public override void Assign(object value, IGraphProcessingEnvironment procEnv) { IGraphElement elem = (IGraphElement)DestVar.GetVariableValue(procEnv); object container = elem.GetAttribute(AttributeName); object key = KeyExpression.Evaluate(procEnv); AttributeType attrType = elem.Type.GetAttributeType(AttributeName); BaseGraph.ChangingAttributeAssignElement(procEnv.Graph, elem, attrType, value, key); if(container is IList) { IList array = (IList)container; array[(int)key] = value; } else if(container is IDeque) { IDeque deque = (IDeque)container; deque[(int)key] = value; } else { IDictionary map = (IDictionary)container; map[key] = value; } BaseGraph.ChangedAttribute(procEnv.Graph, elem, attrType); }
public static object GetGraphElementAttributeOrElementOfMatch(object source, string attributeOrElementName) { if (source is IMatch) { IMatch match = (IMatch)source; object value = match.getNode(attributeOrElementName); if (value != null) { return(value); } value = match.getEdge(attributeOrElementName); if (value != null) { return(value); } value = match.getVariable(attributeOrElementName); return(value); } else { IGraphElement elem = (IGraphElement)source; object value = elem.GetAttribute(attributeOrElementName); value = ContainerHelper.IfAttributeOfElementIsContainerThenCloneContainer( elem, attributeOrElementName, value); return(value); } }
protected void WriteAttributes(IGraphElement elem) { foreach(AttributeType attrType in elem.Type.AttributeTypes) { object value = elem.GetAttribute(attrType.Name); String valuestr = (value == null) ? "" : value.ToString(); switch(attrType.Kind) { case AttributeKind.BooleanAttr: case AttributeKind.DoubleAttr: case AttributeKind.FloatAttr: case AttributeKind.ByteAttr: case AttributeKind.ShortAttr: case AttributeKind.IntegerAttr: case AttributeKind.LongAttr: case AttributeKind.StringAttr: xmlwriter.WriteAttributeString(RemoveGrGenPrefix(attrType.Name), valuestr); break; case AttributeKind.EnumAttr: xmlwriter.WriteAttributeString(RemoveGrGenPrefix(attrType.Name), RemoveGrGenPrefix(valuestr)); break; default: throw new Exception("Unsupported attribute value type: \"" + attrType.Kind + "\""); } } }
private String GetElemLabelWithChangedAttr(IGraphElement elem, AttributeType changedAttrType, object newValue) { List <InfoTag> infoTagTypes = dumpInfo.GetTypeInfoTags(elem.Type); String infoTagStr = ""; if (infoTagTypes != null) { foreach (InfoTag infoTag in infoTagTypes) { object attr; if (infoTag.AttributeType == changedAttrType) { attr = newValue; } else { attr = elem.GetAttribute(infoTag.AttributeType.Name); } if (attr == null) { continue; } infoTagStr += "\\n" + infoTag.AttributeType.Name + " = " + attr.ToString(); } } return(dumpInfo.GetElementName(elem) + ":" + elem.Type.Name + infoTagStr); }
/// <summary> /// Dumps all attributes in the form "kind owner::name = value" into a String List /// </summary> /// <param name="elem">IGraphElement which attributes are to be dumped</param> /// <returns>A String List containing the dumped attributes </returns> private List <String> DumpAttributes(IGraphElement elem) { List <String> attribs = new List <String>(); foreach (AttributeType attrType in elem.Type.AttributeTypes) { object attr = elem.GetAttribute(attrType.Name); String attrString; if (attr != null) { if (attr is double) { attrString = ((double)attr).ToString(System.Globalization.CultureInfo.InvariantCulture); } else if (attr is float) { attrString = ((float)attr).ToString(System.Globalization.CultureInfo.InvariantCulture) + "f"; } else { attrString = attr.ToString(); } } else { attrString = "<Not initialized>"; } attribs.Add(String.Format("{0} {1}::{2} = {3}", GetKindName(attrType), attrType.OwnerType.Name, attrType.Name, attrString)); } return(attribs); }
private static void ExtractAttribute(IList array, string attribute, IList extractedArray) { foreach (object element in array) { IGraphElement graphElement = (IGraphElement)element; extractedArray.Add(graphElement.GetAttribute(attribute)); } }
protected List <Attr> GetAttributes(IGraphElement elem) { List <Attr> attrs = new List <Attr>(); foreach (AttributeType attrType in elem.Type.AttributeTypes) { object value = elem.GetAttribute(attrType.Name); String valType; String valuestr = (value == null) ? "" : value.ToString(); switch (attrType.Kind) { case AttributeKind.BooleanAttr: valType = "bool"; valuestr = ((bool)value) ? "true" : "false"; break; case AttributeKind.DoubleAttr: case AttributeKind.FloatAttr: valType = "double"; if (value is float) { valuestr = ((float)value).ToString(System.Globalization.CultureInfo.InvariantCulture); } else { valuestr = ((double)value).ToString(System.Globalization.CultureInfo.InvariantCulture); } break; case AttributeKind.ByteAttr: case AttributeKind.ShortAttr: case AttributeKind.IntegerAttr: case AttributeKind.LongAttr: valType = "int"; break; // TODO: This does not allow differentiating between empty and null strings case AttributeKind.StringAttr: valType = "string"; break; case AttributeKind.EnumAttr: valType = "enum"; break; default: throw new Exception("Unsupported attribute value type: \"" + attrType.Kind + "\""); } attrs.Add(new Attr(attrType.Name, valType, valuestr)); } return(attrs); }
/// <summary> /// Dumps all attributes in the form "kind owner::name = value" into a String List /// </summary> /// <param name="elem">IGraphElement which attributes are to be dumped</param> /// <returns>A String List containing the dumped attributes </returns> private static List <String> DumpAttributes(IGraphElement elem) { List <String> attribs = new List <String>(); foreach (AttributeType attrType in elem.Type.AttributeTypes) { object attr = elem.GetAttribute(attrType.Name); String attrString = (attr != null) ? attr.ToString() : "<Not initialized>"; attribs.Add(String.Format("{0}::{1} : {2} = {3}", attrType.OwnerType.Name, attrType.Name, attrType.GetKindName(), attrString)); } return(attribs); }
private void EncodeAttr(AttributeType attrType, IGraphElement elem, out String attrTypeString, out String attrValueString) { if (attrType.Kind == AttributeKind.SetAttr || attrType.Kind == AttributeKind.MapAttr) { EmitHelper.ToString((IDictionary)elem.GetAttribute(attrType.Name), out attrTypeString, out attrValueString, attrType, graph); attrValueString = Encode(attrValueString); } else if (attrType.Kind == AttributeKind.ArrayAttr) { EmitHelper.ToString((IList)elem.GetAttribute(attrType.Name), out attrTypeString, out attrValueString, attrType, graph); attrValueString = Encode(attrValueString); } else if (attrType.Kind == AttributeKind.DequeAttr) { EmitHelper.ToString((IDeque)elem.GetAttribute(attrType.Name), out attrTypeString, out attrValueString, attrType, graph); attrValueString = Encode(attrValueString); } else { EmitHelper.ToString(elem.GetAttribute(attrType.Name), out attrTypeString, out attrValueString, attrType, graph); attrValueString = Encode(attrValueString); } }
/// <summary> /// If the attribute of the given name of the given element is a container attribute /// then return a clone of the given container value, otherwise just return the original value; /// additionally returns the AttributeType of the attribute of the element. /// </summary> public static object IfAttributeOfElementIsContainerThenCloneContainer( IGraphElement element, String AttributeName, object value, out AttributeType attrType) { attrType = element.Type.GetAttributeType(AttributeName); if (attrType.Kind == AttributeKind.SetAttr || attrType.Kind == AttributeKind.MapAttr) { Type keyType, valueType; ContainerHelper.GetDictionaryTypes(element.GetAttribute(AttributeName), out keyType, out valueType); return(ContainerHelper.NewDictionary(keyType, valueType, value)); // by-value-semantics -> clone dictionary } else if (attrType.Kind == AttributeKind.ArrayAttr) { Type valueType; ContainerHelper.GetListType(element.GetAttribute(AttributeName), out valueType); return(ContainerHelper.NewList(valueType, value)); // by-value-semantics -> clone array } else if (attrType.Kind == AttributeKind.DequeAttr) { Type valueType; ContainerHelper.GetDequeType(element.GetAttribute(AttributeName), out valueType); return(ContainerHelper.NewDeque(valueType, value)); // by-value-semantics -> clone deque } return(value); }
private static String GetElemLabel(IGraphElement elem, DumpInfo dumpInfo) { List <InfoTag> infoTagTypes = dumpInfo.GetTypeInfoTags(elem.Type); String label = dumpInfo.GetElemTypeLabel(elem.Type); bool first = true; if (label == null) { label = dumpInfo.GetElementName(elem) + ":" + elem.Type.Name; first = false; } if (infoTagTypes != null) { foreach (InfoTag infoTag in infoTagTypes) { object attr = elem.GetAttribute(infoTag.AttributeType.Name); if (attr == null) { continue; } if (!first) { label += "\n"; } else { first = false; } if (infoTag.ShortInfoTag) { label += attr.ToString(); } else { label += infoTag.AttributeType.Name + " = " + attr.ToString(); } } } return(label); }
private String GetElemLabel(IGraphElement elem) { List <InfoTag> infoTagTypes = dumpInfo.GetTypeInfoTags(elem.Type); String infoTagStr = ""; if (infoTagTypes != null) { foreach (InfoTag infoTag in infoTagTypes) { object attr = elem.GetAttribute(infoTag.AttributeType.Name); if (attr == null) { continue; } infoTagStr += "\\n" + infoTag.AttributeType.Name + " = " + attr.ToString(); } } return(dumpInfo.GetElementName(elem) + ":" + elem.Type.Name + infoTagStr); }
private void EncodeAttr(AttributeType attrType, IGraphElement elem, out String attrTypeString, out String attrValueString) { if (attrType.Kind == AttributeKind.SetAttr || attrType.Kind == AttributeKind.MapAttr) { EmitHelper.ToString((IDictionary)elem.GetAttribute(attrType.Name), out attrTypeString, out attrValueString, attrType, graph); attrValueString = Encode(attrValueString); } else if(attrType.Kind == AttributeKind.ArrayAttr) { EmitHelper.ToString((IList)elem.GetAttribute(attrType.Name), out attrTypeString, out attrValueString, attrType, graph); attrValueString = Encode(attrValueString); } else if(attrType.Kind == AttributeKind.DequeAttr) { EmitHelper.ToString((IDeque)elem.GetAttribute(attrType.Name), out attrTypeString, out attrValueString, attrType, graph); attrValueString = Encode(attrValueString); } else { EmitHelper.ToString(elem.GetAttribute(attrType.Name), out attrTypeString, out attrValueString, attrType, graph); attrValueString = Encode(attrValueString); } }
private void ContainerAddIndexed(IGraphElement elem, String attrName, object keyObj, object valueObj) { object attr = elem.GetAttribute(attrName); if(attr is IDictionary) { IDictionary dict = attr as IDictionary; dict[keyObj] = valueObj; } else if(attr is IList) { IList array = attr as IList; array.Insert((int)valueObj, keyObj); } else if(attr is IDeque) { IDeque deque = attr as IDeque; deque.EnqueueAt((int)valueObj, keyObj); } else throw new Exception(graph.GetElementName(elem) + "." + attrName + " is neither a map nor an array nor a deque."); }
//Stolen from GXLExport.cs private string CanonizeElement (IGraphElement elem) { List<String> attributes = new List<String> (); foreach (AttributeType attrType in elem.Type.AttributeTypes) { object value = elem.GetAttribute (attrType.Name); String valType; String valuestr = (value == null) ? "" : value.ToString (); switch (attrType.Kind) { case AttributeKind.BooleanAttr: valType = "bool"; valuestr = ((bool)value) ? "true" : "false"; break; case AttributeKind.DoubleAttr: case AttributeKind.FloatAttr: valType = "double"; valuestr = ((double)value).ToString(System.Globalization.CultureInfo.InvariantCulture); break; case AttributeKind.ByteAttr: case AttributeKind.ShortAttr: case AttributeKind.IntegerAttr: case AttributeKind.LongAttr: valType = "int"; break; // TODO: This does not allow differentiating between empty and null strings case AttributeKind.StringAttr: valType = "string"; valuestr= "\"" + valuestr + "\""; break; case AttributeKind.EnumAttr: valType = "enum"; break; default: throw new Exception ("Unsupported attribute value type: \"" + attrType.Kind + "\""); } attributes.Add (attrType.Name + ":" + valType + ":" + valuestr); } attributes.Sort ((x,y) => x.CompareTo (y)); string elemTypeName = null; string elemClassName = elem.GetType ().Name; if (elem is INode) { elemTypeName = "Node"; } else if (elem is IEdge) { elemTypeName = "Edge"; } else { elemTypeName = "Unsupported Graph Element Type"; } StringBuilder sb = new StringBuilder (elemClassName + ":" + elemTypeName); if (attributes.Count > 0) { sb.Append (","); for (int i=0; i< (attributes.Count-1); i++) { sb.Append (attributes [i] + ","); } } if(attributes.Count > 0) sb.Append(attributes[attributes.Count-1]); return sb.ToString(); }
//Stolen from GXLExport.cs private string CanonizeElement(IGraphElement elem) { List <String> attributes = new List <String>(); foreach (AttributeType attrType in elem.Type.AttributeTypes) { object value = elem.GetAttribute(attrType.Name); String valType; String valuestr = (value == null) ? "" : value.ToString(); switch (attrType.Kind) { case AttributeKind.BooleanAttr: valType = "bool"; valuestr = ((bool)value) ? "true" : "false"; break; case AttributeKind.DoubleAttr: case AttributeKind.FloatAttr: valType = "double"; valuestr = ((double)value).ToString(System.Globalization.CultureInfo.InvariantCulture); break; case AttributeKind.ByteAttr: case AttributeKind.ShortAttr: case AttributeKind.IntegerAttr: case AttributeKind.LongAttr: valType = "int"; break; // TODO: This does not allow differentiating between empty and null strings case AttributeKind.StringAttr: valType = "string"; valuestr = "\"" + valuestr + "\""; break; case AttributeKind.EnumAttr: valType = "enum"; break; default: throw new Exception("Unsupported attribute value type: \"" + attrType.Kind + "\""); } attributes.Add(attrType.Name + ":" + valType + ":" + valuestr); } attributes.Sort((x, y) => x.CompareTo(y)); string elemTypeName = null; string elemClassName = elem.GetType().Name; if (elem is INode) { elemTypeName = "Node"; } else if (elem is IEdge) { elemTypeName = "Edge"; } else { elemTypeName = "Unsupported Graph Element Type"; } StringBuilder sb = new StringBuilder(elemClassName + ":" + elemTypeName); if (attributes.Count > 0) { sb.Append(","); for (int i = 0; i < (attributes.Count - 1); ++i) { sb.Append(attributes [i] + ","); } } if (attributes.Count > 0) { sb.Append(attributes[attributes.Count - 1]); } return(sb.ToString()); }
public object ExecuteNoImplicitContainerCopy(IGraphProcessingEnvironment procEnv, out IGraphElement elem, out AttributeType attrType) { elem = SourceValue(procEnv); object value = elem.GetAttribute(AttributeName); attrType = elem.Type.GetAttributeType(AttributeName); return value; }
private static bool AddSubgraphAsNeeded(MainGraphExportContext mainGraphContext, IGraphElement elem, AttributeType attrType) { if(attrType.Kind == AttributeKind.GraphAttr) return AddSubgraphAsNeeded(mainGraphContext, (INamedGraph)elem.GetAttribute(attrType.Name)); bool graphAdded = false; if(attrType.Kind == AttributeKind.SetAttr || attrType.Kind == AttributeKind.MapAttr || attrType.Kind == AttributeKind.ArrayAttr || attrType.Kind == AttributeKind.DequeAttr) { if(attrType.ValueType.Kind == AttributeKind.GraphAttr) { if(attrType.Kind == AttributeKind.SetAttr) { IDictionary set = (IDictionary)elem.GetAttribute(attrType.Name); foreach(DictionaryEntry entry in set) { graphAdded |= AddSubgraphAsNeeded(mainGraphContext, (INamedGraph)entry.Key); } } else if(attrType.Kind == AttributeKind.MapAttr) { IDictionary map = (IDictionary)elem.GetAttribute(attrType.Name); foreach(DictionaryEntry entry in map) { graphAdded |= AddSubgraphAsNeeded(mainGraphContext, (INamedGraph)entry.Value); } } else if(attrType.Kind == AttributeKind.ArrayAttr) { IList array = (IList)elem.GetAttribute(attrType.Name); foreach(object entry in array) { graphAdded |= AddSubgraphAsNeeded(mainGraphContext, (INamedGraph)entry); } } else if(attrType.Kind == AttributeKind.DequeAttr) { IDeque deque = (IDeque)elem.GetAttribute(attrType.Name); foreach(object entry in deque) { graphAdded |= AddSubgraphAsNeeded(mainGraphContext, (INamedGraph)entry); } } } } if(attrType.Kind == AttributeKind.MapAttr) { if(attrType.KeyType.Kind == AttributeKind.GraphAttr) { IDictionary map = (IDictionary)elem.GetAttribute(attrType.Name); foreach(DictionaryEntry entry in map) { graphAdded |= AddSubgraphAsNeeded(mainGraphContext, (INamedGraph)entry.Key); } } } return graphAdded; }
public void DoUndo(IGraphProcessingEnvironment procEnv) { String attrName = _attrType.Name; LGSPGraphProcessingEnvironment procEnv_ = (LGSPGraphProcessingEnvironment)procEnv; if (_undoOperation == UndoOperation.PutElement) { if (_attrType.Kind == AttributeKind.SetAttr) { ChangingElementAttribute(procEnv_); IDictionary dict = (IDictionary)_elem.GetAttribute(_attrType.Name); dict.Add(_value, null); } else if (_attrType.Kind == AttributeKind.MapAttr) { ChangingElementAttribute(procEnv_); IDictionary dict = (IDictionary)_elem.GetAttribute(_attrType.Name); dict.Add(_keyOfValue, _value); } else if (_attrType.Kind == AttributeKind.ArrayAttr) { ChangingElementAttribute(procEnv_); IList array = (IList)_elem.GetAttribute(_attrType.Name); if (_keyOfValue == null) { array.Add(_value); } else { array.Insert((int)_keyOfValue, _value); } } else //if(_attrType.Kind == AttributeKind.DequeAttr) { ChangingElementAttribute(procEnv_); IDeque deque = (IDeque)_elem.GetAttribute(_attrType.Name); if (_keyOfValue == null) { deque.EnqueueFront(_value); } else { deque.EnqueueAt((int)_keyOfValue, _value); } } } else if (_undoOperation == UndoOperation.RemoveElement) { if (_attrType.Kind == AttributeKind.SetAttr) { ChangingElementAttribute(procEnv_); IDictionary dict = (IDictionary)_elem.GetAttribute(_attrType.Name); dict.Remove(_value); } else if (_attrType.Kind == AttributeKind.MapAttr) { ChangingElementAttribute(procEnv_); IDictionary dict = (IDictionary)_elem.GetAttribute(_attrType.Name); dict.Remove(_keyOfValue); } else if (_attrType.Kind == AttributeKind.ArrayAttr) { ChangingElementAttribute(procEnv_); IList array = (IList)_elem.GetAttribute(_attrType.Name); if (_keyOfValue == null) { array.RemoveAt(array.Count - 1); } else { array.RemoveAt((int)_keyOfValue); } } else //if(_attrType.Kind == AttributeKind.DequeAttr) { ChangingElementAttribute(procEnv_); IDeque deque = (IDeque)_elem.GetAttribute(_attrType.Name); if (_keyOfValue == null) { deque.DequeueBack(); } else { deque.DequeueAt((int)_keyOfValue); } } } else if (_undoOperation == UndoOperation.AssignElement) { if (_attrType.Kind == AttributeKind.ArrayAttr) { ChangingElementAttribute(procEnv_); IList array = (IList)_elem.GetAttribute(_attrType.Name); array[(int)_keyOfValue] = _value; } else if (_attrType.Kind == AttributeKind.DequeAttr) { ChangingElementAttribute(procEnv_); IDeque deque = (IDeque)_elem.GetAttribute(_attrType.Name); deque[(int)_keyOfValue] = _value; } else //if(_attrType.Kind == AttributeKind.MapAttr) { ChangingElementAttribute(procEnv_); IDictionary dict = (IDictionary)_elem.GetAttribute(_attrType.Name); dict[_keyOfValue] = _value; } } else if (_undoOperation == UndoOperation.Assign) { ChangingElementAttribute(procEnv_); _elem.SetAttribute(attrName, _value); } // otherwise UndoOperation.None }
private void ParseAttributeValueIndexed(IGraphElement elem, AttributeType attrType, string attrName, object index) { object value = ParseAttributeSimpleValue(attrType); object attr = elem.GetAttribute(attrName); if(attr is IList) { IList array = (IList)attr; array[(int)index] = value; } else if(attr is IDeque) { IDeque deque = (IDeque)attr; deque[(int)index] = value; } else { IDictionary setmap = (IDictionary)attr; setmap[index] = value; } }
private void ContainerRem(IGraphElement elem, String attrName, object keyObj) { object attr = elem.GetAttribute(attrName); if(attr is IDictionary) { IDictionary dict = attr as IDictionary; dict.Remove(keyObj); } else if(attr is IList) { IList array = attr as IList; if(keyObj != null) array.RemoveAt((int)keyObj); else array.RemoveAt(array.Count - 1); } else if(attr is IDeque) { IDeque deque = attr as IDeque; if(keyObj != null) deque.DequeueAt((int)keyObj); else deque.Dequeue(); } else throw new Exception(graph.GetElementName(elem) + "." + attrName + " is not a container."); }
public IGraph _graph; // for ToString only public LGSPUndoAttributeChanged(IGraphElement elem, AttributeType attrType, AttributeChangeType changeType, Object newValue, Object keyValue, LGSPGraphProcessingEnvironment procEnv) { _elem = elem; _attrType = attrType; if(procEnv.graph is LGSPNamedGraph) _name = ((LGSPNamedGraph)procEnv.graph).GetElementName(_elem); else _name = "?"; _graph = procEnv.graph; if (_attrType.Kind == AttributeKind.SetAttr) { if (changeType == AttributeChangeType.PutElement) { IDictionary dict = (IDictionary)_elem.GetAttribute(_attrType.Name); if (dict.Contains(newValue)) { _undoOperation = UndoOperation.None; } else { _undoOperation = UndoOperation.RemoveElement; _value = newValue; } } else if (changeType == AttributeChangeType.RemoveElement) { IDictionary dict = (IDictionary)_elem.GetAttribute(_attrType.Name); if (dict.Contains(newValue)) { _undoOperation = UndoOperation.PutElement; _value = newValue; } else { _undoOperation = UndoOperation.None; } } else // Assign { Type keyType, valueType; IDictionary dict = ContainerHelper.GetDictionaryTypes( _elem.GetAttribute(_attrType.Name), out keyType, out valueType); IDictionary clonedDict = ContainerHelper.NewDictionary(keyType, valueType, dict); _undoOperation = UndoOperation.Assign; _value = clonedDict; } } else if (_attrType.Kind == AttributeKind.ArrayAttr) { if (changeType == AttributeChangeType.PutElement) { IList array = (IList)_elem.GetAttribute(_attrType.Name); _undoOperation = UndoOperation.RemoveElement; _keyOfValue = keyValue; } else if (changeType == AttributeChangeType.RemoveElement) { IList array = (IList)_elem.GetAttribute(_attrType.Name); _undoOperation = UndoOperation.PutElement; if(keyValue == null) { _value = array[array.Count-1]; } else { _value = array[(int)keyValue]; _keyOfValue = keyValue; } } else if(changeType == AttributeChangeType.AssignElement) { IList array = (IList)_elem.GetAttribute(_attrType.Name); _undoOperation = UndoOperation.AssignElement; _value = array[(int)keyValue]; _keyOfValue = keyValue; } else // Assign { Type valueType; IList array = ContainerHelper.GetListType( _elem.GetAttribute(_attrType.Name), out valueType); IList clonedArray = ContainerHelper.NewList(valueType, array); _undoOperation = UndoOperation.Assign; _value = clonedArray; } } else if(_attrType.Kind == AttributeKind.DequeAttr) { if(changeType == AttributeChangeType.PutElement) { IDeque deque = (IDeque)_elem.GetAttribute(_attrType.Name); _undoOperation = UndoOperation.RemoveElement; _keyOfValue = keyValue; } else if(changeType == AttributeChangeType.RemoveElement) { IDeque deque = (IDeque)_elem.GetAttribute(_attrType.Name); _undoOperation = UndoOperation.PutElement; if(keyValue == null) { _value = deque.Front; } else { _value = deque[(int)keyValue]; _keyOfValue = keyValue; } } else if(changeType == AttributeChangeType.AssignElement) { IDeque deque = (IDeque)_elem.GetAttribute(_attrType.Name); _undoOperation = UndoOperation.AssignElement; _value = deque[(int)keyValue]; _keyOfValue = keyValue; } else // Assign { Type valueType; IDeque deque = ContainerHelper.GetDequeType( _elem.GetAttribute(_attrType.Name), out valueType); IDeque clonedDeque = ContainerHelper.NewDeque(valueType, deque); _undoOperation = UndoOperation.Assign; _value = clonedDeque; } } else if(_attrType.Kind == AttributeKind.MapAttr) { if (changeType == AttributeChangeType.PutElement) { IDictionary dict = (IDictionary)_elem.GetAttribute(_attrType.Name); if (dict.Contains(keyValue)) { if (dict[keyValue] == newValue) { _undoOperation = UndoOperation.None; } else { _undoOperation = UndoOperation.PutElement; _value = dict[keyValue]; _keyOfValue = keyValue; } } else { _undoOperation = UndoOperation.RemoveElement; _value = newValue; _keyOfValue = keyValue; } } else if (changeType == AttributeChangeType.RemoveElement) { IDictionary dict = (IDictionary)_elem.GetAttribute(_attrType.Name); if (dict.Contains(keyValue)) { _undoOperation = UndoOperation.PutElement; _value = dict[keyValue]; _keyOfValue = keyValue; } else { _undoOperation = UndoOperation.None; } } else if(changeType == AttributeChangeType.AssignElement) { IDictionary dict = (IDictionary)_elem.GetAttribute(_attrType.Name); if(dict[keyValue] == newValue) { _undoOperation = UndoOperation.None; } else { _undoOperation = UndoOperation.AssignElement; _value = dict[keyValue]; _keyOfValue = keyValue; } } else // Assign { Type keyType, valueType; IDictionary dict = ContainerHelper.GetDictionaryTypes( _elem.GetAttribute(_attrType.Name), out keyType, out valueType); IDictionary clonedDict = ContainerHelper.NewDictionary(keyType, valueType, dict); _undoOperation = UndoOperation.Assign; _value = clonedDict; } } else // Primitve Type Assign { _undoOperation = UndoOperation.Assign; _value = _elem.GetAttribute(_attrType.Name); } }
private static bool AddSubgraphAsNeeded(MainGraphExportContext mainGraphContext, IGraphElement elem, AttributeType attrType) { if (attrType.Kind == AttributeKind.GraphAttr) { return(AddSubgraphAsNeeded(mainGraphContext, (INamedGraph)elem.GetAttribute(attrType.Name))); } bool graphAdded = false; if (attrType.Kind == AttributeKind.SetAttr || attrType.Kind == AttributeKind.MapAttr || attrType.Kind == AttributeKind.ArrayAttr || attrType.Kind == AttributeKind.DequeAttr) { if (attrType.ValueType.Kind == AttributeKind.GraphAttr) { if (attrType.Kind == AttributeKind.SetAttr) { IDictionary set = (IDictionary)elem.GetAttribute(attrType.Name); foreach (DictionaryEntry entry in set) { graphAdded |= AddSubgraphAsNeeded(mainGraphContext, (INamedGraph)entry.Key); } } else if (attrType.Kind == AttributeKind.MapAttr) { IDictionary map = (IDictionary)elem.GetAttribute(attrType.Name); foreach (DictionaryEntry entry in map) { graphAdded |= AddSubgraphAsNeeded(mainGraphContext, (INamedGraph)entry.Value); } } else if (attrType.Kind == AttributeKind.ArrayAttr) { IList array = (IList)elem.GetAttribute(attrType.Name); foreach (object entry in array) { graphAdded |= AddSubgraphAsNeeded(mainGraphContext, (INamedGraph)entry); } } else if (attrType.Kind == AttributeKind.DequeAttr) { IDeque deque = (IDeque)elem.GetAttribute(attrType.Name); foreach (object entry in deque) { graphAdded |= AddSubgraphAsNeeded(mainGraphContext, (INamedGraph)entry); } } } } if (attrType.Kind == AttributeKind.MapAttr) { if (attrType.KeyType.Kind == AttributeKind.GraphAttr) { IDictionary map = (IDictionary)elem.GetAttribute(attrType.Name); foreach (DictionaryEntry entry in map) { graphAdded |= AddSubgraphAsNeeded(mainGraphContext, (INamedGraph)entry.Key); } } } return(graphAdded); }
private static String GetElemLabel(IGraphElement elem, DumpInfo dumpInfo) { List<InfoTag> infoTagTypes = dumpInfo.GetTypeInfoTags(elem.Type); String label = dumpInfo.GetElemTypeLabel(elem.Type); bool first = true; if(label == null) { label = dumpInfo.GetElementName(elem) + ":" + elem.Type.Name; first = false; } if(infoTagTypes != null) { foreach(InfoTag infoTag in infoTagTypes) { object attr = elem.GetAttribute(infoTag.AttributeType.Name); if(attr == null) continue; if(!first) label += "\n"; else first = false; if(infoTag.ShortInfoTag) label += attr.ToString(); else label += infoTag.AttributeType.Name + " = " + attr.ToString(); } } return label; }
protected List<Attr> GetAttributes(IGraphElement elem) { List<Attr> attrs = new List<Attr>(); foreach(AttributeType attrType in elem.Type.AttributeTypes) { object value = elem.GetAttribute(attrType.Name); String valType; String valuestr = (value == null) ? "" : value.ToString(); switch(attrType.Kind) { case AttributeKind.BooleanAttr: valType = "bool"; valuestr = ((bool)value) ? "true" : "false"; break; case AttributeKind.DoubleAttr: case AttributeKind.FloatAttr: valType = "double"; if(value is float) valuestr = ((float)value).ToString(System.Globalization.CultureInfo.InvariantCulture); else valuestr = ((double)value).ToString(System.Globalization.CultureInfo.InvariantCulture); break; case AttributeKind.ByteAttr: case AttributeKind.ShortAttr: case AttributeKind.IntegerAttr: case AttributeKind.LongAttr: valType = "int"; break; // TODO: This does not allow differentiating between empty and null strings case AttributeKind.StringAttr: valType = "string"; break; case AttributeKind.EnumAttr: valType = "enum"; break; default: throw new Exception("Unsupported attribute value type: \"" + attrType.Kind + "\""); } attrs.Add(new Attr(attrType.Name, valType, valuestr)); } return attrs; }
public bool FetchObjectToBeShownAsGraph(Sequence seq, out object toBeShownAsGraph, out AttributeType attrType) { do { Console.WriteLine("Enter name of variable or attribute access to show as graph (just enter for abort): "); Console.WriteLine("Examples: \"v\", \"v.a\", \"@(\"$0\").a\" "); String str = Console.ReadLine(); if (str.Length == 0) { toBeShownAsGraph = null; attrType = null; return(true); } if (str.StartsWith("@")) { // graph element by name string attributeName; IGraphElement elem = ParseAccessByName(str, out attributeName); if (elem == null) { Console.WriteLine("Can't parse graph access / unknown graph element: " + str); continue; } if (attributeName == null) { Console.WriteLine("The result of a graph access is a node or edge, you must access an attribute: " + str); continue; } attrType = elem.Type.GetAttributeType(attributeName); if (attrType == null) { Console.WriteLine("Unknown attribute: " + attributeName); continue; } object attribute = elem.GetAttribute(attributeName); if (attribute == null) { Console.WriteLine("Null-valued attribute: " + attributeName); continue; } toBeShownAsGraph = attribute; return(false); } else { // variable string attributeName; object value = ParseVariable(str, seq, out attributeName); if (value == null) { Console.WriteLine("Can't parse variable / unknown variable / null-valued variable: " + str); continue; } if (attributeName != null) { if (!(value is IGraphElement)) { Console.WriteLine("Can't access attribute, the variable value is not a graph element: " + str); continue; } IGraphElement elem = (IGraphElement)value; attrType = elem.Type.GetAttributeType(attributeName); if (attrType == null) { Console.WriteLine("Unknown attribute: " + attributeName); continue; } object attribute = elem.GetAttribute(attributeName); if (attribute == null) { Console.WriteLine("Null-valued attribute: " + attributeName); continue; } toBeShownAsGraph = attribute; return(false); } else { attrType = null; toBeShownAsGraph = value; return(false); } } }while(true); }
private void ContainerAdd(IGraphElement elem, String attrName, object keyObj) { object attr = elem.GetAttribute(attrName); if(attr is IDictionary) { IDictionary dict = attr as IDictionary; dict[keyObj] = null; } else if(attr is IList) { IList array = attr as IList; array.Add(keyObj); } else if(attr is IDeque) { IDeque deque = attr as IDeque; deque.Enqueue(keyObj); } else throw new Exception(graph.GetElementName(elem) + "." + attrName + " is neither a set nor an array nor a deque."); }
public readonly IGraph _graph; // for ToString only public LGSPUndoAttributeChanged(IGraphElement elem, AttributeType attrType, AttributeChangeType changeType, Object newValue, Object keyValue, LGSPGraphProcessingEnvironment procEnv) { _elem = elem; _attrType = attrType; if (procEnv.graph is LGSPNamedGraph) { _name = ((LGSPNamedGraph)procEnv.graph).GetElementName(_elem); } else { _name = "?"; } _graph = procEnv.graph; if (_attrType.Kind == AttributeKind.SetAttr) { if (changeType == AttributeChangeType.PutElement) { IDictionary dict = (IDictionary)_elem.GetAttribute(_attrType.Name); if (dict.Contains(newValue)) { _undoOperation = UndoOperation.None; } else { _undoOperation = UndoOperation.RemoveElement; _value = newValue; } } else if (changeType == AttributeChangeType.RemoveElement) { IDictionary dict = (IDictionary)_elem.GetAttribute(_attrType.Name); if (dict.Contains(newValue)) { _undoOperation = UndoOperation.PutElement; _value = newValue; } else { _undoOperation = UndoOperation.None; } } else // Assign { Type keyType; Type valueType; IDictionary dict = ContainerHelper.GetDictionaryTypes( _elem.GetAttribute(_attrType.Name), out keyType, out valueType); IDictionary clonedDict = ContainerHelper.NewDictionary(keyType, valueType, dict); _undoOperation = UndoOperation.Assign; _value = clonedDict; } } else if (_attrType.Kind == AttributeKind.ArrayAttr) { if (changeType == AttributeChangeType.PutElement) { IList array = (IList)_elem.GetAttribute(_attrType.Name); _undoOperation = UndoOperation.RemoveElement; _keyOfValue = keyValue; } else if (changeType == AttributeChangeType.RemoveElement) { IList array = (IList)_elem.GetAttribute(_attrType.Name); _undoOperation = UndoOperation.PutElement; if (keyValue == null) { _value = array[array.Count - 1]; } else { _value = array[(int)keyValue]; _keyOfValue = keyValue; } } else if (changeType == AttributeChangeType.AssignElement) { IList array = (IList)_elem.GetAttribute(_attrType.Name); _undoOperation = UndoOperation.AssignElement; _value = array[(int)keyValue]; _keyOfValue = keyValue; } else // Assign { Type valueType; IList array = ContainerHelper.GetListType( _elem.GetAttribute(_attrType.Name), out valueType); IList clonedArray = ContainerHelper.NewList(valueType, array); _undoOperation = UndoOperation.Assign; _value = clonedArray; } } else if (_attrType.Kind == AttributeKind.DequeAttr) { if (changeType == AttributeChangeType.PutElement) { IDeque deque = (IDeque)_elem.GetAttribute(_attrType.Name); _undoOperation = UndoOperation.RemoveElement; _keyOfValue = keyValue; } else if (changeType == AttributeChangeType.RemoveElement) { IDeque deque = (IDeque)_elem.GetAttribute(_attrType.Name); _undoOperation = UndoOperation.PutElement; if (keyValue == null) { _value = deque.Front; } else { _value = deque[(int)keyValue]; _keyOfValue = keyValue; } } else if (changeType == AttributeChangeType.AssignElement) { IDeque deque = (IDeque)_elem.GetAttribute(_attrType.Name); _undoOperation = UndoOperation.AssignElement; _value = deque[(int)keyValue]; _keyOfValue = keyValue; } else // Assign { Type valueType; IDeque deque = ContainerHelper.GetDequeType( _elem.GetAttribute(_attrType.Name), out valueType); IDeque clonedDeque = ContainerHelper.NewDeque(valueType, deque); _undoOperation = UndoOperation.Assign; _value = clonedDeque; } } else if (_attrType.Kind == AttributeKind.MapAttr) { if (changeType == AttributeChangeType.PutElement) { IDictionary dict = (IDictionary)_elem.GetAttribute(_attrType.Name); if (dict.Contains(keyValue)) { if (dict[keyValue] == newValue) { _undoOperation = UndoOperation.None; } else { _undoOperation = UndoOperation.PutElement; _value = dict[keyValue]; _keyOfValue = keyValue; } } else { _undoOperation = UndoOperation.RemoveElement; _value = newValue; _keyOfValue = keyValue; } } else if (changeType == AttributeChangeType.RemoveElement) { IDictionary dict = (IDictionary)_elem.GetAttribute(_attrType.Name); if (dict.Contains(keyValue)) { _undoOperation = UndoOperation.PutElement; _value = dict[keyValue]; _keyOfValue = keyValue; } else { _undoOperation = UndoOperation.None; } } else if (changeType == AttributeChangeType.AssignElement) { IDictionary dict = (IDictionary)_elem.GetAttribute(_attrType.Name); if (dict[keyValue] == newValue) { _undoOperation = UndoOperation.None; } else { _undoOperation = UndoOperation.AssignElement; _value = dict[keyValue]; _keyOfValue = keyValue; } } else // Assign { Type keyType, valueType; IDictionary dict = ContainerHelper.GetDictionaryTypes( _elem.GetAttribute(_attrType.Name), out keyType, out valueType); IDictionary clonedDict = ContainerHelper.NewDictionary(keyType, valueType, dict); _undoOperation = UndoOperation.Assign; _value = clonedDict; } } else // Primitve Type Assign { _undoOperation = UndoOperation.Assign; _value = _elem.GetAttribute(_attrType.Name); } }
public static void AssignAttributeIndexed(object target, object key, object value, string attributeName, IGraph graph) { if (target is IGraphElement) { IGraphElement elem = (IGraphElement)target; object container = elem.GetAttribute(attributeName); AttributeType attrType = elem.Type.GetAttributeType(attributeName); BaseGraph.ChangingAttributeAssignElement(graph, elem, attrType, value, key); if (container is IList) { IList array = (IList)container; array[(int)key] = value; } else if (container is IDeque) { IDeque deque = (IDeque)container; deque[(int)key] = value; } else { IDictionary map = (IDictionary)container; map[key] = value; } BaseGraph.ChangedAttribute(graph, elem, attrType); } else if (target is IObject) { IObject elem = (IObject)target; object container = elem.GetAttribute(attributeName); AttributeType attrType = elem.Type.GetAttributeType(attributeName); if (container is IList) { IList array = (IList)container; array[(int)key] = value; } else if (container is IDeque) { IDeque deque = (IDeque)container; deque[(int)key] = value; } else { IDictionary map = (IDictionary)container; map[key] = value; } } else { ITransientObject elem = (ITransientObject)target; object container = elem.GetAttribute(attributeName); AttributeType attrType = elem.Type.GetAttributeType(attributeName); if (container is IList) { IList array = (IList)container; array[(int)key] = value; } else if (container is IDeque) { IDeque deque = (IDeque)container; deque[(int)key] = value; } else { IDictionary map = (IDictionary)container; map[key] = value; } } }
public static IList Extract(object container, string memberOrAttribute, IGraphProcessingEnvironment procEnv) { IList array = (IList)container; string arrayType = TypesHelper.DotNetTypeToXgrsType(array.GetType()); string arrayValueType = TypesHelper.ExtractSrc(arrayType); if (arrayValueType.StartsWith("match<")) { if (arrayValueType == "match<>") { if (array.Count > 0) { IMatch match = (IMatch)array[0]; object matchElement = match.GetMember(memberOrAttribute); Type matchElementType; if (matchElement is IGraphElement) { matchElementType = TypesHelper.GetType(((IGraphElement)matchElement).Type, procEnv.Graph.Model); } else { matchElementType = matchElement.GetType(); } Type listType = typeof(List <>).MakeGenericType(matchElementType); IList extractedArray = (IList)Activator.CreateInstance(listType); ExtractMatchMember(array, memberOrAttribute, extractedArray); return(extractedArray); } else { return(new List <object>()); } } else { if (arrayValueType.StartsWith("match<class ")) { MatchClassFilterer matchClass = procEnv.Actions.GetMatchClass(TypesHelper.GetMatchClassName(arrayValueType)); IPatternElement element = matchClass.info.GetPatternElement(memberOrAttribute); GrGenType elementType = element.Type; Type listType = typeof(List <>).MakeGenericType(TypesHelper.GetType(elementType, procEnv.Graph.Model)); IList extractedArray = (IList)Activator.CreateInstance(listType); ExtractMatchMember(array, memberOrAttribute, extractedArray); return(extractedArray); } else { IAction action = procEnv.Actions.GetAction(TypesHelper.GetRuleName(arrayValueType)); IPatternElement element = action.RulePattern.PatternGraph.GetPatternElement(memberOrAttribute); GrGenType elementType = element.Type; Type listType = typeof(List <>).MakeGenericType(TypesHelper.GetType(elementType, procEnv.Graph.Model)); IList extractedArray = (IList)Activator.CreateInstance(listType); ExtractMatchMember(array, memberOrAttribute, extractedArray); return(extractedArray); } } } else { GrGenType graphElementType = TypesHelper.GetNodeOrEdgeType(arrayValueType, procEnv.Graph.Model); if (graphElementType != null) { AttributeType attributeType = graphElementType.GetAttributeType(memberOrAttribute); Type listType = typeof(List <>).MakeGenericType(attributeType.Type); IList extractedArray = (IList)Activator.CreateInstance(listType); ExtractAttribute(array, memberOrAttribute, extractedArray); return(extractedArray); } else { if (array.Count > 0) { IGraphElement graphElement = (IGraphElement)array[0]; object element = graphElement.GetAttribute(memberOrAttribute); Type elementType; if (element is IGraphElement) { elementType = TypesHelper.GetType(((IGraphElement)element).Type, procEnv.Graph.Model); } else { elementType = element.GetType(); } Type listType = typeof(List <>).MakeGenericType(elementType); IList extractedArray = (IList)Activator.CreateInstance(listType); ExtractAttribute(array, memberOrAttribute, extractedArray); return(extractedArray); } else { return(new List <object>()); } } } }
public void RetypingElement(IGraphElement oldElem, IGraphElement newElem) { bool isNode = oldElem is INode; GrGenType oldType = oldElem.Type; GrGenType newType = newElem.Type; if (isNode) { if (dumpInfo.IsExcludedNodeType((NodeType)oldType)) { return; } } else { if (dumpInfo.IsExcludedEdgeType((EdgeType)oldType)) { return; } } String elemKind = isNode ? "Node" : "Edge"; String elemNamePrefix = isNode ? "n" : "e"; String name = elemNamePrefix + graph.GetElementName(oldElem); ycompStream.Write("set" + elemKind + "Label \"" + name + "\" \"" + GetElemLabel(newElem) + "\"\n"); // remove the old attributes foreach (AttributeType attrType in oldType.AttributeTypes) { ycompStream.Write("clear" + elemKind + "Attr \"" + name + "\" \"" + attrType.OwnerType.Name + "::" + attrType.Name + " : " + GetKindName(attrType) + "\"\n"); } // set the new attributes foreach (AttributeType attrType in newType.AttributeTypes) { object attr = newElem.GetAttribute(attrType.Name); String attrString = (attr != null) ? attr.ToString() : "<Not initialized>"; ycompStream.Write("change" + elemKind + "Attr \"" + name + "\" \"" + attrType.OwnerType.Name + "::" + attrType.Name + " : " + GetKindName(attrType) + "\" \"" + attrString + "\"\n"); } if (isNode) { String oldNr = GetNodeRealizer((NodeType)oldType); String newNr = GetNodeRealizer((NodeType)newType); if (oldNr != newNr) { ChangeNode((INode)oldElem, newNr); } } else { String oldEr = GetEdgeRealizer((EdgeType)oldType); String newEr = GetEdgeRealizer((EdgeType)newType); if (oldEr != newEr) { ChangeEdge((IEdge)oldElem, newEr); } } isDirty = true; }
/// <summary> /// Dumps all attributes in the form "kind owner::name = value" into a String List /// </summary> /// <param name="elem">IGraphElement which attributes are to be dumped</param> /// <returns>A String List containing the dumped attributes </returns> private static List<String> DumpAttributes(IGraphElement elem) { List<String> attribs = new List<String>(); foreach(AttributeType attrType in elem.Type.AttributeTypes) { object attr = elem.GetAttribute(attrType.Name); String attrString = (attr != null) ? attr.ToString() : "<Not initialized>"; attribs.Add(String.Format("{0}::{1} : {2} = {3}", attrType.OwnerType.Name, attrType.Name, attrType.GetKindName(), attrString)); } return attribs; }