/// <summary> /// Returns the domain ID for the given attribute type. /// </summary> /// <param name="kind">The attribute kind</param> /// <param name="enumAttrType">For enums, enumAttrType must be valid. Otherwise it may be null.</param> /// <returns></returns> protected String GetDomainID(AttributeKind kind, EnumAttributeType enumAttrType) { switch (kind) { case AttributeKind.BooleanAttr: return("DM_bool"); case AttributeKind.DoubleAttr: return("DM_double"); case AttributeKind.FloatAttr: return("DM_float"); case AttributeKind.ByteAttr: return("DM_byte"); case AttributeKind.ShortAttr: return("DM_short"); case AttributeKind.IntegerAttr: return("DM_int"); case AttributeKind.LongAttr: return("DM_long"); case AttributeKind.StringAttr: return("DM_string"); case AttributeKind.EnumAttr: return("DM_enum_" + enumAttrType.Name); default: throw new Exception("Unsupported attribute value type: \"" + kind + "\""); } }
/// <summary> /// Initializes an AttributeType instance. /// </summary> /// <param name="name">The name for the attribute.</param> /// <param name="ownerType">The owner model type.</param> /// <param name="kind">The kind of the attribute.</param> /// <param name="enumType">The enum type description, if Kind == AttributeKind.EnumAttr, otherwise null.</param> /// <param name="valueType">The attribute type of the value of the set, if Kind == AttributeKind.SetAttr; the attribute type of the value of the map, if Kind == AttributeKind.MapAttr; the attribute type of the value of the array, if Kind == AttributeKind.ArrayAttr; the attribute type of the value of the deque, if Kind == AttributeKind.DequeAttr; otherwise null. </param> /// <param name="keyType">The attribute type of the key of the map, if Kind == AttributeKind.MapAttr; otherwise null.</param> /// <param name="typeName">The name of the attribute type, if Kind == AttributeKind.NodeAttr || Kind == AttributeKind.EdgeAttr; otherwise null.</param> /// <param name="package">The package name if this is a node or edge type that is contained in a package, otherwise null.</param> /// <param name="packagePrefixedTypeName">The name of the attribute type with the package as prefix if it is contained in a package, if Kind == AttributeKind.NodeAttr || Kind == AttributeKind.EdgeAttr.</param> /// <param name="type">The type of the attribute type.</param> public AttributeType(String name, InheritanceType ownerType, AttributeKind kind, EnumAttributeType enumType, AttributeType valueType, AttributeType keyType, String typeName, String package, String packagePrefixedTypeName, Type type) { Name = name; OwnerType = ownerType; Kind = kind; EnumType = enumType; ValueType = valueType; KeyType = keyType; TypeName = typeName; Package = package; PackagePrefixedTypeName = packagePrefixedTypeName; Type = type; }
protected void WriteEnumType(EnumAttributeType enumType) { String enumid = GetDomainID(enumType); WriteGXLNode(enumid, "Enum"); foreach (EnumMember member in enumType.Members) { String memberid = "EV_"; if ((int)member.Value < 0) { memberid += "_" + (-member.Value); } else { memberid += member.Value.ToString(); } memberid += "_" + member.Name; WriteGXLNode(memberid, "EnumVal", new Attr("value", "string", member.Name)); WriteGXLEdge(enumid, memberid, "containsValue"); } }
protected String GetDomainID(EnumAttributeType enumAttrType) { return(GetDomainID(AttributeKind.EnumAttr, enumAttrType)); }
/// <summary> /// Returns a string representation of the given scalar value /// </summary> /// <param name="value">The scalar of which to get the string representation</param> /// <param name="attrType">The attribute type</param> /// <param name="graph">The graph with the model and the element names</param> /// <returns>String representation of the scalar.</returns> private static string ToString(object value, AttributeType attrType, IGraph graph) { // enums are bitches, sometimes ToString gives the symbolic name, sometimes only the integer value // we always want the symbolic name, enforce this here if (attrType != null && attrType.Kind == AttributeKind.EnumAttr) { Debug.Assert(attrType.Kind != AttributeKind.SetAttr && attrType.Kind != AttributeKind.MapAttr); EnumAttributeType enumAttrType = attrType.EnumType; EnumMember member = enumAttrType[(int)value]; if (member != null) { return(member.Name); } } if (graph != null && value is Enum) { Debug.Assert(value.GetType().Name != "Dictionary`2" && value.GetType().Name != "List`1" && value.GetType().Name != "Deque`1"); foreach (EnumAttributeType enumAttrType in graph.Model.EnumAttributeTypes) { if (value.GetType() == enumAttrType.EnumType) { EnumMember member = enumAttrType[(int)value]; if (member != null) { return(member.Name); } else { break; } } } } // for set/map entries of node/edge type return the persistent name if (attrType != null && (attrType.Kind == AttributeKind.NodeAttr || attrType.Kind == AttributeKind.EdgeAttr)) { if (graph != null && value != null) { return(((INamedGraph)graph).GetElementName((IGraphElement)value)); } } if (value is IGraphElement) { if (graph != null) { return(((INamedGraph)graph).GetElementName((IGraphElement)value)); } } // we return "" for null as null is a valid string denoting the empty string in GrGen (dubious performance optimization) if (value == null) { return(""); } else { if (value is double) { return(((double)value).ToString(System.Globalization.CultureInfo.InvariantCulture)); } else if (value is float) { return(((float)value).ToString(System.Globalization.CultureInfo.InvariantCulture) + "f"); } else { return(value.ToString()); } } }