Exemple #1
0
        /// <summary>
        /// Method is used for creating ObjectWrapper. This method is created because
        /// DateTime and TimeSpan types. When we transforming this two object
        /// we need to get only number of ticks from them. All other cases we just
        /// need to put object to Data property and object will be transformed in a right way.
        /// </summary>
        /// <param name="typeOfdata">Type of data object</param>
        /// <param name="data"></param>
        /// <returns></returns>
        public static ObjectWrapper CreateObjectWrapper(Object data)
        {
            ObjectWrapper ow = new ObjectWrapper();

            if (data == null)
            {
                ow.TypeName = null;
                ow.Data     = null;
                return(ow);
            }

            Type typeOfdata = data.GetType();

            ow.TypeName = TypeSingleton.ExtractPropertyType(typeOfdata);//typeOfdata.Name;

            if (typeOfdata.Equals(typeof(DateTime)))
            {
                ow.Data = ((DateTime)data).Ticks;
            }
            else
            {
                if (typeOfdata.Equals(typeof(TimeSpan)))
                {
                    ow.Data = ((TimeSpan)data).Ticks;
                }
                else
                {
                    ow.Data = data;
                }
            }

            return(ow);
        }
Exemple #2
0
        /// <summary>
        /// This method is used for transforming Node into NodeWrapper.
        /// </summary>
        /// <param name="node"> Node that need to be tranformed into NodeWrapper</param>
        /// <returns>NodeWrapper that is being result of transformation of Node</returns>
        public static NodeWrapper TransformeNode(Node <Guid, object, EdgeData> node)
        {
            if (node == null)
            {
                return(null);
            }
            NodeWrapper newNode = new NodeWrapper();

            newNode.Commited = node.Commited;
            newNode.NodeType = node.NodeType;
            newNode.Previous = node.Previous;

            ObjectWrapper newData = null;

            if (node.NodeType == NodeType.Type)
            {
                //getting name of type of node data.
                newData = ObjectWrapper.CreateObjectWrapper(node.Data);
                //this is needed because data contains string that is contain data that
                //identifies type in .NET. Because of that we need to change type of objectWrapper
                newData.TypeName = TypeSingleton.ExtractPropertyType(Type.GetType((String)node.Data));
                newNode.Data     = newData;
            }
            else
            {
                //getting type name of data, in case node.Data is null type will be null
                newData = ObjectWrapper.CreateObjectWrapper(node.Data);

                newNode.Data = newData;
            }

            foreach (KeyValuePair <Guid, object> item in node.Values)
            {
                //making ObjectWrapper from object
                ObjectWrapper ow = ObjectWrapper.CreateObjectWrapper(item.Value);
                //adding new Guid-ObjectWrapper pair into Values
                newNode.Values.Add(item.Key.ToString(), ow);
            }

            foreach (KeyValuePair <EdgeData, Edge <Guid, EdgeData> > item in node.Edges)
            {
                //getting type of key and value
                Type typeOfObject = item.Key.GetType();
                Type edgeDataType = typeof(EdgeData);
                if (typeOfObject.Equals(edgeDataType))
                {
                    EdgeDataWrapper edgeDataKey = EdgeDataWrapper.TransformeEdgeData(item.Key);

                    EdgeWrapper edgeWraper = EdgeWrapper.TransformeEdge(item.Value);

                    newNode.Edges.Add(new KeyValueWrapper(edgeDataKey, edgeWraper));
                }
                else
                {
                    throw new Exception("Unexpected type in node wraper!");
                }
            }
            return(newNode);
        }