public void GetAllInstancesWithInjectSplit(
InjectContext context, List <TypeValuePair> args, out Action injectAction, List <object> buffer)
{
Assert.IsEmpty(args);
Assert.IsNotNull(context);
Assert.That(typeof(TReturn).DerivesFromOrEqual(context.MemberType));
injectAction = null;
if (_container.IsValidating && !TypeAnalyzer.ShouldAllowDuringValidation(context.MemberType))
{
buffer.Add(new ValidationMarker(typeof(TReturn)));
}
else
{
var result = _method(context);
if (result == null)
{
throw Assert.CreateException(
"Method '{0}' returned null when list was expected. Object graph:\n {1}",
_method.ToDebugString(), context.GetObjectGraphString());
}
foreach (var obj in result)
{
buffer.Add(obj);
}
}
}
public void GetAllInstancesWithInjectSplit(
InjectContext context, List <TypeValuePair> args, out Action injectAction, List <object> buffer)
{
Assert.IsEmpty(args);
Assert.IsNotNull(context);
injectAction = null;
if (_container.IsValidating && !TypeAnalyzer.ShouldAllowDuringValidation(context.MemberType))
{
buffer.Add(new ValidationMarker(context.MemberType));
}
else
{
var result = _method(context);
if (result == null)
{
Assert.That(!context.MemberType.IsPrimitive(),
"Invalid value returned from FromMethod. Expected non-null.");
}
else
{
Assert.That(result.GetType().DerivesFromOrEqual(context.MemberType));
}
buffer.Add(result);
}
}
public void GetAllInstancesWithInjectSplit(
InjectContext context, List <TypeValuePair> args, out Action injectAction, List <object> buffer)
{
Assert.IsNotNull(context);
Assert.That(context.ObjectType.DerivesFrom <Component>(),
"Object '{0}' can only be injected into MonoBehaviour's since it was bound with 'FromNewComponentSibling'. Attempted to inject into non-MonoBehaviour '{1}'",
context.MemberType, context.ObjectType);
object instance;
if (!_container.IsValidating || TypeAnalyzer.ShouldAllowDuringValidation(_componentType))
{
var gameObj = ((Component)context.ObjectInstance).gameObject;
var componentInstance = gameObj.GetComponent(_componentType);
instance = componentInstance;
// Use componentInstance so that it triggers unity's overloaded comparison operator
// So if the component is there but missing then it returns null
// (https://github.com/svermeulen/UniDi/issues/582)
if (componentInstance != null)
{
injectAction = null;
buffer.Add(instance);
return;
}
instance = gameObj.AddComponent(_componentType);
}
else
{
instance = new ValidationMarker(_componentType);
}
// Note that we don't just use InstantiateComponentOnNewGameObjectExplicit here
// because then circular references don't work
injectAction = () =>
{
var extraArgs = UniDiPools.SpawnList <TypeValuePair>();
extraArgs.AllocFreeAddRange(_extraArguments);
extraArgs.AllocFreeAddRange(args);
_container.InjectExplicit(instance, _componentType, extraArgs, context, _concreteIdentifier);
Assert.That(extraArgs.IsEmpty());
UniDiPools.DespawnList(extraArgs);
if (_instantiateCallback != null)
{
_instantiateCallback(context, instance);
}
};
buffer.Add(instance);
}
IEnumerable <InjectableInfo> GetAllInjectableIncludingBaseTypes()
{
var info = TypeAnalyzer.GetInfo(_installerType);
while (info != null)
{
foreach (var injectable in info.AllInjectables)
{
yield return(injectable);
}
info = info.BaseTypeInfo;
}
}
public void GetAllInstancesWithInjectSplit(
InjectContext context, List <TypeValuePair> args, out Action injectAction, List <object> buffer)
{
Assert.IsEmpty(args);
Assert.IsNotNull(context);
Assert.That(typeof(TReturn).DerivesFromOrEqual(context.MemberType));
injectAction = null;
if (_container.IsValidating && !TypeAnalyzer.ShouldAllowDuringValidation(context.MemberType))
{
buffer.Add(new ValidationMarker(typeof(TReturn)));
}
else
{
// We cannot do a null assert here because in some cases they might intentionally
// return null
buffer.Add(_method(context));
}
}
public void GetAllInstancesWithInjectSplit(
InjectContext context, List <TypeValuePair> args, out Action injectAction, List <object> buffer)
{
Assert.IsNotNull(context);
object instance;
// We still want to make sure we can get the game object during validation
var gameObj = GetGameObject(context);
var wasActive = gameObj.activeSelf;
if (wasActive && ShouldToggleActive)
{
// We need to do this in some cases to ensure that [Inject] always gets
// called before awake / start
gameObj.SetActive(false);
}
if (!_container.IsValidating || TypeAnalyzer.ShouldAllowDuringValidation(_componentType))
{
if (_componentType == typeof(Transform))
// Treat transform as a special case because it's the one component that's always automatically added
// Otherwise, calling AddComponent below will fail and return null
// This is nice to allow doing things like
// Container.Bind<Transform>().FromNewComponentOnNewGameObject();
{
instance = gameObj.transform;
}
else
{
instance = gameObj.AddComponent(_componentType);
}
Assert.IsNotNull(instance);
}
else
{
instance = new ValidationMarker(_componentType);
}
injectAction = () =>
{
try
{
var extraArgs = UniDiPools.SpawnList <TypeValuePair>();
extraArgs.AllocFreeAddRange(_extraArguments);
extraArgs.AllocFreeAddRange(args);
_container.InjectExplicit(instance, _componentType, extraArgs, context, _concreteIdentifier);
Assert.That(extraArgs.Count == 0);
UniDiPools.DespawnList(extraArgs);
if (_instantiateCallback != null)
{
_instantiateCallback(context, instance);
}
}
finally
{
if (wasActive && ShouldToggleActive)
{
gameObj.SetActive(true);
}
}
};
buffer.Add(instance);
}
