public bool TryGetValue(string text, out int val)
{
val = default;
if (text == null)
{
return(false);
}
var systemTab = SharedSymbolTable.GetSystem(1);
var st = systemTab.Find(text);
if (st.Text != null)
{
//found it
val = st.Sid;
return(true);
}
// for (int i = 0, l = Symbols.SystemSymbolTokens.Length; i < l; i++)
// {
// var systemToken = Symbols.SystemSymbolTokens[i];
// if (systemToken.Text != text) continue;
// val = systemToken.Sid;
// return true;
// }
if (Parents.Length == 0)
{
return(false);
}
return(_dict.TryGetValue(text, out val));
}
public void InternNull_ThrowsException(string nullString)
{
const string name = "tableName";
const int version = 1;
var table = SharedSymbolTable.NewSharedSymbolTable(name, version, null, new string[0]);
Assert.ThrowsException <ArgumentNullException>(() => table.Intern(nullString));
}
public void BasicSymbol_NoImport_Valid(string[] symbols)
{
const string name = "tableName";
const int version = 1;
var table = SharedSymbolTable.NewSharedSymbolTable(name, version, null, symbols);
AssertTable(table, name, version, symbols);
}
public static ICatalog GetCatalog()
{
var catalog = new SimpleCatalog();
var yjSymbols = SharedSymbolTable.NewSharedSymbolTable("YJ_symbols", 10, null, YjSymbols);
catalog.PutTable(yjSymbols);
return(catalog);
}
public void InternKnownText_KeepEntry(string text)
{
var table = SharedSymbolTable.NewSharedSymbolTable("table", 1, null, new[] { text });
var extraText = new StringBuilder(text).ToString();
Assert.AreNotSame(text, extraText);
var symtok = table.Find(extraText);
//make sure that no extra allocation is made
Assert.AreSame(text, symtok.Text);
Assert.AreEqual(SymbolToken.UnknownSid, symtok.Sid);
}
public void GetTable_BestMatch(int expected, int requested, int[] available)
{
const string tName = "T";
var map = new Dictionary <int, ISymbolTable>();
var cat = new SimpleCatalog();
foreach (var a in available)
{
map.Add(a, SharedSymbolTable.NewSharedSymbolTable(tName, a, null, new[] { "yes", "no" }));
cat.PutTable(map[a]);
}
Assert.AreEqual(expected, cat.GetTable(tName, requested).Version);
}
public void FindToken(string[] symbols)
{
var table = SharedSymbolTable.NewSharedSymbolTable("table", 1, null, symbols);
foreach (var symbol in symbols)
{
var token = table.Find(symbol);
Assert.AreSame(symbol, token.Text);
}
var unknown = table.Find($"{string.Join(",", symbols)}key");
Assert.AreEqual(SymbolToken.None, unknown);
Assert.ThrowsException <ArgumentNullException>(() => table.Find(null));
}
private void MoveNextUser()
{
base.HasNext();
// if we're not at the top (datagram) level or the next value is null
if (this.CurrentDepth != 0 || this.valueIsNull)
{
return;
}
Debug.Assert(this.valueTid != BinaryConstants.TidTypedecl, "valueTid is Typedec1");
if (this.valueTid == BinaryConstants.TidSymbol)
{
// trying to read a symbol here
// $ion_1_0 is read as an IVM only if it is not annotated
// we already count the number of annotations
if (this.Annotations.Count != 0)
{
return;
}
this.LoadOnce();
// just get it straight from the holder, no conversion needed
var sid = this.valueVariant.IntValue;
if (sid != SystemSymbols.Ion10Sid)
{
return;
}
this.SymbolTable = SharedSymbolTable.GetSystem(1);
// user don't need to see this symbol so continue here
this.moveNextNeeded = true;
}
else if (this.valueTid == BinaryConstants.TidStruct)
{
// trying to read the local symbolTable here
if (this.hasSymbolTableAnnotation)
{
this.SymbolTable = ReaderLocalTable.ImportReaderTable(this, this.catalog, false);
// user don't need to read the localsymboltable so continue
this.moveNextNeeded = true;
}
}
}
public bool TryGetValue(string text, out int val)
{
if (text == null)
{
val = 0;
return(false);
}
var systemTab = SharedSymbolTable.GetSystem(1);
val = systemTab.FindSymbolId(text);
if (val > 0)
{
return(true);
}
return(this.dict.TryGetValue(text, out val));
}
protected SystemTreeReader(IIonValue value)
{
_systemSymbols = SharedSymbolTable.GetSystem(1);
_current = null;
_eof = false;
_top = 0;
if (value.Type() == IonType.Datagram)
{
_parent = value;
_next = null;
_iter = value.GetEnumerator();
}
else
{
_parent = null;
_next = value;
}
}
protected SystemTreeReader(IIonValue value)
{
this.systemSymbols = SharedSymbolTable.GetSystem(1);
this.current = null;
this.eof = false;
this.top = 0;
if (value.Type() == IonType.Datagram)
{
this.parent = value;
this.next = null;
this.iter = value.GetEnumerator();
}
else
{
this.parent = null;
this.next = value;
}
}
public void OneTable_MissingVersion()
{
const string tName = "T";
var cat = new SimpleCatalog();
Assert.IsNull(cat.GetTable(tName));
Assert.IsNull(cat.GetTable(tName, 3));
var t1 = SharedSymbolTable.NewSharedSymbolTable(tName, 1, null, new[] { "yes", "no" });
cat.PutTable(t1);
Assert.AreSame(t1, cat.GetTable(tName));
Assert.AreSame(t1, cat.GetTable(tName, 1));
Assert.AreSame(t1, cat.GetTable(tName, 5));
var t2 = SharedSymbolTable.NewSharedSymbolTable(tName, 2, null, new[] { "yes", "no", "maybe" });
cat.PutTable(t2);
Assert.AreSame(t1, cat.GetTable(tName, 1));
Assert.AreSame(t2, cat.GetTable(tName, 2));
Assert.AreSame(t2, cat.GetTable(tName, 5));
}
protected SystemTextReader(TextStream input, IonType parent) : base(input, parent)
{
_systemSymbols = SharedSymbolTable.GetSystem(1);
}
protected SystemTextReader(TextStream input)
: base(input)
{
this.systemSymbols = SharedSymbolTable.GetSystem(1);
}
internal SystemBinaryReader(Stream input)
: this(input, SharedSymbolTable.GetSystem(1))
{
}
public void WriterReader()
{
var catalog = new SimpleCatalog();
var table1 = SharedSymbolTable.NewSharedSymbolTable("table1", 1, null, new[] { "s1", "s2" });
var table2 = SharedSymbolTable.NewSharedSymbolTable("table2", 1, null, new[] { "s3", "s4" });
catalog.PutTable(table1);
catalog.PutTable(table2);
var stream = new MemoryStream();
byte[] output;
using (var binWriter = new ManagedBinaryWriter(stream, new[] { table1, table2 }))
{
binWriter.StepIn(IonType.Struct);
binWriter.SetFieldName("s1");
binWriter.WriteSymbol("s2");
binWriter.SetFieldName("s3");
binWriter.WriteSymbol("s4");
binWriter.StepOut();
binWriter.Finish();
Assert.AreEqual(binWriter.SymbolTable.GetImportedMaxId(), binWriter.SymbolTable.MaxId);
output = stream.ToArray();
}
var reader = IonReaderBuilder.Build(new MemoryStream(output));
Assert.AreEqual(IonType.Struct, reader.MoveNext());
reader.StepIn();
Assert.AreEqual(IonType.Symbol, reader.MoveNext());
var fns = reader.GetFieldNameSymbol();
Assert.AreEqual(10, fns.Sid);
Assert.IsNull(fns.Text);
Assert.ThrowsException <UnknownSymbolException>(() => reader.CurrentFieldName);
Assert.AreEqual(11, reader.SymbolValue().Sid);
Assert.AreEqual(IonType.Symbol, reader.MoveNext());
fns = reader.GetFieldNameSymbol();
Assert.AreEqual(12, fns.Sid);
Assert.IsNull(fns.Text);
Assert.ThrowsException <UnknownSymbolException>(() => reader.CurrentFieldName);
Assert.AreEqual(13, reader.SymbolValue().Sid);
//make sure that a reader with the correct imports can read it
var reader2 = new UserBinaryReader(new MemoryStream(output), catalog);
Assert.AreEqual(IonType.Struct, reader2.MoveNext());
var localTable = reader2.GetSymbolTable();
Console.WriteLine(localTable.Find("s1").ToString());
reader2.StepIn();
Assert.AreEqual(IonType.Symbol, reader2.MoveNext());
Assert.AreEqual("s1", reader2.CurrentFieldName);
Assert.AreEqual("s2", reader2.SymbolValue().Text);
Assert.AreEqual(IonType.Symbol, reader2.MoveNext());
Assert.AreEqual("s3", reader2.CurrentFieldName);
Assert.AreEqual("s4", reader2.SymbolValue().Text);
}
public override ISymbolTable GetSystemTable() => SharedSymbolTable.GetSystem(1);
public ISymbolTable GetSystemTable() => SharedSymbolTable.GetSystem(1);
internal SystemBinaryReader(Stream input, IReaderRoutine readerRoutine)
: this(input, SharedSymbolTable.GetSystem(1), readerRoutine)
{
}
public void InternUnknownText_Throws()
{
var table = SharedSymbolTable.NewSharedSymbolTable("table", 1, null, new[] { "a", "b", "c" });
Assert.ThrowsException <InvalidOperationException>(() => table.Intern("d"));
}
