public void Remove_CorrectRemoveOfSegments_ReturnsNothing() { var segments = new Segments(); var segmentTest1 = new VolarisSegment { ID = "120", DepartureStation = "MEX", ArrivalStation = "CUN", DepartureTime = DateTime.Now, ArrivalTime = DateTime.Now.AddHours(3), Type = SegmentType.Connection }; var segmentTest2 = new VolarisSegment { ID = "123", DepartureStation = "MEX", ArrivalStation = "MTY", DepartureTime = DateTime.Now, ArrivalTime = DateTime.Now.AddHours(2), Type = SegmentType.Connection }; segments.Add(segmentTest1); segments.Add(segmentTest2); segments.Remove(segmentTest1); Assert.IsTrue(segments.GetAll().Count == 1, "No se removieron correctamente los segmentos"); }
/// <summary> /// Process whole message. /// </summary> /// <returns>Result flag</returns> public bool Process() { if (string.IsNullOrWhiteSpace(content)) { return(false); } // MSH must at the begining of the messge bool ok = false; foreach (string s in content.Split(new string[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries)) { ok |= s.StartsWith("MSH", StringComparison.OrdinalIgnoreCase); Segments.Add(new Segment(s, Version)); } foreach (string s in content.Split(new string[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries)) { Segments.Add(new Segment(s, Version)); } if (!ok) { throw new Exception("Incorrect message header"); } throw new NotImplementedException(); }
/// <summary> /// Adds a new segment in the list of segments of this surface /// </summary> /// <param name="segment"></param> public void AddSegment(Segment segment) { foreach (Segment other in Segments) { if (segment.Start < other.Start) { if (segment.End > other.End) { Segment s2 = new Segment(other.End, segment.End, segment.Graph); AddSegment(s2); } segment.End = other.Start; } else { // segment.Start > other.Start if (segment.Start < other.End) { if (segment.End < other.End) { segment = null; break; } segment.Start = Math.Min(segment.End, other.End); } } } if (segment != null) { Segments.Add(segment); } }
internal void OnAreasLoaded(int messageId, List <ClientArea> areas) { List <ClientSegment> segments = new List <ClientSegment>(areas.Count * 512); foreach (ClientArea area in areas) { List <ClientSegment> areaSegments = area.GetSegments(); segments.AddRange(areaSegments); Areas.Add(area.Key, area); foreach (ClientSegment segment in areaSegments) { Segments.Add(segment.Key, segment); } } LoadRequest request = new LoadRequest() { Entity = _Player, MessageId = messageId }; OnAreasLoaded(request, areas, segments); if (_Player.CurrentSegment == null) { // prepare the player _Player.HandleMovement(); } }
/// <summary> /// Close <c>PolyLine2D</c> by a LineSegment. /// </summary> public void Close() { if (Segments.Count > 0 && StartPoint != Segments[Segments.Count - 1].EndPoint) { Segments.Add(new LineSegment2D(StartPoint)); } }
internal override void ParseXml(XmlElement xml) { base.ParseXml(xml); foreach (XmlNode child in xml.ChildNodes) { string name = child.Name; if (string.Compare(name, "BaseCurve", true) == 0) { BaseCurve = mDatabase.ParseXml <IfcBoundedCurve>(child as XmlElement); } else if (string.Compare(name, "Segments") == 0) { foreach (XmlNode cn in child.ChildNodes) { IfcCurveSegment o = mDatabase.ParseXml <IfcCurveSegment>(cn as XmlElement); if (o != null) { Segments.Add(o); } } } else if (string.Compare(name, "EndPoint", true) == 0) { EndPoint = mDatabase.ParseXml <IfcCartesianPoint>(child as XmlElement); } } }
/// <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; }
//-------------------------------------------------------------------------------------------------- public int AddSegment(SketchSegment segment) { var index = Segments.Keys.Any() ? Segments.Keys.Max() + 1 : 0; Segments.Add(index, segment); return(index); }
internal override void ParseXml(XmlElement xml) { base.ParseXml(xml); foreach (XmlNode child in xml.ChildNodes) { string name = child.Name; if (string.Compare(name, "Points") == 0) { Points = mDatabase.ParseXml <IfcCartesianPointList>(child as XmlElement); } else if (string.Compare(name, "Segments") == 0) { foreach (XmlNode node in child.ChildNodes) { List <int> ints = node.InnerText.Split(" ".ToCharArray()).ToList().ConvertAll(x => int.Parse(x)); if (string.Compare("IfcLineIndex-wrapper", node.Name) == 0) { Segments.Add(new IfcLineIndex(ints)); } else { Segments.Add(new IfcArcIndex(ints[0], ints[1], ints[2])); } } } } if (xml.HasAttribute("SelfIntersect")) { mSelfIntersect = bool.Parse(xml.Attributes["SelfIntersect"].Value) ? IfcLogicalEnum.TRUE : IfcLogicalEnum.FALSE; } }
/// <summary> /// Populates the element (including children) with information from its XML definition. /// </summary> /// <param name="Input">XML definition.</param> public override void FromXml(XmlElement Input) { base.FromXml(Input); List <ISegment> Segments = null; foreach (ILayoutElement Child in this.Children) { if (Child is ISegment Segment) { if (Segments is null) { Segments = new List <ISegment>(); } Segments.Add(Segment); } else { throw new LayoutSyntaxException("Not a segment type: " + Child.Namespace + "#" + Child.LocalName); } } this.segments = Segments?.ToArray(); }
public MetadataBuilder(MetadataHeader header) { _header = header; Segments.Add(header); Segments.Add(_streamBuilder = new StreamTableBuilder()); }
/// <summary> /// Class constructor /// </summary> /// <param name="messageSubType">ORU Message Sub Type.</param> public OruMessage(System.String messageSubType) : base("ORU", messageSubType) { Hl7Segment segment = new Hl7Segment(1, Hl7SegmentEnum.PID); Segments.Add(segment.SegmentId.Id, segment); segment = new Hl7Segment(2, Hl7SegmentEnum.PD1); Segments.Add(segment.SegmentId.Id, segment); segment = new Hl7Segment(3, Hl7SegmentEnum.NK1); Segments.Add(segment.SegmentId.Id, segment); segment = new Hl7Segment(4, Hl7SegmentEnum.PV1); Segments.Add(segment.SegmentId.Id, segment); segment = new Hl7Segment(5, Hl7SegmentEnum.PV2); Segments.Add(segment.SegmentId.Id, segment); segment = new Hl7Segment(6, Hl7SegmentEnum.ORC); Segments.Add(segment.SegmentId.Id, segment); segment = new Hl7Segment(7, Hl7SegmentEnum.OBR); Segments.Add(segment.SegmentId.Id, segment); segment = new Hl7Segment(8, Hl7SegmentEnum.NTE); Segments.Add(segment.SegmentId.Id, segment); segment = new Hl7Segment(9, Hl7SegmentEnum.OBX); Segments.Add(segment.SegmentId.Id, segment); segment = new Hl7Segment(10, Hl7SegmentEnum.CTI); Segments.Add(segment.SegmentId.Id, segment); segment = new Hl7Segment(11, Hl7SegmentEnum.DSC); Segments.Add(segment.SegmentId.Id, segment); segment = new Hl7Segment(12, Hl7SegmentEnum.ZDS); Segments.Add(segment.SegmentId.Id, segment); }
public CompositionViewModel() { _fileText = "abcdefghijklmnopqrstuvwxyz"; Segments.Add(new SegmentViewModel(0, 5, _fileText)); Segments.Add(new SegmentViewModel(5, 5, _fileText)); Segments.Add(new SegmentViewModel(10, 5, _fileText)); }
public Cable(ConnectionNode startNode) { StartNode = startNode; Segments.Add(new CableSegment(this, Segments.Count)); Segments.Add(new CableSegment(this, Segments.Count)); }
internal override void ParseXml(XmlElement xml) { base.ParseXml(xml); string height = xml.GetAttribute("Height"); if (!string.IsNullOrEmpty(height)) { double.TryParse(height, out mHeight); } foreach (XmlNode child in xml.ChildNodes) { string name = child.Name; if (string.Compare(name, "BaseCurve", true) == 0) { BaseCurve = mDatabase.ParseXml <IfcBoundedCurve>(child as XmlElement); } else if (string.Compare(name, "Segments") == 0) { foreach (XmlNode cn in child.ChildNodes) { IfcCurveSegment o = mDatabase.ParseXml <IfcCurveSegment>(cn as XmlElement); if (o != null) { Segments.Add(o); } } } else if (string.Compare(name, "EndPoint", true) == 0) { EndPoint = mDatabase.ParseXml <IfcCartesianPoint>(child as XmlElement); } } }
private void CalculateSegments() { if (Segments == null) { Segments = new List <ISegment>(); } else { Segments.Clear(); } // 2 // x-------x // | | // 3 | o | 4 // | | // x-------x // 1 Segments.Add(new LineSegment( new Point(Centre.X - (Width / 2) + (Shrink / 2), Centre.Y - (Height / 2) + (Shrink / 2)), new Point(Centre.X + (Width / 2) - (Shrink / 2), Centre.Y - (Height / 2) + (Shrink / 2)))); Segments.Add(new LineSegment( new Point(Centre.X - (Width / 2) + (Shrink / 2), Centre.Y + (Height / 2) - (Shrink / 2)), new Point(Centre.X + (Width / 2) - (Shrink / 2), Centre.Y + (Height / 2) - (Shrink / 2)))); Segments.Add(new LineSegment( new Point(Centre.X - (Width / 2) + (Shrink / 2), Centre.Y - (Height / 2) + (Shrink / 2)), new Point(Centre.X - (Width / 2) + (Shrink / 2), Centre.Y + (Height / 2) - (Shrink / 2)))); Segments.Add(new LineSegment( new Point(Centre.X + (Width / 2) - (Shrink / 2), Centre.Y - (Height / 2) + (Shrink / 2)), new Point(Centre.X + (Width / 2) - (Shrink / 2), Centre.Y + (Height / 2) - (Shrink / 2)))); }
public FileSegment GetLookupSegment(ImageSymbolImport symbolImport) { FileSegment segment; if (!_lookupSegments.TryGetValue(symbolImport, out segment)) { if (symbolImport.IsImportByOrdinal) { segment = DataSegment.CreateNativeInteger(symbolImport.Lookup, Is32Bit); } else if (symbolImport.HintName != null) { _nameTableBuffer.AddHintNameSegment(symbolImport.HintName); segment = new PointerSegment(symbolImport.HintName, _offsetConverter, Is32Bit); } else { segment = DataSegment.CreateNativeInteger(0, Is32Bit); } _lookupSegments.Add(symbolImport, segment); Segments.Add(segment); } return(segment); }
protected override void Algorithm() { m_processStack = new Stack <Vector3>(); int cacheRootA; int cacheRootB; STSegment cacheSegment; m_processStack.Push(InputPoints[Random.Range(0, InputPoints.Count)]); while (m_processStack.Count != 0) { cacheSegment = GetRandomSegment(m_processStack.Peek()); if (cacheSegment == null) { m_processStack.Pop(); continue; } cacheRootA = FindRoot(cacheSegment.PointAIndex); cacheRootB = FindRoot(cacheSegment.PointBIndex); if (cacheRootA != cacheRootB) { UnionSet(cacheSegment.PointAIndex, cacheSegment.PointBIndex); Segments.Add(cacheSegment); } RemoveSegment(cacheSegment); AddProcess(cacheSegment); } }
public NetTextBuilder(ImageNetDirectory directory) { _directory = directory; ImportBuilder = new ImageImportDirectoryBuilder(directory.Assembly, directory.Assembly.ImportDirectory); Segments.Add(ImportBuilder.AddressTablesBuilder); Segments.Add(directory); Segments.Add(MethodBodyTableBuilder = new MethodBodyTableBuilder()); Segments.Add(NetResourceDirectoryBuilder = new NetResourceDirectoryBuilder()); Segments.Add(DataBuilder = new NetDataTableBuilder()); if (directory.StrongNameData != null) { Segments.Add(directory.StrongNameData); } Segments.Add(Metadata = new MetadataBuilder(directory.MetadataHeader)); if (directory.Assembly.DebugDirectory != null) { Segments.Add(directory.Assembly.DebugDirectory); Segments.Add(directory.Assembly.DebugDirectory.Data); } Segments.Add(ImportBuilder); Segments.Add(StartupCode = new StartupCodeSegmentBuilder()); }
/// ------------------------------------------------------------------------------------ public AnnotationSegment AddSegment(string text) { var segment = new AnnotationSegment(this, text ?? string.Empty); Segments.Add(segment); return(segment); }
/// ------------------------------------------------------------------------------------ public AnnotationSegment AddSegment(float start, float stop) { var segment = new AnnotationSegment(this, start, stop); Segments.Add(segment); return(segment); }
private void InitializeBluePrint() { Segments.Add(Assembly.DosHeader); Segments.Add(Assembly.NtHeaders); Segments.Add(_sectionsTableBuilder); _textSectionBuilder = _sectionsTableBuilder.GetSectionBuilder(".text"); _textSectionBuilder.Header.Attributes = ImageSectionAttributes.MemoryExecute | ImageSectionAttributes.MemoryRead | ImageSectionAttributes.ContentCode; _textSectionBuilder.Segments.Add(TextBuilder = new NetTextBuilder(Assembly.NetDirectory)); if (Assembly.RootResourceDirectory != null) { _rsrcSectionBuilder = _sectionsTableBuilder.GetSectionBuilder(".rsrc"); _rsrcSectionBuilder.Header.Attributes = ImageSectionAttributes.MemoryRead | ImageSectionAttributes.ContentInitializedData; } if (Assembly.RelocationDirectory != null) { _relocSectionBuilder = _sectionsTableBuilder.GetSectionBuilder(".reloc"); _relocSectionBuilder.Header.Attributes = ImageSectionAttributes.MemoryRead | ImageSectionAttributes.MemoryDiscardable | ImageSectionAttributes.ContentInitializedData; } }
public void Move(bool addSegment = false, bool sendEvent = true) { if (Direction == GameDirection.Stopped || Segments.Count < 2) { return; } GameObject tail = Segments[Segments.Count - 1]; GameObject nseg = GetNextSegment(); float tailX = tail.X; float tailY = tail.Y; for (int i = Segments.Count - 1; i > 0; i--) { Segments[i].X = Segments[i - 1].X; Segments[i].Y = Segments[i - 1].Y; } if (addSegment) { Segments.Add(new GameObject(tailX, tailY, tail.Width, tail.Height)); } Segments[0].X = nseg.X; Segments[0].Y = nseg.Y; if (sendEvent) { SnakeMove?.Invoke(this, new SnakeEventArgs(Segments, Direction)); } }
public void AddHintNameSegment(HintName hintName) { if (!Segments.Contains(hintName)) { Segments.Add(hintName); } }
private void AddSegment() { var seg = TvShowSegment.NewSegment(_tvShow.id); Segments.Add(seg); SelectedSegment = seg; }
public ImageSegment AddSegment(ImageSegment segNew) { if (!TryFindSegment(segNew.Address, out ImageSegment seg)) { EnsureSegmentSize(segNew); Segments.Add(segNew.Address, segNew); SegmentByLinAddress.Add(segNew.Address.ToLinear(), segNew); MapChanged?.Fire(this); //DumpSections(); return(segNew); } long delta = segNew.Address - seg.Address; Debug.Assert(delta >= 0); if (delta > 0) { // Need to split the segment if it has a size // x86 real mode segments don't have sizes, and can overlap. var segSplit = new ImageSegment(segNew.Name, segNew.Address, segNew.MemoryArea, segNew.Access); segSplit.Size = (uint)(seg.Size - delta); seg.Size = (uint)delta; Segments.Add(segNew.Address, segSplit); SegmentByLinAddress.Add(segNew.Address.ToLinear(), segSplit); // And split any items in the segment MapChanged?.Fire(this); //DumpSections(); return(segSplit); } return(seg); }
public PolyCurve(List <Curve> segments) { foreach (var seg in segments) { Segments.Add(seg); } }
/// <summary> /// Initializes a new instance of the <see cref="ZeroitDecimalCell"/> class. /// </summary> public ZeroitDecimalCell() { Value = '.'; m_segmentA.Color = this.ForeColor; m_segmentB.Color = this.ForeColor; m_segmentC.Color = this.ForeColor; m_segmentA.OpacityWhenOff = this.OpacityWhenOff; m_segmentB.OpacityWhenOff = this.OpacityWhenOff; m_segmentC.OpacityWhenOff = this.OpacityWhenOff; //never use internal padding for this type of cell m_segmentA.Padding = 0; m_segmentB.Padding = 0; m_segmentC.Padding = 0; //corners for the comma m_segmentC.Corners = SegmentCorners.TopLeft | SegmentCorners.TopRight | SegmentCorners.BottomRight; Segments.Add(m_segmentA); Segments.Add(m_segmentB); Segments.Add(m_segmentC); InitializeComponent(); }
/// <summary> /// Class constructor - ACK /// </summary> /// <param name="messageSubType">ACK Message Sub Type.</param> public AckMessage(System.String messageSubType) : base("ACK", messageSubType) { Hl7Segment segment = new Hl7Segment(1, Hl7SegmentEnum.MSA); Segments.Add(segment.SegmentId.Id, segment); segment = new Hl7Segment(2, Hl7SegmentEnum.ERR); Segments.Add(segment.SegmentId.Id, segment); }
/// <summary> /// Creates the segments of FastLineSeries. /// </summary> public override void CreateSegments() { if (GroupedSeriesYValues != null && GroupedSeriesYValues[0].Contains(double.NaN)) { List <List <double> > yValList; List <List <double> > xValList; this.CreateEmptyPointSegments(GroupedSeriesYValues[0], out yValList, out xValList); } else if (YValues.Contains(double.NaN)) { List <List <double> > yValList; List <List <double> > xValList; this.CreateEmptyPointSegments(YValues, out yValList, out xValList); } else { bool isGrouping = this.ActualXAxis is CategoryAxis ? (this.ActualXAxis as CategoryAxis).IsIndexed : true; if (!isGrouping) { xValues = GroupedXValuesIndexes; } else { xValues = (ActualXValues is IList <double> && !IsIndexed) ? ActualXValues as IList <double> : GetXValues(); } if (!isGrouping) { Segments.Clear(); Adornments.Clear(); if (Segment == null || Segments.Count == 0) { FastLineSegment segment = new FastLineSegment(xValues, GroupedSeriesYValues[0], this); Segment = segment; Segments.Add(segment); } } else { ClearUnUsedAdornments(this.DataCount); if (Segment == null || Segments.Count == 0) { FastLineSegment segment = new FastLineSegment(xValues, YValues, this); Segment = segment; Segments.Add(segment); } else if (ActualXValues != null) { Segment.SetData(xValues, YValues); (Segment as FastLineSegment).SetRange(); Segment.Item = ActualData; } } isAdornmentPending = true; } }
private Segments CreateSegmentsMultipleMatches(string source) { Segments segments = new Segments(); foreach (Regex pattern in _patterns) { MatchCollection matches = pattern.Matches(source); if (matches != null) { foreach (Match match in matches) { segments.Add(new Segment(match.Value)); } } } return segments; }
private Segments CreateSegmentsFirstMatch(string source) { Segments segments = new Segments(); foreach (Regex pattern in _patterns) { Match match = pattern.Match(source); if (match != null && match.Success) segments.Add(new Segment(match.Value)); else segments.Add(new Segment(string.Empty)); } return segments; }
/// <summary> /// Returns the segments from the source string. Where a segment returns nothing /// a single empty segment will be added. /// </summary> /// <param name="source"></param> /// <returns></returns> internal override Segments CreateAllSegments(string source) { Segments results = new Segments(); foreach (RegexSegment segment in _segments) { results.Add(CreateSegments(source, segment)); } return results; }