class    One_side
{
    ref< Another_side > m_ref;
}

class Another_side
{
    ref< One_side > m_ref
}

// А это физическое представление ссылки.
class    Ref_image
{
    bool    m_is_valid;
    oid    m_one_side;
    oid    m_another_side;
}

E>class    One_side
E>{
E>    ref< Another_side > m_ref;
E>}

E>class Another_side
E>{
E>    ref< One_side > m_ref
E>}

E>// А это физическое представление ссылки.
E>class    Ref_image
E>{
E>    bool    m_is_valid;
E>    oid    m_one_side;
E>    oid    m_another_side;
E>}
E>

Если после поднятия ссылки (уже в другой задаче) оказывается, что она указывает на помеченный как удаленный элемент, то без уведомления приложения СУБД сама может обнулить соответсвующую ссылку и передать дальше уже null, а объект на диске исправить (вписать нул в хначение ссылки).

S>Так вот, например, я загрузил операцию (или мне ее вернула какая-нибудь функция) и решил изменить у нее ссылку на документ. То есть переприсвоить операцию другому документу (пример, конечно неудачный, но...). Я же должен соответствующие изменения сделать и в коллекциях ссылок старого и нового документа. Т.е. все равно эти коллекции сначала придется подгрузить. Так что выделяй в отдельный объект или нет — без разницы.

Что-то я не очень понимаю в чем суть проблемы. Если по условиям задачи возможно, что в объекте "операция над документом" можно поменять ссылку на изменяемый документ (что само по себе странно), то можно организовать коллекцию ссылок таким образом, чтобы операции вставки/удаления были дешевыми. Например, вместо вектора ссылок использовать двусвязный список (каждый элемент содержит собственно ссылку + ссылки на предыдущий/следующий элементы списка) или map на основе B+ дерева.

S>Только вот я тут думаю уже на протяжении полугода как бы это сделать. Уж больно все сложно получается. Так — что у меня крыша съезжает .

    public class SoftwareIdentityImpl : EntityWrapper {
        ProductImpl _product;

        IDetailEntitiesCollection _incarnations;
        IDetailEntitiesCollection _packages;
        IDetailEntitiesCollection _prerequisiteChecks;

        /// <summary>
        /// Creates new instance of software identity
        /// </summary>
        /// <param name="product">parent product</param>
        /// <param name="entityRef">SW ID entity object</param>
        public SoftwareIdentityImpl(ProductImpl product, IEntityRef entityRef)
            : base(EsdDb.SoftwareIdentity, entityRef) {
            _product = product;
            Init();
        }

        /// <summary>
        /// Constructed from existing SoftwareIdentity
        /// </summary>
        /// <param name="entityRef">SW ID entity object</param>
        public SoftwareIdentityImpl(IEntityRef entityRef)
            : base(EsdDb.SoftwareIdentity, entityRef) {
            Init();
        }

        /// <summary>
        /// Creates new SoftwareIdentity object for given product
        /// </summary>
        public SoftwareIdentityImpl(ProductImpl product)
            : base(EsdDb.SoftwareIdentity) {
            _product = product;
            Entity.productId = product.ObjectId;
            Init();
        }

        void Init() {
            _incarnations = EsdDb.Links.Version_Incarnation.GetDetail(Entity.ObjectId);
            _packages = EsdDb.Links.Version_Package.GetDetail(Entity.ObjectId);
            _prerequisiteChecks = EsdDb.Links.Version_Prerequisite.GetDetail(Entity.ObjectId);
        }


[...]

    /// <summary>
    /// Summary description for IEntityFactory.
    /// </summary>
    public interface IEntityFactory
    {
        /// <summary>
        /// Creates clone of entity
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        object CloneEntity(object entity);

        /// <summary>
        /// Creates uninitialized entity object
        /// </summary>
        /// <returns></returns>
        object CreateEntityInstance();

    }


    public interface IEntityDescriptor : IEntityFactory {

        /// <summary>
        /// TypeCode of Entity type
        /// </summary>
        TypeCodeT TypeCode { get; }

        /// <summary>
        /// Type of entity
        /// </summary>
        Type EntityType { get; }

        /// <summary>
        /// Type of wrapper
        /// </summary>
        Type WrapperType { get; }

        /// <summary>
        /// Short friendly entity name (most usual just class name without namespaces)
        /// </summary>
        string Name { get; }

        /// <summary>
        /// List of entity fields
        /// </summary>
        EntityFieldCollection FieldList { get; }

        /// <summary>
        /// Extracts entity ID
        /// </summary>
        /// <param name="entity">target entity</param>
        /// <returns>Object ID of entity</returns>
        ObjectIdT ExtractEntityId(object entity);

        /// <summary>
        /// Extracts entity Name
        /// </summary>
        /// <param name="entity">target entity</param>
        /// <returns>name of entity object</returns>
        string ExtractEntityName(object entity);

        /// <summary>
        /// Extracts entity description
        /// </summary>
        /// <param name="entity">target entity</param>
        /// <returns>description of entity object</returns>
        string ExtractEntityDescription(object entity);

        /// <summary>
        /// Creates wrapper for given entity instance
        /// </summary>
        /// <param name="entityRef">instance of entity ref to wrap</param>
        /// <returns>Wrapper object</returns>
        EntityWrapper GetWrapper(IEntityRef entityRef);

        /// <summary>
        /// Extracts NamedObjectId structure from entity object
        /// </summary>
        /// <param name="entity"></param>
        /// <returns>NamedObjectId entity representation</returns>
        NamedObjectId ToNamedObjectId(object entity);

        /// <summary>
        /// Extracts NamedObjectId structure from entity object
        /// </summary>
        /// <param name="entities">collection of entities</param>
        /// <returns>NamedObjectId[] array of entities representations</returns>
        NamedObjectId[] ToNamedObjectIdList(ICollection entities);

        EntityValue[] ConvertToEntitiesValues(ICollection entities);

        void SetFieldValue(object entity, int fieldId, Var val);

        Var GetFieldValue(object entity, int fieldId);

        /// <summary>
        /// Entity comparer
        /// </summary>
        IComparer Comparer { get; }

    }



    public interface IEntityStorage : IEntityRefFactory, ISynchronizable {

        /// <summary>
        /// Entity meta-information provider and helper
        /// </summary>
        IEntityDescriptor Descriptor { get; }

        /// <summary>
        /// Extracts full list of entities
        /// </summary>
        /// <returns>full list of entities</returns>
        ICollection GetEntityList();

        /// <summary>
        /// Extracts selected list of entity
        /// </summary>
        /// <param name="filterObjectIds">filtered IDs of entities</param>
        /// <returns>filtered list</returns>
        ICollection GetEntityList(ObjectIdT[] filterObjectIds);

        /// <summary>
        /// Get cache entry for entity ID.
        /// By default - with no cache behaviour implementation
        /// </summary>
        /// <param name="objectId">ID of entity</param>
        /// <param name="loadObject">if true the load object imediatelly</param>
        /// <returns>Cache entry for given entity ID</returns>
        IEntityRef GetCacheEntry(ObjectIdT objectId, bool loadObject);

        /// <summary>
        /// Get cache entry for entity
        /// By default - with no cache behaviour implementation
        /// </summary>
        /// <param name="entity">ID of entity</param>
        /// <returns>Cache entry for given entity ID</returns>
        IEntityRef GetCacheEntry(object entity);

        /// <summary>
        /// Get cache entries
        /// </summary>
        /// <param name="entityCollection"></param>
        /// <returns></returns>
        ICacheEntryCollection GetCacheEntries(ICollection entityCollection);


        /// <summary>
        /// Get cache entries
        /// </summary>
        /// <param name="ids">IDs of objects</param>
        /// <param name="initialize">initialize cache entry</param>
        /// <returns></returns>
        ICacheEntryCollection GetCacheEntries(ObjectIdT[] ids, bool initialize);

        /// <summary>
        /// Initializes cache entry if needed
        /// </summary>
        /// <param name="entry">cache</param>
        void InitCacheEntry(IEntityRef entry);

        /// <summary>
        /// Extract related objects from DB or cache
        /// </summary>
        /// <param name="childStorage">related links</param>
        /// <param name="parentObjId">master object ID</param>
        /// <returns>list of related objects</returns>
        ICollection GetChildEntities(IEntityStorage childStorage, ObjectIdT parentObjId);

        // TODO: Remove!!!
        ICollection GetChildEntities(TypeCodeT childTypeCode, ObjectIdT parentObjId);

        /// <summary>
        /// Creates new entity object in storage
        /// initializes key fields
        /// </summary>
        /// <returns></returns>
        IEntityRef CreateNewEntity();

        /// <summary>
        /// TODO: Remove!!!
        /// </summary>
        /// <param name="parentStorage"></param>
        /// <param name="masterObjectId"></param>
        /// <returns></returns>
        IEntityRef CreateRelatedEntity(IEntityStorage parentStorage, ObjectIdT masterObjectId);
            
        /// <summary>
        /// Deletes entity from storage
        /// </summary>
        /// <param name="entityId">id of entity</param>
        /// <param name="transaction">transaction context</param>
        void DeleteEntity(EsdTransaction transaction, ObjectIdT entityId);

        /// <summary>
        /// Save entity wrapper
        /// </summary>
        /// <param name="transaction"></param>
        /// <param name="wrapper"></param>
        void SaveEntityWrapper(EsdTransaction transaction, EntityWrapper wrapper);

        /// <summary>
        /// Collection of related IEntityRef entries
        /// </summary>
        /// <param name="link"></param>
        /// <param name="masterObjectId"></param>
        /// <returns></returns>
        ICollection GetRelatedEntities(IMasterDetailLink link, ObjectIdT masterObjectId);

        /// <summary>
        /// Register link on storage
        /// </summary>
        /// <param name="link"></param>
        void RegisterLink(LinkBase link);

        IMasterDetailLink GetMasterDetailLink(TypeCodeT childTypeCode);

    }

    /// <summary>
    /// Collection of IEntityRef
    /// </summary>
    public interface ICacheEntryCollection : ICollection {

        /// <summary>
        /// Storage
        /// </summary>
        IEntityStorage EntityStorage { get; }
        
        /// <summary>
        /// initialized tag
        /// </summary>
        bool Initialized { get; }
    }


    public interface IMasterDetailLink {
        void Clear();

        /// <summary>
        /// Master entity meta-info
        /// </summary>
        IEntityStorage MasterStorage { get; }

        /// <summary>
        /// Detail entity meta-info
        /// </summary>
        IEntityStorage DetailStorage { get; }


        /// <summary>
        /// Returns detail links
        /// </summary>
        /// <param name="masterObjectId">master object links</param>
        /// <returns>Detail links collection</returns>
        IDetailEntitiesCollection GetDetail(ObjectIdT masterObjectId);

    }

    /// <summary>
    /// Detail links bag definition
    /// </summary>
    public interface IDetailEntitiesCollection : ICollection, IEntityListProvider {
        /// <summary>
        /// add detail linked object
        /// </summary>
        /// <param name="childEntityRef">added child entity</param>
        void Add(IEntityRef childEntityRef);

        /// <summary>
        /// Key of Master Object (ObjectIdT)
        /// </summary>
        ObjectIdT MasterObjectId { get; }

        /// <summary>
        /// Master entity meta-info
        /// </summary>
        IEntityStorage MasterEntityStorage { get; }

        /// <summary>
        /// Detail entity meta-info
        /// </summary>
        IEntityStorage DetailEntityStorage { get; }

        /// <summary>
        /// Creates new detail-side linked (!!!) object
        /// </summary>
        /// <returns>newly created object</returns>
        IEntityRef CreateDetailEntity();

        /// <summary>
        /// Accesor to linked object by ID
        /// </summary>
        /// <param name = "detailObjectId">ID of linked object to extract</param>
        object this[ObjectIdT detailObjectId] { get; }

        /// <summary>
        /// Remove child object (or delete in pure MD-link)
        /// </summary>
        /// <param name="transaction"></param>
        /// <param name="childObjectId"></param>
        void RemoveChild(EsdTransaction transaction, ObjectIdT childObjectId);
    }


    public interface IEntityRef {
        ObjectIdT ObjectId { get; }
        object Entity { get; set; }
    }


    /// <summary>
    /// Entity reference
    /// </summary>
    public class EntityRef : IEntityRef {
        object _entity;
        ObjectIdT _id;

        public EntityRef(ObjectIdT id, object entity) {
            _id = id;
            _entity = entity;
        }

        public EntityRef(ObjectIdT id) {
            _id = id;
        }

        public ObjectIdT ObjectId {
            get { return _id; }
        }

        public object Entity {
            get { return _entity; }
            set { _entity = value; }
        }
    }

    /// <summary>
    /// Weak entity reference
    /// </summary>
    public class WeakEntityRef : WeakReference, IEntityRef {
        ObjectIdT _id;

        public WeakEntityRef(ObjectIdT id, object entity)
            : base(entity, false) {
            _id = id;
        }

        public ObjectIdT ObjectId {
            get { return _id; }
        }

        public object Entity {
            get {
                if (IsAlive)
                    return Target;
                return null;
            }

            set { Target = value; }
        }
    }