/// <summary>
        /// Create a new ContextRuntime.
        /// </summary>
        /// <param name="serviceInjector"></param>
        /// <param name="contextConfiguration">the Configuration for this context.</param>
        /// <param name="parentContext"></param>
        public ContextRuntime(
                IInjector serviceInjector,
                IConfiguration contextConfiguration,
                Optional<ContextRuntime> parentContext)
        {
            ContextConfiguration config = contextConfiguration as ContextConfiguration;
            if (config == null)
            {
                var e = new ArgumentException("contextConfiguration is not of type ContextConfiguration");
                Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Throw(e, LOGGER);
            }
            _contextLifeCycle = new ContextLifeCycle(config.Id);
            _serviceInjector = serviceInjector;
            _parentContext = parentContext;
            try
            {
                _contextInjector = serviceInjector.ForkInjector();
            }
            catch (Exception e)
            {
                Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Caught(e, Level.Error, LOGGER);

                Optional<string> parentId = ParentContext.IsPresent() ?
                    Optional<string>.Of(ParentContext.Value.Id) :
                    Optional<string>.Empty();
                ContextClientCodeException ex = new ContextClientCodeException(ContextClientCodeException.GetId(contextConfiguration), parentId, "Unable to spawn context", e);
                
                Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Throw(ex, LOGGER);
            }
            // Trigger the context start events on contextInjector.
            _contextLifeCycle.Start();
        }

        public GroupCommClient(
            [Parameter(typeof(GroupCommConfigurationOptions.SerializedGroupConfigs))] ISet<string> groupConfigs,
            [Parameter(typeof(TaskConfigurationOptions.Identifier))] string taskId,
            StreamingNetworkService<GeneralGroupCommunicationMessage> networkService,
            AvroConfigurationSerializer configSerializer,
            IInjector injector)
        {
            _commGroups = new Dictionary<string, ICommunicationGroupClientInternal>();
            _networkService = networkService;

            foreach (string serializedGroupConfig in groupConfigs)
            {
                IConfiguration groupConfig = configSerializer.FromString(serializedGroupConfig);
                IInjector groupInjector = injector.ForkInjector(groupConfig);
                var commGroupClient = (ICommunicationGroupClientInternal)groupInjector.GetInstance<ICommunicationGroupClient>();
                _commGroups[commGroupClient.GroupName] = commGroupClient;
            }

            networkService.Register(new StringIdentifier(taskId));

            foreach (var group in _commGroups.Values)
            {
               group.WaitingForRegistration();
            }
        }

		public static bool Approve(IInjector injector, IEnumerable<object> guards)
		{
			object guardInstance;

			foreach (object guard in guards)
			{
				if (guard is Func<bool>)
				{
					if ((guard as Func<bool>)())
						continue;
					return false;
				}
				if (guard is Type)
				{
					if (injector != null)
						guardInstance = injector.InstantiateUnmapped(guard as Type);
					else
						guardInstance = Activator.CreateInstance(guard as Type);
				}
				else
					guardInstance = guard;

				MethodInfo approveMethod = guardInstance.GetType().GetMethod("Approve");
				if (approveMethod != null)
				{
					if ((bool)approveMethod.Invoke (guardInstance, null) == false)
						return false;
				}
				else
				{
					throw(new Exception (String.Format("Guard {0} is not a valid guard. It doesn't have the method 'Approve'", guardInstance)));
				}
			}
			return true;
		}

        private EvaluatorSettings(
            [Parameter(typeof(ApplicationIdentifier))] string applicationId,
            [Parameter(typeof(EvaluatorIdentifier))] string evaluatorId,
            [Parameter(typeof(EvaluatorHeartbeatPeriodInMs))] int heartbeatPeriodInMs,
            [Parameter(typeof(HeartbeatMaxRetry))] int maxHeartbeatRetries,
            [Parameter(typeof(RootContextConfiguration))] string rootContextConfigString,
            RuntimeClock clock,
            IRemoteManagerFactory remoteManagerFactory,
            REEFMessageCodec reefMessageCodec,
            IInjector injector)
        {
            _injector = injector;
            _applicationId = applicationId;
            _evaluatorId = evaluatorId;
            _heartBeatPeriodInMs = heartbeatPeriodInMs;
            _maxHeartbeatRetries = maxHeartbeatRetries;
            _clock = clock;

            if (string.IsNullOrWhiteSpace(rootContextConfigString))
            {
                Utilities.Diagnostics.Exceptions.Throw(
                    new ArgumentException("empty or null rootContextConfigString"), Logger);
            }
            _rootContextConfig = new ContextConfiguration(rootContextConfigString);
            _rootTaskConfiguration = CreateTaskConfiguration();
            _rootServiceConfiguration = CreateRootServiceConfiguration();

            _remoteManager = remoteManagerFactory.GetInstance(reefMessageCodec);
            _operationState = EvaluatorOperationState.OPERATIONAL;
        }

		/*============================================================================*/
		/* Constructor                                                                */
		/*============================================================================*/

		/**
		 * @private
		 */
		public ModuleConnector(IContext context)
		{
			IInjector injector= context.injector;
			_rootInjector = GetRootInjector(injector);
			_localDispatcher = injector.GetInstance(typeof(IEventDispatcher)) as IEventDispatcher;
			context.WhenDestroying(Destroy);
		}

        public ContextRuntime(
            string id,
            IInjector serviceInjector,
            IConfiguration contextConfiguration)
        {
            // This should only be used at the root context to support backward compatibility.
            LOGGER.Log(Level.Info, "Instantiating root context");
            _contextLifeCycle = new ContextLifeCycle(id);
            _serviceInjector = serviceInjector;
            _parentContext = Optional<ContextRuntime>.Empty();
            try
            {
                _contextInjector = serviceInjector.ForkInjector();
            }
            catch (Exception e)
            {
                Utilities.Diagnostics.Exceptions.Caught(e, Level.Error, LOGGER);

                Optional<string> parentId = ParentContext.IsPresent() ?
                    Optional<string>.Of(ParentContext.Value.Id) :
                    Optional<string>.Empty();
                ContextClientCodeException ex = new ContextClientCodeException(ContextClientCodeException.GetId(contextConfiguration), parentId, "Unable to spawn context", e);

                Utilities.Diagnostics.Exceptions.Throw(ex, LOGGER);
            }

            // Trigger the context start events on contextInjector.
            _contextLifeCycle.Start();
        }

		public static void Apply(IInjector injector, IEnumerable<object> hooks)
		{
			object hookInstance;

			foreach (object hook in hooks)
			{
				if (hook is Action)
				{
					(hook as Action)();
					continue;
				}
				if (hook is Type)
				{
					if (injector != null)
						hookInstance = injector.InstantiateUnmapped(hook as Type);
					else
						hookInstance = Activator.CreateInstance(hook as Type);
				}
				else
					hookInstance = hook;

				MethodInfo hookMethod = hookInstance.GetType().GetMethod("Hook");
				if (hookMethod != null)
					hookMethod.Invoke (hookInstance, null);
				else
					throw new Exception ("Invalid hook to apply");
			}
		}

		/*============================================================================*/
		/* Public Functions                                                           */
		/*============================================================================*/

		public void Process(object view, Type type, IInjector injector)
		{
			if(!_injectedObjects.ContainsKey(view))
			{
				InjectAndRemember(view, injector);
			}
		}

 //---------------------------------------------------------------------
 //  Constructor
 //---------------------------------------------------------------------
 /**
  * Creates a new <code>CommandMap</code> object
  *
  * @param eventDispatcher The <code>IEventDispatcher</code> to listen to
  * @param injector An <code>IInjector</code> to use for this context
  * @param reflector An <code>IReflector</code> to use for this context
  */
 public CommandMap( IEventDispatcher eventDispatcher, IInjector injector, IReflector reflector )
 {
     this.eventDispatcher = eventDispatcher;
     this.injector = injector;
     this.reflector = reflector;
     this.eventTypeMap = new Dictionary<string,Dictionary<Type, Dictionary<Type, Action<Event>>>>();
     this.verifiedCommandClasses = new Dictionary<Type,bool>();
 }

		/*============================================================================*/
		/* Constructor                                                                */
		/*============================================================================*/

		public EventCommandTrigger (IInjector injector, IEventDispatcher dispatcher, Enum type, Type eventClass = null, IEnumerable<CommandMappingList.Processor> processors = null, ILogger logger = null)
		{
			_dispatcher = dispatcher;
			_type = type;
			_eventClass = eventClass;
			_mappings = new CommandMappingList(this, processors, logger);
			_executor = new CommandExecutor(injector, _mappings.RemoveMapping);
		}

 //---------------------------------------------------------------------
 // Constructor
 //---------------------------------------------------------------------
 /**
  * Creates a new <code>ViewMap</code> object
  *
  * @param contextView The root view node of the context. The map will listen for ADDED_TO_STAGE events on this node
  * @param injector An <code>IInjector</code> to use for this context
  */
 public ViewMap( FrameworkElement contextView, IInjector injector )
     : base(contextView, injector)
 {
     // mappings - if you can do it with fewer dictionaries you get a prize
     this.mappedPackages = new List<string>();
     this.mappedTypes = new Dictionary<Type,Type>();
     this.injectedViews = new Dictionary<FrameworkElement,bool>(); //Warning was marked as weak
 }

		public void Unprocess(object view, Type type, IInjector injector)
 		{
			if (_createdMediatorsByView.ContainsKey(view))
			{
				DestroyMediator(_createdMediatorsByView[view]);
				_createdMediatorsByView.Remove(view);
			}
 		}

		/*============================================================================*/
		/* Constructor                                                                */
		/*============================================================================*/

		public MediatorFactory (IInjector injector)
		{
			_injector = injector;
			_manager = injector.HasMapping (typeof(IMediatorManager)) 
				? injector.GetInstance (typeof(IMediatorManager)) as IMediatorManager
				: new MediatorManager ();
			_manager.ViewRemoved += RemoveMediators;
		}

        //---------------------------------------------------------------------
        // Constructor
        //---------------------------------------------------------------------
        /**
         * Creates a new <code>ViewMap</code> object
         *
         * @param contextView The root view node of the context. The map will listen for ADDED_TO_STAGE events on this node
         * @param injector An <code>IInjector</code> to use for this context
         */
        public ViewMapBase( FrameworkElement contextView, IInjector injector )
        {
            this.injector = injector;

            // change this at your peril lest ye understand the problem and have a better solution
            this.useCapture = true;

            // this must come last, see the setter
            this.ContextView = contextView;
        }

		public void Setup()
		{
			injector = new RobotlegsInjector();
			viewInjector = new ViewInjectionProcessor();
			injectionValue = MapSpriteForInjection();
			view = new ViewWithInjection();
		}

		public void Setup()
		{
			injector = new robotlegs.bender.framework.impl.RobotlegsInjector();
			viewProcessorFactory = new ViewProcessorFactory(injector);
			trackingProcessor = new TrackingProcessor();
			view = new object();
		}

		public void before()
		{
			context = new Context();
			injector = context.injector;
			injector.Map<IDirectCommandMap>().ToType<DirectCommandMap>();
			subject = injector.GetInstance<IDirectCommandMap>() as DirectCommandMap;
		}

		/*============================================================================*/
		/* Public Functions                                                           */
		/*============================================================================*/

		public void Extend(IContext context)
		{
			_injector = context.injector;
			_logger = context.GetLogger(this);
			context.AfterInitializing (BeforeInitializing);
			context.AddConfigHandler(new InstanceOfMatcher (typeof(IContextView)), AddContextView);
		}

		public void Extend (IContext context)
		{
			_injector = context.injector;

			_parentFinder = new SupportParentFinder();
			_injector.Map(typeof(IParentFinder)).ToValue(_parentFinder);
			context.BeforeInitializing(BeforeInitializing);
		}

		/*============================================================================*/
		/* Public Functions                                                           */
		/*============================================================================*/

		public void Extend(IContext context)
		{
			context.BeforeInitializing(BeforeInitializing)
				.BeforeDestroying(BeforeDestroying)
				.WhenDestroying(WhenDestroying);
			_injector = context.injector;
			_injector.Map (typeof(IMediatorMap)).ToSingleton (typeof(MediatorMap));
		}