Examples of org.dmd.dms.generated.dmo.TypeDefinitionDMO

org.dmd.dms.generated.dmo.TypeDefinitionDMO
The TypeDefinition is used to define the types of attributes that can be used\n as the basis for attribute values. The name of the type definition should be the same as the\n actual Java class that is used to store the value of an attribute e.g. the name of the type\n used to store strings is String. The typeClassName is the fully qualified name of the class\n derived from DmcAttribute that stores this type of value; they are always, by convention,\n named DmcTypeXXX.\n
\n TypeDefinitions are automatically generated internally for ClassDefinitions, \n ComplexTypeDefinitions, ExtendedReferenceTypeDefinitions and\n EnumDefinitions so that these objects can be referred to via the type attribute of AttributeDefinitions.\n These definitions are marked as internallyGenerated .\n
\n The simplest TypeDefinition would look something like:\n
```
\n TypeDefinition\n name           String\n typeClassName  org.dmd.dmc.types.DmcTypeString\n description    Provides support for String values.\n 
```
\n This form would be used for attribute types whose base type originates in java.lang.\n The dark-matter base types include: Boolean, Byte, Double, Float, Integer, Long, Short and String.\n
\n TypeDefinitions also support the concept of specifying a nullReturnValue \n for the entire type i.e. whenever an attribute of the specified type is accessed, it will return\n that value when the attribute doesn't exist in the object. An example of this is the Boolean type:\n
```
\n TypeDefinition\n name   Boolean\n typeClassName   org.dmd.dmc.types.DmcTypeBoolean\n nullReturnValue false\n description     Provides support for Boolean values. This type makes use of the\n                 nullReturnValue flag so that, even if there is no\n                 value for an attribute of this type, a value of false will\n                 be returned.\n 
```
\n
\n The next most common form of TypeDefinition adds the primitiveType \n attribute. This is required for code generation so that we can import the appropriate type for\n use in the various getter/setter methods. An example would be the Date type.\n
```
\n TypeDefinition\n name           Date\n typeClassName  org.dmd.dmc.types.DmcTypeDate\n primitiveType  java.util.Date\n description    Provides support for Date values.\n 
```
\n Another common form of TypeDefinition is the definition of a name type. Object\n naming is a fundamental aspect of DMOs, with all object names being based on the DmcObjectName.\n Flagging a type as being a name type also implies the definition of a designated naming attribute\n associated with the type. This mechanism allows for the transport of names that are self\n describing in terms of their implementation type. This feature supports the NameContainer\n type that allows any name to be transported in things like dark-matter protocol GetRequest.\n An example of a naming type would be:\n
```
\n TypeDefinition\n name           CamelCaseName\n typeClassName  org.dmd.dmc.types.DmcTypeCamelCaseName\n primitiveType  org.dmd.dmc.types.CamelCaseName\n isNameType     true\n description    The CamelCaseName is a string based name that must start with\n                an alpha character which is followed by a mix of alphanumerics.\n 
```
\n And its associated designated naming attribute would be:\n
```
\n AttributeDefinition\n name                     camelCaseName\n dmdID       116\n type                     CamelCaseName\n designatedNameAttribute  true\n description              The camelCaseName attribute is used to store a single camelCase\n                          format name for something. The name starts with a single letter\n          and can be followed by a mix of letters and numbers. No spaces or \n                          other characters are allowed.\n 
```
\n The last form of type definition is one that includes some additional information to provide\n a convenient, alternate interface for the generation of member functions associated with\n a container type; this concept is pretty much limited to the meta-schema, so it is unlikely\n that non-contributors to dark-matter will make use of this concept. However, here is an example:\n
```
\n TypeDefinition\n name      NameContainer\n typeClassName  org.dmd.dmc.types.DmcTypeNameContainer\n primitiveType  org.dmd.dmc.types.NameContainer\n altType        DmcObjectName\n altTypeImport  org.dmd.dmc.DmcObjectName\n description    The NameContainer type allows for the storage of object names of different types...\n 
```
@author Auto GeneratedGenerated from: org.dmd.dms.meta.MetaGenerator.dumpDMOClasses(MetaGenerator.java:1847)

        // Determine if we have any reference fields
        boolean hasRefs = false;
        ArrayList<String> refFields = new ArrayList<String>();
        while(fields.hasNext()){
          Field field = fields.next();
          TypeDefinitionDMO type = field.getType().getObject();
          
          if (type == null){
            DebugInfo.debug("Unknown type in ExtendedReferenceTypeDefinition: " + field.getType().getObjectName());
            System.exit(1);
          }


          if (type.getIsRefType()){
            hasRefs = true;
            refFields.add(field.getName());
          }
        }
        
        out.write(header);
        
        out.write("package " + ertd.getDefinedIn().getSchemaPackage() + ".generated.types;\n\n");
        
        String nameBaseImport = ertd.getExtendedReferenceClass().getIsNamedBy().getType().getDefinedIn().getSchemaPackage() + ".generated.types.DmcType";
        String nameImport = ertd.getExtendedReferenceClass().getIsNamedBy().getType().getName().getNameString() + "SV";
        String staticNameType = ertd.getExtendedReferenceClass().getIsNamedBy().getType().getName().getNameString() + "STATIC";


        imports.addImport(nameBaseImport + nameImport, "Name type");
        imports.addImport(ertd.getExtendedReferenceClass().getIsNamedBy().getType().getPrimitiveType(), "Name type");
        
        imports.addImport(nameBaseImport + staticNameType, "Static type for name");
        
        imports.addImport(ertd.getExtendedReferenceClass().getDmoImport(), "Object based constructor");


        imports.addImport("org.dmd.dmc.DmcExtendedReferenceIF", "Marker interface for extended references");


//        out.write("import java.io.Serializable;\n");
//        out.write("import org.dmd.dmc.DmcInputStreamIF;\n");
//        out.write("import org.dmd.dmc.DmcOutputStreamIF;\n");
//        out.write("import org.dmd.dmc.types.IntegerVar;\n");
        
        imports.addImport("java.io.Serializable", "Serialization support");
        imports.addImport("org.dmd.dmc.DmcInputStreamIF", "Serialization support");
        imports.addImport("org.dmd.dmc.DmcOutputStreamIF", "Serialization support");
        imports.addImport("org.dmd.dmc.types.IntegerVar", "Parsing support");
        
        if (hasRefs){
//            out.write("import org.dmd.dmc.DmcNameResolverIF;\n");
//            out.write("import org.dmd.dmc.DmcNamedObjectIF;\n");
//            out.write("import org.dmd.dmc.DmcNamedObjectREF;\n");
//            out.write("import org.dmd.dmc.DmcContainerIF;\n");
            
            imports.addImport("org.dmd.dmc.DmcNameResolverIF", "Object reference support");
            imports.addImport("org.dmd.dmc.DmcNamedObjectIF", "Object reference support");
            imports.addImport("org.dmd.dmc.DmcNamedObjectREF", "Object reference support");
            imports.addImport("org.dmd.dmc.DmcContainerIF", "Object reference support");
        }


//        out.write("import org.dmd.dmc.DmcValueException;\n\n");
        
        imports.addImport("org.dmd.dmc.DmcValueException", "Value exceptions");
        
//        out.write(getComplexTypeImports(ertd));
        
        getComplexTypeImports(ertd, imports);
        
        out.write(imports.getFormattedImports() + "\n\n");
        
        out.write("@SuppressWarnings(\"serial\")\n");


        out.write("/**\n * The " + ctn + " class.\n");
        out.write(" * This code was auto-generated and shouldn't be alterred manually.\n");
        out.write(" * \n");
        out.write(" * Generated from: " + DebugInfo.getWhereWeAreNow() + "\n");
        out.write(" */\n");


        out.write("public class " + ctn + " extends " + ertd.getExtendedReferenceClass().getName() + "REF implements Serializable, DmcExtendedReferenceIF {\n\n");
        
        out.write(getComplexTypeFieldInstances(ertd));
          
        out.write("    /**\n");
        out.write("     * Default constructor.\n");
        out.write("     */\n");
        out.write("    public " + ctn + "(){\n");
      out.write("    }\n\n");
                  
      ///////////////////////////////////////////////////////////////////////
      // Copy constructor
      
        out.write("    /**\n");
        out.write("     * Copy constructor.\n");
        out.write("     * Generated from: " + DebugInfo.getWhereWeAreNow() + "\n");
        out.write("     */\n");
        out.write("    public " + ctn + "(" + ctn + " original){\n");
        out.write("        myName = original.myName;\n");
        out.write("        object = original.object;\n");
        fields = ertd.getField();
        while(fields.hasNext()){
          Field field = fields.next();
          out.write("        _" + field.getName() + " = original._" + field.getName() + ";\n");
        }
      out.write("    }\n\n");
        
      ///////////////////////////////////////////////////////////////////////
      // All fields constructor with name
      
      String nametype = ertd.getExtendedReferenceClass().getIsNamedBy().getType().getName().getNameString();
      String attrName = ertd.getExtendedReferenceClass().getIsNamedBy().getName().getNameString();
      
        out.write("    /**\n");
        out.write("     * All fields constructor.\n");
        out.write("     * Generated from: " + DebugInfo.getWhereWeAreNow() + "\n");
        out.write("     */\n");
        out.write("    public " + ctn + "(" + nametype + " name, ");
        int fnum = 1;
        fields = ertd.getField();
        while(fields.hasNext()){
          Field field = fields.next();
//          out.write(field.getType().getObjectName() + " f" + fnum);
          out.write(field.getType().getObjectName() + " " + field.getName());


          fnum++;
          if (fnum <= ertd.getFieldSize())
            out.write(", ");
        }
        
//        out.write(") throws DmcValueException {\n");
        out.write(") {\n");
        out.write("        setName(name);\n");
        fnum = 1;
        fields = ertd.getField();
        while(fields.hasNext()){
          Field field = fields.next();
          TypeDefinition  type = (TypeDefinition) field.getType().getObject().getContainer();
          
          if (type.getIsRefType()){
//            out.write("        _" + field.getName() + " = DmcType" + field.getType().getObjectName() + "REFSTATIC.instance.typeCheck(f" + fnum + ");\n");
            out.write("        _" + field.getName() + " = " + field.getName() + ";\n");
          }
          else{
//            out.write("        _" + field.getName() + " = DmcType" + field.getType().getObjectName() + "STATIC.instance.typeCheck(f" + fnum + ");\n");
            out.write("        _" + field.getName() + " = " + field.getName() + ";\n");
          }
          fnum++;
        }
      out.write("    }\n\n");
      
      ///////////////////////////////////////////////////////////////////////
      // All fields constructor with object
      
        out.write("    /**\n");
        out.write("     * All fields constructor.\n");
        out.write("     * Generated from: " + DebugInfo.getWhereWeAreNow() + "\n");
        out.write("     */\n");
        out.write("    public " + ctn + "(" + ertd.getExtendedReferenceClass().getName().getNameString() + "DMO obj, ");
        fnum = 1;
        fields = ertd.getField();
        while(fields.hasNext()){
          Field field = fields.next();
//          out.write(field.getType().getObjectName() + " f" + fnum);
          out.write(field.getType().getObjectName() + " " + field.getName());


          fnum++;
          if (fnum <= ertd.getFieldSize())
            out.write(", ");
        }
        
//        out.write(") throws DmcValueException {\n");
        out.write(") {\n");
        out.write("        super(obj);\n");
        fnum = 1;
        fields = ertd.getField();
        while(fields.hasNext()){
          Field field = fields.next();
          TypeDefinition  type = (TypeDefinition) field.getType().getObject().getContainer();
          
          if (type.getIsRefType()){
//            out.write("        _" + field.getName() + " = DmcType" + field.getType().getObjectName() + "REFSTATIC.instance.typeCheck(f" + fnum + ");\n");
            out.write("        _" + field.getName() + " = " + field.getName() + ";\n");
          }
          else{
//            out.write("        _" + field.getName() + " = DmcType" + field.getType().getObjectName() + "STATIC.instance.typeCheck(f" + fnum + ");\n");
            out.write("        _" + field.getName() + " = " + field.getName() + ";\n");
          }
          fnum++;
        }
      out.write("    }\n\n");
      
      ///////////////////////////////////////////////////////////////////////
      // String based constructor
      
        out.write("    /**\n");
        out.write("     * String based constructor.\n");
        out.write("     * Generated from: " + DebugInfo.getWhereWeAreNow() + "\n");
        out.write("     */\n");
        out.write("    public " + ctn + "(String input) throws DmcValueException {\n");
        out.write("        IntegerVar seppos = new IntegerVar(-1);\n");
        
        out.write("        " + nametype + " n = DmcType" + nametype + "STATIC.instance.typeCheck(getNextField(input,seppos,\"object name\",false));\n");
        out.write("        myName = new DmcType" + nametype + "SV(__" + attrName + ");\n");
        out.write("        myName.set(n);\n\n");
        
//        StringName n = DmcTypeStringNameSTATIC.instance.typeCheck(getNextField(input,seppos,"object name",false));
//        myName = new DmcTypeStringNameSV(__name);
//        myName.set(n);


        fnum = 1;
        fields = ertd.getField();
        while(fields.hasNext()){
          Field field = fields.next();
          TypeDefinition  type = (TypeDefinition) field.getType().getObject().getContainer();
          String REF = "";
          if (type.getIsRefType())
            REF = "REF";
          
          if (fnum == ertd.getFieldSize())
              out.write("        _" + field.getName() + " = DmcType" + field.getType().getObjectName() + REF + "STATIC.instance.typeCheck(getNextField(input,seppos,\"" + field.getName() + "\",true));\n");
            else
            out.write("        _" + field.getName() + " = DmcType" + field.getType().getObjectName() + REF + "STATIC.instance.typeCheck(getNextField(input,seppos,\"" + field.getName() + "\",false));\n");
            
          fnum++;
        }
      out.write("    }\n\n");
      
      ///////////////////////////////////////////////////////////////////////
      // Serialization
      
        out.write("    /**\n");
        out.write("     * Serialization.\n");
        out.write("     * Generated from: " + DebugInfo.getWhereWeAreNow() + "\n");
        out.write("     */\n");
        out.write("    public void serializeIt(DmcOutputStreamIF dos) throws Exception {\n");
        out.write("        DmcType" + nametype + "STATIC.instance.serializeValue(dos, myName.getSV());\n");
        fields = ertd.getField();
        while(fields.hasNext()){
          Field field = fields.next();
          TypeDefinition  type = (TypeDefinition) field.getType().getObject().getContainer();
          
          if (type.getIsRefType())
              out.write("        DmcType" + field.getType().getObjectName() + "REFSTATIC.instance.serializeValue(dos, _" + field.getName() + ");\n");
          else
            out.write("        DmcType" + field.getType().getObjectName() + "STATIC.instance.serializeValue(dos, _" + field.getName() + ");\n");
        }
      out.write("    }\n\n");
      
        out.write("    /**\n");
        out.write("     * Deserialization.\n");
        out.write("     * Generated from: " + DebugInfo.getWhereWeAreNow() + "\n");
        out.write("     */\n");
        out.write("    public void deserializeIt(DmcInputStreamIF dis) throws Exception {\n");
        out.write("        " + nametype + " n = DmcType" + nametype + "STATIC.instance.deserializeValue(dis);\n");
        out.write("        myName = new DmcType" + nametype + "SV(__" + attrName + ");\n");
        out.write("        myName.set(n);\n\n");
        
        fields = ertd.getField();
        while(fields.hasNext()){
          Field field = fields.next();
          TypeDefinition  type = (TypeDefinition) field.getType().getObject().getContainer();
          
          if (type.getIsRefType())
              out.write("        _" + field.getName() + " = DmcType" + field.getType().getObjectName() + "REFSTATIC.instance.deserializeValue(dis);\n");
          else
            out.write("        _" + field.getName() + " = DmcType" + field.getType().getObjectName() + "STATIC.instance.deserializeValue(dis);\n");
        }
      out.write("    }\n\n");
      
      ///////////////////////////////////////////////////////////////////////
      // String form
      
        out.write("    /**\n");
        out.write("     * String form.\n");
        out.write("     */\n");
        out.write("    public String toString(){\n");
        fnum = 1;
        out.write("        return(");
        out.write("myName.getSV().getNameString()");
        if (ertd.getFieldSize() > 0)
          out.write(" + \"" + fieldSeparator + "\" + ");


        fields = ertd.getField();
        while(fields.hasNext()){
          Field field = fields.next();
          out.write("_" + field.getName() + ".toString()");
          if (fnum < ertd.getFieldSize())
            out.write(" + \"" + fieldSeparator + "\" + ");
          fnum++;
        }
        out.write(");\n");
      out.write("    }\n\n");
      
      ///////////////////////////////////////////////////////////////////////
      // Getter/setters
      
        out.write("    public void setName(" + nametype + " name){\n");
        out.write("        try{\n");
        out.write("            super.setName(name);\n");
      out.write("            object = null;\n");
      out.write("        } catch (DmcValueException e) {\n");
      out.write("            throw new IllegalStateException(\"Setting name with a specific type shouldn't throw an exception.\",e);\n");
      out.write("        }\n\n");
      out.write("    }\n\n");
   
        out.write("    public void setObject(" + ertd.getExtendedReferenceClass().getName().getNameString() + "DMO obj){\n");
      out.write("        super.setObject(obj);\n");
      out.write("    }\n\n");
   
      
        fields = ertd.getField();
        while(fields.hasNext()){
          Field field = fields.next();
          TypeDefinition  type = (TypeDefinition) field.getType().getObject().getContainer();
          
          if (type.getIsRefType())
                out.write("    public " + field.getType().getObjectName() + "REF get" + GenUtility.capTheName(field.getName()) + "(){\n");
          else
            out.write("    public " + field.getType().getObjectName() + " get" + GenUtility.capTheName(field.getName()) + "(){\n");
          
          out.write("        return(_" + field.getName() + ");\n");
          out.write("    }\n\n");
          
          if (type.getIsRefType())
                out.write("    public void set" + GenUtility.capTheName(field.getName()) + "(" + field.getType().getObjectName() + " " + field.getName() + "){\n");
          else
            out.write("    public void set" + GenUtility.capTheName(field.getName()) + "(" + field.getType().getObjectName() + " " + field.getName() + "){\n");
          
          out.write("        _" + field.getName() + " = " + field.getName() + ";\n");

View Full Code Here

        // Determine if we have any reference fields
        boolean hasRefs = false;
        ArrayList<String> refFields = new ArrayList<String>();
        while(fields.hasNext()){
          Field field = fields.next();
          TypeDefinitionDMO type = field.getType().getObject();
          
          if (type == null){
            DebugInfo.debug("Unknown type in ComplexTypeDefinition: " + field.getType().getObjectName());
            System.exit(1);
          }


          if (type.getIsRefType()){
            hasRefs = true;
            refFields.add(field.getName());
          }
        }
        
        if (header != null)
          out.write(header);
        
        out.write("package " + ctd.getDefinedIn().getSchemaPackage() + ".generated.types;\n\n");


    ImportManager imports = new ImportManager();


    imports.addImport("java.io.Serializable", "To prevent serialization warnings");
    imports.addImport("org.dmd.dmc.DmcInputStreamIF", "Standard serialization techniques");
    imports.addImport("org.dmd.dmc.DmcOutputStreamIF", "Standard serialization techniques");
    imports.addImport("org.dmd.dmc.types.IntegerVar", "To support getNextField()");
//    out.write("import java.io.Serializable;\n");
//        out.write("import org.dmd.dmc.DmcInputStreamIF;\n");
//        out.write("import org.dmd.dmc.DmcOutputStreamIF;\n");
//        out.write("import org.dmd.dmc.types.IntegerVar;\n");
        
        if (hasRefs){
        imports.addImport("org.dmd.dmc.DmcNameResolverIF", "To support object references");
        imports.addImport("org.dmd.dmc.DmcNamedObjectIF", "To support object references");
        imports.addImport("org.dmd.dmc.DmcNamedObjectREF", "To support object references");
        imports.addImport("org.dmd.dmc.DmcContainerIF", "To support object references");


//        out.write("import org.dmd.dmc.DmcNameResolverIF;\n");
//            out.write("import org.dmd.dmc.DmcNamedObjectIF;\n");
//            out.write("import org.dmd.dmc.DmcNamedObjectREF;\n");
//            out.write("import org.dmd.dmc.DmcContainerIF;\n");
        }


//        out.write("import org.dmd.dmc.DmcAttribute;\n");
//        out.write("import org.dmd.dmc.DmcAttributeInfo;\n");
        
    imports.addImport("org.dmd.dmc.DmcValueException", "Standard value exception");


//        out.write("import org.dmd.dmc.DmcValueException;\n\n");
        
    getComplexTypeImports(ctd, imports);
//        out.write(getComplexTypeImports(ctd));
    
    out.write(imports.getFormattedImports());
        
        out.write("@SuppressWarnings(\"serial\")\n");


        out.write("/**\n * The " + ctn + " class.\n");
        out.write(" * This code was auto-generated and shouldn't be alterred manually.\n");
        out.write(" * \n");
        out.write(" * Generated from: " + DebugInfo.getWhereWeAreNow() + "\n");
        out.write(" */\n");


        out.write("public class " + ctn + " implements Serializable {\n\n");
        
        out.write(getComplexTypeFieldInstances(ctd));
          
        out.write("    /**\n");
        out.write("     * Default constructor.\n");
        out.write("     */\n");
        out.write("    public " + ctn + "(){\n");
      out.write("    }\n\n");
                          
        out.write("    /**\n");
        out.write("     * Copy constructor.\n");
        out.write("     */\n");
        out.write("    public " + ctn + "(" + ctn + " original){\n");
        fields = ctd.getField();
        while(fields.hasNext()){
          Field field = fields.next();
          out.write("        " + field.getName() + " = original." + field.getName() + ";\n");
        }
      out.write("    }\n\n");
        
      
        out.write("    /**\n");
        out.write("     * All fields constructor.\n");
        out.write("     * Generated from: " + DebugInfo.getWhereWeAreNow() + "\n");
        out.write("     */\n");
        out.write("    public " + ctn + "(");
        int fnum = 1;
        fields = ctd.getField();
        while(fields.hasNext()){
          Field field = fields.next();
          TypeDefinition  type = (TypeDefinition) field.getType().getObject().getContainer();


          if (type.getIsRefType()){
            out.write(field.getType().getObjectName() + "REF f" + fnum);
          }
          else{
            out.write(field.getType().getObjectName() + " f" + fnum);
          }


          fnum++;
          if (fnum <= ctd.getFieldSize())
            out.write(", ");
        }
        
        out.write(") throws DmcValueException {\n");
        fnum = 1;
        fields = ctd.getField();
        while(fields.hasNext()){
          Field field = fields.next();
          TypeDefinition  type = (TypeDefinition) field.getType().getObject().getContainer();
          
          if (type.getIsRefType()){
            out.write("        " + field.getName() + " = DmcType" + field.getType().getObjectName() + "REFSTATIC.instance.typeCheck(f" + fnum + ");\n");
          }
          else{
            out.write("        " + field.getName() + " = DmcType" + field.getType().getObjectName() + "STATIC.instance.typeCheck(f" + fnum + ");\n");
          }
          fnum++;
        }
      out.write("    }\n\n");
      
        out.write("    /**\n");
        out.write("     * String based constructor.\n");
        out.write("     * Generated from: " + DebugInfo.getWhereWeAreNow() + "\n");
        out.write("     */\n");
        out.write("    public " + ctn + "(String initialInput) throws DmcValueException {\n");
        out.write("        IntegerVar seppos = new IntegerVar(-1);\n");
    if (whiteSpaceSeparator){
      out.write("        String input = initialInput.trim();\n");
      out.write("        input = input.replaceAll(\"(\\\\s)+\", \" \");\n");
    }
    else{
      out.write("        String input = initialInput.trim();\n");
    }
        fnum = 1;
        fields = ctd.getField();
        while(fields.hasNext()){
          Field field = fields.next();
          TypeDefinition  type = (TypeDefinition) field.getType().getObject().getContainer();
          String REF = "";
          if (type.getIsRefType())
            REF = "REF";
          
          if (fnum == ctd.getFieldSize())
              out.write("        " + field.getName() + " = DmcType" + field.getType().getObjectName() + REF + "STATIC.instance.typeCheck(getNextField(input,seppos,\"" + field.getName() + "\",true));\n");
            else
            out.write("        " + field.getName() + " = DmcType" + field.getType().getObjectName() + REF + "STATIC.instance.typeCheck(getNextField(input,seppos,\"" + field.getName() + "\",false));\n");
            
          fnum++;
        }
      out.write("    }\n\n");
      
      
        out.write("    /**\n");
        out.write("     * Serialization.\n");
        out.write("     * Generated from: " + DebugInfo.getWhereWeAreNow() + "\n");
        out.write("     */\n");
        out.write("    public void serializeIt(DmcOutputStreamIF dos) throws Exception {\n");
        fields = ctd.getField();
        while(fields.hasNext()){
          Field field = fields.next();
          TypeDefinition  type = (TypeDefinition) field.getType().getObject().getContainer();
          
          if (type.getIsRefType())
              out.write("        DmcType" + field.getType().getObjectName() + "REFSTATIC.instance.serializeValue(dos, " + field.getName() + ");\n");
          else
            out.write("        DmcType" + field.getType().getObjectName() + "STATIC.instance.serializeValue(dos, " + field.getName() + ");\n");
        }
      out.write("    }\n\n");
      
        out.write("    /**\n");
        out.write("     * Deserialization.\n");
        out.write("     * Generated from: " + DebugInfo.getWhereWeAreNow() + "\n");
        out.write("     */\n");
        out.write("    public void deserializeIt(DmcInputStreamIF dis) throws Exception {\n");
        fields = ctd.getField();
        while(fields.hasNext()){
          Field field = fields.next();
          TypeDefinition  type = (TypeDefinition) field.getType().getObject().getContainer();
          
          if (type.getIsRefType())
              out.write("        " + field.getName() + " = DmcType" + field.getType().getObjectName() + "REFSTATIC.instance.deserializeValue(dis);\n");
          else
            out.write("        " + field.getName() + " = DmcType" + field.getType().getObjectName() + "STATIC.instance.deserializeValue(dis);\n");
        }
      out.write("    }\n\n");
      
        out.write("    /**\n");
        out.write("     * String form.\n");
        out.write("     */\n");
        out.write("    public String toString(){\n");
        fnum = 1;
        out.write("        return(");
        fields = ctd.getField();
        while(fields.hasNext()){
          Field field = fields.next();
          out.write(field.getName() + ".toString()");
          if (fnum < ctd.getFieldSize())
            out.write(" + \"" + fieldSeparator + "\" + ");
          fnum++;
        }
        out.write(");\n");
      out.write("    }\n\n");
      
        fields = ctd.getField();
        while(fields.hasNext()){
          Field field = fields.next();
          TypeDefinition  type = (TypeDefinition) field.getType().getObject().getContainer();
          
          if (type.getIsRefType())
                out.write("    public " + field.getType().getObjectName() + "REF get" + GenUtility.capTheName(field.getName()) + "(){\n");
          else
            out.write("    public " + field.getType().getObjectName() + " get" + GenUtility.capTheName(field.getName()) + "(){\n");
          
          out.write("        return(" + field.getName() + ");\n");

View Full Code Here


    /**
     * Default constructor.
     */
    public TypeDefinition(){
      super(new TypeDefinitionDMO(),MetaSchemaAG._TypeDefinition);
    }

View Full Code Here

TOP

Related Classes of org.dmd.dms.generated.dmo.TypeDefinitionDMO

org.dmd.dms.TypeDefinition

org.dmd.dms.util.ComplexTypeFormatter

org.dmd.dms.util.ExtendedReferenceTypeFormatter

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.