/// <summary>
/// Fetches all of the processors for the given type.
/// </summary>
private List <fsObjectProcessor> GetProcessors(Type type)
{
List <fsObjectProcessor> processors;
// Check to see if the user has defined a custom processor for the type. If they
// have, then we don't need to scan through all of the processor to check which
// one can process the type; instead, we directly use the specified processor.
fsObjectAttribute attr = fsPortableReflection.GetAttribute <fsObjectAttribute>(type);
if (attr != null && attr.Processor != null)
{
fsObjectProcessor processor = (fsObjectProcessor)Activator.CreateInstance(attr.Processor);
processors = new List <fsObjectProcessor>();
processors.Add(processor);
_cachedProcessors[type] = processors;
}
else if (_cachedProcessors.TryGetValue(type, out processors) == false)
{
processors = new List <fsObjectProcessor>();
for (int i = 0; i < _processors.Count; ++i)
{
fsObjectProcessor processor = _processors[i];
if (processor.CanProcess(type))
{
processors.Add(processor);
}
}
_cachedProcessors[type] = processors;
}
return(processors);
}
// Token: 0x060004D1 RID: 1233 RVA: 0x0001DB68 File Offset: 0x0001BD68
private static void CollectProperties(fsConfig config, List <fsMetaProperty> properties, Type reflectedType)
{
bool flag = config.DefaultMemberSerialization == fsMemberSerialization.OptIn;
bool flag2 = config.DefaultMemberSerialization == fsMemberSerialization.OptOut;
fsObjectAttribute attribute = fsPortableReflection.GetAttribute <fsObjectAttribute>(reflectedType);
if (attribute != null)
{
flag = (attribute.MemberSerialization == fsMemberSerialization.OptIn);
flag2 = (attribute.MemberSerialization == fsMemberSerialization.OptOut);
}
MemberInfo[] declaredMembers = reflectedType.GetDeclaredMembers();
MemberInfo[] array = declaredMembers;
MemberInfo member;
for (int i = 0; i < array.Length; i++)
{
member = array[i];
if (!config.IgnoreSerializeAttributes.Any((Type t) => fsPortableReflection.HasAttribute(member, t)))
{
PropertyInfo propertyInfo = member as PropertyInfo;
FieldInfo fieldInfo = member as FieldInfo;
if (propertyInfo != null || fieldInfo != null)
{
if (propertyInfo == null || config.EnablePropertySerialization)
{
if (!flag || config.SerializeAttributes.Any((Type t) => fsPortableReflection.HasAttribute(member, t)))
{
if (!flag2 || !config.IgnoreSerializeAttributes.Any((Type t) => fsPortableReflection.HasAttribute(member, t)))
{
if (propertyInfo != null)
{
if (fsMetaType.CanSerializeProperty(config, propertyInfo, declaredMembers, flag2))
{
properties.Add(new fsMetaProperty(config, propertyInfo));
}
}
else if (fieldInfo != null && fsMetaType.CanSerializeField(config, fieldInfo, flag2))
{
properties.Add(new fsMetaProperty(config, fieldInfo));
}
}
}
}
}
}
}
if (reflectedType.Resolve().BaseType != null)
{
fsMetaType.CollectProperties(config, properties, reflectedType.Resolve().BaseType);
}
}
private static void CollectProperties(fsConfig config, List <fsMetaProperty> properties, Type reflectedType)
{
// do we require a [SerializeField] or [fsProperty] attribute?
bool requireOptIn = config.DefaultMemberSerialization == fsMemberSerialization.OptIn;
bool requireOptOut = config.DefaultMemberSerialization == fsMemberSerialization.OptOut;
fsObjectAttribute attr = fsPortableReflection.GetAttribute <fsObjectAttribute>(reflectedType);
if (attr != null)
{
requireOptIn = attr.MemberSerialization == fsMemberSerialization.OptIn;
requireOptOut = attr.MemberSerialization == fsMemberSerialization.OptOut;
}
MemberInfo[] members = reflectedType.GetDeclaredMembers();
foreach (MemberInfo member in members)
{
// We don't serialize members annotated with any of the ignore
// serialize attributes
if (config.IgnoreSerializeAttributes.Any(t => fsPortableReflection.HasAttribute(member, t)))
{
continue;
}
PropertyInfo property = member as PropertyInfo;
FieldInfo field = member as FieldInfo;
// Early out if it's neither a field or a property, since we
// don't serialize anything else.
if (property == null && field == null)
{
continue;
}
// Skip properties if we don't want them, to avoid the cost of
// checking attributes.
if (property != null && !config.EnablePropertySerialization)
{
continue;
}
// If an opt-in annotation is required, then skip the property if
// it doesn't have one of the serialize attributes
if (requireOptIn &&
!config.SerializeAttributes.Any(t => fsPortableReflection.HasAttribute(member, t)))
{
continue;
}
// If an opt-out annotation is required, then skip the property
// *only if* it has one of the not serialize attributes
if (requireOptOut &&
config.IgnoreSerializeAttributes.Any(t => fsPortableReflection.HasAttribute(member, t)))
{
continue;
}
if (property != null)
{
if (CanSerializeProperty(config, property, members, requireOptOut))
{
properties.Add(new fsMetaProperty(config, property));
}
}
else if (field != null)
{
if (CanSerializeField(config, field, requireOptOut))
{
properties.Add(new fsMetaProperty(config, field));
}
}
}
if (reflectedType.Resolve().BaseType != null)
{
CollectProperties(config, properties, reflectedType.Resolve().BaseType);
}
}
private static void CollectProperties(List <fsMetaProperty> properties, Type reflectedType)
{
// do we require a [SerializeField] or [fsProperty] attribute?
bool requireOptIn = fsConfig.DefaultMemberSerialization == fsMemberSerialization.OptIn;
bool requireOptOut = fsConfig.DefaultMemberSerialization == fsMemberSerialization.OptOut;
fsObjectAttribute attr = fsPortableReflection.GetAttribute <fsObjectAttribute>(reflectedType);
if (attr != null)
{
requireOptIn = attr.MemberSerialization == fsMemberSerialization.OptIn;
requireOptOut = attr.MemberSerialization == fsMemberSerialization.OptOut;
}
MemberInfo[] members = reflectedType.GetDeclaredMembers();
foreach (var member in members)
{
// We don't serialize members annotated with any of the ignore serialize attributes
if (fsConfig.IgnoreSerializeAttributes.Any(t => fsPortableReflection.HasAttribute(member, t)))
{
continue;
}
PropertyInfo property = member as PropertyInfo;
FieldInfo field = member as FieldInfo;
// If an opt-in annotation is required, then skip the property if it doesn't have one
// of the serialize attributes
if (requireOptIn &&
!fsConfig.SerializeAttributes.Any(t => fsPortableReflection.HasAttribute(member, t)))
{
continue;
}
// If an opt-out annotation is required, then skip the property *only if* it has one of
// the not serialize attributes
if (requireOptOut &&
fsConfig.IgnoreSerializeAttributes.Any(t => fsPortableReflection.HasAttribute(member, t)))
{
continue;
}
if (property != null)
{
if (CanSerializeProperty(property, members, requireOptOut))
{
properties.Add(new fsMetaProperty(property));
}
}
else if (field != null)
{
if (CanSerializeField(field, requireOptOut))
{
properties.Add(new fsMetaProperty(field));
}
}
}
if (reflectedType.Resolve().BaseType != null)
{
CollectProperties(properties, reflectedType.Resolve().BaseType);
}
}
/// <summary>
/// Fetches a converter that can serialize/deserialize the given type.
/// </summary>
private fsBaseConverter GetConverter(Type type, Type overrideConverterType)
{
// Use an override converter type instead if that's what the user has requested.
if (overrideConverterType != null)
{
fsBaseConverter overrideConverter;
if (_cachedConverterTypeInstances.TryGetValue(overrideConverterType, out overrideConverter) == false)
{
overrideConverter = (fsBaseConverter)Activator.CreateInstance(overrideConverterType);
overrideConverter.Serializer = this;
_cachedConverterTypeInstances[overrideConverterType] = overrideConverter;
}
return(overrideConverter);
}
// Try to lookup an existing converter.
fsBaseConverter converter;
if (_cachedConverters.TryGetValue(type, out converter))
{
return(converter);
}
// Check to see if the user has defined a custom converter for the type. If they
// have, then we don't need to scan through all of the converters to check which
// one can process the type; instead, we directly use the specified converter.
{
fsObjectAttribute attr = fsPortableReflection.GetAttribute <fsObjectAttribute>(type);
if (attr != null && attr.Converter != null)
{
converter = (fsBaseConverter)Activator.CreateInstance(attr.Converter);
converter.Serializer = this;
return(_cachedConverters[type] = converter);
}
}
// Check for a [fsForward] attribute.
{
fsForwardAttribute attr = fsPortableReflection.GetAttribute <fsForwardAttribute>(type);
if (attr != null)
{
converter = new fsForwardConverter(attr);
converter.Serializer = this;
return(_cachedConverters[type] = converter);
}
}
// There is no specific converter specified; try all of the general ones to see
// which ones matches.
if (_cachedConverters.TryGetValue(type, out converter) == false)
{
if (_availableDirectConverters.ContainsKey(type))
{
converter = _availableDirectConverters[type];
return(_cachedConverters[type] = converter);
}
for (int i = 0; i < _availableConverters.Count; ++i)
{
if (_availableConverters[i].CanProcess(type))
{
converter = _availableConverters[i];
return(_cachedConverters[type] = converter);
}
}
}
throw new InvalidOperationException("Internal error -- could not find a converter for " + type);
}
