private HZincWriter writeDictKeyVals(HDict dict)
{
if (dict.isEmpty())
{
return(this);
}
bool bFirst = true;
for (int i = 0; i < dict.size(); i++)
{
string name = dict.getKeyAt(i, false);
if (name != null)
{
HVal val = (HVal)dict.get(name, false);
if (!bFirst)
{
p(' ');
}
p(name);
if (val != HMarker.VAL)
{
p(':').writeVal(val);
}
bFirst = false;
}
}
flush();
return(this);
}
private string valToString(HVal val)
{
if (val == null)
{
return("");
}
if (val == HMarker.VAL)
{
return("\u2713");
}
if (val is HRef)
{
HRef href = (HRef)val;
string s = "@" + href.val;
if (href.disSet)
{
s += " " + href.display();
}
return(s);
}
return(val.ToString());
}
private HDict parseDict()
{
HDictBuilder db = new HDictBuilder();
bool braces = m_tokCur == HaystackToken.lbrace;
if (braces)
{
consume(HaystackToken.lbrace);
}
while (m_tokCur == HaystackToken.id)
{
// tag name
string id = consumeTagName();
if (!char.IsLower(id[0]))
{
err("Invalid dict tag name: " + id);
}
// tag value
HVal val = HMarker.VAL;
if (m_tokCur == HaystackToken.colon)
{
consume(HaystackToken.colon);
val = parseVal();
}
db.add(id, val);
}
if (braces)
{
consume(HaystackToken.rbrace);
}
return(db.toDict());
}
void verifyRowIterator(HRow it, int iIndex, string name, HVal val)
{
Assert.IsTrue(it.Size > iIndex);
string strKeyValue = it.getKeyAt(iIndex, false);
Assert.AreEqual(strKeyValue, name);
Assert.IsTrue(it.get(strKeyValue, false).hequals(val));
}
private static string Msg(HGrid grid)
{
HVal dis = grid.meta.get("dis", false);
if (dis is HStr)
{
return(((HStr)dis).Value);
}
return("server side error");
}
/** Get the server side stack trace or return null if not available */
public string trace()
{
HVal val = m_grid.meta.get("errTrace", false);
if (val is HStr)
{
return(((HStr)val).ToString());
}
return(null);
}
// Return display name of column which is meta.dis or name
public string dis()
{
HVal dis = meta.get("dis", false);
if (dis is HStr)
{
return(((HStr)dis).Value);
}
return(Name);
}
public static string valToString(HVal val)
{
MemoryStream msOut = new MemoryStream();
StreamWriter swOut = new StreamWriter(msOut);
new HZincWriter(swOut).writeVal(val);
StreamReader sr = new StreamReader(msOut);
msOut.Position = 0;
return(sr.ReadToEnd());
}
private void writeRow(HGrid grid, HRow row)
{
for (int i = 0; i < grid.numCols; ++i)
{
HVal val = row.get(grid.col(i), false);
if (i > 0)
{
m_swOut.Write(m_cDelimiter);
}
writeCell(valToString(val));
}
}
// Read a value. Close the stream if close is true
public HVal readVal(bool close)
{
try
{
HVal val = null;
bool bValisVer = false;
if (m_curVal is string)
{
if (((string)m_curVal).CompareTo("ver") == 0)
{
bValisVer = true;
}
}
if (m_tokCur == HaystackToken.id && bValisVer)
{
val = parseGrid();
}
else
{
val = parseVal();
}
// Depart from Java - 15.08.2018 after testing with Java Toolkit
// It is possible there might be newlines or other non prihtables before eof
// only verify it is not a token of interest
bool bEnd = false;
while (!bEnd)
{
if (tryVerify(HaystackToken.nl, false))
{
consume();
}
else
{
// This will throw an exception if it is not eof
verify(HaystackToken.eof);
bEnd = true;
}
}
return(val);
}
finally
{
if (close)
{
this.close();
}
}
}
private HList parseList()
{
List <HVal> arr = new List <HVal>();
consume(HaystackToken.lbracket);
while (m_tokCur != HaystackToken.rbracket && m_tokCur != HaystackToken.eof)
{
HVal val = parseVal();
arr.Add(val);
if (m_tokCur != HaystackToken.comma)
{
break;
}
consume(HaystackToken.comma);
}
consume(HaystackToken.rbracket);
return(HList.make(arr));
}
private void writeScalar(HVal val)
{
if (val == null)
{
p('N');
}
else if (val is HBin)
{
writeBin((HBin)val);
}
else if (val is HXStr)
{
writeXStr((HXStr)val);
}
else
{
p(val.toZinc());
}
flush();
}
private void writeDictTags(HDict dict, bool first)
{
bool bLocalFirst = first;
// Is ther a multi-threaded issue here - for a changing size of dict
for (int i = 0; i < dict.size(); i++)
{
if (bLocalFirst)
{
bLocalFirst = false;
}
else
{
m_swOut.Write(", ");
}
string name = dict.getKeyAt(i, true);
HVal val = dict.get(name, false);
m_swOut.Write(HStr.toCode(name));
m_swOut.Write(":");
writeVal(val);
}
}
private void writeVal(HVal val)
{
if (val == null)
{
m_swOut.Write("null");
}
else if (val is HBool)
{
m_swOut.Write(val);
}
else if (val is HDict)
{
writeDict((HDict)val);
}
else if (val is HGrid)
{
writeGrid((HGrid)val);
}
else
{
m_swOut.Write(HStr.toCode(val.toJson()));
}
}
private void writeRow(HGrid grid, HRow row)
{
for (int i = 0; i < grid.numCols; ++i)
{
HVal val = row.get(grid.col(i), false);
if (i > 0)
{
m_swOut.Write(',');
}
if (val == null)
{
if (i == 0)
{
m_swOut.Write('N');
}
}
else
{
m_swOut.Write(val.toZinc());
}
}
flush();
}
// Write a zinc value
public HZincWriter writeVal(HVal val)
{
if (val is HGrid)
{
HGrid grid = (HGrid)val;
try
{
bool insideGrid = m_iGridDepth > 0;
++m_iGridDepth;
if (insideGrid)
{
writeNestedGrid(grid);
}
else
{
writeGrid(grid);
}
}
finally
{
--m_iGridDepth;
}
}
else if (val is HList)
{
writeList((HList)val);
}
else if (val is HDict)
{
writeDict((HDict)val);
}
else
{
writeScalar(val);
}
return(this);
}
//////////////////////////////////////////////////////////////////////////
// PointWrite
//////////////////////////////////////////////////////////////////////////
/**
* Write to a given level of a writable point, and return the current status
* of a writable point's priority array (see pointWriteArray()).
*
* @param id Ref identifier of writable point
* @param level Number from 1-17 for level to write
* @param val value to write or null to auto the level
* @param who optional username performing the write, otherwise user dis is used
* @param dur Number with duration unit if setting level 8
*/
public HGrid pointWrite(HRef id, int level, string who,
HVal val, HNum dur)
{
HGridBuilder b = new HGridBuilder();
b.addCol("id");
b.addCol("level");
b.addCol("who");
b.addCol("val");
b.addCol("duration");
b.addRow(new HVal[] {
id,
HNum.make(level),
HStr.make(who),
val,
dur
});
HGrid req = b.toGrid();
HGrid res = call("pointWrite", req);
return(res);
}
private HGrid parseGrid()
{
bool nested = m_tokCur == HaystackToken.lt2;
if (nested)
{
consume(HaystackToken.lt2);
if (m_tokCur == HaystackToken.nl)
{
consume(HaystackToken.nl);
}
}
bool bValisVer = false;
if (m_curVal is string)
{
if (((string)m_curVal).CompareTo("ver") == 0)
{
bValisVer = true;
}
}
// ver:"3.0"
if (m_tokCur != HaystackToken.id || !bValisVer)
{
err("Expecting grid 'ver' identifier, not " + curToStr());
}
consume();
consume(HaystackToken.colon);
m_iversion = checkVersion(consumeStr());
// grid meta
HGridBuilder gb = new HGridBuilder();
if (m_tokCur == HaystackToken.id)
{
gb.Meta.add(parseDict());
}
consume(HaystackToken.nl);
// column definitions
int numCols = 0;
while (m_tokCur == HaystackToken.id)
{
++numCols;
string name = consumeTagName();
HDict colMeta = HDict.Empty;
if (m_tokCur == HaystackToken.id)
{
colMeta = parseDict();
}
gb.addCol(name).add(colMeta);
if (m_tokCur != HaystackToken.comma)
{
break;
}
consume(HaystackToken.comma);
}
if (numCols == 0)
{
err("No columns defined");
}
consume(HaystackToken.nl);
// grid rows
while (true)
{
if (m_tokCur == HaystackToken.nl)
{
break;
}
if (m_tokCur == HaystackToken.eof)
{
break;
}
if (nested && m_tokCur == HaystackToken.gt2)
{
break;
}
// read cells
HVal[] cells = new HVal[numCols];
for (int i = 0; i < numCols; ++i)
{
if (m_tokCur == HaystackToken.comma || m_tokCur == HaystackToken.nl || m_tokCur == HaystackToken.eof)
{
cells[i] = null;
}
else
{
cells[i] = parseVal();
}
if (i + 1 < numCols)
{
consume(HaystackToken.comma);
}
}
gb.addRow(cells);
// newline or end
if (nested && m_tokCur == HaystackToken.gt2)
{
break;
}
if (m_tokCur == HaystackToken.eof)
{
break;
}
consume(HaystackToken.nl);
}
if (m_tokCur == HaystackToken.nl)
{
consume(HaystackToken.nl);
}
if (nested)
{
consume(HaystackToken.gt2);
}
return(gb.toGrid());
}
protected void verifyZinc(HVal val, string s)
{
Assert.AreEqual(val.toZinc(), s);
Assert.IsTrue(read(s).hequals(val));
}
public HGrid pointWrite(HRef id, int level, string who, HVal val, HNum dur)
{
throw new NotImplementedException();
}
