public void CreateEnumeration(Profile profile, string key) { Class enumeration = new Class(); enumeration.Type = "Class"; profile.ProfileMap[ProfileElementTypes.Class].Add(enumeration); List <string> enums; predifinedEnumerations.TryGetValue(key, out enums); if (enums != null) { foreach (string en in enums) { EnumMember enumerationMember = new EnumMember(); //enumerationMember = new EnumMember(); enumerationMember.URI = "#" + key + "." + en; enumerationMember.Label = en; enumerationMember.EnumerationObject = enumeration; enumeration.AddToMyEnumerationMembers(enumerationMember); } enumeration.URI = "#" + key; enumeration.BelongsToCategory = "#Package_Core"; enumeration.BelongsToCategoryAsObject = profile.FindProfileElementByName(StringManipulationManager.ExtractAllAfterSeparator(enumeration.BelongsToCategory, StringManipulationManager.SeparatorSharp)); ((ClassCategory)profile.FindProfileElementByName(StringManipulationManager.ExtractAllAfterSeparator(enumeration.BelongsToCategory, StringManipulationManager.SeparatorSharp))).AddToMembersOfClassCategory(enumeration); } }
/// <summary> /// Method first tries to find the ProfileElementStereotype object with given fullName isInside the /// (static) StereotypeList, and if it doesn't find it, it creates new stereotype objects /// and adds it to this list. /// <remarks>If the fullStereotypeName is null, method will return null.</remarks> /// </summary> /// <param fullName="fullStereotypeName">full fullName of stereotype which is being searched</param> /// <returns>ProfileElementStereotype object with given fullName founded (or added) in StereotypeList</returns> public static ProfileElementStereotype FindOrCreateStereotypeForName(string fullStereotypeName) { ProfileElementStereotype stereotype = null; if (!string.IsNullOrEmpty(fullStereotypeName)) { string shortName = StringManipulationManager.ExtractShortestName(fullStereotypeName, StringManipulationManager.SeparatorSharp); foreach (ProfileElementStereotype existingStereotype in Profile.StereotypeList) { if (existingStereotype.Name.Equals(fullStereotypeName) || existingStereotype.Name.Equals(shortName)) { stereotype = existingStereotype; break; } } if (stereotype == null) { stereotype = new ProfileElementStereotype(Profile.StereotypeList.Count, fullStereotypeName); Profile.StereotypeList.Add(stereotype); } } return(stereotype); }
private void CreatePropertyForField(CodeTypeDeclaration file, string dataType, CodeMemberField att, bool get, bool set) { CodeMemberProperty prop = new CodeMemberProperty(); prop.Attributes = MemberAttributes.Public; prop.Type = new CodeTypeReference(dataType); prop.Name = StringManipulationManager.CreateHungarianNotation(att.Name.Substring(4)); if (prop.Name.Equals(file.Name)) { prop.Name = prop.Name + "P"; } if (get) { prop.HasGet = true; prop.GetStatements.Add(new CodeSnippetExpression("return this." + att.Name + ((String.Compare(dataType, "system.string", true) == 0)?"":".GetValueOrDefault()"))); } if (set) { prop.HasSet = true; prop.SetStatements.Add(new CodeSnippetExpression("this." + att.Name + " = value")); } file.Members.Add(prop); CreateHasValueProperty(file, att); }
private void CreateIsMandatoryFieldAndProperty(CodeTypeDeclaration file, CodeMemberField att, Property field) { CodeMemberField fieldIsMandatory = new CodeMemberField(); fieldIsMandatory.Attributes = MemberAttributes.Private | MemberAttributes.Const; fieldIsMandatory.Type = new CodeTypeReference(typeof(bool)); fieldIsMandatory.Name = "is" + StringManipulationManager.CreateHungarianNotation(att.Name.Substring(4)) + "Mandatory"; //switch case and set true or false if (ExtractSimpleNameFromResourceURI(field.MultiplicityAsString).Equals(MultiplicityExactlyOneString1) || ExtractSimpleNameFromResourceURI(field.MultiplicityAsString).Equals(MultiplicityExactlyOneString2) || ExtractSimpleNameFromResourceURI(field.MultiplicityAsString).Equals(MultiplicityOneOrMoreString)) { fieldIsMandatory.InitExpression = new CodePrimitiveExpression(true); } else { fieldIsMandatory.InitExpression = new CodePrimitiveExpression(false); } file.Members.Add(fieldIsMandatory); CodeMemberProperty propIsMandatory = new CodeMemberProperty(); propIsMandatory.Attributes = MemberAttributes.Public | MemberAttributes.Static; propIsMandatory.Type = new CodeTypeReference(typeof(bool)); propIsMandatory.Name = "Is" + StringManipulationManager.CreateHungarianNotation(att.Name.Substring(4)) + "Mandatory"; propIsMandatory.HasGet = true; propIsMandatory.HasSet = false; propIsMandatory.GetStatements.Add(new CodeSnippetExpression("return " + fieldIsMandatory.Name)); file.Members.Add(propIsMandatory); }
private void SetReferenceToProperty(CIMObject element, object something, string attValue, PropertyInfo prop, ConcreteModel model) { if (!string.IsNullOrEmpty(attValue)) { Type referencedType = prop.PropertyType; string referencedID = StringManipulationManager.ExtractAllAfterSeparator(attValue, StringManipulationManager.SeparatorSharp); object referencedObject = model.GetObjectByID(referencedID); if (referencedObject == null) { if (!(referencedType.GetProperty("Value") != null && referencedType.GetProperty("Multiplier") != null && referencedType.GetProperty("Unit") != null) && referencedType.Name != "AbsoluteDate") { OnMessage("Referenced object on property: " + prop.DeclaringType + "." + prop.Name + ", elements ID:" + element.ID + " not in model. Referenced: " + referencedType.ToString() + ", ID:" + referencedID , MessageLevel.WARNING); string propertyType = StringManipulationManager.ExtractAllAfterSeparator(referencedType.FullName, StringManipulationManager.SeparatorDot); } //otherwise its DataType and its already set } else { if (referencedObject.GetType().Equals(referencedType) || referencedObject.GetType().IsSubclassOf(referencedType)) { prop.SetValue(something, referencedObject, null); } else { string referencedObjectType = StringManipulationManager.ExtractAllAfterSeparator(referencedObject.GetType().FullName, StringManipulationManager.SeparatorDot); string propertyType = StringManipulationManager.ExtractAllAfterSeparator(referencedType.FullName, StringManipulationManager.SeparatorDot); } } } }
/// <summary> /// Method creates property field for member field <c>att</c> inside <c>file</c> class /// </summary> /// <param name="file">CodeTypeDeclaration class that property is added to</param> /// <param name="att">CodeMemberField member field that property is made for</param> /// <param name="get">bool value - if <c>true</c> get will be added to property field</param> /// <param name="set">bool value - if <c>true</c> set will be added to property field</param> private static void CreatePropertyForField(CodeTypeDeclaration file, CodeMemberField att, bool get, bool set) { CodeMemberProperty prop = new CodeMemberProperty(); prop.Attributes = MemberAttributes.Public; prop.Type = att.Type; prop.Name = StringManipulationManager.CreateHungarianNotation(att.Name.Substring(4)); if (prop.Name.Equals(file.Name)) { prop.Name = prop.Name + "P"; } if (get) { prop.HasGet = true; prop.GetStatements.Add(new CodeSnippetExpression("return this." + att.Name)); } if (set) { prop.HasSet = true; prop.SetStatements.Add(new CodeSnippetExpression("this." + att.Name + " = value")); } file.Members.Add(prop); CreateHasValueProperty(file, att); }
/// <summary> /// Method creates constant field and its property which contains prefix of the property /// </summary> /// <param name="file">CodeTypeDeclaration class that field and its property are been added to</param> /// <param name="att">CodeMemberField member attribute that prefix field and its property are made for</param> /// <param name="field">Property which is being processing</param> private void CreateFieldPrefix(CodeTypeDeclaration file, CodeMemberField att, Property field) { CodeMemberField fieldPrefix = new CodeMemberField(); fieldPrefix.Attributes = MemberAttributes.Private | MemberAttributes.Const; fieldPrefix.Type = new CodeTypeReference(typeof(string)); fieldPrefix.Name = "_" + att.Name.Substring(4) + "Prefix"; //set prefix if (field.GetUndefinedStereotypes() != null && field.GetUndefinedStereotypes().Count > 0) { fieldPrefix.InitExpression = new CodePrimitiveExpression(StringManipulationManager.ExtractShortestName(field.GetUndefinedStereotypes().ElementAt(0).Name, separator)); } else { fieldPrefix.InitExpression = new CodePrimitiveExpression("cim"); } file.Members.Add(fieldPrefix); CodeMemberProperty propFieldPrefix = new CodeMemberProperty(); propFieldPrefix.Attributes = MemberAttributes.Public | MemberAttributes.Static; propFieldPrefix.Type = new CodeTypeReference(typeof(string)); propFieldPrefix.Name = StringManipulationManager.CreateHungarianNotation(att.Name.Substring(4)) + "Prefix"; propFieldPrefix.HasGet = true; propFieldPrefix.HasSet = false; propFieldPrefix.GetStatements.Add(new CodeSnippetExpression("return " + fieldPrefix.Name)); file.Members.Add(propFieldPrefix); }
private void CreateIsMandatoryFieldAndProperty(CodeTypeDeclaration file, CodeMemberField att, EAPAttribute attribute) { CodeMemberField fieldIsMandatory = new CodeMemberField(); fieldIsMandatory.Attributes = MemberAttributes.Private | MemberAttributes.Const; fieldIsMandatory.Type = new CodeTypeReference(typeof(bool)); fieldIsMandatory.Name = "is" + StringManipulationManager.CreateHungarianNotation(att.Name) + "Mandatory"; //switch case and set true or false if (int.Parse(attribute.Min) == 1) { fieldIsMandatory.InitExpression = new CodePrimitiveExpression(true); } else { fieldIsMandatory.InitExpression = new CodePrimitiveExpression(false); } file.Members.Add(fieldIsMandatory); CodeMemberProperty propIsMandatory = new CodeMemberProperty(); propIsMandatory.Attributes = MemberAttributes.Public | MemberAttributes.Static; propIsMandatory.Type = new CodeTypeReference(typeof(bool)); propIsMandatory.Name = "Is" + StringManipulationManager.CreateHungarianNotation(att.Name) + "Mandatory"; propIsMandatory.HasGet = true; propIsMandatory.HasSet = false; propIsMandatory.GetStatements.Add(new CodeSnippetExpression("return " + fieldIsMandatory.Name)); file.Members.Add(propIsMandatory); }
private void ReplaceDataTypesWithSimpleTypes(PredefinedClasses cimPredefined) { if ((cimPredefined != null) && (profile != null) && (profile.PropertyCount > 0)) { foreach (Property property in profile.ProfileMap[ProfileElementTypes.Property]) { string dataTypeName = StringManipulationManager.ExtractAllAfterSeparator(property.DataType, StringManipulationManager.SeparatorSharp); if (string.IsNullOrEmpty(dataTypeName)) { //// support cim15 dataTypeName = StringManipulationManager.ExtractAllAfterSeparator(property.Range, StringManipulationManager.SeparatorSharp); } if (cimPredefined.PedifinedClassesList.Contains(dataTypeName)) { //// read the simple type from "value" attribute Class dataTypeClass = profile.FindProfileElementByName(dataTypeName) as Class; foreach (Property p in dataTypeClass.MyProperties) { if (string.Compare(p.Name, "value") == 0) { property.DataType = p.DataType; if (!string.IsNullOrEmpty(property.Range)) { property.Range = null; property.RangeAsObject = null; } } } } } } }
private void AddPredefined() { foreach (Class el in predefined) { el.BelongsToCategory = "#Package_Core"; el.BelongsToCategoryAsObject = profile.FindProfileElementByName(StringManipulationManager.ExtractAllAfterSeparator(el.BelongsToCategory, StringManipulationManager.SeparatorSharp)); ((ClassCategory)profile.FindProfileElementByName(StringManipulationManager.ExtractAllAfterSeparator(el.BelongsToCategory, StringManipulationManager.SeparatorSharp))).AddToMembersOfClassCategory(el); } predefined.Clear(); }
private static void CreateHasValueProperty(CodeTypeDeclaration file, CodeMemberField att) { CodeMemberProperty propHasValue = new CodeMemberProperty(); propHasValue.Attributes = MemberAttributes.Public; propHasValue.Type = new CodeTypeReference(typeof(bool)); propHasValue.Name = StringManipulationManager.CreateHungarianNotation(att.Name.Substring(4)) + "HasValue"; propHasValue.HasGet = true; propHasValue.HasSet = false; propHasValue.GetStatements.Add(new CodeSnippetExpression("return this." + att.Name + " != null")); file.Members.Add(propHasValue); }
public override void StartElement(string localName, string qName, SortedList <string, string> attributes, int lineNumber = 0, int columnNumber = 0) { string type = localName; string namespaceName = string.Empty; if (qName.Contains(StringManipulationManager.SeparatorColon)) { namespaceName = qName.Substring(0, qName.IndexOf(StringManipulationManager.SeparatorColon)); } if (string.Compare(qName, rdfRootQ, true) == 0) { //// rdf:RDF element - extract attributes if ((attributes != null) && (attributes.Count > 0)) { foreach (string attrName in attributes.Keys) { if (!attrName.StartsWith(xmlnsPrefix, true, null)) { namespaces.Add(attrName, attributes[attrName]); } } } } if (string.Compare(rdfRoot, type, true) != 0) { string id = TryReadRDFIdAttribute(attributes); //// start of new main element if (currentElement == null) { if (id != null) { inLevel = Level.Element; sourceText.Clear(); currentElement = new CIMEntity(); currentElement.RdfID = StringManipulationManager.ExtractAllAfterSeparator(id, StringManipulationManager.SeparatorSharp); currentElement.StartLine = lineNumber - 1; currentElement.StartColumn = columnNumber; GoToPosistion(lineNumber, columnNumber); x = true; } } //// start of new subelement (attribute or embedded element) else { //// new attribute inLevel = Level.Property; } } }
/// <summary> /// Method creates CodeCompileUnit that represents enumeration /// NOTE: in this method if character '-' is found it is replaced by string "MINUS" /// so that the member field names in CodeCompileUnit ca be valid for C# code /// e.g. Hz-1 will become HzMINUS1 /// </summary> /// <param name="package">ProfileElement element that represents the package</param> /// <param name="entity">ProfileElement element that represents enumeration</param> /// <returns>CodeCompileUnit unit representing enumeration</returns> private CodeCompileUnit CreateEnumeration(ProfileElement package, Class entity) { CodeCompileUnit unit = new CodeCompileUnit(); //namespace string fullNS = package.Name; ProfileElement temp = package; /*while(temp.BelongsToCategoryAsObject != null) * { * temp = temp.BelongsToCategoryAsObject; * fullNS = temp.Name + "." + fullNS; * } * fullNS = defaultNS + "." + fullNS;*/ //CodeNamespace nameSpace = new CodeNamespace(fullNS); CodeNamespace nameSpace = new CodeNamespace(defaultNS); unit.Namespaces.Add(nameSpace); //namespace imports nameSpace.Imports.Add(new CodeNamespaceImport("System")); CodeTypeDeclaration enumeration = new CodeTypeDeclaration(entity.Name); enumeration.IsEnum = true; enumeration.Attributes = MemberAttributes.Public; enumeration.TypeAttributes = TypeAttributes.Public; if (entity.MyEnumerationMembers != null) { foreach (ProfileElement enumMember in entity.MyEnumerationMembers) { /* * REPLACES '-' with "MINUS" because in enumeration '-' is not a valid character */ string value = enumMember.Name; value = StringManipulationManager.ReplaceInvalidEnumerationCharacters(value); CodeMemberField val = new CodeMemberField(typeof(int), value); if (!string.IsNullOrEmpty(enumMember.Comment)) { val.Comments.Add(new CodeCommentStatement(enumMember.Comment, true)); } enumeration.Members.Add(val); } } nameSpace.Types.Add(enumeration); return(unit); }
public void CreatePackage(Profile profile, string key) { List <NameValuePair> packageProps = predefinedPackages[key]; ClassCategory package = new ClassCategory(); foreach (NameValuePair prop in packageProps) { if (prop.Name.Equals("URI")) { package.URI = prop.Value; } else if (prop.Name.Equals("BelongsToCategory")) { package.BelongsToCategory = prop.Value; } else if (prop.Name.Equals("Comment")) { package.Comment = prop.Value; } else if (prop.Name.Equals("Label")) { package.Label = prop.Value; } else if (prop.Name.Equals("Type")) { package.Type = prop.Value; } } List <ProfileElement> elems = profile.ProfileMap[ProfileElementTypes.ClassCategory]; if (elems == null) { elems = new List <ProfileElement>(); } if (elems.Count > 0 && !elems.Contains(package)) { elems.Add(package); profile.ProfileMap.Remove(ProfileElementTypes.ClassCategory); profile.ProfileMap.Add(ProfileElementTypes.ClassCategory, elems); } package.BelongsToCategoryAsObject = (ClassCategory)profile.FindProfileElementByName(StringManipulationManager.ExtractAllAfterSeparator(package.BelongsToCategory, StringManipulationManager.SeparatorSharp)); ((ClassCategory)profile.FindProfileElementByName(StringManipulationManager.ExtractAllAfterSeparator(package.BelongsToCategory, StringManipulationManager.SeparatorSharp))).AddToMembersOfClassCategory(package); }
//// Method tries to read the "rdf:resource" attribute and if it is found, //// it connects the referenced object (parent) with child object. private void ReadAndProcessAttributeValue(ObjectAttribute objectAttribute, SortedList <string, string> atts) { if ((objectAttribute != null) && (atts != null)) { //// if object attribute contains reference to another element, //// it is being read and put on stack of that element (parent element) if (atts.ContainsKey(rdfResource)) { string parentId = atts[rdfResource]; objectAttribute.Value = parentId; objectAttribute.IsReference = true; if (parentId.StartsWith(StringManipulationManager.SeparatorSharp)) { parentId = StringManipulationManager.ExtractAllAfterSeparator(parentId, StringManipulationManager.SeparatorSharp); } AddChildElementToReferencedParentElement(parentId); } } }
/// <summary> /// Method adds reference to list on property prop /// </summary> /// <param name="list">list that reference will be added to</param> /// <param name="att">attribute containing information about reference</param> /// <param name="prop">property containing list</param> private void AddReferenceToList(CIMObject element, ref IList list, string attValue, PropertyInfo prop, ConcreteModel model) { if (!string.IsNullOrEmpty(attValue)) { Type referencedType = prop.PropertyType; string referencedID = StringManipulationManager.ExtractAllAfterSeparator(attValue, StringManipulationManager.SeparatorSharp); string refType = referencedType.ToString(); if (referencedType.IsGenericType) { refType = referencedType.GetGenericArguments()[0].ToString(); } //DataTypes? what about them if in list - should be a way to determine object referencedObject = model.GetObjectByID(referencedID); if (referencedObject != null) { try { list.Add(referencedObject); } catch { OnMessage("Unsuccessful adding item to list on property: " + prop.DeclaringType + "." + prop.Name + ", elements ID:" + element.ID + " Referenced: " + refType + ", ID: " + referencedID , MessageLevel.ERROR); string referencedTypeWithoutPrefix = StringManipulationManager.ExtractAllAfterSeparator(refType, StringManipulationManager.SeparatorDot); } } else { OnMessage("Referenced object on property: " + prop.DeclaringType + "." + prop.Name + ", elements ID:" + element.ID + " not in model. Referenced: " + refType + ", ID:" + referencedID , MessageLevel.WARNING); string referencedTypeWithoutPrefix = StringManipulationManager.ExtractAllAfterSeparator(refType, StringManipulationManager.SeparatorDot); } } }
/// <summary> /// Method creates CodeCompileUnit that represents enumeration /// NOTE: in this method if character '-' is found it is replaced by string "MINUS" /// so that the member field names in CodeCompileUnit ca be valid for C# code /// e.g. Hz-1 will become HzMINUS1 /// </summary> /// <param name="package">ProfileElement element that represents the package</param> /// <param name="entity">ProfileElement element that represents enumeration</param> /// <returns>CodeCompileUnit unit representing enumeration</returns> private CodeCompileUnit CreateEnumeration(ProfileElement package, Class entity) { CodeCompileUnit unit = new CodeCompileUnit(); //namespace string fullNS = package.Name; ProfileElement temp = package; //CodeNamespace nameSpace = new CodeNamespace(fullNS); CodeNamespace nameSpace = new CodeNamespace(defaultNS); unit.Namespaces.Add(nameSpace); //namespace imports nameSpace.Imports.Add(new CodeNamespaceImport("System")); CodeTypeDeclaration enumeration = new CodeTypeDeclaration(entity.Name); enumeration.IsEnum = true; enumeration.Attributes = MemberAttributes.Public; enumeration.TypeAttributes = TypeAttributes.Public; if (entity.MyEnumerationMembers != null) { foreach (ProfileElement enumMember in entity.MyEnumerationMembers) { string value = enumMember.Name; value = StringManipulationManager.ReplaceInvalidEnumerationCharacters(value); CodeMemberField val = new CodeMemberField(typeof(int), value); if (!string.IsNullOrEmpty(enumMember.Comment)) { val.Comments.Add(new CodeCommentStatement(enumMember.Comment, true)); } enumeration.Members.Add(val); } } nameSpace.Types.Add(enumeration); return(unit); }
public override void StartElement(string localName, string qName, SortedList <string, string> attributes, int lineNumber = 0, int columnNumber = 0) { if (string.Compare(qName, forwardDiffQ, true) == 0) { changeType = ChangeType.Forward; } if (string.Compare(qName, reverseDiffQ, true) == 0) { changeType = ChangeType.Reverse; } string type = localName; if (string.Compare(rdfRoot, type, true) != 0) { string id = TryReadRDFIdAttribute(attributes); //// start of new main element if (currentElement == null) { if (id != null) { inLevel = Level.Element; sourceText.Clear(); currentElement = new CIMEntity(); currentElement.RdfID = StringManipulationManager.ExtractAllAfterSeparator(id, StringManipulationManager.SeparatorSharp); currentElement.StartLine = lineNumber - 1; currentElement.StartColumn = columnNumber; GoToPosistion(lineNumber, columnNumber); x = true; } } //// start of new subelement (attribute or embedded element) else { //// new attribute inLevel = Level.Property; } } }
/// <summary> /// Sets value of enumeration to property <c>prop</c> of object <c>instance</c> /// </summary> /// <param name="assembly">contains enumeration definition</param> /// <param name="instance">object that contains property</param> /// <param name="prop">property that value will be set to</param> /// <param name="att">attribute from model that cointains value and name of enumeration</param> private void SetEnumerationProperty(CIMObject element, Assembly assembly, object instance, PropertyInfo prop, ObjectAttribute att) { if (!string.IsNullOrEmpty(att.Value)) { ////get type, that is, enumeration member that has name equal to the string value of attribute ////get the field with name casted into int and set itatt.Value Type enumType = assembly.GetType(prop.PropertyType.ToString()); FieldInfo enumVal = enumType.GetField(StringManipulationManager.ReplaceInvalidEnumerationCharacters(att.Value)); if (enumVal == null) { OnMessage("Error occured while trying to set value to field " + prop.DeclaringType.Name + "." + prop.Name + ", enumeration value <" + prop.PropertyType.ToString() + "." + StringManipulationManager.ReplaceInvalidEnumerationCharacters(att.Value) + "> not found in assembly!" + " elements ID: " + element.ID, MessageLevel.WARNING); } else { object newEnumValue = enumVal.GetValue(enumType); prop.SetValue(instance, newEnumValue, null); } } }
private void CreatePropertyForField(CodeTypeDeclaration file, EAPAttribute attribute, CodeMemberField att, bool get, bool set) { CodeMemberProperty prop = new CodeMemberProperty(); prop.Attributes = MemberAttributes.Public | MemberAttributes.Final; if (attribute.TypeCode != "") { if (attribute.TypeCode.Equals("Enum") || attribute.TypeCode.Equals("Class")) { prop.Type = new CodeTypeReference(attribute.MeasurementType); } } else { if (attribute.MeasurementType != "") { string dataType = StringManipulationManager.GetSystemType(attribute.MeasurementType); prop.Type = new CodeTypeReference(dataType); } } prop.Name = StringManipulationManager.CreateHungarianNotation(att.Name); if (prop.Name.Equals(file.Name)) { prop.Name = prop.Name + "P"; } if (get) { prop.HasGet = true; prop.GetStatements.Add(new CodeSnippetExpression("return this." + att.Name)); } if (set) { prop.HasSet = true; prop.SetStatements.Add(new CodeSnippetExpression("this." + att.Name + " = value")); } file.Members.Add(prop); }
private string ExtractSimpleNameFromResourceURI(string resourceUri) { return(StringManipulationManager.ExtractShortestName(resourceUri, separator)); }
/// <summary> /// Method creates predefined class that contains ID and other needed fields /// </summary> private void CreateParentClass() { CodeCompileUnit unit = new CodeCompileUnit(); //namespace CodeNamespace nameSpace = new CodeNamespace(defaultNS); unit.Namespaces.Add(nameSpace); //namespace imports nameSpace.Imports.Add(new CodeNamespaceImport("System")); //class CodeTypeDeclaration file = new CodeTypeDeclaration(); file.IsClass = true; file.Name = "IDClass"; file.TypeAttributes = TypeAttributes.Public; //create field string fieldName = "cim_ID"; CodeMemberField att = new CodeMemberField(typeof(string), fieldName); att.Attributes = MemberAttributes.Private; att.Comments.Add(new CodeCommentStatement("ID used for reference purposes", true)); file.Members.Add(att); //create property CodeMemberProperty prop = new CodeMemberProperty(); prop.Attributes = MemberAttributes.Public; prop.Type = new CodeTypeReference(typeof(string)); prop.Name = "ID"; prop.HasGet = true; prop.GetStatements.Add(new CodeSnippetExpression("return this." + fieldName)); prop.HasSet = true; prop.SetStatements.Add(new CodeSnippetExpression("this." + fieldName + " = value")); file.Members.Add(prop); CodeMemberField fieldIsMandatory = new CodeMemberField(); fieldIsMandatory.Attributes = MemberAttributes.Private | MemberAttributes.Const; fieldIsMandatory.Type = new CodeTypeReference(typeof(bool)); fieldIsMandatory.Name = "is" + StringManipulationManager.CreateHungarianNotation(att.Name.Substring(4)) + "Mandatory"; //switch case and set true or false fieldIsMandatory.InitExpression = new CodePrimitiveExpression(true); file.Members.Add(fieldIsMandatory); CodeMemberProperty propIsMandatory = new CodeMemberProperty(); propIsMandatory.Attributes = MemberAttributes.Public; propIsMandatory.Type = new CodeTypeReference(typeof(bool)); propIsMandatory.Name = "Is" + StringManipulationManager.CreateHungarianNotation(att.Name.Substring(4)) + "Mandatory"; propIsMandatory.HasGet = true; propIsMandatory.HasSet = false; propIsMandatory.GetStatements.Add(new CodeSnippetExpression("return " + fieldIsMandatory.Name)); file.Members.Add(propIsMandatory); nameSpace.Types.Add(file); Files.Add(unit); }
/// <summary> /// Adds missing data to <c>entity</c> with respect to <c>modelClass</c>, and <c>package</c> from the model /// </summary> /// <param name="entity">ProfileElement element with missing data</param> /// <param name="modelClass">CClass from model</param> /// <param name="package">CPackage from model. Contains the <c>modelClass</c></param> private void updateClassData(ProfileElement entity, CClass modelClass, CPackage package) { entity.AddStereotype(ProfileElementStereotype.StereotypeConcrete); entity.URI = modelClass.name; //PACKAGE: name and object - added "Package_" because of the current scheme entity.BelongsToCategory = "Package_" + package.name; entity.TypeAsEnumValue = ProfileElementTypes.Class; entity.Label = StringManipulationManager.ExtractAllAfterSeparator(modelClass.name, StringManipulationManager.SeparatorSharp); List <ProfileElement> packages = profile.GetAllProfileElementsOfType(ProfileElementTypes.ClassCategory); foreach (ProfileElement pack in packages) { if (pack.UniqueName.Equals(entity.BelongsToCategory)) { entity.BelongsToCategoryAsObject = pack; pack.AddToMembersOfClassCategory(entity); break; } } //if package is not found, look for it in the model //----------------------------------------------------------------------------- if (entity.BelongsToCategoryAsObject == null) { //looking for package (and we know which one - CPackage) and adding it to hierarchy ProfileElement newPackage = new ProfileElement(); newPackage.Label = package.name; newPackage.URI = "Package_" + package.name; //create separate package - detached from hierarchy, because we wont need it newPackage.TypeAsEnumValue = ProfileElementTypes.ClassCategory; newPackage.AddToMembersOfClassCategory(entity); entity.BelongsToCategoryAsObject = newPackage; entity.BelongsToCategory = newPackage.UniqueName; profile.GetAllProfileElementsOfType(ProfileElementTypes.ClassCategory).Add(newPackage); } //----------------------------------------------------------------------------- //PARENT: assumption is that all the classes needed are in profile, //we dont need to add additional, not mentioned in profile entity.SubClassOf = modelClass.parentClassName == null ? string.Empty : modelClass.parentClassName; if (!string.IsNullOrEmpty(entity.SubClassOf)) { bool foundInModel = false; List <ProfileElement> classes = profile.GetAllProfileElementsOfType(ProfileElementTypes.Class); foreach (ProfileElement temp in classes) { if (temp.URI.Equals(entity.SubClassOf)) { entity.SubClassOfAsObject = temp; break; } } if (!foundInModel) { entity.SubClassOf = string.Empty; } } //FIELDS foreach (CAttribute att in modelClass.attributes) { addAttributeToElement(entity, att, modelClass); } }
private void ConnectModelElements(CIMModel CIM_Model, Assembly assembly, ref ConcreteModel concreteModel) { foreach (string type in CIM_Model.ModelMap.Keys) { SortedDictionary <string, CIMObject> objects = CIM_Model.ModelMap[type]; foreach (string objID in objects.Keys) { CIMObject element = objects[objID]; Type classType; classType = assembly.GetType(ActiveNamespace + "." + type); if (classType == null) { OnMessage("Element (" + element.ID + ") not found in assembly:" + ActiveNamespace + "." + type + " - validation of document failed!", MessageLevel.ERROR); continue; } ////aquire object from concrete model object currentObject = concreteModel.GetObjectByTypeAndID(classType, objID); if (currentObject != null) { foreach (int attKey in element.MyAttributes.Keys) { string propertyName = StringManipulationManager.ExtractShortestName(CIM_Model.ModelContext.ReadAttributeWithCode(attKey), StringManipulationManager.SeparatorDot); propertyName = StringManipulationManager.CreateHungarianNotation(propertyName); if (propertyName.Equals(type)) { propertyName = propertyName + "P"; } PropertyInfo prop = classType.GetProperty(propertyName); if (prop == null) { OnMessage("Property " + propertyName + " not found in class " + element.CIMType + ", elements ID:" + element.ID + " - validation of document failed!", MessageLevel.ERROR); continue; } ////if it is a list or collection of references if (prop.PropertyType.IsGenericType) { Type propertyListType = prop.PropertyType.GetGenericArguments()[0]; List <ObjectAttribute> attList = element.MyAttributes[attKey]; ////get the property as IList IList list = (IList)prop.GetValue(currentObject, null); foreach (ObjectAttribute att in attList) { ////this part should add a reference to IList if (!IsSimpleValue(propertyListType) && !propertyListType.IsEnum) { AddReferenceToList(element, ref list, att.Value, prop, concreteModel); } } } else { List <ObjectAttribute> attList = element.MyAttributes[attKey]; ////if its not a list... ObjectAttribute att = attList.ElementAt(0); if (null != prop && prop.CanWrite) { if (!IsSimpleValue(prop.PropertyType) && !prop.PropertyType.IsEnum) { SetReferenceToProperty(element, currentObject, att.Value, prop, concreteModel); } } } } ////embeded elements - lists if (element.GetEmbeddedChildren() != null) { foreach (string attKey in element.GetEmbeddedChildren().Keys) { ////first is the name of property string propertyName = StringManipulationManager.ExtractShortestName(attKey, StringManipulationManager.SeparatorDot); propertyName = StringManipulationManager.CreateHungarianNotation(propertyName); if (propertyName.Equals(type)) { propertyName = propertyName + "P"; } PropertyInfo prop = classType.GetProperty(propertyName); if (prop != null && prop.PropertyType.IsGenericType) { Type propertyListType = prop.PropertyType.GetGenericArguments()[0]; List <string> attList = element.GetEmbeddedChildren()[attKey]; ////get the property as IList IList list = (IList)prop.GetValue(currentObject, null); foreach (string att in attList) { ////this part should add a reference to IList if (!IsSimpleValue(propertyListType) && !propertyListType.IsEnum) { AddReferenceToList(element, ref list, att, prop, concreteModel); } } } else { List <string> attList = element.GetEmbeddedChildren()[attKey]; ////if its not a list... string att = attList.ElementAt(0); if (prop != null && prop.CanWrite) { if (!IsSimpleValue(prop.PropertyType) && !prop.PropertyType.IsEnum) { SetReferenceToProperty(element, currentObject, att, prop, concreteModel); } } } } } } else { OnMessage("Object of class:" + classType + ", with ID:" + objID + " not found in model! Unable to create concrete model." , MessageLevel.ERROR); } } } }
/// <summary> /// Reads all the "simple" values (not references) from attribute list and sets properties to the /// specified value /// </summary> /// <param name="assembly">assembly that contains class definitions</param> /// <param name="element">element being processes</param> /// <param name="classType">type of the instance</param> /// <param name="instance">instance of classType that will have properties set</param> private void ProcessAttributes(Assembly assembly, CIMObject element, Type classType, object instance) { foreach (int attKey in element.MyAttributes.Keys) { ////all properties have capital letters used for naming them string propertyName = StringManipulationManager.ExtractShortestName(element.ModelContext.ReadAttributeWithCode(attKey), StringManipulationManager.SeparatorDot); propertyName = StringManipulationManager.CreateHungarianNotation(propertyName); if (propertyName.Equals(element.CIMType)) { propertyName = propertyName + "P"; } PropertyInfo prop = classType.GetProperty(propertyName); if (prop == null) { OnMessage("Property " + propertyName + " not found in class " + element.CIMType + " (element ID:" + element.ID + ")" + " - validation of document failed!" , MessageLevel.ERROR); continue; } ////if it is a list or collection - though it always has to be a list if (prop.PropertyType.IsGenericType) { ////gets the type of the items in list Type propertyListType = prop.PropertyType.GetGenericArguments()[0]; ////get all the values for this property List <ObjectAttribute> attList = element.MyAttributes[attKey]; ////get the property as IList IList list = (IList)prop.GetValue(instance, null); List <FTN.Commands> pomComm = new List <FTN.Commands>(); List <FTN.States> pomState = new List <FTN.States>(); if (attList.Count > 0) { string[] items = attList[0].Value.Split(' '); foreach (var item in items) { if (item.Equals("Open")) { pomComm.Add(FTN.Commands.Open); } else if (item.Equals("Close")) { pomComm.Add(FTN.Commands.Close); } } foreach (var item in items) { if (item.Equals("Opened")) { pomState.Add(FTN.States.Opened); } else if (item.Equals("Closed")) { pomState.Add(FTN.States.Closed); } } } foreach (ObjectAttribute att in attList) { ////Only add a simple value to IList, enumerations and references are not needed if (IsSimpleValue(propertyListType)) { AddSimpleValueToList(element, ref list, att, propertyListType); } } if (pomComm.Count > 0) { prop.SetValue(instance, pomComm, null); } if (pomState.Count > 0) { prop.SetValue(instance, pomState, null); } } else { ////if property is not a list... List <ObjectAttribute> attList = element.MyAttributes[attKey]; ////it only has one attribute value in list then if (attList.Count <= 1) { ObjectAttribute att = attList.ElementAt(0); if (null != prop) { if (IsSimpleValue(prop.PropertyType)) { SetSimpleValue(element, instance, att, prop); } else { if (prop.PropertyType.IsEnum) { SetEnumerationProperty(element, assembly, instance, prop, att); } else { ////if it was not found up until now it has to be reference or data type ////if it is not empty and it is not any of the cases checked already it is DataType ////make instance of dataType and set value if (!IsSimpleValue(prop.PropertyType) && !string.IsNullOrEmpty(att.Value)) { SetDataTypeProperty(element, assembly, instance, prop, att); } } } } } else { OnMessage("Multiple values for attribute with multiplicity 1 on element with ID:" + element.ID + ". ATTRIBUTE: " + classType + "." + prop.Name , MessageLevel.WARNING); } } } }
private void GenerateSetPropertyMethod(CodeTypeDeclaration file, EAPClass classPom) { CodeMemberMethod method = new CodeMemberMethod(); method.Attributes = MemberAttributes.Public | MemberAttributes.Override; method.Name = "SetProperty"; method.ReturnType = new CodeTypeReference(typeof(void)); method.Parameters.Add(new CodeParameterDeclarationExpression("Property", "property")); List <CodeSnippetStatement> snipets = new List <CodeSnippetStatement>() { new CodeSnippetStatement("\t\t\t\tswitch(property.Id)"), new CodeSnippetStatement("\t\t\t\t{") }; foreach (EAPAttribute att in classPom.Attributes) { if (att.IsListOfReferences == true) { continue; } CodeSnippetStatement css = new CodeSnippetStatement("\t\t\t\t\tcase ModelCode." + att.Code + ":"); CodeSnippetStatement cssProp = new CodeSnippetStatement(); if (att.TypeCode != "" && att.TypeCode.Equals("Enum")) { cssProp = new CodeSnippetStatement("\t\t\t\t\t\t" + att.Name + " = (" + att.MeasurementType + ") property.AsEnum();"); } else if (att.IsReference == true || att.TypeCode.Equals("Class")) { cssProp = new CodeSnippetStatement("\t\t\t\t\t\t" + att.Name + " = property.AsReference();"); } else { cssProp = new CodeSnippetStatement("\t\t\t\t\t\t" + att.Name + " = property." + StringManipulationManager.GetAsMethod(att.MeasurementType)); } CodeSnippetStatement cssBreak = new CodeSnippetStatement("\t\t\t\t\t\tbreak;"); snipets.Add(css); snipets.Add(cssProp); snipets.Add(cssBreak); } CodeSnippetStatement cssDefault = new CodeSnippetStatement("\t\t\t\t\tdefault:"); CodeSnippetStatement cssBase = new CodeSnippetStatement("\t\t\t\t\t\tbase.SetProperty(property);"); CodeSnippetStatement cssBreakDefault = new CodeSnippetStatement("\t\t\t\t\t\tbreak;"); CodeSnippetStatement ccss = new CodeSnippetStatement("\t\t\t\t}"); snipets.Add(cssDefault); snipets.Add(cssBase); snipets.Add(cssBreakDefault); snipets.Add(ccss); foreach (var item in snipets) { method.Statements.Add(item); } file.Members.Add(method); }
public override string ToString() { StringBuilder toStringBuilder = new StringBuilder("Profile: \n"); if (profileMap != null) { if (profileMap.ContainsKey(ProfileElementTypes.ClassCategory)) { foreach (ProfileElement package in profileMap[ProfileElementTypes.ClassCategory]) { toStringBuilder.Append("* members of "); toStringBuilder.AppendLine(package.UniqueName); List <ProfileElement> list = (package as ClassCategory).MembersOfClassCategory; if (list != null) { foreach (ProfileElement elem in list) { if (elem is Class) { toStringBuilder.Append("\t ").AppendLine(elem.URI); toStringBuilder.Append("\t\t type = ").AppendLine(elem.Type); toStringBuilder.Append("\t\t label = ").AppendLine(elem.Label); if (elem.IsEnumeration) { toStringBuilder.AppendLine("\t\t Enumeration class"); } if ((elem as Class).Stereotypes != null) { toStringBuilder.AppendLine("\t\t has Stereotypes : "); foreach (ProfileElementStereotype stereotype in (elem as Class).Stereotypes) { toStringBuilder.Append("\t\t\t").AppendLine(stereotype.ToString()); } } toStringBuilder.Append("\t\t subClassOf = ").AppendLine((elem as Class).SubClassOf); toStringBuilder.Append("\t\t belongsToCategory = ").AppendLine((elem as Class).BelongsToCategory); if ((elem as Class).MyProperties != null) { toStringBuilder.AppendLine("\t\t has Properties : "); foreach (ProfileElement property in (elem as Class).MyProperties) { toStringBuilder.Append("\t\t\t").AppendLine(property.UniqueName); toStringBuilder.Append("\t\t\t\t label = ").AppendLine(property.Label); toStringBuilder.Append("\t\t\t\t dataType = ").AppendLine((property as Property).DataType); toStringBuilder.Append("\t\t\t\t range = ").AppendLine((property as Property).Range); toStringBuilder.Append("\t\t\t\t multiplicity = ").AppendLine(StringManipulationManager.ExtractShortestName(property.MultiplicityAsString, StringManipulationManager.SeparatorSharp)); if (property.Stereotypes != null) { toStringBuilder.AppendLine("\t\t\t\t has Stereotypes : "); foreach (ProfileElementStereotype stereotype in property.Stereotypes) { toStringBuilder.Append("\t\t\t\t\t").AppendLine(stereotype.ToString()); } } toStringBuilder.AppendLine(); } } if ((elem as Class).MyEnumerationMembers != null) { toStringBuilder.AppendLine("\t\t\t has enum members : "); foreach (ProfileElement enumMember in (elem as Class).MyEnumerationMembers) { toStringBuilder.Append("\t\t\t\t").AppendLine(enumMember.UniqueName); } } } } } } } } return(toStringBuilder.ToString()); }
private void CollenctConectors(EAPModel model, Connector l_Attr, EAPClass l_Class, bool group, EA.Element l_class) { EAPAttribute l_MyAttr = new EAPAttribute(); l_MyAttr.Description = l_Attr.Notes; if (l_MyAttr.Description.Split(':').Length > 1) { l_MyAttr.Title = l_MyAttr.Description.Split(':')[0]; l_MyAttr.Description = l_MyAttr.Description.Remove(0, l_MyAttr.Title.Length + 1); } else { l_MyAttr.Title = ""; l_MyAttr.Description = l_MyAttr.Description.Trim(); } l_MyAttr.Title = l_MyAttr.Title.Replace("<b>", "").Replace("</b>", "").Replace("<i>", "").Replace("</i>", "").Trim(); l_MyAttr.Description = l_MyAttr.Description.Replace("<b>", "").Replace("</b>", "").Replace("<i>", "").Replace("</i>", "").Trim(); l_MyAttr.Code = l_Attr.Alias; bool pom = false; if (l_class.ElementID == l_Attr.ClientID) { l_MyAttr.Name = l_Attr.SupplierEnd.Role; l_MyAttr.Code = l_Attr.SupplierEnd.Alias; if (StringManipulationManager.GetMaxCardinality(l_Attr.SupplierEnd.Cardinality).Equals("*")) { l_MyAttr.Max = "*"; string min = l_Attr.SupplierEnd.Cardinality.Substring(0, 1); l_MyAttr.Min = min; // pair of attributes on same connector for Add and Remove Ref l_MyAttr.onSameConnectorPairAtt = new EAPAttribute(l_Attr.ClientEnd.Role, l_Attr.ClientEnd.Alias); } else if (StringManipulationManager.GetMaxCardinality(l_Attr.SupplierEnd.Cardinality).Equals("1")) { l_MyAttr.Max = "1"; l_MyAttr.Min = "1"; // pair of attributes on same connector for Add and Remove Ref l_MyAttr.onSameConnectorPairAtt = new EAPAttribute(l_Attr.ClientEnd.Role, l_Attr.ClientEnd.Alias); } else if (StringManipulationManager.GetMaxCardinality(l_Attr.ClientEnd.Cardinality).Equals("2")) { l_MyAttr.Max = "2"; l_MyAttr.Min = "0"; // pair of attributes on same connector for Add and Remove Ref l_MyAttr.onSameConnectorPairAtt = new EAPAttribute(l_Attr.ClientEnd.Role, l_Attr.ClientEnd.Alias); } pom = true; } else { l_MyAttr.Name = l_Attr.ClientEnd.Role; l_MyAttr.Code = l_Attr.ClientEnd.Alias; if (StringManipulationManager.GetMaxCardinality(l_Attr.ClientEnd.Cardinality).Equals("*")) { l_MyAttr.Max = "*"; string min = l_Attr.ClientEnd.Cardinality.Substring(0, 1); l_MyAttr.Min = min; // pair of attributes on same connector for Add and Remove Ref l_MyAttr.onSameConnectorPairAtt = new EAPAttribute(l_Attr.SupplierEnd.Role, l_Attr.SupplierEnd.Alias); } else if (StringManipulationManager.GetMaxCardinality(l_Attr.ClientEnd.Cardinality).Equals("1")) { l_MyAttr.Max = "1"; l_MyAttr.Min = "1"; // pair of attributes on same connector for Add and Remove Ref l_MyAttr.onSameConnectorPairAtt = new EAPAttribute(l_Attr.SupplierEnd.Role, l_Attr.SupplierEnd.Alias); } else if (StringManipulationManager.GetMaxCardinality(l_Attr.ClientEnd.Cardinality).Equals("2")) { l_MyAttr.Max = "2"; l_MyAttr.Min = "0"; // pair of attributes on same connector for Add and Remove Ref l_MyAttr.onSameConnectorPairAtt = new EAPAttribute(l_Attr.SupplierEnd.Role, l_Attr.SupplierEnd.Alias); } } if (l_MyAttr.Max == "*") { if (pom) { l_MyAttr.MeasurementType = "List<" + FindClassById(l_Attr.SupplierID, MyModelCopy) + ">"; } else { l_MyAttr.MeasurementType = "List<" + FindClassById(l_Attr.ClientID, MyModelCopy) + ">"; } l_MyAttr.IsListOfReferences = true; } else if (l_MyAttr.Max == "1") { l_MyAttr.MeasurementType = "long"; l_MyAttr.IsReference = true; } // FindType(l_Class, l_MyAttr, l_Attr); //l_MyAttr.Aggregated = GetAggregated(l_Attr, l_MyAttr); // l_MyAttr.Searchable = GetSearchable(l_Attr, l_MyAttr); // l_MyAttr.Cardinality = GetCardinality(l_Attr, l_MyAttr) == 0 ? null : GetCardinality(l_Attr, l_MyAttr).ToString(); if (!(l_Class.AddAttribute(l_MyAttr))) { if (Validate) { tw.WriteLine("Attribute Model Code:" + l_Attr.Alias + ", already exists in Class name: " + l_Class.Name + ". (Look at EAP)"); tw.WriteLine("*************************************************************************"); tw.WriteLine("\n\n"); } } }
private CodeCompileUnit CreateClass(EAPModel model, EAPClass classPom, bool flagDb) { CodeCompileUnit unit = new CodeCompileUnit(); //namespace CodeNamespace nameSpace = new CodeNamespace("Default_Namespace"); unit.Namespaces.Add(nameSpace); //namespace imports nameSpace.Imports.Add(new CodeNamespaceImport("System")); CodeTypeDeclaration file = new CodeTypeDeclaration(); file.IsClass = true; file.Name = classPom.Name; file.TypeAttributes = TypeAttributes.Public; file.Attributes = MemberAttributes.Public; if (classPom.Parent != null) { file.BaseTypes.Add(new CodeTypeReference(classPom.Parent)); nameSpace.Imports.Add(new CodeNamespaceImport("Default_Namespace")); } else { //if class doesn't have a parent, //it should extend IDClass as the root of hierarhy - for rdf:ID file.BaseTypes.Add(new CodeTypeReference("IDClass")); nameSpace.Imports.Add(new CodeNamespaceImport("Default_Namespace")); } if (!string.IsNullOrEmpty(classPom.Description)) { file.Comments.Add(new CodeCommentStatement(classPom.Description, true)); } //Generate constructor without param CodeConstructor baseStringConstructorSimple = new CodeConstructor(); baseStringConstructorSimple.Attributes = MemberAttributes.Public; //Gererating constuctor with param CodeConstructor baseStringConstructor = new CodeConstructor(); baseStringConstructor.Attributes = MemberAttributes.Public; baseStringConstructor.BaseConstructorArgs.Add(new CodeVariableReferenceExpression("globalId")); baseStringConstructor.Parameters.Add(new CodeParameterDeclarationExpression("System.Int64", "globalId")); file.Members.Add(baseStringConstructorSimple); file.Members.Add(baseStringConstructor); List <EAPAttribute> attributes = new List <EAPAttribute>(); if (classPom.Attributes.Count > 0) { foreach (EAPAttribute attribut in classPom.Attributes) { CodeMemberField att = null; if (attribut.MeasurementType != "") { if (Enum.IsDefined(typeof(MeasurementType), attribut.MeasurementType.ToUpper()) || attribut.MeasurementType.Contains("List<") || attribut.TypeCode.Equals("Enum") || attribut.TypeCode.Equals("Class")) { if (attribut.Max == "*") { nameSpace.Imports.Add(new CodeNamespaceImport("System.Collections.Generic")); string fieldName = attribut.Name; att = new CodeMemberField(new CodeTypeReference("List", new CodeTypeReference[] { new CodeTypeReference(attribut.MeasurementType.Split('<', '>')[1]) }), fieldName); att.Attributes = MemberAttributes.Private | MemberAttributes.Final; att.InitExpression = new CodeObjectCreateExpression(new CodeTypeReference("List", new CodeTypeReference[] { new CodeTypeReference(attribut.MeasurementType.Split('<', '>')[1]) })); if (!string.IsNullOrEmpty(attribut.Description)) { att.Comments.Add(new CodeCommentStatement(attribut.Description, true)); } file.Members.Add(att); CreatePropertyForField(file, att, true, true); } else { string fieldName = attribut.Name; string type = attribut.MeasurementType; // att = new CodeMemberField(StringManipulationManager.GetSystemType(type), fieldName); if (attribut.TypeCode != null && attribut.TypeCode != "") { if (attribut.TypeCode.Equals("Enum")) { att = new CodeMemberField(attribut.MeasurementType, fieldName); } if (attribut.TypeCode.Equals("Class")) { att = new CodeMemberField(attribut.MeasurementType, fieldName); } } else { att = new CodeMemberField(StringManipulationManager.GetSystemType(type), fieldName); } att.Attributes = MemberAttributes.Private | MemberAttributes.Final; if (!string.IsNullOrEmpty(attribut.Description)) { att.Comments.Add(new CodeCommentStatement(attribut.Description, true)); } if (type.Equals("long") && attribut.IsReference == true) { att.InitExpression = new CodeSnippetExpression("0"); } file.Members.Add(att); //property for the field CreatePropertyForField(file, attribut, att, true, true); } } else { continue; } } } if (IsDbSelected && flagDb == false) { GenerateIDForDb(file, classPom.Name); // generate id if db checbox is selected } if (flagDb) { GenerateEqualsMethod(file, classPom); GenerateHashCodeMethod(file, classPom); GenerateGetProperty(file, classPom); GenerateHasPropertyMethod(file, classPom); GenerateSetPropertyMethod(file, classPom); GenerateIsReferencedProperty(file, classPom); GenerateGetReferencesMethod(file, classPom); GenerateAddreferenceMethod(file, classPom); GenerateRemoveReferencMethod(file, classPom); } } else { if (flagDb) { GenerateEqualsMethod(file, classPom); GenerateHashCodeMethod(file, classPom); GenerateGetProperty(file, classPom); GenerateHasPropertyMethod(file, classPom); GenerateSetPropertyMethod(file, classPom); GenerateGetReferencesMethod(file, classPom); } } nameSpace.Types.Add(file); return(unit); }