proc IsMultiLanguage(MAttribute as ATTRIBUTE)
    loop (ATTRIBUTE -> TaggedValue where toLower([TaggedValue.tag]) == "languageindex")
        if ([TaggedValue.value] != "")
            return _True();
        end if
    end loop
    return _False();
end proc

proc IsTrimmed(MAttribute as ATTRIBUTE)
    loop (ATTRIBUTE -> TaggedValue where toLower([TaggedValue.tag]) == "trim")
        if (toLower([TaggedValue.value]) == "true")
            return _True();
        end if
    end loop
    return _False();
end proc

proc GetLanguageIndex(MAttribute as ATTRIBUTE)
    loop (ATTRIBUTE -> TaggedValue where toLower([TaggedValue.tag]) == "languageindex")
        return [TaggedValue.value];
    end loop
    return "Hiba: nincs languageindex";
end proc


proc GetModelVersion()
    loop (Instances -> MClass as VERSIONCLASS -> TaggedValue as VERSION where [VERSIONCLASS.name] == ToUpper([ProjectName]) "_VERSION" and ToLower([VERSION.tag]) == "version")
        return [VERSION.value];
    end loop
    return "0";
end proc


proc IsClassView(MClass as ELEMENT)
    local result;
    local package;
    [result] = getStereotype([ELEMENT]);
    [package] = GetPackage([ELEMENT]);

    if ([result] == "View")
        if (IsPackageAllowed([package]) == "True")
            return "View";
        else
            return "";
        end if
    end if
    return [result];
end proc

//***************************************************************************//
// Visszaadja egy entitásról, hogy melyik sémába kerüljön.                   //
//                                                                           //
// DBO értékkel, ha nem a projekt package-ben van benne.   //
//***************************************************************************//
proc GetSchemaName(MClass as ELEMENT)
    local result;
    local package;
    [result] = "DBO";
    [package] = GetPackage([ELEMENT]);

    if([ProjectName] != [package])
		[result] = [package];
	end if

    return [result];
end proc


//***************************************************************************//
// Visszaadja egy entitásról, hogy védett kódtétel-e.                        //
//                                                                           //
// True, ha védett kódtétel; egyébként False.                                //
//***************************************************************************//
proc IsProtectedDictionaryItem(MClass as ENTITY)
//    if (IsEntityDictionaryItem([ENTITY]) == "True")
        loop (ENTITY -> TaggedValue where toLower([TaggedValue.tag]) == "saveddi")
            if (toLower([TaggedValue.value]) == "true")
                return "True";
            end if
        end loop
//    end if
    return "False";
end proc


//***************************************************************************//
// Visszaadja egy asszociációról, hogy engedélyezett-e rá a kaszkád törlés,  //
// vagy sem.                                                                 //
//                                                                           //
// True, ha engedélyezett; egyébként False.                                  //
//***************************************************************************//
proc IsCascadeDelete(MAssociation as ASSOCIATION)
    loop (ASSOCIATION -> TaggedValue where toLower([TaggedValue.tag]) == "cascadedelete")
        if (toLower([TaggedValue.value]) == "true")
            return "True";
        end if
    end loop
    return "False";
end proc


//***************************************************************************//
// Visszaadja egy modellelem adott nevű taggedvalue-jának értékét. Ha nincs  //
// definiálva, akkor üres karakterláncot ad vissza.                          //
//***************************************************************************//
proc GetTaggedValue(MSemElement as ELEMENT, NAME)
    loop (ELEMENT -> TaggedValue as TAGGEDVALUE where toLower([TAGGEDVALUE.tag]) == toLower([NAME]))
        return [TAGGEDVALUE.value];
    end loop
    
    return "";
end proc


//***************************************************************************//
// Visszaadja, hogy a jelenlegi generálási kontextusban egy adott UML csomag //
// engedélyezett-e, vagy sem.                                                //
//                                                                           //
// True, ha engedélyezett, egyébként False.                                  //
//***************************************************************************//
proc IsPackageAllowed(PACKAGE)
    switch ([PACKAGE])
        case "":              
			switch ([ProjectName])
				case "Kreta": return "True";
				case "stage": return "True";
				default: return "False";
			end switch
        case [ProjectName]:                 return "True";
        case "stage":                       return "True";
    end switch
    
    return "False";
end proc


//***************************************************************************//
// Visszaadja egy asszociációs szerepkör nevét, ha az definiált; ha nem      //
// definiált, akkot nevet generál neki a partnerosztály nevéből.             //
//***************************************************************************//
proc GetRoleName(MAssociationEnd as ROLE)
    return DefineRoleName([ROLE]);
end proc


//***************************************************************************//
// Visszaadja egy osztály sztereotípiáját.                                   //
//***************************************************************************//
proc GetStereoType(MClass as ELEMENT)
    local result;
    local package;
    [result] = getStereotype([ELEMENT]);
    [package] = GetPackage([ELEMENT]);

    if ([result] == "Entity" or [result] == "Entity2")
        if (IsPackageAllowed([package]) == "True")
            return "Entity";
        else
            return "";
        end if
    end if
    return [result];
end proc


//***************************************************************************//
// Visszaadja egy attribútum sztereotípiáját.                                //
//***************************************************************************//
proc GetStereoTypeForAttribute(MAttribute as ATTRIBUTE)
    local temp;
    [temp] = getStereotype([ATTRIBUTE]);
    return [temp];
end proc


//***************************************************************************//
// Visszaadja egy művelet sztereotípiáját.                                   //
//***************************************************************************//
proc GetStereoTypeForOperation(MOperation as OPERATION)
    local temp;
    [temp] = getStereotype([OPERATION]);
    return [temp];
end proc


//***************************************************************************//
// Visszaadja egy entitás nevét.                                             //
//***************************************************************************//
proc GetEntityName(MClass as ENTITY)
    return [ENTITY.name];
end proc


//***************************************************************************//
// Visszaadja egy attribútum nevét.                                          //
//***************************************************************************//
proc GetAttributeName(MAttribute as ATTRIBUTE)
    return [ATTRIBUTE.name];
end proc


//***************************************************************************//
// Megmondja, hogy egy osztály entitásnak tekintendő-e, vagy sem.            //
// Az, hogy entitás-e, az attól is függ, hogy melyik UML csomagot dolgozzuk  //
// fel, és az osztály melyik UML csomagban található.                        //
//***************************************************************************//
proc IsEntity(MClass as ENTITY)
    if (GetStereoType([ENTITY]) == "Entity")
        return "True";
    else
        return "False";
    end if
end proc


//***************************************************************************//
// Visszaadja, hogy egy osztály melyik UML csomagban található.              //
//***************************************************************************//
proc GetPackage(MClass as ELEMENT)
    loop (ELEMENT -> MPackage) 
        return [MPackage.name];
    end loop
    return "";
end proc


//***************************************************************************//
// Visszaadja, hogy egy attribútum rendelkezik-e UML-ben előírt              //
// alapértelmezett értékkel, vagy sem.                                       //
//                                                                           //
// True, ha rendelkezik; egyébként False.                                    //
//***************************************************************************//
proc HasDefaultValue(MAttribute)
    if ([MAttribute.type] == "DictionaryItem")
      loop (MAttribute -> TaggedValue where toLower([TaggedValue.tag]) == "dictdefault")
          return "true";
      end loop
      return "false";
    end if
    
    local result = [MAttribute.defaultValue];
    
    if ([result] == "")
        return "False";
    else
        return "True";
    end if
end proc


//***************************************************************************//
// Visszaadja, hogy egy osztály kódtételnek tekintendő-e vagy sem. Ez attól  //
// függ, hogy leszármazottja-e a DictionaryItemBase osztálynak.              //
//                                                                           //
// True, ha kódtételnek minősül; egyébként False.                            //
//***************************************************************************//
proc IsEntityDictionaryItem(MClass as ENTITY)
    local dictitems = GetDictionaryItemTypes();
    loop (Instances -> TokenSet([dictitems]) )
        if ([ENTITY.name] == [TokenSet.line])
            return "True";
        end if
    end loop
    return "False";    
end proc


//***************************************************************************//
// Visszaadja az osztály legősibb entitás ősének a nevét.                    //
//***************************************************************************//
proc GetMasterEntityNameOf(MClass as ENTITY)
    if (IsMasterEntity([ENTITY]) == "false")
        loop (ENTITY -> SuperClass as BASECLASS)
            return GetMasterEntityNameOf([BASECLASS]);
        end loop
    else
        return [ENTITY.name];
    end if
end proc

//***************************************************************************//
// Visszaadja, az öröklodés típusát, ha neki nincs, akkor az öséét            //
//***************************************************************************//
proc GetInheritance(MClass as ENTITY)
    loop (ENTITY -> TaggedValue where toLower([TaggedValue.tag]) == "inheritance")
      return [TaggedValue.value];
    end loop
    loop (ENTITY -> SuperClass as BASECLASS)
        return GetInheritance([BASECLASS]);
    end loop           
    return "";
end proc

//***************************************************************************//
// Visszaadja, hogy egy entitás rendelkezik-e UML-ben definiált saját        //
// integritás-ellenőrzésre irányuló igénnyel, vagy sem.                      //
//                                                                           //
// True, ha rendelkezik; egyébként False.                                    //
//                                                                           //
// VALÓSZÍNŰLEG MÁR ELAVULT, ÉS NEM HASZNÁLT!                                //
//***************************************************************************//
proc HasCustomValidate(MClass as ENTITY)
    loop (ENTITY -> TaggedValue where toLower([TaggedValue.tag]) == "customvalidate")
        if (toLower([TaggedValue.value]) == "true")
            return "True";
        else
            return "False";
        end if
    end loop
    return "False";
end proc


//***************************************************************************//
// Visszaadja, hogy egy osztály leszármazottja-e egy másik osztálynak.       //
//***************************************************************************//
proc IsA(MClass as ENTITY, ASCENDANT)
    if ([ENTITY.name] == [ASCENDANT])
        return "True";
    end if
    
    if (IsMasterEntity([ENTITY]) == "false")
        loop (ENTITY -> SuperClass as BASECLASS)
            return IsA([BASECLASS], [ASCENDANT]);
        end loop
    else
        return "False";
    end if
end proc


//***************************************************************************//
// Visszaadja egy attribútumról, hogy csak olvasható-e vagy sem.             //
// True, ha igen; egyébként False.                                           //
//***************************************************************************//
proc IsReadonlyAttribute(MAttribute as ATTRIBUTE)
    loop (ATTRIBUTE -> TaggedValue where toLower([TaggedValue.tag]) == "readonly")
        if (toLower([TaggedValue.value]) == "true")
            return _True();
        else
            return _False();
        end if
    end loop
    return _False();
end proc

//***************************************************************************//
// Visszaadja egy attribútumról, hogy csak olvasható-e vagy sem.             //
// True, ha igen; egyébként False.                                           //
//***************************************************************************//
proc IsComputedAttribute(MAttribute as ATTRIBUTE)
    loop (ATTRIBUTE -> TaggedValue where toLower([TaggedValue.tag]) == "computed")
        return _True();
    end loop
    return _False();
end proc

//***************************************************************************//
// Visszaadja egy attribútumról, hogy csak alapértelmezett értékkel          //
// rendelkezhet, vagy sem.                                                   //
// True, ha igen; egyébként False.                                           //
//***************************************************************************//
proc IsDefaultonlyAttribute(MAttribute as ATTRIBUTE)
    loop (ATTRIBUTE -> TaggedValue where toLower([TaggedValue.tag]) == "defaultonly")
        if (toLower([TaggedValue.value]) == "true")
            return _True();
        else
            return _False();
        end if
    end loop
    return _False();
end proc


//***************************************************************************//
// Visszaadja egy asszociációról, hogy csak olvasható-e vagy sem.            //
//***************************************************************************//
proc IsReadonlyAssociation(MAssociation as ASSOCIATION)
    loop (ASSOCIATION -> TaggedValue where toLower([TaggedValue.tag]) == "readonly")
        if (toLower([TaggedValue.value]) == "true")
            return "True";
        else
            return "False";
        end if
    end loop
    return "False";
end proc


//***************************************************************************//
// Visszaadja egy asszociációról, hogy csak alapértelmezett értékkel         //
// rendelkezhet, vagy sem.                                                   //
//***************************************************************************//
proc IsDefaultonlyAssociation(MAssociation as ASSOCIATION)
    loop (ASSOCIATION -> TaggedValue where toLower([TaggedValue.tag]) == "defaultonly")
        if (toLower([TaggedValue.value]) == "true")
            return "True";
        else
            return "False";
        end if
    end loop
    return "False";
end proc


//***************************************************************************//
// Visszaadja egy attribútumról, hogy vannak-e névnek tekintendő             //
// attribútumai, vagy sem.                                                   //
//                                                                           //
// True, ha igen; egyébként False.                                           //
//***************************************************************************//
proc HasNameAttribures(MClass as ENTITY)
    loop (ENTITY -> MAttribute as ATTRIBUTE where GetStereoTypeForAttribute([ATTRIBUTE]) == "DisplayName")
        return "True";
    end loop
    return "False";
end proc


//***************************************************************************//
// Visszaadja egy attribútumról, hogy az névnek tekintendő-e vagy sem.       //
//                                                                           //
// True, ha igen; egyébként False.                                           //
//***************************************************************************//
proc IsNameAttribute(MAttribute as ATTRIBUTE)
    if (GetStereoTypeForAttribute([ATTRIBUTE]) == "DisplayName")
        return "True";
    else
        return "False";
    end if
end proc


//***************************************************************************//
// Visszaadja egy műveletről, hogy vannak-e paraméterei, vagy sem.           //
//                                                                           //
// True, ha van legalább egy; egyébként False.                               //
//***************************************************************************//
proc HasParameters(MOperation as OPERATION)
    loop (OPERATION -> OpPara as PARAMETER)
        return "True";
    end loop
    return "False";
end proc


//***************************************************************************//
// Visszaadja egy műveletről, hogy van-e Object típusú paramétere, vagy sem. //
//                                                                           //
// True, ha van legalább egy; egyébként False.                               //
//***************************************************************************//
proc HasObjectParameters(MOperation as OPERATION)
    loop (OPERATION -> OpPara as PARAMETER)
        if ([PARAMETER.type] == "Object")
            return "True";
        end if
    end loop
    return "False";
end proc


//***************************************************************************//
// Visszaadja egy osztályról, hogy vannak-e műveletei, vagy sem.             //
//                                                                           //
// True, ha van legalább egy; egyébként False.                               //
//***************************************************************************//
proc HasOperations(MClass as ENTITY)
    local package;
    loop (ENTITY -> MOperation as OPERATION)
        [package] = getStereotype([OPERATION]);
        if (IsPackageAllowed([package]) == "True")
            return "True";
        end if
    end loop
    return "False";
end proc


//***************************************************************************//
// Visszaadja egy attribútumról, hogy kötelezően kitöltött-e vagy sem.       //
//                                                                           //
// True, ha kötelezően kitöltött; egyébként False.                           //
//***************************************************************************//
proc IsAttributeRequired(MAttribute) 
    loop (MAttribute -> TaggedValue where toLower([TaggedValue.tag]) == "required")
        if (toLower([TaggedValue.value]) == "true")
            return _True();
        else
            return _False();
        end if
    end loop
    return _False();
end proc

//***************************************************************************//
// Visszaadja egy stringattributumról, hogy unicode-e                .       //
//                                                                           //
// False, ha nem; egyébként True.                                            //
//***************************************************************************//
proc IsAttributeUnicode(MAttribute) 
    if (toLower([MAttribute.type]) == "string")
      loop (MAttribute -> TaggedValue where toLower([TaggedValue.tag]) == "unicode")
          if (toLower([TaggedValue.value]) == "false")
              return "false";
          else
              return "true";
          end if
      end loop
      return "true";
    end if
    return "";
end proc

//***************************************************************************//
// Visszaadja egy attribútumról, hogy túl nagy hosszúság esetén kell-e vágni //
// Ha false akkor exception túl nagy hossz esetén                            //
// True, ha igen; egyébként False.                                           //
//***************************************************************************//
proc IsAttributeTruncateable(MAttribute) 
    loop (MAttribute -> TaggedValue where toLower([TaggedValue.tag]) == "truncateable")
        if (toLower([TaggedValue.value]) == "true")
            return _True();
        else
            return _False();
        end if
    end loop
    return _False();
end proc

//***************************************************************************//
// Megjegyzés?                                                               //
//                                                                           //
// VALÓSZÍNŰLEG MÁR ELAVULT, ÉS NEM HASZNÁLT!                                //
//***************************************************************************//
proc SDA_GetTaggedValueOfType(typeName, taggedvalue)
    loop (Instances -> MClass Where toLower([MClass.name]) == toLower([typeName]) )
        loop (MClass -> TaggedValue Where toLower([TaggedValue.tag]) == toLower([taggedvalue]))
            return [TaggedValue.value];
        end loop
    end loop
    
    switch (ToLower([typeName]))
        case "char": return "1";
        case "boolean": return "1";
        case "dictionaryitem": return SDA_GetTaggedValueOfType("ID", "length");
    end switch
    return "";
end proc


//***************************************************************************//
// Visszaadja egy osztályról, hogy szerepel-e asszociációban, mint           //
// asszociációs osztály.                                                     //
//                                                                           //
// true, ha az osztály psszociációs osztály; egyébként false.                //
//***************************************************************************//
proc IsAssociationClass(MClass)
    loop (MClass -> MAssociation as CurrentAssoc -> MAssociationEnd as StartRole -> MClass as StartClass where (GetStereoType([StartClass]) == "Entity")  )
        loop (CurrentAssoc -> MAssociationEnd as EndRole -> MClass as EndClass where([StartRole.id] < [EndRole.id] and GetStereoType([EndClass]) == "Entity" ))
            return "true";
        end loop
    end loop
    return "false";
end proc


//***************************************************************************//
// Megmondja, hogy egy típus az adatbázisbázisban lehet-e üres.              //
//                                                                           //
// VALÓSZÍNŰLEG MÁR ELAVULT, ÉS NEM HASZNÁLT!                                //
//***************************************************************************//
proc IsTypeNullable(type)
//    info = "\n  IsTypeNullable()        elavult...\n";
    switch (ToLower([type]))
        case "string":          return "true";
        case "dictionaryitem":  return "true";
        case "binary":          return "true";
        case "datetime":        return "true";
    end switch
    return "false";
end proc


//***************************************************************************//
// Visszadja egy attribútum hosszát.                                         //
//***************************************************************************//
proc GetAttributeLength(MAttribute)
    if ([MAttribute.type] == "LongString")
        return "2147483647"; // Ez itt kettőaharmicegyedikenmínuszegy...
    end if
    local taggedvalue = "";
    loop (MAttribute -> TaggedValue Where toLower([TaggedValue.tag]) == "length")
        [taggedvalue] = [TaggedValue.value];
    end loop

    if ([taggedvalue] != "" )
        return [taggedvalue];
    else
        return SDA_GetTaggedValueOfType([MAttribute.type], "length");
    end if
end proc


//***************************************************************************//
// Megnöveli eggyel a paraméterként kapott változó értékét.                  //
//***************************************************************************//
tcl_proc incr(val)
    return incr $val
end proc


//***************************************************************************//
// Visszadja egy osztály az ősosztályának a nevét. Ha nincs definiálva,      //
// az elapértelmezettel tér vissza.                                          //
//***************************************************************************//
proc GetBaseClassName(MClass, defaultname)
    local bcl;
    [bcl] = "";
    loop(MClass -> SuperClass)
        [bcl] = [SuperClass.name];
        break;
    end loop
    if ([bcl] == "")
        [bcl] = [defaultname];
    end if
    return [bcl];
end proc


//***************************************************************************//
// Visszaadja egy osztály ősosztályának ősosztályának nevét. Ha nincs ilyen  //
// az UML-ben definiálva, akkor a megadott alapértelmezett értékkel tér      //
// vissza.                                                                   //
//***************************************************************************//
proc GetBaseBaseClassName(MClass, defaultname)
    local bcl;
    [bcl] = "";
    loop(MClass -> SuperClass as baseclass)
        loop (baseclass -> SuperClass)
            [bcl] = [SuperClass.name];
            break;
         end loop
    end loop
    if ([bcl] == "")
        [bcl] = [defaultname];
    end if
    return [bcl];
end proc


//***************************************************************************//
// A kimenetre generál, olyan commandline utasítást amlye az editort a       //
// parameterkent kapott azonosító alapján a megfelelő diagramra navigálja    //
//***************************************************************************//
proc GenerateEditorNavigation(ModelElementGuid)
    out = "stpem.exe -ed stp -p " [stpreposdir] " -s " [stpprojname] " -C \"EditorQrlEval  RTM_Navigate(\\\"" [ModelElementGuid]"\\\"); \n";
    out = "pause\n";
end proc


//***************************************************************************//
// A parameterként kapott tokensetet végig nézi, és ha nem találja meg benne //
// a paraméterként kapott erteket, akkor beleteszi.                          //
//***************************************************************************//
proc AddDistinctValueToTokenSet(tokenset, value)
    // belső változó, hogy figyeljem a
    // tokensetben benne van-e már az elem
    local IsInSet = _False();

    // végig nézem, hogy az elem benne van-e a tokensetben
    loop(Instances -> TokenSet([tokenset]) )
        if ( [TokenSet.line] == [value] )
            [IsInSet] = _True();
        end if 
    end loop
    // ha nem volt benne, akkor belerekom.
    if ( [IsInSet] == _False() )
        [tokenset] = [tokenset] [value] "\n";
    end if
    
    return [tokenset];
end proc


//***************************************************************************//
// A paraméterként kapott tokensetben keresi a paraméterként kapott elemet.  //
// Ha megtalálja igaz, ha nem találja hamis értékkel tér vissza.             //
//***************************************************************************//
proc IsElementInTokenset(tokenset, element)
    loop(Instances -> TokenSet([tokenset]))
        if ( [TokenSet.line] == [element] )
            return _True();
        end if
    end loop
    return _False();
end proc


//***************************************************************************//
// Hamis értéket ad vissza, ezt a függvényt érdemes használni, egységesíti   //
// a logikai hamis érték ábrázolását, eliminálja a gépelési hibát, mert      //
// szintaktikai ellenőrzést visz a rendszerbe!                               //
//***************************************************************************//
proc _False()
    return "false";
end proc


//***************************************************************************//
// Igaz értéket ad vissza, ezt a függvényt érdemes használni, egységesíti    //
// a logikai igaz érték ábrázolását, eliminálja a gépelési hibát, mert       //
// szintaktikai ellenőrzést visz a rendszerbe!                               //
//***************************************************************************//
proc _True()
    return "true";
end proc


//***************************************************************************//
// Név és típus alapján elkészíti az XML sztinggé alakítást.                 //
//***************************************************************************//
proc GenerateEntityWrapperSaveToXMLExpression(ADAPTERNAME, ATTRIBUTENAME, ATTRIBUTETYPE, VALUE, DICTIONARYITEMTYPE)
    switch (ToLower([ATTRIBUTETYPE]))
        case "integer":         return [ADAPTERNAME] ".WriteIntegerField(\"" [ATTRIBUTENAME] "\", " [VALUE] ");";
        case "string":          return [ADAPTERNAME] ".WriteStringField(\"" [ATTRIBUTENAME] "\", " [VALUE] ");";
        case "datetime":        return [ADAPTERNAME] ".WriteDateTimeField(\"" [ATTRIBUTENAME] "\", " [VALUE] ");";
        case "boolean":         return [ADAPTERNAME] ".WriteBooleanField(\"" [ATTRIBUTENAME] "\", " [VALUE] ");";
        case "char":            return [ADAPTERNAME] ".WriteCharField(\"" [ATTRIBUTENAME] "\", " [VALUE] ");";
        case "double":          return [ADAPTERNAME] ".WriteDoubleField(\"" [ATTRIBUTENAME] "\", " [VALUE] ");";
        case "float":           return [ADAPTERNAME] ".WriteFloatField(\"" [ATTRIBUTENAME] "\", " [VALUE] ");";
        case "id":              return [ADAPTERNAME] ".WriteIDField(\"" [ATTRIBUTENAME] "\", " [VALUE] ");";
        case "dictionaryitem":  return [ADAPTERNAME] ".WriteDictionaryItemField(\"" [ATTRIBUTENAME] "\", " [VALUE] ", \"" [DICTIONARYITEMTYPE] "\");";
        case "binary":          return [ADAPTERNAME] ".WriteBinaryField(\"" [ATTRIBUTENAME] "\", " [VALUE] ");";
        case "associationid":   return [ADAPTERNAME] ".WriteAssociationID(\"" [ATTRIBUTENAME] "\", " [VALUE] ");";
        case "associationname": return [ADAPTERNAME] ".WriteAssociationName(\"" [ATTRIBUTENAME] "\", " [VALUE] ");";
        case "longstring":      return [ADAPTERNAME] ".WriteLongStringField(\"" [ATTRIBUTENAME] "\", " [VALUE] ");";
    end switch
    return "/* ERROR  Ismeretlen típus: " [ATTRIBUTETYPE] " */";
end proc


//***************************************************************************//
// Legenerálja azt a kódtöredéket, ami elvégzi a DirectXML-es XML sztinggé   //
// alakítást.                                                                //
//***************************************************************************//
proc GenerateDirectXMLSaveToXMLExpression(ADAPTERNAME, ATTRIBUTENAME, ATTRIBUTETYPE, VALUE, DICTIONARYITEMTYPE)
    switch (ToLower([ATTRIBUTETYPE]))
        case "integer":         return [ADAPTERNAME] ".WriteIntegerField(\"" [ATTRIBUTENAME] "\", reader.GetValue(counter++));";
        case "string":          return [ADAPTERNAME] ".WriteStringField(\"" [ATTRIBUTENAME] "\", reader.GetValue(counter++));";
        case "datetime":        return [ADAPTERNAME] ".WriteDateTimeField(\"" [ATTRIBUTENAME] "\", reader.GetValue(counter++));";
        case "boolean":         return [ADAPTERNAME] ".WriteBooleanField(\"" [ATTRIBUTENAME] "\", reader.GetValue(counter++));";
        case "char":            return [ADAPTERNAME] ".WriteCharField(\"" [ATTRIBUTENAME] "\", reader.GetValue(counter++));";
        case "double":          return [ADAPTERNAME] ".WriteDoubleField(\"" [ATTRIBUTENAME] "\", reader.GetValue(counter++));";
        case "float":           return [ADAPTERNAME] ".WriteFloatField(\"" [ATTRIBUTENAME] "\", reader.GetValue(counter++));";
        case "id":              return [ADAPTERNAME] ".WriteIDField(\"" [ATTRIBUTENAME] "\", reader.GetValue(counter++));";
        case "dictionaryitem":  return [ADAPTERNAME] ".WriteDictionaryItemField(\"" [ATTRIBUTENAME] "\", reader.GetValue(counter++), \"" [DICTIONARYITEMTYPE] "\");";
        case "binary":          return [ADAPTERNAME] ".WriteBinaryField(\"" [ATTRIBUTENAME] "\", reader.GetValue(counter++));";
        case "associationid":   return [ADAPTERNAME] ".WriteAssociationID(\"" [ATTRIBUTENAME] "\", reader.GetValue(counter++));";
        case "associationname": return [ADAPTERNAME] ".WriteAssociationName(\"" [ATTRIBUTENAME] "\", reader.GetValue(counter++));";
        case "longstring":      return [ADAPTERNAME] ".WriteLongStringField(\"" [ATTRIBUTENAME] "\", reader.GetValue(counter++));";

    /*
        case "integer":         return [ADAPTERNAME] ".WriteIntegerField(\"" [ATTRIBUTENAME] "\", " [VALUE] ");";
        case "string":          return [ADAPTERNAME] ".WriteStringField(\"" [ATTRIBUTENAME] "\", " [VALUE] ");";
        case "datetime":        return [ADAPTERNAME] ".WriteDateTimeField(\"" [ATTRIBUTENAME] "\", " [VALUE] ");";
        case "boolean":         return [ADAPTERNAME] ".WriteBooleanField(\"" [ATTRIBUTENAME] "\", " [VALUE] ");";
        case "char":            return [ADAPTERNAME] ".WriteCharField(\"" [ATTRIBUTENAME] "\", " [VALUE] ");";
        case "double":          return [ADAPTERNAME] ".WriteDoubleField(\"" [ATTRIBUTENAME] "\", " [VALUE] ");";
        case "float":           return [ADAPTERNAME] ".WriteFloatField(\"" [ATTRIBUTENAME] "\", " [VALUE] ");";
        case "id":              return [ADAPTERNAME] ".WriteIDField(\"" [ATTRIBUTENAME] "\", " [VALUE] ");";
        case "dictionaryitem":  return [ADAPTERNAME] ".WriteDictionaryItemField(\"" [ATTRIBUTENAME] "\", " [VALUE] ", \"" [DICTIONARYITEMTYPE] "\");";
        case "binary":          return [ADAPTERNAME] ".WriteBinaryField(\"" [ATTRIBUTENAME] "\", " [VALUE] ");";
        case "associationid":   return [ADAPTERNAME] ".WriteAssociationID(\"" [ATTRIBUTENAME] "\", " [VALUE] ");";
        case "associationname": return [ADAPTERNAME] ".WriteAssociationName(\"" [ATTRIBUTENAME] "\", " [VALUE] ");";

        case "integer":         return "if (reader.IsDBNull(counter) == false) { " [ADAPTERNAME] ".WriteIntegerField(\"" [ATTRIBUTENAME] "\", reader.GetDecimal(counter++)); } else { " [ADAPTERNAME] ".WriteIntegerField(\"" [ATTRIBUTENAME] "\", reader.GetValue(counter++)); }";
        case "string":          return "if (reader.IsDBNull(counter) == false) { " [ADAPTERNAME] ".WriteStringField(\"" [ATTRIBUTENAME] "\", reader.GetString(counter++)); } else { " [ADAPTERNAME] ".WriteStringField(\"" [ATTRIBUTENAME] "\", reader.GetValue(counter++)); }";
        case "datetime":        return "if (reader.IsDBNull(counter) == false) { " [ADAPTERNAME] ".WriteDateTimeField(\"" [ATTRIBUTENAME] "\", reader.GetDateTime(counter++)); } else { " [ADAPTERNAME] ".WriteDateTimeField(\"" [ATTRIBUTENAME] "\", reader.GetValue(counter++)); }";
        case "boolean":         return "if (reader.IsDBNull(counter) == false) { " [ADAPTERNAME] ".WriteBooleanField(\"" [ATTRIBUTENAME] "\", reader.GetString(counter++)); } else { " [ADAPTERNAME] ".WriteBooleanField(\"" [ATTRIBUTENAME] "\", reader.GetValue(counter++)); }";
        case "char":            return [ADAPTERNAME] ".WriteCharField(\"" [ATTRIBUTENAME] "\", " [VALUE] ");";
        case "double":          return [ADAPTERNAME] ".WriteDoubleField(\"" [ATTRIBUTENAME] "\", " [VALUE] ");";
        case "float":           return [ADAPTERNAME] ".WriteFloatField(\"" [ATTRIBUTENAME] "\", " [VALUE] ");";
        case "id":              return "if (reader.IsDBNull(counter) == false) { " [ADAPTERNAME] ".WriteIDField(\"" [ATTRIBUTENAME] "\", reader.GetDecimal(counter++)); } else { " [ADAPTERNAME] ".WriteIDField(\"" [ATTRIBUTENAME] "\", reader.GetValue(counter++)); }";
        case "dictionaryitem":  return [ADAPTERNAME] ".WriteDictionaryItemField(\"" [ATTRIBUTENAME] "\", " [VALUE] ", \"" [DICTIONARYITEMTYPE] "\");";
        case "binary":          return [ADAPTERNAME] ".WriteBinaryField(\"" [ATTRIBUTENAME] "\", " [VALUE] ");";
        case "associationid":   return "if (reader.IsDBNull(counter) == false) { " [ADAPTERNAME] ".WriteAssociationID(\"" [ATTRIBUTENAME] "\", reader.GetDecimal(counter++)); } else { " [ADAPTERNAME] ".WriteAssociationID(\"" [ATTRIBUTENAME] "\", reader.GetValue(counter++)); }";
        case "associationname": return "if (reader.IsDBNull(counter) == false) { " [ADAPTERNAME] ".WriteAssociationName(\"" [ATTRIBUTENAME] "\", reader.GetString(counter++)); } else { " [ADAPTERNAME] ".WriteAssociationName(\"" [ATTRIBUTENAME] "\", reader.GetValue(counter++)); }";
    */
    end switch
    return "/* ERROR  Ismeretlen típus: " [ATTRIBUTETYPE] " */";
end proc


//***************************************************************************//
// Visszaadja, hogy egy attribútum kicsinek tekintendő, vagy sem. Akkor      //
// tekintendő egy attribútum kicsinek, ha a hossza biztosan kisebb, mint     //
// 200 bájt. (karakterlánc esetén 200 karakter)                              //
//                                                                           //
// true, ha kicsinek tekintendő; egyébként false.                            //
//***************************************************************************//
proc IsAttributeSmall(MAttribute as ATTRIBUTE)
    if ([ATTRIBUTE.type] == "Binary")
        return "false";
    end if
    if ([ATTRIBUTE.type] == "String")
        if (GetAttributeLength([ATTRIBUTE]) > 200)
            return "false";
        else
            return "true";
        end if
    end if
    return "true";
end proc