public void Serialize_WithNullInput_ThrowsArgumentNullException()
{
Assert.Throws <ArgumentNullException>(() =>
{
string result = TypeSerializer.Serialize(null);
});
}
public void BuiltInType_can_be_serialized_and_deserialized()
{
var builtIns = new []
{
new BuiltInType(BuiltInTypeKind.Any),
new BuiltInType(BuiltInTypeKind.Null),
new BuiltInType(BuiltInTypeKind.Bool),
new BuiltInType(BuiltInTypeKind.Int),
new BuiltInType(BuiltInTypeKind.String),
new BuiltInType(BuiltInTypeKind.Object),
new BuiltInType(BuiltInTypeKind.Array),
new BuiltInType(BuiltInTypeKind.ResourceRef),
};
var serialized = TypeSerializer.Serialize(builtIns);
var deserializedBuiltIns = TypeSerializer.Deserialize(serialized);
for (var i = 0; i < builtIns.Length; i++)
{
deserializedBuiltIns[i].Should().BeOfType <BuiltInType>();
var deserializedBuiltIn = (BuiltInType)deserializedBuiltIns[i];
deserializedBuiltIn.Kind.Should().Be(builtIns[i].Kind);
}
}
public void OnBeforeSerialize()
{
if (parameterTypes != null)
{
_parameterTypes = parameterTypes.Select(type => TypeSerializer.Serialize(type)).ToArray();
}
}
public void TypeSerialize <valueType>(valueType value)
{
if (value != null)
{
TypeSerializer <valueType> .Serialize(this, value);
}
}
/// <summary>
/// 对象转换XML字符串
/// </summary>
/// <typeparam name="valueType">目标数据类型</typeparam>
/// <param name="value">数据对象</param>
private void serialize <valueType>(valueType value)
{
Warning = SerializeWarning.None;
if (checkLoopDepth != Config.CheckLoopDepth)
{
if (Config.CheckLoopDepth <= 0)
{
checkLoopDepth = 0;
if (forefather == null)
{
forefather = new object[sizeof(int)];
}
}
else
{
checkLoopDepth = Config.CheckLoopDepth;
}
}
CharStream.Write(Config.Header);
fixed(char *nameFixed = Config.BootNodeName)
{
nameStart(nameFixed, Config.BootNodeName.Length);
TypeSerializer <valueType> .Serialize(this, value);
nameEnd(nameFixed, Config.BootNodeName.Length);
}
}
protected void Serialize(WriteTarget target)
{
Type type = target.item.GetType();
context = target.item;
int id;
if (type.IsClass)
{
id = GetRefId(target.item);
outputTargets[id] = target;
}
else
{
id = -1;
}
//string creationType = SerializerUtil.GetCreationType(type, context);
TypeSerializer serializer = SerializerUtil.GetTypeSerializer(type);
builder.Length = 0;
writeCalls = 0;
serializer.Serialize(target.item, this);
target.id = id;
target.fieldCount = writeCalls;
target.fields = builder.ToString();
target.version = serializer.GetVersion();
}
public void Test_Char()
{
var serializer = new TypeSerializer(new ManualByteConverter());
var value = 'o';
var expected = new byte[] { 0x6f };
var actual = serializer.Serialize(value);
Assert.AreEqual(expected, actual);
}
public void Test_Null()
{
var serializer = new TypeSerializer(new ManualByteConverter());
var expected = new byte[0];
var actual = serializer.Serialize <string>(null);
Assert.AreEqual(expected, actual);
}
public void Test_Deserialize_Int()
{
var serializer = new TypeSerializer(new ManualByteConverter());
var five = 5;
var bytes = serializer.Serialize(five);
var actual = serializer.Deserialize <int>(bytes, 0, bytes.Length);
Assert.AreEqual(five, actual);
}
public void Test_Serialize_UInt64()
{
var serializer = new TypeSerializer(new ManualByteConverter());
UInt64 data = 9;
var expected = new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09 };
var actual = serializer.Serialize(data);
Assert.AreEqual(expected, actual);
}
public void Test_Deserialize_String()
{
var serializer = new TypeSerializer(new ManualByteConverter());
var value = "astring";
var bytes = serializer.Serialize(value);
var bytes1 = Encoding.UTF8.GetBytes(value);
var actual = serializer.Deserialize <string>(bytes, 0, bytes.Length);
Assert.AreEqual(value, actual);
}
public void Test_Serialize_UInt64()
{
var serializer = new TypeSerializer(new ManualByteConverter());
UInt64 data = 9;
var expected = new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09 };
var actual = serializer.Serialize(data);
Assert.AreEqual(expected, actual);
}
public void Test_Serialize_String()
{
var serializer = new TypeSerializer(new ManualByteConverter());
string data = "Hello";
var expected = new byte[] { 0x48, 0x65, 0x6c, 0x6c, 0x6f };
var actual = serializer.Serialize(data);
Assert.AreEqual(expected, actual);
}
public void TypeSerialize <valueType>(valueType value)
{
if (value == null)
{
CharStream.WriteJsonNull();
}
else
{
TypeSerializer <valueType> .Serialize(this, ref value);
}
}
public void Test_Poco()
{
var serializer = new TypeSerializer(new ManualByteConverter());
var value = new Person {
Name = "jeff"
};
var bytes = serializer.Serialize(value);
var actual = serializer.Deserialize <Person>(new ArraySegment <byte>(bytes), 0, bytes.Length);
Assert.AreEqual(value.Name, actual.Name);
}
protected YuzuException Error(string message, params object[] args)
{
for (int i = 0; i < args.Length; ++i)
{
if (args[i] is Type)
{
args[i] = TypeSerializer.Serialize((Type)args[i]);
}
}
return(new YuzuException(
String.Format(message, args),
Options.ReportErrorPosition ? new YuzuPosition(Reader.BaseStream.Position) : null));
}
/// <summary>
/// 準備したデータをシリアライズします。
/// </summary>
private void Serialize()
{
if (Data == null)
{
throw new PbException("Dataがnullです。");
}
SerializedData = PbUtil.Serialize(Data, Data.GetType());
// 型名はPbConnectionでエンコードします。
TypeName = TypeSerializer.Serialize(Data.GetType());
EncodedTypeName = PbConnection.EncodeTypeName(TypeName);
EncodedTypeData = Encoding.UTF8.GetBytes(EncodedTypeName);
}
protected object FromReaderIntGenerated(object obj)
{
KillBuf();
Require('{');
var expectedType = obj.GetType();
string name = GetNextName(first: true);
if (name == JsonOptions.ClassTag)
{
CheckExpectedType(RequireUnescapedString(), expectedType);
name = GetNextName(first: false);
}
return(name == null ? obj :
MakeDeserializer(TypeSerializer.Serialize(obj.GetType())).ReadFields(obj, name));
}
private ClassDef WriteClassId(object obj)
{
var t = obj.GetType();
ClassDef result;
if (classIdCache.TryGetValue(t, out result))
{
writer.Write(result.Id);
var g = result.Meta.GetUnknownStorage;
if (g == null)
{
return(result);
}
var i = g(obj).Internal;
// If we have unknown fields, their definition must be present in the first serialized object,
// but not necessariliy in subsequent ones.
if (i != null && i != result.ReaderDef)
{
throw new YuzuException("Conflictiing reader class definitions for unknown storage of " + t.Name);
}
return(result);
}
result = new ClassDef {
Id = (short)(classIdCache.Count + unknownClassIdCache.Count + 1)
};
result.Meta = Meta.Get(t, Options);
classIdCache[t] = result;
if (result.Meta.GetUnknownStorage == null)
{
PrepareClassDefFields(result);
}
else
{
result.ReaderDef = result.Meta.GetUnknownStorage(obj).Internal as ReaderClassDef;
if (result.ReaderDef == null)
{
PrepareClassDefFields(result);
}
else
{
PrepareClassDefFieldsUnknown(result);
}
}
WriteClassDefFields(result, result.Meta.WriteAlias ?? TypeSerializer.Serialize(result.Meta.Type));
return(result);
}
private Surrogate GetSurrogate <T>(Type actualType)
{
var sg = Meta.Get(typeof(T), Options).Surrogate;
if (sg.FuncFrom == null)
{
throw Error(
"Expected type '{0}', but got '{1}'",
typeof(T), actualType == null ? "number" : TypeSerializer.Serialize(actualType));
}
if (actualType != null && !sg.SurrogateType.IsAssignableFrom(actualType))
{
throw Error(
"Expected type '{0}' or '{1}', but got '{2}'",
typeof(T), sg.SurrogateType.Name, actualType);
}
return(sg);
}
/// <summary>
/// Assign the parameter types to their underlying properties
/// </summary>
public static void SerializeParameterTypes(SerializedProperty parameterTypesProperty, Type[] parameterTypes)
{
if (parameterTypes == null)
{
parameterTypesProperty.arraySize = 0;
}
else
{
parameterTypesProperty.arraySize = parameterTypes.Length;
for (int i = 0; i < parameterTypesProperty.arraySize; i++)
{
SerializedProperty parameterTypeProperty = parameterTypesProperty.GetArrayElementAtIndex(i);
parameterTypeProperty.stringValue = TypeSerializer.Serialize(parameterTypes[i]);
}
}
}
public void Serialize_WithAllProperties_ReturnsCorrectlySequencedFields()
{
Address hl7Type = new()
{
StreetAddress = "1",
OtherDesignation = "2",
City = "3",
StateOrProvince = "4",
ZipOrPostalCode = "5",
Country = "6",
AddressType = "7",
OtherGeographicDesignation = "8"
};
string expected = "1^2^3^4^5^6^7^8";
string actual = TypeSerializer.Serialize(hl7Type);
Assert.Equal(expected, actual);
}
public override void Serialize(StreamElement value, IDataOutputView target)
{
if (value.IsRecord)
{
var record = value.AsRecord <T>();
if (record.HasTimestamp)
{
target.Write(TagRecWithTimestamp);
target.WriteLong(record.Timestamp);
}
else
{
target.Write(TagRecWithoutTimestamp);
}
ContainedTypeSerializer.Serialize(record.Value, target);
}
else if (value.IsWatermark)
{
target.Write(TagWatermark);
target.WriteLong(value.AsWatermark().Timestamp);
}
else if (value.IsStreamStatus)
{
target.Write(TagStreamStatus);
target.WriteInt(value.AsStreamStatus().Status);
}
else if (value.IsLatencyMarker)
{
target.Write(TagLatencyMarker);
target.WriteLong(value.AsLatencyMarker().MarkedTime);
target.WriteLong(value.AsLatencyMarker().OperatorId.LowerPart);
target.WriteLong(value.AsLatencyMarker().OperatorId.UpperPart);
target.WriteInt(value.AsLatencyMarker().SubTaskIndex);
}
else
{
throw new RuntimeException();
}
}
public override async Task Generate(CodeModel serviceClient)
{
var apiVersions = serviceClient.Methods
.SelectMany(method => method.XMsMetadata.apiVersions)
.Concat(new [] { serviceClient.ApiVersion })
.Where(each => each != null)
.Distinct().ToArray();
foreach (var version in apiVersions)
{
var results = CodeModelProcessor.GenerateTypes(serviceClient, version);
foreach (var result in results)
{
var generatedTypes = result.TypeFactory.GetTypes();
var typesJson = TypeSerializer.Serialize(generatedTypes);
await Write(typesJson, Path.Combine(result.ProviderNamespace, result.ApiVersion, "types.json"), true);
}
}
}
/// <inheritdoc />
protected override void SetValue(UnityMethod value)
{
base.SetValue(value);
// Assign the parameter types to their underlying properties
if (value == null || value.parameterTypes == null)
{
parameterTypesProperty.arraySize = 0;
}
else
{
parameterTypesProperty.arraySize = value.parameterTypes.Length;
for (int i = 0; i < parameterTypesProperty.arraySize; i++)
{
SerializedProperty parameterTypeProperty = parameterTypesProperty.GetArrayElementAtIndex(i);
parameterTypeProperty.stringValue = TypeSerializer.Serialize(value.parameterTypes[i]);
}
}
}
/// <summary>
/// Recursive method, serializing every object in my objects graph
/// </summary>
internal void Serialize(object obj, Type objType)
{
// If it's Object, we get the underlying type
if (objType == typeof(Object) && obj != null)
{
var baseType = obj.GetType().GetBaseType();
// var s = TypeSerializer.GetSerializer(baseType);
Serialize(obj, baseType);
return;
}
TypeSerializer serializer = null;
if (!typeSerializers.ContainsKey(objType))
{
serializer = TypeSerializer.GetSerializer(objType);
typeSerializers.Add(objType, serializer);
}
serializer = typeSerializers[objType];
// Write object type
this.Writer.Write(objType.GetAssemblyQualifiedName());
// Check if it's not a reference
int refIndex = 0;
DmState state = this.GetState(obj, objType, ref refIndex);
// Write state
this.Writer.Write((byte)state);
// Write index;
this.Writer.Write(refIndex);
// if not null or ref
if (state == DmState.IsAloneOrValue)
{
serializer.Serialize(this, obj, objType);
}
}
public FromElementsFunction(TypeSerializer <T> serializer, IEnumerable <T> elements)
{
var stream = new MemoryStream();
var output = new DataOutputViewStreamWrapper(stream);
var count = 0;
try
{
foreach (var element in elements)
{
_serializer.Serialize(element, output);
count++;
}
}
catch (Exception e)
{
throw new IOException("Serializing the source elements failed.", e);
}
_numElements = count;
_serializer = serializer;
_elementsSerialized = stream.ToArray();
}
public void Test_Null()
{
var serializer = new TypeSerializer(new ManualByteConverter());
var expected = new byte[0];
var actual = serializer.Serialize<string>(null);
Assert.AreEqual(expected, actual);
}
internal static void SerializeObject <valueType>(JsonSerializer jsonSerializer, object value)
{
TypeSerializer <valueType> .Serialize(jsonSerializer, (valueType)value);
}
/// <summary>
/// 对象转换JSON字符串
/// </summary>
/// <typeparam name="valueType">目标数据类型</typeparam>
/// <param name="value">数据对象</param>
private void serialize <valueType>(ref valueType value)
{
#if AutoCSer
if (Config.GetLoopObject == null || Config.SetLoopObject == null)
{
if (Config.GetLoopObject != null)
{
Warning = SerializeWarning.LessSetLoop;
}
else if (Config.SetLoopObject != null)
{
Warning = SerializeWarning.LessGetLoop;
}
else
{
Warning = SerializeWarning.None;
}
if (checkLoopDepth != Config.CheckLoopDepth || isLoopObject)
{
if (Config.CheckLoopDepth <= 0)
{
checkLoopDepth = 0;
if (forefather == null)
{
forefather = new object[sizeof(int)];
}
}
else
{
checkLoopDepth = Config.CheckLoopDepth;
}
}
isLoopObject = false;
}
else
{
if (!isLoopObject)
{
isLoopObject = true;
if (objectIndexs == null)
{
objectIndexs = ReusableDictionary <ObjectReference> .Create <int>();
}
}
Warning = SerializeWarning.None;
checkLoopDepth = Config.CheckLoopDepth <= 0 ? SerializeConfig.DefaultCheckLoopDepth : Config.CheckLoopDepth;
}
#else
Warning = SerializeWarning.None;
if (checkLoopDepth != Config.CheckLoopDepth)
{
if (Config.CheckLoopDepth <= 0)
{
checkLoopDepth = 0;
if (forefather == null)
{
forefather = new object[sizeof(int)];
}
}
else
{
checkLoopDepth = Config.CheckLoopDepth;
}
}
#endif
TypeSerializer <valueType> .Serialize(this, ref value);
}
private void TestTypeSerializerHelper(Type t, string s)
{
Assert.AreEqual(s, TypeSerializer.Serialize(t));
Assert.AreEqual(t, TypeSerializer.Deserialize(s));
}
public void Test_Char()
{
var serializer = new TypeSerializer(new ManualByteConverter());
var value = 'o';
var expected = new byte[] { 0x6f };
var actual = serializer.Serialize(value);
Assert.AreEqual(expected, actual);
}
public void Test_Poco()
{
var serializer = new TypeSerializer(new ManualByteConverter());
var value = new Person {Name = "jeff"};
var bytes = serializer.Serialize(value);
var actual = serializer.Deserialize<Person>(new ArraySegment<byte>(bytes), 0, bytes.Length);
Assert.AreEqual(value.Name, actual.Name);
}
/// <summary>
/// シリアライズandデシリアライズで同じ型に戻るか調べます。
/// </summary>
private void TypeTest(Type type)
{
var selialized = TypeSerializer.Serialize(type);
Assert.AreEqual(type, TypeSerializer.Deserialize(selialized));
}
public void Test_Serialize_String()
{
var serializer = new TypeSerializer(new ManualByteConverter());
string data = "Hello";
var expected = new byte[] { 0x48, 0x65, 0x6c, 0x6c, 0x6f };
var actual = serializer.Serialize(data);
Assert.AreEqual(expected, actual);
}
public void Test_Deserialize_Int()
{
var serializer = new TypeSerializer(new ManualByteConverter());
var five = 5;
var bytes = serializer.Serialize(five);
var actual = serializer.Deserialize<int>(bytes, 0, bytes.Length);
Assert.AreEqual(five, actual);
}
public void Test_Deserialize_String()
{
var serializer = new TypeSerializer(new ManualByteConverter());
var value = "astring";
var bytes = serializer.Serialize(value);
var bytes1 = Encoding.UTF8.GetBytes(value);
var actual = serializer.Deserialize<string>(bytes, 0, bytes.Length);
Assert.AreEqual(value, actual);
}