private SimpleObjectSerializer(object Value, SimpleObjectFieldSerializationMode FieldMode, DefinitionList Types) : base(Value, Types) { this.FieldMode = FieldMode; if (IsEmpty) { return; } if (IsArray) { Children = GetArrayValues().ToArray(); } else if (TypeCode == TypeCode.Object) { this.CustomSerializer = Object as ICustomSerializer; if (CustomSerializer != null && CustomSerializer.Initialize(this)) { return; } Children = GetFields().ToArray(); } else if (TypeCode == TypeCode.String) { StringIndex = defs.Strings.Add((string)Value); } }
internal NamedPipeConnection(int id, string name, PipeStream serverStream, ICustomSerializer <TRead> serializerRead, ICustomSerializer <TWrite> serializerWrite) { Id = id; Name = name; Handle = serverStream.SafePipeHandle; _streamWrapper = new PipeStreamWrapper <TRead, TWrite>(serverStream, serializerRead, serializerWrite); }
public override void ReadData(SerializedObject objSerializedObject) { base.ReadData(objSerializedObject); Initialize(); SerializedObject objSerializedItems = objSerializedObject.Objects["Items"]; if (objSerializedItems != null) { foreach (SerializedValue objItem in objSerializedItems.Values.ToArray()) { TObjectType objValue = (TObjectType)objItem.Value; Add(objValue); } foreach (SerializedObject objItem in objSerializedItems.Objects.ToArray()) { TObjectType objValue = default(TObjectType); ICustomSerializer objCustomSerializer = objItem.Deserialize(); if (objCustomSerializer is SerializedWrapperObject) { SerializedWrapperObject objSerializedWrapperObject = (SerializedWrapperObject)objCustomSerializer; objValue = (TObjectType)objSerializedWrapperObject.Data; } else { objValue = (TObjectType)((object)objCustomSerializer); } Add(objValue); } } }
public ReturnType Deserialize <ReturnType>(string pathToFile) where ReturnType : class { string extension = pathToFile.Split('.')[1]; ICustomSerializer deserializer = GetDeserializer(extension); object result = deserializer.Deserialize(pathToFile); return(result as ReturnType); }
public static void RegisterCustomSerializer(int num, Type type, ICustomSerializer serializer) { if (!types.ContainsKey(type)) { types.Add(type, num); customSerializers.Add(num, serializer); } }
/// <summary> /// The set custom serializer. /// </summary> /// <param name="type"> /// The type. /// </param> /// <param name="serializer"> /// The serializer. /// </param> public void SetCustomSerializer <T>(ICustomSerializer <T> serializer) { var type = typeof(T); this.customSerializers.Remove(type); this.customSerializers.Add(type, serializer); }
public EventService(ILogger logger, IEventStoreConnection eventStoreConnection, ICustomDataConverter customDataConverter, string streamName, ICustomSerializer customSerializer) { _eventStoreConnection = eventStoreConnection; _customDataConverter = customDataConverter; _streamName = streamName; _customSerializer = customSerializer; _logger = logger; }
public void SetValue(string strName, ICustomSerializer objObject) { if (strName == null) { throw new ArgumentNullException("strName", "A valid non-null string is required."); } Settings.Remove(strName); if (objObject != null) { Settings.Add(strName, objObject); } }
ICustomSerializer GetDeserializer(string extension) { ICustomSerializer serializer = null; switch (extension) { case "cl": serializer = new CollisionComponentSerializer(); break; default: serializer = new EngineObjectsSerializer(); break; } return(serializer); }
public SerializedObject Add(string strName, ICustomSerializer objCustomSerializer) { if (strName == null) { throw new ArgumentNullException("strName", "A valid non-null string is required.."); } SerializedObject objSerializedObject = null; if (objCustomSerializer != null) { objSerializedObject = objCustomSerializer.Serialize(strName); Add(objSerializedObject); } return(objSerializedObject); }
public static SerializedObject Serialize(string strName, ICustomSerializer objCustomSerializer) { if ((strName == null) || (strName.Length == 0)) { throw new ArgumentOutOfRangeException("strName", "A valid non-null, non-empty string is required.."); } if (objCustomSerializer == null) { throw new ArgumentException("objCustomSerializer", "A valid non-null ICustomSerializer is required.."); } SerializedTypeInfo objTypeInfo = new SerializedTypeInfo(objCustomSerializer); SerializedObject objSerializedObject = new SerializedObject(strName, objTypeInfo); objCustomSerializer.WriteData(objSerializedObject); return(objSerializedObject); }
public ICustomSerializer Deserialize() { string strAssemblyName = TypeInfo.AssemblyName; string strTypeName = TypeInfo.TypeName; Assembly objAssembly = null; try { objAssembly = Assembly.Load(strAssemblyName); } catch (Exception objException) { string strErrorMessage = "An error was encountered while loading the assembly - Assembly.Load('" + strAssemblyName + "'):\n"; throw new Exception(strErrorMessage, objException); } Type objType = null; try { objType = objAssembly.GetType(strTypeName, true, true); } catch (Exception objException) { string strErrorMessage = "An error was encountered while loading the type - objAssemblyName.GetType('" + strTypeName + "', True, True):\n"; throw new Exception(strErrorMessage, objException); } ICustomSerializer objCustomSerializer = null; try { ConstructorInfo objConstructorInfo = objType.GetConstructor(BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Public, null, new Type[] { typeof(SerializedObject) }, null); objCustomSerializer = (ICustomSerializer)objConstructorInfo.Invoke(new object[] { this }); } catch (Exception objException) { string strErrorMessage = "An error was encountered while creating the object - Activator.CreateInstance('" + objType.FullName + "'):\n"; throw new Exception(strErrorMessage, objException); } return(objCustomSerializer); }
public TObjectType GetObject <TObjectType>(string strName, TObjectType objDefaultValue) { TObjectType objReturnValue = objDefaultValue; SerializedObject objSerializedObject = this[strName]; if (objSerializedObject != null) { ICustomSerializer objCustomSerializer = objSerializedObject.Deserialize(); if (objCustomSerializer is SerializedWrapperBase <TObjectType> ) { SerializedWrapperBase <TObjectType> objSerializedWrapper = (SerializedWrapperBase <TObjectType>)objCustomSerializer; objReturnValue = (TObjectType)objSerializedWrapper.Data; } else { objReturnValue = (TObjectType)((object)objCustomSerializer); } } return(objReturnValue); }
public LogWrapper(ILogger logger, ICustomSerializer serializer) { _logger = logger; _serializer = serializer; }
/// <inheritdoc /> /// <summary> /// Constructs a new <c>PipeStreamWrapper</c> object that reads from and writes to the given <paramref name="stream" />. /// </summary> /// <param name="stream">Stream to read from and write to</param> /// <param name="serializer">Serializer to use. Can be null to use the default serializer</param> public PipeStreamWrapper(PipeStream stream, ICustomSerializer <TReadWrite> serializer) : base(stream, serializer, serializer) { }
/// <summary> /// Constructs a new <c>NamedPipeClient</c> to connect to the <see cref="NamedPipeServer{TReadWrite}"/> specified by <paramref name="pipeName"/>. /// </summary> /// <param name="pipeName">Name of the server's pipe</param> /// <param name="serverName">Server name. By default, "." (local).</param> /// <param name="serializer">Serializer to use. Can be null to use the default serializer</param> public NamedPipeClient(string pipeName, string serverName, ICustomSerializer <TReadWrite> serializer = null) : base(pipeName, serverName, serializer, serializer) { }
/// <summary> /// Objects that are castable to give type are serialized with given serializer /// </summary> public void AddCustomSerializer(ICustomSerializer serializer) { serializers.Add(serializer); }
public static void RegisterCustomSerializer(int num, Type type, ICustomSerializer serializer) { types.Add(type, num); customSerializers.Add(num, serializer); }
public static PipeStreamWrapper <TRead, TWrite> Connect <TRead, TWrite>(string pipeName, string serverName, ICustomSerializer <TRead> serializerRead, ICustomSerializer <TWrite> serializerWrite, CancellationToken cancelToken) where TRead : class where TWrite : class { var inner = CreateAndConnectPipe(pipeName, serverName, cancelToken); return(inner == null ? null : new PipeStreamWrapper <TRead, TWrite>(inner, serializerRead, serializerWrite)); }
public SerializationTester(ICustomSerializer <TData> serializer, bool showResult = false) { _serializer = serializer; _showResult = showResult; }
public virtual void AddToMessageStream(Stream stream, Type type, object val) { if (null == val) { UnityEngine.Debug.Log("NULL VALUE of Type = " + type.ToString()); return; } if (type == typeof(bool)) { stream.WriteByte((byte)((bool)val ? 1 : 0)); return; } if (type == typeof(byte)) { stream.WriteByte((byte)val); return; } if (type == typeof(Int16)) { var buf = BitConverter.GetBytes((Int16)val); stream.Write(buf, 0, buf.Length); return; } if (type == typeof(UInt16)) { var buf = BitConverter.GetBytes((UInt16)val); stream.Write(buf, 0, buf.Length); return; } if (type == typeof(Int32)) { var buf = BitConverter.GetBytes((Int32)val); stream.Write(buf, 0, buf.Length); return; } if (type == typeof(UInt32)) { var buf = BitConverter.GetBytes((UInt32)val); stream.Write(buf, 0, buf.Length); return; } if (type == typeof(Int64)) { var buf = BitConverter.GetBytes((Int64)val); stream.Write(buf, 0, buf.Length); return; } if (type == typeof(UInt64)) { var buf = BitConverter.GetBytes((UInt64)val); stream.Write(buf, 0, buf.Length); return; } if (type == typeof(float)) { var buf = BitConverter.GetBytes((float)val); stream.Write(buf, 0, buf.Length); return; } if (type == typeof(double)) { var buf = BitConverter.GetBytes((double)val); stream.Write(buf, 0, buf.Length); return; } if (type == typeof(DateTime)) { var buf = BitConverter.GetBytes((Int32)(((DateTime)val).Ticks / 10000000 - 62135596800)); // 01.01.1970 stream.Write(buf, 0, buf.Length); return; } if (type == typeof(Byte[])) { var buf = (byte[])val; stream.Write(buf, 0, buf.Length); return; } if (type == typeof(String) || val.GetType() == typeof(string)) { var typed = (string)val; if (string.IsNullOrEmpty(typed)) { stream.WriteByte(0); return; } var buf = Encoding.UTF8.GetBytes(typed); var buflen = VarInt(buf.Length); stream.Write(buflen, 0, buflen.Length); stream.Write(buf, 0, buf.Length); return; } ICustomSerializer customSerializer = val as ICustomSerializer; if (null != customSerializer) { customSerializer.Serializer(stream, this); return; } if (type.IsEnum) { stream.WriteByte((byte)val); return; } if (type.IsArray) { var typed = (ICollection)val; if (typed == null) { return; } var buf = VarInt(typed.Count); stream.Write(buf, 0, buf.Length); foreach (var value in typed) { AddToMessageStream(stream, value.GetType(), value); } return; } if (type.IsClass) { var chType = val.GetType(); var properties = GetPropertiesForMessage(chType); foreach (var prop in properties) { AddToMessageStream(stream, prop, val); } return; } throw new NotImplementedException(); }
public SaverLoader(ICustomSerializer serializer) { internalSerializer = serializer; }
public static NamedPipeConnection <TRead, TWrite> CreateConnection <TRead, TWrite>(PipeStream pipeStream, ICustomSerializer <TRead> serializerRead, ICustomSerializer <TWrite> serializerWrite) where TRead : class where TWrite : class => new NamedPipeConnection <TRead, TWrite>(++_lastId, "Client " + _lastId, pipeStream, serializerRead, serializerWrite);
public static void RegisterCustomSerializer <T>(int num, ICustomSerializer serializer) { RegisterCustomSerializer(num, typeof(T), serializer); }
internal void AddCustomSerializer(ICustomSerializer customSerializer) { m_CustomSerializers.Add(customSerializer.GetType(), customSerializer); }
/// <summary> /// Constructs a new <c>NamedPipeServer</c> object that listens for client connections on the given <paramref name="pipeName"/>. /// </summary> /// <param name="pipeName">Name of the pipe to listen on</param> /// <param name="bufferSize">Size of input and output buffer</param> /// <param name="security">And object that determine the access control and audit security for the pipe</param> /// <param name="serializer">Serializer to use. Can be null to use the default serializer</param> public NamedPipeServer(string pipeName, int bufferSize, PipeSecurity security, ICustomSerializer <TReadWrite> serializer = null) : base(pipeName, bufferSize, security, serializer, serializer) { }
/// <inheritdoc /> protected CustomSerializor(ICustomSerializer serializer) { _serializer = serializer; }
/// <summary> /// Constructs a new <c>PipeStreamWriter</c> object that writes to given <paramref name="stream"/>. /// </summary> /// <param name="stream">Pipe to write to</param> /// <param name="serializer">Serializer to use. Can be null to use the default serializer</param> public PipeStreamWriter(PipeStream stream, ICustomSerializer <T> serializer) { BaseStream = stream; _serializer = serializer ?? new BinaryFormatterSerializer <T>(); }
public void SetCustomSerializer <T>(ICustomSerializer <T> serializer) { throw new NotImplementedException(); }
/// <summary> /// Constructs a new <c>PipeStreamReader</c> object that reads data from the given <paramref name="stream"/>. /// </summary> /// <param name="stream">Pipe to read from</param> /// <param name="serializer">Serializer to use. Can be null to use the default serializer</param> public PipeStreamReader(PipeStream stream, ICustomSerializer<T> serializer) { BaseStream = stream; IsConnected = stream.IsConnected; _serializer = serializer ?? new BinaryFormatterSerializer<T>(); }