public virtual ITypeHandler4 CorrectHandlerVersion(ITypeHandler4 originalHandler,
     int version)
 {
     if (version >= HandlerRegistry.HandlerVersion)
     {
         return originalHandler;
     }
     if (originalHandler == null)
     {
         return null;
     }
     // HandlerVersionKey with null key will throw NPE.
     var replacement = (ITypeHandler4) _versions.Get(new HandlerVersionKey
         (this, GenericTemplate(originalHandler), version));
     if (replacement == null)
     {
         return CorrectHandlerVersion(originalHandler, version + 1);
     }
     if (replacement is IVersionedTypeHandler)
     {
         return (ITypeHandler4) ((IVersionedTypeHandler) replacement).DeepClone(new TypeHandlerCloneContext
             (_registry, originalHandler, version));
     }
     return replacement;
 }

 public HandlerVersionKey(HandlerVersionRegistry _enclosing, ITypeHandler4 handler
     , int version)
 {
     this._enclosing = _enclosing;
     _handler = handler;
     _version = version;
 }

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

 public PreparedArrayContainsComparison(IContext context, ArrayHandler arrayHandler
     , ITypeHandler4 typeHandler, object obj)
 {
     _arrayHandler = arrayHandler;
     _preparedComparison = Handlers4.PrepareComparisonFor(typeHandler, context, obj);
     _container = context.Transaction().Container();
 }

		public TypeHandlerCloneContext(HandlerRegistry handlerRegistry_, ITypeHandler4 original_
			, int version_)
		{
			handlerRegistry = handlerRegistry_;
			original = original_;
			version = version_;
		}

 private ITypeHandler4 GenericTemplate(ITypeHandler4 handler)
 {
     if (handler is IVersionedTypeHandler)
     {
         return ((IVersionedTypeHandler) handler).UnversionedTemplate();
     }
     return handler;
 }

		public virtual object ReadAtCurrentSeekPosition(ITypeHandler4 handler)
		{
			if (Handlers4.UseDedicatedSlot(this, handler))
			{
				return ReadObject();
			}
			return Handlers4.ReadValueType(this, handler);
		}

		public override bool IsIndirectedWithinSlot(ITypeHandler4 handler)
		{
			if (Handlers4.IsUntyped(handler))
			{
				return false;
			}
			return Handlers4.IsVariableLength(handler) && Handlers4.IsValueType(handler);
		}

		protected override void SeekSecondaryOffset(IReadBuffer buffer, ITypeHandler4 typeHandler
			)
		{
			if (Handlers4.HandlesPrimitiveArray(typeHandler))
			{
				buffer.Seek(buffer.ReadInt());
			}
		}

 private void RegisterTypeHandler(IConfiguration config, Type clazz, ITypeHandler4
     typeHandler)
 {
     var reflector = ((Config4Impl) config).Reflector();
     var itemClass = reflector.ForClass(clazz);
     ITypeHandlerPredicate predicate = new _ITypeHandlerPredicate_229(itemClass);
     config.RegisterTypeHandler(predicate, typeHandler);
 }

		private void WriteElements(IWriteContext context, ICollection collection, ITypeHandler4
			 elementHandler)
		{
			IEnumerator elements = collection.GetEnumerator();
			while (elements.MoveNext())
			{
				context.WriteObject(elementHandler, elements.Current);
			}
		}

 public virtual object DoWithSlotIndirection(IReadBuffer buffer, ITypeHandler4 typeHandler
     , IClosure4 closure)
 {
     if (!IsIndirectedWithinSlot(typeHandler))
     {
         return closure.Run();
     }
     return DoWithSlotIndirection(buffer, closure);
 }

		public TypeHandlerAspect(ClassMetadata classMetadata, ITypeHandler4 typeHandler)
		{
			if (Handlers4.IsValueType(typeHandler))
			{
				throw new InvalidOperationException();
			}
			_ownerMetadata = classMetadata;
			_typeHandler = typeHandler;
		}

		public object ReadObject(ITypeHandler4 handlerType)
		{
			if (null == handlerType)
			{
				throw new ArgumentNullException();
			}
			ITypeHandler4 handler = HandlerRegistry.CorrectHandlerVersion(this, handlerType);
			return SlotFormat().DoWithSlotIndirection(this, handler, new _IClosure4_38(this, 
				handler));
		}

		public static IReflectClass PrimitiveClassReflector(ITypeHandler4 handler, IReflector
			 reflector)
		{
			ITypeHandler4 baseTypeHandler = BaseTypeHandler(handler);
			if (baseTypeHandler is PrimitiveHandler)
			{
				return ((PrimitiveHandler)baseTypeHandler).PrimitiveClassReflector();
			}
			return null;
		}

		public static ITypeHandler4 BaseTypeHandler(ITypeHandler4 handler)
		{
			if (handler is ArrayHandler)
			{
				return ((ArrayHandler)handler).DelegateTypeHandler();
			}
			if (handler is PrimitiveTypeMetadata)
			{
				return ((PrimitiveTypeMetadata)handler).TypeHandler();
			}
			return handler;
		}

		public static bool IsQueryLeaf(ITypeHandler4 handler)
		{
			ITypeHandler4 baseTypeHandler = BaseTypeHandler(handler);
			if (!(baseTypeHandler is IQueryableTypeHandler))
			{
				return false;
			}
			if (baseTypeHandler is ArrayHandler)
			{
				return false;
			}
			return baseTypeHandler is IValueTypeHandler;
		}

		private static void RegisterHandlerFor(IConfiguration config, Type type, ITypeHandler4 collectionHandler)
		{
			Config4Impl configImpl = (Config4Impl)config;
			ITypeHandler4 handler = configImpl.TypeHandlerForClass(configImpl.Reflector().ForClass(type), 0);

			if (handler == null)
			{
				config.RegisterTypeHandler(new GenericTypeHandlerPredicate(type.GetGenericTypeDefinition()), collectionHandler);
				return;
			}

			if (!(handler is GenericCollectionTypeHandler))
			{
				throw new InvalidOperationException();
			}
		}

		public virtual void Delete(ITypeHandler4 handler)
		{
			ITypeHandler4 correctHandlerVersion = HandlerRegistry.CorrectHandlerVersion(this, 
				handler);
			int preservedCascadeDepth = CascadeDeleteDepth();
			CascadeDeleteDepth(AdjustedDepth());
			if (Handlers4.HandleAsObject(correctHandlerVersion))
			{
				DeleteObject();
			}
			else
			{
				correctHandlerVersion.Delete(this);
			}
			CascadeDeleteDepth(preservedCascadeDepth);
		}

 public TypeHandlerPredicatePair(ITypeHandlerPredicate predicate, ITypeHandler4 typeHandler
     )
 {
     _predicate = predicate;
     _typeHandler = typeHandler;
 }