public void CtorName()
		{
			var s = new ExpandSegment ("name", null);
			Assert.AreEqual ("name", s.Name);
			Assert.AreEqual (null, s.Filter);
			Assert.IsFalse (s.HasFilter);
		}
Example #2
0
        public void PathHasFilter()
        {
            var param  = Expression.Parameter(typeof(bool), "b");
            var filter = Expression.Lambda(param, param);

            Assert.IsTrue(ExpandSegment.PathHasFilter(new []
                                                      { new ExpandSegment("first", null), new ExpandSegment("second", filter), new ExpandSegment("third", null) }));
        }
Example #3
0
        public void CtorName()
        {
            var s = new ExpandSegment("name", null);

            Assert.AreEqual("name", s.Name);
            Assert.AreEqual(null, s.Filter);
            Assert.IsFalse(s.HasFilter);
        }
Example #4
0
        public void CtorFilter()
        {
            var param  = Expression.Parameter(typeof(bool), "b");
            var filter = Expression.Lambda(param, param);
            var s      = new ExpandSegment("name", filter);

            Assert.AreEqual("name", s.Name);
            Assert.AreEqual(filter, s.Filter);
            Assert.IsTrue(s.HasFilter);
        }
		public void CtorFilter()
		{
			var param = Expression.Parameter (typeof (bool), "b");
			var filter = Expression.Lambda (param, param);
			var s = new ExpandSegment ("name", filter);

			Assert.AreEqual ("name", s.Name);
			Assert.AreEqual (filter, s.Filter);
			Assert.IsTrue (s.HasFilter);
		}
		public void HasFilterAddWithFilter()
		{
			var esc = new ExpandSegmentCollection();
			esc.Add (new ExpandSegment ("first", null));

			var param = Expression.Parameter (typeof (bool), "b");
			var filter = Expression.Lambda (param, param);
			var filteredSegment = new ExpandSegment ("second", filter);
			esc.Add (filteredSegment);
			Assert.IsTrue (esc.HasFilter);
		}
Example #7
0
        public void HasFilterAddWithFilter()
        {
            var esc = new ExpandSegmentCollection();

            esc.Add(new ExpandSegment("first", null));

            var param           = Expression.Parameter(typeof(bool), "b");
            var filter          = Expression.Lambda(param, param);
            var filteredSegment = new ExpandSegment("second", filter);

            esc.Add(filteredSegment);
            Assert.IsTrue(esc.HasFilter);
        }
        internal ExpandedProjectionNode AddExpandedNode(ExpandSegment segment)
        {
            ExpandedProjectionNode node = (ExpandedProjectionNode)this.FindNode(segment.Name);

            if ((node != null) && (node.Property == segment.ExpandedProperty))
            {
                if (segment.TargetResourceType.IsAssignableFrom(node.TargetResourceType))
                {
                    node.TargetResourceType = segment.TargetResourceType;
                }
                return(node);
            }
            node = new ExpandedProjectionNode(segment.Name, segment.ExpandedProperty, segment.TargetResourceType, segment.Container, segment.OrderingInfo, segment.Filter, null, (segment.Container.PageSize != 0) ? new int?(segment.Container.PageSize) : null, (segment.MaxResultsExpected != 0x7fffffff) ? new int?(segment.MaxResultsExpected) : null);
            this.AddNode(node);
            return(node);
        }
Example #9
0
        /// <summary>
        /// Adds the segment as pathedgenode
        /// </summary>
        /// <param name="parentNode">The parent node.</param>
        /// <param name="segments">The segments.</param>
        /// <param name="currentNodeIndex">The current node index in the segments list.</param>
        /// <param name="pathElement">The path element.</param>
        /// <param name="entityType">Type of the entity.</param>
        /// <remarks>Declared public to avoid medium trust reflection issues.</remarks>
        public void AddSegment(PathEdgeNode parentNode, IList <ExpandSegment> segments, int currentNodeIndex, IPrefetchPathElementCore pathElement, Type entityType)
        {
            if (currentNodeIndex >= segments.Count)
            {
                return;
            }

            ExpandSegment segment   = segments[currentNodeIndex];
            PathEdgeNode  childNode = null;

            if (!parentNode.ChildPathEdgeNodes.TryGetValue(segment.Name, out childNode))
            {
                childNode = new PathEdgeNode(entityType, pathElement, segment);
                parentNode.ChildPathEdgeNodes.Add(segment.Name, childNode);
            }
            DecodeSegment(childNode, segments, ++currentNodeIndex, entityType);
        }
        /// <summary>
        /// Adds a new expanded node with the given segment name, if required.
        /// </summary>
        /// <param name="segment">Expand segment as specified in the uri.</param>
        /// <param name="childSelectExpandClause">The select expand clause for the current node from the URI Parser.</param>
        /// <returns>An instance of ExpandedProjectionNode - either new or existing one.</returns>
        internal ExpandedProjectionNode AddExpandedNode(ExpandSegment segment, SelectExpandClause childSelectExpandClause)
        {
            Debug.Assert(segment.ExpandedProperty != null, "we do not allow expands on open properties");
            Debug.Assert(childSelectExpandClause != null, "childSelectExpandClause != null");

            ExpandedProjectionNode childNode = (ExpandedProjectionNode)this.FindNode(segment.Name);

            // Currently, since we do not have a back pointer in ResourceProperty for the declaring type,
            // the same resource property instance can belong to 2 completely different types.
            // Hence doing reference equality on Resource Property instance does not gaurantee that they
            // refer to the same property. But if the references are not equal, they are gauranteed to be
            // different. The check of reference equality is to make sure we do the expensive IsAssignableFrom
            // check, only if the instances are the same, and if the IsAssignable returns true, then we are
            // gauranteed that the property refers to the same property.
            if (childNode != null && childNode.Property == segment.ExpandedProperty)
            {
                // If the given segment specifies the same property on a super type (or an ancestor),
                // then we need to change the target type on the segment to the super type (or ancestor),
                // otherwise we should ignore the segment.
                // Since IsAssignableFrom returns true, if the instances are the same, we will update the
                // target resource type to the same instance. It doesn't matter, but having another check
                // for reference equality makes code less readable.
                if (segment.TargetResourceType.IsAssignableFrom(childNode.TargetResourceType))
                {
                    childNode.TargetResourceType = segment.TargetResourceType;
                }
            }
            else
            {
                childNode = new ExpandedProjectionNode(
                    segment.Name,
                    segment.ExpandedProperty,
                    segment.TargetResourceType,
                    segment.Container,
                    segment.OrderingInfo,
                    segment.Filter,
                    null,
                    segment.Container.PageSize != 0 ? (int?)segment.Container.PageSize : null,
                    segment.MaxResultsExpected != Int32.MaxValue ? (int?)segment.MaxResultsExpected : null,
                    childSelectExpandClause);
                this.AddNode(childNode);
            }

            return(childNode);
        }
Example #11
0
 public void PathDoesntHaveFilter()
 {
     Assert.IsFalse(ExpandSegment.PathHasFilter(new []
                                                { new ExpandSegment("first", null), new ExpandSegment("second", null), new ExpandSegment("third", null) }));
 }
Example #12
0
 public void PathHasFilterException()
 {
     ExpandSegment.PathHasFilter(null);
 }
 /// <summary>
 /// Initializes a new instance of the <see cref="PathEdgeNode"/> class.
 /// </summary>
 /// <param name="entityType">Type of the entity.</param>
 /// <param name="pathElement">The path element.</param>
 /// <param name="segment">The segment.</param>
 internal PathEdgeNode(Type entityType, IPrefetchPathElementCore pathElement, ExpandSegment segment)
 {
     _pathElement = pathElement;
     _segment     = segment;
     _entityType  = entityType;
 }
        /// <summary>
        /// Adds a new expanded node with the given segment name, if required.
        /// </summary>
        /// <param name="segment">Expand segment as specified in the uri.</param>
        /// <param name="childSelectExpandClause">The select expand clause for the current node from the URI Parser.</param>
        /// <returns>An instance of ExpandedProjectionNode - either new or existing one.</returns>
        internal ExpandedProjectionNode AddExpandedNode(ExpandSegment segment, SelectExpandClause childSelectExpandClause)
        {
            Debug.Assert(segment.ExpandedProperty != null, "we do not allow expands on open properties");
            Debug.Assert(childSelectExpandClause != null, "childSelectExpandClause != null");

            ExpandedProjectionNode childNode = (ExpandedProjectionNode)this.FindNode(segment.Name);

            // Currently, since we do not have a back pointer in ResourceProperty for the declaring type,
            // the same resource property instance can belong to 2 completely different types.
            // Hence doing reference equality on Resource Property instance does not gaurantee that they
            // refer to the same property. But if the references are not equal, they are gauranteed to be
            // different. The check of reference equality is to make sure we do the expensive IsAssignableFrom
            // check, only if the instances are the same, and if the IsAssignable returns true, then we are
            // gauranteed that the property refers to the same property.
            if (childNode != null && childNode.Property == segment.ExpandedProperty)
            {
                // If the given segment specifies the same property on a super type (or an ancestor),
                // then we need to change the target type on the segment to the super type (or ancestor),
                // otherwise we should ignore the segment.
                // Since IsAssignableFrom returns true, if the instances are the same, we will update the
                // target resource type to the same instance. It doesn't matter, but having another check
                // for reference equality makes code less readable.
                if (segment.TargetResourceType.IsAssignableFrom(childNode.TargetResourceType))
                {
                    childNode.TargetResourceType = segment.TargetResourceType;
                }
            }
            else
            {
                childNode = new ExpandedProjectionNode(
                    segment.Name,
                    segment.ExpandedProperty,
                    segment.TargetResourceType,
                    segment.Container,
                    segment.OrderingInfo,
                    segment.Filter,
                    null,
                    segment.Container.PageSize != 0 ? (int?)segment.Container.PageSize : null,
                    segment.MaxResultsExpected != Int32.MaxValue ? (int?)segment.MaxResultsExpected : null,
                    childSelectExpandClause);
                this.AddNode(childNode);
            }

            return childNode;
        }