Exemple #1
0
        // Constructors

        protected EntityContainer(Key key, TypeInfo type, bool exactType, PrefetchManager manager)
        {
            ArgumentValidator.EnsureArgumentNotNull(type, "type");
            ArgumentValidator.EnsureArgumentNotNull(manager, "processor");
            Key       = key;
            Type      = type;
            ExactType = exactType;
            Manager   = manager;
        }
        // Constructors

        public ReferencedEntityContainer(Key ownerKey, PrefetchFieldDescriptor referencingFieldDescriptor,
                                         bool isOwnerTypeKnown, PrefetchManager manager)
            : base(null, referencingFieldDescriptor.Field.Associations.Last().TargetType, true, manager)
        {
            ArgumentValidator.EnsureArgumentNotNull(referencingFieldDescriptor, "referencingFieldDescriptor");
            ArgumentValidator.EnsureArgumentNotNull(ownerKey, "ownerKey");
            this.ownerKey = ownerKey;
            this.referencingFieldDescriptor = referencingFieldDescriptor;
            this.isOwnerTypeKnown           = isOwnerTypeKnown;
        }
        // Constructors

        public GraphContainer(Key key, TypeInfo type, bool exactType, PrefetchManager manager)
        {
            ArgumentValidator.EnsureArgumentNotNull(key, "key");
            ArgumentValidator.EnsureArgumentNotNull(type, "type");
            ArgumentValidator.EnsureArgumentNotNull(manager, "processor");

            Key  = key;
            Type = type;

            Manager        = manager;
            this.exactType = exactType;
        }
        // Constructors

        public EntitySetTask(Key ownerKey, PrefetchFieldDescriptor referencingFieldDescriptor, bool isOwnerCached,
                             PrefetchManager manager)
        {
            ArgumentValidator.EnsureArgumentNotNull(ownerKey, "ownerKey");
            ArgumentValidator.EnsureArgumentNotNull(referencingFieldDescriptor, "referencingFieldDescriptor");
            ArgumentValidator.EnsureArgumentNotNull(manager, "processor");

            this.ownerKey = ownerKey;
            this.referencingFieldDescriptor = referencingFieldDescriptor;
            this.isOwnerCached = isOwnerCached;
            ItemCountLimit     = referencingFieldDescriptor.EntitySetItemCountLimit;
            this.manager       = manager;
            cacheKey           = new CacheKey(ReferencingField, ItemCountLimit);
        }
        // Constructors

        public EntityGroupTask(TypeInfo type, int[] columnIndexes, PrefetchManager manager)
        {
            ArgumentValidator.EnsureArgumentNotNull(type, "type");
            ArgumentValidator.EnsureArgumentNotNull(columnIndexes, "columnIndexes");
            ArgumentValidator.EnsureArgumentIsGreaterThan(columnIndexes.Length, 0, "columnIndexes.Length");
            ArgumentValidator.EnsureArgumentNotNull(manager, "processor");

            this.type          = type;
            this.columnIndexes = columnIndexes;
            this.manager       = manager;
            var cachedHashCode = 0;

            for (var i = 0; i < columnIndexes.Length; i++)
            {
                cachedHashCode = unchecked (379 * cachedHashCode + columnIndexes[i]);
            }
            cachedHashCode = unchecked (cachedHashCode ^ type.GetHashCode());
            cacheKey       = new CacheKey(columnIndexes, type, cachedHashCode);
        }
        // Constructors

        public EntityGroupTask(TypeInfo type, int[] columnIndexes, PrefetchManager manager)
        {
            ArgumentValidator.EnsureArgumentNotNull(type, nameof(type));
            ArgumentValidator.EnsureArgumentNotNull(columnIndexes, nameof(columnIndexes));
            ArgumentValidator.EnsureArgumentIsGreaterThan(columnIndexes.Length, 0, "columnIndexes.Length");
            ArgumentValidator.EnsureArgumentNotNull(manager, nameof(manager));

            this.type    = type;
            this.manager = manager;
            var cachedHashCode = 0;

            foreach (var columnIndex in columnIndexes)
            {
                cachedHashCode = unchecked (379 * cachedHashCode + columnIndex);
            }

            cachedHashCode ^= type.GetHashCode();
            cacheKey        = new CacheKey(columnIndexes, type, cachedHashCode);
        }
 public static bool?TryGetExactKeyType(Key key, PrefetchManager manager, out TypeInfo type)
 {
     type = null;
     if (!key.TypeReference.Type.IsLeaf)
     {
         var         cachedKey = key;
         EntityState state;
         if (!manager.TryGetTupleOfNonRemovedEntity(ref cachedKey, out state))
         {
             return(null);
         }
         if (cachedKey.HasExactType)
         {
             type = cachedKey.TypeReference.Type;
             return(true);
         }
         return(false);
     }
     type = key.TypeReference.Type;
     return(true);
 }
Exemple #8
0
        // Constructors

        public Fetcher(PrefetchManager manager)
        {
            ArgumentValidator.EnsureArgumentNotNull(manager, nameof(manager));
            this.manager = manager;
        }
        // Constructors

        public RootEntityContainer(Key key, TypeInfo type, bool exactType, PrefetchManager manager)
            : base(key, type, exactType, manager)
        {
            ArgumentValidator.EnsureArgumentNotNull(key, "key");
        }
Exemple #10
0
        // Constructors

        public Fetcher(PrefetchManager manager)
        {
            ArgumentValidator.EnsureArgumentNotNull(manager, "processor");

            this.manager = manager;
        }