public void ReflectedPropertyBagVisitor_Transfer_NestedContainer()
{
PropertyBagResolver.Register(new ReflectedPropertyBagProvider().Generate <SimpleContainer>());
PropertyBagResolver.Register(new ReflectedPropertyBagProvider().Generate <NestedContainer>());
PropertyBagResolver.Register(new ReflectedPropertyBagProvider().Generate <Foo>());
var source = new SimpleContainer
{
Int32Value = 15,
Nested = new NestedContainer
{
Int32Value = 42
}
};
var foo = new Foo
{
Nested = new NestedContainer {
Int32Value = 10
}
};
using (var result = PropertyContainer.Transfer(ref foo, ref source))
{
Assert.That(result.Succeeded, Is.True);
Assert.AreEqual(42, foo.Nested.Int32Value);
}
}
public void ReflectedPropertyBagVisitor_Visit()
{
PropertyBagResolver.Register(new ReflectedPropertyBagProvider().Generate <SimpleContainer>());
PropertyBagResolver.Register(new ReflectedPropertyBagProvider().Generate <NestedContainer>());
PropertyContainer.Visit(new SimpleContainer(), new VoidVisitor());
}
public void ReflectedPropertyBagVisitor_Transfer_NestedContainer()
{
PropertyBagResolver.Register(new ReflectedPropertyBagProvider().Generate <SimpleContainer>());
PropertyBagResolver.Register(new ReflectedPropertyBagProvider().Generate <NestedContainer>());
PropertyBagResolver.Register(new ReflectedPropertyBagProvider().Generate <Foo>());
var source = new SimpleContainer
{
Int32Value = 15,
Nested = new NestedContainer
{
Int32Value = 42
}
};
var foo = new Foo
{
Nested = new NestedContainer {
Int32Value = 10
}
};
var changeTracker = new ChangeTracker(null);
PropertyContainer.Transfer(ref foo, ref source, ref changeTracker);
Assert.AreEqual(42, foo.Nested.Int32Value);
}
VisitStatus IPropertyVisitor.VisitProperty <TProperty2, TContainer2, TValue2>(TProperty2 property, ref TContainer2 container, ref ChangeTracker changeTracker)
{
if (visitedFirst)
{
return(VisitStatus.Handled);
}
if (!Result)
{
return(VisitStatus.Handled);
}
visitedFirst = true;
if (property.IsContainer)
{
var bag = PropertyBagResolver.Resolve <TValue2>();
if (bag != null)
{
var ct = new ChangeTracker();
var v = property.GetValue(ref container);
var visitor2 = new FirstVisitor(Visitor);
bag.Accept(ref v, ref visitor2, ref ct);
Result = visitor2.Result;
}
}
return(VisitStatus.Handled);
}
public void ReflectedPropertyBagVisitor_Transfer_Collections()
{
PropertyBagResolver.Register(new ReflectedPropertyBagProvider().Generate <ContainerWithCollections>());
var source = new ContainerWithCollections
{
IListGeneric = new List <int> {
4, 5, 6
},
ListGeneric = new List <int> {
7
},
Array = new [] { 6, 9, 10, 11 }
};
var destination = new ContainerWithCollections
{
IListGeneric = new List <int>(),
ListGeneric = new List <int>(),
Array = new int[0]
};
var changeTracker = new ChangeTracker(null);
PropertyContainer.Transfer(ref destination, ref source, ref changeTracker);
Assert.That(destination.IListGeneric.Count, Is.EqualTo(3));
Assert.That(destination.ListGeneric.Count, Is.EqualTo(1));
Assert.That(destination.Array.Length, Is.EqualTo(4));
}
public void ReflectedPropertyBag_SetValue_ReadOnly()
{
PropertyBagResolver.Register(new ReflectedPropertyBagProvider().Generate <ContainerWithSpecialAccess>());
var instance = default(ContainerWithSpecialAccess);
Assert.DoesNotThrow(() =>
{
PropertyContainer.SetValue(ref instance, "m_ReadWriteField", 10);
});
Assert.Throws <InvalidOperationException>(() =>
{
PropertyContainer.SetValue(ref instance, "m_ExplicitReadOnlyField", 10);
});
Assert.DoesNotThrow(() =>
{
PropertyContainer.SetValue(ref instance, "ReadWriteProperty", 10);
});
Assert.Throws <InvalidOperationException>(() =>
{
PropertyContainer.SetValue(ref instance, "ImplicitReadOnlyProperty", 10);
});
}
public void SetUp()
{
PropertyBagResolver.Register(new TestNestedContainerPropertyBag());
PropertyBagResolver.Register(new TestPrimitiveContainerPropertyBag());
PropertyBagResolver.Register(new TestArrayContainerPropertyBag());
PropertyBagResolver.Register(new CustomDataFooPropertyBag());
PropertyBagResolver.Register(new CustomDataBarPropertyBag());
}
public void Setup()
{
m_PreviousWorld = World.Active;
m_World = World.Active = new World("Test World");
m_Manager = m_World.EntityManager;
PropertyBagResolver.RegisterProvider(new ReflectedPropertyBagProvider());
}
public static bool Execute(object container, InspectorVisitor <T> visitor, IProperty property, PropertyPath path,
string propertyName, InspectorVisitLevel visitLevel)
{
var action = new GetCustomInspectorCallback(visitor, property, path, propertyName, visitLevel);
PropertyBagResolver.Resolve(container.GetType()).Cast(ref action);
return(action.Visited);
}
public static void InitializePropertyBags()
{
PropertyBagResolver.Register(new TestNestedContainerPropertyBag());
PropertyBagResolver.Register(new TestPrimitiveContainerPropertyBag());
PropertyBagResolver.Register(new TestArrayContainerPropertyBag());
PropertyBagResolver.Register(new TestListContainerPropertyBag());
PropertyBagResolver.Register(new CustomDataFooPropertyBag());
PropertyBagResolver.Register(new CustomDataBarPropertyBag());
}
static void AssertCollectionPropertyType <TContainer>(ref TContainer container, string name, Type type)
{
var change = new ChangeTracker();
var action = new AssertCollectionPropertyTypeGetter <TContainer>
{
ExpectedPropertyType = type
};
PropertyBagResolver.Resolve <TContainer>().FindProperty(name, ref container, ref change, ref action);
}
public void PropertyBag_Accept_Object()
{
var untypedPropertyBag = PropertyBagResolver.Resolve(typeof(TestPrimitiveContainer));
var boxedContainer = (object)default(TestPrimitiveContainer);
var changeTracker = default(ChangeTracker);
untypedPropertyBag.Accept(ref boxedContainer, new SetPropertyVisitor {
Name = nameof(TestPrimitiveContainer.Int32Value), Value = 42
}, ref changeTracker);
Assert.That(((TestPrimitiveContainer)boxedContainer).Int32Value, Is.EqualTo(42));
}
static DomainReload()
{
// Save and close the project during an assembly reload or application shutdown
AssemblyReloadEvents.beforeAssemblyReload += HandleDomainWillUnload;
EditorApplication.quitting += HandleDomainWillUnload;
// Register to unity application events
EditorApplication.update += HandleUpdate;
PropertyBagResolver.Register(new SessionState.PropertyBag());
}
public static object ReadBoxedClass(Type type, PropertiesBinaryReader reader)
{
var forwarder = new ReadBoxedClassForwarder {
reader = reader, Container = null
};
var propertyBag = PropertyBagResolver.Resolve(type);
propertyBag.Cast(ref forwarder);
return(forwarder.Container);
}
public static void Visit <TContainer, TVisitor>(ref TContainer container, TVisitor visitor, ref ChangeTracker changeTracker)
where TVisitor : IPropertyVisitor
{
if (RuntimeTypeInfoCache <TContainer> .IsAbstractOrInterface())
{
PropertyBagResolver.Resolve(container.GetType())?.Accept(container, visitor, ref changeTracker);
}
else
{
PropertyBagResolver.Resolve <TContainer>()?.Accept(ref container, visitor, ref changeTracker);
}
}
private static void Initialize()
{
var provider = new ReflectedPropertyBagProvider();
provider.AddGenerator(new CharPropertyGenerator());
PropertyBagResolver.RegisterProvider(provider);
PropertyBagResolver.Register(new SerializedObjectViewPropertyBag());
AssemblyReloadEvents.beforeAssemblyReload += HandleDomainWillUnload;
EditorApplication.update += HandleUpdate;
Bridge.EditorApplication.UpdateMainWindowTitleHandler += MainWindowTitleHandler;
}
public static void Visit <TContainer, TVisitor>(ref TContainer container, TVisitor visitor, ref ChangeTracker changeTracker)
where TVisitor : IPropertyVisitor
{
if (!RuntimeTypeInfoCache <TContainer> .IsValueType() && null != container && typeof(TContainer) != container.GetType())
{
var boxed = (object)container;
PropertyBagResolver.Resolve(container.GetType())?.Accept(ref boxed, visitor, ref changeTracker);
container = (TContainer)boxed;
}
else
{
PropertyBagResolver.Resolve <TContainer>()?.Accept(ref container, visitor, ref changeTracker);
}
}
public void ReflectedPropertyBag_SetValue_PrivateFields()
{
PropertyBagResolver.Register(new ReflectedPropertyBagProvider().Generate <SimpleContainerWithPrivateFields>());
var instance = default(SimpleContainerWithPrivateFields);
PropertyContainer.SetValue(ref instance, "m_Int32Value", 10);
Assert.That(instance.Int32Value, Is.EqualTo(10));
Assert.Throws <InvalidOperationException>(() =>
{
PropertyContainer.SetValue(ref instance, "m_HiddenInt32Value", 10);
});
}
public void ReflectedPropertyBag_SetValue_CSharpProperties()
{
PropertyBagResolver.Register(new ReflectedPropertyBagProvider().Generate <ContainerWithProperties>());
var instance = default(ContainerWithProperties);
PropertyContainer.SetValue(ref instance, "IntProperty", 10);
Assert.That(instance.IntProperty, Is.EqualTo(10));
Assert.Throws <InvalidOperationException>(() =>
{
PropertyContainer.SetValue(ref instance, "HiddenInt32Property", 10);
});
}
VisitStatus IPropertyVisitor.VisitProperty <TProperty2, TContainer2, TValue2>(TProperty2 property, ref TContainer2 container, ref ChangeTracker changeTracker)
{
if (property.IsContainer)
{
var bag = PropertyBagResolver.Resolve <TValue2>();
if (bag != null)
{
var ct = new ChangeTracker();
var v = property.GetValue(ref container);
bag.Accept(ref v, ref Visitor, ref ct);
}
}
return(VisitStatus.Handled);
}
public static void WriteBoxedType <TVisitor>(object container, TVisitor visitor)
where TVisitor : IPropertyVisitor
{
var changeTracker = new ChangeTracker();
var resolved = PropertyBagResolver.Resolve(container.GetType());
if (resolved != null)
{
resolved.Accept(ref container, ref visitor, ref changeTracker);
}
else
{
throw new ArgumentException("Not supported");
}
}
internal static void PatchEntityForPrefabInBoxedType(object container, SparseEntityRemapInfo *remapInfo, int remapInfoCount)
{
var visitor = new EntityRemappingVisitor(remapInfo, remapInfoCount);
var changeTracker = new ChangeTracker();
var type = container.GetType();
var resolved = PropertyBagResolver.Resolve(type);
if (resolved != null)
{
resolved.Accept(ref container, ref visitor, ref changeTracker);
}
else
{
throw new ArgumentException($"Type '{type.FullName}' not supported for visiting.");
}
}
public static void Transfer <TDestination, TSource>(ref TDestination destination, ref TSource source, ref ChangeTracker changeTracker)
{
if (RuntimeTypeInfoCache <TSource> .IsAbstractOrInterface())
{
var propertyBag = PropertyBagResolver.Resolve(source.GetType());
var action = new TransferAbstractType <TDestination>
{
Destination = destination,
SourceContainer = (object)source
};
propertyBag.Cast(action);
destination = action.Destination;
}
else
{
Visit(ref destination, new TransferVisitor <TSource>(source), ref changeTracker);
}
}
static JsonObject()
{
PropertyBagResolver.Register(new JsonObjectPropertyBag());
}
static SerializedObjectView()
{
PropertyBagResolver.Register(new SerializedObjectViewPropertyBag());
}
static DynamicBufferContainer()
{
PropertyBagResolver.Register(new PropertyBag());
}
static EntityContainer()
{
PropertyBagResolver.Register(new EntityContainerPropertyBag());
PropertyBagResolver.RegisterProvider(new ReflectedPropertyBagProvider());
}
static SceneContainer()
{
PropertyBagResolver.Register(new ScenePropertyBag());
}
static ImguiVisitorBase()
{
#if !NEW_PROPERTIES
PropertyBagResolver.RegisterProvider(new ReflectedPropertyBagProvider());
#endif
}
static EntityContainer()
{
PropertyBagResolver.Register(new EntityContainerPropertyBag());
}
