init
This commit is contained in:
commit
e124a47765
19374 changed files with 9806149 additions and 0 deletions
110
Tools/CodeGeneration/Templates/Common/ActionUtil.tdl
Normal file
110
Tools/CodeGeneration/Templates/Common/ActionUtil.tdl
Normal file
|
|
@ -0,0 +1,110 @@
|
|||
//***************************************************************************//
|
||||
// Visszaadja, hogy a törlő akció engedélyezett-e, vagy sem. //
|
||||
// //
|
||||
// true, ha engedélyezett; egyébként false. //
|
||||
//***************************************************************************//
|
||||
proc IsDeleterEnabled(MClass)
|
||||
if ([ProjectName] == "Poszeidon")
|
||||
if (toLower(GetTaggedValue([MClass], "PoszeidonDeleter")) == "false")
|
||||
return "false";
|
||||
else
|
||||
return "true";
|
||||
end if
|
||||
else
|
||||
return "true";
|
||||
end if
|
||||
end proc
|
||||
|
||||
|
||||
//***************************************************************************//
|
||||
// Legenerálja az entitás nevéből és a művelet nevéből a saját (egyéni) //
|
||||
// akció nevét. //
|
||||
//***************************************************************************//
|
||||
proc GenerateCustomActionName(CLASSNAME, OPERATIONNAME)
|
||||
return [CLASSNAME] "_" [OPERATIONNAME];
|
||||
end proc
|
||||
|
||||
|
||||
//***************************************************************************//
|
||||
// Nevet generál egy osztályhoz tartozó service-nek. //
|
||||
//***************************************************************************//
|
||||
proc GenerateServiceName(ENTITYNAME)
|
||||
return [ENTITYNAME] "Service";
|
||||
end proc
|
||||
|
||||
|
||||
//***************************************************************************//
|
||||
// Legenerálja az entitás nevéből az alaphalmazt lekérdező akció nevét. //
|
||||
//***************************************************************************//
|
||||
proc GenerateLoadBaseSetActionName(ENTITYNAME)
|
||||
return [ENTITYNAME] "BaseSetLoader";
|
||||
end proc
|
||||
|
||||
|
||||
//***************************************************************************//
|
||||
// Legenrálja az entitás nevéből az azonosító alapján lekérdező ació nevét. //
|
||||
//***************************************************************************//
|
||||
proc GenerateLoadEntityActionName(ENTITYNAME)
|
||||
return [ENTITYNAME] "Loader";
|
||||
end proc
|
||||
|
||||
|
||||
//***************************************************************************//
|
||||
// Legenerálja az entitás nevéből a törlő akció nevét. //
|
||||
//***************************************************************************//
|
||||
proc GenerateDeleteEntityActionName(ENTITYNAME)
|
||||
return [ENTITYNAME] "Deleter";
|
||||
end proc
|
||||
|
||||
|
||||
//***************************************************************************//
|
||||
// Legenerálja az entitás nevéből a létrehozó akció nevét. //
|
||||
//***************************************************************************//
|
||||
proc GenerateInsertEntityActionName(ENTITYNAME)
|
||||
return [ENTITYNAME] "Inserter";
|
||||
end proc
|
||||
|
||||
|
||||
//***************************************************************************//
|
||||
// Legenerálja az entitás nevéből a módosító akció nevét. //
|
||||
//***************************************************************************//
|
||||
proc GenerateModifyEntityActionName(ENTITYNAME)
|
||||
return [ENTITYNAME] "Modifier";
|
||||
end proc
|
||||
|
||||
|
||||
//***************************************************************************//
|
||||
// Legenerálja egy entitás nevéből, és az asszociáció szerepkörének nevéből //
|
||||
// az összerendelő akció nevét. //
|
||||
//***************************************************************************//
|
||||
proc GenerateAssociaterName(MClass, MAssociationEnd)
|
||||
if (([MAssociationEnd.multiplicity] == "1") or ([MAssociationEnd.multiplicity] == "0..1"))
|
||||
return [MClass.name] "_" "Set" "_" DefineRoleName([MAssociationEnd]);
|
||||
else
|
||||
return [MClass.name] "_" "AddTo" "_" DefineRoleName([MAssociationEnd]);
|
||||
end if
|
||||
end proc
|
||||
|
||||
|
||||
//***************************************************************************//
|
||||
// Legenerálja egy entitás nevéből, és az asszociáció szerepkörének nevéből //
|
||||
// a szétkapcsoló akció nevét. //
|
||||
//***************************************************************************//
|
||||
proc GenerateDeAssociaterName(MClass, MAssociationEnd)
|
||||
if (([MAssociationEnd.multiplicity] == "1") or ([MAssociationEnd.multiplicity] == "0..1"))
|
||||
return [MClass.name] "_" "Null" "_" DefineRoleName([MAssociationEnd]);
|
||||
else
|
||||
return [MClass.name] "_" "RemoveFrom" "_" DefineRoleName([MAssociationEnd]);
|
||||
end if
|
||||
end proc
|
||||
|
||||
|
||||
//***************************************************************************//
|
||||
// Legenerálja egy entitás nevéből, és az asszociáció szerepkörének nevéből //
|
||||
// a lekérdező akció nevét. //
|
||||
//***************************************************************************//
|
||||
proc GenerateAssociationQuerierName(MClass, MAssociationEnd)
|
||||
return [MClass.name] "_" "Get" "_" DefineRoleName([MAssociationEnd]);
|
||||
end proc
|
||||
|
||||
|
||||
176
Tools/CodeGeneration/Templates/Common/CSharpUtil.tdl
Normal file
176
Tools/CodeGeneration/Templates/Common/CSharpUtil.tdl
Normal file
|
|
@ -0,0 +1,176 @@
|
|||
//***************************************************************************//
|
||||
// Nevet konvertál C# osztály névre. //
|
||||
//***************************************************************************//
|
||||
proc ConvertNameToCSharpClassName(name)
|
||||
return [name];
|
||||
end proc
|
||||
|
||||
|
||||
//***************************************************************************//
|
||||
// C# kommentet gyárt egy sztringből. //
|
||||
//***************************************************************************//
|
||||
template ConvertDescriptionToCSharpSummary(description)
|
||||
[if ([description] == "")]
|
||||
[else]
|
||||
/// [replace([description], "", "\n /// ")]
|
||||
[end if]
|
||||
end template
|
||||
|
||||
|
||||
//***************************************************************************//
|
||||
// Visszaadja egy művelet visszatérési értékét a C# nyelv szintaktikájának //
|
||||
// megfelelően //
|
||||
//***************************************************************************//
|
||||
proc GetCSharpReturnTypeOfOperation(MOperation)
|
||||
if ([MOperation.returnType] == "")
|
||||
return "void";
|
||||
else
|
||||
return GetCSharpType([MOperation.returnType]);
|
||||
end if
|
||||
end proc
|
||||
|
||||
|
||||
//***************************************************************************//
|
||||
// Visszaadja egy művelet paraméterlistáját a C# nyelv szintaktikájának és //
|
||||
// a saját jelölésbeli konvencióinknak megfelelően //
|
||||
//***************************************************************************//
|
||||
proc GetCSharpOperationParameters(MOperation)
|
||||
local ops;
|
||||
[ops] = "";
|
||||
loop (MOperation -> OpPara; setDelim(""); setDelim(", "))
|
||||
[ops] = [ops] delim() GetCSharpType([OpPara.type]) " " ToLower([OpPara.name]);
|
||||
end loop
|
||||
return [ops];
|
||||
end proc
|
||||
|
||||
proc GetCSharpTypeOfAttribute(MAttribute)
|
||||
return GetCSharpType([MAttribute.type]);
|
||||
end proc
|
||||
|
||||
|
||||
//***************************************************************************//
|
||||
// Visszadja a megadott típushoz tartozó C# tipust //
|
||||
//***************************************************************************//
|
||||
proc GetCSharpType(type)
|
||||
switch(ToLower([type]))
|
||||
case "string": return "string";
|
||||
case "integer": return "int";
|
||||
case "datetime": return "DateTime";
|
||||
case "boolean": return "bool";
|
||||
case "dictionaryitem": return "int /* DictionaryItem */"; //XXX
|
||||
case "binary": return "Byte[]";
|
||||
case "float": return "double";
|
||||
case "char": return "string";
|
||||
case "longstring": return "string";
|
||||
case "id": return "int";
|
||||
case "guid": return "Guid";
|
||||
end switch
|
||||
//return "object /* ERROR Ismeretlen tipus: " [type] " */";
|
||||
return [type];
|
||||
end proc
|
||||
|
||||
|
||||
//***************************************************************************//
|
||||
// Visszaadja a megadott típus alapértelmezett (kezdeti) értékét a C# nyelv //
|
||||
// szintaktikájának megfelelően //
|
||||
//***************************************************************************//
|
||||
proc GetCSharpDefaultValueOfType(type)
|
||||
switch(ToLower([type]))
|
||||
case "string": return "\"\"";
|
||||
case "integer": return "-1";
|
||||
case "datetime": return "DateTime.Now /* XXX DateTime */";//XXX
|
||||
case "boolean": return "false";
|
||||
case "dictionaryitem": return "-1 /* DictionaryItem */"; //XXX
|
||||
case "binary": return "null";
|
||||
case "float": return "0";
|
||||
case "char": return "\"\"";
|
||||
case "longstring": return "\"\"";
|
||||
case "id": return "-1";
|
||||
case "guid": return "default(Guid)";
|
||||
end switch
|
||||
return "null /* ERROR Ismeretlen tipus: " [type] " */";
|
||||
end proc
|
||||
|
||||
//***************************************************************************//
|
||||
// Visszaadja hogy DictionaryItem tipusu-e az adott attributum //
|
||||
// //
|
||||
//***************************************************************************//
|
||||
proc IsDictionaryItem(MAttribute)
|
||||
if (ToLower([MAttribute.type]) == "dictionaryitem")
|
||||
return _True();
|
||||
else
|
||||
return _False();
|
||||
end if
|
||||
end proc
|
||||
|
||||
//***************************************************************************//
|
||||
// Visszaadja az adott DictionaryItem konkrét osztályának a nevét //
|
||||
// //
|
||||
//***************************************************************************//
|
||||
proc GetDictionaryItemClass(MAttribute)
|
||||
return [MAttribute.defaultValue];
|
||||
end proc
|
||||
|
||||
//***************************************************************************//
|
||||
// Visszaadja a megadott attribútum alapértelmezett (kezdeti) értékét a C# //
|
||||
// nyelv szintaktikájának megfelelően //
|
||||
//***************************************************************************//
|
||||
proc GetCSharpDefaultValueOfAttribute(MAttribute)
|
||||
if (IsAttributeRequired([MAttribute]) == _True())
|
||||
else
|
||||
return "null";
|
||||
end if
|
||||
|
||||
if ([MAttribute.type] == "DictionaryItem")
|
||||
return GetCSharpDefaultValueOfType("ID");
|
||||
end if
|
||||
if ([MAttribute.type] == "Char")
|
||||
//info = [MAttribute.defaultValue]; // teszt
|
||||
end if
|
||||
|
||||
local result;
|
||||
[result] = [MAttribute.defaultValue];
|
||||
|
||||
if ([result] == "")
|
||||
[result] = GetCSharpDefaultValueOfType([MAttribute.type]);
|
||||
else
|
||||
switch (ToLower([MAttribute.type]))
|
||||
case "string": return "\"" [result] "\"";
|
||||
case "boolean": return ToLower([result]);
|
||||
case "longstring": return "\"" [result] "\"";
|
||||
case "char": //return "'" [result] "'";
|
||||
return "\"" [result] "\"";
|
||||
end switch
|
||||
if (ToLower([MAttribute.type]) == "guid")
|
||||
if ([result] == "NEWID")
|
||||
return "Guid.NewGuid()";
|
||||
else
|
||||
return "Guid.Parse(\"" [result] "\")";
|
||||
end if
|
||||
end if
|
||||
end if
|
||||
|
||||
return [result];
|
||||
end proc
|
||||
|
||||
|
||||
//***************************************************************************//
|
||||
// Visszadja a megadott típushoz tartozó C# nullabletipust //
|
||||
//***************************************************************************//
|
||||
proc GetCSharpNullableType(type)
|
||||
switch(ToLower([type]))
|
||||
case "string": return "string";
|
||||
case "integer": return "int?";
|
||||
case "datetime": return "DateTime?";
|
||||
case "boolean": return "bool?";
|
||||
case "dictionaryitem": return "int? /* DictionaryItem */"; //XXX
|
||||
case "binary": return "Byte[]";
|
||||
case "float": return "double?";
|
||||
case "char": return "string";
|
||||
case "longstring": return "string";
|
||||
case "id": return "int?";
|
||||
case "guid": return "Guid?";
|
||||
end switch
|
||||
//return "object /* ERROR Ismeretlen tipus: " [type] " */";
|
||||
return [type];
|
||||
end proc
|
||||
816
Tools/CodeGeneration/Templates/Common/CommonUtil.tdl
Normal file
816
Tools/CodeGeneration/Templates/Common/CommonUtil.tdl
Normal file
|
|
@ -0,0 +1,816 @@
|
|||
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
|
||||
|
||||
|
||||
399
Tools/CodeGeneration/Templates/Common/Converters.tdl
Normal file
399
Tools/CodeGeneration/Templates/Common/Converters.tdl
Normal file
|
|
@ -0,0 +1,399 @@
|
|||
//***************************************************************************//
|
||||
// A paraméterként kapott stringet a névkonvenciókank megfelelő //
|
||||
// indexnévvé konvertálja //
|
||||
//***************************************************************************//
|
||||
proc ConvertNameToIndexName(targetTablename, str)
|
||||
return "NCI_" [targetTablename] "_" [str];
|
||||
end proc
|
||||
|
||||
proc ConvertNameToIndexNameOld(str)
|
||||
return toUpper(TruncateString("I_" ConvertNameToSQLTableScript([str]), 29) );
|
||||
end proc
|
||||
|
||||
proc ConvertNameToForeignKeyName(tablename, columnname, tablename2)
|
||||
return "FK_" [tablename] "_" [columnname] "_REF_" [tablename2];
|
||||
end proc
|
||||
|
||||
proc ConvertNameToUniqueIndexName(tablename, columnname)
|
||||
return "NCU_" [tablename] "_" [columnname];
|
||||
end proc
|
||||
|
||||
|
||||
//***************************************************************************//
|
||||
// A paraméterként kapott cél tábla nevét, és az asszociáció azonosítóját //
|
||||
// a névkonvencióknak megfelelő foregnkeyconstraint névvé konvertája. //
|
||||
//***************************************************************************//
|
||||
proc ConvertNameToForeignKeyConstraint(targetTablename,Associd)
|
||||
return "FK_" [targetTablename] "_" [Associd];
|
||||
end proc
|
||||
|
||||
//***************************************************************************//
|
||||
// Kódtételhez táblanevet generál. //
|
||||
//***************************************************************************//
|
||||
proc ConvertDictItemTypeToItemTableName(dictItemType)
|
||||
return ConvertNameToSQLTableScript([dictItemType]);
|
||||
end proc
|
||||
|
||||
|
||||
//***************************************************************************//
|
||||
// Kódtételhez fordítástábla nevet generál. //
|
||||
//***************************************************************************//
|
||||
proc ConvertDictItemTypeToTranslationTableName(dictItemType)
|
||||
return ConvertNameToSQLTableScript("TRANS_" [dictItemType] );
|
||||
end proc
|
||||
|
||||
|
||||
//***************************************************************************//
|
||||
// Visszaadja az attributumhoz típusához tartozó kényszereket //
|
||||
//***************************************************************************//
|
||||
proc GetColumnModifyerOfAttribute(MAttribute)
|
||||
local required = GetTaggedValueOfAttribute([MAttribute], "required");
|
||||
if ( [required] == _True() )
|
||||
return "NOT NULL";
|
||||
else
|
||||
return "NULL";
|
||||
end if
|
||||
|
||||
// switch( [MAttribute.type] )
|
||||
// case "String" :
|
||||
// return "null";
|
||||
// case "Binary" :
|
||||
// return "null";
|
||||
// case "Integer" :
|
||||
// return "not null";
|
||||
// case "ID" :
|
||||
// return "null";
|
||||
// case "Float" :
|
||||
// return "not null";
|
||||
// case "DateTime":
|
||||
// return "not null";
|
||||
// case "Boolean" :
|
||||
// return "not null";
|
||||
// case "DictionaryItem" :
|
||||
// return "null";
|
||||
// case "Char" :
|
||||
// return "not null";
|
||||
// default:
|
||||
// return "UNKNOWN TYPE:" [MAttribute.type];
|
||||
// end switch
|
||||
end proc
|
||||
|
||||
|
||||
//***************************************************************************//
|
||||
// Átalakítja az attributm leíró információit SQL típussá. Ezt a függvényt a //
|
||||
// más függvények használják. //
|
||||
// pl: ConvertAttributeToSQlType,ConvertUMLTypeToSQLType //
|
||||
//***************************************************************************//
|
||||
proc ConvertAttributeInfoToSQlType(attributetype, attributelength, attributeprecision, attributeunicode)
|
||||
|
||||
// attribute length vizsgalat
|
||||
if ([attributelength] == "" )
|
||||
[attributelength] = GetTaggedValueOfType([attributetype],"length");
|
||||
end if
|
||||
|
||||
// attribute precision vizsgalat
|
||||
if ([attributeprecision] == "" )
|
||||
[attributeprecision] = GetTaggedValueOfType([attributetype],"precision");
|
||||
end if
|
||||
|
||||
if ([attributeunicode] == "" )
|
||||
[attributeunicode] = GetTaggedValueOfType([attributetype],"unicode");
|
||||
end if
|
||||
|
||||
switch( [attributetype] )
|
||||
//String Type
|
||||
case "String" :
|
||||
if ([attributelength] <= "4000")
|
||||
if ([attributeunicode] == "false")
|
||||
return "varchar(" [attributelength] ")";
|
||||
else
|
||||
return "nvarchar(" [attributelength] ")";
|
||||
end if
|
||||
else
|
||||
if ([attributeunicode] == "false")
|
||||
return "varchar(max)";
|
||||
else
|
||||
return "nvarchar(max)";
|
||||
end if
|
||||
end if
|
||||
|
||||
case "FixString" :
|
||||
return "char(" [attributelength] ")";
|
||||
|
||||
// LongString type
|
||||
case "LongString" :
|
||||
if ([attributeunicode] == "false")
|
||||
return "varchar(max)";
|
||||
else
|
||||
return "nvarchar(max)";
|
||||
end if
|
||||
|
||||
// Binary Type
|
||||
case "Binary" :
|
||||
return "varbinary(max)";
|
||||
|
||||
// Integer Type
|
||||
case "Integer" :
|
||||
return "int";
|
||||
|
||||
// ID Type
|
||||
case "ID" :
|
||||
return "int";
|
||||
|
||||
// retk teszt
|
||||
// Float Type
|
||||
case "Float" :
|
||||
if ([CimbyTest_MSSQL] == "true")
|
||||
return "numeric(" [attributelength] "," [attributeprecision] ")";
|
||||
else
|
||||
return "numeric(" [attributelength] "," [attributeprecision] ")";
|
||||
end if
|
||||
|
||||
// DateTime Type
|
||||
case "DateTime":
|
||||
return "datetime";
|
||||
|
||||
// Boolean Type
|
||||
case "Boolean" :
|
||||
return "char(1)";
|
||||
|
||||
// DictionaryItem Type
|
||||
case "DictionaryItem" :
|
||||
if ([CimbyTest_MSSQL] == "true")
|
||||
return "int";
|
||||
else
|
||||
return "numeric(" GetTaggedValueOfType("ID","length") ")";
|
||||
end if
|
||||
|
||||
// Char Type
|
||||
case "Char" :
|
||||
return "nchar(1)";
|
||||
|
||||
// Guid Type
|
||||
case "Guid" :
|
||||
return "uniqueidentifier";
|
||||
|
||||
// Kivetel ag
|
||||
default :
|
||||
return "UNKNOWN TYPE:" [attributetype];
|
||||
end switch
|
||||
break;
|
||||
end proc
|
||||
|
||||
|
||||
//***************************************************************************//
|
||||
// Átalakítja az Attribútumot SQL típussá. //
|
||||
//***************************************************************************//
|
||||
proc ConvertAttributeToSQlType(MAttribute)
|
||||
local attributelength = "";
|
||||
local attributeprecision = "";
|
||||
local attributeunicode = "";
|
||||
|
||||
[attributelength] = GetTaggedValueOfAttribute([MAttribute],"length");
|
||||
[attributeprecision] = GetTaggedValueOfAttribute([MAttribute],"precision");
|
||||
[attributeunicode] = GetTaggedValueOfAttribute([MAttribute],"unicode");
|
||||
|
||||
return ConvertAttributeInfoToSQlType([MAttribute.type], [attributelength], [attributeprecision], [attributeunicode]);
|
||||
|
||||
end proc
|
||||
|
||||
|
||||
//***************************************************************************//
|
||||
// Átalakítja az UML modelben felvett és ismert alap típust SQL típussá //
|
||||
//***************************************************************************//
|
||||
proc ConvertUMLTypeToSQLType(attributetype)
|
||||
//default null-okkal hívom meg a convertálást
|
||||
//így a típushoz definiált tulajdonságok figyelembe
|
||||
// vételével történik a convertálás.
|
||||
return ConvertAttributeInfoToSQlType([attributetype],"","", "");
|
||||
end proc
|
||||
|
||||
|
||||
//***************************************************************************//
|
||||
// A paraméterként kapott stringet a név konvencióknak megfelelő SQL //
|
||||
// paraméter névvé konvertálja. //
|
||||
//***************************************************************************//
|
||||
proc ConvertNameToSQLParamName(str)
|
||||
local parPrefix = "";
|
||||
switch ( [SQL_DBType] )
|
||||
//ORACLE Type
|
||||
case "ORACLE" :
|
||||
[parPrefix] = ":p";
|
||||
break;
|
||||
//MSSQL Type
|
||||
case "MSSQL" :
|
||||
[parPrefix] = "@p";
|
||||
break;
|
||||
//DB2Type
|
||||
case "DB2" :
|
||||
[parPrefix] = ":p";
|
||||
break;
|
||||
end switch
|
||||
|
||||
return [parPrefix]toUpper([str]);
|
||||
end proc
|
||||
|
||||
|
||||
//***************************************************************************//
|
||||
// A paraméterként kapott stringet a névkonvencióknak megfelelő oszlopnévvé //
|
||||
// konvertálja //
|
||||
//***************************************************************************//
|
||||
proc ConvertNameToSQLColumnName(str)
|
||||
return toUpper(TruncateString("C_" [str], 29));
|
||||
end proc
|
||||
|
||||
|
||||
//***************************************************************************//
|
||||
// A paraméterként kapott stringet a névkonvencióknak megfelelő táblanévvé //
|
||||
// konvertálja //
|
||||
//***************************************************************************//
|
||||
proc ConvertNameToSQLTableScript(str)
|
||||
if (TruncateString([str], 3) == "DKT_")
|
||||
return toUpper("T_"[str]);
|
||||
end if
|
||||
return toUpper(TruncateString("T_"[str], 29));
|
||||
end proc
|
||||
|
||||
|
||||
//***************************************************************************//
|
||||
// A paraméterként kapott stringet a névkonvencióknak megfelelő táblanévvé //
|
||||
// konvertálja Tanév független Intézmény függővé //
|
||||
//***************************************************************************//
|
||||
proc ConvertNameToSQLTableName(str)
|
||||
return ConvertNameToSQLTableScript([str]) "_OSSZES";
|
||||
end proc
|
||||
|
||||
//***************************************************************************//
|
||||
// A paraméterként kapott stringet a névkonvencióknak megfelelő táblanévvé //
|
||||
// konvertálja //
|
||||
//***************************************************************************//
|
||||
proc ConvertNameToSQLDefaultTableName(str)
|
||||
return toUpper(TruncateString("D_"[str], 29));
|
||||
end proc
|
||||
|
||||
//***************************************************************************//
|
||||
// A paraméterként kapott stringet a névkonvencióknak megfelelő viewnévvé //
|
||||
// konvertálja //
|
||||
//***************************************************************************//
|
||||
proc ConvertNameToSQLViewName(str)
|
||||
return toUpper(TruncateString("T_"[str], 29));
|
||||
end proc
|
||||
|
||||
//***************************************************************************//
|
||||
// A paraméterként kapott stringet a névkonvenciókank megfelelő //
|
||||
// primarykey constraint névvé konvertálja //
|
||||
//***************************************************************************//
|
||||
proc ConvertNameToPrimaryKeyConstraintName(str)
|
||||
return "PK_" [str];
|
||||
end proc
|
||||
|
||||
|
||||
//***************************************************************************//
|
||||
// A paraméterként kapott asszociáció azonosítót a névkonvencióknak megfelelő//
|
||||
// uniquekeyconstraint névvé konvertálja. //
|
||||
//***************************************************************************//
|
||||
proc ConvertNameToUniqueKeyConstraint(targetTablename, Associd)
|
||||
return toUpper("UQ_" TruncateString([targetTablename], 27) "_" [Associd]);
|
||||
end proc
|
||||
|
||||
//***************************************************************************//
|
||||
// A paraméterként kapott stringet a névkonvenciókank megfelelő //
|
||||
// check constraint névvé konvertálja //
|
||||
//***************************************************************************//
|
||||
proc ConvertNameToCheckConstraintName(str)
|
||||
return toUpper(TruncateString("CK_" ConvertNameToSQLTableScript([str]), 29) );
|
||||
end proc
|
||||
|
||||
|
||||
//***************************************************************************//
|
||||
// Meghatározza a paraméterként kapott asszociációsvégponthoz tartozó //
|
||||
// szerepkör nevét. Ha nincs a modelben beállított szerepkörnév akkor //
|
||||
// meghatároz egyet //
|
||||
//***************************************************************************//
|
||||
proc DefineRoleName(MAssociationEnd as StartRole)
|
||||
if ([StartRole.name]!="")
|
||||
return [StartRole.name];
|
||||
else
|
||||
loop (StartRole -> MClass)
|
||||
return [MClass.name];
|
||||
end loop
|
||||
end if
|
||||
end proc
|
||||
|
||||
proc GetRoleClassName(MAssociationEnd as StartRole)
|
||||
loop (StartRole -> MClass)
|
||||
return [MClass.name];
|
||||
end loop
|
||||
end proc
|
||||
|
||||
//***************************************************************************//
|
||||
// A paraméterként kapott Asszociációsvégponttot oszlopnévvé konvertája //
|
||||
//***************************************************************************//
|
||||
proc ConvertRoleToName( MAssociationEnd as StartRole )
|
||||
return DefineRoleName([StartRole]) "Id";
|
||||
end proc
|
||||
|
||||
|
||||
//***************************************************************************//
|
||||
// A paraméterként kapott asszociációsvégpontokat kapcsolótábla névvé //
|
||||
// konvertálja //
|
||||
//***************************************************************************//
|
||||
proc ConvertAssociationRolesToSwitchTableName(MAssociationEnd as StartRole, MAssociationEnd as EndRole)
|
||||
if ([StartRole.id] < [EndRole.id])
|
||||
return DefineRoleName([StartRole]) "_" DefineRoleName([EndRole]);
|
||||
else
|
||||
return DefineRoleName([EndRole]) "_" DefineRoleName([StartRole]);
|
||||
end if
|
||||
end proc
|
||||
|
||||
//***************************************************************************//
|
||||
// Az SQL parancsok elválasztására szolgáló szeparátort adja vissza //
|
||||
//***************************************************************************//
|
||||
proc GetCommandSeparator()
|
||||
switch ( [SQL_DBType])
|
||||
//ORACLE Type
|
||||
case "ORACLE" :
|
||||
return "/";
|
||||
case "MSSQL" :
|
||||
return "GO";
|
||||
case "DB2" :
|
||||
return "";
|
||||
end switch
|
||||
end proc
|
||||
|
||||
|
||||
//***************************************************************************//
|
||||
// Az egyes SQL függvények néveltéréseit kiküszöbölő függvény //
|
||||
//***************************************************************************//
|
||||
proc GetFunctionName( functionType )
|
||||
switch ( toUpper( [ functionType ] ))
|
||||
case "LENGTH" :
|
||||
switch ( [SQL_DBType])
|
||||
//ORACLE Type
|
||||
case "ORACLE" :
|
||||
return "LENGTH";
|
||||
case "MSSQL" :
|
||||
return "LEN";
|
||||
case "DB2" :
|
||||
return "LENGTH";
|
||||
end switch
|
||||
break;
|
||||
end switch
|
||||
end proc
|
||||
|
||||
|
||||
//***************************************************************************//
|
||||
// Az egyes default dátum értékekek kezeléséhez használt függvény //
|
||||
//***************************************************************************//
|
||||
proc GetDefaultDateTimeString()
|
||||
switch ( [SQL_DBType])
|
||||
//ORACLE Type
|
||||
case "ORACLE" :
|
||||
return "DEFAULT SYSDATE";
|
||||
case "MSSQL" :
|
||||
return "DEFAULT GETDATE()";
|
||||
case "DB2" :
|
||||
return "";
|
||||
end switch
|
||||
end proc
|
||||
|
||||
695
Tools/CodeGeneration/Templates/Common/DAUtil.tdl
Normal file
695
Tools/CodeGeneration/Templates/Common/DAUtil.tdl
Normal file
|
|
@ -0,0 +1,695 @@
|
|||
//***************************************************************************//
|
||||
// Nevet konvertál SQL szöveg névvé, a konvencióinknak megfelelően. //
|
||||
//***************************************************************************//
|
||||
proc ConvertNameToCommandTextName(COMMANDNAME)
|
||||
return [COMMANDNAME] "CommandText";
|
||||
end proc
|
||||
|
||||
|
||||
//***************************************************************************//
|
||||
// Névből adatbázisművelethez paraméternevet generál. //
|
||||
//***************************************************************************//
|
||||
proc ConvertNameToCommandParameterName(name)
|
||||
return TruncateString("p" ToUpper([name]), 29);
|
||||
end proc
|
||||
|
||||
|
||||
//***************************************************************************//
|
||||
// Legenrálja azt a kódtöredéket, ami egy DataReader objektumból kiolvassa //
|
||||
// az adatot, az adat típusának és az oszlop indexének megfelelően. //
|
||||
//***************************************************************************//
|
||||
proc GenerateReaderRead(type, column, readername)
|
||||
switch (ToLower([type]))
|
||||
case "integer": return "((int)" [readername] ".GetDecimal(" [column] "))";
|
||||
case "string": return [readername] ".GetString(" [column] ")";
|
||||
case "datetime": return [readername] ".GetDateTime(" [column] ")";
|
||||
case "boolean": return "(" [readername] ".GetString(" [column] ")[0] != 'F')";
|
||||
case "char": //return "(" [readername] ".GetString(" [column] ")[0])";
|
||||
return [readername] ".GetString(" [column] ")";
|
||||
case "double": return [readername] ".GetDouble(" [column] ")";
|
||||
case "float": return [readername] ".GetDouble(" [column] ")";
|
||||
case "id": return "((int)" [readername] ".GetDecimal(" [column] "))";
|
||||
case "dictionaryitem": return "((int)" [readername] ".GetDecimal(" [column] ")) /* XXX DictionaryItem */";
|
||||
case "binary": return "((Byte[])" [readername] ".GetValue(" [column] "))";
|
||||
case "longstring": return [readername] ".GetString(" [column] ")";
|
||||
case "guid": return "((Guid)" [readername] ".GetValue(" [column] "))";
|
||||
end switch
|
||||
return [readername] ".GetInt32(999) /* XXX Ismeretlen tipus: " [type] " */";
|
||||
end proc
|
||||
|
||||
|
||||
|
||||
//***************************************************************************//
|
||||
// Legenerálja azt az SQL töredéket, ami egy entitáshoz tartozó táblaneveket //
|
||||
// soroja fel, az ősosztályok tábláival együtt. //
|
||||
// //
|
||||
// REKURZÍV! //
|
||||
//***************************************************************************//
|
||||
proc GenerateSuperClassTableList(MClass)
|
||||
local result;
|
||||
[result] = "";
|
||||
if (GetInheritance([MClass]) == "tpc")
|
||||
return [result];
|
||||
end if
|
||||
loop (MClass -> SuperClass as MBaseClass)
|
||||
[result] = "inner join " ConvertNameToSQLTableName([MBaseClass.name]) " on (" ConvertNameToSQLTableName([MClass.name]) ".ID = " ConvertNameToSQLTableName([MBaseClass.name]) ".ID)";
|
||||
[result] = [result] " " GenerateSuperClassTableList([MBaseClass]);
|
||||
break;
|
||||
end loop
|
||||
|
||||
return [result];
|
||||
end proc
|
||||
|
||||
|
||||
//***************************************************************************//
|
||||
// Legenerálja azt az SQL töredéket, ami egy entitás és az ősosztályainak //
|
||||
// tábláit kapcsolja össze az SQL where részében. //
|
||||
// //
|
||||
// REKURZÍV! //
|
||||
//***************************************************************************//
|
||||
template SDA_GetSuperClassSelectFilter(MClass)
|
||||
[if (IsMasterEntity([MClass]) == "false")]
|
||||
"([ConvertNameToSQLTableName(GetBaseClassName([MClass], "/* XXX errorhiba van! */"))].ID = [ConvertNameToSQLTableName([MClass.name])].ID) "[if (GetBaseBaseClassName([MClass], "") != "")] +
|
||||
[loop (MClass -> SuperClass as MBaseClass)]
|
||||
"and " +
|
||||
[SDA_GetSuperClassSelectFilter([MBaseClass])][break]
|
||||
[end loop]
|
||||
[end if]
|
||||
[end if]
|
||||
end template
|
||||
|
||||
|
||||
//***************************************************************************//
|
||||
//***************************************************************************//
|
||||
proc GetReadAttributeMethodName(ATTRIBUTETYPE)
|
||||
switch (ToLower([ATTRIBUTETYPE]))
|
||||
case "string": return "ReadStringAttribute";
|
||||
case "integer": return "ReadIntegerAttribute";
|
||||
case "datetime": return "ReadDateTimeAttribute";
|
||||
case "boolean": return "ReadBooleanAttribute";
|
||||
case "dictionaryitem": return "ReadIntegerAttribute";
|
||||
case "binary": return "ReadBinaryAttribute";
|
||||
case "float": return "ReadDoubleAttribute";
|
||||
case "char": return "ReadStringAttribute";
|
||||
case "longstring": return "ReadStringAttribute";
|
||||
case "double": return "ReadDoubleAttribute";
|
||||
case "id": return "ReadIntegerAttribute";
|
||||
case "guid": return "ReadGuidAttribute";
|
||||
end switch
|
||||
return "Ismeretlen /* XXX Ismeretlen tipus: " [type] " */";
|
||||
end proc
|
||||
|
||||
|
||||
template GenerateFieldLoadEntityCore(MClass, offset, entityname, readername)
|
||||
// [MClass.name] mezői
|
||||
[setVar("counter", [offset])]
|
||||
[loop (MClass -> MAttribute where [MAttribute.name] != [MClass.name])]
|
||||
|
||||
[if (IsAttributeRequired([MAttribute]) == _True())]
|
||||
[entityname].m_[MAttribute.name] = DAUtil.[GetReadAttributeMethodName([MAttribute.type])]([readername], [counter], [GetCSharpDefaultValueOfAttribute([MAttribute])]);
|
||||
[else]
|
||||
[entityname].m_[MAttribute.name] = DAUtil.[GetReadAttributeMethodName([MAttribute.type])]([readername], [counter]);
|
||||
[end if]
|
||||
|
||||
[setVar("counter", incr([counter]))]
|
||||
[end loop]
|
||||
[if (GetBaseClassName([MClass], [""]) != [""] )]
|
||||
[loop (MClass -> SuperClass as MBaseClass)]
|
||||
[GenerateFieldLoadEntityCore([MBaseClass], [counter], [entityname], [readername])][break]
|
||||
[end loop]
|
||||
[end if]
|
||||
end template
|
||||
|
||||
template GenerateAssociationLoadEntityCore(MClass, offset, entityname, readername)
|
||||
// [MClass.name] kapcsoló mezői
|
||||
[setVar("counter", [offset])]
|
||||
[loop (MClass -> Role as StartRole -> MAssociation as CurrentAssoc -> MAssociationEnd as EndRole -> MClass as PartnerClass where (([StartRole.id] != [EndRole.id]) and GetStereoType([PartnerClass]) == "Entity"))]
|
||||
[if (HasAssociationClass([CurrentAssoc]) == "")]
|
||||
[if ([EndRole.multiplicity] == "1")]
|
||||
DAUtil.ReadIDAttribute([readername], [counter], ref [entityname].m_[ConvertRoleToName([EndRole])], 0);
|
||||
[setVar("counter", incr([counter]))]
|
||||
[else]
|
||||
[if ([EndRole.multiplicity] == "0..1")]
|
||||
[if (([StartRole.multiplicity] == "1..*") or ([StartRole.multiplicity] == "*") or ([StartRole.multiplicity] == "0..*"))]
|
||||
DAUtil.ReadIDAttribute([readername], [counter], ref [entityname].m_[ConvertRoleToName([EndRole])], -1);
|
||||
[setVar("counter", incr([counter]))]
|
||||
[end if]
|
||||
[end if]
|
||||
[end if]
|
||||
[end if]
|
||||
[end loop]
|
||||
[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" ))]
|
||||
DAUtil.ReadIDAttribute([readername], [counter], ref [entityname].m_[ConvertRoleToName([StartRole])], 0);
|
||||
[setVar("counter", incr([counter]))]
|
||||
DAUtil.ReadIDAttribute([readername], [counter], ref [entityname].m_[ConvertRoleToName([EndRole])], 0);
|
||||
[setVar("counter", incr([counter]))]
|
||||
[end loop]
|
||||
[end loop]
|
||||
[if (GetBaseClassName([MClass], [""]) != [""] )]
|
||||
[loop (MClass -> SuperClass as MBaseClass)]
|
||||
[GenerateAssociationLoadEntityCore([MBaseClass], [counter], [entityname], [readername])][break]
|
||||
[end loop]
|
||||
[end if]
|
||||
end template
|
||||
|
||||
//***************************************************************************//
|
||||
// Legenerálja azt a ciklusmagot, amely egy DataReader-ből kiszippantja //
|
||||
// az entitás összes mezőjét. //
|
||||
// //
|
||||
// REKURZÍV! //
|
||||
//***************************************************************************//
|
||||
template GenerateLoadEntityCore(MClass, offset, entityname, readername)
|
||||
// [MClass.name] betöltése
|
||||
[setVar("counter", [offset])]
|
||||
[GenerateFieldLoadEntityCore([MClass], [counter], [entityname], [readername])]
|
||||
[GenerateAssociationLoadEntityCore([MClass], [counter], [entityname], [readername])]
|
||||
end template
|
||||
|
||||
template GenerateFieldDynamicLoadEntityCore(MClass, entityname, readername)
|
||||
// [MClass.name] mezői
|
||||
[loop (MClass -> MAttribute where [MAttribute.name] != [MClass.name])]
|
||||
if (((columnFilterMode == ColumnFilterMode.DEFAULT_ALLOWED) ^ (columns.Contains("[MAttribute.name]"))))
|
||||
{
|
||||
[if (IsAttributeRequired([MAttribute]) == _True())]
|
||||
[entityname].m_[MAttribute.name] = DAUtil.[GetReadAttributeMethodName([MAttribute.type])]([readername], index++, [GetCSharpDefaultValueOfAttribute([MAttribute])]);
|
||||
[else]
|
||||
[entityname].m_[MAttribute.name] = DAUtil.[GetReadAttributeMethodName([MAttribute.type])]([readername], index++);
|
||||
[end if]
|
||||
}
|
||||
[end loop]
|
||||
[if (GetBaseClassName([MClass], [""]) != [""] )]
|
||||
[loop (MClass -> SuperClass as MBaseClass)]
|
||||
[GenerateFieldDynamicLoadEntityCore([MBaseClass], [entityname], [readername])]
|
||||
[end loop]
|
||||
[end if]
|
||||
end template
|
||||
|
||||
template GenerateAssociationDynamicLoadEntityCore(MClass, entityname, readername)
|
||||
// [MClass.name] kapcsoló mezői
|
||||
[loop (MClass -> Role as StartRole -> MAssociation as CurrentAssoc -> MAssociationEnd as EndRole -> MClass as PartnerClass where (([StartRole.id] != [EndRole.id]) and GetStereoType([PartnerClass]) == "Entity"))]
|
||||
[if (HasAssociationClass([CurrentAssoc]) == "")]
|
||||
[if ([EndRole.multiplicity] == "1")]
|
||||
DAUtil.ReadIDAttribute([readername], index++, ref [entityname].m_[ConvertRoleToName([EndRole])], 0);
|
||||
[else]
|
||||
[if ([EndRole.multiplicity] == "0..1")]
|
||||
[if (([StartRole.multiplicity] == "1..*") or ([StartRole.multiplicity] == "*") or ([StartRole.multiplicity] == "0..*"))]
|
||||
DAUtil.ReadIDAttribute([readername], index++, ref [entityname].m_[ConvertRoleToName([EndRole])], -1);
|
||||
[end if]
|
||||
[end if]
|
||||
[end if]
|
||||
[end if]
|
||||
[end loop]
|
||||
[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" ))]
|
||||
DAUtil.ReadIDAttribute([readername], index++, ref [entityname].m_[ConvertRoleToName([StartRole])], 0);
|
||||
DAUtil.ReadIDAttribute([readername], index++, ref [entityname].m_[ConvertRoleToName([EndRole])], 0);
|
||||
[end loop]
|
||||
[end loop]
|
||||
[if (GetBaseClassName([MClass], [""]) != [""] )]
|
||||
[loop (MClass -> SuperClass as MBaseClass)]
|
||||
[GenerateAssociationDynamicLoadEntityCore([MBaseClass], [entityname], [readername])]
|
||||
[end loop]
|
||||
[end if]
|
||||
end template
|
||||
|
||||
//***************************************************************************//
|
||||
// Legenerálja azt a ciklusmagot, amely egy DataReader-ből kiszippantja //
|
||||
// az entitás összes mezőjét. //
|
||||
// //
|
||||
// REKURZÍV! //
|
||||
//***************************************************************************//
|
||||
template GenerateDynamicLoadEntityCore(MClass, entityname, readername)
|
||||
// [MClass.name] betöltése
|
||||
[GenerateFieldDynamicLoadEntityCore([MClass], [entityname], [readername])]
|
||||
[GenerateAssociationDynamicLoadEntityCore([MClass], [entityname], [readername])]
|
||||
end template
|
||||
|
||||
|
||||
//***************************************************************************//
|
||||
// Legenerálja azt az SQL töredéket, ami egy entitás attribútumaihoz tartozó //
|
||||
// mezőket, és az asszociációs kapcsolómezőket tartalmazza. //
|
||||
// //
|
||||
// REKURZÍV! //
|
||||
//***************************************************************************//
|
||||
template GenerateFieldListWithBaseClassFields(MClass, entityname)
|
||||
// [MClass.name] betöltése
|
||||
[GenerateAttributeFieldListWithBaseClassFields([MClass], [entityname])]
|
||||
[GenerateAssociationFieldListWithBaseClassFields([MClass], [entityname] )]
|
||||
[GenerateIdAndSerialFields([MClass], [entityname] )]
|
||||
end template
|
||||
|
||||
template GenerateIdAndSerialFields(MClass, entityname)
|
||||
[if (IsMasterEntity([MClass]) == "false")]
|
||||
[loop (MClass -> SuperClass as MBaseClass)]
|
||||
[if (GetInheritance([MClass]) == "tpc")]
|
||||
[GenerateIdAndSerialFields([MBaseClass], [entityname])][break]
|
||||
[else]
|
||||
[GenerateIdAndSerialFields([MBaseClass], [MBaseClass.name])][break]
|
||||
[end if]
|
||||
[end loop]
|
||||
[else]
|
||||
"[ConvertNameToSQLTableName([entityname])].TOROLT, " +
|
||||
"[ConvertNameToSQLTableName([entityname])].SERIAL, " +
|
||||
"[ConvertNameToSQLTableName([entityname])].CREATED, " +
|
||||
"[ConvertNameToSQLTableName([entityname])].CREATOR, " +
|
||||
"[ConvertNameToSQLTableName([entityname])].LASTCHANGED, " +
|
||||
"[ConvertNameToSQLTableName([entityname])].MODIFIER " +
|
||||
[end if]
|
||||
end template
|
||||
|
||||
template GenerateAssociationFieldListWithBaseClassFields(MClass, entityname)
|
||||
// [MClass.name] kapcsoló mezői
|
||||
[loop (MClass -> Role as StartRole -> MAssociation as CurrentAssoc -> MAssociationEnd as EndRole -> MClass as PartnerClass where (([StartRole.id] != [EndRole.id]) and GetStereoType([PartnerClass]) == "Entity"))]
|
||||
[if (HasAssociationClass([CurrentAssoc]) == "")]
|
||||
[if ([EndRole.multiplicity] == "1")]
|
||||
"[ConvertNameToSQLTableName([entityname])].[ConvertNameToSQLColumnName(ConvertRoleToName([EndRole]))], " + /* Kötelező asszociációs kapcsolómező */
|
||||
[else]
|
||||
[if ([EndRole.multiplicity] == "0..1")]
|
||||
[if (([StartRole.multiplicity] == "1..*") or ([StartRole.multiplicity] == "*") or ([StartRole.multiplicity] == "0..*"))]
|
||||
"[ConvertNameToSQLTableName([entityname])].[ConvertNameToSQLColumnName(ConvertRoleToName([EndRole]))], " + /* Opcionális asszociációs kapcsolómező */
|
||||
[end if]
|
||||
[end if]
|
||||
[end if]
|
||||
[end if]
|
||||
[end loop]
|
||||
[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" ))]
|
||||
"[ConvertNameToSQLTableName([entityname])].[ConvertNameToSQLColumnName(ConvertRoleToName([StartRole]))], " + /* Asszociációs mező */
|
||||
"[ConvertNameToSQLTableName([entityname])].[ConvertNameToSQLColumnName(ConvertRoleToName([EndRole]))], " + /* Asszociációs mező */
|
||||
[end loop]
|
||||
[end loop]
|
||||
[if (IsMasterEntity([MClass]) == "false")]
|
||||
[loop (MClass -> SuperClass as MBaseClass)]
|
||||
[if (GetInheritance([MClass]) == "tpc")]
|
||||
[GenerateAssociationFieldListWithBaseClassFields([MBaseClass], [entityname])][break]
|
||||
[else]
|
||||
[GenerateAssociationFieldListWithBaseClassFields([MBaseClass], [MBaseClass.name])][break]
|
||||
[end if]
|
||||
[end loop]
|
||||
[end if]
|
||||
end template
|
||||
|
||||
template GenerateAttributeFieldListWithBaseClassFields(MClass, entityname)
|
||||
// [MClass.name] mezői
|
||||
[loop (MClass->MAttribute)]
|
||||
"[ConvertNameToSQLTableName([entityname])].[ConvertNameToSQLColumnName([MAttribute.name])], " +
|
||||
[end loop]
|
||||
[if (IsMasterEntity([MClass]) == "false")]
|
||||
[loop (MClass -> SuperClass as MBaseClass)]
|
||||
[if (GetInheritance([MClass]) == "tpc")]
|
||||
[GenerateAttributeFieldListWithBaseClassFields([MBaseClass], [entityname])][break]
|
||||
[else]
|
||||
[GenerateAttributeFieldListWithBaseClassFields([MBaseClass], [MBaseClass.name])][break]
|
||||
[end if]
|
||||
[end loop]
|
||||
[end if]
|
||||
end template
|
||||
|
||||
//********************************************************************************//
|
||||
// Legenerálja azt az SQL töredéket, ami egy entitás alap attribútumaihoz tartozó //
|
||||
// mezőket, és az asszociációs kapcsolómezőket tartalmazza. //
|
||||
// //
|
||||
// REKURZÍV! //
|
||||
//********************************************************************************//
|
||||
template GenerateDynamicFieldListWithBaseClassFields(MClass, entityname)
|
||||
// [MClass.name] betöltése
|
||||
[GenerateAssociationFieldListWithBaseClassFields([MClass], [entityname])]
|
||||
[GenerateIdAndSerialFields([MClass], [entityname])]
|
||||
end template
|
||||
|
||||
//***************************************************************************//
|
||||
// Legenerálja a DataAccess.csproj fájl szerelvény hivatkozási szekciójának //
|
||||
// azt a részét, ami az adatbáziskezelésre vonatkozik. Ez adatbázisonként //
|
||||
// más. //
|
||||
//***************************************************************************//
|
||||
template GenerateDataAccessAssemblyReferences()
|
||||
[if ([DBTYPE] == "UniDirect")]
|
||||
<Reference
|
||||
Name = "CoreLab.UniDirect"
|
||||
AssemblyName = "CoreLab.UniDirect"
|
||||
HintPath = "..\References\CoreLab.UniDirect.dll"
|
||||
/>
|
||||
[else][if ([DBTYPE] == "ODP")]
|
||||
<Reference
|
||||
Name = "Oracle.DataAccess"
|
||||
AssemblyName = "Oracle.DataAccess"
|
||||
HintPath = "..\References\Oracle.DataAccess.dll"
|
||||
AssemblyFolderKey = "hklm\dn\odp.net"
|
||||
/>
|
||||
[else][if ([DBTYPE] == "OracleClient")]
|
||||
<Reference
|
||||
Name = "System.Data.OracleClient"
|
||||
AssemblyName = "System.Data.OracleClient"
|
||||
HintPath = "..\References\System.Data.OracleClient.dll"
|
||||
/>
|
||||
[else][if ([DBTYPE] == "SDA")]
|
||||
<Reference
|
||||
Name = "SDA.DataProvider"
|
||||
AssemblyName = "SDA.DataProvider"
|
||||
HintPath = "..\References\SDA.DataProvider.dll"
|
||||
/>
|
||||
[end if][end if][end if][end if]
|
||||
end template
|
||||
|
||||
|
||||
//***************************************************************************//
|
||||
// Legenerálja azt a kóddarabot, ami egy command obejktum inicializálását //
|
||||
// végzi. Ez adatbázisonként más. //
|
||||
//***************************************************************************//
|
||||
template GenerateCommandInit(COMMANDNAME)
|
||||
[if ([DBTYPE] == "SDA")]
|
||||
[COMMANDNAME].Connection = UserContext.Instance.SDAConnection;
|
||||
[COMMANDNAME].Transaction = UserContext.Instance.SDATransaction;
|
||||
[else]
|
||||
[COMMANDNAME].Connection = UserContext.Instance.DBConnection;
|
||||
[if ([DBTYPE] != "ODP")]
|
||||
[COMMANDNAME].Transaction = UserContext.Instance.Transaction;
|
||||
[end if]
|
||||
[end if]
|
||||
end template
|
||||
|
||||
|
||||
//***************************************************************************//
|
||||
// Visszaadja a megadott típusnak megfelelő adatbázistípus nevét a C# nyelv //
|
||||
// és a .NET keretrendszernek megfelelően. Ez adatbázisonként más. //
|
||||
//***************************************************************************//
|
||||
proc GetCSharpDatasetType(type, isunicode)
|
||||
switch ([DBTYPE])
|
||||
case "SDA":
|
||||
switch(ToLower([type]))
|
||||
case "string":
|
||||
if ([isunicode] == "true")
|
||||
return "SDA.DataProvider.SDADBType.String";
|
||||
else
|
||||
return "SDA.DataProvider.SDADBType.NonUnicodeString";
|
||||
end if
|
||||
case "integer": return "SDA.DataProvider.SDADBType.Int";
|
||||
case "datetime": return "SDA.DataProvider.SDADBType.DateTime";
|
||||
case "boolean": return "SDA.DataProvider.SDADBType.Boolean /* Boolean */";
|
||||
case "dictionaryitem": return "SDA.DataProvider.SDADBType.Int /* DictionaryItem */";
|
||||
case "binary": return "SDA.DataProvider.SDADBType.Binary /* Binary */";
|
||||
case "float": return "SDA.DataProvider.SDADBType.Double";
|
||||
case "char": return "SDA.DataProvider.SDADBType.Char";
|
||||
case "id": return "SDA.DataProvider.SDADBType.Int";
|
||||
case "longstring": return "SDA.DataProvider.SDADBType.LongString";
|
||||
case "guid": return "SDA.DataProvider.SDADBType.Guid";
|
||||
|
||||
end switch
|
||||
return "0 /* ERROR Ismeretlen tipus: " [type] " */";
|
||||
case "UniDirect":
|
||||
switch(ToLower([type]))
|
||||
case "string": return "System.Data.DbType.String";
|
||||
case "integer": return "System.Data.DbType.Int32";
|
||||
case "datetime": return "System.Data.DbType.DateTime";
|
||||
case "boolean": return "System.Data.DbType.Boolean";
|
||||
case "dictionaryitem": return "System.Data.DbType.Int32 /* DictionaryItem */";
|
||||
case "binary": return "System.Data.DbType.Binary /* Binary */";
|
||||
case "float": return "System.Data.DbType.Double";
|
||||
case "char": return "System.Data.DbType.StringFixedLength";
|
||||
case "id": return "System.Data.DbType.Int32";
|
||||
end switch
|
||||
return "0 /* ERROR Ismeretlen tipus: " [type] " */";
|
||||
case "ODP":
|
||||
switch(ToLower([type]))
|
||||
case "string": return "Oracle.DataAccess.Client.OracleDbType.Varchar2";
|
||||
case "integer": return "Oracle.DataAccess.Client.OracleDbType.Int32";
|
||||
case "datetime": return "Oracle.DataAccess.Client.OracleDbType.Date";
|
||||
case "boolean": return "Oracle.DataAccess.Client.OracleDbType.Char";
|
||||
case "dictionaryitem": return "Oracle.DataAccess.Client.OracleDbType.Int32 /* DictionaryItem */";
|
||||
case "binary": return "Oracle.DataAccess.Client.OracleDbType.Raw /* Binary */";
|
||||
case "float": return "Oracle.DataAccess.Client.OracleDbType.Double";
|
||||
case "char": //return "Oracle.DataAccess.Client.OracleDbType.Char";
|
||||
return "Oracle.DataAccess.Client.OracleDbType.Varchar2";
|
||||
case "id": return "Oracle.DataAccess.Client.OracleDbType.Int32";
|
||||
end switch
|
||||
return "0 /* ERROR Ismeretlen tipus: " [type] " */";
|
||||
case "OracleClient":
|
||||
switch(ToLower([type]))
|
||||
case "string": return "System.Data.OracleClient.OracleType.VarChar";
|
||||
case "integer": return "System.Data.OracleClient.OracleType.Number";
|
||||
case "datetime": return "System.Data.OracleClient.OracleType.DateTime";
|
||||
case "boolean": return "System.Data.OracleClient.OracleType.Char";
|
||||
case "dictionaryitem": return "System.Data.OracleClient.OracleType.Number /* DictionaryItem */";
|
||||
case "binary": return "System.Data.OracleClient.OracleType.Raw /* Binary */";
|
||||
case "float": return "System.Data.OracleClient.OracleType.Float";
|
||||
case "char": return "System.Data.OracleClient.OracleType.Char";
|
||||
case "id": return "System.Data.OracleClient.OracleType.Number";
|
||||
end switch
|
||||
return "System.Data.SqlDbType.Variant /* ERROR Ismeretlen tipus: " [type] " */";
|
||||
end switch
|
||||
|
||||
return "/* Érvénytelen adatbázistípus: " [DBTYPE] " */";
|
||||
end proc
|
||||
|
||||
|
||||
//***************************************************************************//
|
||||
// Visszaadja az adatbázisspecifikus C# ID típus nevét. Ez adatbázisonként //
|
||||
// más. //
|
||||
//***************************************************************************//
|
||||
proc GetCSharpSQLIDType()
|
||||
switch ([DBTYPE])
|
||||
case "SDA": return "SDA.DataProvider.SDADBType.Int";
|
||||
case "UniDirect": return "System.Data.DbType.Int32";
|
||||
case "ODP": return "Oracle.DataAccess.Client.OracleDbType.Int32";
|
||||
case "OracleClient": return "System.Data.OracleClient.OracleType.Number";
|
||||
end switch
|
||||
return "/* Érvénytelen adatbázistípus: " [DBTYPE] " */";
|
||||
end proc
|
||||
|
||||
|
||||
//***************************************************************************//
|
||||
// Visszaadja az adatbázisspecifikus C# ROWID típus nevét. Ez //
|
||||
// adatbázisonként más. //
|
||||
//***************************************************************************//
|
||||
proc GetCSharpSQLRowIDType()
|
||||
switch ([DBTYPE])
|
||||
case "SDA": return "SDA.DataProvider.SDADBType.String";
|
||||
case "UniDirect": return "System.Data.DbType.String";
|
||||
case "ODP": return "Oracle.DataAccess.Client.OracleDbType.Varchar2";
|
||||
case "OracleClient": return "System.Data.OracleClient.OracleType.VarChar";
|
||||
end switch
|
||||
return "/* Érvénytelen adatbázistípus: " [DBTYPE] " */";
|
||||
end proc
|
||||
|
||||
|
||||
//***************************************************************************//
|
||||
// Visszaadja az adatbázisspecifikus C# DBCommand típus nevét. Ez //
|
||||
// adatbázisonként más. //
|
||||
//***************************************************************************//
|
||||
proc GetCSharpSQLCommandType()
|
||||
switch ([DBTYPE])
|
||||
case "SDA": return "SDA.DataProvider.SDACommand";
|
||||
case "UniDirect": return "CoreLab.UniDirect.UniCommand";
|
||||
case "ODP": return "Oracle.DataAccess.Client.OracleCommand";
|
||||
case "OracleClient": return "System.Data.OracleClient.OracleCommand";
|
||||
end switch
|
||||
return "/* Érvénytelen adatbázistípus: " [DBTYPE] " */";
|
||||
end proc
|
||||
|
||||
|
||||
//***************************************************************************//
|
||||
// Visszaadja az adatbázisspecifikus C# CommandParameter típus nevét. Ez //
|
||||
// adatbázisonként más. //
|
||||
//***************************************************************************//
|
||||
proc GetCSharpSQLCommandParameterType()
|
||||
switch ([DBTYPE])
|
||||
case "SDA": return "SDA.DataProvider.SDACommandParameter";
|
||||
case "UniDirect": return "CoreLab.UniDirect.UniParameter";
|
||||
case "ODP": return "Oracle.DataAccess.Client.OracleParameter";
|
||||
case "OracleClient": return "System.Data.OracleClient.OracleParameter";
|
||||
end switch
|
||||
return "/* Érvénytelen adatbázistípus: " [DBTYPE] " */";
|
||||
end proc
|
||||
|
||||
|
||||
//***************************************************************************//
|
||||
// Visszaadja az adatbázisspecifikus C# DBConnection típus nevét. Ez //
|
||||
// adatbázisonként más. //
|
||||
//***************************************************************************//
|
||||
proc GetCSharpSQLConnectionType()
|
||||
switch ([DBTYPE])
|
||||
case "SDA": return "SDA.DataProvider.SDAConnection";
|
||||
case "UniDirect": return "CoreLab.UniDirect.UniConnection";
|
||||
case "ODP": return "Oracle.DataAccess.Client.OracleConnection";
|
||||
case "OracleClient": return "System.Data.OracleClient.OracleConnection";
|
||||
end switch
|
||||
return "/* Érvénytelen adatbázistípus: " [DBTYPE] " */";
|
||||
end proc
|
||||
|
||||
|
||||
//***************************************************************************//
|
||||
// Visszaadja az adatbázisspecifikus C# Transaction típus nevét. Ez //
|
||||
// adatbázisonként más. //
|
||||
//***************************************************************************//
|
||||
proc GetCSharpSQLTransactionType()
|
||||
switch ([DBTYPE])
|
||||
case "SDA": return "SDA.DataProvider.SDATransaction";
|
||||
case "UniDirect": return "CoreLab.UniDirect.UniTransaction";
|
||||
case "ODP": return "Oracle.DataAccess.Client.OracleTransaction";
|
||||
case "OracleClient": return "System.Data.OracleClient.OracleTransaction";
|
||||
end switch
|
||||
return "/* Érvénytelen adatbázistípus: " [DBTYPE] " */";
|
||||
end proc
|
||||
|
||||
|
||||
//***************************************************************************//
|
||||
// Visszaadja az adatbázisspecifikus C# DataReader típus nevét. Ez //
|
||||
// adatbázisonként más. //
|
||||
//***************************************************************************//
|
||||
proc GetCSharpSQLDataReaderType()
|
||||
switch ([DBTYPE])
|
||||
case "SDA": return "SDA.DataProvider.SDADataReader";
|
||||
case "UniDirect": return "CoreLab.UniDirect.UniDataReader";
|
||||
case "ODP": return "Oracle.DataAccess.Client.OracleDataReader";
|
||||
case "OracleClient": return "System.Data.OracleClient.OracleDataReader";
|
||||
end switch
|
||||
return "/* Érvénytelen adatbázistípus: " [DBTYPE] " */";
|
||||
end proc
|
||||
|
||||
|
||||
//***************************************************************************//
|
||||
// Visszaadja egy művelethez tartozó SQL parancsobjektum nevét. //
|
||||
//***************************************************************************//
|
||||
proc ConvertNameToCommandName(operation)
|
||||
return [operation] "Command";
|
||||
end proc
|
||||
|
||||
|
||||
//***************************************************************************//
|
||||
// Visszaadja egy művelethez tartozó SQL parancsobjektum //
|
||||
// megcsinálómetódusának a nevét. //
|
||||
//***************************************************************************//
|
||||
proc GenerateCommandCreatorName(CommandName)
|
||||
return "Create" [CommandName] "Command";
|
||||
end proc
|
||||
|
||||
|
||||
//***************************************************************************//
|
||||
// Egy SQL parancs típusú property-t generál. //
|
||||
//***************************************************************************//
|
||||
template GenerateCommandGetterProperty(COMMANDNAME)
|
||||
[if ([COMMANDCACHE] == "True")]
|
||||
private [GetCSharpSQLCommandType()] m_[ConvertNameToCommandName([COMMANDNAME])] = null;
|
||||
[end if]
|
||||
private [GetCSharpSQLCommandType()] [ConvertNameToCommandName([COMMANDNAME])]
|
||||
{
|
||||
get
|
||||
{
|
||||
[if ([COMMANDCACHE] == "True")]
|
||||
if (this.m_[ConvertNameToCommandName([COMMANDNAME])] == null)
|
||||
{
|
||||
this.m_[ConvertNameToCommandName([COMMANDNAME])] = this.[GenerateCommandCreatorName([COMMANDNAME])]();
|
||||
}
|
||||
|
||||
return this.m_[ConvertNameToCommandName([COMMANDNAME])];
|
||||
[else]
|
||||
return this.[GenerateCommandCreatorName([COMMANDNAME])]();
|
||||
[end if]
|
||||
}
|
||||
}
|
||||
end template
|
||||
|
||||
|
||||
//***************************************************************************//
|
||||
// Legenerálja egy entitás SERIAL rendszeroszlopának SQL töredékét, teljesen //
|
||||
// minősített névvel. //
|
||||
//***************************************************************************//
|
||||
template GenerateSerialColumn(MClass as ENTITY)
|
||||
[if (IsMasterEntity([ENTITY]) == "false")]
|
||||
[loop (ENTITY -> SuperClass as BASECLASS)]
|
||||
[GenerateSerialColumn([BASECLASS])][break]
|
||||
[end loop]
|
||||
[else]
|
||||
[ConvertNameToSQLTableName([ENTITY.name])].SERIAL
|
||||
[end if]
|
||||
end template
|
||||
|
||||
|
||||
//***************************************************************************//
|
||||
// Legenerálja azt a kóddarabot, ami egy command obejktum inicializálását //
|
||||
// végzi. Ez adatbázisonként más. Szükség esetén a szűréket is réteszi az //
|
||||
// SQL parancsszövegre. //
|
||||
//***************************************************************************//
|
||||
template GenerateCommandInitialization(COMMANDNAME, COMMANDTEXTNAME, ENTITYNAME, OPERATIONNAME, APPLYFILTERS, MASTERNAME)
|
||||
[if ([DBTYPE] == "SDA")]
|
||||
[COMMANDNAME].Connection = UserContext.Instance.SDAConnection;
|
||||
[COMMANDNAME].Transaction = UserContext.Instance.SDATransaction;
|
||||
[if ([APPLYFILTERS] == "False")]
|
||||
[COMMANDNAME].CommandText = [ConvertNameToCommandTextName([COMMANDTEXTNAME])];
|
||||
[else]
|
||||
[COMMANDNAME].CommandText = [ConvertNameToCommandTextName([COMMANDTEXTNAME])];
|
||||
Kreta.Framework.FilterApplier.ApplyFilters([COMMANDNAME], "[ENTITYNAME]", "[MASTERNAME]");
|
||||
[end if]
|
||||
[else]
|
||||
[COMMANDNAME].Connection = UserContext.Instance.DBConnection;
|
||||
[if ([DBTYPE] != "ODP")]
|
||||
[COMMANDNAME].Transaction = UserContext.Instance.Transaction;
|
||||
[end if]
|
||||
[if ([APPLYFILTERS] == "False")]
|
||||
[COMMANDNAME].CommandText = [ConvertNameToCommandTextName([COMMANDTEXTNAME])];
|
||||
[else]
|
||||
[COMMANDNAME].CommandText = [ConvertNameToCommandTextName([COMMANDTEXTNAME])];
|
||||
Kreta.Framework.FilterApplier.ApplyFilters([COMMANDNAME], "[ENTITYNAME]", "[MASTERNAME]");
|
||||
[end if]
|
||||
[end if]
|
||||
end template
|
||||
|
||||
|
||||
////***************************************************************************////
|
||||
////***************************************************************************////
|
||||
////***************************************************************************////
|
||||
//// ////
|
||||
//// Valószínüleg már nem használt kód ////
|
||||
//// ////
|
||||
////***************************************************************************////
|
||||
////***************************************************************************////
|
||||
////***************************************************************************////
|
||||
|
||||
|
||||
|
||||
|
||||
//***************************************************************************//
|
||||
// Megjegyzés? //
|
||||
//***************************************************************************//
|
||||
template GenerateDuoSelectWhere(MClass as CurrentClass, MAssociationEnd as StartRole, MAssociation as CurrentAssoc, MAssociationEnd as EndRole, MClass as PartnerClass, MClass as AssocClass)
|
||||
"([ConvertNameToSQLTableName([AssocClass.name])].[ConvertNameToSQLColumnName(ConvertRoleToName([StartRole]))] = [ConvertNameToSQLParamName(ConvertRoleToName([StartRole]))]) " +
|
||||
[if (IsMasterEntity([PartnerClass]) == "true")]
|
||||
"and ([ConvertNameToSQLTableName([PartnerClass.name])].ID = [ConvertNameToSQLTableName([AssocClass.name])].[ConvertNameToSQLColumnName(ConvertRoleToName([EndRole]))])"
|
||||
[else]
|
||||
"and ([ConvertNameToSQLTableName([PartnerClass.name])].ID = [ConvertNameToSQLTableName([AssocClass.name])].[ConvertNameToSQLColumnName(ConvertRoleToName([EndRole]))]) " +
|
||||
"and " +
|
||||
[SDA_GetSuperClassSelectFilter([PartnerClass])]
|
||||
[end if]
|
||||
end template
|
||||
|
||||
|
||||
//***************************************************************************//
|
||||
// Megjegyzés? //
|
||||
//***************************************************************************//
|
||||
template GenerateDuoSelectFrom(MClass as CurrentClass, MAssociationEnd as StartRole, MAssociation as CurrentAssoc, MAssociationEnd as EndRole, MClass as PartnerClass, MClass as AssociationClass)
|
||||
[/*
|
||||
"[ConvertNameToSQLTableName([AssociationClass.name])], " +
|
||||
"[ConvertNameToSQLTableName([PartnerClass.name])] " +
|
||||
*/]
|
||||
"[GenerateSuperClassTableList([AssociationClass])], " +
|
||||
"[GenerateSuperClassTableList([PartnerClass])] " +
|
||||
end template
|
||||
|
||||
|
||||
//***************************************************************************//
|
||||
// Megjegyzés? //
|
||||
//***************************************************************************//
|
||||
proc SDA_GetFieldLength(MAttribute)
|
||||
local result;
|
||||
[result] = GetAttributeLength([MAttribute]);
|
||||
if ([result] != "")
|
||||
[result] = ", " [result];
|
||||
end if
|
||||
return [result];
|
||||
end proc
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
61
Tools/CodeGeneration/Templates/Common/DBUtil.tdl
Normal file
61
Tools/CodeGeneration/Templates/Common/DBUtil.tdl
Normal file
|
|
@ -0,0 +1,61 @@
|
|||
//***************************************************************************//
|
||||
// SQL table script formázott fejlézének elkészítéséhez használt függvény. //
|
||||
// a paraméterként kapott stringet kiegészíti 75 karakter hosszúra spacekkel //
|
||||
//***************************************************************************//
|
||||
proc FormatSQLHeader(str)
|
||||
return CompleteString( [str],75," ","post");
|
||||
end proc
|
||||
|
||||
|
||||
//***************************************************************************//
|
||||
// Az SQL table script oszlop kényszer értékét formázza meg //
|
||||
//***************************************************************************//
|
||||
proc FormatSQLColumnModifier(str)
|
||||
return [str];
|
||||
end proc
|
||||
|
||||
|
||||
//***************************************************************************//
|
||||
// Az SQL table script oszlop típus értékét formázza meg //
|
||||
//***************************************************************************//
|
||||
proc FormatSQLColumnType(str)
|
||||
return CompleteString( [str],32," ","post");
|
||||
end proc
|
||||
|
||||
|
||||
//***************************************************************************//
|
||||
// Az SQL table script oszlop név értékét formázza meg //
|
||||
//***************************************************************************//
|
||||
proc FormatColumnName(str)
|
||||
return CompleteString( [str],33," ","post");
|
||||
end proc
|
||||
|
||||
|
||||
//***************************************************************************//
|
||||
// Az DROP TABLE <TÁBLANÉV> utáni részt adja vissza. //
|
||||
//***************************************************************************//
|
||||
proc GetDropTableOptions()
|
||||
switch ( [SQL_DBType])
|
||||
//ORACLE Type
|
||||
case "ORACLE" :
|
||||
return "cascade constraints";
|
||||
case "MSSQL" :
|
||||
return "";
|
||||
case "DB2" :
|
||||
return "";
|
||||
end switch
|
||||
end proc
|
||||
|
||||
|
||||
//***************************************************************************//
|
||||
// A paraméterként megadott elemhez tartozo Constraint értékét adja vissza //
|
||||
//***************************************************************************//
|
||||
proc getConstraint(MSemElement)
|
||||
loop(MSemElement->Note where [Note.type] == "UmlExtensibilityDefinition")
|
||||
loop(Note->Item where [Item.type] == "UmlConstraintItem")
|
||||
return [Item.value];
|
||||
end loop
|
||||
end loop
|
||||
return "";
|
||||
end proc
|
||||
|
||||
73
Tools/CodeGeneration/Templates/Common/ModelDataRetreive.tdl
Normal file
73
Tools/CodeGeneration/Templates/Common/ModelDataRetreive.tdl
Normal file
|
|
@ -0,0 +1,73 @@
|
|||
//***************************************************************************//
|
||||
// Megmondja egy osztályról, hogy entitásból származik-e vagy sem //
|
||||
// visszatérési értékei [true | false] //
|
||||
//***************************************************************************//
|
||||
proc IsMasterEntity(MClass)
|
||||
loop (MClass -> SuperClass as super)
|
||||
if ( GetStereoType([super]) == "Entity" )
|
||||
return "false";
|
||||
else
|
||||
return "true";
|
||||
end if
|
||||
end loop
|
||||
return "true";
|
||||
end proc
|
||||
|
||||
|
||||
//***************************************************************************//
|
||||
// visszaadja az attribútumhoz megadott taggedvalue értékét //
|
||||
//***************************************************************************//
|
||||
proc GetTaggedValueOfAttribute(MAttribute, taggedvaluename)
|
||||
local taggedvalue = "";
|
||||
loop (MAttribute -> TaggedValue Where toLower([TaggedValue.tag])==toLower([taggedvaluename]))
|
||||
[taggedvalue] = [TaggedValue.value];
|
||||
end loop
|
||||
|
||||
return [taggedvalue];
|
||||
end proc
|
||||
|
||||
|
||||
//***************************************************************************//
|
||||
// visszaadja a megadott típusnévhez tartozó megadott taggedvalue értékért //
|
||||
//***************************************************************************//
|
||||
proc 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
|
||||
end proc
|
||||
|
||||
|
||||
//***************************************************************************//
|
||||
// Meghatározza, hogy a paraméterként kapott asszociációhoz tartozik-e //
|
||||
// asszociációs osztály, ha igen akkor az asszociációs osztály azonosítóját //
|
||||
// adja vissza, egyébként üres sztringet. //
|
||||
//***************************************************************************//
|
||||
proc HasAssociationClass(MAssociation as Ass)
|
||||
loop(Ass -> AssociationClass)
|
||||
return [AssociationClass.id];
|
||||
end loop
|
||||
return "";
|
||||
end proc
|
||||
|
||||
|
||||
//***************************************************************************//
|
||||
// Listában adja vissza a modelben definiált tipizált dictionary Item //
|
||||
// típusokat //
|
||||
//***************************************************************************//
|
||||
proc GetDictionaryItemTypes()
|
||||
if ([DI_CACHEINITIALIZED] == "true")
|
||||
return [DI_CACHE];
|
||||
end if
|
||||
local dictitems = "";
|
||||
loop (Instances -> MClass Where(GetStereoType([MClass]) == "Entity" ) )
|
||||
loop( MClass -> MAttribute Where ([MAttribute.type] == "DictionaryItem"))
|
||||
[dictitems] = AddDistinctValueToTokenSet([dictitems], [MAttribute.defaultValue]);
|
||||
end loop
|
||||
end loop
|
||||
[DI_CACHE] = [dictitems];
|
||||
[DI_CACHEINITIALIZED] = "true";
|
||||
return [dictitems];
|
||||
end proc
|
||||
|
||||
99
Tools/CodeGeneration/Templates/Common/PascalUtil.tdl
Normal file
99
Tools/CodeGeneration/Templates/Common/PascalUtil.tdl
Normal file
|
|
@ -0,0 +1,99 @@
|
|||
//***************************************************************************//
|
||||
// Visszaadja egy művelet paraméterlistáját ay Object Pascal nyelv //
|
||||
// szintaktikájának és a saját jelölésbeli konvencióinknak megfelelően. //
|
||||
//***************************************************************************//
|
||||
proc GetPascalOperationParameters(MOperation as OPERATION)
|
||||
local ops;
|
||||
[ops] = "";
|
||||
loop (OPERATION -> OpPara as PARAMETER; setDelim(""); setDelim("; "))
|
||||
[ops] = [ops] delim() ToLower([PARAMETER.name]) ": " GetPascalType([PARAMETER.type]);
|
||||
end loop
|
||||
return [ops];
|
||||
end proc
|
||||
|
||||
|
||||
//***************************************************************************//
|
||||
// Pascal kommentet gyárt egy karakterláncból. //
|
||||
//***************************************************************************//
|
||||
template ConvertDescriptionToPascalComment(description)
|
||||
[if ([description] == "")]
|
||||
{
|
||||
nincs megjegyzés
|
||||
}
|
||||
[else]
|
||||
{
|
||||
[replace([description], "", "\n ")]
|
||||
}
|
||||
[end if]
|
||||
end template
|
||||
|
||||
|
||||
//***************************************************************************//
|
||||
// Pascal kommentet gyárt egy karakterláncból. //
|
||||
//***************************************************************************//
|
||||
template ConvertDescriptionToPascalSummary(description)
|
||||
[if ([description] == "")]
|
||||
(*
|
||||
* Nincs megjegyzés
|
||||
*)
|
||||
[else]
|
||||
(*
|
||||
* [replace([description], "", "\n * ")]
|
||||
*)
|
||||
[end if]
|
||||
end template
|
||||
|
||||
|
||||
//***************************************************************************//
|
||||
// Visszadja a megadott típushoz tartozó pascal tipust. //
|
||||
//***************************************************************************//
|
||||
proc GetPascalType(type)
|
||||
switch(ToLower([type]))
|
||||
case "integer": return "integer";
|
||||
case "string": return "string";
|
||||
case "boolean": return "boolean";
|
||||
case "float": return "double";
|
||||
case "char": return "char";
|
||||
case "datetime": return "TDateTime";
|
||||
case "id": return "integer";
|
||||
case "binary": return "TBase64String";
|
||||
case "dictionaryitem": return "integer";
|
||||
case "dataset": return "string";
|
||||
case "object": return "TXMLString";
|
||||
case "longstring": return "string";
|
||||
end switch
|
||||
return "TObject { ERROR Ismeretlen tipus: " [type] " }";
|
||||
end proc
|
||||
|
||||
|
||||
//***************************************************************************//
|
||||
// Visszaadja a megadott típus alapértelmezett (kezdeti) értékét a pascal //
|
||||
// nyelv szintaktikájának megfelelően. //
|
||||
//***************************************************************************//
|
||||
proc GetPascalDefaultValueOfType(type)
|
||||
switch(ToLower([type]))
|
||||
case "integer": return "-1";
|
||||
case "string": return "''";
|
||||
case "boolean": return "false";
|
||||
case "float": return "0";
|
||||
case "char": return "''";
|
||||
case "datetime": return "Now";
|
||||
case "id": return "-1";
|
||||
case "binary": return "''";
|
||||
case "dictionaryitem": return "-1";
|
||||
case "dataset": return "''";
|
||||
case "object": return "''";
|
||||
case "longstring": return "''";
|
||||
end switch
|
||||
return "nil { ERROR Ismeretlen tipus: " [type] " }";
|
||||
end proc
|
||||
|
||||
|
||||
//***************************************************************************//
|
||||
// Osztály nevéből pascal unit nevet generál a konvencióinknak megfelelően. //
|
||||
//***************************************************************************//
|
||||
proc GenerateUnitName(classname)
|
||||
return "u" [classname];
|
||||
end proc
|
||||
|
||||
|
||||
112
Tools/CodeGeneration/Templates/Common/ProviderUtil.tdl
Normal file
112
Tools/CodeGeneration/Templates/Common/ProviderUtil.tdl
Normal file
|
|
@ -0,0 +1,112 @@
|
|||
//***************************************************************************//
|
||||
// Visszaadja egy attribútumról, hogy kötelező-e. //
|
||||
// True, ha igen; egyébként False. //
|
||||
//***************************************************************************//
|
||||
proc IsRequired(MAttribute)
|
||||
return IsAttributeRequired([MAttribute]);
|
||||
end proc
|
||||
|
||||
|
||||
//***************************************************************************//
|
||||
// Visszaadja egy asszociációs végpontról, hogy navigálható-e. //
|
||||
// True, ha igen; egyébként False. //
|
||||
//***************************************************************************//
|
||||
proc IsNavigable(MAssociationEnd)
|
||||
if ([MAssociationEnd.isNavigable] == "TRUE")
|
||||
return "True";
|
||||
else
|
||||
return "False";
|
||||
end if
|
||||
end proc
|
||||
|
||||
|
||||
//***************************************************************************//
|
||||
// Visszaadja egy attribútumról, hogy csak alapértéket lehet neki értékül //
|
||||
// adni, vagy sem. //
|
||||
// True, ha igen; egyébként False. //
|
||||
//***************************************************************************//
|
||||
proc IsDefaultOnly(MAttribute)
|
||||
return IsDefaultonlyAttribute([MAttribute]);
|
||||
end proc
|
||||
|
||||
|
||||
//***************************************************************************//
|
||||
// Visszaadja egy attribútumról, hogy csak olvasható-e vagy sem. //
|
||||
//***************************************************************************//
|
||||
proc IsReadOnly(MAttribute)
|
||||
return IsReadonlyAttribute([MAttribute]);
|
||||
end proc
|
||||
|
||||
|
||||
//***************************************************************************//
|
||||
// UML típust konvertál a Delphi-s TClientDataset XML formátumában megadandó //
|
||||
// típusra. //
|
||||
//***************************************************************************//
|
||||
proc GetMidasType(type)
|
||||
switch(ToLower([type]))
|
||||
case "integer": return "i4";
|
||||
case "string": return "string.uni";
|
||||
case "boolean": return "boolean";
|
||||
case "float": return "r8"; // XXX
|
||||
case "char": return "string.uni"; // XXX
|
||||
case "datetime": return "dateTime";
|
||||
case "id": return "i4";
|
||||
case "binary": return "bin.hex\" SUBTYPE=\"Binary";
|
||||
case "dictionaryitem": return "i4";
|
||||
case "longstring": return "bin.hex\" SUBTYPE=\"Binary"; // XXX
|
||||
end switch
|
||||
return "object /* ERROR Ismeretlen tipus: " [type] " */";
|
||||
end proc
|
||||
|
||||
|
||||
//***************************************************************************//
|
||||
// Megdupláz egy számot. //
|
||||
//***************************************************************************//
|
||||
proc GetDoubleValue(value)
|
||||
return add([value], [value]);
|
||||
end proc
|
||||
|
||||
|
||||
//***************************************************************************//
|
||||
// Visszaadja egy attribútum hosszát a Delphi-s TClientDataSet-nek //
|
||||
// megfelelően. //
|
||||
//***************************************************************************//
|
||||
proc GetMidasAttributeLength(MAttribute)
|
||||
if (([MAttribute.type] == "String") or ([MAttribute.type] == "Char"))
|
||||
return add(GetAttributeLength([MAttribute]), GetAttributeLength([MAttribute]));
|
||||
else
|
||||
return GetAttributeLength([MAttribute]);
|
||||
end if
|
||||
end proc
|
||||
|
||||
|
||||
//***************************************************************************//
|
||||
// Generál egy Delphi-s karakterláncot, ami felsorolja egy adott entitás //
|
||||
// összes ősosztályát, $ -ral elválasztva. (homlokzat) //
|
||||
//***************************************************************************//
|
||||
template GenerateSuperProviderString(MClass as ENTITY)
|
||||
[if (IsMasterEntity([ENTITY]) == "false")]
|
||||
[loop (ENTITY -> SuperClass as BASECLASS)]
|
||||
[GenerateSuperProviderStringCore([ENTITY])][break]
|
||||
[end loop]
|
||||
[end if]
|
||||
''
|
||||
end template
|
||||
|
||||
|
||||
//***************************************************************************//
|
||||
// Generál egy Delphi-s karakterláncot, ami felsorolja egy adott entitás //
|
||||
// összes ősosztályát, $ -ral elválasztva. (mag) //
|
||||
// //
|
||||
// REKURZÍV! //
|
||||
//***************************************************************************//
|
||||
template GenerateSuperProviderStringCore(MClass as ENTITY)
|
||||
[if (IsMasterEntity([ENTITY]) == "false")]
|
||||
[loop (ENTITY -> SuperClass as BASECLASS)]
|
||||
'$[BASECLASS.name]' +
|
||||
[GenerateSuperProviderStringCore([BASECLASS])][break]
|
||||
[end loop]
|
||||
[end if]
|
||||
end template
|
||||
|
||||
|
||||
85
Tools/CodeGeneration/Templates/Common/StringUtil.tdl
Normal file
85
Tools/CodeGeneration/Templates/Common/StringUtil.tdl
Normal file
|
|
@ -0,0 +1,85 @@
|
|||
//***************************************************************************//
|
||||
//A kapott sztring első betűjét nagybetűvé alakítja. //
|
||||
//***************************************************************************//
|
||||
tcl_proc ToUpperFirst(str)
|
||||
return [string toupper [string index $str 0]][string range $str 1 end];
|
||||
end proc
|
||||
|
||||
|
||||
//***************************************************************************//
|
||||
//A kapott sztring első betűjét kisbetűvé alakítja. //
|
||||
//***************************************************************************//
|
||||
tcl_proc ToLowerFirst(str)
|
||||
return [string tolower [string index $str 0]][string range $str 1 end];
|
||||
end proc
|
||||
|
||||
|
||||
//***************************************************************************//
|
||||
// A kapott sztringet nagybetűssé alakítja. //
|
||||
//***************************************************************************//
|
||||
tcl_proc ToUpper(str)
|
||||
return [string toupper [string range $str 0 end]];
|
||||
end proc
|
||||
|
||||
|
||||
//***************************************************************************//
|
||||
// A kapott sztringet kisbetűssé alakítja. //
|
||||
//***************************************************************************//
|
||||
tcl_proc ToLower(str)
|
||||
return [string tolower [string range $str 0 end]];
|
||||
end proc
|
||||
|
||||
|
||||
//***************************************************************************//
|
||||
// Levágja a paraméterként kapott string jobb oldalát, úgy hogy a string //
|
||||
// a paraméterben kapott hosszúságú legyen. Ha a string röveidebb volt, mint //
|
||||
// a paraméterként megadott érték, akkor változatlan marad a string. //
|
||||
//***************************************************************************//
|
||||
tcl_proc TruncateString(str, length)
|
||||
return [string range $str 0 $length]
|
||||
end proc
|
||||
|
||||
|
||||
//***************************************************************************//
|
||||
// kiegészít egy sztringet töltelék karakterrel, hogy a string megadott //
|
||||
// hosszúságú legyen. //
|
||||
// str: a bejövő string //
|
||||
// length: a kivánt hossz //
|
||||
// delimitter: a töltelék karakter //
|
||||
// pos: string elé vagy mögé rakja a töltelék karaktereket //
|
||||
// értékei: [pre|post] //
|
||||
//***************************************************************************//
|
||||
tcl_proc CompleteString(str,length, delimitter, pos)
|
||||
set strLength [string length $str];
|
||||
|
||||
set res ""
|
||||
set dl $delimitter
|
||||
|
||||
if {$strLength >= $length } {
|
||||
return $str
|
||||
} else {
|
||||
while {$strLength < $length} {
|
||||
set res $res$dl
|
||||
incr strLength
|
||||
}
|
||||
}
|
||||
|
||||
if {$pos == "pre"} {
|
||||
return $res$str
|
||||
} else {
|
||||
if {$pos == "post"} {
|
||||
return $str$res
|
||||
}
|
||||
}
|
||||
end proc
|
||||
|
||||
|
||||
//***************************************************************************//
|
||||
// UID_xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx formátumú GUID-ból //
|
||||
// xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx formátumú GUID-ot csinál. //
|
||||
// gyk: levágja az elejét //
|
||||
//***************************************************************************//
|
||||
tcl_proc TrimGUID(str)
|
||||
return [string range $str 4 end];
|
||||
end proc
|
||||
|
||||
334
Tools/CodeGeneration/Templates/Common/std.tdl
Normal file
334
Tools/CodeGeneration/Templates/Common/std.tdl
Normal file
|
|
@ -0,0 +1,334 @@
|
|||
//*****************************************************************************
|
||||
// $RCSfile: std.tdl,v $
|
||||
// $Revision: 1.2 $
|
||||
// $Date: 2002/03/08 15:54:33 $
|
||||
// Author: Markus Kern
|
||||
//*****************************************************************************
|
||||
/*
|
||||
Contains language independent procedures and templates. These are used by the
|
||||
language dependent code generators.
|
||||
See the documentation for a description of these procedures and templates
|
||||
*/
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
proc setCount(count)
|
||||
[__COUNT__] = [count];
|
||||
end proc
|
||||
|
||||
proc addCount(number)
|
||||
[__COUNT__] = add([__COUNT__],[number]);
|
||||
end proc
|
||||
|
||||
proc getCount()
|
||||
return [__COUNT__];
|
||||
end proc
|
||||
|
||||
proc setDelim(delim)
|
||||
[__DELIM__] = [delim];
|
||||
end proc
|
||||
|
||||
proc delim()
|
||||
return [__DELIM__];
|
||||
end proc
|
||||
|
||||
proc setVar(varName, varValue)
|
||||
[[varName]] = [varValue];
|
||||
end proc
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
proc setString(init)
|
||||
[__INIT__] = [init];
|
||||
return [init];
|
||||
end proc
|
||||
|
||||
proc getString()
|
||||
local txt = [__INIT__];
|
||||
[__INIT__] = "";
|
||||
return [txt];
|
||||
end proc
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
tcl_proc add(num1, num2)
|
||||
return [expr $num1 + $num2]
|
||||
end proc
|
||||
|
||||
tcl_proc sub(num1, num2)
|
||||
return [expr $num1 - $num2]
|
||||
end proc
|
||||
|
||||
tcl_proc mul(num1, num2)
|
||||
return [expr $num1 * $num2]
|
||||
end proc
|
||||
|
||||
tcl_proc div(num1, num2)
|
||||
return [expr $num1 / $num2]
|
||||
end proc
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
tcl_proc time()
|
||||
return [clock format [clock seconds] -format "%X"]
|
||||
end proc
|
||||
|
||||
tcl_proc date()
|
||||
return [clock format [clock seconds] -format "%x"]
|
||||
end proc
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
tcl_proc hostname()
|
||||
return [info hostname]
|
||||
end proc
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
tcl_proc replace(str, expr, subSpec)
|
||||
set ret "";
|
||||
regsub -all $expr $str $subSpec ret;
|
||||
return $ret;
|
||||
end proc
|
||||
|
||||
tcl_proc toUpper(str)
|
||||
return [string toupper $str];
|
||||
end proc
|
||||
|
||||
tcl_proc toLower(str)
|
||||
return [string tolower $str];
|
||||
end proc
|
||||
|
||||
tcl_proc getLength(str)
|
||||
return [string length $str];
|
||||
end proc
|
||||
|
||||
tcl_proc lsdir(dir)
|
||||
return [file dirname $dir];
|
||||
end proc
|
||||
|
||||
tcl_proc mkdir(dir)
|
||||
file mkdir $dir;
|
||||
end proc
|
||||
|
||||
tcl_proc dirName(file)
|
||||
set dirName [file dirname $file];
|
||||
if { $dirName == "" } { return "";}
|
||||
set delim "/"
|
||||
return $dirName$delim;
|
||||
end proc
|
||||
|
||||
tcl_proc fileName(file)
|
||||
set fileList [file split $file]
|
||||
return [lindex $fileList [ expr [llength $fileList] - 1]]
|
||||
end proc
|
||||
|
||||
tcl_proc regexp(str,reg)
|
||||
set ret ""
|
||||
regexp $reg $str ret;
|
||||
return $ret;
|
||||
end proc
|
||||
|
||||
tcl_proc createString(str,count)
|
||||
set x 0
|
||||
set ret ""
|
||||
while {$x < $count} {
|
||||
set ret $ret$str
|
||||
incr x
|
||||
}
|
||||
return $ret
|
||||
end proc
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
tcl_proc invIdOrder(list)
|
||||
set invList "";
|
||||
set li [split $list " "];
|
||||
foreach {elem} $li {
|
||||
set invList [concat $elem $invList]
|
||||
}
|
||||
return $invList
|
||||
end proc
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
proc isExternal(MClass)
|
||||
loop(MClass->Note->Item
|
||||
Where [Item.value] == "True" AND [Item.type] == "UmlClassIsImported")
|
||||
return TRUE;
|
||||
end loop
|
||||
return FALSE;
|
||||
end proc
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
proc getStereotype(MSemElement)
|
||||
loop(MSemElement->Stereotype)
|
||||
return [Stereotype.name];
|
||||
end loop
|
||||
end proc
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
proc getMultiplicity(multiplicity)
|
||||
|
||||
switch([multiplicity])
|
||||
case "":
|
||||
case "1":
|
||||
case "0..1":
|
||||
case "1..0":
|
||||
case "0..0":
|
||||
return "One";
|
||||
|
||||
case "*":
|
||||
case "1..*":
|
||||
case "n":
|
||||
case "N":
|
||||
return "Many";
|
||||
|
||||
case regexp([multiplicity],"[0-9]+"):
|
||||
return [multiplicity];
|
||||
|
||||
case regexp([multiplicity],"[0-9]+\.\.[0-9]+"):
|
||||
return split([multiplicity],".","T");
|
||||
|
||||
default:
|
||||
return "Many";
|
||||
|
||||
end switch
|
||||
end proc
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
tcl_proc split(str,delim,pos)
|
||||
|
||||
set li [split $str $delim];
|
||||
switch $pos {
|
||||
"L" {
|
||||
return [lindex $li 0]
|
||||
}
|
||||
|
||||
"T" {
|
||||
return [lindex $li [ expr [llength $li] - 1]]
|
||||
}
|
||||
|
||||
default {
|
||||
return [lindex $li $pos]
|
||||
}
|
||||
}
|
||||
end proc
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
proc setText(init)
|
||||
[__INIT__] = [init];
|
||||
return [init];
|
||||
end proc
|
||||
|
||||
proc getText()
|
||||
local txt = [__INIT__];
|
||||
[__INIT__] = "";
|
||||
return [txt];
|
||||
end proc
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
proc outText(text,delim1,delim2)
|
||||
local ret;
|
||||
loop(Instances->TokenSet([text]);setString([delim1]);setString("\n" [delim2]))
|
||||
[ret] = [ret] getString()[TokenSet.line];
|
||||
end loop
|
||||
return [ret];
|
||||
end proc
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
proc safeOutput(fileName)
|
||||
mkdir(lsdir([fileName]));
|
||||
setOutput([fileName]);
|
||||
|
||||
// This comes last, so that it holds the correct value during the insert/mark fixup process
|
||||
[ACT_OUTPUT_FILE] = [fileName];
|
||||
end proc
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
proc output(fileName)
|
||||
mkdir(lsdir([fileName]));
|
||||
setOutput(dirName([fileName])"_"fileName([fileName]));
|
||||
appendMergeFile([fileName]);
|
||||
|
||||
// This comes last, so that it holds the correct value during the insert/mark fixup process
|
||||
[ACT_OUTPUT_FILE] = [fileName];
|
||||
end proc
|
||||
|
||||
|
||||
proc getOutput()
|
||||
return [ACT_OUTPUT_FILE];
|
||||
end proc
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
proc setLanguage(language)
|
||||
[ACT_LANGUAGE] = [language];
|
||||
end proc
|
||||
|
||||
// Generate the id list for the class(es) with specified name.
|
||||
// Note that we normally expect a single MClass in the list.
|
||||
// This was introduced to improve the code generator performance.
|
||||
proc MClass_ids_by_name (name)
|
||||
|
||||
local x = "MClass_by_name_Cache_For_" [name];
|
||||
|
||||
if ([[x]] == "")
|
||||
loop(Instances -> MClass where [MClass.name] == [name])
|
||||
[[x]] = [[x]] " " [MClass.id];
|
||||
//T info = "MClass_ids_by_name #" [x]" -> "[[x]]"\n";
|
||||
end loop
|
||||
end if
|
||||
|
||||
//T info = "MClass_ids_by_name :" [x]" -> "[[x]]"\n";
|
||||
return [[x]];
|
||||
end proc
|
||||
|
||||
proc getDataType(type)
|
||||
loop(Instances->MClass(MClass_ids_by_name ([type]))->MDataType->TaggedValue
|
||||
Where [TaggedValue.tag] == [ACT_LANGUAGE])
|
||||
return [TaggedValue.value];
|
||||
end loop
|
||||
//info = "MClass_ids_by_name #" [ACT_LANGUAGE] "\n";
|
||||
return [type];
|
||||
end proc
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
template genLines(Lines)
|
||||
[loop(Instances->TokenSet([Lines]))]
|
||||
[TokenSet.line]
|
||||
[end loop]
|
||||
end template
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
proc getUniqueId(MElement)
|
||||
loop (MElement->MSemElement where [MSemElement.guid] != "")
|
||||
return [MSemElement.guid];
|
||||
end loop
|
||||
return [MElement.id];
|
||||
end proc
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
tcl_proc appendMergeFile(fileName)
|
||||
catch {
|
||||
set file [open "_acdGeneratedFiles.mrg" "a"];
|
||||
puts $file $fileName;
|
||||
close $file
|
||||
}
|
||||
end proc
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
tcl_proc delMergeFile()
|
||||
catch {
|
||||
file delete "_acdGeneratedFiles.mrg"
|
||||
}
|
||||
end proc
|
||||
|
||||
// ECR 5664 begin
|
||||
|
||||
tcl_proc substring(text, first, last)
|
||||
return [string range $text $first $last];
|
||||
end proc
|
||||
|
||||
tcl_proc searchstr(text, str, start)
|
||||
variable res
|
||||
set res [string first $str [string range $text $start end]]
|
||||
if {$res == -1} {
|
||||
return -1
|
||||
} else {
|
||||
return [expr $start + $res]
|
||||
}
|
||||
end proc
|
||||
|
||||
// ECR 5664 end
|
||||
Loading…
Add table
Add a link
Reference in a new issue