Example #1
0
        public static SerializableActor ToSerializableActor(this Dictionary <string, object> d)
        {
            var res = new SerializableActor
            {
                ActorNr  = (int)d[Actor.ActorNrKey],
                UserId   = d.ContainsKey(Actor.UserIdKey) ? (string)d[Actor.UserIdKey] : string.Empty,
                Nickname = d.ContainsKey(Actor.NicknameKey) ? (string)d[Actor.NicknameKey] : string.Empty,
                Binary   = d.ContainsKey(Actor.BinaryKey) ? (string)d[Actor.BinaryKey] : string.Empty
            };

            if (d.ContainsKey("DEBUG_BINARY"))
            {
                var debug_bin = d["DEBUG_BINARY"] as Dictionary <string, object>;
                if (debug_bin != null)
                {
                    res.DEBUG_BINARY = new Dictionary <byte, object>();
                    foreach (var entry in debug_bin)
                    {
                        var key = Convert.ToByte(entry.Key);
                        res.DEBUG_BINARY.Add(key, entry.Value);
                    }
                }
            }
            return(res);
        }
Example #2
0
        public SerializableActor Serialize(bool withDebugInfo)
        {
            bool?isActive = null;

            if (this.IsActive)
            {
                isActive = true;
            }

            var item = new SerializableActor
            {
                ActorNr          = this.ActorNr,
                UserId           = this.UserId,
                IsActive         = isActive,
                Nickname         = this.Nickname,
                DeactivationTime = this.DeactivationTime,
            };

            if (this.Properties.Count > 0)
            {
                var actorBinState = new Dictionary <byte, object>
                {
                    { BinrayPropertiesId, this.Properties.AsDictionary().ToDictionary(prop => prop.Key, prop => prop.Value.Value) }
                };
                item.Binary = Serializer.SerializeBase64(actorBinState);
                if (withDebugInfo)
                {
                    item.DEBUG_BINARY = actorBinState;
                }
            }
            return(item);
        }
Example #3
0
 public static Dictionary <string, object> ToDictionary(this SerializableActor actor)
 {
     return(new Dictionary <string, object>
     {
         { Actor.ActorNrKey, actor.ActorNr },
         { Actor.BinaryKey, actor.Binary },
         { Actor.NicknameKey, actor.Nickname },
         { Actor.UserIdKey, actor.UserId },
         { "DEBUG_BINARY", actor.DEBUG_BINARY },
     });
 }
Example #4
0
        public static Actor Deserialize(SerializableActor a)
        {
            IDictionary properties = null;

            if (!String.IsNullOrEmpty(a.Binary))
            {
                var dic = (IDictionary)Serializer.DeserializeBase64(a.Binary);
                properties = (IDictionary)dic[BinrayPropertiesId];
            }
            return(new Actor(a.ActorNr, a.UserId, properties, a.DeactivationTime));
        }
Example #5
0
        public static string ToStr(SerializableActor info)
        {
            StringBuilder builder = new StringBuilder();

            builder.AppendLine(string.Format("SerializableActor.ActorNr={0}", info.ActorNr));
            builder.AppendLine(string.Format("SerializableActor.IsActive={0}", info.IsActive));
            builder.AppendLine(string.Format("SerializableActor.Nickname={0}", info.Nickname));
            builder.AppendLine(string.Format("SerializableActor.UserId={0}", info.UserId));
            builder.AppendLine(string.Format("SerializableActor.Binary={0}", info.Binary));
            builder.AppendLine(string.Format("SerializableActor.DeactivationTime={0}", info.DeactivationTime));
            builder.AppendLine(info.DEBUG_BINARY.ToStr <byte, object>("SerializableActor.DEBUG_BINARY"));


            return(builder.ToString());
        }