示例#1
0
        public bnet.protocol.presence.Field GetField(bnet.protocol.attribute.Variant variantValue)
        {
            var fieldKey = FieldKeyHelper.Create(Program, OriginatingClass, FieldNumber, Index);
            var field    = bnet.protocol.presence.Field.CreateBuilder().SetKey(fieldKey).SetValue(variantValue).Build();

            return(field);
        }
        public static void Serialize(Stream stream, bnet.protocol.attribute.Variant instance)
        {
            BinaryWriter binaryWriter = new BinaryWriter(stream);

            if (instance.HasBoolValue)
            {
                stream.WriteByte(16);
                ProtocolParser.WriteBool(stream, instance.BoolValue);
            }
            if (instance.HasIntValue)
            {
                stream.WriteByte(24);
                ProtocolParser.WriteUInt64(stream, (ulong)instance.IntValue);
            }
            if (instance.HasFloatValue)
            {
                stream.WriteByte(33);
                binaryWriter.Write(instance.FloatValue);
            }
            if (instance.HasStringValue)
            {
                stream.WriteByte(42);
                ProtocolParser.WriteBytes(stream, Encoding.UTF8.GetBytes(instance.StringValue));
            }
            if (instance.HasBlobValue)
            {
                stream.WriteByte(50);
                ProtocolParser.WriteBytes(stream, instance.BlobValue);
            }
            if (instance.HasMessageValue)
            {
                stream.WriteByte(58);
                ProtocolParser.WriteBytes(stream, instance.MessageValue);
            }
            if (instance.HasFourccValue)
            {
                stream.WriteByte(66);
                ProtocolParser.WriteBytes(stream, Encoding.UTF8.GetBytes(instance.FourccValue));
            }
            if (instance.HasUintValue)
            {
                stream.WriteByte(72);
                ProtocolParser.WriteUInt64(stream, instance.UintValue);
            }
            if (instance.HasEntityidValue)
            {
                stream.WriteByte(82);
                ProtocolParser.WriteUInt32(stream, instance.EntityidValue.GetSerializedSize());
                EntityId.Serialize(stream, instance.EntityidValue);
            }
        }
 public override bool Equals(object obj)
 {
     bnet.protocol.attribute.Variant variant = obj as bnet.protocol.attribute.Variant;
     if (variant == null)
     {
         return(false);
     }
     if (this.HasBoolValue != variant.HasBoolValue || this.HasBoolValue && !this.BoolValue.Equals(variant.BoolValue))
     {
         return(false);
     }
     if (this.HasIntValue != variant.HasIntValue || this.HasIntValue && !this.IntValue.Equals(variant.IntValue))
     {
         return(false);
     }
     if (this.HasFloatValue != variant.HasFloatValue || this.HasFloatValue && !this.FloatValue.Equals(variant.FloatValue))
     {
         return(false);
     }
     if (this.HasStringValue != variant.HasStringValue || this.HasStringValue && !this.StringValue.Equals(variant.StringValue))
     {
         return(false);
     }
     if (this.HasBlobValue != variant.HasBlobValue || this.HasBlobValue && !this.BlobValue.Equals(variant.BlobValue))
     {
         return(false);
     }
     if (this.HasMessageValue != variant.HasMessageValue || this.HasMessageValue && !this.MessageValue.Equals(variant.MessageValue))
     {
         return(false);
     }
     if (this.HasFourccValue != variant.HasFourccValue || this.HasFourccValue && !this.FourccValue.Equals(variant.FourccValue))
     {
         return(false);
     }
     if (this.HasUintValue != variant.HasUintValue || this.HasUintValue && !this.UintValue.Equals(variant.UintValue))
     {
         return(false);
     }
     if (this.HasEntityidValue == variant.HasEntityidValue && (!this.HasEntityidValue || this.EntityidValue.Equals(variant.EntityidValue)))
     {
         return(true);
     }
     return(false);
 }
示例#4
0
 public void SetValue(bnet.protocol.attribute.Variant val)
 {
     this.Value = val;
 }
        public static bnet.protocol.attribute.Variant DeserializeLengthDelimited(Stream stream, bnet.protocol.attribute.Variant instance)
        {
            long position = (long)ProtocolParser.ReadUInt32(stream);

            position += stream.Position;
            return(bnet.protocol.attribute.Variant.Deserialize(stream, instance, position));
        }
 public static bnet.protocol.attribute.Variant DeserializeLengthDelimited(Stream stream)
 {
     bnet.protocol.attribute.Variant variant = new bnet.protocol.attribute.Variant();
     bnet.protocol.attribute.Variant.DeserializeLengthDelimited(stream, variant);
     return(variant);
 }
        public static bnet.protocol.attribute.Variant Deserialize(Stream stream, bnet.protocol.attribute.Variant instance, long limit)
        {
            BinaryReader binaryReader = new BinaryReader(stream);

            while (true)
            {
                if (limit < (long)0 || stream.Position < limit)
                {
                    int num = stream.ReadByte();
                    if (num == -1)
                    {
                        if (limit >= (long)0)
                        {
                            throw new EndOfStreamException();
                        }
                        break;
                    }
                    else if (num == 16)
                    {
                        instance.BoolValue = ProtocolParser.ReadBool(stream);
                    }
                    else if (num == 24)
                    {
                        instance.IntValue = (long)ProtocolParser.ReadUInt64(stream);
                    }
                    else if (num == 33)
                    {
                        instance.FloatValue = binaryReader.ReadDouble();
                    }
                    else if (num == 42)
                    {
                        instance.StringValue = ProtocolParser.ReadString(stream);
                    }
                    else if (num == 50)
                    {
                        instance.BlobValue = ProtocolParser.ReadBytes(stream);
                    }
                    else if (num == 58)
                    {
                        instance.MessageValue = ProtocolParser.ReadBytes(stream);
                    }
                    else if (num == 66)
                    {
                        instance.FourccValue = ProtocolParser.ReadString(stream);
                    }
                    else if (num == 72)
                    {
                        instance.UintValue = ProtocolParser.ReadUInt64(stream);
                    }
                    else if (num != 82)
                    {
                        Key key = ProtocolParser.ReadKey((byte)num, stream);
                        if (key.Field == 0)
                        {
                            throw new ProtocolBufferException("Invalid field id: 0, something went wrong in the stream");
                        }
                        ProtocolParser.SkipKey(stream, key);
                    }
                    else if (instance.EntityidValue != null)
                    {
                        EntityId.DeserializeLengthDelimited(stream, instance.EntityidValue);
                    }
                    else
                    {
                        instance.EntityidValue = EntityId.DeserializeLengthDelimited(stream);
                    }
                }
                else
                {
                    if (stream.Position != limit)
                    {
                        throw new ProtocolBufferException("Read past max limit");
                    }
                    break;
                }
            }
            return(instance);
        }
 public static bnet.protocol.attribute.Variant Deserialize(Stream stream, bnet.protocol.attribute.Variant instance)
 {
     return(bnet.protocol.attribute.Variant.Deserialize(stream, instance, (long)-1));
 }