public DeleteContextImpl(Db4objects.Db4o.Internal.StatefulBuffer buffer, ObjectHeader
			 objectHeader, IReflectClass fieldClass, Config4Field fieldConfig) : base(buffer
			.Transaction(), buffer, objectHeader)
		{
			_fieldClass = fieldClass;
			_fieldConfig = fieldConfig;
		}

 private void ThrowUnsupportedAdd(IReflectClass runtimeAncestor)
 {
     throw new InvalidOperationException("Unsupported class hierarchy change. Class "
                                         + runtimeAncestor.GetName() + " was added to hierarchy of " +
                                         _runtimeClass.GetName
                                             ());
 }

		internal QConClass(Transaction trans, QCon parent, QField field, IReflectClass claxx
			) : base(trans, parent, field, null)
		{
			// C/S
			if (claxx != null)
			{
				ObjectContainerBase container = trans.Container();
				_classMetadata = container.ClassMetadataForReflectClass(claxx);
				if (_classMetadata == null)
				{
					// could be an aliased class, try to resolve.
					string className = claxx.GetName();
					string aliasRunTimeName = container.Config().ResolveAliasStoredName(className);
					if (!className.Equals(aliasRunTimeName))
					{
						_classMetadata = container.ClassMetadataForName(aliasRunTimeName);
					}
				}
				if (claxx.Equals(container._handlers.IclassObject))
				{
					_classMetadata = (ClassMetadata)_classMetadata.TypeHandler();
				}
			}
			_claxx = claxx;
		}

 public PrimitiveTypeMetadata(ObjectContainerBase container, ITypeHandler4 handler
     , int id, IReflectClass classReflector) : base(container, classReflector)
 {
     _aspects = FieldMetadata.EmptyArray;
     _typeHandler = handler;
     _id = id;
 }

		private void AssertKnownClasses(IReflectClass[] knownClasses)
		{
			for (int i = 0; i < knownClasses.Length; i++)
			{
				Assert.AreNotEqual(FullyQualifiedName(typeof(StoredClassFilterTestCase.SimpleClass
					)), knownClasses[i].GetName());
			}
		}

		public SelfField(string name, IReflectClass type, SelfClass selfclass, SelfReflectionRegistry
			 registry)
		{
			_name = name;
			_type = type;
			_selfclass = selfclass;
			_registry = registry;
		}

 public virtual IReflectClass GetComponentType(IReflectClass a_class)
 {
     while (a_class.IsArray())
     {
         a_class = a_class.GetComponentType();
     }
     return a_class;
 }

 private void AssertKnownClasses(IReflectClass[] knownClasses)
 {
     for (var i = 0; i < knownClasses.Length; i++)
     {
         Assert.AreNotEqual(FullyQualifiedName(typeof (SimpleClass
             )), knownClasses[i].GetName());
     }
 }

		public virtual bool CanHandleClass(IReflectClass claxx)
		{
			if (_mapHandler.CanHandleClass(claxx))
			{
				return true;
			}
			return ReplicationPlatform.IsBuiltinCollectionClass(_reflector, claxx);
		}

		public virtual IReflectClass ClassReflector(IReflector reflector)
		{
			if (_classReflector == null)
			{
				_classReflector = ((IBuiltinTypeHandler)GetHandler()).ClassReflector();
			}
			return _classReflector;
		}

		public virtual bool IsNDimensional(IReflectClass a_class)
		{
			if (a_class is GenericArrayClass)
			{
				return false;
			}
			return _delegate.IsNDimensional(a_class.GetDelegate());
		}

		public virtual object CloneWithCounterparts(ICollectionSource sourceProvider, object
			 originalMap, IReflectClass claxx, ICounterpartFinder elementCloner)
		{
			IDictionary original = (IDictionary)originalMap;
			IDictionary result = (IDictionary)EmptyClone(sourceProvider, original, claxx);
			CopyState(original, result, elementCloner);
			return result;
		}

 private ITypeDescription CreateArrayType(TypeName fullName,
     IReflectClass classInfo, Func<TypeName, Maybe<IReflectClass>> classLookup,
     IDictionary<string, ITypeDescription> knownTypes)
 {
     var innerType = GetOrCreateType(classInfo.GetComponentType(), classLookup, knownTypes);
     var type = ArrayDescription.Create(innerType, fullName.OrderOfArray);
     knownTypes[fullName.FullName] = type;
     return type;
 }

		public virtual object EmptyClone(ICollectionSource sourceProvider, object original
			, IReflectClass originalCollectionClass)
		{
			if (sourceProvider.IsProviderSpecific(original) || original is Hashtable)
			{
				return new Hashtable(((IDictionary)original).Count);
			}
			return _reflector.ForObject(original).NewInstance();
		}

		private void TraverseSuperclass(object @object, IReflectClass claxx)
		{
			IReflectClass superclass = claxx.GetSuperclass();
			if (superclass == null)
			{
				return;
			}
			TraverseAllFields(@object, superclass);
		}

		public virtual bool CallConstructor(IReflectClass clazz)
		{
			TernaryBool specialized = CallConstructorSpecialized(clazz);
			if (!specialized.IsUnspecified())
			{
				return specialized.DefiniteYes();
			}
			return _config.CallConstructors().DefiniteYes();
		}

		public virtual object NewInstance(IReflectClass componentType, int length)
		{
			componentType = componentType.GetDelegate();
			if (componentType is GenericClass)
			{
				return new GenericArray(((GenericClass)componentType).ArrayClass(), length);
			}
			return _delegate.NewInstance(componentType, length);
		}

		public GenericClass(GenericReflector reflector, IReflectClass delegateClass, string
			 name, Db4objects.Db4o.Reflect.Generic.GenericClass superclass)
		{
			_reflector = reflector;
			_delegate = delegateClass;
			_name = name;
			_superclass = superclass;
			_hashCode = _name.GetHashCode();
		}

		public virtual IReflectClass GetComponentType(IReflectClass claxx)
		{
			claxx = claxx.GetDelegate();
			if (claxx is GenericClass)
			{
				return claxx;
			}
			return _delegate.GetComponentType(claxx);
		}

 private static TypeName NameOf(IReflectClass typeToFind)
 {
     var name = TypeNameParser.ParseString(typeToFind.GetName());
     if (typeToFind.IsArray() && !name.ArrayOf.HasValue)
     {
         return TypeName.CreateArrayOf(name, 1);
     }
     return name;
 }