private void WriteFixedRow(SharpNodeRow row, SharpNodeMap mapNode)
{
var columns = new Dictionary <string, string>();
var next = row.First;
if (next.Node.IsValueNode && !next.Node.IsSingleValueNode)
{
if (next.Node.Parent.Path == mapNode.Parent.Path)
{
return;
}
}
while (next != null)
{
var vr = next as SharpValueRow;
if (vr != null)
{
columns[next.Node.Name] = SharpValue.ToString(vr.Values[0], vr.Node.ValueType);
}
next = next.Next;
}
WriteLine(columns, mapNode);
}
public void UpdateColumnValue(int column, object value, StringBuilder row)
{
if (column < Columns.Count)
{
var col = Columns[column];
var val = SharpValue.ToString(value, col.ValueType);
if (val.Length == col.Width)
{
row.Insert(col.Offset, val);
}
else if (val.Length > col.Width)
{
row.Insert(col.Offset,
col.AlignLeft ? val.Substring(0, col.Width) : val.Substring(val.Length - col.Width, col.Width));
}
else
{
int padCount = col.Width - val.Length;
if (col.AlignLeft)
{
row.Insert(col.Offset, val);
row.Insert(col.Width + val.Length, col.Padding.ToString(), padCount);
}
else
{
row.Insert(col.Width, col.Padding.ToString(), padCount);
row.Insert(col.Width + padCount, val);
}
}
}
}
public object GetValueList()
{
SharpValueType listType = SharpValueType.None;
List <SharpValueType> types = _items.Select(x => x.GetType("#")).Distinct().ToList();
if (types.Count == 1)
{
listType = types[0];
}
return(SharpValue.AsValueList(_items.Select(x => x.GetValue()), listType));
}
public void Parse(string row)
{
if (row.StartsWith("#!"))
{
var equalStart = row.IndexOf('=');
if (equalStart >= 0)
{
Key = row.Substring(2, equalStart - 2).Trim();
string val = row.Substring(equalStart + 1).Trim();
Value = new SharpValue(val, true);
}
}
}
private void WriteValueRow(SharpValueRow row)
{
if (row.Node.IsSingleValueNode)
{
if (row.Node.PackageName.ToLower() != _lastPackage)
{
WritePackage(row.Node.PackageName);
}
if (row.Node.DefaultValue != null && !_nodeSchemaHistory.Contains(row.Node.Index))
{
_writer.WriteLine(EncodeNode(row.Node, schemaOnly: true));
}
StringBuilder sb = new StringBuilder();
var ns = EncodeNode(row.Node, shortForm: row.Node.Parent == _lastParentNode);
sb.Append(ns);
if (string.IsNullOrWhiteSpace(ns))
{
sb.Append("= ");
}
else
{
sb.Append(" = ");
}
sb.Append(SharpValue.EncodeValue(row.Values[0], row.Node.ValueType));
_writer.WriteLine(sb.ToString());
}
else
{
IEnumerable <object> values = null;
var mapNode = row.Node as SharpNodeMap;
if (mapNode != null && row.Values.Count == 1)
{
if (mapNode.MapType == SharpMapType.Fixed || mapNode.MapType == SharpMapType.Variable)
{
values = mapNode.ExpandRow(row.Values[0].ToString()).Select(x => x.Value);
}
}
foreach (var innerRow in row.Node.GetRows(values ?? row.Values))
{
WriteRow(innerRow);
}
}
}
public SharpMetaNodeRow(SharpNode source)
{
Index = source.Index;
Path = source.Path;
NodeType = source.NodeType;
ValueType = source.ValueType;
if (!string.IsNullOrEmpty(source.Format))
{
AdditionalInfo["Format"] = new SharpValue(source.Format);
}
if (source.DefaultValue != null)
{
AdditionalInfo["DefaultValue"] = new SharpValue(source.DefaultValue);
}
}
private void WriteLine(Dictionary <string, string> columns, SharpNodeMap mapNode)
{
StringBuilder line = new StringBuilder();
foreach (var col in mapNode.Columns)
{
string val = "";
if (columns.ContainsKey(col.Node.Name))
{
val = SharpValue.ToString(columns[col.Node.Name], col.Node.ValueType);
}
else
{
val = col.DefaultValue == null ? String.Empty : col.DefaultValue.ToString();
}
if (val.Length == col.Width)
{
line.Append(val);
}
else if (val.Length > col.Width)
{
line.Append(col.AlignLeft ? val.Substring(0, col.Width) : val.Substring(val.Length - col.Width, col.Width));
}
else
{
if (col.AlignLeft)
{
line.Append(val);
line.Append(col.Padding, col.Width - val.Length);
}
else
{
line.Append(col.Padding, col.Width - val.Length);
line.Append(val);
}
}
}
_writer.WriteLine(line.ToString());
}
public virtual object GetColumnValue(string field, string value)
{
string type;
if (AutoTrimColumns)
{
value = value.Trim();
}
if (ColumnTypes.TryGetValue(field, out type))
{
SharpValueType vt;
if (Enum.TryParse(type, out vt))
{
return(SharpValue.ToValue(value, vt));
}
}
return(AutoTypeColumns ? SharpValue.ToValue(value, SharpValueType.Auto) : value);
}
private void WriteFixedRow(SharpValueRow row, SharpNodeMap mapNode)
{
var columns = new Dictionary <string, string>();
var rowMap = row.Node as SharpNodeMap;
var mapType = rowMap.MapType;
List <SharpValue> rowValues = new List <SharpValue>();
if (mapType == SharpMapType.Fixed)
{
rowValues = rowMap.ExpandRow((string)row.Values[0]).ToList();
}
else if (mapType == SharpMapType.Sequence)
{
rowValues = rowMap.GetRowValues(row.Values).ToList();
}
else if (mapType == SharpMapType.Variable)
{
if (row.Values.Count == 1 && row.Values[0] is string)
{
rowValues = rowMap.ExpandRow((string)row.Values[0]).ToList();
}
else
{
rowValues = rowMap.GetRowValues((row.Values)).ToList();
}
}
int i = 0;
foreach (var column in rowMap.Columns)
{
columns[column.Node.Name] = SharpValue.ToString(rowValues[i].Value, rowValues[i].Type);
i++;
}
WriteLine(columns, mapNode);
}
public object GetColumnValue(int column, List <object> values)
{
var col = _columns[column];
if (!(values[column] is string))
{
return(values[column]);
}
var val = values[column] as string;
val = col.AlignLeft ? val.TrimEnd() : val.TrimStart();
var colType = _columns[column].ValueType;
if (colType == SharpValueType.None || colType == SharpValueType.String)
{
return(val);
}
return(SharpValue.ToValue(val, colType));
}
public SharpMetaParameterRow(string key, object value)
{
Key = key;
Value = new SharpValue(value);
}
public void Parse(string row, string defaultPath = "")
{
AdditionalInfo.Clear();
QueryPath.Clear();
ValueType = SharpValueType.None;
NodeType = SharpNodeType.Any;
StringBuilder sbPath = new StringBuilder();
StringBuilder sbType = new StringBuilder();
StringBuilder sbFormat = new StringBuilder();
StringBuilder sbDefaultValue = new StringBuilder();
StringBuilder sbQueryPath = new StringBuilder();
StringBuilder sbQueryValue = new StringBuilder();
StringBuilder sbIndex = new StringBuilder();
bool parseIndex = false;
bool parsePath = true;
bool parseQueryPath = false;
bool parseQueryValue = false;
bool parseType = false;
bool parseFormat = false;
bool parseDefaultValue = false;
bool isValueNode = false;
bool isAttribute = false;
bool isPathExpanded = false;
bool isPathLocked = false;
int formatCount = 0;
int pos = 0;
while (pos < row.Length)
{
char c = row[pos++];
if (char.IsWhiteSpace(c))
{
continue;
}
if (c == '$')
{
parseIndex = true;
}
else
{
pos--;
}
break;
}
while (pos < row.Length)
{
char c = row[pos++];
if (parseIndex)
{
if (c == '=')
{
int index = -1;
if (int.TryParse(sbIndex.ToString().Trim(), out index))
{
Index = index;
}
parseIndex = false;
}
else
{
sbIndex.Append(c);
}
}
else if (parseDefaultValue)
{
sbDefaultValue.Append(c);
}
else if (parseFormat)
{
if (c == '}')
{
if (formatCount >= 0)
{
parseFormat = false;
parsePath = true;
AdditionalInfo["Format"] = new SharpValue(sbFormat.ToString());
}
else
{
formatCount--;
}
}
else
{
if (c == '{')
{
formatCount++;
}
sbFormat.Append(c);
}
}
else if (parseType)
{
if (c == ' ' || c == '=' || c == '{' || c == ':')
{
var t = sbType.ToString().Trim();
if (!string.IsNullOrEmpty(t))
{
SharpNodeType nt;
if (Enum.TryParse(t, true, out nt))
{
NodeType = nt;
}
SharpValueType vt;
if (Enum.TryParse(t, true, out vt))
{
ValueType = vt;
}
}
sbType.Clear();
if (c == '=' || c == ':')
{
parseType = false;
parsePath = true;
pos--;
continue;
}
else if (c == '{')
{
parseType = false;
parseFormat = true;
}
}
else
{
sbType.Append(c);
}
}
else if (parseQueryValue)
{
if (c == ']')
{
QueryPath[sbPath.ToString()] = new KeyValuePair <string, string>(sbQueryPath.ToString(), sbQueryValue.ToString());
parseQueryValue = false;
sbQueryPath.Clear();
sbQueryValue.Clear();
}
else
{
sbQueryValue.Append(c);
}
}
else if (parseQueryPath)
{
if (c == '=')
{
parseQueryPath = false;
parseQueryValue = true;
}
else if (c == ']')
{
parseQueryPath = false;
sbQueryPath.Clear();
sbQueryValue.Clear();
}
else
{
sbQueryPath.Append(c);
}
}
else if (parsePath)
{
if (char.IsWhiteSpace(c))
{
continue;
}
if (!isPathExpanded)
{
if (c == '~' || c == '=' || c == '{' || c == '.' || c == '@')
{
sbPath.Append(defaultPath);
isPathExpanded = true;
if (c != '.')
{
isValueNode = true;
isPathLocked = true;
sbPath.Append('/');
}
else
{
continue;
}
}
}
else if (c == '.' && !isPathLocked)
{
var parts = sbPath.ToString().Split('/').Select(x => x.Trim()).Where(x => !string.IsNullOrEmpty(x)).ToList();
if (parts.Count > 1)
{
parts = parts.Take(parts.Count - 1).ToList();
}
sbPath = new StringBuilder(String.Join("/", parts));
continue;
}
if (c != '.')
{
isPathLocked = true;
}
if (c == '[')
{
parseQueryPath = true;
}
else if (c == '~')
{
parseType = true;
parsePath = false;
}
else if (c == '{')
{
parseFormat = true;
parsePath = false;
}
else if (c == ':')
{
if (pos < row.Length && row[pos] == '=')
{
pos++;
parseDefaultValue = true;
parsePath = false;
}
}
else if (c == '=')
{
isValueNode = true;
parseDefaultValue = true;
parsePath = false;
}
else
{
if (c == '@')
{
isAttribute = true;
isValueNode = true;
}
else if (c == '#')
{
isValueNode = true;
}
else if (c == '/')
{
isValueNode = false;
isAttribute = false;
}
sbPath.Append(c);
isPathExpanded = true;
}
}
}
if (parseType)
{
var t = sbType.ToString().Trim();
if (!string.IsNullOrEmpty(t))
{
SharpNodeType nt;
if (Enum.TryParse(t, true, out nt))
{
NodeType = nt;
}
SharpValueType vt;
if (Enum.TryParse(t, true, out vt))
{
ValueType = vt;
}
}
parseType = false;
}
Path = sbPath.ToString();
if (isValueNode && !isAttribute && !Path.EndsWith("/#"))
{
if (!Path.EndsWith("/"))
{
Path += "/#";
}
else
{
Path += "#";
}
}
if (parseDefaultValue)
{
var defaultValue = sbDefaultValue.ToString().Trim();
if (defaultValue.StartsWith("\""))
{
defaultValue = EncodedString.ParseQuotedString(defaultValue);
}
AdditionalInfo["DefaultValue"] = new SharpValue(defaultValue);
}
}
private void WriteValueRow(SharpValueRow row, SharpMapType mapType = SharpMapType.None, char delimiter = '\0')
{
if (row.Node.IsSingleValueNode)
{
return;
}
var mapNode = row.Node as SharpNodeMap;
if (mapNode != null)
{
mapType = mapType == SharpMapType.None ? mapNode.MapType : mapType;
delimiter = delimiter == '\0' ? mapNode.Delimiter : delimiter;
if (mapType == SharpMapType.Fixed && row.Values.Count > 1)
{
mapType = SharpMapType.Sequence;
}
if (mapType == SharpMapType.Fixed)
{
_writer.WriteLine(row.Values[0]);
}
else if (mapType == SharpMapType.Variable)
{
if (row.Values.Count > 1)
{
StringBuilder line = new StringBuilder();
bool first = true;
int index = 0;
foreach (var col in mapNode.Columns)
{
var val = (index < row.Values.Count
? SharpValue.ToString(row.Values[index], col.ValueType)
: col.DefaultValue.ToString()) ?? "";
index++;
if (!first)
{
line.Append(delimiter);
}
first = false;
line.Append(val);
}
_writer.WriteLine(line);
}
else
{
_writer.WriteLine(row.Values[0]);
}
}
else if (mapType == SharpMapType.Sequence)
{
int index = 0;
StringBuilder line = new StringBuilder();
foreach (var col in mapNode.Columns)
{
var val = (index < row.Values.Count
? SharpValue.ToString(row.Values[index], col.ValueType)
: col.DefaultValue.ToString()) ?? "";
index++;
if (val.Length == col.Width)
{
line.Append(val);
}
else if (val.Length > col.Width)
{
line.Append(col.AlignLeft ? val.Substring(0, col.Width) : val.Substring(val.Length - col.Width, col.Width));
}
else
{
if (col.AlignLeft)
{
line.Append(val);
line.Append(col.Padding, col.Width - val.Length);
}
else
{
line.Append(col.Padding, col.Width - val.Length);
line.Append(val);
}
}
}
_writer.WriteLine(line.ToString());
}
}
}
public void WriteDelimited(IEnumerable <SharpRow> rows, SharpMapType mapType = SharpMapType.None, char delimiter = ',', List <string> columns = null, Dictionary <string, string> aliases = null)
{
columns = columns ?? new List <string>();
if (mapType == SharpMapType.Variable && IncludeHeader)
{
var columnNames =
columns.Select(x => aliases != null && aliases.ContainsKey(x) ? aliases[x] : x);
var header = string.Join(delimiter.ToString(), AlwaysQuote ? columns.Select(x => EncodedString.EncodeQuotedString(x)) : columns);
_writer.WriteLine(header);
}
var includeNodes = new HashSet <string>(columns);
foreach (var row in rows)
{
var nodeRow = row as SharpNodeRow;
if (nodeRow != null)
{
var next = nodeRow.First;
var valRow = next as SharpValueRow;
var rowValues = new Dictionary <string, string>();
if (valRow != null && valRow.Node is SharpNodeMap)
{
var nodeMap = valRow.Node as SharpNodeMap;
var columnValues = valRow.Values;
if (nodeMap.MapType == SharpMapType.Fixed || nodeMap.MapType == SharpMapType.Variable)
{
if (valRow.Values.Count == 1)
{
columnValues = nodeMap.ExpandRow((string)valRow.Values[0]).Select(x => x.Value).ToList();
}
}
for (int i = 0; i < nodeMap.Columns.Count && i < columnValues.Count; i++)
{
var col = nodeMap.Columns[i];
if (includeNodes.Contains(col.Node.Name))
{
rowValues[col.Node.Name] = SharpValue.ToString(columnValues[i], col.ValueType);
}
}
}
else
{
while (next != null)
{
if (!includeNodes.Contains(next.Node.Name))
{
next = next.Next;
continue;
}
valRow = next as SharpValueRow;
var val = "";
if (valRow != null && valRow.Node.IsSingleValueNode)
{
val = SharpValue.ToString(valRow.Values[0], valRow.Node.ValueType);
}
rowValues[next.Node.Name] = val;
next = next.Next;
}
}
StringBuilder line = new StringBuilder();
bool first = true;
foreach (var col in columns)
{
if (!first)
{
line.Append(delimiter);
}
first = false;
if (rowValues.ContainsKey(col))
{
var val = rowValues[col];
if (AlwaysQuote || (AllowQuotes && EncodedString.IsQuotedStringEncodingRequired(val, delimiter : delimiter, allowOnlyWhitespace : true)))
{
val = EncodedString.EncodeQuotedString(val);
}
line.Append(val);
}
}
_writer.WriteLine(line);
}
}
}
private void AddObjectMember(string memberPath, string key, object value, SharpNode node, List <SharpNodeRow> rows)
{
var objectList = value as SharpObjectList;
if (objectList != null)
{
if (objectList.HasOnlyValue)
{
AddObjectMember(memberPath, "", objectList.GetValueList(), node, rows);
return;
}
}
var memberList = value as IEnumerable <IDictionary <string, object> >;
if (memberList != null)
{
var memberListNode = node ?? _nodes.GetNode(memberPath);
if (memberListNode == null)
{
memberListNode = new SharpNode
{
Path = memberPath,
Name = SharpNode.GetNodeName(memberPath),
NodeType = SharpNodeType.Repeated
};
_nodes.Add(memberListNode);
}
foreach (var item in memberList)
{
AddObject(memberPath, item, rows);
}
return;
}
var memberObj = value as IDictionary <string, object>;
if (memberObj != null)
{
AddObject(memberPath, memberObj, rows);
return;
}
// Value Row
if (!key.StartsWith("@") && !memberPath.EndsWith("/#"))
{
memberPath += "/#";
}
// Multiple Value Row
SharpValueType memberValueType;
if (SharpValue.TryGetValueList(value, out memberValueType))
{
var memberValueListNode = _nodes.GetNode(memberPath);
if (memberValueListNode == null)
{
memberValueListNode = new SharpNode
{
Path = memberPath,
Name = SharpNode.GetNodeName(memberPath),
IsValueNode = true,
ValueType = memberValueType,
NodeType = SharpNodeType.Repeated
};
_nodes.Add(memberValueListNode);
}
foreach (var val in ((IEnumerable)value))
{
rows.Add(new SharpValueRow(memberValueListNode, val));
}
return;
}
// Single Value Row
var memberValue = new SharpValue(value);
var memberNode = _nodes.GetNode(memberPath);
if (memberNode == null)
{
memberNode = new SharpNode()
{
Path = memberPath,
Name = SharpNode.GetNodeName(memberPath),
IsValueNode = true,
ValueType = memberValue.Type
};
_nodes.Add(memberNode);
}
rows.Add(new SharpValueRow(memberNode, memberValue.Value));
}
public SharpValue(SharpValue source)
{
Type = source.Type;
Value = source.Value;
Format = source.Format;
}
