コード例 #1
0
 public void Write(object o)
 {
     if (writeRecurseDepth++ == 0)
     {
         var sFlags = Settings.ToFlags();
         output.WriteVInt(sFlags);
     }
     try
     {
         Write(RObject, o);
     }
     finally { writeRecurseDepth--; }
 }
コード例 #2
0
 /// <summary>
 /// Initializes a new instance of the <see cref="ObjectWriter"/> class.
 /// </summary>
 /// <param name="writer">The writer to which the data is written.</param>
 /// <exception cref="System.ArgumentNullException">If the writer is null</exception>
 public ObjectWriter(IPrimitiveWriter writer)
 {
     if (writer == null)
     {
         throw new ArgumentNullException(nameof(writer));
     }
     Writer  = writer;
     Context = new ObjectContext();
     Writer.WriteVInt(VERSION);
 }
コード例 #3
0
 public Writer(IPrimitiveWriter output)
 {
     this.output = output ?? throw new ArgumentNullException(nameof(output));
     output.WriteVInt(VERSION);
 }
コード例 #4
0
        internal void Write(Writer writer, IPrimitiveWriter output)
        {
            if (!IsSupported)
            {
                output.WriteVInt(0);
                return;
            }
            var flags = 1;

            if (IsInterface)
            {
                flags |= 1 << 1;
            }
            if (IsISerializable)
            {
                flags |= 1 << 2;
            }
            if (IsReference)
            {
                flags |= 1 << 3;
            }
            if (IsSealed)
            {
                flags |= 1 << 4;
            }
            if (IsArray)
            {
                flags |= 1 << 5;
            }
            if (IsNullable)
            {
                flags |= 1 << 6;
            }
            if (IsEnum)
            {
                flags |= 1 << 7;
            }
            if (IsGeneric)
            {
                flags |= 1 << 8;
            }
            if (IsGenericParameter)
            {
                flags |= 1 << 9;
            }
            if (IsGenericTypeDefinition)
            {
                flags |= 1 << 10;
            }
            if (HasConverter)
            {
                flags |= 1 << 11;
            }
            flags |= (int)Kind << 12;
            flags |= (int)CollectionType << 17;
            switch (Kind)
            {
            case PrimitiveType.None:
            case PrimitiveType.Object:
                break;

            default:
                return;
            }
            output.WriteVInt(flags);

            writer.Write(Context.RType, Element);
            writer.Write(Context.RType, Surrogate);
            output.WriteVInt(GenericParameters?.Count ?? 0);
            if (GenericParameters != null)
            {
                for (int i = 0; i < GenericParameters.Count; i++)
                {
                    writer.Write(Context.RType, GenericParameters[i]);
                }
            }

            if (!IsGeneric || IsGenericTypeDefinition)
            {
                writer.Write(Context.RString, FullName);
                writer.Write(Context.RString, Assembly);
                output.WriteVInt(GenericParameterIndex);
                writer.Write(Context.RType, BaseType);
                output.WriteVInt(ArrayRank);

                if (Surrogate == null &&
                    !IsInterface &&
                    !IsArray && !IsEnum &&
                    !IsGenericParameter)
                {
                    output.WriteVInt(Members.Count);
                    for (int i = 0; i < Members.Count; i++)
                    {
                        var m = Members[i];
                        writer.Write(Context.RString, m.Name);
                        writer.Write(Context.RType, m.Type);
                    }
                    writer.Write(Context.RType, Collection1);
                    writer.Write(Context.RType, Collection2);
                }
            }
        }