/// <summary>
/// Searches for a particular implementation of the given interface type inside of the type.
/// This is particularly useful if the interface type is an open type, ie, typeof(IFace{}),
/// because this method will then return IFace{} but with appropriate type parameters
/// inserted.
/// </summary>
/// <param name="type">The base type to search for interface</param>
/// <param name="interfaceType">The interface type to search for. Can be an open generic
/// type.</param>
/// <returns>The actual interface type that the type contains, or null if there is no
/// implementation of the given interfaceType on type.</returns>
public static Type GetInterface(Type type, Type interfaceType)
{
if (interfaceType.Resolve().IsGenericType &&
interfaceType.Resolve().IsGenericTypeDefinition == false) {
throw new ArgumentException("GetInterface requires that if the interface " +
"type is generic, then it must be the generic type definition, not a " +
"specific generic type instantiation");
};
while (type != null) {
foreach (var iface in type.GetInterfaces()) {
if (iface.Resolve().IsGenericType) {
if (interfaceType == iface.GetGenericTypeDefinition()) {
return iface;
}
}
else if (interfaceType == iface) {
return iface;
}
}
type = type.Resolve().BaseType;
}
return null;
}
public override bool CanProcess(Type type)
{
return
typeof(UnityObject).Resolve().IsAssignableFrom(type.Resolve()) == false &&
typeof(ISerializationCallbackReceiver).Resolve().IsAssignableFrom(type.Resolve()) &&
// If we are BaseObject, we explicitly do not want to invoke the callback receivers. Doing
// so will mess up the serialization pipeline. This does not present an issue because the
// object will be serialized normally/as expected by the regular FS pipeline.
typeof(BaseObject).Resolve().IsAssignableFrom(type.Resolve()) == false;
}
private static Type RunSanityCheck(Type type) {
if ((type.Resolve().IsPublic || type.Resolve().IsNestedPublic) == false) {
Throw("sanity check -- type is not public for type={0}", type);
}
if (type.Resolve().IsGenericTypeDefinition) {
Throw("sanity check -- type is a generic definition for type={0}", type);
}
return type;
}
public override bool CanProcess(Type type)
{
return
type.Resolve().IsPrimitive ||
type == typeof(string) ||
type == typeof(decimal);
}
public InspectorCollectionAddItemAttributesAttribute(Type attributes)
{
if (typeof(fiICollectionAttributeProvider).Resolve().IsAssignableFrom(attributes.Resolve()) == false) {
throw new ArgumentException("Must be an instance of FullInspector.fiICollectionAttributeProvider", "attributes");
}
var instance = (fiICollectionAttributeProvider)Activator.CreateInstance(attributes);
AttributeProvider = fiAttributeProvider.Create(instance.GetAttributes().ToArray());
}
public override bool CanProcess(Type type)
{
if (type.Resolve().IsArray ||
typeof(ICollection).IsAssignableFrom(type)) {
return false;
}
return true;
}
/// <summary>
/// Returns the serializer type that the given behavior type uses.
/// </summary>
public static Type GetSerializerType(Type behaviorType)
{
for (int i = 0; i < _mappings.Count; ++i) {
var mapping = _mappings[i];
if (mapping.BehaviorType.Resolve().IsAssignableFrom(behaviorType.Resolve())) {
return mapping.SerializerType;
}
}
throw new InvalidOperationException("Unable to determine serializer for " + behaviorType.CSharpName());
}
/// <summary>
/// Returns the serializer type that the given behavior type uses.
/// </summary>
public static Type GetSerializerType(Type behaviorType)
{
for (int i = 0; i < _mappings.Count; ++i) {
var mapping = _mappings[i];
if (mapping.BehaviorType.Resolve().IsAssignableFrom(behaviorType.Resolve())) {
return mapping.SerializerType;
}
}
// No custom serializer, use the default one
return fiInstalledSerializerManager.DefaultMetadata.SerializerType;
}
private fsMetaType(fsConfig config, Type reflectedType)
{
ReflectedType = reflectedType;
List<fsMetaProperty> properties = new List<fsMetaProperty>();
CollectProperties(config, properties, reflectedType);
Properties = properties.ToArray();
#if UNITY_EDITOR || UNITY_STANDALONE
try
{
if (!ReflectedType.Resolve().IsValueType && ReflectedType.GetDeclaredConstructor(fsPortableReflection.EmptyTypes) != null ){
Generator = Expression.Lambda<Func<object>>(Expression.New(reflectedType)).Compile();
}
}
catch{Generator = null;}
#endif
}
private static string GetTooltipText(Type type)
{
string tooltip;
if (!s_cachedTypeTooltips.TryGetValue(type, out tooltip)) {
tooltip = InspectorTooltipAttribute.GetTooltip(type.Resolve());
s_cachedTypeTooltips[type] = tooltip;
}
return tooltip;
}
/// <summary>
/// If true, then the serializer will include inheritance data for the given converter.
/// </summary>
/// <param name="storageType">The field/property type that is currently storing the object
/// that is being serialized.</param>
public virtual bool RequestInheritanceSupport(Type storageType) {
return storageType.Resolve().IsSealed == false;
}
public static bool IsInIgnoredAssembly(Type type) {
return IsAssemblyAllowed(type.Resolve().Assembly) == false;
}
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>
/// If true, then the serializer will support cyclic references with the given converted
/// type.
/// </summary>
/// <param name="storageType">The field/property type that is currently storing the object
/// that is being serialized.</param>
public virtual bool RequestCycleSupport(Type storageType) {
if (storageType == typeof(string)) return false;
return storageType.Resolve().IsClass || storageType.Resolve().IsInterface;
}
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;
}
// 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);
}
}
public override bool CanProcess(Type type) {
return
type.Resolve().IsGenericType &&
type.GetGenericTypeDefinition() == typeof(KeyValuePair<,>);
}
public override bool CanProcess(Type type)
{
return typeof(UnityObject).Resolve().IsAssignableFrom(type.Resolve());
}
/// <summary>
/// A simple type is a type that is either primitive, a string, or a
/// non-generic non-abstract class composed of other simple types.
/// </summary>
private static bool IsSimpleTypeThatUnityCanSerialize(Type type)
{
if (IsPrimitiveSkippedByUnity(type)) {
return false;
}
if (type.Resolve().IsPrimitive) {
return true;
}
if (type == typeof(string)) {
return true;
}
// TODO: Enable more complex detection for types which Unity can
// serialize by uncommenting this block. First, test it,
// though.
/*
if (type.IsClass && type.IsGenericType == false && type.IsAbstract == false) {
BindingFlags flags =
BindingFlags.Instance |
BindingFlags.FlattenHierarchy |
BindingFlags.Public |
BindingFlags.NonPublic;
// The type might contain a property that should be serialized.
if (type.GetProperties(flags).Length > 0) {
return false;
}
// The type can have fields composed only of other simple types.
// TODO: will this recurse infinitely for recursive types?
foreach (var field in type.GetFields(flags)) {
if (IsSimpleType(field.FieldType) == false) {
return false;
}
}
return true;
}
*/
return false;
}
private bool IsStack(Type type)
{
return type.Resolve().IsGenericType &&
type.Resolve().GetGenericTypeDefinition() == typeof(Stack<>);
}
private static bool CompareTypes(Type a, Type b) {
// one of them is a definition, so make both of them a definition
if ((a.Resolve().IsGenericType && b.Resolve().IsGenericType) &&
(a.Resolve().IsGenericTypeDefinition || b.Resolve().IsGenericTypeDefinition)) {
a = a.GetGenericTypeDefinition();
b = b.GetGenericTypeDefinition();
}
return a == b;
}
public override bool CanConvert(Type objectType)
{
return typeof(UnityObject).Resolve().IsAssignableFrom(objectType.Resolve());
}
public override bool CanProcess(Type type) {
return
type.Resolve().IsGenericType &&
type.GetGenericTypeDefinition() == typeof(Nullable<>);
}
public override bool CanProcess(Type type) {
return
typeof(UnityObject).Resolve().IsAssignableFrom(type.Resolve()) == false &&
typeof(ISerializationCallbackReceiver).Resolve().IsAssignableFrom(type.Resolve());
}
