Merge branch 'master' of http://github.com/cleavetv/unity-framework into architect_framework_impl

Author: cleavetv

Assets.meta

@@ -18,11 +18,19 @@ We can inject into a C# object like:
 ```
 Note: Injecting into MonoBehaviours is perfectly valid however you must Inject as a Field only. Attempting to Inject a Property into a MonoBehaviour will compile but throw an exception at runtime.
 
+### Templated Injection
+[Inject] also supports templated values, which is a value or reference type associated to a string instead of a System.Type. You can define a field or property to be injected with a template like so:
+```csharp
+[Inject("IsFoo")] public bool HasFoo {get; set;}
+```
+
 ## Injection Types
-Injection of two different variable types is supported: Singleton and Transient. 
+Injection of three different variable types is supported: Singleton, Transient, and Template.
 
 The difference between a singleton and a transient is when you define a singleton you give it an instance of an object but when you define a transient you give it a type of an object. The injector will then assign either the instance of the singleton or create a brand new instance of that transient type when it injects, depending on what was requested. 
 
+A Template is an instance of an object bound to a string, not any type, interface, or concrete. Template injection can be useful if you need to inject default values or objects that may change based on exterior circumstances like a configuration file or application state.
+
 Transient types can define default constructors through the Factory just like any other object which will be run before injection takes place.
 
 ### Singleton types:
@@ -41,7 +49,7 @@ Injector.BindSingleton<FooSystem>(myFooSystem);
 ### Transient types:
 To use a transient type we use the Injector to map a type to an implementation. A type can be a concrete implementation type or an interface.
 
-##### Give the injector a transient type:
+##### Give the Injector a transient type:
 ```csharp
 // if we don't implement any interface we can just give it the type.
 // Any object looking to inject FooSystem will receive a new FooSystem()
@@ -51,14 +59,26 @@ Injector.BindTransient<FooSystem>();
 Injector.BindTransient<IFooSystem, FooSystemImpl>();
 ```
 
+### Template types:
+To use a template type we use the Injector to map a string to an instance or value. Any value or reference type can be bound to a template.
+
+##### Give the Injector a template:
+```csharp
+Injector.BindTemplate("IsFoo", true);
+```
+
+Note I'm using bool here as a simple example but you can use this to bind any instance. Attempting to assign into to something that can't be implicitly casted from the target will cause an assertion at runtime.
+
 ##### Define an object that injects a FooSystem:
 ```csharp
 // define our object
 class ObjectA : IInitializable {
  // precede injectable types with the [Inject] attribute
  [Inject] public IFooSystem AFooSystem {get; set;} // Field or Property injection is valid here
+ [Inject("IsFoo")] public bool HasFoo {get; set;}
  void Initialize() {
- AFooSystem.SomeMethod(); // AFooSystem is resolved here already assuming ObjectA was created by Factory
+ if(HasFoo) // this is true because of templated injection
+ AFooSystem.SomeMethod(); // AFooSystem is resolved here already assuming ObjectA was created by Factory
  }
 }
 ```
@@ -70,7 +90,9 @@ var myA = Factory.Create<ObjectA>(ConstructObjectA);
 object ConstructObjectA(object obj)
 {
  var objA = obj as ObjectA;
- objA.AFooSystem.SomeMethod(); // AFooSystem is resolved here already and we can use it if we need to
+ if(objA.HasFoo) // This is true because of templated injection
+ objA.AFooSystem.SomeMethod(); // AFooSystem is resolved here already and we can use it if we need to
+ 
  return objA;
 }
 ```

CleaveFramework.unitypackage

@@ -1,6 +1,6 @@
 # SceneObjectData
 
-The SceneObjectData is a container for objects created at runtime. The container is what provides the invocation of the framework [Interfaces](Interfaces.md) available so any object you want to have the interface methods automatically invoked on needs to be inside of a SceneObjectData container. 
+The SceneObjectData is a container for objects created at runtime. The container is what provides the invocation of the framework [Interfaces](Interfaces.md) available so any object you want to have the interface methods automatically invoked on needs to be inside of an initialized, updating, and destroyed SceneObjectData container. This is done behind the scenes for the `SceneView` instance of SceneObjectData but it's important to note in case you want to reuse this object elsewhere.
 
 ## `InitializeSceneObjects()`
 
@@ -18,13 +18,14 @@ Calling `Update(deltaTime)` on the SceneObjectData instance will invoke the `Upd
 
 Calling `Destroy()` on the SceneObjectData will invoke the `Destroy()` method on all contained objects implementing the `IDestroyable` interface. It will also clear all the containers and reset the initialization state of the object to false allowing you to re-use it with new object data if you want to.
 
-## SceneDataObject contained object types
+## Example code
 
 For the following examples assume we have access to a SceneObjectData defined like:
 ```csharp
 public SceneObjectData SceneObjects;
 ```
 
+
 ### Singleton
 
 A SceneObjects Singleton type is a 1-to-1 mapping of a System.Type to an instance of that type. 
@@ -59,6 +60,8 @@ for(var i = 0; i < 5; i++) {
 ```
 
 #### Resolve a transient
+
+##### By Name:
 ```csharp
 // resolve instances of Foo named Foo0 through Foo4
 List<Foo> fooList = new List<Foo>();
@@ -67,3 +70,36 @@ for(var i = 0; i < 5; i++) {
 }
 ```
 
+##### By Type:
+```csharp
+// return every transient object of type Foo found in the data and map it's name to it's instance
+KeyValuePair<string, object> [] foosArray = SceneObjects.ResolveTransient<Foo>();
+```
+
+### Removing Objects from the data
+
+Upon removal of the object from the data `Destroy()` will be invoked on the object before it is returned. 
+
+Depending on the type the technique to remove the data varies:
+
+#### Removing Singletons
+
+A singleton can be removed or replaced by simply binding over it with another instance of the same object type or by binding it to `null`. Obviously no object will be returned here so be sure to cache the reference or destruct it properly before binding over it. For example:
+
+```csharp
+var oldFoo = SceneObjects.ResolveSingleton<IFoo>();
+FoosFriends.SayGoodbye(oldFoo);
+var newFoo = SceneObjects.PushSingleton<IFoo>(new DifferentFooImpl()); // oldFoo.Destroy() method was invoked now
+FoosFriends.SayHello(newFoo);
+```
+
+#### Removing Transients
+
+A transient can be removed by calling `PopTransient<T>(string ...)` on the SceneObjectData. For example:
+
+```csharp
+// pop an object of type People named "Jeff" out of the data:
+var jeff = SceneObjects.PopTransient<People>("Jeff"); // jeff.Destroy() was invoked now
+```
+
+

CleaveFramework.unitypackage.meta

@@ -1,21 +1,25 @@
-# CleaveFramework v0.2.2
+# CleaveFramework v0.2.4
 
 A Unity3D C# application framework.
 
 ## Quick Feature Overview
 
  * Unity Scene Management
  - Transitional Loading Scenes
- * C# Object Management with modular Interface support
+ * POCO Object Management with modular Interface support
  - Global Objects
  * Resolve object instances across your entire application in any scene or class
  - Scene Objects
  * Resolve scene specific object instances in any class
- - Automatically Update Objects
- * Object Manager takes care of updating objects that require it for you. Stops you from creating general objects specifically to manage other objects.
+ - Reusable object container
+ * Add, remove, or resolve objects of any type at any time.
+ * Automatically initialize, update, and destroy objects.
  * Object Creation Factory supports C# Objects and Unity Component Attachments
  - Attach Constructors to MonoBehaviour Components
  * Automated Dependency Injection Module
+ - Supports Field or Property injection into POCOs or MonoBehaviours 
+ * Bind interfaces to implementations
+ * Binding of templated value or reference types to parameterized members
  * Global Application level Executable Command Queuing System
  - Reuse the Command Framework and Executable Command Queue Object in your own implementations with minimal code.
  * Private Command Subscription for Multi-Delegate Callbacks