/// <summary> /// Create a new AdaptorCollator providing collator it adapts, with read and write conversions for the outer /// and underlying types /// </summary> /// <param name="baseCollator">Collator this adaptor wraps</param> /// <param name="readConvert">Conversion from data read from inner collator to type of outer adaptor</param> /// <param name="writeConvert">Conversion for data being written from outer adaptor to inner collator</param> public AdaptorCollator(ICollator baseCollator, Func <TFrom, TTo> readConvert, Func <TTo, TFrom, TFrom> writeConvert) : base(baseCollator.System) { this.baseCollator = baseCollator; this.readConvert = readConvert; this.writeConvert = writeConvert; IdWriteConvert = x => x; PropertyMap = new Dictionary <string, string>(); }
public async Task <ImageCollatorOutputs> FunctionHandler(ImageCollatorInputs input, ILambdaContext context) { this.context = context; Log("Collation: " + input.collation); Log("Accounts: " + string.Join(",", input.accounts)); Log("Period: " + input.period); Log("Filter: " + input.filter); Log("Group: " + input.group); var collation = EnumHelper.EnsureArgument <Collations>(input.collation, "collation"); var twitterApiKey = GetEnv("TWITTER_CONSUMER_KEY"); var twitterApiKeySecret = GetEnv("TWITTER_CONSUMER_KEY_SECRET"); var twitterAccessToken = GetEnv("TWITTER_ACCESS_TOKEN"); var twitterAccessTokenSecret = GetEnv("TWITTER_ACCESS_TOKEN_SECRET"); var githubToken = GetEnv("GITHUB_TOKEN", collation == Collations.github); var githubOwner = GetEnv("GITHUB_OWNER", collation == Collations.github); var githubRepository = GetEnv("GITHUB_REPOSITORY", collation == Collations.github); var bucket = GetEnv("AWS_S3_BUCKET", collation == Collations.s3); var filter = EnumHelper.EnsureArgument <Filters>(input.filter, "filter"); var dates = PeriodHelper.ParsePeriod(input.period); var start = dates[0]; var end = dates[1]; var keywords = await KeywordsHelper.FindKeywordsAsync(input.keywords_list, input.keywords_list_url); var inspector = new TwitterInspector( twitterApiKey, twitterApiKeySecret, twitterAccessToken, twitterAccessTokenSecret, filter, context.Logger.LogLine, keywords); ICollator collator = CollatorFactory.Create(collation, Log, input.group, bucket, githubToken, githubOwner, githubRepository); collator.Verbose = true; var outputs = new ImageCollatorOutputs(); foreach (var account in input.accounts) { var medias = await inspector.FilterTimelineAsync(account, start, end); var summary = await collator.CollateAsync(medias); outputs.summaries += summary.Summaries; outputs.files += summary.Files; outputs.errors.AddRange(summary.Errors); } return(outputs); }
/// <summary> /// Get the url(s) of a container or content item with option to process through /// processes registered to GenerateUrl event /// </summary> /// <param name="o">container or content item</param> /// <param name="transform">whether to process through GenerateUrl event</param> /// <returns>All the possible urls</returns> public IEnumerable <string> GetUrls(object o, bool transform) { Type type = Collator.GetContentType(o); ICollator collator = Collator.Instance.Registered(type); var address = collator.GetAddress(o); var urls = GetUrls(address); if (transform) { var container = Collator.Instance.GetContainer(o); ItemVersion iv = new ItemVersion(container); urls = urls.Select(url => transform ? UrlTransform(url, iv) : url); } return(urls); }
private void Add(int indexId, int wsId, string text, T item) { SortKeyIndex index = GetIndex(indexId, wsId); IWritingSystem ws = m_wsManager.Get(wsId); ICollator collator = ws.Collator; switch (m_type) { case SearchType.Exact: case SearchType.Prefix: index.Add(collator.GetSortKey(text).KeyData, item); break; case SearchType.FullText: foreach (string token in Icu.Split(Icu.UBreakIteratorType.UBRK_WORD, ws.IcuLocale, text)) { index.Add(collator.GetSortKey(token).KeyData, item); } break; } }
/// -------------------------------------------------------------------------------- /// <summary> /// Opens the collating engine. /// </summary> /// <param name="sWs">The s ws.</param> /// -------------------------------------------------------------------------------- public void OpenCollatingEngine(string sWs) { m_collater = m_cache.ServiceLocator.WritingSystemManager.Get(sWs).Collator; }
private void Init() { m_collater = null; }
/// <summary> /// Get the possible route datas that could have selected a given container or content item via a route /// </summary> /// <param name="route">The route</param> /// <param name="o">The container or content item</param> /// <returns>The route datas that could have accessed the object via the route</returns> public List <RouteData> GetRouteDatas(Route route, Address address) { // Start list of urls which could map to this item. Note, catchall items (starting *) are treated as normal ones List <RouteValueDictionary> rvds = new List <RouteValueDictionary>(); var keyOutputs = route.KeyOutputs(); Type type = address.Type; ICollator collator = Collator.Instance.Registered(type); var rvd = new RouteValueDictionary(address); // Action & controller if (!(keyOutputs.ContainsKey("controller") && keyOutputs.ContainsKey("action"))) { throw new Exception("Route " + route.Url + " fails to define controller and action"); } if (keyOutputs["controller"].StartsWith("?")) { throw new Exception("Route " + route.Url + " is a data route which lacks but must have a specified controller"); } if (!ContentTypeHierarchy.ControllerActions.ContainsKey(keyOutputs["controller"])) { return(new List <RouteData>()); // Controller doesn't exist therefore no rvds } rvd.Add("controller", keyOutputs["controller"]); rvds.Add(rvd); // copy list so we can change 'actions' var actions = ContentTypeHierarchy.ControllerActions[keyOutputs["controller"]].ToList(); if (keyOutputs["action"].StartsWith("?")) { if (keyOutputs["action"].Length > 1 && actions.Contains(keyOutputs["action"].Substring(1).ToLower())) { actions.Add("??"); } rvds = PermuteAdd(rvds, "action", actions); } else if (!actions.Contains(keyOutputs["action"])) { return(new List <RouteData>()); // Fixed action doesn't exist therefore no urls } else { rvd.Add("action", keyOutputs["action"]); } // Route vars addressing the content item foreach (var kvp in keyOutputs) { if (kvp.Key == "controller" || kvp.Key == "action") // already dealt with { continue; } if (kvp.Value == "??" && address.ContainsKey(kvp.Key)) // optional variable { address.SetMatched(kvp.Key); } else if (kvp.Value.StartsWith("?")) // variable takes any value { // matches a path element address.SetMatched(kvp.Key); // this address element is matched } else // fixed value, has to be matched by item { bool matched = false; if (address.ContainsKey(kvp.Key)) { if (address.GetAsString(kvp.Key) == kvp.Value) { matched = true; address.SetMatched(kvp.Key); } } if (!matched) { return(new List <RouteData>()); } } } if (!address.FullyMatched) // Fails because one or more address elements could not have come from this route { return(new List <RouteData>()); } return(rvds .Select(r => { var rd = new RouteData(); r.Do(kvp => rd.Values.Add(kvp.Key, kvp.Value)); rd.Route = route; rd.RouteHandler = route.RouteHandler; return rd; }) .ToList()); }
/// <summary> /// Initialise the type system, the collator and the repository for a content type /// </summary> /// <param name="t">content type</param> /// <param name="coll">the collator</param> /// <param name="repo">the repository</param> public static void SetupType(this ITypeSystemRegistrar regr, Type t, ICollator coll, IRepository repo) { regr.SetupType(t, coll, repo, null); }
/// <summary> /// Initialise the type system, the collator, the repository and the editor redirect for a content type /// </summary> /// <typeparam name="T">content type</typeparam> /// <param name="coll">the collator</param> /// <param name="repo">the repository</param> /// <param name="redir">the editor redirect</param> public static void SetupType <T>(this ITypeSystemRegistrar regr, ICollator coll, IRepository repo, Func <IRouter, RouteContext, object, IRouter> redir) { regr.SetupType(typeof(T), coll, repo, redir); }
protected void ResetCollator() { _collator = null; IsValid = false; }
/// <summary> /// Initialise the type system, the collator, the repository and the editor redirect for a content type /// </summary> /// <typeparam name="T">content type</typeparam> /// <param name="coll">the collator</param> /// <param name="repo">the repository</param> /// <param name="redir">the editor redirect</param> public static void SetupType <T>(this ITypeSystemRegistrar regr, ICollator coll, IRepository repo, DiversionStrategy redir) { regr.SetupType(typeof(T), coll, repo, redir); }
/// <summary> /// Searches an index for the specified string. /// </summary> /// <param name="indexId">The index ID.</param> /// <param name="tss">The string.</param> /// <returns>The search results.</returns> public IEnumerable <T> Search(int indexId, ITsString tss) { if (tss == null || string.IsNullOrEmpty(tss.Text)) { return(Enumerable.Empty <T>()); } HashSet <T> results = null; foreach (Tuple <int, string> wsStr in GetWsStrings(tss)) { SortKeyIndex index = GetIndex(indexId, wsStr.Item1); ICollator collator = m_wsManager.Get(wsStr.Item1).Collator; switch (m_type) { case SearchType.Exact: case SearchType.Prefix: { byte[] sortKey = collator.GetSortKey(wsStr.Item2).KeyData; var lower = new byte[wsStr.Item2.Length * SortKeyFactor]; Icu.GetSortKeyBound(sortKey, Icu.UColBoundMode.UCOL_BOUND_LOWER, ref lower); var upper = new byte[wsStr.Item2.Length * SortKeyFactor]; Icu.GetSortKeyBound(sortKey, m_type == SearchType.Exact ? Icu.UColBoundMode.UCOL_BOUND_UPPER : Icu.UColBoundMode.UCOL_BOUND_UPPER_LONG, ref upper); IEnumerable <T> items = index.GetItems(lower, upper); if (results == null) { results = new HashSet <T>(items); } else { results.IntersectWith(items); } break; } case SearchType.FullText: string locale = m_wsManager.GetStrFromWs(wsStr.Item1); string[] tokens = Icu.Split(Icu.UBreakIteratorType.UBRK_WORD, locale, wsStr.Item2).ToArray(); for (int i = 0; i < tokens.Length; i++) { byte[] sortKey = collator.GetSortKey(tokens[i]).KeyData; var lower = new byte[tokens[i].Length * SortKeyFactor]; Icu.GetSortKeyBound(sortKey, Icu.UColBoundMode.UCOL_BOUND_LOWER, ref lower); var upper = new byte[tokens[i].Length * SortKeyFactor]; Icu.GetSortKeyBound(sortKey, i < tokens.Length - 1 ? Icu.UColBoundMode.UCOL_BOUND_UPPER : Icu.UColBoundMode.UCOL_BOUND_UPPER_LONG, ref upper); IEnumerable <T> items = index.GetItems(lower, upper); if (results == null) { results = new HashSet <T>(items); } else { results.IntersectWith(items); } } break; } } return(results ?? Enumerable.Empty <T>()); }