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;
}
