public static fsOption <fsVersionedType> GetVersionedType(Type type)
{
fsOption <fsVersionedType> optionalVersionedType;
if (_cache.TryGetValue(type, out optionalVersionedType) == false)
{
fsObjectAttribute attr = fsPortableReflection.GetAttribute <fsObjectAttribute>(type);
if (attr != null)
{
if (string.IsNullOrEmpty(attr.VersionString) == false || attr.PreviousModels != null)
{
// Version string must be provided
if (attr.PreviousModels != null && string.IsNullOrEmpty(attr.VersionString))
{
throw new Exception("fsObject attribute on " + type +
" contains a PreviousModels specifier - it must also include a VersionString modifier");
}
// Map the ancestor types into versioned types
fsVersionedType[] ancestors =
new fsVersionedType[attr.PreviousModels != null ? attr.PreviousModels.Length : 0];
for (int i = 0; i < ancestors.Length; ++i)
{
fsOption <fsVersionedType> ancestorType = GetVersionedType(attr.PreviousModels[i]);
if (ancestorType.IsEmpty)
{
throw new Exception("Unable to create versioned type for ancestor " + ancestorType +
"; please add an [fsObject(VersionString=\"...\")] attribute");
}
ancestors[i] = ancestorType.Value;
}
// construct the actual versioned type instance
fsVersionedType versionedType = new fsVersionedType
{
Ancestors = ancestors,
VersionString = attr.VersionString,
ModelType = type
};
// finally, verify that the versioned type passes some
// sanity checks
VerifyUniqueVersionStrings(versionedType);
VerifyConstructors(versionedType);
optionalVersionedType = fsOption.Just(versionedType);
}
}
_cache[type] = optionalVersionedType;
}
return(optionalVersionedType);
}
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 (var 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;
}
// 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);
}
}
