public FSharpOption <T> ReadValue(IValueReader valueReader)
{
if (default(T) != null)
{
var obj = NullableInterface.Read(valueReader);
if (obj is null)
{
return(FSharpOption <T> .None);
}
return((T)obj);
}
else
{
var val = ValueInterface <T> .ReadValue(valueReader);
if (val == null)
{
return(FSharpOption <T> .None);
}
return(val);
}
}
public void ReaderTest()
{
var hGCache = new HGlobalCache <char>();
JsonFormatter.SerializeObject(new object[] { 123, "Dogwei", true, null, new { Id = 123 } }, hGCache);
var jsonReader = JsonFormatter.CreateJsonReader(hGCache);
AreEqual(jsonReader.GetToken(), JsonToken.Array);
AreEqual(jsonReader.TryReadBeginArray(), true);
AreEqual(jsonReader.TryReadEndArray(), false);
AreEqual(jsonReader.GetToken(), JsonToken.Number);
AreEqual(jsonReader.ReadInt32(), 123);
AreEqual(jsonReader.TryReadEndArray(), false);
AreEqual(jsonReader.GetToken(), JsonToken.String);
AreEqual(jsonReader.ReadString(), "Dogwei");
AreEqual(jsonReader.TryReadEndArray(), false);
AreEqual(jsonReader.GetToken(), JsonToken.Boolean);
AreEqual(jsonReader.ReadBoolean(), true);
AreEqual(jsonReader.TryReadEndArray(), false);
AreEqual(jsonReader.GetToken(), JsonToken.Null);
AreEqual(jsonReader.DirectRead(), null);
AreEqual(jsonReader.TryReadEndArray(), false);
AreEqual(jsonReader.GetToken(), JsonToken.Object);
AreEqual(JsonFormatter.SerializeObject(ValueInterface <Dictionary <string, object> > .ReadValue(jsonReader)), "{\"Id\":123}");
AreEqual(jsonReader.TryReadEndArray(), true);
AreEqual(jsonReader.GetToken(), JsonToken.End);
}
public void XObjectTest()
{
var rw = XObjectRW.Create <ObjectTester>();
AreEqual(rw.Content, null);
AreEqual(rw.Count, 2);
AreEqual(rw.ContentType, typeof(ObjectTester));
rw.Initialize();
AreNotEqual(rw.Content, null);
AreEqual(((ObjectTester)rw.Content).Id, 0);
AreEqual(((ObjectTester)rw.Content).Name, null);
rw["@id"].WriteInt32(123);
rw["@name"].WriteString("Dogwei");
AreEqual(((ObjectTester)rw.Content).Id, 123);
AreEqual(((ObjectTester)rw.Content).Name, "Dogwei");
AreEqual(rw["@id"].ReadInt32(), 123);
AreEqual(rw["@name"].ReadString(), "Dogwei");
IsTrue(
ValueInterface <Dictionary <string, object> > .ReadValue(ValueCopyer.ValueOf(rw)) is Dictionary <string, object> dic &&
dic.Count == 2 &&
(int)dic["@id"] == 123 &&
(string)dic["@name"] == "Dogwei"
);
}
public void ReadMap <TKey>(IDataWriter <TKey> mapWriter)
{
var length = TryReadMapHead();
if (length >= 0)
{
mapWriter.Initialize(length);
for (int i = 0; i < length; i++)
{
mapWriter.OnWriteValue(ValueInterface <TKey> .ReadValue(this), this);
}
return;
}
if (TryReadNull())
{
return;
}
if (IsArrayHead())
{
ReadArray(mapWriter.As <int>());
return;
}
throw new InvalidOperationException("The msgpack node is not a map.");
}
public byte[] ReadBinary()
{
var length = TryReadBinaryHead();
if (length >= 0)
{
var result = new byte[length];
ReadBinary(ref result[0], length);
return(result);
}
if (TryReadNull())
{
return(null);
}
if (IsArrayHead())
{
return(ValueInterface <byte[]> .ReadValue(this));
}
return((byte[])Convert.ChangeType(DirectRead(), typeof(byte[])));
}
internal static object ReadArray(IValueReader valueReader, Type type)
{
var items = ValueInterface.ReadValue(valueReader, GetArrayValueType(type));
Underlying.GetMethodTablePointer(items) = TypeHelper.GetMethodTablePointer(type);
return(items);
}
public T?ReadNullable <T>() where T : struct
{
if ((RandomInstance.Next() & 3) == 3)
{
return(null);
}
return(ValueInterface <T> .ReadValue(this));
}
public T?ReadNullable <T>() where T : struct
{
if (TryReadNull())
{
return(null);
}
return(ValueInterface <T> .ReadValue(this));
}
public TwoDimensionaArrayTest()
{
var random = new RandomDataReader()
{
MinArraySize = 10, MaxArraySize = 1000
};
data = ValueInterface <int[, ]> .ReadValue(random);
json = JsonConvert.SerializeObject(data);
}
T Deserialize <T, TMode>(byte *bytes, int length, MessagePackFormatterOptions options) where TMode : struct
{
var deserializer = new MessagePackDeserializer <TMode>(this, bytes, length, MaxDepth, options);
if (typeof(TMode) == typeof(MessagePackDeserializeModes.ReferenceMode))
{
deserializer.InitReferences();
}
return(ValueInterface <T> .ReadValue(deserializer));
}
public T ReadValue(IValueReader valueReader)
{
if (valueReader is IValueReader <T> reader)
{
return(reader.ReadValue());
}
if (typeof(T).IsAssignableFrom(typeof(DataTableReader)))
{
return(Unsafe.As <T>(ValueInterface <DataTable> .ReadValue(valueReader)?.CreateDataReader()));
}
throw new NotSupportedException();
}
public DictionaryTest()
{
var random = new RandomDataReader();
data = new Dictionary <string, CommonData>
{
{ ValueInterface <string> .ReadValue(random), new CommonModeText().GetData() },
{ ValueInterface <string> .ReadValue(random), new CommonModeText().GetData() },
{ ValueInterface <string> .ReadValue(random), new CommonModeText().GetData() },
{ ValueInterface <string> .ReadValue(random), new CommonModeText().GetData() },
{ ValueInterface <string> .ReadValue(random), new CommonModeText().GetData() },
};
json = JsonConvert.SerializeObject(data);
}
public void XSkipDefaultValueTest()
{
var rw = XObjectRW.Create <SkipDefaultValueTester>();
rw.Initialize();
rw.OnWriteAll(RWHelper.CreateReader(new Dictionary <string, object> {
{ "Id", 123 },
{ "Name", null }
}).As <string>());
IsTrue(
ValueInterface <Dictionary <string, object> > .ReadValue(ValueCopyer.ValueOf(rw)) is Dictionary <string, object> dic1 &&
dic1.Count == 1 &&
(int)dic1["Id"] == 123
);
rw.Initialize();
rw.OnWriteAll(RWHelper.CreateReader(new Dictionary <string, object> {
{ "Id", 0 },
{ "Name", "Dogwei" }
}).As <string>());
IsTrue(
ValueInterface <Dictionary <string, object> > .ReadValue(ValueCopyer.ValueOf(rw)) is Dictionary <string, object> dic2 &&
dic2.Count == 1 &&
(string)dic2["Name"] == "Dogwei"
);
rw.Initialize();
rw.OnWriteAll(RWHelper.CreateReader(new Dictionary <string, object> {
{ "Id", 0 },
{ "Name", null }
}).As <string>());
IsTrue(
ValueInterface <Dictionary <string, object> > .ReadValue(ValueCopyer.ValueOf(rw)) is Dictionary <string, object> dic3 &&
dic3.Count == 0
);
}
public static T DeserializeObject <T>(char *chars, int length, JsonFormatterOptions options)
{
switch (options & ModeOptions)
{
case JsonFormatterOptions.MultiReferencingReference:
return(ValueInterface <T> .ReadValue(new JsonDeserializer <JsonDeserializeModes.Reference>(chars, length)));
case JsonFormatterOptions.DeflateDeserialize:
return(ValueInterface <T> .ReadValue(new JsonDeserializer <JsonDeserializeModes.Deflate>(chars, length)));
case JsonFormatterOptions.StandardDeserialize:
return(ValueInterface <T> .ReadValue(new JsonDeserializer <JsonDeserializeModes.Standard>(chars, length)));
default:
return(ValueInterface <T> .ReadValue(new JsonDeserializer <DefaultDeserializeMode>(chars, length)));
}
}
public static unsafe T DeserializeObject <T>(byte *bytes, int length)
{
var hGlobal = CacheHelper.RentChars();
try
{
var deserializer = new MessagePackDeserializer(
bytes,
length,
hGlobal);
return(ValueInterface <T> .ReadValue(deserializer));
}
finally
{
CacheHelper.Return(hGlobal);
}
}
/// <summary>
/// 将 JSON 字符串反序列化为指定类型的值。
/// </summary>
/// <typeparam name="T">指定类型</typeparam>
/// <param name="chars">JSON 字符串</param>
/// <param name="length">JSON 字符串长度</param>
/// <returns>返回指定类型的值</returns>
public T Deserialize <T>(char *chars, int length)
{
var options = Options;
if ((options & JsonFormatterOptions.MultiReferencingReference) != 0)
{
var jsonDeserializer = new JsonReferenceDeserializer(chars, length);
if (id != 0)
{
jsonDeserializer.jsonFormatter = this;
}
var result = ValueInterface <T> .ReadValue(jsonDeserializer);
if (jsonDeserializer.references.Count != 0)
{
ReferenceInfo.ProcessReference(result, jsonDeserializer.references);
if (jsonDeserializer.updateBase)
{
result = RWHelper.GetContent <T>(jsonDeserializer.writer);
}
}
return(result);
}
else
{
var jsonDeserializer = new JsonDeserializer(chars, length);
if (id != 0)
{
jsonDeserializer.jsonFormatter = this;
}
return(ValueInterface <T> .ReadValue(jsonDeserializer));
}
}
public void FastObjectTest()
{
var rw = FastObjectRW <ObjectTester> .Create();
AreEqual(rw.content, null);
AreEqual(rw.Count, 2);
AreEqual(rw.ContentType, typeof(ObjectTester));
rw.Initialize();
AreNotEqual(rw.content, null);
AreEqual(rw.content.Id, 0);
AreEqual(rw.content.Name, null);
rw["@id"].WriteInt32(123);
rw["@name"].WriteString("Dogwei");
AreEqual(rw.content.Id, 123);
AreEqual(rw.content.Name, "Dogwei");
AreEqual(rw["@id"].ReadInt32(), 123);
AreEqual(rw["@name"].ReadString(), "Dogwei");
IsTrue(
ValueInterface <Dictionary <string, object> > .ReadValue(ValueCopyer.ValueOf(rw)) is Dictionary <string, object> dic &&
dic.Count == 2 &&
(int)dic["@id"] == 123 &&
(string)dic["@name"] == "Dogwei"
);
rw[rw.GetOrdinal("@id")].WriteInt32(456);
rw[rw.GetOrdinal("@name")].WriteString("Eway");
AreEqual(rw[rw.GetOrdinal("@id")].ReadInt32(), 456);
AreEqual(rw[rw.GetOrdinal("@name")].ReadString(), "Eway");
}
public static T DeserializeObject <T>(char *chars, int length, JsonFormatterOptions options)
{
if ((options & JsonFormatterOptions.MultiReferencingReference) != 0)
{
var jsonDeserializer = new JsonReferenceDeserializer(chars, length);
var result = ValueInterface <T> .ReadValue(jsonDeserializer);
if (jsonDeserializer.references.Count != 0)
{
ReferenceInfo.ProcessReference(result, jsonDeserializer.references);
if (jsonDeserializer.updateBase)
{
result = RWHelper.GetContent <T>(jsonDeserializer.writer);
}
}
return(result);
}
return(DeserializeObject <T>(chars, length));
}
void IXFieldRW.OnWriteValue(object obj, IValueReader valueReader)
{
GetReference(obj) = ValueInterface <TValue> .ReadValue(valueReader);
}
public override int[,,] GetObject()
{
return(ValueInterface <int[, , ]> .ReadValue(new RandomValueReader(1218)));
}
public SingleArrayTest()
{
data = ValueInterface <float[]> .ReadValue(new RandomDataReader { MinArraySize = 100, MaxArraySize = 1000 });
json = JsonConvert.SerializeObject(data);
}
internal static object ReadPrimitive(IValueReader valueReader, Type type)
{
return(ValueInterface.ReadValue(valueReader, type));
}
public ValueTuple <T1> ReadValue(IValueReader valueReader)
{
return(new ValueTuple <T1>(ValueInterface <T1> .ReadValue(valueReader)));
}
public void OnWriteValue(object obj, IValueReader valueReader)
{
Assert(CanWrite, "set");
_set(obj, ValueInterface <TValue> .ReadValue(valueReader));
}
private T InternalDeserialize <T, TMode>(char *chars, int length) where TMode : struct
{
return(ValueInterface <T> .ReadValue(new JsonDeserializer <TMode>(this, chars, length)));
}
public static T DeserializeObject <T>(char *chars, int length)
{
return(ValueInterface <T> .ReadValue(new JsonDeserializer(chars, length)));
}
static T DeserializeObject <T>(byte *bytes, int length)
{
return(ValueInterface <T> .ReadValue(new MessagePackDeserializer <MessagePackDeserializeModes.StandardMode>(bytes, length, DefaultMaxDepth)));
}
public void OnWriteValue(object obj, IValueReader valueReader)
{
Unsafe.WriteUnaligned(ref GetAddress(obj), ValueInterface <TValue> .ReadValue(valueReader));
}
public BaseRandomTest(RandomDataReader random)
{
data = ValueInterface <T> .ReadValue(random);
json = ToJson(data);
}
public object DirectRead()
{
var curr = Read();
int length;
if (curr >= FixInt && curr <= FixIntMax)
{
return(curr /* - FixInt*/);
}
if (curr >= FixNegativeInt && curr <= FixNegativeIntMax)
{
return((sbyte)curr);
}
if (curr >= FixMap && curr <= FixMapMax)
{
length = curr - FixMap;
goto Map;
}
if (curr >= FixArray && curr <= FixArrayMax)
{
length = curr - FixArray;
goto Array;
}
if (curr >= FixStr && curr <= FixStrMax)
{
length = curr - FixStr;
goto String;
}
switch (curr)
{
case Nil:
return(null);
case False:
return(false);
case True:
return(true);
case Bin8:
length = Read();
goto Binary;
case Bin16:
length = Read2();
goto Binary;
case Bin32:
length = checked ((int)Read4());
goto Binary;
case Ext8:
length = Read();
goto Extension;
case Ext16:
length = Read2();
goto Extension;
case Ext32:
length = checked ((int)Read4());
goto Extension;
case FixExt1:
length = 1;
goto Extension;
case FixExt2:
length = 2;
goto Extension;
case FixExt4:
length = 4;
goto Extension;
case FixExt8:
length = 8;
goto Extension;
case FixExt16:
length = 16;
goto Extension;
case Float32:
return(Unsafe.As <uint, float>(ref Unsafe.AsRef(Read4())));
case Float64:
return(Unsafe.As <ulong, double>(ref Unsafe.AsRef(Read8())));
case UInt8:
return(Read());
case MessagePackCode.UInt16:
return(Read2());
case MessagePackCode.UInt32:
return(Read4());
case MessagePackCode.UInt64:
return(Read8());
case Int8:
return((sbyte)Read());
case MessagePackCode.Int16:
return((short)Read2());
case MessagePackCode.Int32:
return((int)Read4());
case MessagePackCode.Int64:
return((long)Read8());
case Str8:
length = Read();
goto String;
case Str16:
length = Read2();
goto String;
case Str32:
length = checked ((int)Read4());
goto String;
case Array16:
case Array32:
goto Array;
case Map16:
case Map32:
goto Map;
default:
throw new InvalidOperationException("NeverUsed bit.");
}
Map:
BackOff();
return(ValueInterface <MessagePackMap> .ReadValue(this));
Array:
BackOff();
return(ValueInterface <MessagePackArray> .ReadValue(this));
String:
return(ReadStringMode2(length));
Binary:
var binary = new byte[length];
ReadBinary(ref binary[0], length);
return(binary);
Extension:
var code = Read();
switch (code)
{
case MessagePackExtensionCode.Timestamp:
return(ReadExtDateTime(length));
}
return(new MessagePackExtension(length, code, this));
}
