public void SequenceItemActionRun_ScribanSubstitute()
{
/* 𝓐𝓻𝓻𝓪𝓷𝓰𝓮... */
var testSequenceItem = new SequenceItem
{
command = "test-cmd-script",
run = new Run {
exec = "{{model.param1}}"
}
};
var testModel = new { param1 = ExecutableFilename };
var dummyRunState = new RunState {
YamlOptions = new YamlScript {
sequence_items = new[] { testSequenceItem }.ToList()
}
};
var testSequenceItemAction = new SequenceItemRun(dummyRunState, testSequenceItem, testModel, new List <SequenceItem>());
/* 𝓐𝓬𝓽 */
var actual = (string)testSequenceItemAction.ActionAsync(new CancellationToken()).Result;
/* 𝓐𝓼𝓼𝓮𝓻𝓽 */
Assert.False(testSequenceItemAction.IsFail);
Assert.Null(testSequenceItemAction.Exception);
Assert.EndsWith(ExecutableExpectedResult, actual);
}
public static dynamic GetResponseItems(RunState state, SequenceItem sequenceItem, string content)
{
dynamic responseModel;
var item_quantity_cap = sequenceItem?.take_only_n;
try
{
if (item_quantity_cap != null)
{
state.ProgressLog?.Progress($" taking the first {item_quantity_cap} results only...");
}
if (item_quantity_cap != null)
{
responseModel = JsonConvert.DeserializeObject <List <IDictionary <string, object> > >(content).Take(item_quantity_cap.Value).ToList();
}
else
{
try {
responseModel = JsonConvert.DeserializeObject <List <IDictionary <string, object> > >(content);
} catch {
responseModel = JsonConvert.DeserializeObject <IDictionary <string, object> >(content);
}
}
}
catch
{
responseModel = content;
}
return(responseModel);
}
public void SequenceItemActionCheck_ExpectSuccess()
{
/* 𝓐𝓻𝓻𝓪𝓷𝓰𝓮... */
var testSequenceItem = new SequenceItem
{
command = "check-item",
check = new SequenceCheck {
pass_template = "true"
}
};
var dummyRunState = new RunState {
YamlOptions = new YamlScript {
sequence_items = new[] { testSequenceItem }.ToList()
}
};
var testModel = new { SomeData = "this is some data" };
var testSequenceItemAction = new SequenceItemCheck(dummyRunState, testSequenceItem, testModel, new List <SequenceItem>());
/* 𝓐𝓬𝓽 */
var actual = testSequenceItemAction.ActionAsync(new CancellationToken()).Result;
/* 𝓐𝓼𝓼𝓮𝓻𝓽 */
Assert.False(testSequenceItemAction.IsFail);
Assert.Null(testSequenceItemAction.Exception);
Assert.Equal(JsonConvert.SerializeObject(testModel), JsonConvert.SerializeObject(actual));
}
public void SequenceItemActionCheck_ScribanSubstitute_CheckPasses()
{
/* 𝓐𝓻𝓻𝓪𝓷𝓰𝓮... */
var testSequenceItem = new SequenceItem
{
command = "test-check-item-sriban-expect-pass",
check = new SequenceCheck {
pass_template = "{{if model.someData == 'the correct data'}}true{{else}}false{{end}}", fail_message_template = "Check failed with value: {{model.someData}}"
}
};
var testModel = new { someData = "the correct data" };
var dummyRunState = new RunState {
YamlOptions = new YamlScript {
sequence_items = new[] { testSequenceItem }.ToList()
}
};
var testSequenceItemAction = new SequenceItemCheck(dummyRunState, testSequenceItem, testModel, new List <SequenceItem>());
/* 𝓐𝓬𝓽 */
var actual = testSequenceItemAction.ActionAsync(new CancellationToken()).Result;
/* 𝓐𝓼𝓼𝓮𝓻𝓽 */
Assert.False(testSequenceItemAction.IsFail);
Assert.Null(testSequenceItemAction.Exception);
Assert.Equal(JsonConvert.SerializeObject(testModel), JsonConvert.SerializeObject(actual));
}
public BeamLimitingDevicePosition(SequenceItem si)
{
if (si.Find(TagHelper.RTBEAM_LIMITING_DEVICE_TYPE) != null)
{
this.si = si;
}
}
// -------------------------------
// - Begin public methods region -
// -------------------------------
/// <summary>
/// Convert a HLI Attribute Set to a AttributeLayer Attribute Set.
/// </summary>
/// <param name="attributeSetIn">The HLI Attribute Set.</param>
/// <param name="attributeSetOut">The AttributeLayer Attribute Set.</param>
public static void ToAttributeSet(DvtkHighLevelInterface.Dicom.Other.AttributeSet attributeSetIn, Dvtk.Dicom.AttributeLayer.AttributeSet attributeSetOut)
{
for (int index = 0; index < attributeSetIn.Count; index++)
{
DvtkHighLevelInterface.Dicom.Other.Attribute hliAttribute = attributeSetIn[index];
Tag tag = new Tag(hliAttribute.GroupNumber, hliAttribute.ElementNumber);
if (hliAttribute.VR != DvtkData.Dimse.VR.SQ)
{
SingleAttribute singleAttribute = new SingleAttribute(tag, (VR)Enum.Parse(typeof(VR), hliAttribute.VR.ToString(), true), attributeSetOut);
}
else
{
SequenceAttribute sequenceAttribute = new SequenceAttribute(tag, attributeSetOut);
for (int sequenceItemIndex = 1; sequenceItemIndex <= hliAttribute.ItemCount; sequenceItemIndex++)
{
DvtkHighLevelInterface.Dicom.Other.SequenceItem hliSequenceItem = hliAttribute.GetItem(sequenceItemIndex);
SequenceItem sequenceItem = new SequenceItem(sequenceAttribute);
ToAttributeSet(hliSequenceItem, sequenceItem);
}
}
}
}
/// <summary>
/// Create both a Content Item instance and all its direct and indirect child Content Item instances.
/// </summary>
/// <param name="attributeSet">
/// <param name="dataSet">
/// The AttributeSet instance containing the DICOM attributes to construct this Content
/// Item instance and its direct and indirect child Content Item instances with.
/// </param>
/// </param>
/// <param name="parentContentItem">
/// The parent Content Item instance.
/// If no parent exists, supply null.
/// </param>
/// <param name="position">
/// The ordinal position of the associated Sequence Item in it's contained Content Sequence.
/// Item.
/// </param>
/// <returns>A Content Item instance.</returns>
private static ContentItem CreateContentItems(AttributeSet attributeSet, ContentItem parentContentItem, uint position)
{
//
// Create the single Content Item instance using the Attribute Set instance supplied.
//
ContentItem contentItem = CreateContentItem(attributeSet, parentContentItem, position);
//
// If existing, create its child Content Item instances.
//
DvtkHighLevelInterface.Dicom.Other.Attribute attribute = attributeSet["0x0040A730"]; // Content Sequence Attribute.
if (attribute.Exists)
{
if (attribute.VR == VR.SQ)
{
for (uint sequenceItemIndex = 1; sequenceItemIndex <= attribute.ItemCount; sequenceItemIndex++)
{
SequenceItem sequenceItem = attribute.GetItem(System.Convert.ToInt32(sequenceItemIndex));
ContentItem childContentItem = CreateContentItems(sequenceItem, contentItem, sequenceItemIndex);
contentItem.childContentItems.Add(childContentItem);
}
}
}
return(contentItem);
}
/// <summary>
/// Determines whether the specified <see cref="SequenceItem"/> is
/// equal to the current <see cref="SequenceItem"/>.
/// </summary>
/// <param name="other">
/// The <see cref="SequenceItem"/> to compare with the current
/// <see cref="SequenceItem"/>.
/// </param>
/// <returns>
/// <c>true</c> if the specified <see cref="SequenceItem"/> is equal
/// to the current <see cref="SequenceItem"/>; otherwise,
/// <c>false</c>.
/// </returns>
public bool Equals(SequenceItem other)
{
return(other != null &&
object.Equals(this.Start, other.Start) &&
object.Equals(this.End, other.End) &&
object.Equals(this.SequenceId, other.SequenceId) &&
EnumerableUtils.NullTolerantSequenceEqual(this.Participants, other.Participants));
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="sequenceItem">The single sequence item that encodes this Measured Value.</param>
public MeasuredValue(SequenceItem sequenceItem)
{
this.sequenceItem = sequenceItem;
this.measurementUnits = ConceptCode.CreateConceptCode(sequenceItem, "0x004008EA", measurementUnitsContext);
this.validationResults = new ValidationResults(context);
}
public void Started(string runid, SequenceItem sequenceItem)
{
this.runid = runid;
var msg = $"{runid,padWidth} - {nameof(Started)}:{sequenceItem.command}";
Logger.Info(msg);
Console.WriteLine(msg.Trim());
}
public ControlPoint(SequenceItem si)
{
if (si.Find(TagHelper.CONTROL_POINT_INDEX) != null)
{
this.si = si;
BeamLimitingDevicePosSequence test = this.BeamLimitingDeviceSequence;
}
}
public void Success(SequenceItem successWith)
{
ProgressLog.Clear();
var msg = $"{runid,padWidth} - Success:{successWith.command}";
Logger.Info(msg);
Console.WriteLine(msg.Trim());
}
public void Read_TextLiteral()
{
var s = WriteTest("TextLiteral.xaml");
var sequence = new SequenceItem[] {
};
ReadSequence("TextLiteral.xaml", sequence);
}
public void Read_WhiteSpacePreservation()
{
var s = WriteTest("WhiteSpacePreservation.xaml");
var sequence = new SequenceItem[] {
};
ReadSequence("WhiteSpacePreservation.xaml", sequence);
}
public void Read_Binding2_SemanticStylesResource()
{
var s = WriteTest("Binding2_SemanticStylesResources.xaml");
var sequence = new SequenceItem[] {
};
ReadSequence("Binding2_SemanticStylesResources.xaml", sequence);
}
public void Read_xBind()
{
var s = WriteTest("xBind.xaml");
var sequence = new SequenceItem[] {
};
ReadSequence("xBind.xaml", sequence);
}
public void Read_RunSpace()
{
var s = WriteTest("RunSpace02.xaml");
var sequence = new SequenceItem[] {
};
ReadSequence("RunSpace02.xaml", sequence);
}
public void Unidentified()
{
ISequenceItem item = new SequenceItem(UnidentifiedBoat, DateTime.Now, string.Empty);
_location.SequenceItems.Add(item);
_repos.ForEach(r => r.LogATime(_location, item));
Finished.Clear();
_location.SequenceItems.OrderByDescending(i => i.TimeStamp).ForEach(Finished.Add);
}
public void Read_AttachedPropertyWithoutNamespace()
{
var s = WriteTest("AttachedPropertyWithoutNamespace.xaml");
var sequence = new SequenceItem[] {
};
ReadSequence("AttachedPropertyWithoutNamespace.xaml", sequence);
}
public void Read_AttachedProperty()
{
var s = WriteTest("AttachedProperty.xaml");
var sequence = new SequenceItem[] {
};
ReadSequence("AttachedProperty.xaml", sequence);
}
public SequenceBuilder WithSequenceItem(string value, int nextItem)
{
var sequenceItem = new SequenceItem {
Value = value, NextItem = nextItem
};
sequence.Add(sequenceItem);
return(this);
}
public void Read_GenericNative3()
{
var s = WriteTest("GenericNative3.xaml");
var sequence = new SequenceItem[] {
};
ReadSequence("GenericNative2.xaml", sequence);
}
public void Read_GenericSimple()
{
var s = WriteTest("GenericSimple.xaml");
var sequence = new SequenceItem[] {
};
ReadSequence("TextContent.xaml", sequence);
}
public void Read_TextContent()
{
var s = WriteTest("TextContent.xaml");
var sequence = new SequenceItem[] {
};
ReadSequence("TextContent.xaml", sequence);
}
private static void Save(SequenceItem item)
{
lock (mAccessor)
{
string value = item.Name + "=" + item.Value.ToString();
Int16 length = (Int16)Encoding.UTF8.GetBytes(value, 0, value.Length, mBuffer, 2);
BitConverter.GetBytes(length).CopyTo(mBuffer, 0);
mAccessor.WriteArray <byte>(item.Index * mRecordSize, mBuffer, 0, mBuffer.Length);
}
}
private static HttpClient MakeClientWithHeaders(Options o, YamlScript yaml, SequenceItem entry = null)
{
var client = new HttpClient();
const int defaultClientTimeoutSeconds = 90;
client.Timeout = TimeSpan.FromSeconds(yaml.client_timeout_seconds ?? defaultClientTimeoutSeconds);
var scribanModel = new { yaml.run_id, command_args = o, model = new { } };
client.DefaultRequestHeaders.Accept.Clear();
if (entry?.send?.header != null)
{
/* UN TESTED - for POST*/
//Add customer headers
foreach (var addHeader in entry.send.header)
{
if (addHeader.Key.Equals("accept", StringComparison.InvariantCultureIgnoreCase))
{
var vals = ScribanUtil.ScribanParse(addHeader.Value, scribanModel);
foreach (var val in vals.Split(',').Select(s => s.Trim()))
{
var queryParts = val.Split(';');
if (queryParts.Length > 1)
{
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue(queryParts[0]));
foreach (var queryPart in queryParts.Skip(1))
{
var keyVal = queryPart.Split('=');
client.DefaultRequestHeaders.Add(keyVal[0], keyVal[1]);
}
}
else
{
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue(val));
}
}
}
else
{
client.DefaultRequestHeaders.Add(addHeader.Key, ScribanUtil.ScribanParse(addHeader.Value, scribanModel));
}
}
}
var contenType = entry.send.content_type ?? "text/plain";
if (client.DefaultRequestHeaders.Accept.Count == 0)
{
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue(contenType));
}
return(client);
}
public void Original_Read_SystemResourcesResources()
{
var s = WriteTest("Simple_SemanticStylesResources.xaml");
var sequence = new SequenceItem[] {
new SequenceItem {
NodeType = XamlNodeType.NamespaceDeclaration,
},
new SequenceItem {
NodeType = XamlNodeType.NamespaceDeclaration,
},
new SequenceItem {
NodeType = XamlNodeType.StartObject, TypeName = "{http://schemas.microsoft.com/winfx/2006/xaml/presentation}ResourceDictionary"
},
new SequenceItem {
NodeType = XamlNodeType.StartMember, MemberType = "{http://schemas.microsoft.com/winfx/2006/xaml}_UnknownContent",
},
new SequenceItem {
NodeType = XamlNodeType.StartObject, TypeName = "{http://schemas.microsoft.com/winfx/2006/xaml/presentation}Color"
},
new SequenceItem {
NodeType = XamlNodeType.StartMember, MemberType = "{http://schemas.microsoft.com/winfx/2006/xaml}Key",
},
new SequenceItem {
NodeType = XamlNodeType.Value, Value = "AppWhiteColor",
},
new SequenceItem {
NodeType = XamlNodeType.EndMember,
},
new SequenceItem {
NodeType = XamlNodeType.StartMember, MemberType = "{http://schemas.microsoft.com/winfx/2006/xaml}_UnknownContent",
},
new SequenceItem {
NodeType = XamlNodeType.Value, Value = "#FFFFFFFF",
},
new SequenceItem {
NodeType = XamlNodeType.EndMember,
},
new SequenceItem {
NodeType = XamlNodeType.EndObject,
},
new SequenceItem {
NodeType = XamlNodeType.EndMember,
},
new SequenceItem {
NodeType = XamlNodeType.EndObject,
},
new SequenceItem {
NodeType = XamlNodeType.None,
},
};
ReadSequence("Simple_SemanticStylesResources.xaml", sequence);
}
//OnStateEnter is called when a transition starts and the state machine starts to evaluate this state
override public void OnStateEnter(Animator animator, AnimatorStateInfo stateInfo, int layerIndex)
{
foreach (var sequenceItem in _sequenceManager.sequenceItems)
{
if (stateInfo.IsName(sequenceItem.animationName))
{
_currentSequenceItem = sequenceItem;
_currentSequenceItem.RadialProgressBar.SetMaxAmount(stateInfo.length);
break;
}
}
}
public static void ExecuteSequenceItem(SequenceItem item)
{
var keys = new List <Keys>();
keys.AddRange(item.Modifiers.Select(m => (Keys)m.Value));
keys.Add((Keys)item.Entry.Value);
ExecuteKeyboardCommand(keys, item.KeepDown);
//if (item.Method.Equals("sendinput"))
// ExecuteKeyboardCommand(keys, item.KeepDown);
//else
// ExecuteVirtualKeyboardCommand(keys, item.KeepDown);
Thread.Sleep(item.KeepDown);
}
public BeamLimitingDevicePosition()
{
si = new SequenceItem();
//Add blank RTBeamDeviceType
CodeString cs = new CodeString();
cs.Tag.Id = TagHelper.RTBEAM_LIMITING_DEVICE_TYPE;
si.AddObject(cs);
//Add blank Leaf Jaw Positions
DecimalString ds = new DecimalString();
ds.Tag.Id = TagHelper.LEAF_JAW_POSITIONS;
si.AddObject(ds);
}
/// <summary>
/// VisitLeave method in the context of the "Hierarchical Visitor Pattern".
/// See "DVTk_Library\Documentation\Design\Hierarchical Visitor Pattern.htm".
/// </summary>
/// <param name="sequenceItem">The SequenceItem instance to visit.</param>
/// <returns>
/// true: continue traversing the siblings of the supplied instance.
/// false: stop traversing the siblings of the supplied instance.
/// </returns>
public override bool VisitLeaveSequenceItem(SequenceItem sequenceItem)
{
this.tableForDetailedResults.NewRow();
this.tableForDetailedResults.AddBlackItem(1, string.Empty.PadLeft(sequenceItem.Parent.NestingLevel + 1, '>') + "End Item " + sequenceItem.Number.ToString());
AttributeData attributeData = (AttributeData)sequenceItem.Parent.Data;
if (!attributeData.AttributesMapped)
{
this.tableForSummaryResults.NewRow();
this.tableForSummaryResults.AddBlackItem(1, string.Empty.PadLeft(sequenceItem.Parent.NestingLevel + 1, '>') + "End Item " + sequenceItem.Number.ToString());
}
return(true);
}
private SequenceItem GetSequenceItem(string key)
{
lock (mSequenceItems)
{
SequenceItem result;
if (!mSequenceItems.TryGetValue(key, out result))
{
result = new SequenceItem();
result.Index = mSequenceItems.Count;
result.Name = key;
mSequenceItems[key] = result;
}
return(result);
}
}
private static IEnumerable <string> FlattenAndReplace(string source,
IEnumerable <SequenceItem> sequences)
{
SequenceItem firstSequence = sequences.FirstOrDefault();
if (firstSequence == null)
{
return(new[] { source });
}
return(FlattenAndReplace(source, sequences.Skip(1)).
SelectMany(child => (
from replacement in firstSequence
let result = child.Remove(firstSequence.ReplacementMatch.Index, firstSequence.ReplacementMatch.Length)
select result.Insert(firstSequence.ReplacementMatch.Index, replacement))));
}
public void Add(SequenceItem item, string key = null)
{
if (String.IsNullOrEmpty(key))
{
key = item.Name;
}
if (String.IsNullOrEmpty(key))
{
throw new ArgumentNullException("Name", "Key/Name cannot be empty.");
}
if (item == null)
{
throw new ArgumentNullException("item");
}
this.SequenceSteps[key] = item;
}
/// <summary>
/// Add an item to this sequence.
/// </summary>
/// <param name="sequenceItem"></param>
public void AddItem(SequenceItem sequenceItem)
{
DvtkDataSequence.Add(sequenceItem.DvtkDataSequenceItem);
}
public void Connect(SequenceItem from, SequenceItem to = null, string message = null)
{
if (from == null)
{
throw new ArgumentException("from");
}
if (message == null)
{
if (to != null)
{
message = from.Name + "-" + to.Name;
}
else
{
message = from.Name;
}
}
this.Connectors.Add(new Tuple<SequenceItem, SequenceItem, string>(from, to, message));
}
public void AddItem(SequenceItem si)
{
items.Add(si);
}
private Sequence GenerateRawSequence(bool ignoreSegments)
{
Sequence sequence = new Sequence();
double totalTime = 0.0;
double totalGem = 0.0;
int columnIdleRegen = 0;
int columnManaOverflow = -1;
for (int i = 0; i < SolutionVariable.Count; i++)
{
if (SolutionVariable[i].Type == VariableType.IdleRegen)
{
columnIdleRegen = i;
break;
}
}
for (int i = 0; i < SolutionVariable.Count; i++)
{
if (SolutionVariable[i].Type == VariableType.ManaGem)
{
sequence.ColumnManaGem = i;
break;
}
}
for (int i = 0; i < SolutionVariable.Count; i++)
{
if (SolutionVariable[i].Type == VariableType.ManaPotion)
{
sequence.ColumnManaPotion = i;
break;
}
}
for (int i = 0; i < SolutionVariable.Count; i++)
{
if (SolutionVariable[i].Type == VariableType.ManaOverflow)
{
columnManaOverflow = i;
break;
}
}
for (int i = 0; i < SolutionVariable.Count; i++)
{
if (Solution[i] > 0.01 && SolutionVariable[i].Type != VariableType.ManaOverflow)
{
SequenceItem item = new SequenceItem(i, Solution[i]);
if (ignoreSegments) item.Segment = 0;
sequence.Add(item);
if (!item.IsManaPotionOrGem) totalTime += item.Duration;
if (item.VariableType == VariableType.ManaGem) totalGem += Solution[i];
}
}
if (CalculationOptions.TargetDamage == 0.0 && totalTime < CalculationOptions.FightDuration - 0.00001)
{
sequence.Add(new SequenceItem(columnIdleRegen, CalculationOptions.FightDuration - totalTime));
}
// evaluate sequence
/*unexplained = sequence.Evaluate(timing, Sequence.EvaluationMode.Unexplained);
if (unexplained < bestUnexplained)
{
bestUnexplained = unexplained;
bestTiming = timing.ToString();
}*/
sequence.GroupMoltenFury();
SequenceGroup heroismGroup = sequence.GroupHeroism();
if (CalculationOptions.HeroismControl == 3)
{
heroismGroup.MinTime = Math.Min(CalculationOptions.FightDuration - CalculationOptions.MoltenFuryPercentage * CalculationOptions.FightDuration, CalculationOptions.FightDuration - 40.0);
}
sequence.GroupCombustion();
sequence.GroupArcanePower();
sequence.GroupVolcanicPotion();
foreach (EffectCooldown cooldown in ItemBasedEffectCooldowns)
{
sequence.GroupSpecialEffect(cooldown);
}
List<SequenceGroup> list = sequence.GroupManaGemEffect();
if (list != null && ManaGemEffect && CalculationOptions.DisplaySegmentCooldowns && columnManaOverflow != -1)
{
float manaBurn = 0;
for (int i = 0; i < SolutionVariable.Count; i++)
{
if (Solution[i] > 0.01 && SolutionVariable[i].Segment == 0 && SolutionVariable[i].Type == VariableType.Spell)
{
CastingState state = SolutionVariable[i].State;
if (state != null && !state.EffectsActive((int)StandardEffect.ManaGemEffect))
{
float burn = (float)SolutionVariable[i].Cycle.ManaPerSecond;
if (burn > manaBurn) manaBurn = burn;
}
}
}
double overflow = Solution[columnManaOverflow];
double tmin = 0;
if (manaBurn > 0) tmin = (ManaGemValue * (1 + BaseStats.BonusManaGem) - overflow) / manaBurn;
foreach (SequenceGroup g in list)
{
if (g.Segment == 0) g.MinTime = tmin;
}
}
sequence.GroupIcyVeins(); // should come after trinkets because of coldsnap
//sequence.GroupWaterElemental();
sequence.GroupMirrorImage();
sequence.GroupBerserking();
sequence.GroupPowerInfusion();
sequence.GroupFlameOrb();
list = sequence.GroupFlameCap();
// very very special case for now
if (list != null && list.Count == 2 && CalculationOptions.FightDuration < 400 && totalGem >= 1)
{
foreach (SequenceGroup group in list)
{
foreach (CooldownConstraint constraint in group.Constraint)
{
if (constraint.EffectCooldown.StandardEffect == StandardEffect.FlameCap)
{
constraint.Cooldown = 300.0;
}
}
}
}
sequence.GroupEvocation();
return sequence;
}
public void Add(SequenceItem item)
{
Mana += item.Mps * item.Duration;
Threat += item.Tps * item.Duration;
Duration += item.Duration;
Item.Add(item);
}
private int Compare(SequenceItem x, SequenceItem y, List<SequenceGroup> tail, double minMps, double maxMps)
{
bool xsingletail = x.Tail.Count > 0;
bool ysingletail = y.Tail.Count > 0;
int compare = ysingletail.CompareTo(xsingletail);
if (compare != 0) return compare;
int xintersect = (tail == null) ? 0 : Rawr.Mage.ListUtils.Intersect<SequenceGroup>(x.Group, tail).Count;
int yintersect = (tail == null) ? 0 : Rawr.Mage.ListUtils.Intersect<SequenceGroup>(y.Group, tail).Count;
compare = yintersect.CompareTo(xintersect);
if (compare != 0) return compare;
return Sequence.CompareMps(x.Mps, y.Mps, minMps, maxMps);
}
public static List<SequenceItem> ReadChildren(byte[] data, Boolean isLittleEndian)
{
List<SequenceItem> items = new List<SequenceItem>();
using (BinaryReader r = new BinaryReader(new MemoryStream(data)))
{
while (r.BaseStream.Position < r.BaseStream.Length)
{
SequenceItem si = new SequenceItem();
//Read length past start tag
byte[] dLength = new byte[4];
r.Read(dLength, 0, 4);
r.Read(dLength, 0, 4);
if (ArrayHelper.isEqualArray(dLength, Constants.INDEFINITE_LENGTH))
{
//INDEFINITE LENGTH: Mark current position and find end
si.LengthType = Constants.LengthType.INDEFINITE;
long dataStart = r.BaseStream.Position;
long dataEnd = FindEndOfSequenceItem(r, isLittleEndian);
if (dataEnd == -1)
{
//Didn't find end tag
Console.WriteLine("Could not find sequence item end tag while decoding sequence items in sequence");
return null;
}
else
{
//Read dicomObject from dataStart to dataEnd
r.BaseStream.Position = dataStart;
while (r.BaseStream.Position < dataEnd)
{
si.AddObject(DICOMReader.ReadSequenceItem(r, isLittleEndian));
}
}
}
else
{
//Read dicomObject from current position to end of length
si.LengthType = Constants.LengthType.FINITE;
int objectsLength = BitConverter.ToInt32(dLength, 0);
if (!isLittleEndian) { objectsLength = BitConverter.ToInt32(ArrayHelper.ReverseArray(dLength), 0); }
int dataEnd = (int)r.BaseStream.Position + objectsLength;
while (r.BaseStream.Position < dataEnd)
{
si.AddObject(DICOMReader.ReadObject(r, isLittleEndian));
}
}
items.Add(si);
}
return items;
}
}
