C# Transaction.Container方法代码示例

 public static CollectIdContext ForID(Transaction
     transaction, IdObjectCollector collector, int id)
 {
     var reader = transaction.Container().ReadStatefulBufferById(transaction
         , id);
     if (reader == null)
     {
         return null;
     }
     var oh = new ObjectHeader(transaction.Container(), reader);
     return new CollectIdContext(transaction, collector
         , oh, reader);
 }

 internal QConClass(Transaction trans, QCon parent, QField field, IReflectClass claxx
     ) : base(trans, parent, field, null)
 {
     // C/S
     if (claxx != null)
     {
         var container = trans.Container();
         _classMetadata = container.ClassMetadataForReflectClass(claxx);
         if (_classMetadata == null)
         {
             // could be an aliased class, try to resolve.
             var className = claxx.GetName();
             var 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 virtual RawClassSpec ReadSpec(Transaction trans, ByteArrayBuffer reader)
 {
     var nameBytes = ReadName(trans, reader);
     var className = trans.Container().StringIO().Read(nameBytes);
     ReadMetaClassID(reader);
     // skip
     var ancestorID = reader.ReadInt();
     reader.IncrementOffset(Const4.IntLength);
     // index ID
     var numFields = reader.ReadInt();
     return new RawClassSpec(className, ancestorID, numFields);
 }

 private void AssociateYapClass(Transaction a_trans, object a_object)
 {
     if (a_object == null)
     {
     }
     else
     {
         //It seems that we need not result the following field
         //i_object = null;
         //i_comparator = Null.INSTANCE;
         //i_classMetadata = null;
         // FIXME: Setting the YapClass to null will prevent index use
         // If the field is typed we can guess the right one with the
         // following line. However this does break some SODA test cases.
         // Revisit!
         //            if(i_field != null){
         //                i_classMetadata = i_field.getYapClass();
         //            }
         _classMetadata = a_trans.Container().ProduceClassMetadata(a_trans.Reflector().ForObject
             (a_object));
         if (_classMetadata != null)
         {
             i_object = _classMetadata.GetComparableObject(a_object);
             if (a_object != i_object)
             {
                 i_attributeProvider = _classMetadata.Config().QueryAttributeProvider();
                 _classMetadata = a_trans.Container().ProduceClassMetadata(a_trans.Reflector().ForObject
                     (i_object));
             }
             if (_classMetadata != null)
             {
                 _classMetadata.CollectConstraints(a_trans, this, i_object, new _IVisitor4_84(this
                     ));
             }
             else
             {
                 AssociateYapClass(a_trans, null);
             }
         }
         else
         {
             AssociateYapClass(a_trans, null);
         }
     }
 }

 public void WriteShort(Transaction trans, string str, ByteArrayBuffer buffer)
 {
     StringIo(trans.Container()).WriteLengthAndString(buffer, str);
 }

 internal override void Unmarshall(Transaction trans)
 {
     if (i_trans != null)
     {
         return;
     }
     base.Unmarshall(trans);
     if (i_object == null)
     {
         _preparedComparison = Null.Instance;
     }
     if (i_classMetadataID != 0)
     {
         _classMetadata = trans.Container().ClassMetadataForID(i_classMetadataID);
     }
     if (i_field != null)
     {
         i_field.Unmarshall(trans);
     }
     if (i_objectID > 0)
     {
         var obj = trans.Container().TryGetByID(trans, i_objectID);
         if (obj != null)
         {
             i_object = obj;
         }
     }
 }

 private static Config4Impl Config(Transaction trans)
 {
     if (null == trans)
     {
         throw new ArgumentNullException();
     }
     return trans.Container().ConfigImpl;
 }

 internal virtual ObjectContainerBase Container(Transaction trans)
 {
     return trans.Container();
 }

 public override void Write(Transaction trans, ClassMetadata clazz, ClassAspect aspect
     , ByteArrayBuffer writer)
 {
     writer.WriteShortString(trans, aspect.GetName());
     if (!(aspect is FieldMetadata))
     {
         return;
     }
     var field = (FieldMetadata) aspect;
     field.Alive();
     if (field.IsVirtual())
     {
         return;
     }
     var handler = field.GetHandler();
     if (handler is StandardReferenceTypeHandler)
     {
         // TODO: ensure there is a test case, to make this happen 
         if (((StandardReferenceTypeHandler) handler).ClassMetadata().GetID() == 0)
         {
             trans.Container().NeedsUpdate(clazz);
         }
     }
     writer.WriteInt(field.FieldTypeID());
     var bitmap = new BitMap4(3);
     bitmap.Set(0, field.IsPrimitive());
     bitmap.Set(1, Handlers4.HandlesArray(handler));
     bitmap.Set(2, Handlers4.HandlesMultidimensionalArray(handler));
     // keep the order
     writer.WriteByte(bitmap.GetByte(0));
 }

 internal virtual void Unmarshall(Transaction a_trans)
 {
     if (i_classMetadataID != 0)
     {
         var yc = a_trans.Container().ClassMetadataForID(i_classMetadataID);
         _fieldMetadata = (FieldMetadata) yc._aspects[_fieldHandle];
     }
 }

 public override void WriteUpdate(Transaction transaction, IUpdateDepth updatedepth
     )
 {
     if (!_firstUpdate)
     {
         base.WriteUpdate(transaction, updatedepth);
         return;
     }
     _firstUpdate = false;
     var container = transaction.Container();
     SetStateClean();
     var context = new MarshallingContext(transaction, this, updatedepth
         , false);
     Handlers4.Write(ClassMetadata().TypeHandler(), context, GetObject());
     var length = Container().BlockConverter().BlockAlignedBytes(context.MarshalledLength
         ());
     var slot = context.AllocateNewSlot(length);
     var pointer = new Pointer4(GetID(), slot);
     var buffer = context.ToWriteBuffer(pointer);
     container.WriteUpdate(transaction, pointer, ClassMetadata(), ArrayType.None,
         buffer);
     if (IsActive())
     {
         SetStateClean();
     }
 }

 public byte[] ReadName(Transaction trans, ByteArrayBuffer reader)
 {
     return ReadName(trans.Container().StringIO(), reader);
 }