public GameObjectNameGroupNameScopeArgBinder FromGameObject()
{
BindingUtil.AssertIsAbstractOrComponentOrGameObject(BindInfo.ContractTypes);
BindingUtil.AssertIsComponentOrGameObject(ConcreteTypes);
var gameObjectInfo = new GameObjectCreationParameters();
if (ConcreteTypes.All(x => x == typeof(GameObject)))
{
SubFinalizer = new ScopableBindingFinalizer(
BindInfo, SingletonTypes.ToGameObject, gameObjectInfo,
(container, type) =>
{
Assert.That(BindInfo.Arguments.IsEmpty(), "Cannot inject arguments into empty game object");
return(new EmptyGameObjectProvider(
container, gameObjectInfo));
});
}
else
{
BindingUtil.AssertIsComponent(ConcreteTypes);
BindingUtil.AssertTypesAreNotAbstract(ConcreteTypes);
SubFinalizer = new ScopableBindingFinalizer(
BindInfo, SingletonTypes.ToGameObject, gameObjectInfo,
(container, type) => new AddToNewGameObjectComponentProvider(
container,
type,
BindInfo.ConcreteIdentifier,
BindInfo.Arguments,
gameObjectInfo));
}
return(new GameObjectNameGroupNameScopeArgBinder(BindInfo, gameObjectInfo));
}
public ConditionCopyNonLazyBinder FromComponentOn(Func <InjectContext, GameObject> gameObjectGetter)
{
BindingUtil.AssertIsComponent(ContractType);
BindingUtil.AssertIsNotAbstract(ContractType);
ProviderFunc =
(container) => new GetFromGameObjectGetterComponentProvider(
ContractType, gameObjectGetter, true);
return(this);
}
public ArgumentsBinder FromSiblingComponent()
{
BindingUtil.AssertIsComponent(ConcreteTypes);
BindingUtil.AssertTypesAreNotAbstract(ConcreteTypes);
SubFinalizer = new SingleProviderBindingFinalizer(
BindInfo, (container, type) => new AddToCurrentGameObjectComponentProvider(
container, type, BindInfo.ConcreteIdentifier, BindInfo.Arguments));
return(new ArgumentsBinder(BindInfo));
}
public ScopeConcreteIdArgConditionCopyNonLazyBinder FromNewComponentSibling()
{
BindingUtil.AssertIsComponent(ConcreteTypes);
BindingUtil.AssertTypesAreNotAbstract(ConcreteTypes);
BindInfo.RequireExplicitScope = true;
SubFinalizer = new SingleProviderBindingFinalizer(
BindInfo, (container, type) => new AddToCurrentGameObjectComponentProvider(
container, type, BindInfo.Arguments, BindInfo.ConcreteIdentifier, BindInfo.InstantiatedCallback));
return(new ScopeConcreteIdArgConditionCopyNonLazyBinder(BindInfo));
}
public ConditionCopyNonLazyBinder FromComponentOn(GameObject gameObject)
{
BindingUtil.AssertIsValidGameObject(gameObject);
BindingUtil.AssertIsComponent(ContractType);
BindingUtil.AssertIsNotAbstract(ContractType);
ProviderFunc =
(container) => new GetFromGameObjectComponentProvider(
ContractType, gameObject, true);
return(this);
}
public ConditionCopyNonLazyBinder FromNewComponentOn(GameObject gameObject)
{
BindingUtil.AssertIsValidGameObject(gameObject);
BindingUtil.AssertIsComponent(ContractType);
BindingUtil.AssertIsNotAbstract(ContractType);
ProviderFunc =
(container) => new AddToExistingGameObjectComponentProvider(
gameObject, container, ContractType,
BindInfo.Arguments, BindInfo.ConcreteIdentifier, BindInfo.InstantiatedCallback);
return(this);
}
public ConditionCopyNonLazyBinder FromNewComponentOn(
Func <InjectContext, GameObject> gameObjectGetter)
{
BindingUtil.AssertIsComponent(ContractType);
BindingUtil.AssertIsNotAbstract(ContractType);
ProviderFunc =
(container) => new AddToExistingGameObjectComponentProviderGetter(
gameObjectGetter, container, ContractType,
new List <TypeValuePair>(), BindInfo.ConcreteIdentifier, BindInfo.InstantiatedCallback);
return(this);
}
public ScopeArgBinder FromComponent(GameObject gameObject)
{
BindingUtil.AssertIsValidGameObject(gameObject);
BindingUtil.AssertIsComponent(ConcreteTypes);
BindingUtil.AssertTypesAreNotAbstract(ConcreteTypes);
SubFinalizer = new ScopableBindingFinalizer(
BindInfo, SingletonTypes.ToComponentGameObject, gameObject,
(container, type) => new AddToExistingGameObjectComponentProvider(
gameObject, container, type, BindInfo.ConcreteIdentifier, BindInfo.Arguments));
return(new ScopeArgBinder(BindInfo));
}
public ScopeConcreteIdArgConditionCopyNonLazyBinder FromNewComponentOn(Func <InjectContext, GameObject> gameObjectGetter)
{
BindingUtil.AssertIsComponent(ConcreteTypes);
BindingUtil.AssertTypesAreNotAbstract(ConcreteTypes);
BindInfo.RequireExplicitScope = true;
SubFinalizer = new ScopableBindingFinalizer(
BindInfo,
(container, type) => new AddToExistingGameObjectComponentProviderGetter(
gameObjectGetter, container, type, BindInfo.Arguments, BindInfo.ConcreteIdentifier, BindInfo.InstantiatedCallback));
return(new ScopeConcreteIdArgConditionCopyNonLazyBinder(BindInfo));
}
public ConditionBinder FromComponent(GameObject gameObject)
{
BindingUtil.AssertIsValidGameObject(gameObject);
BindingUtil.AssertIsComponent(ContractType);
BindingUtil.AssertIsNotAbstract(ContractType);
SubFinalizer = CreateFinalizer(
(container) => new AddToExistingGameObjectComponentProvider(
gameObject, container, ContractType,
null, new List <TypeValuePair>()));
return(this);
}
public ScopeConcreteIdArgConditionCopyNonLazyBinder FromComponentOn(Func <InjectContext, GameObject> gameObjectGetter)
{
BindingUtil.AssertIsComponent(ConcreteTypes);
BindingUtil.AssertTypesAreNotAbstract(ConcreteTypes);
BindInfo.RequireExplicitScope = false;
SubFinalizer = new ScopableBindingFinalizer(
BindInfo,
(container, type) => new GetFromGameObjectGetterComponentProvider(
type, gameObjectGetter, true));
return(new ScopeConcreteIdArgConditionCopyNonLazyBinder(BindInfo));
}
public ConditionCopyNonLazyBinder FromNewComponentOn(GameObject gameObject)
{
BindingUtil.AssertIsValidGameObject(gameObject);
BindingUtil.AssertIsComponent(ContractType);
BindingUtil.AssertIsNotAbstract(ContractType);
ProviderFunc =
(container) => new AddToExistingGameObjectComponentProvider(
gameObject, container, ContractType,
null, new List <TypeValuePair>());
return(this);
}
internal NameTransformScopeConcreteIdArgConditionCopyNonLazyBinder FromNewComponentOnNewPrefabResource(
string resourcePath, GameObjectCreationParameters gameObjectInfo)
{
BindingUtil.AssertIsValidResourcePath(resourcePath);
BindingUtil.AssertIsComponent(ConcreteTypes);
BindingUtil.AssertTypesAreNotAbstract(ConcreteTypes);
BindInfo.RequireExplicitScope = true;
SubFinalizer = new PrefabResourceBindingFinalizer(
BindInfo, gameObjectInfo, resourcePath,
(contractType, instantiator) => new InstantiateOnPrefabComponentProvider(contractType, instantiator));
return(new NameTransformScopeConcreteIdArgConditionCopyNonLazyBinder(BindInfo, gameObjectInfo));
}
internal NameTransformScopeArgConditionCopyNonLazyBinder FromNewComponentOnNewPrefab(
UnityEngine.Object prefab, GameObjectCreationParameters gameObjectInfo)
{
BindingUtil.AssertIsValidPrefab(prefab);
BindingUtil.AssertIsComponent(ConcreteTypes);
BindingUtil.AssertTypesAreNotAbstract(ConcreteTypes);
BindInfo.RequireExplicitScope = true;
SubFinalizer = new PrefabBindingFinalizer(
BindInfo, gameObjectInfo, prefab,
(contractType, instantiator) => new InstantiateOnPrefabComponentProvider(contractType, instantiator));
return(new NameTransformScopeArgConditionCopyNonLazyBinder(BindInfo, gameObjectInfo));
}
public ScopeConcreteIdArgConditionCopyNonLazyBinder FromComponentsOn(GameObject gameObject)
{
BindingUtil.AssertIsValidGameObject(gameObject);
BindingUtil.AssertIsComponent(ConcreteTypes);
BindingUtil.AssertTypesAreNotAbstract(ConcreteTypes);
BindInfo.RequireExplicitScope = true;
SubFinalizer = new ScopableBindingFinalizer(
BindInfo,
(container, type) => new GetFromGameObjectComponentProvider(
type, gameObject, false));
return(new ScopeConcreteIdArgConditionCopyNonLazyBinder(BindInfo));
}
public ScopeConcreteIdArgConditionCopyNonLazyBinder FromNewComponentOn(GameObject gameObject)
{
BindingUtil.AssertIsValidGameObject(gameObject);
BindingUtil.AssertIsComponent(ConcreteTypes);
BindingUtil.AssertTypesAreNotAbstract(ConcreteTypes);
BindInfo.RequireExplicitScope = true;
SubFinalizer = new ScopableBindingFinalizer(
BindInfo,
(container, type) => new AddToExistingGameObjectComponentProvider(
gameObject, container, type, BindInfo.Arguments, BindInfo.ConcreteIdentifier));
return(new ScopeConcreteIdArgConditionCopyNonLazyBinder(BindInfo));
}
public NameTransformScopeConcreteIdArgConditionCopyNonLazyBinder FromNewComponentOnNewGameObject()
{
BindingUtil.AssertIsComponent(ContractType);
BindingUtil.AssertIsNotAbstract(ContractType);
var gameObjectInfo = new GameObjectCreationParameters();
ProviderFunc =
(container) => new AddToNewGameObjectComponentProvider(
container, ContractType,
new List <TypeValuePair>(), gameObjectInfo, BindInfo.ConcreteIdentifier, BindInfo.InstantiatedCallback);
return(new NameTransformScopeConcreteIdArgConditionCopyNonLazyBinder(BindInfo, gameObjectInfo));
}
public NameTransformConditionCopyNonLazyBinder FromNewComponentOnNewGameObject()
{
BindingUtil.AssertIsComponent(ContractType);
BindingUtil.AssertIsNotAbstract(ContractType);
var gameObjectInfo = new GameObjectCreationParameters();
ProviderFunc =
(container) => new AddToNewGameObjectComponentProvider(
container, ContractType, null,
new List <TypeValuePair>(), gameObjectInfo);
return(new NameTransformConditionCopyNonLazyBinder(BindInfo, gameObjectInfo));
}
public NameTransformConditionCopyNonLazyBinder FromNewComponentOnNewPrefab(UnityEngine.Object prefab)
{
BindingUtil.AssertIsValidPrefab(prefab);
BindingUtil.AssertIsComponent(ContractType);
BindingUtil.AssertIsNotAbstract(ContractType);
GameObjectCreationParameters gameObjectInfo = new GameObjectCreationParameters();
ProviderFunc =
(container) => new InstantiateOnPrefabComponentProvider(
ContractType,
new PrefabInstantiator(
container, gameObjectInfo,
ContractType, new List <TypeValuePair>(), new PrefabProvider(prefab)));
return(new NameTransformConditionCopyNonLazyBinder(BindInfo, gameObjectInfo));
}
internal NameTransformScopeConcreteIdArgConditionCopyNonLazyBinder FromNewComponentOnNewGameObject(
GameObjectCreationParameters gameObjectInfo)
{
BindingUtil.AssertIsComponent(ConcreteTypes);
BindingUtil.AssertTypesAreNotAbstract(ConcreteTypes);
BindInfo.RequireExplicitScope = true;
SubFinalizer = new ScopableBindingFinalizer(
BindInfo,
(container, type) => new AddToNewGameObjectComponentProvider(
container,
type,
BindInfo.Arguments,
gameObjectInfo, BindInfo.ConcreteIdentifier, BindInfo.InstantiatedCallback));
return(new NameTransformScopeConcreteIdArgConditionCopyNonLazyBinder(BindInfo, gameObjectInfo));
}
public NameTransformConditionCopyNonLazyBinder FromNewComponentOnNewPrefabResource(string resourcePath)
{
BindingUtil.AssertIsValidResourcePath(resourcePath);
BindingUtil.AssertIsComponent(ContractType);
BindingUtil.AssertIsNotAbstract(ContractType);
var gameObjectInfo = new GameObjectCreationParameters();
ProviderFunc =
(container) => new InstantiateOnPrefabComponentProvider(
ContractType,
new PrefabInstantiator(
container, gameObjectInfo,
ContractType, new List <TypeValuePair>(), new PrefabProviderResource(resourcePath)));
return(new NameTransformConditionCopyNonLazyBinder(BindInfo, gameObjectInfo));
}
public NameTransformScopeConcreteIdArgConditionCopyNonLazyBinder FromNewComponentOnNewPrefab(UnityEngine.Object prefab)
{
BindingUtil.AssertIsValidPrefab(prefab);
BindingUtil.AssertIsComponent(ContractType);
BindingUtil.AssertIsNotAbstract(ContractType);
var gameObjectInfo = new GameObjectCreationParameters();
ProviderFunc =
(container) => new InstantiateOnPrefabComponentProvider(
ContractType,
new PrefabInstantiator(
container, gameObjectInfo,
ContractType, new [] { ContractType }, BindInfo.Arguments,
new PrefabProvider(prefab), BindInfo.InstantiatedCallback));
return(new NameTransformScopeConcreteIdArgConditionCopyNonLazyBinder(BindInfo, gameObjectInfo));
}
public GameObjectNameGroupNameBinder FromGameObject()
{
var gameObjectInfo = new GameObjectBindInfo();
if (ContractType == typeof(GameObject))
{
SubFinalizer = CreateFinalizer(
(container) => new EmptyGameObjectProvider(
container, gameObjectInfo.Name, gameObjectInfo.GroupName));
}
else
{
BindingUtil.AssertIsComponent(ContractType);
BindingUtil.AssertIsNotAbstract(ContractType);
SubFinalizer = CreateFinalizer(
(container) => new AddToNewGameObjectComponentProvider(
container, ContractType, null,
new List <TypeValuePair>(), gameObjectInfo.Name, gameObjectInfo.GroupName));
}
return(new GameObjectNameGroupNameBinder(BindInfo, gameObjectInfo));
}
