//    	throw new IllegalStateException();
 public virtual void CollectIDs(QueryingReadContext readContext)
 {
     IInternalReadContext context = readContext;
     var payloadOffset = context.ReadInt();
     if (payloadOffset == 0)
     {
         return;
     }
     var savedOffSet = context.Offset();
     try
     {
         var typeHandler = ReadTypeHandler(context, payloadOffset);
         if (typeHandler == null)
         {
             return;
         }
         SeekSecondaryOffset(context, typeHandler);
         if (IsPlainObject(typeHandler))
         {
             readContext.Collector().AddId(readContext.ReadInt());
             return;
         }
         CollectIdContext collectIdContext = new _CollectIdContext_203(readContext, readContext
             .Transaction(), readContext.Collector(), null, readContext.Buffer());
         Handlers4.CollectIdsInternal(collectIdContext, context.Container().Handlers.CorrectHandlerVersion
             (typeHandler, context.HandlerVersion()), 0, false);
     }
     finally
     {
         context.Seek(savedOffSet);
     }
 }

			public object Run()
			{
				QueryingReadContext queryingReadContext = new QueryingReadContext(context.Transaction
					(), context.HandlerVersion(), context.Buffer(), 0, context.Collector());
				((ICascadingTypeHandler)this._enclosing._typeHandler).CollectIDs(queryingReadContext
					);
				return null;
			}

		public virtual void CollectIDs(QueryingReadContext context)
		{
			ITypeHandler4 elementHandler = ReadElementTypeHandler(context, context);
			int elementCount = context.ReadInt();
			for (int i = 0; i < elementCount; i++)
			{
				context.ReadId(elementHandler);
			}
		}

 public virtual void CollectIDs(QueryingReadContext context)
 {
     var handlers = ReadKeyValueTypeHandlers(context, context);
     var elementCount = context.ReadInt();
     for (var i = 0; i < elementCount; i++)
     {
         context.ReadId(handlers._keyHandler);
         context.SkipId(handlers._valueHandler);
     }
 }

		public virtual ITypeHandler4 ReadCandidateHandler(QueryingReadContext context)
		{
			int payLoadOffSet = context.ReadInt();
			if (payLoadOffSet == 0)
			{
				return null;
			}
			context.Seek(payLoadOffSet);
			int classMetadataID = context.ReadInt();
			ClassMetadata classMetadata = context.Container().ClassMetadataForID(classMetadataID
				);
			if (classMetadata == null)
			{
				return null;
			}
			return classMetadata.ReadCandidateHandler(context);
		}

		public override ITypeHandler4 ReadCandidateHandler(QueryingReadContext context)
		{
			int id = 0;
			int offset = context.Offset();
			try
			{
				id = context.ReadInt();
			}
			catch (Exception)
			{
			}
			context.Seek(offset);
			if (id != 0)
			{
				StatefulBuffer reader = context.Container().ReadStatefulBufferById(context.Transaction
					(), id);
				if (reader != null)
				{
					ObjectHeader oh = new ObjectHeader(context.Container(), reader);
					try
					{
						if (oh.ClassMetadata() != null)
						{
							context.Buffer(reader);
							return oh.ClassMetadata().SeekCandidateHandler(context);
						}
					}
					catch (Exception e)
					{
					}
				}
			}
			// TODO: Check Exception Types
			// Errors typically occur, if classes don't match
			return null;
		}

 // TODO Auto-generated method stub
 public virtual ITypeHandler4 ReadCandidateHandler(QueryingReadContext context)
 {
     // TODO Auto-generated method stub
     return null;
 }

 // TODO Auto-generated method stub
 public virtual void CollectIDs(QueryingReadContext context)
 {
 }

 private object ReadFieldValue(int id, FieldMetadata field)
 {
     var buffer = BufferFor(id);
     var handlerVersion = field.ContainingClass().SeekToField(_transaction,
         buffer, field);
     if (handlerVersion == HandlerVersion.Invalid)
     {
         return null;
     }
     var context = new QueryingReadContext(_transaction, handlerVersion
         ._number, buffer, id);
     return field.Read(context);
 }

			public _CollectIdContext_203(QueryingReadContext readContext, Transaction baseArg1
				, IdObjectCollector baseArg2, ObjectHeader baseArg3, IReadBuffer baseArg4) : base
				(baseArg1, baseArg2, baseArg3, baseArg4)
			{
				this.readContext = readContext;
			}

		public static void CollectIdsInternal(CollectIdContext context, ITypeHandler4 handler
			, int linkLength, bool doWithSlotIndirection)
		{
			if (!(IsCascading(handler)))
			{
				IReadBuffer buffer = context.Buffer();
				buffer.Seek(buffer.Offset() + linkLength);
				return;
			}
			if (handler is StandardReferenceTypeHandler)
			{
				context.AddId();
				return;
			}
			LocalObjectContainer container = (LocalObjectContainer)context.Container();
			SlotFormat slotFormat = context.SlotFormat();
			if (HandleAsObject(handler))
			{
				// TODO: Code is similar to QCandidate.readArrayCandidates. Try to refactor to one place.
				int collectionID = context.ReadInt();
				ByteArrayBuffer collectionBuffer = container.ReadBufferById(context.Transaction()
					, collectionID);
				ObjectHeader objectHeader = new ObjectHeader(container, collectionBuffer);
				QueryingReadContext subContext = new QueryingReadContext(context.Transaction(), context
					.HandlerVersion(), collectionBuffer, collectionID, context.Collector());
				objectHeader.ClassMetadata().CollectIDs(subContext);
				return;
			}
			QueryingReadContext queryingReadContext = new QueryingReadContext(context.Transaction
				(), context.HandlerVersion(), context.Buffer(), 0, context.Collector());
			IClosure4 collectIDsFromQueryingContext = new _IClosure4_263(handler, queryingReadContext
				);
			if (doWithSlotIndirection)
			{
				slotFormat.DoWithSlotIndirection(queryingReadContext, handler, collectIDsFromQueryingContext
					);
			}
			else
			{
				collectIDsFromQueryingContext.Run();
			}
		}

		public static void CollectIDs(QueryingReadContext context, ITypeHandler4 typeHandler
			)
		{
			if (typeHandler is ICascadingTypeHandler)
			{
				((ICascadingTypeHandler)typeHandler).CollectIDs(context);
			}
		}

 public _IVisitor4_390(QueryingReadContext context)
 {
     this.context = context;
 }

 /// <exception cref="Db4objects.Db4o.Ext.Db4oIOException"></exception>
 private bool CollectIDsByTypehandlerAspect(QueryingReadContext context)
 {
     var aspectFound = new BooleanByRef(false);
     var subContext = CollectIdContext.ForID(context.Transaction(), context
         .Collector(), context.CollectionID());
     ITraverseAspectCommand command = new _MarshallingInfoTraverseAspectCommand_349(this
         , aspectFound, subContext, EnsureFieldList(subContext));
     TraverseAllAspects(subContext, command);
     return aspectFound.value;
 }

 /// <exception cref="Db4objects.Db4o.Ext.Db4oIOException"></exception>
 private void CollectIDsByInstantiatingCollection(QueryingReadContext context)
 {
     var id = context.CollectionID();
     if (id == 0)
     {
         return;
     }
     var transaction = context.Transaction();
     var container = context.Container();
     var obj = container.GetByID(transaction, id);
     if (obj == null)
     {
         return;
     }
     // FIXME: [TA] review activation depth
     var depth = DepthUtil.AdjustDepthToBorders(2);
     container.Activate(transaction, obj, container.ActivationDepthProvider().ActivationDepth
         (depth, ActivationMode.Activate));
     Platform4.ForEachCollectionElement(obj, new _IVisitor4_390(context));
 }

 /// <exception cref="Db4objects.Db4o.Ext.Db4oIOException"></exception>
 public virtual void CollectIDs(QueryingReadContext context)
 {
     if (CollectIDsByTypehandlerAspect(context))
     {
         return;
     }
     CollectIDsByInstantiatingCollection(context);
 }

 public virtual ITypeHandler4 ReadCandidateHandler(QueryingReadContext context)
 {
     if (ClassMetadata().IsArray())
     {
         return this;
     }
     return null;
 }

 public virtual void CollectIDs(QueryingReadContext context)
 {
     throw new NotImplementedException();
 }

 public virtual ITypeHandler4 ReadCandidateHandler(QueryingReadContext context)
 {
     return this;
 }

			public _IRunnable_71(QueryingReadContext context, ITypeHandler4 handler)
			{
				this.context = context;
				this.handler = handler;
			}