Пример #1
0
        public static IDictionary Intersect(IDictionary a, IDictionary b)
        {
            Type        keyType;
            Type        valueType;
            IDictionary dict = ContainerHelper.GetDictionaryTypes(a, out keyType, out valueType);

            // Create empty dictionary.
            IDictionary newDict = NewDictionary(keyType, valueType);

            // Add all elements of a also contained in b.
            if (a.Count <= b.Count)
            {
                foreach (DictionaryEntry entry in a)
                {
                    if (b.Contains(entry.Key))
                    {
                        newDict.Add(entry.Key, entry.Value);
                    }
                }
            }
            else
            {
                foreach (DictionaryEntry entry in b)
                {
                    if (a.Contains(entry.Key))
                    {
                        newDict.Add(entry.Key, a[entry.Key]);
                    }
                }
            }

            return(newDict);
        }
        /// <summary>
        /// Returns a string representation of the given Deque
        /// </summary>
        /// <param name="deque">The Deque of which to get the string representation</param>
        /// <param name="type">The type as string, e.g deque<int></param>
        /// <param name="content">The content as string, e.g. ] 42, 43 [</param>
        /// <param name="attrType">The attribute type of the deque if available, otherwise null</param>
        /// <param name="graph">The graph with the model and the element names if available, otherwise null</param>
        /// <param name="firstLevelObjectEmitted">Prevents emitting of further objects and thus infinite regressions</param>
        /// <param name="nameToObject">If not null, the names of visited objects are added</param>
        /// <param name="procEnv">If not null, the processing environment is used for transient object unique id emitting and fetching</param>
        public static void ToString(IDeque deque, out string type, out string content,
                                    AttributeType attrType, IGraph graph, bool firstLevelObjectEmitted,
                                    IDictionary <string, IObject> nameToObject, IGraphProcessingEnvironment procEnv)
        {
            Type valueType;

            ContainerHelper.GetDequeType(deque, out valueType);

            StringBuilder sb = new StringBuilder(256);

            sb.Append("]");

            AttributeType attrValueType = attrType != null ? attrType.ValueType : null;

            if (deque != null)
            {
                type = "deque<" + valueType.Name + ">";
                AppendDeque(sb, deque, attrValueType, graph, firstLevelObjectEmitted, nameToObject, procEnv);
            }
            else
            {
                type = "<INVALID>";
            }

            sb.Append("[");
            content = sb.ToString();
        }
Пример #3
0
        public static bool LessOrEqualIDictionary(IDictionary a, IDictionary b)
        {
            Type keyType;
            Type valueType;

            ContainerHelper.GetDictionaryTypes(a, out keyType, out valueType);
            if (valueType.Name == "SetValueType")
            {
                foreach (DictionaryEntry entry in a)
                {
                    if (!b.Contains(entry.Key))
                    {
                        return(false);
                    }
                }
            }
            else
            {
                foreach (DictionaryEntry entry in a)
                {
                    if (!b.Contains(entry.Key))
                    {
                        return(false);
                    }
                    if (entry.Value != null ? !entry.Value.Equals(b[entry.Key]) : b[entry.Key] != null)
                    {
                        return(false);
                    }
                }
            }

            return(true);
        }
Пример #4
0
 public static String DotNetTypeToXgrsType(Type type)
 {
     if (type.IsGenericType)
     {
         if (type.Name == "Dictionary`2")
         {
             Type keyType;
             Type valueType;
             ContainerHelper.GetDictionaryTypes(type, out keyType, out valueType);
             if (valueType.Name == "SetValueType")
             {
                 return("set<" + DotNetTypeToXgrsType(keyType.Name, keyType.FullName) + ">");
             }
             else
             {
                 return("map<" + DotNetTypeToXgrsType(keyType.Name, keyType.FullName) + "," + DotNetTypeToXgrsType(valueType.Name, valueType.FullName) + ">");
             }
         }
         else if (type.Name == "List`1")
         {
             Type valueType;
             ContainerHelper.GetListType(type, out valueType);
             return("array<" + DotNetTypeToXgrsType(valueType.Name, valueType.FullName) + ">");
         }
         else if (type.Name == "Deque`1")
         {
             Type valueType;
             ContainerHelper.GetDequeType(type, out valueType);
             return("deque<" + DotNetTypeToXgrsType(valueType.Name, valueType.FullName) + ">");
         }
     }
     return(DotNetTypeToXgrsType(type.Name, type.FullName));
 }
Пример #5
0
 public static object GetAttributeOrElementOfMatch(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
     {
         IAttributeBearer attributeBearer = (IAttributeBearer)source;
         object           value           = attributeBearer.GetAttribute(attributeOrElementName);
         value = attributeBearer is ITransientObject ? value : ContainerHelper.IfAttributeOfElementIsContainerThenCloneContainer(
             attributeBearer, attributeOrElementName, value);
         return(value);
     }
 }
Пример #6
0
        /////////////////////////////////////////////////////////////////////////////////

        public static void AssignAttribute(object target, object value, string attributeName, IGraph graph)
        {
            if (target is IGraphElement)
            {
                IGraphElement elem = (IGraphElement)target;

                AttributeType attrType;
                value = ContainerHelper.IfAttributeOfElementIsContainerThenCloneContainer(
                    elem, attributeName, value, out attrType);

                BaseGraph.ChangingAttributeAssign(graph, elem, attrType, value);

                elem.SetAttribute(attributeName, value);

                BaseGraph.ChangedAttribute(graph, elem, attrType);
            }
            else if (target is IObject)
            {
                IObject elem = (IObject)target;

                AttributeType attrType = elem.Type.GetAttributeType(attributeName);

                BaseGraph.ChangingAttributeAssign(graph, elem, attrType, value);

                elem.SetAttribute(attributeName, value);
            }
            else //if(target is ITransientObject)
            {
                ITransientObject elem = (ITransientObject)target;

                elem.SetAttribute(attributeName, value);
            }
        }
Пример #7
0
 /// <summary>
 /// Creates a shallow clone of the given container.
 /// </summary>
 /// <param name="oldContainer">The container to clone.</param>
 /// <returns>A shallow clone of the container</returns>
 public static object Clone(object oldContainer)
 {
     if (oldContainer is IDictionary)
     {
         Type        keyType, valueType;
         IDictionary dict = ContainerHelper.GetDictionaryTypes(
             oldContainer, out keyType, out valueType);
         return(NewDictionary(keyType, valueType, oldContainer));
     }
     else if (oldContainer is IList)
     {
         Type  valueType;
         IList array = ContainerHelper.GetListType(
             oldContainer, out valueType);
         return(NewList(valueType, oldContainer));
     }
     else if (oldContainer is IDeque)
     {
         Type   valueType;
         IDeque deque = ContainerHelper.GetDequeType(
             oldContainer, out valueType);
         return(NewDeque(valueType, oldContainer));
     }
     return(null); // no known container type
 }
Пример #8
0
 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);
     }
 }
Пример #9
0
 /// <summary>
 /// Creates a new list containing all values from the given dictionary representing a set.
 /// </summary>
 public static IList AsArray(object container, IGraphModel model)
 {
     if (container is IList)
     {
         return((IList)container);
     }
     else if (container is IDictionary)
     {
         Type keyType;
         Type valueType;
         ContainerHelper.GetDictionaryTypes(container, out keyType, out valueType);
         if (valueType.Name == "SetValueType")
         {
             return(SetAsArray((IDictionary)container));
         }
         else
         {
             return(MapAsArray((IDictionary)container, model));
         }
     }
     else if (container is IDeque)
     {
         return(DequeAsArray((IDeque)container));
     }
     return(null);
 }
Пример #10
0
        /// <summary>
        /// Returns a string representation of the given Deque
        /// </summary>
        /// <param name="deque">The Deque of which to get the string representation</param>
        /// <param name="type">The type as string, e.g deque<int></param>
        /// <param name="content">The content as string, e.g. ] 42, 43 [</param>
        /// <param name="attrType">The attribute type of the deque if available, otherwise null</param>
        /// <param name="graph">The graph with the model and the element names if available, otherwise null</param>
        public static void ToString(IDeque deque, out string type, out string content,
                                    AttributeType attrType, IGraph graph)
        {
            Type valueType;

            ContainerHelper.GetDequeType(deque, out valueType);

            StringBuilder sb = new StringBuilder(256);

            sb.Append("]");

            AttributeType attrValueType = attrType != null ? attrType.ValueType : null;

            if (deque != null)
            {
                type = "deque<" + valueType.Name + ">";
                AppendDeque(sb, deque, attrValueType, graph);
            }
            else
            {
                type = "<INVALID>";
            }

            sb.Append("[");
            content = sb.ToString();
        }
Пример #11
0
 protected static void FillReturnVariablesFromValues(SequenceVariable[] ReturnVars, IAction Action, IGraphProcessingEnvironment procEnv, List <object[]> retElemsList)
 {
     IList[] returnVars = null;
     if (ReturnVars.Length > 0)
     {
         returnVars = new IList[ReturnVars.Length];
         for (int i = 0; i < ReturnVars.Length; ++i)
         {
             returnVars[i] = ReturnVars[i].GetVariableValue(procEnv) as IList;
             if (returnVars[i] == null)
             {
                 string returnType = TypesHelper.DotNetTypeToXgrsType(Action.RulePattern.Outputs[i]);
                 Type   valueType  = TypesHelper.GetType(returnType, procEnv.Graph.Model);
                 returnVars[i] = ContainerHelper.NewList(valueType);
                 ReturnVars[i].SetVariableValue(returnVars[i], procEnv);
             }
             else
             {
                 returnVars[i].Clear();
             }
         }
     }
     for (int curRetElemNum = 0; curRetElemNum < retElemsList.Count; ++curRetElemNum)
     {
         object[] retElems = retElemsList[curRetElemNum];
         for (int i = 0; i < ReturnVars.Length; ++i)
         {
             returnVars[i].Add(retElems[i]);
         }
     }
 }
Пример #12
0
        public override void Assign(object value, IGraphProcessingEnvironment procEnv)
        {
            IGraphElement elem = (IGraphElement)DestVar.GetVariableValue(procEnv);
            AttributeType attrType;

            value = ContainerHelper.IfAttributeOfElementIsContainerThenCloneContainer(
                elem, AttributeName, value, out attrType);
            AttributeChangeType changeType = AttributeChangeType.Assign;

            if (elem is INode)
            {
                procEnv.Graph.ChangingNodeAttribute((INode)elem, attrType, changeType, value, null);
            }
            else
            {
                procEnv.Graph.ChangingEdgeAttribute((IEdge)elem, attrType, changeType, value, null);
            }
            elem.SetAttribute(AttributeName, value);
            if (elem is INode)
            {
                procEnv.Graph.ChangedNodeAttribute((INode)elem, attrType);
            }
            else
            {
                procEnv.Graph.ChangedEdgeAttribute((IEdge)elem, attrType);
            }
        }
Пример #13
0
        /// <summary>
        /// Returns a string representation of the given List
        /// </summary>
        /// <param name="array">The List of which to get the string representation</param>
        /// <param name="type">The type as string, e.g array<int></param>
        /// <param name="content">The content as string, e.g. [ 42, 43 ]</param>
        /// <param name="attrType">The attribute type of the array if available, otherwise null</param>
        /// <param name="graph">The graph with the model and the element names if available, otherwise null</param>
        public static void ToString(IList array, out string type, out string content,
                                    AttributeType attrType, IGraph graph)
        {
            Type valueType;

            ContainerHelper.GetListType(array, out valueType);

            StringBuilder sb = new StringBuilder(256);

            sb.Append("[");

            AttributeType attrValueType = attrType != null ? attrType.ValueType : null;

            if (array != null)
            {
                type = "array<" + valueType.Name + ">";
                AppendArray(sb, array, attrValueType, graph);
            }
            else
            {
                type = "<INVALID>";
            }

            sb.Append("]");
            content = sb.ToString();
        }
Пример #14
0
        /// <summary>
        /// Creates a new list representing an array,
        /// containing all values from the given dictionary representing a map <paramref name="map"/> from int to some values.
        /// </summary>
        /// <param name="map">A dictionary representing a map.</param>
        /// <returns>A new list containing all values from <paramref name="map"/>.</returns>
        public static IList MapAsArray(IDictionary map, IGraphModel model)
        {
            int max = 0;

            foreach (int i in map.Keys)
            {
                if (i < 0)
                {
                    throw new Exception("MapAsArray does not support negative indices");
                }
                max = Math.Max(max, i);
            }

            Type keyType;
            Type valueType;

            ContainerHelper.GetDictionaryTypes(map, out keyType, out valueType);
            IList newList = NewList(valueType, max + 1); // yep, if the dict contains max int, contiguous 8GB are needed

            // Add all values of dictionary representing map to new dictionary representing set
            for (int i = 0; i < max + 1; ++i)
            {
                if (map.Contains(i))
                {
                    newList.Add(map[i]);
                }
                else
                {
                    newList.Add(TypesHelper.DefaultValue(valueType.Name, model));
                }
            }

            return(newList);
        }
Пример #15
0
        /// <summary>
        /// Returns a string representation of the given dictionary
        /// </summary>
        /// <param name="setmap">The dictionary of which to get the string representation</param>
        /// <param name="type">The type as string, e.g set<int> or map<string,boolean> </param>
        /// <param name="content">The content as string, e.g. { 42, 43 } or { "foo"->true, "bar"->false } </param>
        /// <param name="attrType">The attribute type of the dictionary if available, otherwise null</param>
        /// <param name="graph">The graph with the model and the element names if available, otherwise null</param>
        public static void ToString(IDictionary setmap, out string type, out string content,
                                    AttributeType attrType, IGraph graph)
        {
            Type keyType;
            Type valueType;

            ContainerHelper.GetDictionaryTypes(setmap, out keyType, out valueType);

            StringBuilder sb = new StringBuilder(256);

            sb.Append("{");

            AttributeType attrValueType = attrType != null ? attrType.ValueType : null;
            AttributeType attrKeyType   = attrType != null ? attrType.KeyType : null;

            if (setmap != null)
            {
                if (valueType == typeof(SetValueType))
                {
                    type = "set<" + keyType.Name + ">";
                    bool first = true;
                    foreach (DictionaryEntry entry in setmap)
                    {
                        if (first)
                        {
                            sb.Append(ToString(entry.Key, attrValueType, graph)); first = false;
                        }
                        else
                        {
                            sb.Append(","); sb.Append(ToString(entry.Key, attrValueType, graph));
                        }
                    }
                }
                else
                {
                    type = "map<" + keyType.Name + "," + valueType.Name + ">";
                    bool first = true;
                    foreach (DictionaryEntry entry in setmap)
                    {
                        if (first)
                        {
                            sb.Append(ToString(entry.Key, attrKeyType, graph)); sb.Append("->"); sb.Append(ToString(entry.Value, attrValueType, graph)); first = false;
                        }
                        else
                        {
                            sb.Append(","); sb.Append(ToString(entry.Key, attrKeyType, graph)); sb.Append("->"); sb.Append(ToString(entry.Value, attrValueType, graph));
                        }
                    }
                }
            }
            else
            {
                type = "<INVALID>";
            }

            sb.Append("}");
            content = sb.ToString();
        }
Пример #16
0
        public override void Assign(object value, IGraphProcessingEnvironment procEnv)
        {
            IGraphElement elem = (IGraphElement)DestVar.GetVariableValue(procEnv);
            AttributeType attrType;
            value = ContainerHelper.IfAttributeOfElementIsContainerThenCloneContainer(
                elem, AttributeName, value, out attrType);

            BaseGraph.ChangingAttributeAssign(procEnv.Graph, elem, attrType, value);

            elem.SetAttribute(AttributeName, value);

            BaseGraph.ChangedAttribute(procEnv.Graph, elem, attrType);
        }
Пример #17
0
        /// <summary>
        /// Creates a new deque containing all values from the given list.
        /// </summary>
        public static IDeque ArrayAsDeque(IList a)
        {
            Type valueType;

            ContainerHelper.GetListType(a, out valueType);
            IDeque newDeque = NewDeque(valueType);

            for (int i = 0; i < a.Count; ++i)
            {
                newDeque.Add(a[i]);
            }

            return(newDeque);
        }
Пример #18
0
        /// <summary>
        /// Creates a new dictionary representing a map containing all values from the given list, mapped to by their index.
        /// </summary>
        public static IDictionary ArrayAsMap(IList a)
        {
            Type valueType;

            ContainerHelper.GetListType(a, out valueType);
            IDictionary newDict = NewDictionary(typeof(int), valueType);

            for (int i = 0; i < a.Count; ++i)
            {
                newDict[i] = a[i];
            }

            return(newDict);
        }
Пример #19
0
        /// <summary>
        /// Creates a new list representing an array containing all values from the given deque.
        /// </summary>
        public static IList DequeAsArray(IDeque a)
        {
            Type valueType;

            ContainerHelper.GetDequeType(a, out valueType);
            IList newArray = NewList(valueType);

            for (int i = 0; i < a.Count; ++i)
            {
                newArray.Add(a[i]);
            }

            return(newArray);
        }
Пример #20
0
        public static IDictionary Domain(IDictionary map)
        {
            Type keyType;
            Type valueType;

            ContainerHelper.GetDictionaryTypes(map, out keyType, out valueType);
            IDictionary newDict = NewDictionary(keyType, typeof(SetValueType));

            foreach (object key in map.Keys)
            {
                newDict[key] = null;
            }

            return(newDict);
        }
Пример #21
0
        public static IDictionary Range(IDictionary map)
        {
            Type keyType;
            Type valueType;

            ContainerHelper.GetDictionaryTypes(map, out keyType, out valueType);
            IDictionary newDict = NewDictionary(valueType, typeof(SetValueType));

            foreach (object value in map.Values)
            {
                newDict[value] = null;
            }

            return(newDict);
        }
Пример #22
0
 /// <summary>
 /// Returns a clone of either a graph or a match or a container
 /// </summary>
 /// <param name="toBeCloned">The graph or match or container to be cloned</param>
 /// <returns>The cloned graph or match or container</returns>
 public static object Clone(object toBeCloned)
 {
     if (toBeCloned is IGraph)
     {
         return(GraphHelper.Copy((IGraph)toBeCloned));
     }
     else if (toBeCloned is IMatch)
     {
         return(((IMatch)toBeCloned).Clone());
     }
     else
     {
         return(ContainerHelper.Clone(toBeCloned));
     }
 }
Пример #23
0
        /// <summary>
        /// Creates a new list containing all values from the given dictionary representing a set.
        /// </summary>
        public static IList SetAsArray(IDictionary a)
        {
            Type keyType;
            Type valueType;

            ContainerHelper.GetDictionaryTypes(a, out keyType, out valueType);
            IList newList = NewList(keyType);

            foreach (DictionaryEntry entry in a)
            {
                newList.Add(entry.Key);
            }

            return(newList);
        }
Пример #24
0
 /// <summary>
 /// Returns a string representation of the given List
 /// after the given operation with the given parameters was applied
 /// </summary>
 /// <param name="array">The base List of the operation</param>
 /// <param name="changeType">The type of the change operation</param>
 /// <param name="newValue">The new value to be inserted/added if changeType==PutElement on array.
 ///                        Or the new value to be assigned to the given position if changeType==AssignElement on array.</param>
 /// <param name="keyValue">The array index to be removed/written to if changeType==RemoveElement/AssignElement on array.</param>
 /// <param name="type">The type as string, e.g array<int></param>
 /// <param name="content">The content as string, e.g. [ 42, 43 ] </param>
 /// <param name="attrType">The attribute type of the List</param>
 /// <param name="graph">The graph with the model and the element names</param>
 public static void ToString(IList array,
                             AttributeChangeType changeType, Object newValue, Object keyValue,
                             out string type, out string content,
                             AttributeType attrType, IGraph graph)
 {
     if (changeType == AttributeChangeType.PutElement)
     {
         Type valueType;
         ContainerHelper.GetListType(array, out valueType);
         ToString(array, out type, out content, attrType, graph);
         content += ".add(" + ToString(newValue, attrType.ValueType, graph);
         if (keyValue != null)
         {
             content += ", " + keyValue.ToString() + ")";
         }
         else
         {
             content += ")";
         }
     }
     else if (changeType == AttributeChangeType.RemoveElement)
     {
         Type valueType;
         ContainerHelper.GetListType(array, out valueType);
         ToString(array, out type, out content, attrType, graph);
         content += ".rem(";
         if (keyValue != null)
         {
             content += keyValue.ToString() + ")";
         }
         else
         {
             content += ")";
         }
     }
     else if (changeType == AttributeChangeType.AssignElement)
     {
         Type valueType;
         ContainerHelper.GetListType(array, out valueType);
         ToString(array, out type, out content, attrType, graph);
         content += "[" + keyValue.ToString() + "] = " + ToString(newValue, attrType.ValueType, graph);
     }
     else // changeType==AttributeChangeType.Assign
     {
         ToString((IList)newValue, out type, out content, attrType, graph);
     }
 }
Пример #25
0
        public static IDictionary Except(IDictionary a, IDictionary b)
        {
            Type        keyType;
            Type        valueType;
            IDictionary dict = ContainerHelper.GetDictionaryTypes(a, out keyType, out valueType);

            // Fill new dictionary with all elements from a.
            IDictionary newDict = NewDictionary(keyType, valueType, a);

            // Remove all elements contained in b.
            foreach (DictionaryEntry entry in b)
            {
                newDict.Remove(entry.Key);
            }

            return(newDict);
        }
Пример #26
0
        public static IDictionary Union(IDictionary a, IDictionary b)
        {
            Type        keyType;
            Type        valueType;
            IDictionary dict = ContainerHelper.GetDictionaryTypes(a, out keyType, out valueType);

            // Fill new dictionary with all elements from a.
            IDictionary newDict = NewDictionary(keyType, valueType, a);

            // Add all elements from b, potentially overwriting those of a.
            foreach (DictionaryEntry entry in b)
            {
                newDict[entry.Key] = entry.Value;
            }

            return(newDict);
        }
Пример #27
0
        /// <summary>
        /// Returns a string representation of the given dictionary
        /// after the given operation with the given parameters was applied
        /// </summary>
        /// <param name="setmap">The base dictionary of the operation</param>
        /// <param name="changeType">The type of the change operation</param>
        /// <param name="newValue">The new value of the attribute, if changeType==Assign.
        ///                        Or the value to be inserted/removed if changeType==PutElement/RemoveElement on set.
        ///                        Or the new map pair value to be inserted if changeType==PutElement on map.</param>
        /// <param name="keyValue">The map pair key to be inserted/removed if changeType==PutElement/RemoveElement on map.</param>
        /// <param name="type">The type as string, e.g set<int> or map<string,boolean> </param>
        /// <param name="content">The content as string, e.g. { 42, 43 } or { "foo"->true, "bar"->false } </param>
        /// <param name="attrType">The attribute type of the dictionary</param>
        /// <param name="graph">The graph with the model and the element names</param>
        public static void ToString(IDictionary setmap,
                                    AttributeChangeType changeType, Object newValue, Object keyValue,
                                    out string type, out string content,
                                    AttributeType attrType, IGraph graph)
        {
            if (changeType == AttributeChangeType.PutElement)
            {
                Type keyType;
                Type valueType;
                ContainerHelper.GetDictionaryTypes(setmap, out keyType, out valueType);

                if (valueType == typeof(SetValueType))
                {
                    ToString(setmap, out type, out content, attrType, graph);
                    content += "|" + ToString(newValue, attrType.ValueType, graph);
                }
                else
                {
                    ToString(setmap, out type, out content, attrType, graph);
                    content += "|" + ToString(keyValue, attrType.KeyType, graph) + "->" + ToString(newValue, attrType.ValueType, graph);
                }
            }
            else if (changeType == AttributeChangeType.RemoveElement)
            {
                Type keyType;
                Type valueType;
                ContainerHelper.GetDictionaryTypes(setmap, out keyType, out valueType);

                if (valueType == typeof(SetValueType))
                {
                    ToString(setmap, out type, out content, attrType, graph);
                    content += "\\" + ToString(newValue, attrType.ValueType, graph);
                }
                else
                {
                    ToString(setmap, out type, out content, attrType, graph);
                    content += "\\" + ToString(keyValue, attrType.KeyType, graph) + "->.";
                }
            }
            else // changeType==AttributeChangeType.Assign
            {
                ToString((IDictionary)newValue, out type, out content, attrType, graph);
            }
        }
Пример #28
0
        public static String XgrsTypeOfConstant(object constant, IGraphModel model)
        {
            if (constant == null)
            {
                return("");
            }

            if (constant.GetType().IsGenericType)
            {
                if (constant.GetType().Name == "Dictionary`2")
                {
                    Type keyType;
                    Type valueType;
                    ContainerHelper.GetDictionaryTypes(constant, out keyType, out valueType);
                    if (valueType == typeof(de.unika.ipd.grGen.libGr.SetValueType))
                    {
                        return("set<" + DotNetTypeToXgrsType(keyType.Name, keyType.FullName) + ">");
                    }
                    else
                    {
                        return("map<" + DotNetTypeToXgrsType(keyType.Name, keyType.FullName) + "," + DotNetTypeToXgrsType(valueType.Name, valueType.FullName) + ">");
                    }
                }
                else if (constant.GetType().Name == "List`1")
                {
                    Type valueType;
                    ContainerHelper.GetListType(constant.GetType(), out valueType);
                    return("array<" + DotNetTypeToXgrsType(valueType.Name, valueType.FullName) + ">");
                }
                else //if(constant.GetType().Name == "Deque`1")
                {
                    Type valueType;
                    ContainerHelper.GetListType(constant.GetType(), out valueType);
                    return("deque<" + DotNetTypeToXgrsType(valueType.Name, valueType.FullName) + ">");
                }
            }

            object typeinsteadofobject = NodeOrEdgeTypeIfNodeOrEdge(constant);

            return(DotNetTypeToXgrsType(typeinsteadofobject.GetType().Name, typeinsteadofobject.GetType().FullName));
        }
Пример #29
0
 /// <summary>
 /// Returns a shallow clone of either a graph or a match or a class object or a transient class object or a container
 /// </summary>
 /// <param name="toBeCloned">The graph or match or (transient) class object or container to be cloned</param>
 /// <returns>The clone</returns>
 public static object Clone(object toBeCloned, IGraph graph)
 {
     if (toBeCloned is IGraph)
     {
         return(GraphHelper.Copy((IGraph)toBeCloned));
     }
     else if (toBeCloned is IMatch)
     {
         return(((IMatch)toBeCloned).Clone());
     }
     else if (toBeCloned is IObject)
     {
         return(((IObject)toBeCloned).Clone(graph));
     }
     else if (toBeCloned is ITransientObject)
     {
         return(((ITransientObject)toBeCloned).Clone());
     }
     else
     {
         return(ContainerHelper.Clone(toBeCloned));
     }
 }
Пример #30
0
 /// <summary>
 /// Returns a deep copy of either a graph or a match or a class object or a transient class object or a container
 /// </summary>
 /// <param name="toBeCopied">The graph or match or (transient) class object or container to be copied</param>
 /// <returns>The copy</returns>
 public static object Copy(object toBeCopied, IGraph graph)
 {
     if (toBeCopied is IGraph)
     {
         return(GraphHelper.Copy((IGraph)toBeCopied));
     }
     else if (toBeCopied is IMatch)
     {
         return(((IMatch)toBeCopied).Clone());
     }
     else if (toBeCopied is IObject)
     {
         return(((IObject)toBeCopied).Copy(graph, new Dictionary <IBaseObject, IBaseObject>()));
     }
     else if (toBeCopied is ITransientObject)
     {
         return(((ITransientObject)toBeCopied).Copy(graph, new Dictionary <IBaseObject, IBaseObject>()));
     }
     else
     {
         return(ContainerHelper.Copy(toBeCopied, graph, new Dictionary <IBaseObject, IBaseObject>()));
     }
 }