private void CascadeActivation(IActivationContext context)
		{
			IActivationDepth depth = context.Depth();
			if (!depth.RequiresActivation())
			{
				return;
			}
			if (depth.Mode().IsDeactivate())
			{
				Container().StillToDeactivate(_transaction, context.TargetObject(), depth, false);
			}
			else
			{
				// FIXME: [TA] do we really need to check for isValueType here?
				Db4objects.Db4o.Internal.ClassMetadata classMetadata = context.ClassMetadata();
				if (classMetadata.IsStruct())
				{
					classMetadata.CascadeActivation(context);
				}
				else
				{
					Container().StillToActivate(context);
				}
			}
		}

 public void CascadeActivation(IActivationContext context)
 {
     ICollection collection = ((ICollection)context.TargetObject());
     foreach (object item in collection)
     {
         context.CascadeActivationToChild(item);
     }
 }

		public override void Deactivate(IActivationContext context)
		{
			if (context.Depth().RequiresActivation())
			{
				CascadeActivation(context);
			}
			SetOn(context.Transaction(), context.TargetObject(), null);
		}

		public override void CascadeActivation(IActivationContext context)
		{
			if (!Handlers4.IsCascading(_typeHandler))
			{
				return;
			}
			Handlers4.CascadeActivation(context, _typeHandler);
		}

 public void CascadeActivation(IActivationContext context)
 {
     var all = ((ICollection) context.TargetObject()).GetEnumerator();
     while (all.MoveNext())
     {
         context.CascadeActivationToChild(all.Current);
     }
 }

		public virtual void CascadeActivation(IActivationContext context)
		{
			object targetObject = context.TargetObject();
			if (IsPlainObject(targetObject))
			{
				return;
			}
			ITypeHandler4 typeHandler = TypeHandlerForObject(targetObject);
			Handlers4.CascadeActivation(context, typeHandler);
		}

 public void CascadeActivation(IActivationContext context)
 {
     var map = (IDictionary) context.TargetObject();
     var keys = (map).Keys.GetEnumerator();
     while (keys.MoveNext())
     {
         var key = keys.Current;
         context.CascadeActivationToChild(key);
         context.CascadeActivationToChild(map[key]);
     }
 }

		public void CascadeActivation(IActivationContext context)
		{
            IEnumerable collection = ((IEnumerable)context.TargetObject());

			// TODO: detect the element type
			// and return immediately when it's a primitive

			foreach (object item in collection)
			{
				context.CascadeActivationToChild(item);
			}
		}

		public void CascadeActivation(IActivationContext context)
		{
			if (!Handlers4.IsCascading(_handler))
			{
				return;
			}
			ObjectContainerBase container = context.Container();
			IEnumerator all = AllElements(container, context.TargetObject());
			while (all.MoveNext())
			{
				context.CascadeActivationToChild(all.Current);
			}
		}

		private bool ProcessedByImmediateActivation(IActivationContext context)
		{
			if (!StackIsSmall())
			{
				return false;
			}
			if (!context.Depth().RequiresActivation())
			{
				return true;
			}
			ObjectReference @ref = context.Transaction().ReferenceForObject(context.TargetObject
				());
			if (@ref == null)
			{
				return false;
			}
			if (HandledInCurrentTopLevelCall(@ref))
			{
				return true;
			}
			FlagAsHandled(@ref);
			IncStackDepth();
			try
			{
				@ref.ActivateInternal(context);
			}
			finally
			{
				DecStackDepth();
			}
			return true;
		}

		public void StillToActivate(IActivationContext context)
		{
			// TODO: We don't want the simple classes to search the hc_tree
			// Kick them out here.
			//		if (a_object != null) {
			//			Class clazz = a_object.getClass();
			//			if(! clazz.isPrimitive()){
			if (ProcessedByImmediateActivation(context))
			{
				return;
			}
			_stillToActivate = StillTo1(context.Transaction(), _stillToActivate, context.TargetObject
				(), context.Depth());
		}

		public static void CascadeActivation(IActivationContext context, ITypeHandler4 handler
			)
		{
			if (!(handler is ICascadingTypeHandler))
			{
				return;
			}
			((ICascadingTypeHandler)handler).CascadeActivation(context);
		}

		private void EnsureObjectIsActive(IActivationContext context)
		{
			if (!context.Depth().Mode().IsActivate())
			{
				return;
			}
			if (Handlers4.IsValueType(GetHandler()))
			{
				return;
			}
			ObjectContainerBase container = context.Container();
			ClassMetadata classMetadata = container.ClassMetadataForObject(context.TargetObject
				());
			if (classMetadata == null || !classMetadata.HasIdentity())
			{
				return;
			}
			if (container.IsActive(context.TargetObject()))
			{
				return;
			}
			container.StillToActivate(context.Descend());
		}

 public virtual void CascadeActivation(IActivationContext context)
 {
     if (!ObjectCanActivate(context.Transaction(), context.TargetObject()))
     {
         return;
     }
     TraverseAllAspects(new _ITraverseAspectCommand_162(context));
 }

		private void ReadForActivation(IActivationContext context)
		{
			Read(context.Transaction(), null, context.TargetObject(), context.Depth(), Const4
				.AddMembersToIdTreeOnly, false);
		}

 public _ITraverseAspectCommand_703(IActivationContext context)
 {
     this.context = context;
 }

		internal virtual void ActivateInternal(IActivationContext context)
		{
			if (null == context)
			{
				throw new ArgumentNullException();
			}
			if (!context.Depth().RequiresActivation())
			{
				return;
			}
			ObjectContainerBase container = context.Container();
			if (context.Depth().Mode().IsRefresh())
			{
				LogActivation(container, "refresh");
			}
			else
			{
				if (IsActive())
				{
					_class.CascadeActivation(context);
					return;
				}
				LogActivation(container, "activate");
			}
			ReadForActivation(context);
		}

 public override void CascadeActivation(IActivationContext context)
 {
 }

		protected object CascadingTarget(IActivationContext context)
		{
			if (context.Depth().Mode().IsDeactivate())
			{
				if (null == _reflectField)
				{
					return null;
				}
				return FieldAccessor().Get(_reflectField, context.TargetObject());
			}
			return GetOrCreate(context.Transaction(), context.TargetObject());
		}

		// QBE constraint collection call
		// There isn't anything useful to do here, since virtual fields
		// are not on the actual object.
		public override void Deactivate(IActivationContext context)
		{
		}