public Dictionary <string, dynamic> Dictify(dynamic objectData, GraphSONWriter writer)
        {
            DateTimeOffset value = objectData;
            var            ticks = (value - UnixStart).Ticks;

            return(GraphSONUtil.ToTypedValue("Date", ticks / TimeSpan.TicksPerMillisecond));
        }
Beispiel #2
0
        public Dictionary <string, dynamic> Dictify(dynamic objectData, GraphSONWriter writer)
        {
            var enumName      = objectData.GetType().Name;
            var valueJavaName = NamingConversions.GetEnumJavaName(enumName, objectData.ToString());

            return(GraphSONUtil.ToTypedValue(enumName, valueJavaName));
        }
 /// <summary>
 ///     Initializes a new instance of the <see cref="GraphSONMessageSerializer" /> class.
 /// </summary>
 /// <param name="mimeType">The MIME type supported by this serializer.</param>
 /// <param name="graphSONReader">The <see cref="GraphSONReader"/> used to deserialize from GraphSON.</param>
 /// <param name="graphSonWriter">The <see cref="GraphSONWriter"/> used to serialize to GraphSON.</param>
 protected GraphSONMessageSerializer(string mimeType, GraphSONReader graphSONReader,
                                     GraphSONWriter graphSonWriter)
 {
     _mimeType       = mimeType;
     _graphSONReader = graphSONReader;
     _graphSONWriter = graphSonWriter;
 }
Beispiel #4
0
        public Dictionary <string, dynamic> Dictify(dynamic objectData, GraphSONWriter writer)
        {
            ITraversal traversal = objectData;
            var        bytecode  = traversal.Bytecode;

            return(writer.ToDict(bytecode));
        }
        private IEnumerable <dynamic> DictifyInstruction(Instruction instruction, GraphSONWriter writer)
        {
            var result = new List <dynamic> {
                instruction.OperatorName
            };

            result.AddRange(instruction.Arguments.Select(arg => writer.ToDict(arg)));
            return(result);
        }
Beispiel #6
0
        public Dictionary <string, dynamic> Dictify(dynamic objectData, GraphSONWriter writer)
        {
            object value = objectData;

            if (StringifyValue)
            {
                value = value?.ToString();
            }
            return(GraphSONUtil.ToTypedValue(GraphSONTypeName, value, Prefix));
        }
        public Dictionary <string, dynamic> Dictify(dynamic objectData, GraphSONWriter writer)
        {
            object value = objectData;

            if (StringifyValue)
            {
                value = string.Format(CultureInfo.InvariantCulture, "{0}", value);
            }
            return(GraphSONUtil.ToTypedValue(GraphSONTypeName, value, Prefix));
        }
Beispiel #8
0
        public Dictionary <string, dynamic> Dictify(dynamic objectData, GraphSONWriter writer)
        {
            Vertex vertex     = objectData;
            var    vertexDict = new Dictionary <string, dynamic>
            {
                { "id", writer.ToDict(vertex.Id) },
                { "label", writer.ToDict(vertex.Label) }
            };

            return(GraphSONUtil.ToTypedValue(nameof(Vertex), vertexDict));
        }
        public Dictionary <string, dynamic> Dictify(dynamic objectData, GraphSONWriter writer)
        {
            var binding   = (Binding)objectData;
            var valueDict = new Dictionary <string, object>
            {
                { "value", writer.ToDict(binding.Value) },
                { "key", binding.Key }
            };

            return(GraphSONUtil.ToTypedValue(nameof(Binding), valueDict));
        }
Beispiel #10
0
        public Dictionary <string, dynamic> Dictify(dynamic objectData, GraphSONWriter writer)
        {
            ILambda lambda    = objectData;
            var     valueDict = new Dictionary <string, dynamic>
            {
                { "script", lambda.LambdaExpression },
                { "language", lambda.Language },
                { "arguments", lambda.Arguments }
            };

            return(GraphSONUtil.ToTypedValue(nameof(Lambda), valueDict));
        }
        public Dictionary <string, dynamic> Dictify(dynamic objectData, GraphSONWriter writer)
        {
            RequestMessage msg = objectData;

            return(new Dictionary <string, dynamic>
            {
                { "requestId", msg.RequestId },
                { "op", msg.Operation },
                { "processor", msg.Processor },
                { "args", writer.ToDict(msg.Arguments) }
            });
        }
Beispiel #12
0
        public Dictionary <string, dynamic> Dictify(dynamic objectData, GraphSONWriter writer)
        {
            VertexProperty vertexProperty = objectData;
            var            valueDict      = new Dictionary <string, dynamic>
            {
                { "id", writer.ToDict(vertexProperty.Id) },
                { "label", vertexProperty.Label },
                { "value", writer.ToDict(vertexProperty.Value) },
                { "vertex", writer.ToDict(vertexProperty.Vertex.Id) }
            };

            return(GraphSONUtil.ToTypedValue(nameof(VertexProperty), valueDict));
        }
        public Dictionary <string, dynamic> Dictify(dynamic objectData, GraphSONWriter writer)
        {
            Property property    = objectData;
            var      elementDict = CreateElementDict(property.Element, writer);
            var      valueDict   = new Dictionary <string, dynamic>
            {
                { "key", property.Key },
                { "value", writer.ToDict(property.Value) },
                { "element", elementDict }
            };

            return(GraphSONUtil.ToTypedValue(nameof(Property), valueDict));
        }
Beispiel #14
0
        public Dictionary <string, dynamic> Dictify(dynamic objectData, GraphSONWriter writer)
        {
            Edge edge     = objectData;
            var  edgeDict = new Dictionary <string, dynamic>
            {
                { "id", writer.ToDict(edge.Id) },
                { "outV", writer.ToDict(edge.OutV.Id) },
                { "outVLabel", edge.OutV.Label },
                { "label", edge.Label },
                { "inV", writer.ToDict(edge.InV.Id) },
                { "inVLabel", edge.InV.Label }
            };

            return(GraphSONUtil.ToTypedValue(nameof(Edge), edgeDict));
        }
Beispiel #15
0
        public Dictionary <string, dynamic> Dictify(dynamic objectData, GraphSONWriter writer)
        {
            if (!(objectData is IDictionary map))
            {
                throw new InvalidOperationException("Object must implement IDictionary");
            }
            var result = new object[map.Count * 2];
            var index  = 0;

            foreach (var key in map.Keys)
            {
                result[index++] = writer.ToDict(key);
                result[index++] = writer.ToDict(map[key]);
            }
            return(GraphSONUtil.ToTypedValue("Map", result));
        }
        public Dictionary <string, dynamic> Dictify(dynamic bytecodeObj, GraphSONWriter writer)
        {
            Bytecode bytecode = bytecodeObj;

            var valueDict = new Dictionary <string, IEnumerable <IEnumerable <dynamic> > >();

            if (bytecode.SourceInstructions.Count > 0)
            {
                valueDict["source"] = DictifyInstructions(bytecode.SourceInstructions, writer);
            }
            if (bytecode.StepInstructions.Count > 0)
            {
                valueDict["step"] = DictifyInstructions(bytecode.StepInstructions, writer);
            }

            return(GraphSONUtil.ToTypedValue(nameof(Bytecode), valueDict));
        }
Beispiel #17
0
        public Dictionary <string, dynamic> Dictify(dynamic predicate, GraphSONWriter writer)
        {
            TraversalPredicate p = predicate;
            var value            = p.Other == null
                ? writer.ToDict(p.Value)
                : new List <dynamic>
            {
                writer.ToDict(p.Value), writer.ToDict(p.Other)
            };
            var dict = new Dictionary <string, dynamic>
            {
                { "predicate", p.OperatorName },
                { "value", value }
            };

            return(GraphSONUtil.ToTypedValue("P", dict));
        }
        private dynamic CreateElementDict(Element element, GraphSONWriter writer)
        {
            if (element == null)
            {
                return(null);
            }
            var serializedElement = writer.ToDict(element);
            Dictionary <string, dynamic> elementDict = serializedElement;

            if (elementDict.ContainsKey(GraphSONTokens.ValueKey))
            {
                var elementValueSerialized = elementDict[GraphSONTokens.ValueKey];
                Dictionary <string, dynamic> elementValueDict = elementValueSerialized;
                if (elementValueDict != null)
                {
                    elementValueDict.Remove("outVLabel");
                    elementValueDict.Remove("inVLabel");
                    elementValueDict.Remove("properties");
                    elementValueDict.Remove("value");
                }
            }
            return(serializedElement);
        }
 private IEnumerable <IEnumerable <dynamic> > DictifyInstructions(IEnumerable <Instruction> instructions,
                                                                  GraphSONWriter writer)
 {
     return(instructions.Select(instruction => DictifyInstruction(instruction, writer)));
 }
Beispiel #20
0
        public Dictionary <string, dynamic> Dictify(dynamic objectData, GraphSONWriter writer)
        {
            AbstractTraversalStrategy strategy = objectData;

            return(GraphSONUtil.ToTypedValue(strategy.StrategyName, writer.ToDict(strategy.Configuration)));
        }
Beispiel #21
0
 public Dictionary <string, dynamic> Dictify(dynamic objectData, GraphSONWriter writer)
 {
     return(GraphSONUtil.ToTypedValue(GraphSONTypeName, objectData));
 }
Beispiel #22
0
        /// <summary>
        /// Converts a Collection to a representation of g:List or g:Set
        /// </summary>
        internal static Dictionary <string, dynamic> ToCollection(dynamic objectData, GraphSONWriter writer,
                                                                  string typename)
        {
            var collection = objectData as IEnumerable;

            if (collection == null)
            {
                throw new InvalidOperationException("Object must implement IEnumerable");
            }
            var result = new List <object>();

            foreach (var item in collection)
            {
                result.Add(writer.ToDict(item));
            }
            return(ToTypedValue(typename, result));
        }
        public Dictionary <string, dynamic> Dictify(dynamic objectData, GraphSONWriter writer)
        {
            TimeSpan value = objectData;

            return(GraphSONUtil.ToTypedValue("Duration", XmlConvert.ToString(value), "gx"));
        }
Beispiel #24
0
 public Dictionary <string, dynamic> Dictify(dynamic objectData, GraphSONWriter writer)
 {
     return(GraphSONUtil.ToCollection(objectData, writer, "List"));
 }
Beispiel #25
0
        public Dictionary <string, dynamic> Dictify(dynamic objectData, GraphSONWriter writer)
        {
            var type = (Type)objectData;

            return(writer.ToDict(Activator.CreateInstance(type)));
        }
        public Dictionary <string, dynamic> Dictify(dynamic objectData, GraphSONWriter writer)
        {
            Guid guid = objectData;

            return(GraphSONUtil.ToTypedValue("UUID", guid));
        }
Beispiel #27
0
        public Dictionary <string, dynamic> Dictify(dynamic objectData, GraphSONWriter writer)
        {
            DateTime dateTime = objectData;

            return(GraphSONUtil.ToTypedValue("Date", ToJavaTimestamp(dateTime)));
        }
        public Dictionary <string, dynamic> Dictify(dynamic objectData, GraphSONWriter writer)
        {
            BigInteger value = objectData;

            return(GraphSONUtil.ToTypedValue("BigInteger", value.ToString(), "gx"));
        }
Beispiel #29
0
        public Dictionary <string, dynamic> Dictify(dynamic objectData, GraphSONWriter writer)
        {
            DateTimeOffset value = objectData;

            return(GraphSONUtil.ToTypedValue("Date", value.ToUnixTimeMilliseconds()));
        }
Beispiel #30
0
 public Dictionary <string, dynamic> Dictify(dynamic objectData, GraphSONWriter writer)
 {
     byte[] value = objectData;
     return(GraphSONUtil.ToTypedValue("ByteBuffer", Convert.ToBase64String(value), "gx"));
 }