public Instance(State <TData, TOffset> state, Annotation <TOffset> ann, NullableValue <TOffset>[,] registers, VariableBindings varBindings)
{
_state = state;
_annotation = ann;
_registers = registers;
_varBindings = varBindings;
}
public void NullableValueTValueType_IsNull()
{
NullableValue <TValueType> number =
new NullableValue <TValueType>();
Assert.IsTrue(number.IsNull);
}
private FstInstance EpsilonAdvanceFst(Annotation <TOffset> ann, NullableValue <TOffset>[,] registers, TData output, IDictionary <Annotation <TOffset>,
Annotation <TOffset> > mappings, Queue <Annotation <TOffset> > queue, VariableBindings varBindings, Arc <TData, TOffset> arc,
List <FstResult <TData, TOffset> > curResults)
{
return(EpsilonAdvance(ann, registers, output, varBindings, arc, curResults, null,
(state, a, regs, vb) => new FstInstance(state, a, regs, output, mappings, queue, vb)));
}
public void GetHashCode_BothNull_HashCodesEqual()
{
var value1 = new NullableValue <int>();
var value2 = new NullableValue <int>();
Assert.That(value1.GetHashCode(), Is.EqualTo(value2.GetHashCode()));
}
public void NullableValueInt_IsNull()
{
NullableValue <int> number =
new NullableValue <int>();
Assert.IsTrue(number.IsNull);
}
public void GetHashCode_DifferentValuesOneIsNull_HashCodesNotEqual()
{
var value1 = new NullableValue <int>();
var value2 = new NullableValue <int>(1);
Assert.That(value1.GetHashCode(), Is.Not.EqualTo(value2.GetHashCode()));
}
private IEnumerable <FsaInstance> AdvanceFsa(Annotation <TOffset> ann, NullableValue <TOffset>[,] registers, VariableBindings varBindings, Arc <TData, TOffset> arc,
List <FstResult <TData, TOffset> > curResults, int[] priorities)
{
priorities = UpdatePriorities(priorities, arc.Priority);
return(Advance(ann, registers, Data, varBindings, arc, curResults, priorities,
(state, nextAnn, regs, vb, clone) => new FsaInstance(state, nextAnn, regs, vb, new HashSet <State <TData, TOffset> >(), priorities)));
}
public void Equals_DifferentValuesOneIsNull_ReturnsFalse()
{
var value1 = new NullableValue <int>(0);
var value2 = new NullableValue <int>();
Assert.That(value1.Equals(value2), Is.False);
}
public void NullableValueInt_IsNull()
{
NullableValue<int> number =
new NullableValue<int>();
Assert.IsTrue(number.IsNull);
}
private void CheckAccepting(Annotation <TOffset> ann, NullableValue <TOffset>[,] registers, TData output,
VariableBindings varBindings, Arc <TData, TOffset> arc, ICollection <FstResult <TData, TOffset> > curResults, int[] priorities)
{
if (arc.Target.IsAccepting && (!_endAnchor || ann == _data.Annotations.GetEnd(_dir)))
{
var matchRegisters = (NullableValue <TOffset> [, ])registers.Clone();
ExecuteCommands(matchRegisters, arc.Target.Finishers, new NullableValue <TOffset>(), new NullableValue <TOffset>());
if (arc.Target.AcceptInfos.Count > 0)
{
foreach (AcceptInfo <TData, TOffset> acceptInfo in arc.Target.AcceptInfos)
{
var candidate = new FstResult <TData, TOffset>(acceptInfo.ID, matchRegisters, output.DeepClone(), varBindings.DeepClone(),
acceptInfo.Priority, arc.Target.IsLazy, ann, priorities);
if (acceptInfo.Acceptable == null || acceptInfo.Acceptable(_data, candidate))
{
curResults.Add(candidate);
}
}
}
else
{
curResults.Add(new FstResult <TData, TOffset>(null, matchRegisters, output.DeepClone(), varBindings.DeepClone(), -1, arc.Target.IsLazy, ann,
priorities));
}
}
}
public void Equals_SameValues_ReturnsTrue()
{
var value1 = new NullableValue <int>(0);
var value2 = new NullableValue <int>(0);
Assert.That(value1.Equals(value2), Is.True);
}
public void NullableValueInt_IsNotNull()
{
NullableValue <int> number =
new NullableValue <int>(42);
Assert.IsFalse(number.IsNull);
Assert.AreEqual <int>(42, number.Value);
}
void MaybeAdd <T>(string name, NullableValue <T> value, bool show_null = true)
where T : struct
{
if (value || show_null)
{
attributes.Add(new Attribute(new AttributeName(name, this), new SimpleValue <NullableValue <T> >(value)));
}
}
private FsaInstance EpsilonAdvanceFsa(Annotation <TOffset> ann, NullableValue <TOffset>[,] registers, VariableBindings varBindings, ISet <State <TData, TOffset> > visited,
Arc <TData, TOffset> arc, List <FstResult <TData, TOffset> > curResults, int[] priorities)
{
priorities = UpdatePriorities(priorities, arc.Priority);
visited.Add(arc.Target);
return(EpsilonAdvance(ann, registers, Data, varBindings, arc, curResults, priorities,
(state, a, regs, vb) => new FsaInstance(state, a, regs, vb, visited, priorities)));
}
public AnnotatedCheckBoxAndIntegerSlider()
{
InitializeComponent();
Value = new NullableValue <int>();
(this.Content as FrameworkElement).DataContext = this;
}
public void NullableValueInt_IsNotNull()
{
NullableValue<int> number =
new NullableValue<int>(42);
Assert.IsFalse(number.IsNull);
Assert.AreEqual<int>(42, number.Value);
}
public void NullableValueInt_IsNotNull()
{
NullableValue <TValueType> number =
new NullableValue <TValueType>(TestValue);
Assert.IsFalse(number.IsNull);
Assert.AreEqual <TValueType>(TestValue, number.Value);
}
public TestClass(int value, int?nullableValue, int[] collectionOfValues, int?[] collectionOfNullableValues, int[] nullableCollectionOfValues, int?[] nullableCollectionOfNullableValues)
{
Value = Value.WithValue(value);
NullableValue = NullableValue.WithValue(nullableValue);
CollectionOfValues = CollectionOfValues.WithValue(collectionOfValues);
CollectionOfNullableValues = CollectionOfNullableValues.WithValue(collectionOfNullableValues);
NullableCollectionOfValues = NullableCollectionOfValues.WithValue(nullableCollectionOfValues);
NullableCollectionOfNullableValues = NullableCollectionOfNullableValues.WithValue(nullableCollectionOfNullableValues);
}
protected TInst EpsilonAdvance <TInst>(Annotation <TOffset> ann, NullableValue <TOffset>[,] registers, TData output, VariableBindings varBindings, Arc <TData, TOffset> arc,
ICollection <FstResult <TData, TOffset> > curResults, int[] priorities,
Func <State <TData, TOffset>, Annotation <TOffset>, NullableValue <TOffset> [, ], VariableBindings, TInst> instFactory)
{
Annotation <TOffset> prevAnn = ann.GetPrevDepthFirst(_dir, (cur, prev) => !cur.Span.Overlaps(prev.Span) && _filter(prev));
ExecuteCommands(registers, arc.Commands, new NullableValue <TOffset>(ann.Span.GetStart(_dir)), new NullableValue <TOffset>(prevAnn.Span.GetEnd(_dir)));
CheckAccepting(ann, registers, output, varBindings, arc, curResults, priorities);
return(instFactory(arc.Target, ann, registers, varBindings));
}
private Stack <Instance> InitializeStack(ref Annotation <TOffset> ann, NullableValue <TOffset>[,] registers,
IList <TagMapCommand> cmds, ISet <Annotation <TOffset> > initAnns)
{
var instStack = new Stack <Instance>();
foreach (Instance inst in Initialize(ref ann, registers, cmds, initAnns, (state, startAnn, regs, vb) => new Instance(state, startAnn, regs, vb)))
{
instStack.Push(inst);
}
return(instStack);
}
internal FstResult(string id, NullableValue <TOffset>[,] registers, TData output, VariableBindings varBindings, int priority, bool isLazy, Annotation <TOffset> nextAnn,
int[] priorities)
{
_id = id;
_registers = registers;
_output = output;
_varBindings = varBindings;
_priority = priority;
_isLazy = isLazy;
_nextAnn = nextAnn;
_priorities = priorities;
}
public int GetHashCode(NullableValue <TOffset>[,] obj)
{
int code = 23;
for (int i = 0; i < obj.GetLength(0); i++)
{
for (int j = 0; j < 2; j++)
{
code = code * 31 + (obj[i, j].HasValue && obj[i, j].Value != null ? _offsetEqualityComparer.GetHashCode(obj[i, j].Value) : 0);
}
}
return(code);
}
public static bool ToIsNullable(this NullableValue nullableValue, WeavingContext weavingContext)
{
switch (nullableValue)
{
case NullableValue.Oblivious:
case NullableValue.Annotated:
return(true);
case NullableValue.NotAnnotated:
return(false);
default:
weavingContext.WriteError("Unexpected nullable argument value.");
return(true);
}
}
protected IEnumerable <TInst> Advance <TInst>(Annotation <TOffset> ann, NullableValue <TOffset>[,] registers, TData output, VariableBindings varBindings,
Arc <TData, TOffset> arc, ICollection <FstResult <TData, TOffset> > curResults, int[] priorities,
Func <State <TData, TOffset>, Annotation <TOffset>, NullableValue <TOffset> [, ], VariableBindings, bool, TInst> instFactory)
{
Annotation <TOffset> nextAnn = ann.GetNextDepthFirst(_dir, (cur, next) => !cur.Span.Overlaps(next.Span) && _filter(next));
TOffset nextOffset = nextAnn == _data.Annotations.GetEnd(_dir) ? _data.Annotations.GetLast(_dir, _filter).Span.GetEnd(_dir) : nextAnn.Span.GetStart(_dir);
TOffset end = ann.Span.GetEnd(_dir);
var newRegisters = (NullableValue <TOffset> [, ])registers.Clone();
ExecuteCommands(newRegisters, arc.Commands, new NullableValue <TOffset>(nextOffset), new NullableValue <TOffset>(end));
CheckAccepting(nextAnn, newRegisters, output, varBindings, arc, curResults, priorities);
if (nextAnn != _data.Annotations.GetEnd(_dir))
{
var anns = new List <Annotation <TOffset> >();
bool cloneOutputs = false;
for (Annotation <TOffset> curAnn = nextAnn; curAnn != _data.Annotations.GetEnd(_dir) && curAnn.Span.GetStart(_dir).Equals(nextOffset); curAnn = curAnn.GetNextDepthFirst(_dir, _filter))
{
if (curAnn.Optional)
{
foreach (TInst ni in Advance(curAnn, registers, output, varBindings, arc, curResults, priorities, instFactory))
{
yield return(ni);
cloneOutputs = true;
}
}
anns.Add(curAnn);
}
bool cloneRegisters = false;
foreach (Annotation <TOffset> curAnn in anns)
{
yield return(instFactory(arc.Target, curAnn, cloneRegisters ? (NullableValue <TOffset> [, ])newRegisters.Clone() : newRegisters,
cloneOutputs ? varBindings.DeepClone() : varBindings, cloneOutputs));
cloneOutputs = true;
cloneRegisters = true;
}
}
else
{
yield return(instFactory(arc.Target, nextAnn, newRegisters, varBindings, false));
}
}
protected static void ExecuteCommands(NullableValue <TOffset>[,] registers, IEnumerable <TagMapCommand> cmds,
NullableValue <TOffset> start, NullableValue <TOffset> end)
{
foreach (TagMapCommand cmd in cmds)
{
if (cmd.Src == TagMapCommand.CurrentPosition)
{
registers[cmd.Dest, 0] = start;
registers[cmd.Dest, 1] = end;
}
else
{
registers[cmd.Dest, 0] = registers[cmd.Src, 0];
registers[cmd.Dest, 1] = registers[cmd.Src, 1];
}
}
}
private Stack <FstInstance> InitializeStack(ref Annotation <TOffset> ann, NullableValue <TOffset>[,] registers,
IList <TagMapCommand> cmds, ISet <Annotation <TOffset> > initAnns)
{
var instStack = new Stack <FstInstance>();
foreach (FstInstance inst in Initialize(ref ann, registers, cmds, initAnns,
(state, startAnn, regs, vb) =>
{
TData o = Data.DeepClone();
Dictionary <Annotation <TOffset>, Annotation <TOffset> > m = Data.Annotations.SelectMany(a => a.GetNodesBreadthFirst())
.Zip(o.Annotations.SelectMany(a => a.GetNodesBreadthFirst())).ToDictionary(t => t.Item1, t => t.Item2);
var q = new Queue <Annotation <TOffset> >();
return(new FstInstance(state, startAnn, regs, o, m, q, vb));
}))
{
instStack.Push(inst);
}
return(instStack);
}
public static int Main()
{
NullableValue test = new NullableValue();
TestLibrary.TestFramework.BeginTestCase("For property:System.Nullable<T>.Value");
if (test.RunTests())
{
TestLibrary.TestFramework.EndTestCase();
TestLibrary.TestFramework.LogInformation("PASS");
return(100);
}
else
{
TestLibrary.TestFramework.EndTestCase();
TestLibrary.TestFramework.LogInformation("FAIL");
return(0);
}
}
public bool Equals(NullableValue <TOffset>[,] x, NullableValue <TOffset>[,] y)
{
for (int i = 0; i < x.GetLength(0); i++)
{
for (int j = 0; j < 2; j++)
{
if (x[i, j].HasValue != y[i, j].HasValue)
{
return(false);
}
if (x[i, j].HasValue && !_offsetEqualityComparer.Equals(x[i, j].Value, x[i, j].Value))
{
return(false);
}
}
}
return(true);
}
private IEnumerable <FstInstance> AdvanceFst(Annotation <TOffset> ann, NullableValue <TOffset>[,] registers, TData output,
IDictionary <Annotation <TOffset>, Annotation <TOffset> > mappings, VariableBindings varBindings, Arc <TData, TOffset> arc,
List <FstResult <TData, TOffset> > curResults, int[] priorities)
{
priorities = UpdatePriorities(priorities, arc.Priority);
return(Advance(ann, registers, output, varBindings, arc, curResults, priorities,
(state, nextAnn, regs, vb, clone) =>
{
TData o = output;
IDictionary <Annotation <TOffset>, Annotation <TOffset> > m = mappings;
if (clone)
{
o = output.DeepClone();
Dictionary <Annotation <TOffset>, Annotation <TOffset> > outputMappings = output.Annotations.SelectMany(a => a.GetNodesBreadthFirst())
.Zip(o.Annotations.SelectMany(a => a.GetNodesBreadthFirst())).ToDictionary(t => t.Item1, t => t.Item2);
m = mappings.ToDictionary(kvp => kvp.Key, kvp => outputMappings[kvp.Value]);
}
return new FstInstance(state, nextAnn, regs, o, m, vb, new HashSet <State <TData, TOffset> >(), priorities);
}));
}
private IEnumerable <FstInstance> AdvanceFst(Annotation <TOffset> ann, NullableValue <TOffset>[,] registers, TData output,
IDictionary <Annotation <TOffset>, Annotation <TOffset> > mappings, Queue <Annotation <TOffset> > queue, VariableBindings varBindings, Arc <TData, TOffset> arc,
List <FstResult <TData, TOffset> > curResults)
{
return(Advance(ann, registers, output, varBindings, arc, curResults, null,
(state, nextAnn, regs, vb, clone) =>
{
TData o = output;
IDictionary <Annotation <TOffset>, Annotation <TOffset> > m = mappings;
Queue <Annotation <TOffset> > q = queue;
if (clone)
{
o = output.DeepClone();
Dictionary <Annotation <TOffset>, Annotation <TOffset> > outputMappings = output.Annotations.SelectMany(a => a.GetNodesBreadthFirst())
.Zip(o.Annotations.SelectMany(a => a.GetNodesBreadthFirst())).ToDictionary(t => t.Item1, t => t.Item2);
m = mappings.ToDictionary(kvp => kvp.Key, kvp => outputMappings[kvp.Value]);
q = new Queue <Annotation <TOffset> >(queue);
}
return new FstInstance(state, nextAnn, regs, o, m, q, vb);
}));
}
public FstInstance(State <TData, TOffset> state, Annotation <TOffset> ann, NullableValue <TOffset>[,] registers, TData output,
IDictionary <Annotation <TOffset>, Annotation <TOffset> > mappings, Queue <Annotation <TOffset> > queue, VariableBindings varBindings)
: base(state, ann, registers, varBindings)
{
_output = output;
_mappings = mappings;
_queue = queue;
}
public override IEnumerable <FstResult <TData, TOffset> > Traverse(ref Annotation <TOffset> ann, NullableValue <TOffset>[,] initRegisters, IList <TagMapCommand> initCmds, ISet <Annotation <TOffset> > initAnns)
{
Stack <FstInstance> instStack = InitializeStack(ref ann, initRegisters, initCmds, initAnns);
var curResults = new List <FstResult <TData, TOffset> >();
while (instStack.Count != 0)
{
FstInstance inst = instStack.Pop();
if (inst.Annotation != null)
{
VariableBindings varBindings = null;
foreach (Arc <TData, TOffset> arc in inst.State.Arcs)
{
if (arc.Input.IsEpsilon)
{
TData output = inst.Output;
IDictionary <Annotation <TOffset>, Annotation <TOffset> > mappings = inst.Mappings;
Queue <Annotation <TOffset> > queue = inst.Queue;
NullableValue <TOffset>[,] registers = inst.Registers;
if (IsInstanceReuseable(inst))
{
if (varBindings == null)
{
varBindings = inst.VariableBindings;
}
}
else
{
registers = (NullableValue <TOffset> [, ])inst.Registers.Clone();
output = inst.Output.DeepClone();
Dictionary <Annotation <TOffset>, Annotation <TOffset> > outputMappings = inst.Output.Annotations.SelectMany(a => a.GetNodesBreadthFirst())
.Zip(output.Annotations.SelectMany(a => a.GetNodesBreadthFirst())).ToDictionary(t => t.Item1, t => t.Item2);
mappings = inst.Mappings.ToDictionary(kvp => kvp.Key, kvp => outputMappings[kvp.Value]);
queue = new Queue <Annotation <TOffset> >(inst.Queue);
if (varBindings == null)
{
varBindings = inst.VariableBindings.DeepClone();
}
}
ExecuteOutputs(arc.Outputs, output, mappings, queue);
instStack.Push(EpsilonAdvanceFst(inst.Annotation, registers, output, mappings, queue, varBindings, arc, curResults));
varBindings = null;
}
else
{
if (varBindings == null)
{
varBindings = IsInstanceReuseable(inst) ? inst.VariableBindings : inst.VariableBindings.DeepClone();
}
if (CheckInputMatch(arc, inst.Annotation, varBindings))
{
TData output = inst.Output;
IDictionary <Annotation <TOffset>, Annotation <TOffset> > mappings = inst.Mappings;
Queue <Annotation <TOffset> > queue = inst.Queue;
if (!IsInstanceReuseable(inst))
{
output = inst.Output.DeepClone();
Dictionary <Annotation <TOffset>, Annotation <TOffset> > outputMappings = inst.Output.Annotations.SelectMany(a => a.GetNodesBreadthFirst())
.Zip(output.Annotations.SelectMany(a => a.GetNodesBreadthFirst())).ToDictionary(t => t.Item1, t => t.Item2);
mappings = inst.Mappings.ToDictionary(kvp => kvp.Key, kvp => outputMappings[kvp.Value]);
queue = new Queue <Annotation <TOffset> >(inst.Queue);
}
for (int i = 0; i < arc.Input.EnqueueCount; i++)
{
queue.Enqueue(inst.Annotation);
}
ExecuteOutputs(arc.Outputs, output, mappings, queue);
foreach (FstInstance ni in AdvanceFst(inst.Annotation, inst.Registers, output, mappings, queue, varBindings, arc, curResults))
{
instStack.Push(ni);
}
break;
}
}
}
}
}
return(curResults);
}
public static int Main()
{
NullableValue test = new NullableValue();
TestLibrary.TestFramework.BeginTestCase("For property:System.Nullable<T>.Value");
if (test.RunTests())
{
TestLibrary.TestFramework.EndTestCase();
TestLibrary.TestFramework.LogInformation("PASS");
return 100;
}
else
{
TestLibrary.TestFramework.EndTestCase();
TestLibrary.TestFramework.LogInformation("FAIL");
return 0;
}
}
public void Equals_DifferentValuesOneIsNull_ReturnsFalse()
{
var value1 = new NullableValue<int>(0);
var value2 = new NullableValue<int>();
Assert.That(value1.Equals(value2), Is.False);
}
public void GetHashCode_DifferentValuesOneIsNull_HashCodesNotEqual()
{
var value1 = new NullableValue<int>();
var value2 = new NullableValue<int>(1);
Assert.That(value1.GetHashCode(), Is.Not.EqualTo(value2.GetHashCode()));
}
public void GetHashCode_BothNull_HashCodesEqual()
{
var value1 = new NullableValue<int>();
var value2 = new NullableValue<int>();
Assert.That(value1.GetHashCode(), Is.EqualTo(value2.GetHashCode()));
}
public void Equals_SameValues_ReturnsTrue()
{
var value1 = new NullableValue<int>(0);
var value2 = new NullableValue<int>(0);
Assert.That(value1.Equals(value2), Is.True);
}
