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); } }