Exemple #1
0
        private void _InitQueryables(XPathQueryableNavigator navigator, IDictionary <string, IList <XPathNavigator> > queryables, IDictionary <XName, XPathQueryableNode> visited)
        {
            visited.Add(XName.Get(LocalName, Namespace), this);

            var subNodes = new List <XPathTypeNode>(ElementChildrenNodes);

            subNodes.AddRange(AttributeChildrenNodes);
            subNodes.AddRange(IgnoredChildrenNodes);

            foreach (XPathTypeNode xptn in subNodes)
            {
                var xpqn = xptn as XPathQueryableNode;
                if ((xpqn != null) && !visited.ContainsKey(XName.Get(xpqn.LocalName, xpqn.Namespace)))
                {
                    xpqn._InitQueryables(navigator, queryables, visited);
                }
            }

            foreach (CswQueryable cq in AssociatedQueryables)
            {
                if (!queryables.ContainsKey(cq.Name))
                {
                    queryables.Add(cq.Name, new List <XPathNavigator>());
                }

                var n = (XPathQueryableNavigator)navigator.Clone();
                n.MoveTo(this);
                queryables[cq.Name].Add(n);
            }
        }
 public override XPathNavigator Clone()
 {
     var ret=new XPathQueryableNavigator(this);
     if (ret._Queryables==null)
         ret._Queryables=Queryables;
     return ret;
 }
        private void _InitQueryables(XPathQueryableNavigator navigator, IDictionary<string, IList<XPathNavigator>> queryables, IDictionary<XName, XPathQueryableNode> visited)
        {
            visited.Add(XName.Get(LocalName, Namespace), this);

            var subNodes=new List<XPathTypeNode>(ElementChildrenNodes);
            subNodes.AddRange(AttributeChildrenNodes);
            subNodes.AddRange(IgnoredChildrenNodes);

            foreach (XPathTypeNode xptn in subNodes)
            {
                var xpqn=xptn as XPathQueryableNode;
                if ((xpqn!=null) && !visited.ContainsKey(XName.Get(xpqn.LocalName, xpqn.Namespace)))
                    xpqn._InitQueryables(navigator, queryables, visited);
            }

            foreach (CswQueryable cq in AssociatedQueryables)
            {
                if (!queryables.ContainsKey(cq.Name))
                    queryables.Add(cq.Name, new List<XPathNavigator>());

                var n=(XPathQueryableNavigator)navigator.Clone();
                n.MoveTo(this);
                queryables[cq.Name].Add(n);
            }
        }
        public override XPathNavigator Clone()
        {
            var ret = new XPathQueryableNavigator(this);

            if (ret._Queryables == null)
            {
                ret._Queryables = Queryables;
            }
            return(ret);
        }
 protected XPathQueryableNavigator(XPathQueryableNavigator other):
     base(other)
 {
     _Queryables=other._Queryables;
 }
 internal void InitQueryables(XPathQueryableNavigator navigator, IDictionary<string, IList<XPathNavigator>> queryables)
 {
     _InitQueryables(navigator, queryables, new Dictionary<XName, XPathQueryableNode>());
 }
            //TODO: compile LINQ expression?
            internal IQueryable Where(IQueryable source, IEnumerable <Uri> ids, XmlNamespaceManager namespaceManager = null, IOperatorImplementationProvider operatorImplementationProvider = null)
            {
                var parameters = new ParameterExpression[] {
                    Expression.Parameter(source.ElementType)
                };

                var xpqn = new XPathQueryableNavigator(source.ElementType, namespaceManager);
                XPathNodeIterator xpni = xpqn.Select(CoreQueryable.Identifier.Name, namespaceManager);

                if (xpni.MoveNext())
                {
                    var           idn       = (XPathQueryableNavigator)xpni.Current;
                    Type          idType    = idn.Type;
                    TypeConverter converter = GetIdentifierUriConverter(idType);

                    // Convert ids from Uris to identifier type
                    // urip => (idType)converter.ConvertTo(urip, idType)
                    var urip  = Expression.Parameter(typeof(Uri));
                    var conex = Expression.Lambda(
                        typeof(Func <,>).MakeGenericType(typeof(Uri), idType),
                        Expression.Convert(
                            Expression.Call(
                                Expression.Constant(converter),
                                "ConvertTo",
                                null,
                                urip,
                                Expression.Constant(idType)
                                ),
                            idType
                            ),
                        urip
                        );
                    // var convertedIds=ids.Select<Uri, idType>(uri => (idType)converter.ConvertTo(uri, idType))
                    var urilistp   = Expression.Parameter(typeof(IEnumerable <Uri>));
                    var convertids = Expression.Lambda(
                        Expression.Call(
                            typeof(Enumerable),
                            "Select",
                            new Type[] { typeof(Uri), idType },
                            Expression.Constant(ids),
                            conex
                            ),
                        urilistp
                        ).Compile();
                    var convertedIds = convertids.DynamicInvoke(ids);

                    // Creates the Where clause
                    LambdaExpression lambda = Expression.Lambda(
                        Expression.Call(
                            typeof(Enumerable),
                            "Contains",
                            new Type[] { idType },
                            Expression.Constant(convertedIds),
                            idn.CreateExpression(parameters[0])
                            ),
                        parameters
                        );
                    return(source.Provider.CreateQuery(
                               Expression.Call(
                                   typeof(Queryable),
                                   "Where",
                                   new Type[] { source.ElementType },
                                   source.Expression,
                                   Expression.Quote(lambda)
                                   )
                               ));
                }

                throw new InvalidOperationException();
            }
Exemple #8
0
 internal void InitQueryables(XPathQueryableNavigator navigator, IDictionary <string, IList <XPathNavigator> > queryables)
 {
     _InitQueryables(navigator, queryables, new Dictionary <XName, XPathQueryableNode>());
 }
 protected XPathQueryableNavigator(XPathQueryableNavigator other) :
     base(other)
 {
     _Queryables = other._Queryables;
 }