private bool FlagsReady() { m_tmpbuf.Reset(); // Store the flags from the wire into the message structure. m_msgFlags = 0; int first = m_tmpbuf[0]; if ((first & V1Protocol.MoreFlag) > 0) { m_msgFlags |= MsgFlags.More; } // The payload length is either one or eight bytes, // depending on whether the 'large' bit is set. if ((first & V1Protocol.LargeFlag) > 0) { NextStep(m_tmpbuf, 8, EightByteSizeReadyState); } else { NextStep(m_tmpbuf, 1, OneByteSizeReadyState); } return(true); }
static public FilteredMsgTypeList Filtered(GameObject inGameObject, MsgFlags inAll, MsgFlags inAny = MsgFlags.None) { if (inGameObject == null && (inAll == MsgFlags.None && inAny == MsgFlags.None)) { return(All()); } Initialize(); List <MsgType> types = null; MsgUtil.GetAvailableMsgTypes(inGameObject, ref types); List <Metadata> metadatas = new List <Metadata>(types.Count); for (int i = 0; i < types.Count; ++i) { Metadata metadata = Manager.Get().Database.Find(types[i]); if (metadata == null) { continue; } if ((inAll == MsgFlags.None || metadata.HasFlags(inAll)) && (inAny == MsgFlags.None || metadata.HasAnyFlags(inAny)) && !metadatas.Contains(metadata)) { metadatas.Add(metadata); } } metadatas.Sort(); return(new FilteredMsgTypeList(metadatas)); }
private void Clone(Msg m) { MsgType = m.MsgType; m_flags = m.m_flags; m_size = m.m_size; m_buf = m.m_buf; m_data = m.m_data; }
public void InitGC([NotNull] byte[] data, int size) { m_type = MsgType.GC; m_flags = MsgFlags.None; m_data = data; m_size = size; m_atomicCounter = null; }
public void InitEmpty() { m_type = MsgType.Empty; m_flags = MsgFlags.None; m_size = 0; m_data = null; m_atomicCounter = null; }
/// <summary> /// Clear this Msg to empty - ie, set MsgFlags to None, MsgType to Empty, and clear the Data. /// </summary> public void InitEmpty() { MsgType = MsgType.Empty; Flags = MsgFlags.None; Size = 0; m_offset = 0; m_data = null; EnsureAtomicCounterNull(); }
public void InitPool(int size) { m_type = MsgType.Pool; m_flags = MsgFlags.None; m_data = BufferPool.Take(size); m_size = size; m_atomicCounter = new AtomicCounter(); }
/// <summary> /// Initialise this Msg to be of MsgType.GC with the given data-buffer value. /// </summary> /// <param name="data">the byte-array of data to assign to the Msg's Data property</param> /// <param name="offset">first byte in the data array</param> /// <param name="size">the number of bytes that are in the data byte-array</param> public void InitGC([NotNull] byte[] data, int offset, int size) { MsgType = MsgType.GC; Flags = MsgFlags.None; m_data = data; Size = size; m_offset = offset; m_refCount = null; }
/// <summary> /// Initialise this Msg to be of MsgType.Pool, with a data-buffer of the given number of bytes. /// </summary> /// <param name="size">the number of bytes to allocate in the data-buffer</param> public void InitPool(int size) { MsgType = MsgType.Pool; Flags = MsgFlags.None; m_data = BufferPool.Take(size); Size = size; m_offset = 0; m_refCount = new AtomicCounter(); }
/// <summary> /// Clear this Msg to empty - ie, set MsgFlags to None, MsgType to Empty, and clear the Data. /// </summary> public void InitEmpty() { MsgType = MsgType.Empty; Flags = MsgFlags.None; Size = 0; m_offset = 0; m_data = null; m_refCount = null; }
/// <summary> /// Initialise this Msg to be of MsgType.GC with the given data-buffer value. /// </summary> /// <param name="data">the byte-array of data to assign to the Msg's Data property</param> /// <param name="offset">first byte in the data array</param> /// <param name="size">the number of bytes that are in the data byte-array</param> public void InitGC([NotNull] byte[] data, int offset, int size) { MsgType = MsgType.GC; Flags = MsgFlags.None; m_data = data; Size = size; m_offset = offset; EnsureAtomicCounterNull(); }
private void Init(MsgType type) { this.MsgType = type; m_flags = MsgFlags.None; Size = 0; m_data = null; m_buf = null; m_header = null; }
public override bool SendPackMsg <T>(T msg, MsgFlags flags, int clientId) { var packer = new MsgPacker((int)msg.Type, false); if (msg.PackError(packer)) { return(false); } return(SendMsg(packer, flags, clientId)); }
public void Process() { Flags = MakeFlags(); #if UNITY_EDITOR StringBuilder tooltipText = new StringBuilder(); tooltipText.Append(Name).Append("\n(ID ").Append((int)Type).Append(")"); if (Description.Length > 0) { tooltipText.Append("\n - ").Append(Description); } if (ArgType == null) { tooltipText.Append("\n - No arguments."); } else { tooltipText.Append("\n - Arg: ").Append(ArgType.FullName); if (HasFlags(MsgFlags.OptionalArgs)) { tooltipText.Append(" (Optional)"); } } if (HasAnyFlags(MsgFlags.Local | MsgFlags.Global | MsgFlags.Input | MsgFlags.Output)) { tooltipText.Append("\n -"); if (HasFlags(MsgFlags.Local)) { tooltipText.Append(" Local"); } else if (HasFlags(MsgFlags.Global)) { tooltipText.Append(" Global"); } if (HasFlags(MsgFlags.Input)) { tooltipText.Append(" Input"); } else if (HasFlags(MsgFlags.Output)) { tooltipText.Append(" Output"); } if (tooltipText[tooltipText.Length - 1] == ' ') { --tooltipText.Length; } } Tooltip = tooltipText.ToString(); #endif m_Database.Process(this); }
public static int ZmqMsgGet(Msg msg, MsgFlags option) { switch (option) { case MsgFlags.More: return(msg.HasMore ? 1 : 0); default: throw InvalidException.Create(); } }
protected override bool SendPackMsgOne(BaseGameMessage msg, MsgFlags flags, int clientId) { var packer = new MsgPacker((int)msg.MsgId); if (msg.PackError(packer)) { return(false); } return(SendMsg(packer, flags, clientId)); }
protected override bool SendPackMsgTranslate(GameMsg_SvEmoticon msg, MsgFlags flags, int clientId) { var copy = new GameMsg_SvEmoticon { ClientId = msg.ClientId, Emoticon = msg.Emoticon }; return(Translate(ref copy.ClientId, clientId) && SendPackMsgOne(copy, flags, clientId)); }
public override bool SendMsg(MsgPacker msg, MsgFlags flags, int clientId) { if (msg == null) { return(false); } var packet = new Chunk() { ClientId = clientId, DataSize = msg.Size(), Data = msg.Data(), Flags = SendFlags.None, }; if (flags.HasFlag(MsgFlags.Vital)) { packet.Flags |= SendFlags.Vital; } if (flags.HasFlag(MsgFlags.Flush)) { packet.Flags |= SendFlags.Flush; } if (!flags.HasFlag(MsgFlags.NoRecord)) { // TODO demo record } if (flags.HasFlag(MsgFlags.NoSend)) { return(true); } if (clientId == -1) { for (var i = 0; i < Clients.Length; i++) { if (Clients[i].State == ServerClientState.InGame && Clients[i].Quitting == false) { packet.ClientId = i; NetworkServer.Send(packet); } } } else { NetworkServer.Send(packet); } return(true); }
public override bool SendMsgEx(MsgPacker msg, MsgFlags flags, int clientId, bool system) { if (msg == null) { return(false); } var packet = new NetworkChunk() { ClientId = clientId, DataSize = msg.Size(), Data = msg.Data(), }; packet.Data[0] <<= 1; if (system) { packet.Data[0] |= 1; } if (flags.HasFlag(MsgFlags.VITAL)) { packet.Flags |= SendFlags.VITAL; } if (flags.HasFlag(MsgFlags.FLUSH)) { packet.Flags |= SendFlags.FLUSH; } if (!flags.HasFlag(MsgFlags.NOSEND)) { if (clientId == -1) { for (var i = 0; i < Clients.Length; i++) { if (Clients[i].State != ServerClientState.IN_GAME) { continue; } packet.ClientId = i; NetworkServer.Send(packet); } } else { NetworkServer.Send(packet); } } return(true); }
private MsgFlags MakeFlags() { MsgFlags flags = Flags; // Don't allow users to determine if the arguments // are serializable flags &= ~(MsgFlags.ArgsAreSerializable); // Auto-populate argument flags. if (ArgType == null) { // Remove optional and requires flags flags &= ~(MsgFlags.OptionalArgs | MsgFlags.RequiresArgs); // No argument required flags |= MsgFlags.NoArgs; } else { flags &= ~(MsgFlags.NoArgs); // If the argument isn't optional, set the required flag if ((flags & MsgFlags.OptionalArgs) != 0) { flags |= MsgFlags.RequiresArgs; } // Check if the argument is serializable in the editor. IntPtr typeHandle = ArgType.TypeHandle.Value; if (typeHandle == TYPE_PTR_BOOL || typeHandle == TYPE_PTR_FLOAT || typeHandle == TYPE_PTR_INT || typeHandle == TYPE_PTR_STRING || ArgType.IsEnum || TYPE_UNITYENGINE_OBJECT.IsAssignableFrom(ArgType)) { flags |= MsgFlags.ArgsAreSerializable; } } // Should this be shown in the editor? if (string.IsNullOrEmpty(DisplayName)) { flags &= ~(MsgFlags.VisibleInEditor); } else { flags |= (MsgFlags.VisibleInEditor); } return(flags); }
protected override bool SendPackMsgBody <T>(T msg, MsgFlags flags, int clientId) { if (msg is GameMsg_SvEmoticon) { return(SendPackMsgTranslate(msg as GameMsg_SvEmoticon, flags, clientId)); } if (msg is GameMsg_SvChat) { return(SendPackMsgTranslate(msg as GameMsg_SvChat, flags, clientId)); } if (msg is GameMsg_SvKillMsg) { return(SendPackMsgTranslate(msg as GameMsg_SvKillMsg, flags, clientId)); } return(SendPackMsgTranslate(msg, flags, clientId)); }
protected override bool SendPackMsgTranslate(GameMsg_SvChat msg, MsgFlags flags, int clientId) { var copy = new GameMsg_SvChat { ClientId = msg.ClientId, Message = msg.Message, IsTeam = msg.IsTeam }; if (copy.ClientId >= 0 && !Translate(ref copy.ClientId, clientId)) { copy.Message = $"{GetClientName(copy.ClientId)}: {copy.Message}"; copy.ClientId = VANILLA_MAX_CLIENTS - 1; } return(SendPackMsgOne(copy, flags, clientId)); }
public void AddReferences(int amount) { if (amount == 0) { return; } if (m_type == MsgType.Pool) { if (m_flags == MsgFlags.Shared) { m_atomicCounter.Increase(amount); } else { m_atomicCounter.Set(amount); m_flags |= MsgFlags.Shared; } } }
public override bool SendPackMsg <T>(T msg, MsgFlags flags, int clientId) { var result = true; if (clientId == -1) { for (var i = 0; i < Clients.Length; i++) { if (ClientInGame(i)) { result &= SendPackMsgBody <T>(msg, flags, i); } } } else { return(SendPackMsgBody <T>(msg, flags, clientId)); } return(result); }
protected override bool SendPackMsgTranslate(GameMsg_SvKillMsg msg, MsgFlags flags, int clientId) { var copy = new GameMsg_SvKillMsg { Weapon = msg.Weapon, Killer = msg.Killer, ModeSpecial = msg.ModeSpecial, Victim = msg.Victim }; if (!Translate(ref copy.Victim, clientId)) { return(false); } if (!Translate(ref copy.Killer, clientId)) { copy.Killer = copy.Victim; } return(SendPackMsgOne(copy, flags, clientId)); }
/// <summary> /// Retrieves a list of all editor-visible message types that match the given flags. /// </summary> public void FindAll(MsgFlags inAll, ref List <Metadata> ioResults) { if (inAll == MsgFlags.None) { FindAll(ref ioResults); return; } if (ioResults == null) { ioResults = new List <Metadata>(); } for (int i = 0; i < m_EditorTypes.Count; ++i) { Metadata type = m_EditorTypes[i]; if (type.HasFlags(inAll)) { ioResults.Add(type); } } }
/// <summary> /// If this Msg is of MsgType.Pool, then - add the given amount number to the reference-counter /// and set the shared-data Flags bit. /// If this is not a Pool Msg, this does nothing. /// </summary> /// <param name="amount">the number to add to the internal reference-counter</param> public void AddReferences(int amount) { if (amount == 0) { return; } if (MsgType == MsgType.Pool) { if (IsShared) { m_refCount.Increase(amount); } else { // Because msg is not yet shared we add 1 to the amount to represent the current copy of the msg. // We can set the amount in a none thread-safe way because the message is not yet shared and // therefore only being used by one thread m_refCount.Set(amount + 1); Flags |= MsgFlags.Shared; } } }
/// <summary> /// Clear the indicated Flags bits. /// </summary> /// <param name="flags">which Flags bits to clear (More, Identity, or Shared)</param> public void ResetFlags(MsgFlags flags) { Flags &= ~flags; }
/// <summary> /// Set the indicated Flags bits. /// </summary> /// <param name="flags">which Flags bits to set (More, Identity, or Shared)</param> public void SetFlags(MsgFlags flags) { Flags |= flags; }
public void SetFlags(MsgFlags flags) { m_flags = m_flags | flags; }
public void ResetFlags(MsgFlags f) { m_flags = m_flags & ~f; }
public void InitDelimiter() { MsgType = MsgType.Delimiter; m_flags = MsgFlags.None; }
public static extern int rd_kafka_produce(IntPtr rkt, int partition, MsgFlags msgflags, byte[] payload, int len, byte[] key, int keylen, IntPtr msg_opaque);
private bool FlagsReady() { // Store the flags from the wire into the message structure. m_msgFlags = 0; int first = m_tmpbuf[0]; if ((first & V1Protocol.MoreFlag) > 0) m_msgFlags |= MsgFlags.More; // The payload length is either one or eight bytes, // depending on whether the 'large' bit is set. if ((first & V1Protocol.LargeFlag) > 0) NextStep (m_tmpbuf, 8, EightByteSizeReadyState); else NextStep (m_tmpbuf,1, OneByteSizeReadyState); return true; }
public static int ZmqMsgGet(Msg msg, MsgFlags option) { switch (option) { case MsgFlags.More: return msg.HasMore ? 1 : 0; default: throw new ArgumentException(); } }
/// <summary> /// Set the indicated Flags bits. /// </summary> /// <param name="flags">which Flags bits to set (More, Identity, or Shared)</param> public void SetFlags(MsgFlags flags) { this.Flags |= flags; }
public static int ZmqMsgGet(Msg msg, MsgFlags option) { switch (option) { case MsgFlags.More: return msg.HasMore ? 1 : 0; default: throw InvalidException.Create(); } }