Examples of gap.hapax.TemplateName

gap.hapax.TemplateName

Syntax
A name is a string that identifies a section or variable in a template data dictionary. A name is employed in templates within the '{{' and '}}' brackets. It is parsed by instances of this class for special data dictionary referencing and dereferencing features.
Path
A section or variable name parsed into a path - list of components delimited by solidus '/' (slash).
Index
A path component accepts an optional index suffix enclosed in square brackets for names identifying lists -- for index from head or tail. A negative list index is added to list size for index from tail. For these indeces negative one refers to the last element of the list.
Complement
A path is boolean - complemented with a '~' (tilde) prefix to any of its components. The complement operator is intended for the first component, and carries through path interpretation. Therefore the first component complemented is necessarily equivalent to all components (or any component) complemented. Complement is employed exclusively for template sections, for "exists" and "not exists" sections. The "variable", "add", and "show" methods ignore the complementarity (polarity) of the name.
Usage
The user implements path interpretation (demonstrated in {@link gap.hapax.TemplateDataDictionary$Abstract} and {@link gap.util.AbstractData}) using the dereference and reference methods. @see TemplateDataDictionary$Abstract @see AbstractData @author jdp

                    return false;
            case Person:
                if (name.has(1)){
                    Person person = this.getPerson(true);
                    if (null != person)
                        return person.hasVariable(new TemplateName(name));
                    else
                        return false;
                }
                else {
                    /*

View Full Code Here

                    return null;
            case Person:
                if (name.has(1)){
                    Person person = this.getPerson(Notation.MayInherit);
                    if (null != person)
                        return person.getVariable(new TemplateName(name));
                    else
                        return null;
                }
                else
                    return this.getPersonId();

View Full Code Here

                    throw new UnsupportedOperationException(field.name());
                case Person:


                    Person person = this.getPerson(true);
                    if (null != person)
                        person.setVariable(new TemplateName(name),value);


                    return ;
                default:
                    throw new IllegalStateException(field.name());
                }

View Full Code Here

            switch (field){
            case Person:
                Person person = this.getPerson(true);
                if (null != person){
                    if (name.has(1))
                        return person.getSection(new TemplateName(name));
                    else
                        return new gap.util.ShortList( this, person);
                }
                else
                    return null;

View Full Code Here

            TemplateDataDictionary primitive = primitives.addSection(TemplateNames.Type);
            String type_name = type.name();
            primitive.setVariable(TemplateNames.Name,type_name);
            primitive.setVariable(TemplateNames.NameCamel,type_name);
            primitive.setVariable(TemplateNames.NameDecamel,Decamel(type_name));
            primitive.addSection(new TemplateName(type_name));
        }
    }

View Full Code Here

        DefineImports(top,imports,null);
    }
    public final static void DefineImports(TemplateDataDictionary top, lxl.List<ImportDescriptor> imports, TemplateName prefix){


        for (ImportDescriptor imp : imports){
            TemplateDataDictionary imd = top.addSection(new TemplateName(prefix,"import"));
            if (imp.hasPackageSpec())
                imd.setVariable(TemplateNames.ImportSpec,imp.getPackageSpec());
            else if (imp.hasClassName())
                imd.setVariable(TemplateNames.ImportSpec,imp.getClassName());
        }

View Full Code Here

        String className = ClassName(pd);
        String classNameDecamel = Decamel(className);
        /*
         * Class globals
         */
        top.setVariable(new TemplateName(prefix,"package_name"), packageName);
        top.setVariable(new TemplateName(prefix,"class_name"), className);
        top.setVariable(new TemplateName(prefix,"class_nameDecamel"), classNameDecamel);
    }

View Full Code Here

        String className = ClassName(uclass);
        String classNameDecamel = Decamel(className);
        /*
         * Class globals
         */
        top.setVariable(new TemplateName(prefix,"package_name"), packageName);
        top.setVariable(new TemplateName(prefix,"class_name"), className);
        top.setVariable(new TemplateName(prefix,"class_nameDecamel"), classNameDecamel);
    }

View Full Code Here

        String defaultSortBy = null, defaultSortByOpt = null;


        /*
         * Class globals
         */
        top.setVariable(new TemplateName(prefix,"package_name"), packageName);
        top.setVariable(new TemplateName(prefix,"class_name"), className);
        top.setVariable(new TemplateName(prefix,"class_nameDecamel"), classNameDecamel);
        top.setVariable(new TemplateName(prefix,"class_version"),classVersion);
        top.setVariable(new TemplateName(prefix,"class_kind"), classKind);
        top.setVariable(new TemplateName(prefix,"class_path"), classPath);


        ClassDescriptor.Relation.Type classRelation = null;
        String classRelationParent = null;
        ClassDescriptor parent = null;
        if (cd instanceof ClassDescriptor.Relation){
            ClassDescriptor.Relation cdr = (ClassDescriptor.Relation)cd;
            classRelation = cdr.getRelation();
            classRelationParent = cdr.getParent();
        }
        if (null == classRelation || ClassDescriptor.Relation.Type.None.equals(classRelation)){


            top.addSection(new TemplateName(prefix,"class_re_not_parent"));
            top.addSection(new TemplateName(prefix,"class_re_not_child"));


        }
        else if (ClassDescriptor.Relation.Type.Parent.equals(classRelation)){


            top.addSection(new TemplateName(prefix,"class_re_parent"));
            top.addSection(new TemplateName(prefix,"class_re_not_child"));


        }
        else if (ClassDescriptor.Relation.Type.Child.equals(classRelation)){


            top.addSection(new TemplateName(prefix,"class_re_not_parent"));




            TemplateDataDictionary child = top.addSection(new TemplateName(prefix,"class_re_child"));


            if (null == classRelationParent)
                throw new ODStateException(cd,"The object data model requires a parent class name.");
            else {


                top.setVariable(new TemplateName(prefix,"parent_class_name"),classRelationParent);


                parent = Classes.For(classRelationParent);
                if (null == parent)
                    throw new ODStateException(cd,String.format("Parent class '%s' of '%s' not found.",classRelationParent,className));
            }
        }
        else
            throw new IllegalStateException("Unrecognized class relation "+classRelation.name());


        cd.setDefinitionClassName(packageName+'.'+className);


        /*
         * Imports
         */
        DefineImports(top,imports,prefix);


        /*
         * Interfaces
         */
        String[] interfaces = ClassImplements(cd);
        for (String inf : interfaces){
            TemplateDataDictionary ind = top.addSection(new TemplateName(prefix,"implements"));
            ind.setVariable(TemplateNames.InterfaceClass,inf);
        }


        /*
         * Fields
         */
        FieldDescriptor key = null;


        TemplateDataDictionary field_unique = null;


        if (cd.hasFields()){




            for (FieldDescriptor field : cd.getFields()){


                final String fieldName = field.getName();


                if (IsFieldNameIllegal(fieldName))
                    throw new ODStateException(field,String.format("Reserved field name '%s'",fieldName));


                final String fieldNameCamel = Camel(fieldName);
                final String fieldType = OD.MapChild.Type(ToString(field.getType()));
                final String fieldTypeClean = CleanTypeName(fieldType);
                final String fieldTypeCleanClean = CleanCleanTypeName(fieldType);
                final ClassDescriptor fieldTypeClassDescriptor = Classes.For(fieldType);
                final Class fieldTypeClass = FieldClass(packageName,fieldType,imports);
                final boolean isBigTable = IsTypeClassBigTable(fieldTypeClassDescriptor,fieldTypeClass);
                final boolean isBigTableInterface;
                if (isBigTable)
                    isBigTableInterface = IsTypeClassBigTableInterface(fieldTypeClassDescriptor);
                else
                    isBigTableInterface = false;


                final boolean isCollection = IsTypeClassCollection(field,fieldTypeClass);


                final boolean isEnumerated = IsFieldEnumerated(field,fieldTypeClassDescriptor,fieldTypeClass);
                final Primitive fieldTypePrimitive = Primitive.For(fieldTypeClass,isEnumerated,isBigTable,isCollection);
                final String[] fieldTypeParameters = FieldTypeParameters(ToString(field.getType()));


                final gap.data.List.Type listType;
                if (IsTypeClassList(fieldTypeClass))
                    listType = gap.data.List.Type.For(fieldTypeClean);
                else
                    listType = null;


                final OD.MapChild mapChild;
                if (IsTypeClassMap(fieldTypeClass))
                    mapChild = new OD.MapChild(field);
                else
                    mapChild = null;


                final boolean isNumber = (null != fieldTypePrimitive && fieldTypePrimitive.isNumber());


                TemplateDataDictionary dataField = null;
                boolean isPersistent = false;
                boolean isInheritable = true;
                boolean isRelation = false;
                boolean isTransient = false;
                boolean isUnique = false;






                if (IsFieldDefaultSortBy(field))
                    defaultSortBy = fieldName;


                /*
                 * Create dataField section with field kind booleans
                 */
                if (IsFieldPersistent(field,fieldTypeClass)){
                    isPersistent = true;


                    dataField = top.addSection(new TemplateName(prefix,"pfield"));
                    top.addSection(new TemplateName(prefix,"field"), dataField);


                    /*
                     * Populate 'pfield' section
                     */
                    if (IsFieldUnique(field)){
                        if (isCollection)
          throw new ODStateException(field,"Unique field '"+fieldName+"' of collection type.");
                        else {
                            isUnique = true;


                            isInheritable = false;


                            defaultSortByOpt = fieldName;


                            dataField.addSection(TemplateNames.FieldIsUnique);
                            dataField.addSection(TemplateNames.FieldIsNotCollection);
                            dataField.addSection(TemplateNames.FieldIsNotPrimitiveCollection);
                            /*
                             * Global section 'field_unique'
                             */
                            if (null == field_unique){


                                top.addSection(new TemplateName(prefix,"field_unique"), dataField);
                            }
                        }
                    }
                    else {
                        dataField.addSection(TemplateNames.FieldIsNotUnique);


                        if (isCollection){
                            dataField.addSection(TemplateNames.FieldIsCollection);
                            if (null != listType){


                                if (ListPrimitive == listType){
                                    dataField.addSection(TemplateNames.FieldIsPrimitiveCollection);
                                }
                                else {
                                    dataField.addSection(TemplateNames.FieldIsNotPrimitiveCollection);
                                    dataField.addSection(TemplateNames.FieldIsCollectionNotPrimitive);
                                }
                            }
                            else if (null != mapChild){


                                if (MapPrimitive == mapChild.mapType){
                                    dataField.addSection(TemplateNames.FieldIsPrimitiveCollection);
                                }
                                else {
                                    dataField.addSection(TemplateNames.FieldIsNotPrimitiveCollection);
                                    dataField.addSection(TemplateNames.FieldIsCollectionNotPrimitive);
                                }
                            }
                            else
                                throw new ODStateException(field,"Collection field '"+fieldName+"' is neither list nor map.");
                        }
                        else {
                            dataField.addSection(TemplateNames.FieldIsNotCollection);
                            dataField.addSection(TemplateNames.FieldIsNotPrimitiveCollection);
                        }
                    }
                    dataField.addSection(TemplateNames.FieldIsNotTransient);
                    dataField.addSection(TemplateNames.FieldIsNotRelation);
                }
                else if (isCollection){


                    dataField = top.addSection(new TemplateName(prefix,"cfield"));
                    top.addSection(new TemplateName(prefix,"field"), dataField);
                    /*
                     * Populate 'cfield' section
                     */
                    dataField.addSection(TemplateNames.FieldIsCollection);
                    dataField.addSection(TemplateNames.FieldIsNotUnique);
                    dataField.addSection(TemplateNames.FieldIsNotTransient);
                    dataField.addSection(TemplateNames.FieldIsNotRelation);


                    if (null != listType){


                        if (ListPrimitive == listType){
                            dataField.addSection(TemplateNames.FieldIsPrimitiveCollection);
                        }
                        else {
                            dataField.addSection(TemplateNames.FieldIsNotPrimitiveCollection);
                            dataField.addSection(TemplateNames.FieldIsCollectionNotPrimitive);
                        }
                    }
                    else if (null != mapChild){


                        if (MapPrimitive == mapChild.mapType){
                            dataField.addSection(TemplateNames.FieldIsPrimitiveCollection);
                        }
                        else {
                            dataField.addSection(TemplateNames.FieldIsNotPrimitiveCollection);
                            dataField.addSection(TemplateNames.FieldIsCollectionNotPrimitive);
                        }
                    }
                    else
                        throw new ODStateException(field,"Collection field '"+fieldName+"' is neither list nor map.");
                }
                else if (IsFieldRelation(field)){
                    isRelation = true;


                    dataField = top.addSection(new TemplateName(prefix,"rfield"));
                    top.addSection(new TemplateName(prefix,"field"), dataField);
                    /*
                     * Populate 'rfield' section
                     */
                    if ((!IsTypeClassKey(fieldTypeClass)) && null != fieldTypeClass && IsNotTypeClassBigTable(fieldTypeClass))
                        throw new ODStateException(field,"Relation field '"+fieldName+"' is not a subclass of 'gap.data.BigTable'.");
                    else {
                        dataField.addSection(TemplateNames.FieldIsNotCollection);
                        dataField.addSection(TemplateNames.FieldIsNotPrimitiveCollection);
                        dataField.addSection(TemplateNames.FieldIsNotUnique);
                        dataField.addSection(TemplateNames.FieldIsNotTransient);
                        dataField.addSection(TemplateNames.FieldIsNotRelation);
                    }
                }
                else {
                    isTransient = true;


                    dataField = top.addSection(new TemplateName(prefix,"tfield"));
                    top.addSection(new TemplateName(prefix,"field"), dataField);
                    /*
                     * Populate 'tfield' section
                     */
                    dataField.addSection(TemplateNames.FieldIsNotCollection);
                    dataField.addSection(TemplateNames.FieldIsNotPrimitiveCollection);
                    dataField.addSection(TemplateNames.FieldIsNotUnique);
                    dataField.addSection(TemplateNames.FieldIsTransient);
                    dataField.addSection(TemplateNames.FieldIsNotRelation);
                }


                /*
                 * Field common properties
                 */
                dataField.setVariable(TemplateNames.FieldName,fieldName);
                dataField.setVariable(TemplateNames.FieldNameCamel,fieldNameCamel);
                dataField.setVariable(TemplateNames.FieldClass,fieldType);
                dataField.setVariable(TemplateNames.FieldClassClean,fieldTypeClean);
                dataField.setVariable(TemplateNames.FieldClassCleanClean,fieldTypeCleanClean);


                /*
                 * I/O functions ToString, FromString, FromObject
                 * and Is/IsNot selectors
                 */
                if (null != fieldTypePrimitive){


                    dataField.addSection(TemplateNames.FieldIsPrimitive);
                    dataField.addSection(TemplateNames.FieldIsNotBigTable);
                    dataField.addSection(TemplateNames.FieldIsNotBigTableInterface);


                    dataField.addSection(TemplateNames.FieldIsNotMap);
                    dataField.addSection(TemplateNames.FieldIsNotMapPrimitive);
                    dataField.addSection(TemplateNames.FieldIsNotMapLong);
                    dataField.addSection(TemplateNames.FieldIsNotMapLongOrShort);
                    dataField.addSection(TemplateNames.FieldIsNotMapShort);
                    dataField.addSection(TemplateNames.FieldIsNotList);
                    dataField.addSection(TemplateNames.FieldIsNotListPrimitive);
                    dataField.addSection(TemplateNames.FieldIsNotListLongOrShort);
                    dataField.addSection(TemplateNames.FieldIsNotListLong);
                    dataField.addSection(TemplateNames.FieldIsNotListShort);


                    if (isNumber){
                        dataField.addSection(TemplateNames.FieldIsNumber);
                        switch(fieldTypePrimitive){
                        case Short:
                            dataField.setVariable(TemplateNames.FieldNumberValue,"shortValue");
                            break;
                        case Integer:
                            dataField.setVariable(TemplateNames.FieldNumberValue,"intValue");
                            break;
                        case Long:
                            dataField.setVariable(TemplateNames.FieldNumberValue,"longValue");
                            break;
                        case Float:
                            dataField.setVariable(TemplateNames.FieldNumberValue,"floatValue");
                            break;
                        case Double:
                            dataField.setVariable(TemplateNames.FieldNumberValue,"doubleValue");
                            break;
                        default:
                            throw new ODStateException(field,"Number field '"+fieldName+"' type not recognized.");
                        }
                    }
                    else
                        dataField.addSection(TemplateNames.FieldIsNotNumber);


                    switch(fieldTypePrimitive){
                    case Key:
                        isInheritable = false;
                        dataField.setVariable(TemplateNames.FieldToStringPrefix,"gap.Strings.KeyToString(");
                        dataField.setVariable(TemplateNames.FieldToStringSuffix,")");


                        dataField.setVariable(TemplateNames.FieldFromStringPrefix,"gap.Strings.KeyFromString(");
                        dataField.setVariable(TemplateNames.FieldFromStringSuffix,")");


                        dataField.setVariable(TemplateNames.FieldFromObjectPrefix,"gap.Objects.KeyFromObject(");
                        dataField.setVariable(TemplateNames.FieldFromObjectSuffix,")");


                        dataField.addSection(TemplateNames.FieldIsKey);
                        dataField.addSection(TemplateNames.FieldIsNotBoolean);
                        dataField.addSection(TemplateNames.FieldIsNotCharacter);
                        dataField.addSection(TemplateNames.FieldIsNotEnum);
                        dataField.addSection(TemplateNames.FieldIsNotBigInteger);
                        dataField.addSection(TemplateNames.FieldIsNotBigDecimal);
                        dataField.addSection(TemplateNames.FieldIsNotSerializable);
                        break;
                    case Enum:
                        dataField.setVariable(TemplateNames.FieldToStringPrefix,"gap.Strings.EnumToString(");
                        dataField.setVariable(TemplateNames.FieldToStringSuffix,")");


                        dataField.setVariable(TemplateNames.FieldFromStringPrefix,"("+fieldType+")gap.Strings.EnumFromString(");
                        dataField.setVariable(TemplateNames.FieldFromStringSuffix,")");


                        dataField.setVariable(TemplateNames.FieldFromObjectPrefix,"("+fieldType+")gap.Objects.EnumFromObject(");
                        dataField.setVariable(TemplateNames.FieldFromObjectSuffix,")");


                        dataField.addSection(TemplateNames.FieldIsNotKey);
                        dataField.addSection(TemplateNames.FieldIsNotBoolean);
                        dataField.addSection(TemplateNames.FieldIsNotCharacter);
                        dataField.addSection(TemplateNames.FieldIsEnum);
                        dataField.addSection(TemplateNames.FieldIsNotBigInteger);
                        dataField.addSection(TemplateNames.FieldIsNotBigDecimal);
                        dataField.addSection(TemplateNames.FieldIsNotSerializable);
                        break;
                    case Boolean:
                        dataField.setVariable(TemplateNames.FieldToStringPrefix,"gap.Strings.BooleanToString(");
                        dataField.setVariable(TemplateNames.FieldToStringSuffix,")");


                        dataField.setVariable(TemplateNames.FieldFromStringPrefix,"gap.Strings.BooleanFromString(");
                        dataField.setVariable(TemplateNames.FieldFromStringSuffix,")");


                        dataField.setVariable(TemplateNames.FieldFromObjectPrefix,"gap.Objects.BooleanFromObject(");
                        dataField.setVariable(TemplateNames.FieldFromObjectSuffix,")");


                        dataField.addSection(TemplateNames.FieldIsNotKey);
                        dataField.addSection(TemplateNames.FieldIsBoolean);
                        dataField.addSection(TemplateNames.FieldIsNotCharacter);
                        dataField.addSection(TemplateNames.FieldIsNotEnum);
                        dataField.addSection(TemplateNames.FieldIsNotBigInteger);
                        dataField.addSection(TemplateNames.FieldIsNotBigDecimal);
                        dataField.addSection(TemplateNames.FieldIsNotSerializable);
                        break;
                    case Character:
                        dataField.setVariable(TemplateNames.FieldToStringPrefix,"gap.Strings.CharacterToString(");
                        dataField.setVariable(TemplateNames.FieldToStringSuffix,")");


                        dataField.setVariable(TemplateNames.FieldFromStringPrefix,"gap.Strings.CharacterFromString(");
                        dataField.setVariable(TemplateNames.FieldFromStringSuffix,")");


                        dataField.setVariable(TemplateNames.FieldFromObjectPrefix,"gap.Objects.CharacterFromObject(");
                        dataField.setVariable(TemplateNames.FieldFromObjectSuffix,")");


                        dataField.addSection(TemplateNames.FieldIsNotKey);
                        dataField.addSection(TemplateNames.FieldIsNotBoolean);
                        dataField.addSection(TemplateNames.FieldIsCharacter);
                        dataField.addSection(TemplateNames.FieldIsNotEnum);
                        dataField.addSection(TemplateNames.FieldIsNotBigInteger);
                        dataField.addSection(TemplateNames.FieldIsNotBigDecimal);
                        dataField.addSection(TemplateNames.FieldIsNotSerializable);
                        break;
                    case String:
                        dataField.setVariable(TemplateNames.FieldToStringPrefix,"");
                        dataField.setVariable(TemplateNames.FieldToStringSuffix,"");


                        dataField.setVariable(TemplateNames.FieldFromStringPrefix,"");
                        dataField.setVariable(TemplateNames.FieldFromStringSuffix,"");


                        dataField.setVariable(TemplateNames.FieldFromObjectPrefix,"gap.Objects.StringFromObject(");
                        dataField.setVariable(TemplateNames.FieldFromObjectSuffix,")");


                        dataField.addSection(TemplateNames.FieldIsNotKey);
                        dataField.addSection(TemplateNames.FieldIsNotBoolean);
                        dataField.addSection(TemplateNames.FieldIsNotCharacter);
                        dataField.addSection(TemplateNames.FieldIsNotEnum);
                        dataField.addSection(TemplateNames.FieldIsNotBigInteger);
                        dataField.addSection(TemplateNames.FieldIsNotBigDecimal);
                        dataField.addSection(TemplateNames.FieldIsNotSerializable);
                        break;
                    case BigInteger:
                        dataField.setVariable(TemplateNames.FieldToStringPrefix,"gap.Strings.BigIntegerToString(");
                        dataField.setVariable(TemplateNames.FieldToStringSuffix,")");


                        dataField.setVariable(TemplateNames.FieldFromStringPrefix,"gap.Strings.BigIntegerFromString(");
                        dataField.setVariable(TemplateNames.FieldFromStringSuffix,")");


                        dataField.setVariable(TemplateNames.FieldFromObjectPrefix,"gap.Objects.BigIntegerFromObject(");
                        dataField.setVariable(TemplateNames.FieldFromObjectSuffix,")");


                        dataField.addSection(TemplateNames.FieldIsNotKey);
                        dataField.addSection(TemplateNames.FieldIsNotBoolean);
                        dataField.addSection(TemplateNames.FieldIsNotCharacter);
                        dataField.addSection(TemplateNames.FieldIsNotEnum);
                        dataField.addSection(TemplateNames.FieldIsBigInteger);
                        dataField.addSection(TemplateNames.FieldIsNotBigDecimal);
                        dataField.addSection(TemplateNames.FieldIsNotSerializable);
                        break;
                    case BigDecimal:
                        dataField.setVariable(TemplateNames.FieldToStringPrefix,"gap.Strings.BigDecimalToString(");
                        dataField.setVariable(TemplateNames.FieldToStringSuffix,")");


                        dataField.setVariable(TemplateNames.FieldFromStringPrefix,"gap.Strings.BigDecimalFromString(");
                        dataField.setVariable(TemplateNames.FieldFromStringSuffix,")");


                        dataField.setVariable(TemplateNames.FieldFromObjectPrefix,"gap.Objects.BigDecimalFromObject(");
                        dataField.setVariable(TemplateNames.FieldFromObjectSuffix,")");


                        dataField.addSection(TemplateNames.FieldIsNotKey);
                        dataField.addSection(TemplateNames.FieldIsNotBoolean);
                        dataField.addSection(TemplateNames.FieldIsNotCharacter);
                        dataField.addSection(TemplateNames.FieldIsNotEnum);
                        dataField.addSection(TemplateNames.FieldIsNotBigInteger);
                        dataField.addSection(TemplateNames.FieldIsBigDecimal);
                        dataField.addSection(TemplateNames.FieldIsNotSerializable);
                        break;
                    case Serializable:
                        dataField.setVariable(TemplateNames.FieldToStringPrefix,"gap.Strings.SerializableToString(");
                        dataField.setVariable(TemplateNames.FieldToStringSuffix,")");


                        dataField.setVariable(TemplateNames.FieldFromStringPrefix,"("+fieldType+")gap.Strings.SerializableFromString(");
                        dataField.setVariable(TemplateNames.FieldFromStringSuffix,")");


                        dataField.setVariable(TemplateNames.FieldFromObjectPrefix,"("+fieldType+")gap.Objects.SerializableFromObject(");
                        dataField.setVariable(TemplateNames.FieldFromObjectSuffix,")");


                        dataField.addSection(TemplateNames.FieldIsNotKey);
                        dataField.addSection(TemplateNames.FieldIsNotBoolean);
                        dataField.addSection(TemplateNames.FieldIsNotCharacter);
                        dataField.addSection(TemplateNames.FieldIsNotEnum);
                        dataField.addSection(TemplateNames.FieldIsNotBigInteger);
                        dataField.addSection(TemplateNames.FieldIsNotBigDecimal);
                        dataField.addSection(TemplateNames.FieldIsSerializable);
                        break;
                    default:
                        dataField.setVariable(TemplateNames.FieldToStringPrefix,"gap.Strings."+fieldTypeCleanClean+"ToString(");
                        dataField.setVariable(TemplateNames.FieldToStringSuffix,")");


                        dataField.setVariable(TemplateNames.FieldFromStringPrefix,"gap.Strings."+fieldTypeCleanClean+"FromString(");
                        dataField.setVariable(TemplateNames.FieldFromStringSuffix,")");


                        dataField.setVariable(TemplateNames.FieldFromObjectPrefix,"gap.Objects."+fieldTypeCleanClean+"FromObject(");
                        dataField.setVariable(TemplateNames.FieldFromObjectSuffix,")");


                        dataField.addSection(TemplateNames.FieldIsNotKey);
                        dataField.addSection(TemplateNames.FieldIsNotBoolean);
                        dataField.addSection(TemplateNames.FieldIsNotCharacter);
                        dataField.addSection(TemplateNames.FieldIsNotEnum);
                        dataField.addSection(TemplateNames.FieldIsNotBigInteger);
                        dataField.addSection(TemplateNames.FieldIsNotBigDecimal);
                        dataField.addSection(TemplateNames.FieldIsNotSerializable);
                        break;
                    }
                }
                else {


                    if (isBigTable){
                        dataField.setVariable(TemplateNames.FieldToStringPrefix,"gap.Strings.KeyToString(");
                        dataField.setVariable(TemplateNames.FieldToStringSuffix,")");


                        dataField.setVariable(TemplateNames.FieldFromStringPrefix,"gap.Strings.KeyFromString(");
                        dataField.setVariable(TemplateNames.FieldFromStringSuffix,")");


                        dataField.setVariable(TemplateNames.FieldFromObjectPrefix,FullClassName(fieldTypeClassDescriptor,fieldTypeClass)+".FromObject(");
                        dataField.setVariable(TemplateNames.FieldFromObjectSuffix,")");
                        /*
                         */
                        dataField.addSection(TemplateNames.FieldIsBigTable);
                        if (isBigTableInterface)
                            dataField.addSection(TemplateNames.FieldIsBigTableInterface);
                        else
                            dataField.addSection(TemplateNames.FieldIsNotBigTableInterface);


                        if (IsFieldShort(cd,field,fieldTypeClassDescriptor))
                            dataField.addSection(TemplateNames.FieldIsShort);
                        else
                            dataField.addSection(TemplateNames.FieldIsLong);


                        dataField.addSection(TemplateNames.FieldIsNotPrimitive);
                        dataField.addSection(TemplateNames.FieldIsNotKey);
                        dataField.addSection(TemplateNames.FieldIsNotEnum);
                        dataField.addSection(TemplateNames.FieldIsNotBoolean);
                        dataField.addSection(TemplateNames.FieldIsNotNumber);
                        dataField.addSection(TemplateNames.FieldIsNotCharacter);
                        dataField.addSection(TemplateNames.FieldIsNotBigInteger);
                        dataField.addSection(TemplateNames.FieldIsNotBigDecimal);
                        dataField.addSection(TemplateNames.FieldIsNotSerializable);


                        dataField.addSection(TemplateNames.FieldIsNotMap);
                        dataField.addSection(TemplateNames.FieldIsNotMapPrimitive);
                        dataField.addSection(TemplateNames.FieldIsNotMapLong);
                        dataField.addSection(TemplateNames.FieldIsNotMapLongOrShort);
                        dataField.addSection(TemplateNames.FieldIsNotMapShort);
                        dataField.addSection(TemplateNames.FieldIsNotList);
                        dataField.addSection(TemplateNames.FieldIsNotListPrimitive);
                        dataField.addSection(TemplateNames.FieldIsNotListLongOrShort);
                        dataField.addSection(TemplateNames.FieldIsNotListLong);
                        dataField.addSection(TemplateNames.FieldIsNotListShort);
                    }
                    else {
                        dataField.addSection(TemplateNames.FieldIsNotBigTable);
                        dataField.addSection(TemplateNames.FieldIsNotBigTableInterface);
                        /*
                         */
                        if (null != listType){
                            dataField.addSection(TemplateNames.FieldIsNotMap);


                            dataField.setVariable(TemplateNames.FieldFromObjectPrefix,"("+fieldType+')');
                            dataField.setVariable(TemplateNames.FieldFromObjectSuffix,"");


                            dataField.addSection(TemplateNames.FieldIsNotPrimitive);
                            dataField.addSection(TemplateNames.FieldIsNotKey);
                            dataField.addSection(TemplateNames.FieldIsNotEnum);
                            dataField.addSection(TemplateNames.FieldIsNotBoolean);
                            dataField.addSection(TemplateNames.FieldIsNotNumber);
                            dataField.addSection(TemplateNames.FieldIsNotCharacter);
                            dataField.addSection(TemplateNames.FieldIsNotBigInteger);
                            dataField.addSection(TemplateNames.FieldIsNotBigDecimal);
                            dataField.addSection(TemplateNames.FieldIsNotSerializable);


                            dataField.addSection(TemplateNames.FieldIsNotMap);
                            dataField.addSection(TemplateNames.FieldIsNotMapPrimitive);
                            dataField.addSection(TemplateNames.FieldIsNotMapLong);
                            dataField.addSection(TemplateNames.FieldIsNotMapLongOrShort);
                            dataField.addSection(TemplateNames.FieldIsNotMapShort);


                            if (1 == fieldTypeParameters.length){


                                dataField.addSection(TemplateNames.FieldIsList);


                                switch(listType){
                                case ListPrimitive:
                                    dataField.addSection(TemplateNames.FieldIsListPrimitive);
                                    dataField.addSection(TemplateNames.FieldIsNotListLongOrShort);
                                    dataField.addSection(TemplateNames.FieldIsNotListLong);
                                    dataField.addSection(TemplateNames.FieldIsNotListShort);
                                    break;
                                case ListShort:
                                    dataField.addSection(TemplateNames.FieldIsNotListPrimitive);
                                    dataField.addSection(TemplateNames.FieldIsListLongOrShort);
                                    dataField.addSection(TemplateNames.FieldIsNotListLong);
                                    dataField.addSection(TemplateNames.FieldIsListShort);
                                    break;
                                case ListLong:
                                    dataField.addSection(TemplateNames.FieldIsNotListPrimitive);
                                    dataField.addSection(TemplateNames.FieldIsListLongOrShort);
                                    dataField.addSection(TemplateNames.FieldIsListLong);
                                    dataField.addSection(TemplateNames.FieldIsNotListShort);
                                    break;
                                default:
                                    throw new ODStateException(field,"List field '"+fieldName+"' has list type '"+listType+"'.");
                                }


                                String typeParameter = fieldTypeParameters[0];
                                dataField.setVariable(TemplateNames.FieldListComponent,typeParameter);


                                if (IsTypeOf(typeParameter,"HasName"))
                                    dataField.addSection(TemplateNames.FieldListComponentNamed);


                                ClassDescriptor component = Classes.For(typeParameter);
                                if (null != component){
                                    String componentKind = ClassKind(component);
                                    if (null != componentKind)
                                        dataField.setVariable(TemplateNames.FieldListComponentKind,componentKind);


                                    dataField.setVariable(TemplateNames.FieldImplClassName,ListImplClassName(fieldTypeClean,className,component));
                                }
                                else if (ListPrimitive == listType){


                                    Class componentClass = FieldClass(pkg,typeParameter,imports);
                                    if (null != componentClass){
                                        Primitive componentPrimitive = Primitive.For(componentClass);


                                        dataField.setVariable(TemplateNames.FieldImplClassName,ListPrimitiveClassName(componentPrimitive));
                                    }
                                    else
                                        throw new ODStateException(field,"In field '"+fieldType+" "+fieldName+"', require pre-compilation for class analysis of component type '"+typeParameter+"'.");
                                }
                                else
                                    throw new ODStateException(field,"In field '"+fieldType+" "+fieldName+"', expecting List.Primitive for component type '"+typeParameter+"'.");
                            }
                            else
                                throw new ODStateException(field,"Field '"+fieldName+"' type list missing type parameter.");
                        }
                        else if (null != mapChild){


                            dataField.addSection(TemplateNames.FieldIsNotList);


                            dataField.setVariable(TemplateNames.FieldFromObjectPrefix,"("+fieldType+')');
                            dataField.setVariable(TemplateNames.FieldFromObjectSuffix,"");


                            dataField.addSection(TemplateNames.FieldIsNotPrimitive);
                            dataField.addSection(TemplateNames.FieldIsNotKey);
                            dataField.addSection(TemplateNames.FieldIsNotEnum);
                            dataField.addSection(TemplateNames.FieldIsNotBoolean);
                            dataField.addSection(TemplateNames.FieldIsNotNumber);
                            dataField.addSection(TemplateNames.FieldIsNotCharacter);
                            dataField.addSection(TemplateNames.FieldIsNotBigInteger);
                            dataField.addSection(TemplateNames.FieldIsNotBigDecimal);
                            dataField.addSection(TemplateNames.FieldIsNotSerializable);


                            dataField.addSection(TemplateNames.FieldIsNotList);
                            dataField.addSection(TemplateNames.FieldIsNotListPrimitive);
                            dataField.addSection(TemplateNames.FieldIsNotListLongOrShort);
                            dataField.addSection(TemplateNames.FieldIsNotListLong);
                            dataField.addSection(TemplateNames.FieldIsNotListShort);


                            if (2 == fieldTypeParameters.length){


                                dataField.addSection(TemplateNames.FieldIsMap);


                                switch(mapChild.mapType){
                                case MapPrimitive:
                                    dataField.addSection(TemplateNames.FieldIsMapPrimitive);
                                    dataField.addSection(TemplateNames.FieldIsNotMapLongOrShort);
                                    dataField.addSection(TemplateNames.FieldIsNotMapLong);
                                    dataField.addSection(TemplateNames.FieldIsNotMapShort);
                                    break;
                                case MapShort:


                                    dataField.addSection(TemplateNames.FieldIsNotMapPrimitive);
                                    dataField.addSection(TemplateNames.FieldIsMapLongOrShort);
                                    dataField.addSection(TemplateNames.FieldIsNotMapLong);
                                    dataField.addSection(TemplateNames.FieldIsMapShort);
                                    break;
                                case MapLong:
                                    dataField.addSection(TemplateNames.FieldIsNotMapPrimitive);
                                    dataField.addSection(TemplateNames.FieldIsMapLongOrShort);
                                    dataField.addSection(TemplateNames.FieldIsMapLong);
                                    dataField.addSection(TemplateNames.FieldIsNotMapShort);
                                    break;
                                }




                                String typeComponentFrom = mapChild.childKeyFieldType;
                                String typeComponentFromName = mapChild.childKeyFieldName;
                                String typeComponentTo = mapChild.childValueClassName;
                                dataField.setVariable(TemplateNames.FieldMapComponentFrom,typeComponentFrom);
                                dataField.setVariable(TemplateNames.FieldMapComponentFromName,typeComponentFromName);
                                dataField.setVariable(TemplateNames.FieldMapComponentFromNameCamel,Camel(typeComponentFromName));
                                dataField.setVariable(TemplateNames.FieldMapComponentTo,typeComponentTo);
                                dataField.setVariable(TemplateNames.FieldMapComponent,typeComponentTo);


                                if (IsTypeOf(typeComponentTo,"HasName"))
                                    dataField.addSection(TemplateNames.FieldMapComponentNamed);


                                ClassDescriptor componentTo = Classes.For(typeComponentTo);
                                if (null != componentTo){
                                    String componentToKind = ClassKind(componentTo);
                                    if (null != componentToKind)
                                        dataField.setVariable(TemplateNames.FieldMapComponentKind,componentToKind);
                                }


                                dataField.setVariable(TemplateNames.FieldImplClassName,MapClassName(fieldTypeClean,className,typeComponentFrom,typeComponentTo));
                            }
                            else
                                throw new ODStateException(field,"Field '"+fieldName+"' type map missing type parameter.");
                        }
                        else {
                            throw new ODStateException(field,"Invalid table or collection type of field '"+fieldType+" "+fieldName+"'.");
                        }
                    }
                }


                /*
                 * Field inheritance
                 */
                if (isPersistent && isInheritable)
                    dataField.addSection(TemplateNames.FieldIsInheritable);
                else
                    dataField.addSection(TemplateNames.FieldIsNotInheritable);
            }
        }


        if (null == field_unique)
            top.showSection(new TemplateName(prefix,"not_field_unique"));




        if (null != defaultSortBy)
            top.setVariable(new TemplateName(prefix,"class_defaultSortBy"), defaultSortBy);
        else if (null != defaultSortByOpt)
            top.setVariable(new TemplateName(prefix,"class_defaultSortBy"), defaultSortByOpt);
        else
            throw new ODStateException(cd,"The object data model requires a default sort by.");


        /*
         * Methods
         */
        if (cd.hasMethods()){


            for (MethodDescriptor method: cd.getMethods()){


                String method_name = method.getName();
                if (null != method_name){
                    String method_body = gap.Strings.TextToString(method.getBody());
                    if (null != method_body){


                        TemplateDataDictionary methodData = top.addSection(new TemplateName(prefix,"method"));
                        methodData.setVariable(TemplateNames.MethodName,method_name);
                        methodData.setVariable(TemplateNames.MethodBody,method_body);


                        TemplateDataDictionary mb = top.addSection(new TemplateName(prefix,"method_"+method_name+"_with_body"));
                        mb.setVariable(TemplateNames.MethodBody,method_body);


                        String method_type = ToString(method.getType());
                        if (null != method_type){
                            TemplateDataDictionary ma = top.addSection(new TemplateName(prefix,"method_"+method_name+"_with_type"));
                            ma.setVariable(TemplateNames.Type,method_type);
                            methodData.setVariable(TemplateNames.MethodType,method_type);
                        }
                        else
                            top.showSection(new TemplateName(prefix,"method_"+method_name+"_without_type"));


                        if (method instanceof MethodDescriptor.Arguments){
                            MethodDescriptor.Arguments ma = (MethodDescriptor.Arguments)method;
                            if (ma.hasArguments()){
                                String method_arguments = ma.getArguments();
                                if (null != method_arguments){
                                    top.addSection(new TemplateName(prefix,"method_"+method_name+"_with_args"));


                                    methodData.setVariable(TemplateNames.MethodArguments,method_arguments);
                                }
                                else
                                    top.showSection(new TemplateName(prefix,"method_"+method_name+"_without_args"));
                            }
                            else
                                top.showSection(new TemplateName(prefix,"method_"+method_name+"_without_args"));
                        }
                        else
                            top.showSection(new TemplateName(prefix,"method_"+method_name+"_without_args"));


                        if (method instanceof MethodDescriptor.Exceptions){
                            MethodDescriptor.Exceptions ma = (MethodDescriptor.Exceptions)method;
                            if (ma.hasExceptions()){
                                String method_exceptions = ma.getExceptions();
                                if (null != method_exceptions){
                                    TemplateDataDictionary td = top.addSection(new TemplateName(prefix,"method_"+method_name+"_with_excs"));
                                    td.setVariable(TemplateNames.MethodExceptions,method_exceptions);
                                    methodData.setVariable(new TemplateName(prefix,"method_exceptions"),method_exceptions);
                                }
                                else
                                    top.showSection(new TemplateName(prefix,"method_"+method_name+"_without_excs"));
                            }
                            else
                                top.showSection(new TemplateName(prefix,"method_"+method_name+"_without_excs"));
                        }
                        else
                            top.showSection(new TemplateName(prefix,"method_"+method_name+"_without_excs"));
                    }
                    else {
                        top.showSection(new TemplateName(prefix,"method_"+method_name+"_without_body"));
                    }
                }
            }
        }
    }

View Full Code Here

TOP

Related Classes of gap.hapax.TemplateName

gap.service.OD

tt.BData

java.util.StringTokenizer

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.

Examples of gap.hapax.TemplateName

Syntax

Path

Index

Complement

Usage

Related Classes of gap.hapax.TemplateName