public void Fill(Dictionary <LookupToken, IEnumerable> lookups, IRetriever retriever) { using (HeavyProfiler.Log("SQL", () => Command.Sql)) using (DbDataReader reader = Executor.UnsafeExecuteDataReader(Command)) { ProjectionRowEnumerator <KeyValuePair <K, V> > enumerator = new ProjectionRowEnumerator <KeyValuePair <K, V> >(reader, ProjectorExpression, lookups, retriever); IEnumerable <KeyValuePair <K, V> > enumerabe = new ProjectionRowEnumerable <KeyValuePair <K, V> >(enumerator); try { var lookUp = enumerabe.ToLookup(a => a.Key, a => a.Value); lookups.Add(Token, lookUp); } catch (Exception ex) { FieldReaderException fieldEx = enumerator.Reader.CreateFieldReaderException(ex); fieldEx.Command = Command; fieldEx.Row = enumerator.Row; fieldEx.Projector = ProjectorExpression; throw fieldEx; } } }
/// <summary> /// Creates a new cache based on the given {@link Retriever} and with given maximum size. /// </summary> /// <param name="retriever">object which can retrieve values for keys</param> /// <param name="maxEntries">maximum number of entries the cache will store before evicting some</param> public Cache(IRetriever <K, V> retriever, int maxEntries) { //Preconditions.checkArgument(retriever != null, "retriever is null"); //Preconditions.checkArgument(maxEntries >= 1, "maxEntries must be at least 1"); cache = new Dictionary <K, V>(11); this.retriever = retriever; }
public MList <T> GetMList(PrimaryKey id, IRetriever retriever) { Interlocked.Increment(ref hits); MList <T> result; var dic = relationalRows.Value.TryGetC(id); if (dic == null) { result = new MList <T>(); } else { result = new MList <T>(dic.Count); var innerList = ((IMListPrivate <T>)result).InnerList; foreach (var obj in dic.Values) { innerList.Add(activator(obj, retriever)); } ((IMListPrivate)result).ExecutePostRetrieving(); } CachedTableConstructor.resetModifiedAction(retriever, result); return(result); }
public async Task FillAsync(Dictionary <LookupToken, IEnumerable> lookups, IRetriever retriever, CancellationToken token) { using (HeavyProfiler.Log("SQL", () => Command.Sql)) using (DbDataReader reader = await Executor.UnsafeExecuteDataReaderAsync(Command, token: token)) { ProjectionRowEnumerator <KeyValuePair <K, V> > enumerator = new ProjectionRowEnumerator <KeyValuePair <K, V> >(reader, ProjectorExpression, lookups, retriever, token); IEnumerable <KeyValuePair <K, V> > enumerabe = new ProjectionRowEnumerable <KeyValuePair <K, V> >(enumerator); try { var lookUp = enumerabe.ToLookup(a => a.Key, a => a.Value); lookups.Add(Token, lookUp); } catch (Exception ex) when(!(ex is OperationCanceledException)) { FieldReaderException fieldEx = enumerator.Reader.CreateFieldReaderException(ex); fieldEx.Command = Command; fieldEx.Row = enumerator.Row; fieldEx.Projector = ProjectorExpression; throw fieldEx; } } }
/// <summary> /// Download metar asynchronously. /// </summary> /// <param name="icao">Icao code of airport/station.</param> /// <param name="retriever">Metar retrievere used to decode metar from source stream</param> /// <param name="downloadCompletedDelegate">Delegate function raised when download is completed or error occured.</param> /// <exception cref="DownloadException"> /// Raised when any error occurs. /// </exception> public static void DownloadAsync(string icao, IRetriever retriever, DownloadCompletedDelegate downloadCompletedDelegate) { Downloader d = new Downloader(retriever); d.DownloadAsync(icao, downloadCompletedDelegate); }
public SearchEngine(SearchEngineConfig config) { mConfig = config; mQueryParser = new SimpleQueryParser(new QueryParserConfig { TextSegmenter = config.TextSegmenter, }); mRetriever = new InexactTopKRetriever(new RetrieverConfig { PostingListStore = config.PostingListStore, UrlFileStore = config.UrlFileStore, InvertedIndexStore = config.InvertedIndexStore, }, ResultSize); var rankerConfig = new RankerConfig { PostingListStore = config.PostingListStore, UrlFileStore = config.UrlFileStore, InvertedIndexStore = config.InvertedIndexStore, }; mRanker = new IntegratedRanker(rankerConfig); mProRanker = new QueryTermProximityRanker(rankerConfig); mLogger = new RuntimeLogger(Path.Combine(config.LogDirectory, "SearchEngine.Log"), true); }
/// <summary> /// Constructor /// </summary> /// <param name="retryRetriever"></param> /// <param name="retryPolicyExceptionHandler"></param> public RetryPolicyMiddleware( IRetriever retryRetriever, IRetryPolicyExceptionHandler retryPolicyExceptionHandler) { _retryRetriever = retryRetriever; _retryPolicyExceptionHandler = retryPolicyExceptionHandler; }
public Lite <T> GetLite(PrimaryKey id, IRetriever retriever) { Interlocked.Increment(ref hits); var lite = (LiteImp <T>)Lite.Create <T>(id, toStrings.Value[id]); return(retriever.ModifiablePostRetrieving(lite) !); }
/// <summary> /// Download metar synchronously. /// </summary> /// <param name="icao">Icao code of airport/station.</param> /// <param name="retriever">Metar retrievere used to decode metar from source stream</param> /// <returns>Metar as string.</returns> /// <exception cref="DownloadException"> /// Raised when any error occurs. /// </exception> public static string Download(string icao, IRetriever retriever) { Downloader d = new Downloader(retriever); string ret = d.Download(icao); return(ret); }
public async Task Run(IRetriever <TIn, TOut> retriever, HttpContext context) { var input = await _parseModel(context); var response = await _middleware.Run(() => retriever.Retrieve(input)); await _parseResponse(context, response); }
public Scheduler() { this.CanPauseAndContinue = true; _handlers = new HashSet <IHandler>(); _schedules = new ConcurrentDictionary <ITrigger, ScheduleToken>(TriggerComparer.Instance); _triggers = new TriggerCollection(_schedules); _retriever = new Retriever(); }
public Scheduler(string name = null) : base(name) { this.CanPauseAndContinue = true; _sequence = 1; _retriever = new Retriever(); _schedules = new ConcurrentDictionary <long, ScheduleToken>(); _schedulars = new ConcurrentDictionary <ITrigger, SchedularToken>(); }
internal void ReleaseRetriever(IRetriever retriever) { if (this.retriever == null || this.retriever != retriever) { throw new InvalidOperationException("Inconsistent state of the retriever"); } this.retriever = retriever.Parent; }
public ReasoningCycle AddRetriever(IRetriever caseRetriever) { if (caseRetriever == null) { throw new ArgumentNullException(nameof(caseRetriever)); } Retrievers.Add(caseRetriever); return(this); }
public override List <T> RequestByBackReference <R>(IRetriever retriever, Expression <Func <T, Lite <R>?> > backReference, Lite <R> lite) { // throw new InvalidOperationException(); /*CSBUG https://github.com/dotnet/roslyn/issues/33276*/ var dic = this.cachedTable.GetBackReferenceDictionary(backReference); var ids = dic.TryGetC(lite.Id).EmptyIfNull(); return(ids.Select(id => retriever.Complete <T>(id, e => this.Complete(e, retriever)) !).ToList()); }
public Downloader(IRetriever retriever) { if (retriever == null) { throw new ArgumentNullException(nameof(retriever)); } _retriever = retriever; }
public object Execute() { using (new EntityCache()) using (Transaction tr = new Transaction()) { object result; using (IRetriever retriever = EntityCache.NewRetriever()) { if (EagerProjections.Any() || LazyChildProjections.Any()) { lookups = new Dictionary <LookupToken, IEnumerable>(); } foreach (var chils in EagerProjections) { chils.Fill(lookups, retriever); } using (HeavyProfiler.Log("SQL", () => MainCommand.PlainSql())) using (DbDataReader reader = Executor.UnsafeExecuteDataReader(MainCommand)) { ProjectionRowEnumerator <T> enumerator = new ProjectionRowEnumerator <T>(reader, ProjectorExpression, lookups, retriever); IEnumerable <T> enumerable = new ProjectionRowEnumerable <T>(enumerator); try { if (Unique == null) { result = enumerable.ToList(); } else { result = UniqueMethod(enumerable, Unique.Value); } } catch (Exception ex) { FieldReaderException fieldEx = enumerator.Reader.CreateFieldReaderException(ex); fieldEx.Command = MainCommand; fieldEx.Row = enumerator.Row; fieldEx.Projector = ProjectorExpression; throw fieldEx; } } foreach (var chils in LazyChildProjections) { chils.Fill(lookups, retriever); } } return(tr.Commit(result)); } }
/// <summary> /// Constructor /// </summary> public DomainEventMediator( IServiceScopeFactory serviceScopeFactory, IDomainEventJsonDeserializer deserializer, ICustomLogger <InMemoryDomainEventsConsumer> logger, IRetriever retriever) { _serviceScopeFactory = serviceScopeFactory; _deserializer = deserializer; _logger = logger; _retriever = retriever; }
public IRetriever NewRetriever() { if (retriever == null) { retriever = new RealRetriever(this); } else { retriever = new ChildRetriever(retriever, this); } return(retriever); }
public void Complete(T entity, IRetriever retriever) { Interlocked.Increment(ref hits); var origin = this.GetRows().TryGetC(entity.Id); if (origin == null) { throw new EntityNotFoundException(typeof(T), entity.Id); } completer(origin, retriever, entity); }
/// <summary> /// Main constructor for ConfigRetriever /// </summary> /// <param name="retriever"><see cref="IRetriever"/> /// Interface for retrieve data from configuration system. /// Usualy <see cref="GH.DD.ConfigRetriever.Retrievers.ConsulRetriever"/> /// for retrieve from Consul</param> public ConfigRetriever(IRetriever retriever, ILogger logger = null) { _retriever = retriever ?? throw new ArgumentNullException(nameof(retriever)); _walker = new ConfigWalker <TItem>(); _convertProvider = new ConvertProvider(); _configMapper = new ConfigMapper <TItem>(); _logger = logger; if (logger == null) { _logger = _defaultLogger; } }
private static async Task TryRunPipeline <TIn, TOut>( IServiceProvider sp, PipelineInstructions <TIn, TOut> instructions, IRetriever <TIn, TOut> retriever, HttpContext context) { var(pipeline, ok) = instructions.TryGetPipeline <TIn, TOut>(sp); if (!ok) { throw new Exception("Could not create pipeline"); } await pipeline.Run(retriever, context); }
private static async Task <(bool Success, string Result)> TryGetPublicAsync(IRetriever retriever, CancellationToken cancellationToken) { try { HttpResponseMessage response = await Client.GetAsync(retriever.Uri, cancellationToken).ConfigureAwait(false); string content = await response.Content.ReadAsStringAsync().ConfigureAwait(false); return(true, retriever.Parse(content)); } catch { return(false, null !); } }
public CachingRecommender(IRecommender recommender) { //Preconditions.checkArgument(recommender != null, "recommender is null"); this.recommender = recommender; maxHowMany = new int[] { 1 }; // Use "num users" as an upper limit on cache size. Rough guess. int numUsers = recommender.GetDataModel().GetNumUsers(); recommendationsRetriever = new RecommendationRetriever(this); recommendationCache = new Cache <long, Recommendations>(recommendationsRetriever, numUsers); estimatedPrefCache = new Cache <Tuple <long, long>, float>(new EstimatedPrefRetriever(this), numUsers); refreshHelper = new RefreshHelper(() => { clear(); }); refreshHelper.AddDependency(recommender); }
void SetInMemory(T entity, IRetriever retriever) { if (!ShouldSet()) { return; } if (ValueFunction == null) { throw new InvalidOperationException($"ValueFunction should be set in AdditionalBinding {PropertyRoute} because {PropertyRoute.Type} is Cached"); } var setValue = _setter ?? (_setter = CreateSetter()); setValue(entity, retriever); }
public object ReadObject(string name) { DateTime current = DateTime.Now; DataRow row = TrySelectRowWithKeys(name); IRetriever retriever = PlugInFactoryManager.CreateInstance <IRetriever>( WeDataObjectPlugInFactory.REG_NAME, name); WeixinResult result; if (row == null) { result = retriever.RetrieveData(); if (!result.IsError) { row = NewRow(); row.BeginEdit(); row["DataKey"] = row["DataPlug"] = name; row["Data"] = result.WriteJson(); row["CreateDate"] = current; row["ValidDate"] = current.AddDays(3); row.EndEdit(); SetCommands(AdapterCommand.Insert); UpdateDatabase(); } } else { if (row["ValidDate"].Value <DateTime>() >= current) { result = retriever.ReadData(row["Data"].ToString()); } else { result = retriever.RetrieveData(); if (!result.IsError) { row.BeginEdit(); row["Data"] = result.WriteJson(); row["ValidDate"] = current.AddDays(3); row.EndEdit(); SetCommands(AdapterCommand.Update); UpdateDatabase(); } } } return(result); }
private static (bool Success, string Result) TryGetPublic(IRetriever retriever) { try { HttpWebRequest request = WebRequest.CreateHttp(retriever.Uri); using HttpWebResponse response = (HttpWebResponse)request.GetResponse(); using Stream stream = response.GetResponseStream(); using StreamReader reader = new StreamReader(stream); string content = reader.ReadToEnd(); return(true, retriever.Parse(content)); } catch { return(false, null !); } }
public async Task FillAsync(Dictionary <LookupToken, IEnumerable> lookups, IRetriever retriever, CancellationToken token) { Dictionary <K, MList <V> > requests = (Dictionary <K, MList <V> >)lookups.TryGetC(Token); if (requests == null) { return; } using (HeavyProfiler.Log("SQL", () => Command.Sql)) using (DbDataReader reader = await Executor.UnsafeExecuteDataReaderAsync(Command, token: token)) { ProjectionRowEnumerator <KeyValuePair <K, MList <V> .RowIdElement> > enumerator = new ProjectionRowEnumerator <KeyValuePair <K, MList <V> .RowIdElement> >(reader, ProjectorExpression, lookups, retriever, token); IEnumerable <KeyValuePair <K, MList <V> .RowIdElement> > enumerabe = new ProjectionRowEnumerable <KeyValuePair <K, MList <V> .RowIdElement> >(enumerator); try { var lookUp = enumerabe.ToLookup(a => a.Key, a => a.Value); foreach (var kvp in requests) { var results = lookUp[kvp.Key]; ((IMListPrivate <V>)kvp.Value).InnerList.AddRange(results); ((IMListPrivate <V>)kvp.Value).InnerListModified(results.Select(a => a.Element).ToList(), null); retriever.ModifiablePostRetrieving(kvp.Value); } } catch (Exception ex) when(!(ex is OperationCanceledException)) { FieldReaderException fieldEx = enumerator.Reader.CreateFieldReaderException(ex); fieldEx.Command = Command; fieldEx.Row = enumerator.Row; fieldEx.Projector = ProjectorExpression; throw fieldEx; } } }
public BaseHandlerModule(IRetriever readonlyRepository, IMessageHandlerFactory messageHandlerFactory, IPersistStuff persister) { _messageHandlerFactory = messageHandlerFactory; _persister = persister; this.RequiresHttps(true, null); Get["/{environment?dev}/{provider}"] = parameters => { try { var model = readonlyRepository.Get((string)parameters.environment, (string)parameters.provider); var viewModel = new ViewModel { ConfigureModel = model, }; return(View[viewModel]); } catch (Exception ex) { return(ErrorResponse.FromException(ex).WithStatusCode(500)); } }; Post["/{environment?dev}/{provider}"] = parameters => { var configureModel = readonlyRepository.Get(parameters.environment, parameters.provider) as ConfigureModel; string contents = Respond(Request.Body, configureModel, parameters.provider); var byteArray = Encoding.UTF8.GetBytes(contents); var stream = new MemoryStream(byteArray); return(Response.FromStream(stream, "text/xml; charset=utf-8")); }; Post["/{environment?dev}/{provider}/Update"] = parameters => { UpdateConfiguration(parameters.provider, parameters.environment); return(Response.AsRedirect($"/{(string) parameters.environment}/{(string) parameters.provider}")); }; }
public void Complete(T entity, IRetriever retriever) { Interlocked.Increment(ref hits); var origin = this.GetRows().TryGetC(entity.Id); if (origin == null) { throw new EntityNotFoundException(typeof(T), entity.Id); } completer(origin, retriever, entity); var additional = Schema.Current.GetAdditionalBindings(typeof(T)); if (additional != null) { foreach (var ab in additional) { ab.SetInMemory(entity, retriever); } } }
public TvrageClient(IRetriever retriever) : base(retriever) { _mapper = new TvrageMapper(); }
public ClientBase(IRetriever retriever) { this.Retriever = retriever; Initialise(); }