root/branches/Carsten_PtrWork2/Tools/fcdProcess/fcdProcess.pl

#!/usr/bin/perl -w

use strict;

my $gfc;
my $gfcdXml = '';
my $currElem;

my $filePrefix    = "OSG";
my $decFileSuffix = ".h";
my $inlFileSuffix = ".inl";
my $impFileSuffix = ".cpp";

my $baseTmplCpp = "FCBaseTemplate_cpp.h";
my $baseTmplH   = "FCBaseTemplate_h.h";
my $baseTmplInl = "FCBaseTemplate_inl.h";

my $fieldImpH  = "FCFieldsTemplate_h.h";

my $fcTmplCpp   = "FCTemplate_cpp.h";
my $fcTmplH     = "FCTemplate_h.h";
my $fcTmplInl   = "FCTemplate_inl.h";

my $enableCompat = 0;

sub start_element 
{
  my ($self,$localname) = @_;

  if($localname eq "FieldContainer")
  {
#      print "Create FieldContainer $self\n";

      $gfc = new OSGFieldContainer;

      while(@_)
      {
          my $key = shift;
          my $val = shift;

          $gfc->{$key} = $val;
      }

      my @fArray = ();
      my $fArrayRef = \@fArray;

      $gfc->{fields} = $fArrayRef;

      $currElem = $gfc;
  }

  if($localname eq "Field")
  {
#      printf "Create Field\n";

      my $field = new OSGField;

      while(@_)
      {
          my $key = shift;
          my $val = shift;

          $field->{$key} = $val;
      }
      
      my $fArrayRef = $gfc->{fields};

      push @$fArrayRef, $field;

      $currElem = $field;
  }
}

sub end_element 
{
}

sub characters 
{
    my $self = shift;

    my $a1 = shift;

    if($a1 ne "\n" && $a1 ne "\t")
    {
        $currElem->{description} .= "$a1\n";
#        print "Foo -$a1-\n";
    }
}

package OSGFieldContainer;
use strict;

sub new
{
    my $class = shift;
    my $self  = {};

    $self->{name}                  = "<UNDEF>";
    $self->{parent}                = "<UNDEF>";
    $self->{library}               = "<UNDEF>";
    $self->{pointerfieldtypes}     = "none";
    $self->{structure}             = "<UNDEF>";
    $self->{systemcomponent}       = "true";
    $self->{parentsystemcomponent} = "true";
    $self->{decoratable}           = "false";
    $self->{useLocalIncludes}      = "false";
    $self->{isNodeCore}            = "false";
    $self->{description}           = "";
    $self->{group}                 = "NULL";
    $self->{namespace}             = 0;
    $self->{decorateeFieldFlags}   = "";
    $self->{CompatOneSix}          = "false";

    bless $self, $class
}

sub isSystemComponent
{
    my $self = shift;

    return $self->{systemcomponent};
}

sub isDecoratable
{
    my $self = shift;

    return $self->{isDecoratable};
}

sub hasFields
{
    my $self = shift;

    return $self->{hasFields};
}

sub addFieldIdsAndMasksDecl
{
    my $self    = shift;
    my $destRef = shift;
    my $tmpLine;

    my $fArrayRef   = $self->{fields};
    my @aArrayField = @{$self->{fields}};

    if($self->{hasFields} eq "false")
    {
        return;
    }

    push(@$destRef, "    enum\n");
    push(@$destRef, "    {\n");

    $tmpLine  = "        ";
    $tmpLine .= $aArrayField[0]->{Fieldname};
    $tmpLine .= "FieldId = Inherited::NextFieldId,\n";

    push(@$destRef, $tmpLine);
    

    for(my $i = 1; $i <= $#aArrayField; $i++)
    {
        $tmpLine  = "        ";
        $tmpLine .= $aArrayField[$i]->{Fieldname};
        $tmpLine .= "FieldId = ";
        $tmpLine .= $aArrayField[$i - 1]->{Fieldname};
        $tmpLine .= "FieldId + 1,\n";

        push(@$destRef, $tmpLine);
    }
        

    $tmpLine  = "        ";
    $tmpLine .= "NextFieldId = ";
    $tmpLine .= $aArrayField[$#aArrayField]->{Fieldname};
    $tmpLine .= "FieldId + 1\n";

    push(@$destRef, $tmpLine);

    push(@$destRef, "    };\n\n");

    for(my $i = 0; $i <= $#aArrayField; $i++)
    {
        $tmpLine  = "    static const OSG::BitVector ";
        $tmpLine .= $aArrayField[$i]->{Fieldname};
        $tmpLine .= "FieldMask = \n";

        push(@$destRef, $tmpLine);

        $tmpLine   = "        (TypeTraits<BitVector>::One << ";
        $tmpLine  .= $aArrayField[$i]->{Fieldname};
        $tmpLine  .= "FieldId);\n";

        push(@$destRef, $tmpLine);
    }

    $tmpLine  = "    static const OSG::BitVector NextFieldMask = \n";

    push(@$destRef, $tmpLine);

    $tmpLine   = "        (TypeTraits<BitVector>::One << NextFieldId);\n";
    
    push(@$destRef, $tmpLine);

}

sub addAdditionaIncludes
{
    my $self    = shift;
    my $destRef = shift;
    my $tmpLine;

    if(exists $self->{'additionalIncludes'})
    {
        my @addIncludes = split(/,/,$self->{'additionalIncludes'});
        
        
        for my $addInclude (@addIncludes)
        {
            push(@$destRef, "#include <$addInclude>");
        }
    }
}

sub setupDecorator
{
    my $self = shift;

    $self->{Classname} = $self->{name}."Decorator";
    $self->{CLASSNAME} = uc($self->{name})."DECORATOR";
    $self->{Parent}    = $self->{name};
}

sub setupFieldContainer
{
    my $self = shift;

    $self->{Classname} = $self->{name};
    $self->{CLASSNAME} = uc($self->{name});
    $self->{Parent}    = $self->{parent};
}

sub finalize
{
    my $self = shift;

    my $fArrayRef   = $self->{fields};
    my @aArrayField = @{$self->{fields}};

#    print "Finalize $fArrayRef $#$fArrayRef \n";

    if($#$fArrayRef != -1)
    {
        ${self}->{hasFields} = "true";
    }
    else
    {
        ${self}->{hasFields} = "false";
    }

    if(exists ${self}->{library})
    {
        ${self}->{Library} = "true";
        ${self}->{Libname} =    ${self}->{library};
        ${self}->{LIBNAME} = uc(${self}->{library});
    }
    else
    {
        ${self}->{Library} = "false";
        ${self}->{Libname} = "<UNDEF>";
        ${self}->{LIBNAME} = "<UNDEF>";
    }

    $self->{CLASSNAME}     = uc($self->{name});
    $self->{Classname}     = $self->{name};
    $self->{isDecoratable} = $self->{decoratable};
    $self->{Parent}        = $self->{parent};

    if($self->{structure} eq "concrete")
    {
        $self->{Abstract} = "false";
    }
    else
    {
        $self->{Abstract} = "true";
    }

    if($self->{parentsystemcomponent} eq "true" &&
       $self->{systemcomponent}       eq "false" )
    {
        $self->{ParentHeaderPrefix} = "OpenSG/";
    }
    else
    {
        $self->{ParentHeaderPrefix} = "";
    }

    if($self->{systemcomponent} eq "false")
    {
        $self->{HeaderPrefix} = "OpenSG/";
    }
    else
    {
        $self->{HeaderPrefix} = "";
    }

    $self->{hasPrivateFields}   = "false";
    $self->{hasProtectedFields} = "false";
    $self->{hasPublicFields}    = "false";
    $self->{hasPtrFields}       = "false";

    my @sfArray = ();
    my @mfArray = ();

#    $self->{fields} = $fArrayRef;

    for my $field (@$fArrayRef)
    {
        $field->finalize($self);

        if($field->isPrivate() eq "true")
        {
            $self->{hasPrivateFields} = "true";            
        }

        if($field->isProtected() eq "true")
        {
            $self->{hasProtectedFields} = "true";            
        }

        if($field->isPublic() eq "true")
        {
            $self->{hasPublicFields} = "true";            
        }

        if($field->isSField() eq "true")
        {
            push(@sfArray, $field);
        }

        if($field->isMField() eq "true")
        {
            push(@mfArray, $field);
        }

        if($field->isPtrField() eq "true")
        {
            $self->{hasPtrFields} = "true";
        }
    }

    if($#$fArrayRef != -1)
    {
        $$fArrayRef[$#$fArrayRef]->{FieldSeparator} = "";
    }

    my $sfArrayRef = \@sfArray;
    my $mfArrayRef = \@mfArray;

    $self->{SFields} = $sfArrayRef;
    $self->{MFields} = $mfArrayRef;

    $self->{abstract} = "false";

    if($self->{structure} eq "concrete")
    {
        $self->{abstract} = "false";
    }

    if($self->{structure} eq "abstract")
    {
        $self->{abstract} = "true";
    }

    $self->{Pointerfield}   = "false";
    $self->{SFPointerfield} = "false";
    $self->{MFPointerfield} = "false";

    if($self->{pointerfieldtypes} eq "both")
    {
        $self->{Pointerfield}   = "true";
        $self->{SFPointerfield} = "true";
        $self->{MFPointerfield} = "true";
    }

    if($self->{pointerfieldtypes} eq "single")
    {
        $self->{Pointerfield}   = "true";
        $self->{SFPointerfield} = "true";
    }

    if($self->{pointerfieldtypes} eq "multi")
    {
        $self->{Pointerfield}   = "true";
        $self->{MFPointerfield} = "true";
    }

    $self->{Description} = $self->{description};
    my $safe_desc = $self->{description};
    $safe_desc =~ s/"/\\\\\\"/g;
    $safe_desc =~ s/\n/\\\\n/g;
    $self->{SafeDescription} = $safe_desc;

    $self->{SystemComponent} = $self->{systemcomponent};

    $self->{FieldMethodType} = "";

    if($self->isDecoratable() eq "true")
    {
        $self->{FieldMethodType} = "virtual";
    }

    $self->{Group}     = $self->{group};
    $self->{Namespace} = $self->{namespace};

    if($self->{decorateeFieldFlags} eq "")
    {
        $self->{decorateeFieldFlags} = "Field::SFDefaultFlags";
    }
    else
    {
        my @flags = split(/[,]/, $self->{decorateeFieldFlags});

        $self->{decorateeFieldFlags} = "(";

        for(my $i = 0; $i <= $#flags; ++$i)
        {
            my $flag = $flags[$i];

            $flag =~ s/ //g;
            $flag =~ s/\t//g;
            $flag =~ s/\n//g;

            if($i == 0 && $i != $#flags)
            {
                $self->{decorateeFieldFlags} .= "Field::".$flag." |";
                
                next;
            }

            if($i == $#flags)
            {
                if($i == 0)
                {
                    $self->{decorateeFieldFlags} .= "Field::".$flag;
                }
                else
                {
                    $self->{decorateeFieldFlags} .= " Field::".$flag;
                }

                next;
            }

            $self->{decorateeFieldFlags} .= " Field::".$flag." |";
        }
    
        $self->{fdecorateeFieldFlags} .= ")";
    }

    if($enableCompat == 1)
    {
        $self->{CompatOneSix} = "true";
    }
    else
    {
        $self->{CompatOneSix} = "false";
    }
}

sub dumpValues
{
    my $self = shift;

    print "FieldContainer\n";
    print "\tname                   : $self->{name}\n";
    print "\tparent                 : $self->{parent}\n";
    print "\tlibrary                : $self->{library}\n";
    print "\tpointerfieldtypes      : $self->{pointerfieldtypes}\n";
    print "\tstructure              : $self->{structure}\n";
    print "\tsystemcomponent        : $self->{systemcomponent}\n";
    print "\tparentsystemcomponent  : $self->{parentsystemcomponent}\n";
    print "\tdecoratable            : $self->{decoratable}\n";
    print "\tuseLocalIncludes       : $self->{useLocalIncludes}\n";
    print "\tgroup                  : $self->{group}\n";
    print "\tnamespace              : $self->{namespace}\n";
    
    print "\tDerived                : \n";
    print "\t  hasFields              : $self->{hasFields}\n";
    print "\t  Library                : $self->{Library}\n";
    print "\t  CLASSNAME              : $self->{CLASSNAME}\n";
    print "\t  Classname              : $self->{Classname}\n";
    print "\t  Parent                 : $self->{Parent}\n";
    print "\t  Libname                : $self->{Libname}\n";
    print "\t  LIBNAME                : $self->{LIBNAME}\n";
    print "\t  isDecoratable          : $self->{isDecoratable}\n";
    print "\t  Abstract               : $self->{Abstract}\n";
    print "\t  HeaderPrefix           : $self->{HeaderPrefix}\n";
    print "\t  ParentHeaderPrefix     : $self->{ParentHeaderPrefix}\n";
    print "\t  hasPrivateFields       : $self->{hasPrivateFields}\n";
    print "\t  hasProtectedFields     : $self->{hasProtectedFields}\n";
    print "\t  hasPublicFields        : $self->{hasPublicFields}\n";
    print "\t  hasPtrFields           : $self->{hasPtrFields}\n";
    print "\t  Pointerfield           : $self->{Pointerfield}\n";
    print "\t  SFPointerfield         : $self->{SFPointerfield}\n";
    print "\t  MFPointerfield         : $self->{MFPointerfield}\n";
    print "\t  Description            : $self->{Description}\n";
    print "\t  SystemComponent        : $self->{SystemComponent}\n";
    print "\t  FieldMethodType        : $self->{FieldMethodType}\n";
    print "\t  Group                  : $self->{Group}\n";
    print "\t  Namespace              : $self->{Namespace}\n";

    my $fArrayRef = $self->{fields};

    for my $field (@$fArrayRef)
    {
        $field->dumpValues();
    }

}


package OSGField;
use strict;

%OSGField::isPerFieldIf = ();

$OSGField::isPerFieldIf{'FieldNamespace'}              = "true";
$OSGField::isPerFieldIf{'isPrivate'}                   = "true";
$OSGField::isPerFieldIf{'isProtected'}                 = "true";
$OSGField::isPerFieldIf{'isPublic'}                    = "true";
$OSGField::isPerFieldIf{'hasDefaultHeader'}            = "true";
$OSGField::isPerFieldIf{'isMField'}                    = "true";
$OSGField::isPerFieldIf{'isSField'}                    = "true";
$OSGField::isPerFieldIf{'isPtrField'}                  = "true";
$OSGField::isPerFieldIf{'checkNilPtr'}                 = "true";
$OSGField::isPerFieldIf{'linkSParent'}                 = "true";
$OSGField::isPerFieldIf{'linkMParent'}                 = "true";
$OSGField::isPerFieldIf{'doRefCount'}                  = "true";
$OSGField::isPerFieldIf{'passFieldMask'}               = "true";
$OSGField::isPerFieldIf{'removeToSet'}                 = "true";
$OSGField::isPerFieldIf{'clearMField'}                 = "true";
$OSGField::isPerFieldIf{'writePushToField'}            = "true";
$OSGField::isPerFieldIf{'writeInsertIntoMField'}       = "true";
$OSGField::isPerFieldIf{'writeReplaceInMFieldIndex'}   = "true";
$OSGField::isPerFieldIf{'writeReplaceInMFieldObject'}  = "true";
$OSGField::isPerFieldIf{'writeRemoveFromMFieldIndex'}  = "true";
$OSGField::isPerFieldIf{'writeRemoveFromMFieldObject'} = "true";
$OSGField::isPerFieldIf{'writeClearField'}             = "true";
$OSGField::isPerFieldIf{'needClassInclude'}            = "true";

sub new
{
    my $class = shift;
    my $self  = {};

    $self->{name}                     = "<UNDEF>";
    $self->{type}                     = "<UNDEF>";
    $self->{cardinality}              = "<UNDEF>";
    $self->{FieldNamespace}           = "";
    $self->{visibility}               = "external";
    $self->{fieldFlags}               = "";
#mtinf
    $self->{defaultValue}             = "";
    $self->{access}                       = "public";
    $self->{defaultHeader}            = "";
    $self->{header}                   = "auto";
    $self->{description}              = "";

    $self->{checkNilPtr}              = "true";
    $self->{linkSParent}              = "false";
    $self->{linkMParent}              = "false";
    $self->{doRefCount}               = "true";
    $self->{passFieldMask}            = "false";

    $self->{removeTo}                 = "";
    $self->{removeToSet}              = "false";   
    $self->{clearMField}              = "true";

    $self->{pushToField}              = "";
    $self->{insertIntoMField}         = "";
    $self->{replaceInMFieldIndex}     = "";
    $self->{replaceInMFieldObject}    = "";
    $self->{removeFromMFieldIndex}    = "";
    $self->{removeFromMFieldObject}   = "";
    $self->{clearField}               = "";

    $self->{pushToFieldAs}            = "";
    $self->{insertIntoMFieldAs}       = "";
    $self->{replaceInMFieldIndexAs}   = "";
    $self->{replaceInMFieldObjectAs}  = "";
    $self->{removeFromMFieldIndexAs}  = "";
    $self->{removeFromMFieldObjectAs} = "";
    $self->{clearFieldAs}             = "";

    $self->{needClassInclude}         = "true";

    bless $self, $class
}

sub isPrivate
{
    my $self = shift;

    return $self->{isPrivate};
}

sub isProtected
{
    my $self = shift;

    return $self->{isProtected};
}

sub isPublic
{
    my $self = shift;

    return $self->{isPublic};
}

sub isSField
{
    my $self = shift;

    return $self->{isSField};
}

sub isMField
{
    my $self = shift;

    return $self->{isMField};
}

sub isPtrField
{
    my $self = shift;

    return $self->{isPtrField};
}

sub dumpValues
{
    my $self = shift;

    print "\n\tField\n";
    print "\t\tname                     : $self->{name}\n";
    print "\t\ttype                     : $self->{type}\n";
    print "\t\tcardinality              : $self->{cardinality}\n";
    print "\t\tvisibility               : $self->{visibility}\n";
    print "\t\tdefaultValue             : $self->{defaultValue}\n";
    print "\t\taccess                   : $self->{access}\n";
    print "\t\tdefaultHeader            : $self->{defaultHeader}\n";
    print "\t\theader                   : $self->{header}\n";
    print "\t\tcheckNilPtr              : $self->{checkNilPtr}\n";
    print "\t\tlinkSParent              : $self->{linkSParent}\n";
    print "\t\tlinkMParent              : $self->{linkMParent}\n";
    print "\t\tdoRefCount               : $self->{doRefCount}\n";
    print "\t\tpassFieldMask            : $self->{passFieldMask}\n";
    print "\t\tremoveTo                 : $self->{removeTo}\n";
    print "\t\tremoveToSet              : $self->{removeToSet}\n";
    print "\t\tclearMField              : $self->{clearMField}\n";
    print "\t\tpushToField              : $self->{pushToField}\n";
    print "\t\tinsertIntoMField         : $self->{insertIntoMField}\n";
    print "\t\treplaceInMFieldIndex     : $self->{replaceInMFieldIndex}\n";
    print "\t\treplaceInMFieldObject    : $self->{replaceInMFieldObject}\n";
    print "\t\tremoveFromMFieldIndex    : $self->{removeFromMFieldIndex}\n";
    print "\t\tremoveFromMFieldObject   : $self->{removeFromMFieldObject}\n";
    print "\t\tclearField               : $self->{clearField}\n";
    print "\t\tpushToFieldAs            : $self->{pushToFieldAs}\n";
    print "\t\tinsertIntoMFieldAs       : $self->{insertIntoMFieldAs}\n";
    print "\t\treplaceInMFieldIndexAs   : $self->{replaceInMFieldIndexAs}\n";
    print "\t\treplaceInMFieldObjectAs  : $self->{replaceInMFieldObjectAs}\n";
    print "\t\tremoveFromMFieldIndexAs  : $self->{removeFromMFieldIndexAs}\n";
    print "\t\tremoveFromMFieldObjectAs : $self->{removeFromMFieldObjectAs}\n";
    print "\t\tclearFieldAs             : $self->{clearFieldAs}\n";

    print "\n\t\tDerived :\n";
    print "\t\t\tFieldname                   : $self->{Fieldname}\n";
    print "\t\t\tFieldtype                   : $self->{Fieldtype}\n";
    print "\t\t\tFieldtypeCapsClean          : $self->{FieldtypeCapsClean}\n";
    print "\t\t\tCapsFieldtypeClean          : $self->{CapsFieldtypeClean}\n";
    print "\t\t\tisPrivate                   : $self->{isPrivate}\n";
    print "\t\t\tisProtected                 : $self->{isProtected}\n";
    print "\t\t\tisPublic                    : $self->{isPublic}\n";
    print "\t\t\tCARDINALITY                 : $self->{CARDINALITY}\n";
    print "\t\t\tFieldMethodType             : $self->{FieldMethodType}\n";
    print "\t\t\tfieldname                   : $self->{fieldname}\n";
    print "\t\t\tFieldSeparator              : $self->{FieldSeparator}\n";
    print "\t\t\thasDefaultHeader            : $self->{hasDefaultHeader}\n";
    print "\t\t\tfieldnameDesc               : $self->{fieldnameDesc}\n";
    print "\t\t\tfieldvisibility             : $self->{fieldvisibility}\n";
    print "\t\t\tFielddescription            : $self->{Fielddescription}\n";
    print "\t\t\tisSField                    : $self->{isSField}\n";
    print "\t\t\tisMField                    : $self->{isMField}\n";
    print "\t\t\tisPtrField                  : $self->{isPtrField}\n";
    print "\t\t\tpushToField                 : $self->{pushToField}\n";
    print "\t\t\twriteInsertIntoMField       : $self->{insertIntoMField}\n";
    print "\t\t\twriteReplaceInMFieldIndex   : $self->{replaceInMFieldIndex}\n";
    print "\t\t\twritePeplaceInMFieldObject  : $self->{replaceInMFieldObject}\n";
    print "\t\t\twriteRemoveFromMFieldIndex  : $self->{removeFromMFieldIndex}\n";
    print "\t\t\twriteRemoveFromMFieldObject : $self->{removeFromMFieldObject}\n";
    print "\t\t\twriteClearField             : $self->{clearField}\n";
}

sub finalize
{
    my $self = shift;
    my $fc   = shift;

    my $cleanType;

    $cleanType = $self->{type};
    
    $cleanType =~ s/^std:://;
    
    $self->{Fieldname}          = ucfirst($self->{name});
    $self->{Fieldtype}          = $self->{type};
    $self->{FieldtypeCapsClean} = ucfirst($cleanType);
    $self->{CapsFieldtypeClean} = ucfirst($cleanType);

    $self->{isPrivate}   = "false";
    $self->{isProtected} = "false";
    $self->{isPublic}    = "false";

    if($self->{access} eq "private")
    {
        $self->{isPrivate} = "true";
    }
    elsif($self->{access} eq "protected")
    {
        $self->{isProtected} = "true";
    }
    elsif($self->{access} eq "public")
    {
        $self->{isPublic} = "true";
    }

    $self->{isMField} = "false";
    $self->{isSField} = "false";

    if($self->{cardinality} eq "single")
    {
        $self->{isSField} = "true";
    }

    if($self->{cardinality} eq "multi")
    {
        $self->{isMField} = "true";
    }

    if($self->{header} eq "" || $self->{header} eq "auto")
    {
        if($fc->isSystemComponent() eq "true")
        {
            $self->{FieldtypeInclude} = "OSG"
        }
        else
        {
            $self->{FieldtypeInclude} = "OpenSG/OSG"
        }

        $self->{FieldtypeInclude} .= $self->{FieldtypeCapsClean};
        $self->{FieldtypeInclude} =~ s/Ptr$//;
        $self->{FieldtypeInclude} =~ s/GLP:://;
        $self->{FieldtypeInclude} .= "Fields.h";
    }
    else
    {
        $self->{FieldtypeInclude}   = $self->{header};
    }

    $self->{fieldname}   = "";

    if($self->isSField() eq "true")
    {
        $self->{CARDINALITY} = "SF";
        $self->{fieldname}   = "sf";
    }

    if($self->isMField() eq "true")
    {
        $self->{CARDINALITY} = "MF";
        $self->{fieldname}   = "mf";
    }

    if($self->{CapsFieldtypeClean} =~ m/([A-Za-z_]*)::/)
    {
        $self->{FieldNamespace} = "$1::";
        $self->{CapsFieldtypeClean} =~ s/$1:://;
    }

    $self->{fieldname} .= $self->{Fieldname};

    $self->{FieldMethodType} = "";

    if($fc->isDecoratable() eq "true")
    {
        $self->{FieldMethodType} = "virtual";
    }

    $self->{FieldSeparator} = ",";

    if(exists $self->{defaultHeader} && $self->{defaultHeader} ne "")
    {
        $self->{hasDefaultHeader} = "true";

        if(! ($self->{defaultHeader} =~ m/\"|</))  #"
        {
            $self->{defaultHeader} = '"'.$self->{defaultHeader}.'"';
        }        
    }
    else
    {
        $self->{hasDefaultHeader} = "false";
    }

    if(exists $self->{defaultValue} && $self->{defaultValue} ne "")
    {
        $self->{FieldTypedDefault}  = $self->{type};

        $self->{FieldTypedDefault} .= "(";

        if($self->{type} =~ m/std::string/)
        {
            $self->{FieldTypedDefault} .= "\"";
        }

        $self->{FieldTypedDefault} .= $self->{defaultValue};

        if($self->{type} =~ m/std::string/)
        {
            $self->{FieldTypedDefault} .= "\"";
        }

        $self->{FieldTypedDefault} .= ")";
    }
    else
    {
        $self->{FieldTypedDefault} = "";
    }

    $self->{fieldnameDesc}   = $self->{name};

    if($self->{visibility} eq "external")
    {
        $self->{fieldvisibility} = "false";
    }

    if($self->{visibility} eq "internal")
    {
        $self->{fieldvisibility} = "true";
    }