public BracketedExpressionSegment(IEnumerable <IExpressionSegment> segments) { if (segments == null) { throw new ArgumentNullException("segments"); } Segments = segments.ToList().AsReadOnly(); if (Segments.Any(e => e == null)) { throw new ArgumentException("Null reference encountered in segments set"); } if (!Segments.Any()) { throw new ArgumentException("Empty segments set specified - invalid"); } // 2015-03-23 DWR: For deeply-nested bracketed segments, it can be very expensive to enumerate over their AllTokens sets repeatedly so it's worth preparing the data once and // avoiding doing it over and over again. This is often seen with an expression with many string concatenations - currently they are broken down into pairs of operations, // which results in many bracketed operations (I want to change this for concatenations going forward, since it's so common to have sets of concatenations and it would // be better if the CONCAT took a variable number of arguments rather than just two, but this hasn't been done yet). _allTokens = new IToken[] { new OpenBrace(Segments.First().AllTokens.First().LineIndex) } .Concat(Segments.SelectMany(s => s.AllTokens)) .Concat(new[] { new CloseBrace(Segments.Last().AllTokens.Last().LineIndex) }) .ToList() .AsReadOnly(); }
/// <summary> /// Extends a memory chunk references list by adding a new reference. If the new reference is contiguous to the last existing reference, /// then the list size remains constant. /// </summary> /// <param name="memoryChunkReferences"></param> /// <param name="newSegment"></param> public void ExtendSegments(MemoryBlockIDAndSlice blockAndSlice, bool extendEarlierReferencesForSameChunk) { if (Segments.Any()) { if (extendEarlierReferencesForSameChunk) { for (int i = 0; i < Segments.Count; i++) { var segment = Segments[i]; if (segment.MemoryBlockID == blockAndSlice.MemoryBlockID) { MemoryChunk existingChunk = GetMemoryChunkByMemoryBlockID(segment.MemoryBlockID); if (existingChunk != null) { existingChunk.LoadingInfo.PreTruncationLength = blockAndSlice.Length; } } } } var last = Segments.Last(); if (last.MemoryBlockID == blockAndSlice.MemoryBlockID && blockAndSlice.Offset == last.Offset + last.Length) { last = new MemoryBlockIDAndSlice(last.MemoryBlockID, last.Offset, last.Length + blockAndSlice.Length); Segments[Segments.Count - 1] = last; PatchesTotalLength += blockAndSlice.Length; return; } } Segments.Add(new MemoryBlockIDAndSlice(blockAndSlice.MemoryBlockID, blockAndSlice.Offset, blockAndSlice.Length)); PatchesTotalLength += blockAndSlice.Length; }
// Transforms query to a string. public string ToString(int profileCounter) { StringBuilder queryBuilder = new StringBuilder(); queryBuilder.Append(General.GA_RequestURIs.Default.ReportFeed); // (Ids.Count > 1 ? Ids.ToList().First().ToString() : queryBuilder.Append(Ids.Count > 0 ? Ids.ToString(profileCounter) : string.Empty); queryBuilder.Append(Dimensions.Count > 0 ? "&dimensions=" + string.Join(",", Dimensions.Values.ToArray()) : string.Empty); queryBuilder.Append(Metrics.Count > 0 ? "&metrics=" + string.Join(",", Metrics.Values.ToArray()) : string.Empty); if (Segments.Count > 0 && !Segments.Any(s => s.Value == "")) { queryBuilder.Append(Segments.Count > 0 ? "&segment=" + string.Join(",", Segments.Values.ToArray()) : string.Empty); } queryBuilder.Append(Filter.ToString()); queryBuilder.Append(Sort.ToString()); if (_selectDates.Equals(false)) { queryBuilder.Append(GetQueryTimeSpan()); TimeRange(); } else { string paramContainer = "&start-date={0}&end-date={1}"; queryBuilder.Append(string.Format(paramContainer, ToUnifiedCultureFormat(StartDate), ToUnifiedCultureFormat(EndDate))); } queryBuilder.Append(StartIndex > 0 ? "&start-index=" + StartIndex : string.Empty); queryBuilder.Append("&max-results=" + MaxResults); return(queryBuilder.ToString()); }
/// <summary> /// Initializes a new instance of <see cref="ODataPath"/> class. /// </summary> /// <param name="segments">The segments.</param> public ODataPath(IEnumerable <ODataSegment> segments) { Segments = segments.ToList(); if (Segments.Any(s => s == null)) { throw Error.ArgumentNull("segments"); } }
private ODataPathKind CalcPathType() { if (Segments.Count == 1 && Segments.First().Kind == ODataSegmentKind.Metadata) { return(ODataPathKind.Metadata); } else if (Segments.Last().Kind == ODataSegmentKind.DollarCount) { return(ODataPathKind.DollarCount); } else if (Segments.Last().Kind == ODataSegmentKind.TypeCast) { return(ODataPathKind.TypeCast); } else if (Segments.Last().Kind == ODataSegmentKind.ComplexProperty) { return(ODataPathKind.ComplexProperty); } else if (Segments.Any(c => c.Kind == ODataSegmentKind.StreamProperty || c.Kind == ODataSegmentKind.StreamContent)) { return(ODataPathKind.MediaEntity); } else if (Segments.Any(c => c.Kind == ODataSegmentKind.Ref)) { return(ODataPathKind.Ref); } else if (Segments.Any(c => c.Kind == ODataSegmentKind.OperationImport)) { return(ODataPathKind.OperationImport); } else if (Segments.Any(c => c.Kind == ODataSegmentKind.Operation)) { return(ODataPathKind.Operation); } else if (Segments.Any(c => c.Kind == ODataSegmentKind.NavigationProperty)) { return(ODataPathKind.NavigationProperty); } else if (Segments.Count == 1 && Segments[0] is ODataNavigationSourceSegment segment) { if (segment.NavigationSource is IEdmSingleton) { return(ODataPathKind.Singleton); } else { return(ODataPathKind.EntitySet); } } else if (Segments.Count == 2 && Segments.Last().Kind == ODataSegmentKind.Key) { return(ODataPathKind.Entity); } return(ODataPathKind.Unknown); }
/// <summary> /// Gets whether the specified offset is included in the selection. /// </summary> /// <returns>True, if the selection contains the offset (selection borders inclusive); /// otherwise, false.</returns> public virtual bool Contains(int offset) { if (IsEmpty) { return(false); } return(SurroundingSegment.Contains(offset, 0) && Segments.Any(s => s.Contains(offset, 0))); }
public bool Remove(Position p) { if (Segments.Any(s => s.Position == p)) { Segments.First(s => s.Position == p).RemoveElement(); return(true); } return(false); }
/// <summary> /// Pop the last segment. /// </summary> /// <returns>The pop last segment.</returns> internal ODataPath Pop() { if (!Segments.Any()) { throw Error.InvalidOperation(SRResource.ODataPathPopInvalid); } _pathKind = null; _defaultPathItemName = null; Segments.RemoveAt(Segments.Count - 1); return(this); }
public void ToAml(XmlWriter writer, AmlWriterSettings settings) { writer.WriteStartElement("Item"); writer.WriteAttributeString("type", Type); writer.WriteAttributeString("id", Id); writer.WriteAttributeString("action", "edit"); writer.WriteAttributeString("doGetItem", "0"); writer.WriteElementString("x", _context.Format(Position.X)); writer.WriteElementString("y", _context.Format(Position.Y)); if (Segments.Any()) { writer.WriteElementString("segments", Segments.GroupConcat("|", p => $"{p.X},{p.Y}")); } writer.WriteEndElement(); }
public Subpath(Point startPoint, [NotNull] IEnumerable <SegmentBase> segments, bool isClosed) { StartPoint = startPoint; Segments = segments.ToReadOnlyList(); IsClosed = isClosed; if (Segments.Any(x => x == null)) { throw new ArgumentException(); } if (Segments.Count > 0 && EndPoint != StartPoint) { _closingSegment = new LineSegment(StartPoint); } }
public Expression(IEnumerable <IExpressionSegment> segments) { if (segments == null) { throw new ArgumentNullException("segments"); } Segments = segments.ToList().AsReadOnly(); if (!Segments.Any()) { throw new ArgumentException("The segments set may not be empty"); } if (Segments.Any(t => t == null)) { throw new ArgumentException("Null reference encountered in segments set"); } }
private ODataPathKind CalcPathType() { if (Segments.Any(c => c.Kind == ODataSegmentKind.StreamProperty || c.Kind == ODataSegmentKind.StreamContent)) { return(ODataPathKind.MediaEntity); } else if (Segments.Any(c => c.Kind == ODataSegmentKind.Ref)) { return(ODataPathKind.Ref); } else if (Segments.Any(c => c.Kind == ODataSegmentKind.OperationImport)) { return(ODataPathKind.OperationImport); } else if (Segments.Any(c => c.Kind == ODataSegmentKind.Operation)) { return(ODataPathKind.Operation); } else if (Segments.Any(c => c.Kind == ODataSegmentKind.NavigationProperty)) { return(ODataPathKind.NavigationProperty); } if (Segments.Count == 1) { ODataNavigationSourceSegment segment = Segments[0] as ODataNavigationSourceSegment; if (segment != null) { if (segment.NavigationSource is IEdmSingleton) { return(ODataPathKind.Singleton); } else { return(ODataPathKind.EntitySet); } } } else if (Segments.Count == 2 && Segments.Last().Kind == ODataSegmentKind.Key) { return(ODataPathKind.Entity); } return(ODataPathKind.Unknown); }
protected virtual HttpUri CreateUri() { var url = BaseUrl.CombinePath(ResourceUrl).AddQueryParams(QueryParams.Concat(SuffixQueryParams)); if (Segments.Any()) { var fullUri = url.FullUri; foreach (var segment in Segments) { fullUri = fullUri.Replace(segment.Key, segment.Value); } url = new HttpUri(fullUri); } return(url); }
public string this[string propertyName] { get { try { string validationResult = String.Empty; if (ValidationEnabled) { switch (propertyName) { case "TaskSegment": if (TaskSegment < EnumSimpleCommandSegmentTask.Reset) { validationResult = ResourceReader.GetString("ERR_TASK"); } break; case "Segment": if (!Segments.Any(p => p == Segment)) { validationResult = ResourceReader.GetString("ERR_SEGMENT"); } break; } } Validator.AddOrUpdate(propertyName, validationResult == String.Empty); AllPropertiesValid = Validator.IsValid(); return(validationResult); } catch (Exception e) { _warehouse.AddEvent(Database.Event.EnumSeverity.Error, Database.Event.EnumType.Exception, string.Format("{0}.{1}: {2}", this.GetType().Name, (new StackTrace()).GetFrame(0).GetMethod().Name, e.Message)); Validator.AddOrUpdate(propertyName, false); AllPropertiesValid = Validator.IsValid(); return(ResourceReader.GetString("ERR_EXCEPTION")); } } }
private Segment[] JoinInternal(NodeEndpoint endpoint) { log.DebugFormat("Endpoint {0} joining", endpoint.Sync); endpoints.Add(endpoint); if (Segments.Any(x => x.BelongsTo(endpoint))) { log.DebugFormat("Endpoint {0} is already registered, probably an end point restart, ignoring", endpoint.Sync); return(Segments.Where(x => x.BelongsTo(endpoint)).ToArray()); } var thereAreSegementsWithNoowners = Segments .Any(x => x.AssignedEndpoint == null); if (thereAreSegementsWithNoowners) { Topology = new Topology(Segments .Where(x => x.AssignedEndpoint == null) .Select(x => new Segment { AssignedEndpoint = endpoint, Backups = x.Backups, Index = x.Index, InProcessOfMovingToEndpoint = x.InProcessOfMovingToEndpoint, PendingBackups = x.PendingBackups }).ToArray(), Topology.Version + 1 ); TopologyChanged(); log.DebugFormat("Endpoint {0} was assigned all segments without owners", endpoint.Sync); return(Segments.Where(x => x.AssignedEndpoint == endpoint).ToArray()); } log.DebugFormat("New endpoint {0}, allocating segments for it", endpoint.Sync); return(RestructureSegmentsFairly(endpoint)); }
//-------------------------------------------------------------------------------------------------- protected override bool MakeInternal(MakeFlags flags) { if (!Segments.Any() || !Points.Any()) { var makeVertex = new BRepBuilderAPI_MakeVertex(Pnt.Origin); BRep = makeVertex.Vertex(); HasErrors = false; return(base.MakeInternal(flags)); } // Create edges var freeSegmentEdges = new Dictionary <SketchSegment, TopoDS_Edge>(); foreach (var segmentKvp in _Segments) { var segment = segmentKvp.Value; if (segment.IsAuxilliary) { continue; } var segEdge = segment.MakeEdge(_Points); if (segEdge == null) { Messages.Warning($"The segment {segmentKvp.Key} of type {segment.GetType().Name} failed creating an edge."); continue; } freeSegmentEdges.Add(segment, segEdge); AddNamedSubshape("seg", segEdge, segmentKvp.Key); } // Create wires var wires = new List <TopoDS_Wire>(); while (freeSegmentEdges.Any()) { var nextSegmentEdge = freeSegmentEdges.First(); var frontSegment = nextSegmentEdge.Key; freeSegmentEdges.Remove(nextSegmentEdge.Key); var makeWire = new BRepBuilderAPI_MakeWire(nextSegmentEdge.Value); if ((frontSegment.StartPoint != -1) || (frontSegment.EndPoint != -1)) { var backSegment = frontSegment; while (freeSegmentEdges.Any()) { nextSegmentEdge = freeSegmentEdges.FirstOrDefault(kvp => kvp.Key.IsConnected(frontSegment)); if (nextSegmentEdge.Value != null) { frontSegment = nextSegmentEdge.Key; } else { nextSegmentEdge = freeSegmentEdges.FirstOrDefault(kvp => kvp.Key.IsConnected(backSegment)); if (nextSegmentEdge.Value != null) { backSegment = nextSegmentEdge.Key; } else { // disconnected segment break; } } makeWire.Add(nextSegmentEdge.Value); freeSegmentEdges.Remove(nextSegmentEdge.Key); } } // Get wire shape var wire = makeWire.Wire(); if (wire == null) { Messages.Error("Error when creating a wire."); return(false); } wires.Add(wire); } // Create resulting shape var builder = new TopoDS_Builder(); var shape = new TopoDS_Compound(); builder.MakeCompound(shape); foreach (var wire in wires) { builder.Add(shape, wire); } BRep = shape; return(base.MakeInternal(flags)); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Returns true if all the segments in the tier are not empty. /// </summary> /// ------------------------------------------------------------------------------------ public bool GetIsComplete() { return(Segments.Count > 0 && !Segments.Any(s => string.IsNullOrEmpty(s.Text))); }
public void ComputeFretShape() { VerifyIsStraight(); //if (!IsStraight && !Layout.CompensateFretPositions && Layout.FretsTemperament == Physics.Temperament.Equal && CheckForHardBreak()) // return; var layout = Segments[0].String.Layout; if (Segments.Any(s => s.IsNut && !s.IsVirtual) && !Segments.All(s => s.IsNut || s.IsVirtual)) { SeparateNutFromFrets(); return; } if (IsStraight && Segments.Count > 1) { var leftBound = layout.GetStringBoundaryLine(Segments.Last(fs => !fs.IsVirtual).String, FingerboardSide.Bass); var rightBound = layout.GetStringBoundaryLine(Segments.First(fs => !fs.IsVirtual).String, FingerboardSide.Treble); var line = Line.FromPoints(Segments.First().PointOnString.ToVector(), Segments.Last().PointOnString.ToVector()); Points.Add(PointM.FromVector(line.GetIntersection(leftBound.Equation), UnitOfMeasure.Centimeters)); Points.Add(PointM.FromVector(line.GetIntersection(rightBound.Equation), UnitOfMeasure.Centimeters)); } else { if (Layout.FretInterpolation == FretInterpolationMethod.Spline && StringCount >= 2) { foreach (var seg in Segments.Where(s => !s.IsVirtual || s.String.HasFret(s.FretIndex))) { Points.Add(seg.PointOnString); } InterpolateSplineV2(1d / (Segments.Count * 2.2)); ExtendToBorders(); } else if (Layout.FretInterpolation == FretInterpolationMethod.NotchedSpline && StringCount >= 2) { foreach (var seg in Segments.Where(s => !s.IsVirtual || s.String.HasFret(s.FretIndex))) { //Points.Add(seg.PointOnString + (seg.Direction * Measure.Mm(1.5))); Points.Add(PointM.Average(seg.P2, seg.PointOnString)); //Points.Add(seg.PointOnString); Points.Add(PointM.Average(seg.P1, seg.PointOnString)); //Points.Add(seg.PointOnString + (seg.Direction * -1 * Measure.Mm(1.5))); } InterpolateSpline(0.33, 0.4); ExtendToBorders(); } else { foreach (var seg in Segments.Where(s => !s.IsVirtual)) { Points.Add(seg.PointOnString); } ExtendToBorders(); } (Points as ObservableCollectionEx <PointM>).Reverse(); if (Points.Count == 2) { _IsStraight = true; } } }
public void WriteTo(BinaryWriter writer) { writer.Write(SRID); if (SRID == -1) { return; } writer.Write(Version); var properties = SerializationProperties.None; if (ZValues.Any()) { properties |= SerializationProperties.HasZValues; } if (MValues.Any()) { properties |= SerializationProperties.HasMValues; } if (IsValid) { properties |= SerializationProperties.IsValid; } if (Shapes.First().Type == OpenGisType.Point && Points.Any()) { properties |= SerializationProperties.IsSinglePoint; } if (Shapes.First().Type == OpenGisType.LineString && Points.Count == 2) { properties |= SerializationProperties.IsSingleLineSegment; } if (IsLargerThanAHemisphere) { properties |= SerializationProperties.IsLargerThanAHemisphere; } writer.Write((byte)properties); if (!properties.HasFlag(SerializationProperties.IsSinglePoint) && !properties.HasFlag(SerializationProperties.IsSingleLineSegment)) { writer.Write(Points.Count); } foreach (var point in Points) { point.WriteTo(writer); } foreach (var z in ZValues) { writer.Write(z); } foreach (var m in MValues) { writer.Write(m); } if (properties.HasFlag(SerializationProperties.IsSinglePoint) || properties.HasFlag(SerializationProperties.IsSingleLineSegment)) { return; } writer.Write(Figures.Count); if (Version == 1) { for (var shapeIndex = 0; shapeIndex < Shapes.Count; shapeIndex++) { var shape = Shapes[shapeIndex]; if (shape.FigureOffset == -1 || shape.IsCollection()) { continue; } var nextShapeIndex = shapeIndex + 1; while (nextShapeIndex < Shapes.Count && Shapes[nextShapeIndex].FigureOffset == -1) { nextShapeIndex++; } var lastFigureIndex = nextShapeIndex >= Shapes.Count ? Figures.Count - 1 : Shapes[nextShapeIndex].FigureOffset - 1; if (Shapes[shapeIndex].Type == OpenGisType.Polygon) { // NB: Although never mentioned in MS-SSCLRT (v20170816), exterior rings must be first writer.Write((byte)LegacyFigureAttribute.ExteriorRing); writer.Write(Figures[shape.FigureOffset].PointOffset); for (var figureIndex = shape.FigureOffset + 1; figureIndex <= lastFigureIndex; figureIndex++) { writer.Write((byte)LegacyFigureAttribute.InteriorRing); writer.Write(Figures[figureIndex].PointOffset); } continue; } for (var figureIndex = shape.FigureOffset; figureIndex <= lastFigureIndex; figureIndex++) { writer.Write((byte)LegacyFigureAttribute.Stroke); writer.Write(Figures[figureIndex].PointOffset); } } } else { foreach (var figure in Figures) { figure.WriteTo(writer); } } writer.Write(Shapes.Count); foreach (var shape in Shapes) { shape.WriteTo(writer); } if (Segments.Any()) { writer.Write(Segments.Count); foreach (var segment in Segments) { segment.WriteTo(writer); } } }
private bool _anySegmentHit(Coordinates hitCoordinates) => Segments.Any(x => x.Coordinates.Equals(hitCoordinates));