public IRequestIndexEntry Read(RequestIndexEntryObjectId objectId)
 {
     if (objectId.IndexId.RequestIndexEntryType == null)
     {
         return(null);
     }
     return(RequestIndexEntryProvider.Handle <IRequestIndexEntry>(objectId.IndexId.RequestIndexEntryType, (IRequestIndexEntryHandler handler) => handler.Read(this, objectId)));
 }
        public void Save(IConfigurable instance)
        {
            IRequestIndexEntry requestIndexEntry = RequestIndexEntryProvider.ValidateInstance(instance);

            RequestIndexEntryProvider.Handle(requestIndexEntry.GetType(), delegate(IRequestIndexEntryHandler handler)
            {
                handler.Save(this, requestIndexEntry);
            });
        }
        private static T Handle <T>(Type requestIndexEntryType, Func <IRequestIndexEntryHandler, T> function)
        {
            T returnValue = default(T);

            RequestIndexEntryProvider.Handle(requestIndexEntryType, delegate(IRequestIndexEntryHandler handler)
            {
                returnValue = function(handler);
            });
            return(returnValue);
        }
        public IEnumerable <T> FindPaged <T>(QueryFilter filter, ObjectId rootId, bool deepSearch, SortBy sortBy, int pageSize) where T : IConfigurable, new()
        {
            Type requestIndexEntryType = RequestIndexEntryProvider.ValidateQueryFilter <T>(filter);
            IEnumerable <IRequestIndexEntry> enumerable = RequestIndexEntryProvider.Handle <IEnumerable <IRequestIndexEntry> >(requestIndexEntryType, (IRequestIndexEntryHandler handler) => handler.FindPaged(this, filter, rootId, deepSearch, sortBy, pageSize));

            if (enumerable == null)
            {
                return(Array <T> .Empty);
            }
            if (typeof(T).IsSubclassOf(typeof(RequestBase)))
            {
                return(enumerable.Select(new Func <IRequestIndexEntry, T>(RequestIndexEntryProvider.CreateRequest <T>)));
            }
            if (enumerable is IEnumerable <T> )
            {
                return((IEnumerable <T>)enumerable);
            }
            MrsTracer.Common.Warning("IndexId not supported by this provider.", new object[0]);
            return(Array <T> .Empty);
        }
 public static void CreateAndPopulateRequestIndexEntries(RequestJobBase requestJobBase, RequestIndexId requestIndexId)
 {
     if (requestJobBase == null)
     {
         throw new ArgumentNullException("requestJobBase");
     }
     if (requestJobBase.IndexEntries == null)
     {
         requestJobBase.IndexEntries = new List <IRequestIndexEntry>();
     }
     if (requestJobBase.IndexIds == null)
     {
         requestJobBase.IndexIds = new List <RequestIndexId>();
     }
     RequestIndexEntryProvider.Handle(requestIndexId.RequestIndexEntryType, delegate(IRequestIndexEntryHandler handler)
     {
         IRequestIndexEntry item = handler.CreateRequestIndexEntryFromRequestJob(requestJobBase, requestIndexId);
         requestJobBase.IndexIds.Add(requestIndexId);
         requestJobBase.IndexEntries.Add(item);
     });
 }
        public IConfigurable[] Find <T>(QueryFilter filter, ObjectId rootId, bool deepSearch, SortBy sortBy) where T : IConfigurable, new()
        {
            Type requestIndexEntryType = RequestIndexEntryProvider.ValidateQueryFilter <T>(filter);

            IRequestIndexEntry[] array = RequestIndexEntryProvider.Handle <IRequestIndexEntry[]>(requestIndexEntryType, (IRequestIndexEntryHandler handler) => handler.Find(this, filter, rootId, deepSearch, sortBy));
            if (array == null)
            {
                return(Array <IConfigurable> .Empty);
            }
            Type typeFromHandle = typeof(T);

            if (array.GetType().GetElementType() == typeFromHandle)
            {
                return(array.Cast <IConfigurable>().ToArray <IConfigurable>());
            }
            if (typeFromHandle.IsSubclassOf(typeof(RequestBase)))
            {
                return(array.Select(new Func <IRequestIndexEntry, T>(RequestIndexEntryProvider.CreateRequest <T>)).Cast <IConfigurable>().ToArray <IConfigurable>());
            }
            MrsTracer.Common.Warning("IndexId not supported by this provider.", new object[0]);
            return(Array <IConfigurable> .Empty);
        }
        public static void CreateAndPopulateRequestIndexEntries(RequestJobBase requestJobBase, IConfigurationSession session)
        {
            if (requestJobBase == null)
            {
                throw new ArgumentNullException("requestJobBase");
            }
            if (requestJobBase.IndexEntries == null)
            {
                requestJobBase.IndexEntries = new List <IRequestIndexEntry>();
            }
            if (requestJobBase.IndexIds == null)
            {
                requestJobBase.IndexIds = new List <RequestIndexId>();
            }
            RequestIndexId indexId = new RequestIndexId(RequestIndexLocation.AD);

            RequestIndexEntryProvider.Handle(indexId.RequestIndexEntryType, delegate(IRequestIndexEntryHandler handler)
            {
                IRequestIndexEntry item = handler.CreateRequestIndexEntryFromRequestJob(requestJobBase, session);
                requestJobBase.IndexIds.Add(indexId);
                requestJobBase.IndexEntries.Add(item);
            });
        }