public override void Serialize(IoBuffer output, ISerializationContext context) { using (var mem = new MemoryStream()) { using (var writer = new BinaryWriter(mem)) { Tuning.SerializeInto(writer); var result = mem.ToArray(); output.PutInt32(result.Length); output.Put(result, 0, result.Length); } } output.PutInt32(ObjectUpgrades.Length); output.Put(ObjectUpgrades, 0, ObjectUpgrades.Length); }
public override void Serialize(IoBuffer output, ISerializationContext context) { output.PutEnum(Type); if (Type == MailRequestType.SEND) { byte[] dat; if (Item == null) { dat = new byte[0]; } else { using (var str = new MemoryStream()) { Item.Save(str); dat = str.ToArray(); } } output.PutInt32(dat.Length); foreach (var b in dat) { output.Put(b); } } else { output.PutInt64(TimestampID); } }
public override void Serialize(IoBuffer output, ISerializationContext context) { output.PutEnum <PurchaseLotStatus>(Status); output.PutEnum <PurchaseLotFailureReason>(Reason); output.PutUInt32(NewLotId); output.PutInt32(NewFunds); }
public override void Serialize(IoBuffer output, ISerializationContext context) { base.Serialize(output, context); output.PutPascalString(TaskType); output.PutInt32(ShardId); output.PutString(ParameterJson, Encoding.UTF8); }
public void SendMsg() { //lock (this) { while (m_sendMsgs.Count > 0) { MessageBody msg = m_sendMsgs.Dequeue(); if (msg != null) { m_sendBuffer.Clear(); Array.Clear(m_sendData, 0, m_sendData.Length); int len = CPacket.HEADER_TYPE_BYTES + msg.data.Length; m_sendBuffer.PutInt32(len); m_sendBuffer.PutInt16((short)msg.type); m_sendBuffer.Put(msg.data); m_sendBuffer.Flip(); m_sendBuffer.Get(m_sendData, 0, len + CPacket.HEADER_LENGTH_BYTES); m_currentSendBufferWritePosition = len + CPacket.HEADER_LENGTH_BYTES; SendMsg(m_sendData); } } } }
public override void Serialize(IoBuffer output, ISerializationContext context) { base.Serialize(output, context); byte[] data = null; using (var mem = new MemoryStream()) { foreach (var item in Items) { item.Save(mem); } data = mem.ToArray(); } output.PutInt32(Items.Count); output.PutInt32(data.Length); output.Put(data); }
public override void Serialize(IoBuffer output, ISerializationContext context) { output.PutUInt32(AvatarId); output.PutUInt32(ReplaceId); output.PutInt32(LotId); output.PutEnum(Change); }
public override void Serialize(IoBuffer output, ISerializationContext context) { output.PutEnum(Status); output.PutEnum(Type); output.PutInt32(EntityId); output.PutUInt32(ClaimId); output.PutPascalString(NewOwner); }
public void Serialize(IoBuffer output, ISerializationContext context) { output.PutInt32(Outfits.Length); foreach (var outfit in Outfits) { outfit.Serialize(output, context); } }
public override void Serialize(IoBuffer output, ISerializationContext context) { output.PutEnum(Type); output.PutEnum(Action); output.PutInt32(EntityId); output.PutUInt32(ClaimId); output.PutUInt32(SpecialId); output.PutPascalString(FromOwner); }
public void Encode(IoSession session, PacketOutStream message, IProtocolEncoderOutput output) { int size = message.GetSize(); IoBuffer buf = IoBuffer.Allocate(size + 4); buf.PutInt32(size); buf.Put(message.getPackets2()); buf.Flip(); output.Write(buf); }
public override void Serialize(IoBuffer output, ISerializationContext context) { output.PutEnum(Type); output.PutInt32(Messages.Length); foreach (var msg in Messages) { byte[] dat; using (var str = new MemoryStream()) { msg.Save(str); dat = str.ToArray(); } output.PutInt32(dat.Length); foreach (var b in dat) { output.Put(b); } } }
protected override void EncodeBody(IoSession session, T message, IoBuffer output) { if (message.OK) { output.PutInt16((short)Constants.RESULT_OK); output.PutInt32(message.Value); } else { output.PutInt16((short)Constants.RESULT_ERROR); } }
public void Encode(IoSession session, T message, IProtocolEncoderOutput output) { IoBuffer buf = IoBuffer.Allocate(16); buf.AutoExpand = true; // Enable auto-expand for easier encoding // Encode a header buf.PutInt16((short)_type); buf.PutInt32(message.Sequence); // Encode a body EncodeBody(session, message, buf); buf.Flip(); output.Write(buf); }
private static FileInfo CreateLargeFile() { IoBuffer buffer = IoBuffer.Allocate(FILE_SIZE); for (Int32 i = 0; i < FILE_SIZE / 4; i++) { buffer.PutInt32(i); } buffer.Flip(); String path = Path.GetTempFileName(); Byte[] data = new Byte[buffer.Remaining]; buffer.Get(data, 0, data.Length); File.WriteAllBytes(path, data); return(new FileInfo(path)); }
public override void Serialize(IoBuffer output, ISerializationContext context) { output.PutBool(NominationMode); output.PutInt32(Candidates.Count); foreach (var candidate in Candidates) { output.PutUInt32(candidate.ID); output.PutPascalVLCString(candidate.Name); output.PutUInt32(candidate.Rating); if (!NominationMode) { output.PutPascalVLCString(candidate.LastNhoodName); output.PutUInt32(candidate.LastNhoodID); output.PutUInt32(candidate.TermNumber); output.PutPascalVLCString(candidate.Message); } } }
public void Encode(IoSession session, object message, IProtocolEncoderOutput output) { WampCommandBase cmd = (WampCommandBase)message; string json = cmd.toCommandJson(); byte[] jsonByteArray = System.Text.Encoding.UTF8.GetBytes(json); int len = jsonByteArray.Length + 4; if (len > 1000000) { throw new ArgumentException("{msg:'data size > 1m', dataSize:" + len + "}"); } IoBuffer buffer = IoBuffer.Allocate(len); buffer.AutoExpand = true; buffer.PutInt32(len); buffer.Put(jsonByteArray); buffer.Flip(); output.Write(buffer); }
private cTSOValue SerializeValue(uint type, object value) { var result = new cTSOValue(); IoBuffer buffer = null; switch (type) { case 0x48BC841E: if (!(value is sbyte) && !(value is Enum)) { return(null); } result.Type = cTSOValue_sint8; result.Value = new sbyte[] { Convert.ToSByte(value) }; break; case 0x74336731: if (!(value is ushort)) { return(null); } buffer = AbstractVoltronPacket.Allocate(2); buffer.PutUInt16((ushort)value); buffer.Flip(); result.Type = cTSOValue_uint16; result.Value = buffer; break; case 0xF192ECA6: if (!(value is short)) { return(null); } buffer = AbstractVoltronPacket.Allocate(2); buffer.PutInt16((short)value); buffer.Flip(); result.Type = cTSOValue_sint16; result.Value = buffer; break; case 0xE0463A2F: if (!(value is uint)) { return(null); } buffer = AbstractVoltronPacket.Allocate(4); buffer.PutUInt32((uint)value); buffer.Flip(); result.Type = cTSOValue_uint32; result.Value = buffer; break; case 0xA0587098: if (!(value is int)) { return(null); } buffer = AbstractVoltronPacket.Allocate(4); buffer.PutInt32((int)value); buffer.Flip(); result.Type = cTSOValue_sint32; result.Value = buffer; break; case 0x385070C9: if (!(value is ulong)) { return(null); } buffer = AbstractVoltronPacket.Allocate(8); buffer.PutUInt64((ulong)value); buffer.Flip(); result.Type = cTSOValue_uint64; result.Value = buffer; break; case 0x90D315F7: if (!(value is long)) { return(null); } buffer = AbstractVoltronPacket.Allocate(8); buffer.PutInt64((long)value); buffer.Flip(); result.Type = cTSOValue_sint64; result.Value = buffer; break; default: //It may be a struct var _struct = Format.Structs.FirstOrDefault(x => x.ID == type); if (_struct != null) { var body = new cITSOProperty(); body.StructType = _struct.ID; body.StructFields = new List <cITSOField>(); foreach (var field in _struct.Fields) { object fieldValue = GetFieldValue(value, field.Name); if (fieldValue == null) { continue; } body.StructFields.Add(new cITSOField { ID = field.ID, Value = SerializeValue(field.TypeID, fieldValue) }); } result.Type = cTSOValue_property; result.Value = body; return(result); } return(null); } return(result); }
public static void PutUInt32(this IoBuffer buffer, uint value) { int converted = unchecked ((int)value); buffer.PutInt32(converted); }
public bool Write(IoBuffer output, DuplexMessage message) { var writeOk = false; try { using (var scope = ObjectHost.Host.BeginLifetimeScope()) { var filters = new List <IMessageFilter>(); var dataStack = new StackMessageDataContaner(); var filterFactory = scope.Resolve <MessageFilterFactory>(); filters.Add(filterFactory.CreateFilter( message.Header.FilterCode[0], message.Header.FilterType & MessageFilterType.Compression)); filters.Add(filterFactory.CreateFilter( message.Header.FilterCode[0], message.Header.FilterType & MessageFilterType.Crypto)); var identifierBinary = message.Header.Identifier.FromHex(); dataStack.Push(identifierBinary); dataStack.Push(message.GetContentBinary()); FilterResult result = new FilterResult { OK = true }; foreach (var filter in filters) { result = filter.Out(message.Header, dataStack); if (!result.OK) { break; } } if (result.OK) { var body = dataStack.Take(); output.PutInt32(49 + body.Length); output.Put(message.Header.Version.ToByte()); output.PutInt16(Convert.ToInt16(message.Header.CommandCode)); output.Put(message.Header.ErrorCode.ToByte()); output.Put(message.Header.MessageType.ToByte()); output.Put(identifierBinary); output.Put(message.Header.MessageID.FromBase64()); output.Put(message.Header.FilterType.ToByte()); output.Put(message.Header.FilterCode); output.Put(message.Header.SerializeMode.ToByte()); output.Flip(); var header = output.GetRemainingArray(); dataStack.Push(body); dataStack.Push(header); result = filterFactory .CreateFilter(message.Header.FilterCode[0], message.Header.FilterType & MessageFilterType.Checksum) .Out(message.Header, dataStack); writeOk = result.OK; if (writeOk) { output.Put(dataStack.Take()); output.Put(body); } } } } catch (Exception ex) { Log.Error(ErrorCode.SysError.ToString(), ex); } return(writeOk); }
protected override void EncodeBody(IoSession session, T message, IoBuffer output) { output.PutInt32(message.Value); }
public override void Serialize(IoBuffer output, ISerializationContext context) { output.PutInt32(Data.Length); output.Put(Data, 0, Data.Length); }
public override void Serialize(IoBuffer output, ISerializationContext context) { output.PutUInt32(AvatarId); output.PutInt32(LotId); output.PutPascalString(FromOwner); }
public override void Serialize(IoBuffer output, ISerializationContext context) { base.Serialize(output, context); output.PutInt32(TaskId); }