public TypeHandlerCloneContext(HandlerRegistry handlerRegistry_, ITypeHandler4 original_
, int version_)
{
handlerRegistry = handlerRegistry_;
original = original_;
version = version_;
}
public PreparedArrayContainsComparison(IContext context, ArrayHandler arrayHandler
, ITypeHandler4 typeHandler, object obj)
{
_arrayHandler = arrayHandler;
_preparedComparison = Handlers4.PrepareComparisonFor(typeHandler, context, obj);
_container = context.Transaction().Container();
}
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 virtual object ReadAtCurrentSeekPosition(ITypeHandler4 handler)
{
if (Handlers4.UseDedicatedSlot(this, handler))
{
return ReadObject();
}
return Handlers4.ReadValueType(this, handler);
}
private ITypeHandler4 GenericTemplate(ITypeHandler4 handler)
{
if (handler is IVersionedTypeHandler)
{
return ((IVersionedTypeHandler) handler).UnversionedTemplate();
}
return handler;
}
protected override void SeekSecondaryOffset(IReadBuffer buffer, ITypeHandler4 typeHandler
)
{
if (Handlers4.HandlesPrimitiveArray(typeHandler))
{
buffer.Seek(buffer.ReadInt());
}
}
public override bool IsIndirectedWithinSlot(ITypeHandler4 handler)
{
if (Handlers4.IsUntyped(handler))
{
return false;
}
return Handlers4.IsVariableLength(handler) && Handlers4.IsValueType(handler);
}
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);
}
public TypeHandlerAspect(ClassMetadata classMetadata, ITypeHandler4 typeHandler)
{
if (Handlers4.IsValueType(typeHandler))
{
throw new InvalidOperationException();
}
_ownerMetadata = classMetadata;
_typeHandler = typeHandler;
}
public virtual object DoWithSlotIndirection(IReadBuffer buffer, ITypeHandler4 typeHandler
, IClosure4 closure)
{
if (!IsIndirectedWithinSlot(typeHandler))
{
return closure.Run();
}
return DoWithSlotIndirection(buffer, closure);
}
private void WriteElements(IWriteContext context, ICollection collection, ITypeHandler4
elementHandler)
{
IEnumerator elements = collection.GetEnumerator();
while (elements.MoveNext())
{
context.WriteObject(elementHandler, elements.Current);
}
}
public static IReflectClass PrimitiveClassReflector(ITypeHandler4 handler, IReflector
reflector)
{
ITypeHandler4 baseTypeHandler = BaseTypeHandler(handler);
if (baseTypeHandler is PrimitiveHandler)
{
return ((PrimitiveHandler)baseTypeHandler).PrimitiveClassReflector();
}
return null;
}
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 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;
}
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);
}
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();
}
}
/// <param name="buffer"></param>
/// <param name="typeHandler"></param>
protected virtual void SeekSecondaryOffset(IReadBuffer buffer, ITypeHandler4 typeHandler
)
{
}
private void WriteObject(IWriteContext context, ITypeHandler4 typeHandler, object
obj)
{
if (IsPlainObject(obj))
{
context.WriteObject(new PlainObjectHandler(), obj);
return;
}
if (Handlers4.UseDedicatedSlot(context, typeHandler))
{
context.WriteObject(obj);
}
else
{
typeHandler.Write(context, obj);
}
}
public static bool HandlesArray(ITypeHandler4 handler)
{
return handler is ArrayHandler;
}
public static bool HandlesClass(ITypeHandler4 handler)
{
return BaseTypeHandler(handler) is ICascadingTypeHandler;
}
public TypeHandlerPredicatePair(ITypeHandlerPredicate predicate, ITypeHandler4 typeHandler
)
{
_predicate = predicate;
_typeHandler = typeHandler;
}
public static bool IsClassAware(ITypeHandler4 typeHandler)
{
return(typeHandler is IBuiltinTypeHandler || typeHandler is StandardReferenceTypeHandler);
}
public virtual void RegisterTypeHandler(ITypeHandlerPredicate predicate, ITypeHandler4
typeHandler)
{
_config.RegisterTypeHandler(predicate, typeHandler);
}
private bool CreateChildForDescendable(QCandidates parentCandidates, ITypeHandler4
handler, QueryingReadContext queryingReadContext, ITypeHandler4 arrayElementHandler
)
{
int offset = queryingReadContext.Offset();
bool outerRes = true;
// The following construct is worse than not ideal. For each constraint it completely reads the
// underlying structure again. The structure could be kept fairly easy. TODO: Optimize!
IEnumerator i = parentCandidates.IterateConstraints();
while (i.MoveNext())
{
QCon qcon = (QCon)i.Current;
QField qf = qcon.GetField();
if (qf != null && !qf.Name().Equals(_fieldMetadata.GetName()))
{
continue;
}
QCon tempParent = qcon.Parent();
qcon.SetParent(null);
QCandidates candidates = new QCandidates(parentCandidates.i_trans, null, qf, false
);
candidates.AddConstraint(qcon);
qcon.SetCandidates(candidates);
ReadArrayCandidates(handler, queryingReadContext.Buffer(), arrayElementHandler, candidates
);
queryingReadContext.Seek(offset);
bool isNot = qcon.IsNot();
if (isNot)
{
qcon.RemoveNot();
}
candidates.Evaluate();
ByRef pending = ByRef.NewInstance();
BooleanByRef innerRes = new BooleanByRef(isNot);
candidates.Traverse(new QCandidate.CreateDescendChildTraversingVisitor(pending, innerRes
, isNot));
if (isNot)
{
qcon.Not();
}
// In case we had pending subresults, we need to communicate them up to our root.
if (((Tree)pending.value) != null)
{
((Tree)pending.value).Traverse(new _IVisitor4_168(this));
}
if (!innerRes.value)
{
// Again this could be double triggering.
//
// We want to clean up the "No route" at some stage.
qcon.Visit(GetRoot(), qcon.Evaluator().Not(false));
outerRes = false;
}
qcon.SetParent(tempParent);
}
return(outerRes);
}
public static bool HandlesMultidimensionalArray(ITypeHandler4 handler)
{
return(handler is MultidimensionalArrayHandler);
}
public static bool HandlesClass(ITypeHandler4 handler)
{
return(BaseTypeHandler(handler) is ICascadingTypeHandler);
}
public static bool HandlesArray(ITypeHandler4 handler)
{
return(handler is ArrayHandler);
}
public static bool IsStandaloneTypeHandler(ITypeHandler4 customTypeHandler)
{
return(IsValueType(customTypeHandler) || customTypeHandler is OpenTypeHandler);
}
public static object ReadValueType(IReadContext context, ITypeHandler4 handler)
{
return(((IValueTypeHandler)handler).Read(context));
}
public virtual void Put(ITypeHandler4 handler, int version, ITypeHandler4 replacement
)
{
_versions.Put(new HandlerVersionKey(this, handler, version
), replacement);
}
public _IRunnable_71(QueryingReadContext context, ITypeHandler4 handler)
{
this.context = context;
this.handler = handler;
}
public virtual void Put(ITypeHandler4 handler, int version, ITypeHandler4 replacement
)
{
_versions.Put(new HandlerVersionRegistry.HandlerVersionKey(this, handler, version
), replacement);
}
public ArrayHandler(ITypeHandler4 handler, bool usePrimitiveClassReflector) : this
()
{
_handler = handler;
_usePrimitiveClassReflector = usePrimitiveClassReflector;
}
public virtual ITypeHandler4 CorrectHandlerVersion(ITypeHandler4 typeHandler)
{
return handlerRegistry.CorrectHandlerVersion(typeHandler, version);
}
public virtual void CollectIDs(QueryingReadContext context)
{
ITypeHandler4 handler = HandlerRegistry.CorrectHandlerVersion(context, _handler);
ForEachElement(context, new _IRunnable_71(context, handler));
}
public static void Write(ITypeHandler4 handler, IWriteContext context, object obj
)
{
handler.Write(context, obj);
}
public _IClosure4_263(ITypeHandler4 handler, QueryingReadContext queryingReadContext
)
{
this.handler = handler;
this.queryingReadContext = queryingReadContext;
}
private void RegisterGenericTypeHandler(Type genericTypeDefinition, ITypeHandler4 handler)
{
_config.RegisterTypeHandler(new GenericTypeHandlerPredicate(genericTypeDefinition), handler);
}
public ObjectTypeMetadata(ObjectContainerBase container, ITypeHandler4 handler, int
id, IReflectClass classReflector) : base(container, handler, id, classReflector
)
{
}
public static bool HandlesMultidimensionalArray(ITypeHandler4 handler)
{
return handler is MultidimensionalArrayHandler;
}
private static void ReadElements(IReadContext context, ICollectionInitializer initializer, ITypeHandler4 elementHandler)
{
int elementCount = context.ReadInt();
for (int i = 0; i < elementCount; i++)
{
initializer.Add(context.ReadObject(elementHandler));
}
}
public KeyValueHandlerPair(ITypeHandler4 keyHandler, ITypeHandler4 valueHandler)
{
_keyHandler = keyHandler;
_valueHandler = valueHandler;
}
private static void WriteElements(IWriteContext context, IEnumerable enumerable, ITypeHandler4 elementHandler)
{
IEnumerator elements = enumerable.GetEnumerator();
while (elements.MoveNext())
{
context.WriteObject(elementHandler, elements.Current);
}
}
public override bool IsIndirectedWithinSlot(ITypeHandler4 handler)
{
return false;
}
public static bool HandlesPrimitiveArray(ITypeHandler4 typeHandler)
{
return(typeHandler is ArrayHandler);
}
public static bool IsPlainObject(ITypeHandler4 typeHandler)
{
return typeHandler.GetType() == typeof(Db4objects.Db4o.Internal.OpenTypeHandler)
|| typeHandler.GetType() == typeof(OpenTypeHandler0) || typeHandler.GetType() ==
typeof(OpenTypeHandler2) || typeHandler.GetType() == typeof(OpenTypeHandler7);
}
public static bool IsVariableLength(ITypeHandler4 handler)
{
return(handler is IVariableLengthTypeHandler);
}
private static ArrayHandler ReadArrayHandler(IContext context)
{
ITypeHandler4 handler = ReadElementTypeHandler((IReadBuffer)context, context);
return(new ArrayHandler(handler, false));
}
public static bool IsUntyped(ITypeHandler4 handler)
{
return(handler is OpenTypeHandler);
}
private void ReadArrayCandidates(ITypeHandler4 typeHandler, IReadBuffer buffer, ITypeHandler4
arrayElementHandler, QCandidates candidates)
{
if (!Handlers4.IsCascading(arrayElementHandler))
{
return;
}
SlotFormat slotFormat = SlotFormat.ForHandlerVersion(_handlerVersion);
slotFormat.DoWithSlotIndirection(buffer, typeHandler, new _IClosure4_205(this, arrayElementHandler
, buffer, candidates));
}
public static bool IsCascading(ITypeHandler4 handler)
{
return(handler is ICascadingTypeHandler);
}
public virtual void WriteObject(ITypeHandler4 handler, object obj)
{
Handlers4.Write(handler, this, obj);
}
public static bool IsValueType(ITypeHandler4 handler)
{
return(!(handler is IReferenceTypeHandler));
}
public abstract bool IsIndirectedWithinSlot(ITypeHandler4 handler);
public static bool HoldsValueType(ITypeHandler4 handler)
{
return(IsValueType(BaseTypeHandler(handler)));
}
private void WriteElementClassMetadataId(IWriteContext context, ITypeHandler4 elementHandler
)
{
context.WriteInt(0);
}
public static bool IsIndirectedIndexed(ITypeHandler4 handler)
{
return(IsValueType(handler) && (handler is IVariableLengthTypeHandler) && (handler
is IIndexableTypeHandler));
}
