/// <summary> /// Lookup in own map. /// </summary> /// <param name="prefix"></param> /// <returns></returns> private IEnumerable <string> FromMap(string prefix) { var ns = new ManyOf <string>(); if (this.map.ContainsKey(prefix)) { ns = new ManyOf <string>(this.map[prefix]); } return(ns); }
/// <summary> /// Lookup in other contexts. /// </summary> /// <param name="prefix">prefix to find</param> /// <returns>list with one or no result</returns> private IEnumerable <string> FromContexts(string prefix) { IEnumerable <string> ns = new ManyOf <string>(); foreach (IScalar <IXmlNamespaceResolver> ctx in this.contexts) { string uri = ctx.Value().LookupNamespace(prefix); if (uri != null) { ns = new ManyOf <string>(uri); } } return(ns); }
public IEnumerator <Exception> GetEnumerator() { var schemas = new XmlSchemaSet(); schemas.Add("", XmlReader.Create(new StringReader(this.schema.Value()))); IEnumerable <Exception> errors = new ManyOf <Exception>(); this.xml.Value().Validate( schemas, (obj, ex) => errors = new Joined <Exception>(errors, ex.Exception) ); return(errors.GetEnumerator()); }
/// <summary> /// A mapped Dictionary that does not enumerate the dicitonary /// </summary> /// <param name="func">key, value, out</param> /// <param name="origin"></param> public MappedDictionary(Func <string, Func <string>, Out> func, IDictionary <string, string> origin) : base(new ScalarOf <IEnumerable <Out> >( () => { IEnumerable <Out> result = new ManyOf <Out>(); foreach (var key in origin.Keys) { result = new Atoms.Enumerable.Joined <Out>( result, func(key, () => origin[key]) ); } return(result); }), false) { }
/// <summary> /// A filtered Dictionary that does not enumerate the dictionary /// </summary> public FilteredDictionary(Func <string, Func <string>, bool> func, IDictionary <string, string> origin) : base(() => { IEnumerable <IKvp> result = new ManyOf <IKvp>(); foreach (var key in origin.Keys) { if (func(key, () => origin[key])) { result = new Yaapii.Atoms.Enumerable.Joined <IKvp>(result, new KvpOf(key, () => origin[key]) ); } } return(new MapOf(result)); }, false ) { }
private async Task <CommandResult> LinkAccounts(CommandContext context) { ManyOf <User> users = await context.ParseArgs <ManyOf <User> >(); if (users.Values.Count < 2) { return new CommandResult { Response = "Must link at least 2 accounts" } } ; bool success = await _linkedAccountRepo.Link(users.Values.Select(u => u.Id).ToImmutableHashSet()); return(new CommandResult { Response = success ? "Accounts successfully linked" : "Accounts were already linked" }); }
/// <summary> /// Lookup in XML specification. /// </summary> /// <param name="prefix">prefix to find</param> /// <returns>list with one or no result</returns> private IEnumerable <string> FromXMLSpec(string prefix) { IEnumerable <string> ns; if (prefix.Equals(XML_NS_PREFIX)) //Defined by the XML specification to be "xml" { ns = new ManyOf <string>(XML_NS_URI); //Defined by the XML specification } else if (prefix.Equals(XMLNS_ATTRIBUTE)) //Defined by the XML specification to be "xmlns" { ns = new ManyOf <string>(XMLNS_ATTRIBUTE_NS_URI); //Defined by the XML specification } else { ns = new ManyOf <string>(NULL_NS_URI); } return(ns); }
///// <summary> ///// Fetches only root node. ///// The root node is found if <paramref name="root"/> contains "*" or the root node name. ///// </summary> ///// <param name="root">Root node name</param> ///// <param name="dom">Document</param> ///// <returns>Found nodes</returns> //private IEnumerable<XmlNode> RootOnly(string root, XmlNode dom) //{ // var rootElem = new XmlDocumentOf(dom).Value().DocumentElement; // var targets = new ManyOf<XmlNode>(); // empty list // if ( // root != null && // rootElem != null && // ("*".Equals(root) || rootElem.Name.Equals(root)) // ) // { // targets = new ManyOf<XmlNode>(rootElem); // } // return targets; //} /// <summary> /// Get roots to start searching from. /// The root nodes are the <paramref name="nodes"/> if there are any or the document root node. /// </summary> /// <param name="dom">Document</param> /// <param name="nodes">Current nodes</param> /// <returns>Root nodes to start searching from</returns> private IEnumerable <XNode> Roots(XNode dom, IEnumerable <XNode> nodes) { IEnumerable <XNode> roots = nodes; // Return document root if there are no nodes. if (new LengthOf(nodes).Value() == 0) { roots = new ManyOf <XNode>( new XmlDocumentOf( dom ).Value().Document); } // DocumentElement may be null. Then remove it from the list. roots = new Filtered <XNode>( (node) => node != null, roots ); return(roots); }
public void SendsMultipleHeaderValues(string expected) { var port = new AwaitedPort(new TestPort()).Value(); IEnumerable <string> headers = new ManyOf <string>(); using (var server = new HttpMock(port, new FkWire(req => { headers = new Accept.Of(req); return(new Response.Of(200, "OK")); }) ).Value() ) { new AspNetCoreWire( new AspNetCoreClients(), new TimeSpan(0, 1, 0) ).Response( new Get( new Scheme("http"), new Host("localhost"), new Port(server.Port), new Headers( new KvpOf("Accept", "application/json"), new KvpOf("Accept", "application/xml"), new KvpOf("Accept", "text/plain") ) ) ).Wait(30000); } Assert.Contains( expected, new Yaapii.Atoms.Text.Joined(", ", headers).AsString() ); }