WriteBytes() public static method

Writes a byte-array to the stream; supported wire-types: String
public static WriteBytes ( byte data, ProtoWriter writer ) : void
data byte
writer ProtoWriter
return void
 /// <summary>
 /// Writes a byte-array to the stream; supported wire-types: String
 /// </summary>
 public static void WriteBytes(byte[] data, ProtoWriter writer)
 {
     if (data == null)
     {
         throw new ArgumentNullException("data");
     }
     ProtoWriter.WriteBytes(data, 0, data.Length, writer);
 }
Esempio n. 2
0
        public static void WriteGuid(Guid value, ProtoWriter dest)
        {
            byte[]       data  = value.ToByteArray();
            SubItemToken token = ProtoWriter.StartSubItem(null, dest);

            if (value != Guid.Empty)
            {
                ProtoWriter.WriteFieldHeader(1, WireType.Fixed64, dest);
                ProtoWriter.WriteBytes(data, 0, 8, dest);
                ProtoWriter.WriteFieldHeader(2, WireType.Fixed64, dest);
                ProtoWriter.WriteBytes(data, 8, 8, dest);
            }
            ProtoWriter.EndSubItem(token, dest);
        }
        /// <summary>
        /// Writes a CombGuid to a protobuf stream
        /// </summary>
        public static void WriteCombGuid(CuteAnt.CombGuid value, ProtoWriter dest)
        {
            byte[] blob = value.GetByteArray();

            SubItemToken token = ProtoWriter.StartSubItem(null, dest);

            if (!value.IsNullOrEmpty)
            {
                ProtoWriter.WriteFieldHeader(FieldGuidLow, WireType.Fixed64, dest);
                ProtoWriter.WriteBytes(blob, 0, 8, dest);
                ProtoWriter.WriteFieldHeader(FieldGuidHigh, WireType.Fixed64, dest);
                ProtoWriter.WriteBytes(blob, 8, 8, dest);
            }
            ProtoWriter.EndSubItem(token, dest);
        }
Esempio n. 4
0
        private void AppendExtensionField(ProtoWriter writer)
        {
            //TODO: replace this with stream-based, buffered raw copying
            ProtoWriter.WriteFieldHeader(fieldNumber, wireType, writer);
            switch (wireType)
            {
            case WireType.Fixed32:
                ProtoWriter.WriteInt32(ReadInt32(), writer);
                return;

            case WireType.Variant:
            case WireType.SignedVariant:
            case WireType.Fixed64:
                ProtoWriter.WriteInt64(ReadInt64(), writer);
                return;

            case WireType.String:
                ProtoWriter.WriteBytes(AppendBytes(null, this), writer);
                return;

            case WireType.StartGroup:
                SubItemToken readerToken = StartSubItem(this),
                             writerToken = ProtoWriter.StartSubItem(null, writer);
                while (ReadFieldHeader() > 0)
                {
                    AppendExtensionField(writer);
                }
                EndSubItem(readerToken, this);
                ProtoWriter.EndSubItem(writerToken, writer);
                return;

            case WireType.None:     // treat as explicit errorr
            case WireType.EndGroup: // treat as explicit error
            default:                // treat as implicit error
                throw CreateException();
            }
        }
Esempio n. 5
0
        private void AppendExtensionField(ProtoWriter writer)
        {
            ProtoWriter.WriteFieldHeader(this.fieldNumber, this.wireType, writer);
            WireType wireType = this.wireType;

            switch (wireType + 1)
            {
            case WireType.Fixed64:
            case WireType.String:
            case (WireType)9:
                ProtoWriter.WriteInt64(this.ReadInt64(), writer);
                return;

            case WireType.StartGroup:
                ProtoWriter.WriteBytes(ProtoReader.AppendBytes(null, this), writer);
                return;

            case WireType.EndGroup:
            {
                SubItemToken token  = ProtoReader.StartSubItem(this);
                SubItemToken token2 = ProtoWriter.StartSubItem(null, writer);
                while (this.ReadFieldHeader() > 0)
                {
                    this.AppendExtensionField(writer);
                }
                ProtoReader.EndSubItem(token, this);
                ProtoWriter.EndSubItem(token2, writer);
                return;
            }

            case (WireType)6:
                ProtoWriter.WriteInt32(this.ReadInt32(), writer);
                return;
            }
            throw this.CreateWireTypeException();
        }
Esempio n. 6
0
        private void AppendExtensionField(ProtoWriter writer)
        {
            ProtoWriter.WriteFieldHeader(fieldNumber, wireType, writer);
            switch (wireType)
            {
            case WireType.Fixed32:
                ProtoWriter.WriteInt32(ReadInt32(), writer);
                break;

            case WireType.Variant:
            case WireType.Fixed64:
            case WireType.SignedVariant:
                ProtoWriter.WriteInt64(ReadInt64(), writer);
                break;

            case WireType.String:
                ProtoWriter.WriteBytes(AppendBytes(null, this), writer);
                break;

            case WireType.StartGroup:
            {
                SubItemToken token  = StartSubItem(this);
                SubItemToken token2 = ProtoWriter.StartSubItem(null, writer);
                while (ReadFieldHeader() > 0)
                {
                    AppendExtensionField(writer);
                }
                EndSubItem(token, this);
                ProtoWriter.EndSubItem(token2, writer);
                break;
            }

            default:
                throw CreateWireTypeException();
            }
        }
Esempio n. 7
0
 /// <summary>
 /// Writes a byte-array to the stream; supported wire-types: String
 /// </summary>
 public static void WriteBytes(byte[] data, ProtoWriter writer)
 {
     ProtoWriter.WriteBytes(data, 0, data.Length, writer);
 }