public override async Task WriteValueAsync(object value, Stream stream, GraphBinaryWriter writer, bool nullable)
        {
            if (value == null)
            {
                if (!nullable)
                {
                    throw new IOException("Unexpected null value when nullable is false");
                }

                await writer.WriteValueFlagNullAsync(stream).ConfigureAwait(false);

                return;
            }

            if (nullable)
            {
                await writer.WriteValueFlagNoneAsync(stream).ConfigureAwait(false);
            }

            var samplePerson = (SamplePerson)value;
            var name         = samplePerson.Name;

            // value_length = name_byte_length + name_bytes + long
            await stream.WriteIntAsync(4 + Encoding.UTF8.GetBytes(name).Length + 8).ConfigureAwait(false);

            await writer.WriteValueAsync(name, stream, false).ConfigureAwait(false);

            await writer.WriteValueAsync(samplePerson.BirthDate, stream, false).ConfigureAwait(false);
        }
Esempio n. 2
0
        /// <inheritdoc />
        protected override async Task WriteValueAsync(decimal value, Stream stream, GraphBinaryWriter writer)
        {
            var(unscaledValue, scale) = GetUnscaledValueAndScale(value);
            await writer.WriteValueAsync(scale, stream, false).ConfigureAwait(false);

            await writer.WriteValueAsync(unscaledValue, stream, false).ConfigureAwait(false);
        }
        public override async Task WriteAsync(object value, Stream stream, GraphBinaryWriter writer)
        {
            // Write {custom type info}, {value_flag} and {value}
            await stream.WriteAsync(_typeInfoBytes).ConfigureAwait(false);

            await WriteValueAsync(value, stream, writer, true);
        }
Esempio n. 4
0
        /// <inheritdoc />
        protected override async Task WriteValueAsync(AbstractTraversalStrategy value, Stream stream,
                                                      GraphBinaryWriter writer)
        {
            await writer.WriteValueAsync(GremlinType.FromFqcn(value.Fqcn), stream, false).ConfigureAwait(false);

            await writer.WriteValueAsync(value.Configuration, stream, false).ConfigureAwait(false);
        }
Esempio n. 5
0
        protected override async Task WriteNonNullableValueAsync(JanusGraphP value, Stream stream,
                                                                 GraphBinaryWriter writer)
        {
            await writer.WriteValueAsync(value.OperatorName, stream, false).ConfigureAwait(false);

            await writer.WriteAsync(value.Value, stream).ConfigureAwait(false);
        }
Esempio n. 6
0
        /// <inheritdoc />
        protected override async Task WriteValueAsync(string value, Stream stream, GraphBinaryWriter writer)
        {
            var bytes = Encoding.UTF8.GetBytes(value);
            await writer.WriteValueAsync(bytes.Length, stream, false).ConfigureAwait(false);

            await stream.WriteAsync(bytes).ConfigureAwait(false);
        }
Esempio n. 7
0
        /// <inheritdoc />
        protected override async Task WriteValueAsync(Vertex value, Stream stream, GraphBinaryWriter writer)
        {
            await writer.WriteAsync(value.Id, stream).ConfigureAwait(false);

            await writer.WriteValueAsync(value.Label, stream, false).ConfigureAwait(false);

            await writer.WriteAsync(null, stream).ConfigureAwait(false);
        }
Esempio n. 8
0
        /// <inheritdoc />
        protected override async Task WriteValueAsync(ILambda value, Stream stream, GraphBinaryWriter writer)
        {
            await writer.WriteValueAsync(value.Language, stream, false).ConfigureAwait(false);

            await writer.WriteValueAsync(value.LambdaExpression, stream, false).ConfigureAwait(false);

            await writer.WriteValueAsync(value.Arguments, stream, false).ConfigureAwait(false);
        }
Esempio n. 9
0
        /// <inheritdoc />
        protected override async Task WriteValueAsync(Property value, Stream stream, GraphBinaryWriter writer)
        {
            await writer.WriteValueAsync(value.Key, stream, false).ConfigureAwait(false);

            await writer.WriteAsync(value.Value, stream).ConfigureAwait(false);

            // placeholder for the parent element
            await writer.WriteAsync(null, stream).ConfigureAwait(false);
        }
Esempio n. 10
0
        protected override async Task WriteNonNullableValueAsync(RelationIdentifier value, Stream stream,
                                                                 GraphBinaryWriter writer)
        {
            await stream.WriteLongAsync(value.OutVertexId).ConfigureAwait(false);

            await stream.WriteLongAsync(value.TypeId).ConfigureAwait(false);

            await stream.WriteLongAsync(value.RelationId).ConfigureAwait(false);

            await stream.WriteLongAsync(value.InVertexId).ConfigureAwait(false);
        }
Esempio n. 11
0
        private static async Task WriteInstructionsAsync(IReadOnlyCollection <Instruction> instructions, Stream stream,
                                                         GraphBinaryWriter writer)
        {
            await writer.WriteValueAsync(instructions.Count, stream, false).ConfigureAwait(false);

            foreach (var instruction in instructions)
            {
                await writer.WriteValueAsync(instruction.OperatorName, stream, false).ConfigureAwait(false);
                await WriteArgumentsAsync(instruction.Arguments, stream, writer).ConfigureAwait(false);
            }
        }
Esempio n. 12
0
        /// <inheritdoc />
        protected override async Task WriteValueAsync(TSet value, Stream stream, GraphBinaryWriter writer)
        {
            var enumerable = (IEnumerable)value;
            var list       = enumerable.Cast <object>().ToList();

            await writer.WriteValueAsync(list.Count, stream, false).ConfigureAwait(false);

            foreach (var item in list)
            {
                await writer.WriteAsync(item, stream).ConfigureAwait(false);
            }
        }
Esempio n. 13
0
 /// <inheritdoc />
 protected override async Task WriteValueAsync(Type value, Stream stream, GraphBinaryWriter writer)
 {
     if (typeof(AbstractTraversalStrategy).IsAssignableFrom(value))
     {
         var strategyInstance = (AbstractTraversalStrategy)Activator.CreateInstance(value);
         await writer.WriteValueAsync(strategyInstance.Fqcn, stream, false).ConfigureAwait(false);
     }
     else
     {
         throw new IOException("Currently, writing of Types is only supported for traversal strategies.");
     }
 }
Esempio n. 14
0
        /// <inheritdoc />
        protected override async Task WriteValueAsync(Edge value, Stream stream, GraphBinaryWriter writer)
        {
            await writer.WriteAsync(value.Id, stream).ConfigureAwait(false);

            await writer.WriteValueAsync(value.Label, stream, false).ConfigureAwait(false);

            await writer.WriteAsync(value.InV.Id, stream).ConfigureAwait(false);

            await writer.WriteValueAsync(value.InV.Label, stream, false).ConfigureAwait(false);

            await writer.WriteAsync(value.OutV.Id, stream).ConfigureAwait(false);

            await writer.WriteValueAsync(value.OutV.Label, stream, false).ConfigureAwait(false);

            // Placeholder for the parent vertex
            await writer.WriteAsync(null, stream).ConfigureAwait(false);

            // placeholder for the properties
            await writer.WriteAsync(null, stream).ConfigureAwait(false);
        }
Esempio n. 15
0
        /// <inheritdoc />
        protected override async Task WriteValueAsync(Guid value, Stream stream, GraphBinaryWriter writer)
        {
            var bytes = value.ToByteArray();

            // first 4 bytes in reverse order:
            await stream.WriteByteAsync(bytes[3]).ConfigureAwait(false);

            await stream.WriteByteAsync(bytes[2]).ConfigureAwait(false);

            await stream.WriteByteAsync(bytes[1]).ConfigureAwait(false);

            await stream.WriteByteAsync(bytes[0]).ConfigureAwait(false);

            // 2 bytes in reverse order:
            await stream.WriteByteAsync(bytes[5]).ConfigureAwait(false);

            await stream.WriteByteAsync(bytes[4]).ConfigureAwait(false);

            // 3 bytes in reverse order:
            await stream.WriteByteAsync(bytes[7]).ConfigureAwait(false);

            await stream.WriteByteAsync(bytes[6]).ConfigureAwait(false);

            // 3 bytes:
            await stream.WriteByteAsync(bytes[8]).ConfigureAwait(false);

            await stream.WriteByteAsync(bytes[9]).ConfigureAwait(false);

            // last 6 bytes:
            await stream.WriteByteAsync(bytes[10]).ConfigureAwait(false);

            await stream.WriteByteAsync(bytes[11]).ConfigureAwait(false);

            await stream.WriteByteAsync(bytes[12]).ConfigureAwait(false);

            await stream.WriteByteAsync(bytes[13]).ConfigureAwait(false);

            await stream.WriteByteAsync(bytes[14]).ConfigureAwait(false);

            await stream.WriteByteAsync(bytes[15]).ConfigureAwait(false);
        }
Esempio n. 16
0
        /// <inheritdoc />
        public async Task WriteValueAsync(object value, Stream stream, GraphBinaryWriter writer, bool nullable)
        {
            if (value == null)
            {
                if (!nullable)
                {
                    throw new IOException("Unexpected null value when nullable is false");
                }

                await writer.WriteValueFlagNullAsync(stream).ConfigureAwait(false);

                return;
            }

            if (nullable)
            {
                await writer.WriteValueFlagNoneAsync(stream).ConfigureAwait(false);
            }

            await WriteValueAsync((T)value, stream, writer).ConfigureAwait(false);
        }
Esempio n. 17
0
        /// <inheritdoc />
        protected override async Task WriteValueAsync(P value, Stream stream, GraphBinaryWriter writer)
        {
            ICollection args = value.Value is ICollection ? value.Value : new List <object> {
                value.Value
            };

            var argsLength = value.Other == null ? args.Count : args.Count + 1;

            await writer.WriteValueAsync(value.OperatorName, stream, false).ConfigureAwait(false);

            await writer.WriteValueAsync(argsLength, stream, false).ConfigureAwait(false);

            foreach (var arg in args)
            {
                await writer.WriteAsync(arg, stream).ConfigureAwait(false);
            }

            if (value.Other != null)
            {
                await writer.WriteAsync(value.Other, stream).ConfigureAwait(false);
            }
        }
Esempio n. 18
0
 /// <inheritdoc />
 protected override async Task WriteValueAsync(T value, Stream stream, GraphBinaryWriter writer)
 {
     await _writeFunc.Invoke(value, stream).ConfigureAwait(false);
 }
Esempio n. 19
0
 /// <inheritdoc />
 protected override async Task WriteValueAsync(TEnum value, Stream stream, GraphBinaryWriter writer)
 {
     await writer.WriteAsync(value.EnumValue, stream).ConfigureAwait(false);
 }
 /// <inheritdoc />
 protected override async Task WriteValueAsync(DateTimeOffset value, Stream stream, GraphBinaryWriter writer)
 {
     await stream.WriteLongAsync(value.ToUnixTimeMilliseconds()).ConfigureAwait(false);
 }
Esempio n. 21
0
        /// <inheritdoc />
        protected override async Task WriteValueAsync(TMember[] value, Stream stream, GraphBinaryWriter writer)
        {
            await writer.WriteValueAsync(value.Length, stream, false).ConfigureAwait(false);

            foreach (var item in value)
            {
                await writer.WriteAsync(item, stream).ConfigureAwait(false);
            }
        }
Esempio n. 22
0
        /// <inheritdoc />
        protected override async Task WriteValueAsync(Binding value, Stream stream, GraphBinaryWriter writer)
        {
            await writer.WriteValueAsync(value.Key, stream, false).ConfigureAwait(false);

            await writer.WriteAsync(value.Value, stream).ConfigureAwait(false);
        }
Esempio n. 23
0
 /// <inheritdoc />
 protected override async Task WriteValueAsync(char value, Stream stream, GraphBinaryWriter writer)
 {
     var bytes = Encoding.UTF8.GetBytes(value.ToString());
     await stream.WriteAsync(bytes).ConfigureAwait(false);
 }
Esempio n. 24
0
 /// <inheritdoc />
 public abstract Task WriteValueAsync(object value, Stream stream, GraphBinaryWriter writer, bool nullable);
Esempio n. 25
0
        /// <inheritdoc />
        protected override async Task WriteValueAsync(BigInteger value, Stream stream, GraphBinaryWriter writer)
        {
            var bytes = value.ToByteArray().Reverse().ToArray();
            await writer.WriteValueAsync(bytes.Length, stream, false).ConfigureAwait(false);

            await stream.WriteAsync(bytes).ConfigureAwait(false);
        }
Esempio n. 26
0
 /// <inheritdoc />
 protected override async Task WriteValueAsync(ITraversal value, Stream stream, GraphBinaryWriter writer)
 {
     await writer.WriteValueAsync(value.Bytecode, stream, false).ConfigureAwait(false);
 }
Esempio n. 27
0
 /// <inheritdoc />
 public async Task WriteAsync(object value, Stream stream, GraphBinaryWriter writer)
 {
     await WriteValueAsync((T)value, stream, writer, true).ConfigureAwait(false);
 }
Esempio n. 28
0
 /// <summary>
 /// Currently not supported.
 /// </summary>
 protected override Task WriteValueAsync(TList value, Stream stream, GraphBinaryWriter writer)
 {
     throw new System.NotImplementedException("Writing a BulkSet is not supported");
 }
Esempio n. 29
0
 /// <summary>
 /// Writes a non-nullable value into a stream.
 /// </summary>
 /// <param name="value">The value to write.</param>
 /// <param name="stream">The stream to write to.</param>
 /// <param name="writer">A <see cref="GraphBinaryWriter"/>.</param>
 /// <returns>A task that represents the asynchronous write operation.</returns>
 protected abstract Task WriteValueAsync(T value, Stream stream, GraphBinaryWriter writer);
Esempio n. 30
0
 /// <inheritdoc />
 public abstract Task WriteAsync(object value, Stream stream, GraphBinaryWriter writer);