/// <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
}
/// <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();
}
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));
}
/// <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>
/// <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(IList array, out string type, out string content,
AttributeType attrType, IGraph graph, bool firstLevelObjectEmitted,
IDictionary <string, IObject> nameToObject, IGraphProcessingEnvironment procEnv)
{
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, firstLevelObjectEmitted, nameToObject, procEnv);
}
else
{
type = "<INVALID>";
}
sb.Append("]");
content = sb.ToString();
}
/// <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);
}
/// <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);
}
/// <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);
}
}
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));
}
/// <summary>
/// Creates a new dictionary representing a set containing all values from the given list or deque.
/// </summary>
public static IDictionary ArrayOrDequeAsSet(object obj)
{
if (obj is IList)
{
IList a = (IList)obj;
Type valueType;
ContainerHelper.GetListType(a, out valueType);
IDictionary newDict = NewDictionary(valueType, typeof(SetValueType));
for (int i = 0; i < a.Count; ++i)
{
newDict[a[i]] = null;
}
return(newDict);
}
else if (obj is IDeque)
{
IDeque a = (IDeque)obj;
Type valueType;
ContainerHelper.GetDequeType(a, out valueType);
IDictionary newDict = NewDictionary(valueType, typeof(SetValueType));
for (int i = 0; i < a.Count; ++i)
{
newDict[a[i]] = null;
}
return(newDict);
}
else
{
throw new Exception("asSet() can only be used on array or deque");
}
}
/// <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 + ">";
bool first = true;
foreach (Object entry in array)
{
if (first)
{
sb.Append(ToString(entry, attrValueType, graph)); first = false;
}
else
{
sb.Append(","); sb.Append(ToString(entry, attrValueType, graph));
}
}
}
else
{
type = "<INVALID>";
}
sb.Append("]");
content = sb.ToString();
}
/// <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(
IObject 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);
}
