public SiteSettingsProperty(string propertyName, Type propertyType, SerializationType serializeAs, object defaultValue, bool readOnly)
{
PropertyName = propertyName;
PropertyType = propertyType;
ReadOnly = readOnly;
SerializeAs = serializeAs;
DefaultValue = defaultValue;
}
public ObjectReference(string name, object value)
{
m_name = name;
Value = value;
Type valueType = m_value != null ? m_value.GetType() : null;
if (valueType == null)
m_serializationType = SerializationType.Null;
else if (valueType == typeof(IntPtr))
m_serializationType = SerializationType.IntPtr;
else if (valueType.IsPrimitive)
{
if (m_value is int && UnusedMarker.IsUnused((int)m_value))
m_serializationType = SerializationType.UnusedMarker;
else if (m_value is uint && UnusedMarker.IsUnused((uint)m_value))
m_serializationType = SerializationType.UnusedMarker;
else if (m_value is float && UnusedMarker.IsUnused((float)m_value))
m_serializationType = SerializationType.UnusedMarker;
else
m_serializationType = SerializationType.Any;
}
else if (valueType == typeof(string))
m_serializationType = SerializationType.String;
else if (valueType.IsArray)
m_serializationType = SerializationType.Array;
else if (valueType.IsEnum)
m_serializationType = SerializationType.Enum;
else if (valueType.Implements<IList>() || valueType.Implements<IDictionary>())
{
if (valueType.IsGenericType)
m_serializationType = SerializationType.GenericEnumerable;
else
m_serializationType = SerializationType.Enumerable;
}
else
{
if (m_value is Type)
m_serializationType = SerializationType.Type;
else if (valueType.Implements<Delegate>())
m_serializationType = SerializationType.Delegate;
else if (valueType.Implements<MemberInfo>())
m_serializationType = SerializationType.MemberInfo;
else
{
if (m_value is Vec3 && UnusedMarker.IsUnused((Vec3)m_value))
m_serializationType = SerializationType.UnusedMarker;
else if(m_forbiddenTypes.Contains(valueType))
m_serializationType = SerializationType.Null;
else
m_serializationType = SerializationType.Object;
}
}
}
public ISerializationStrategy Build(SerializationType type)
{
switch (type)
{
case SerializationType.Base64:
return new Base64SerializationStrategy();
case SerializationType.DataContractJson:
return new DataContractJsonSerializationStrategy();
case SerializationType.Xml:
return new XmlSerializationStrategy();
}
throw new NotSupportedException();
}
public static void sendRequestToAllFarmers <T>(string address, object request, Action <T> callback, SerializationType serializationType = SerializationType.PLAIN, int timeout = 500, XmlSerializer xmlSerializer = null)
{
sendRequestToFarmer(address, request, -1, callback, serializationType, timeout, xmlSerializer);
}
public Func<RestListenerContext, object> this[string path, SerializationType serializeAs, Func<RestListenerContext, bool> condition = null]
{
set
{
path += BasePath;
Action<RestListenerContext> handlerAction = context =>
{
using (StreamWriter writer = new StreamWriter(context.Response.OutputStream))
{
object instanceToSerialize = value(context);
// TODO: if object is null then 404
if (serializeAs == SerializationType.Json)
{
context.Response.ContentType.Set("application/json");
string serializedObject = SimpleJson.SimpleJson.SerializeObject(instanceToSerialize);
// TODO: If serialization failed 404
context.Response.ContentLength64.Set(serializedObject.Length);
context.Response.StatusCode.Set(200); // Everything is ok
writer.Write(serializedObject);
}
}
context.Response.Close();
};
this[path, condition] = handlerAction;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="PeerNet.DataConnectionOptions"/> class.
/// </summary>
/// <param name="label">Label optional, if not given a random token is generated for this dataconnection.</param>
/// <param name="metadata">Some metatdat to be given to the client on the other end</param>
/// <param name="serialization">The serialization used for this dataconnection </param>
/// <param name="reliable">If set to <c>true</c> reliable.</param>
public DataConnectionOptions (string label, string metadata, SerializationType serialization, bool reliable)
{
this.Label = label ?? "dc_" + Util.token;
this.MetaData = metadata ?? "";
this.Reliable = reliable;
this.Serialization = serialization;
}
public static void sendRequestToAllFarmers <T>(string address, object request, Action <T> callback, SerializationType serializationType = SerializationType.PLAIN, int timeout = 10000, XmlSerializer xmlSerializer = null)
{
foreach (Farmer farmer in Game1.otherFarmers.Values.Where(f => f.isActive() && f != Game1.player))
{
Task.Run(() => sendRequestToFarmer(address, request, farmer, callback, serializationType, timeout, xmlSerializer));
}
}
public static async Task <T> sendRequestToFarmer <T>(string address, object request, Farmer farmer, Action <T> callback = null, SerializationType serializationType = SerializationType.PLAIN, int timeout = 500, XmlSerializer xmlSerializer = null)
{
long fromFarmer = farmer.UniqueMultiplayerID;
if (xmlSerializer == null)
{
xmlSerializer = new XmlSerializer(typeof(T));
}
object objectData = request;
if (serializationType == SerializationType.XML)
{
StringWriter writer = new StringWriter();
xmlSerializer.Serialize(writer, request);
objectData = writer.ToString();
}
else if (serializationType == SerializationType.JSON)
{
objectData = JsonConvert.SerializeObject(request);
}
Int16 id = (Int16)random.Next(Int16.MinValue, Int16.MaxValue);
string returnAddress = address + "." + id;
PyMessenger <T> messenger = new PyMessenger <T>(returnAddress);
sendMessage(new MPMessage(address, Game1.player, objectData, id, fromFarmer));
object result = await Task.Run(() =>
{
while (true)
{
List <T> msgs = new List <T>(messenger.receive());
if (msgs.Count() > 0)
{
messages.Remove(returnAddress);
return(msgs[0]);
}
timeout--;
if (timeout < 0)
{
return(default(T));
}
Thread.Sleep(1);
}
});
callback?.Invoke((T)result);
return((T)result);
}
public ObjectReference(string name, SerializationType type)
{
m_name = name;
m_serializationType = type;
}
SerializationType MarkType(Type type)
{
SerializationType sType;
if (!typeMap.TryGetValue(type, out sType)) {
string assemblyName = null;
string typeName = null;
if (type.HasElementType) {
Debug.Assert(type.IsArray);
MarkType(type.GetElementType());
} else if (type.IsGenericType && !type.IsGenericTypeDefinition) {
MarkType(type.GetGenericTypeDefinition());
foreach (Type typeArg in type.GetGenericArguments())
MarkType(typeArg);
} else if (type.IsGenericParameter) {
throw new NotSupportedException();
} else {
var serializationBinder = fastSerializer.SerializationBinder;
if (serializationBinder != null) {
serializationBinder.BindToName(type, out assemblyName, out typeName);
} else {
assemblyName = type.Assembly.FullName;
typeName = type.FullName;
Debug.Assert(typeName != null);
}
}
sType = new SerializationType(typeMap.Count, type);
sType.TypeName = typeName;
if (assemblyName != null) {
if (!assemblyNameToID.TryGetValue(assemblyName, out sType.AssemblyNameID)) {
sType.AssemblyNameID = assemblyNames.Count;
assemblyNameToID.Add(assemblyName, sType.AssemblyNameID);
assemblyNames.Add(assemblyName);
Log("Registered assembly #{0}: {1}", sType.AssemblyNameID, assemblyName);
}
}
typeMap.Add(type, sType);
types.Add(sType);
Log("Registered type %{0}: {1}", sType.ID, type);
if (type == typeof(string)) {
stringType = sType;
}
}
return sType;
}
public ObjectReference(string name, SerializationType type)
{
this.Name = name;
this.SerializationType = type;
}
bool IsReferenceType(SerializationType type)
{
return type == SerializationType.Enumerable ||
type == SerializationType.GenericEnumerable ||
type == SerializationType.Object ||
type == SerializationType.MemberInfo ||
type == SerializationType.MemberInfo ||
type == SerializationType.Delegate ||
type == SerializationType.Type;
}
public static Task <T> sendRequestToFarmer <T>(string address, object request, long uniqueMultiplayerId, Action <T> callback = null, SerializationType serializationType = SerializationType.PLAIN, int timeout = 500, XmlSerializer xmlSerializer = null)
{
return(Task.Run(() =>
{
long toFarmer = uniqueMultiplayerId;
if (xmlSerializer == null)
{
xmlSerializer = new XmlSerializer(typeof(T));
}
object objectData = request;
if (serializationType == SerializationType.XML)
{
StringWriter writer = new StringWriter();
xmlSerializer.Serialize(writer, request);
objectData = writer.ToString();
}
else if (serializationType == SerializationType.JSON)
{
objectData = JsonConvert.SerializeObject(request);
}
int id = Guid.NewGuid().GetHashCode();
string returnAddress = address + "." + id;
PyMessenger <T> messenger = new PyMessenger <T>(returnAddress, null);
int run = 0;
bool received = false;
T result = default(T);
EventHandler <StardewModdingAPI.Events.ModMessageReceivedEventArgs> handler = (s, e) => checkForMessage(messenger, ref result, ref received, ref run);
Helper.Events.Multiplayer.ModMessageReceived += handler;
sendMessage(new MPMessage(address, Game1.player, objectData, id, toFarmer));
if (timeout > 0)
{
while (!received && run < 100 && timeout > 0)
{
timeout--;
Thread.Sleep(10);
}
}
Helper.Events.Multiplayer.ModMessageReceived -= handler;
callback?.Invoke((T)result);
return ((T)result);
}));
}
public static Task <T> sendRequestToFarmer <T>(string address, object request, Farmer farmer, Action <T> callback = null, SerializationType serializationType = SerializationType.PLAIN, int timeout = 500, XmlSerializer xmlSerializer = null)
{
return(sendRequestToFarmer(address, request, farmer.UniqueMultiplayerID, callback, serializationType, timeout, xmlSerializer));
}
public static void sendDataToFarmer(string address, object data, long uniqueMultiplayerId, SerializationType serializationType = SerializationType.PLAIN, XmlSerializer xmlSerializer = null)
{
sendRequestToFarmer <bool>(address, data, uniqueMultiplayerId, null, serializationType, -1, xmlSerializer);
}
protected IMessage DeserializeMessage(ReadOnlyMemory <byte> body, Type objectType, SerializationType serializationType)
{
IMessage message = null;
if (Serializers.TryGetValue(serializationType, out ISerializer serializer))
{
message = (IMessage)serializer.ByteArrayToObject(body.ToArray(), objectType);
}
else
{
Logger.LogError($"Cannot find serializer {serializationType} for Type {objectType.FullName} ...");
}
return(message);
}
object ReadValue(SerializationType etype, TypeSig argType, out TypeSig realArgType)
{
if (!recursionCounter.Increment())
{
throw new CABlobParserException("Too much recursion");
}
object result;
switch (etype)
{
case SerializationType.Boolean:
realArgType = module.CorLibTypes.Boolean;
result = reader.ReadByte() != 0;
break;
case SerializationType.Char:
realArgType = module.CorLibTypes.Char;
result = (char)reader.ReadUInt16();
break;
case SerializationType.I1:
realArgType = module.CorLibTypes.SByte;
result = reader.ReadSByte();
break;
case SerializationType.U1:
realArgType = module.CorLibTypes.Byte;
result = reader.ReadByte();
break;
case SerializationType.I2:
realArgType = module.CorLibTypes.Int16;
result = reader.ReadInt16();
break;
case SerializationType.U2:
realArgType = module.CorLibTypes.UInt16;
result = reader.ReadUInt16();
break;
case SerializationType.I4:
realArgType = module.CorLibTypes.Int32;
result = reader.ReadInt32();
break;
case SerializationType.U4:
realArgType = module.CorLibTypes.UInt32;
result = reader.ReadUInt32();
break;
case SerializationType.I8:
realArgType = module.CorLibTypes.Int64;
result = reader.ReadInt64();
break;
case SerializationType.U8:
realArgType = module.CorLibTypes.UInt64;
result = reader.ReadUInt64();
break;
case SerializationType.R4:
realArgType = module.CorLibTypes.Single;
result = reader.ReadSingle();
break;
case SerializationType.R8:
realArgType = module.CorLibTypes.Double;
result = reader.ReadDouble();
break;
case SerializationType.String:
realArgType = module.CorLibTypes.String;
result = ReadUTF8String();
break;
// It's ET.ValueType if it's eg. a ctor enum arg type
case (SerializationType)ElementType.ValueType:
if (argType == null)
{
throw new CABlobParserException("Invalid element type");
}
realArgType = argType;
result = ReadEnumValue(GetEnumUnderlyingType(argType));
break;
// It's ET.Object if it's a ctor object arg type
case (SerializationType)ElementType.Object:
case SerializationType.TaggedObject:
realArgType = ReadFieldOrPropType();
var arraySig = realArgType as SZArraySig;
if (arraySig != null)
{
result = ReadArrayArgument(arraySig);
}
else
{
TypeSig tmpType;
result = ReadValue((SerializationType)realArgType.ElementType, realArgType, out tmpType);
}
break;
// It's ET.Class if it's eg. a ctor System.Type arg type
case (SerializationType)ElementType.Class:
var tdr = argType as TypeDefOrRefSig;
if (tdr != null && tdr.DefinitionAssembly.IsCorLib() && tdr.Namespace == "System")
{
if (tdr.TypeName == "Type")
{
result = ReadValue(SerializationType.Type, tdr, out realArgType);
break;
}
if (tdr.TypeName == "String")
{
result = ReadValue(SerializationType.String, tdr, out realArgType);
break;
}
if (tdr.TypeName == "Object")
{
result = ReadValue(SerializationType.TaggedObject, tdr, out realArgType);
break;
}
}
// Assume it's an enum that couldn't be resolved
realArgType = argType;
return(ReadEnumValue(null));
case SerializationType.Type:
realArgType = argType;
result = ReadType();
break;
case SerializationType.Enum:
realArgType = ReadType();
result = ReadEnumValue(GetEnumUnderlyingType(realArgType));
break;
default:
throw new CABlobParserException("Invalid element type");
}
recursionCounter.Decrement();
return(result);
}
public void should_enumerate_member_specified_type_when_in_serialize_mode_and_configured_or_when_in_deserialize_mode(
string name, Mode mode, SerializationType type, int count)
{
var nodes = CreateAccessModifierNode(Options.Create(x => x.Serialization(y =>
{ if (type == SerializationType.ActualType) y.UseActualType(); })),
new SimpleValue(ModelInstance, typeof(Model).ToCachedType()), mode).ToList();
nodes.GetNode(name).ShouldTotal(count);
}
protected virtual NestedModelSerializationRule SerializationRuleForField(string field, SerializationType type)
{
return(NestedModelSerializationRule.IdParameter);
}
public static SerializerData PopulateSerializerDataIDataReader(IDataReader dr, SerializationType type)
{
SerializerData data = new SerializerData();
switch(type)
{
case SerializationType.Post:
//data.Bytes = dr["PostStringNameValues"] as byte[];
data.Keys = dr["PostPropertyNames"] as string;
data.Values = dr["PostPropertyValues"] as string;
break;
case SerializationType.Section:
//data.Bytes = dr["SectionStringNameValues"] as byte[];
data.Keys = dr["SectionPropertyNames"] as string;
data.Values = dr["SectionPropertyValues"] as string;
break;
case SerializationType.User:
//data.Bytes = dr["UserStringNameValues"] as byte[];
data.Keys = dr["UserPropertyNames"] as string;
data.Values = dr["UserPropertyValues"] as string;
break;
default:
//data.Bytes = dr["StringNameValues"] as byte[];
data.Keys = dr["PropertyNames"] as string;
data.Values = dr["PropertyValues"] as string;
break;
}
return data;
}
internal KeyValuePair <string, object> ConvertKey(KeyValuePair <string, object> obj, SerializationType type)
{
var key = obj.Key;
var value = obj.Value;
if (value is Array)
{
value = ((object[])value).Select((x) => ConvertKey(new KeyValuePair <string, object>("", x), type).Value);
}
else if (value is Model)
{
if (type != SerializationType.Plain && SerializationRuleForField(key, type) == NestedModelSerializationRule.IdParameter)
{
key += "_id";
value = ((Model)value).Id;
}
else
{
value = ((Model)value).ToDictionary(type);
}
}
else if (value is AbstractModel)
{
value = ((AbstractModel)value).ToDictionary(type);
}
#if NET40
else if (value != null && value.GetType().IsEnum)
#else
else if (value != null && value.GetType().GetTypeInfo().IsEnum)
#endif
{
value = EnumMagic.ConvertToString((Enum)value);
}
return(new KeyValuePair <string, object>(key, value));
}
internal string ToJson(SerializationType type = SerializationType.Shallow)
{
return(JsonConvert.SerializeObject(ToDictionary(type)));
}
private static OpCode GetSerializationTypeValue(SerializationType serializeAs)
{
switch (serializeAs)
{
case SerializationType.String:
return OpCodes.Ldc_I4_0;
case SerializationType.Xml:
return OpCodes.Ldc_I4_1;
case SerializationType.Binary:
return OpCodes.Ldc_I4_2;
}
throw new Exception();
}
object ReadValue(SerializationType etype, TypeSig argType, out TypeSig realArgType)
{
if (!recursionCounter.Increment())
throw new CABlobParserException("Too much recursion");
object result;
switch (etype) {
case SerializationType.Boolean:
realArgType = module.CorLibTypes.Boolean;
result = reader.ReadByte() != 0;
break;
case SerializationType.Char:
realArgType = module.CorLibTypes.Char;
result = (char)reader.ReadUInt16();
break;
case SerializationType.I1:
realArgType = module.CorLibTypes.SByte;
result = reader.ReadSByte();
break;
case SerializationType.U1:
realArgType = module.CorLibTypes.Byte;
result = reader.ReadByte();
break;
case SerializationType.I2:
realArgType = module.CorLibTypes.Int16;
result = reader.ReadInt16();
break;
case SerializationType.U2:
realArgType = module.CorLibTypes.UInt16;
result = reader.ReadUInt16();
break;
case SerializationType.I4:
realArgType = module.CorLibTypes.Int32;
result = reader.ReadInt32();
break;
case SerializationType.U4:
realArgType = module.CorLibTypes.UInt32;
result = reader.ReadUInt32();
break;
case SerializationType.I8:
realArgType = module.CorLibTypes.Int64;
result = reader.ReadInt64();
break;
case SerializationType.U8:
realArgType = module.CorLibTypes.UInt64;
result = reader.ReadUInt64();
break;
case SerializationType.R4:
realArgType = module.CorLibTypes.Single;
result = reader.ReadSingle();
break;
case SerializationType.R8:
realArgType = module.CorLibTypes.Double;
result = reader.ReadDouble();
break;
case SerializationType.String:
realArgType = module.CorLibTypes.String;
result = ReadUTF8String();
break;
// It's ET.ValueType if it's eg. a ctor enum arg type
case (SerializationType)ElementType.ValueType:
if (argType == null)
throw new CABlobParserException("Invalid element type");
realArgType = argType;
result = ReadEnumValue(GetEnumUnderlyingType(argType));
break;
// It's ET.Object if it's a ctor object arg type
case (SerializationType)ElementType.Object:
case SerializationType.TaggedObject:
realArgType = ReadFieldOrPropType();
var arraySig = realArgType as SZArraySig;
if (arraySig != null)
result = ReadArrayArgument(arraySig);
else {
TypeSig tmpType;
result = ReadValue((SerializationType)realArgType.ElementType, realArgType, out tmpType);
}
break;
// It's ET.Class if it's eg. a ctor System.Type arg type
case (SerializationType)ElementType.Class:
var tdr = argType as TypeDefOrRefSig;
if (tdr != null && tdr.DefinitionAssembly.IsCorLib() && tdr.Namespace == "System") {
if (tdr.TypeName == "Type") {
result = ReadValue(SerializationType.Type, tdr, out realArgType);
break;
}
if (tdr.TypeName == "String") {
result = ReadValue(SerializationType.String, tdr, out realArgType);
break;
}
if (tdr.TypeName == "Object") {
result = ReadValue(SerializationType.TaggedObject, tdr, out realArgType);
break;
}
}
// Assume it's an enum that couldn't be resolved
realArgType = argType;
return ReadEnumValue(null);
case SerializationType.Type:
realArgType = argType;
result = ReadType();
break;
case SerializationType.Enum:
realArgType = ReadType();
result = ReadEnumValue(GetEnumUnderlyingType(realArgType));
break;
default:
throw new CABlobParserException("Invalid element type");
}
recursionCounter.Decrement();
return result;
}
public TypeInformation(Type type, string name, string namespaceName, string itemName, string keyName, string valueName, SerializationType isAttributeSuchAsDataContractPresent)
{
this.Type = type;
this.Name = name;
this.NamespaceName = namespaceName;
this.ItemName = itemName;
this.KeyName = keyName;
this.ValueName = valueName;
this.serializationType = isAttributeSuchAsDataContractPresent;
}
