} // ctor
/// <summary>Add a meta info value.</summary>
/// <param name="key">Meta key.</param>
/// <param name="getDataType">Data type of the value.</param>
/// <param name="value">Unconverted value of the meta key.</param>
protected void Add(string key, Func <Type> getDataType, object value)
{
if (String.IsNullOrEmpty(key))
{
throw new ArgumentNullException("key");
}
if (value == null)
{
metaInfo.Remove(key);
}
else
{
// change the type
if (WellknownMetaTypes.TryGetValue(key, out var dataType))
{
value = Procs.ChangeType(value, dataType);
}
else if (getDataType != null)
{
value = Procs.ChangeType(value, getDataType());
}
// add the key
if (value == null)
{
metaInfo.Remove(key);
}
else
{
metaInfo[key] = value;
}
}
} // proc Add
/// <summary>Parse tag, return from sqlite db.</summary>
/// <param name="attributeLine"></param>
/// <returns></returns>
public static PpsObjectTag ParseTag(string attributeLine)
{
// name:class=value
// e.g.: key:0=text
var m = regAttributeLine.Match(attributeLine);
if (!m.Success)
{
throw new FormatException("Attribute line does not match format.");
}
var classHint = (PpsObjectTagClass)(String.IsNullOrEmpty(m.Groups["c"].Value) ? 0 : Int32.Parse(m.Groups["c"].Value));
object value;
if (classHint == PpsObjectTagClass.Deleted)
{
value = null;
}
else
{
var dataType = GetTypeFromClass(classHint);
value = Procs.UnescapeSpecialChars(m.Groups["v"].Value);
if (value != null)
{
value = Procs.ChangeType(value, dataType);
}
}
return(new PpsObjectTag(m.Groups["n"].Value, classHint, value));
} // func ParseTag
/// <summary></summary>
/// <param name="xTag"></param>
/// <returns></returns>
public static PpsObjectTag FromXml(XElement xTag)
{
var key = xTag.GetAttribute("key", null);
var tagClass = xTag.GetAttribute("tagClass", PpsObjectTagClass.Text);
var value = Procs.ChangeType(xTag.GetAttribute("value", null), PpsObjectTag.GetTypeFromClass(tagClass));
return(new PpsObjectTag(key, tagClass, value));
} // func FromXml
} // func GetPaneType
/// <summary>Get default open pane mode</summary>
/// <param name="paneManager">Pane manager to use.</param>
/// <param name="arguments"></param>
/// <returns></returns>
public static PpsOpenPaneMode GetDefaultPaneMode(this IPpsWindowPaneManager paneManager, dynamic arguments)
{
if (arguments != null && arguments.Mode != null)
{
return(Procs.ChangeType <PpsOpenPaneMode>(arguments.Mode));
}
return(paneManager.Shell.GetOptionalValue("NewPaneMode", true) ? PpsOpenPaneMode.NewPane : PpsOpenPaneMode.ReplacePane);
} // func GetDefaultPaneMode
public static void RunCommand(string cmd, string[] argArray)
{
var ti = typeof(Program).GetTypeInfo();
var mi = (from c in ti.GetRuntimeMethods()
let attr = c.GetCustomAttribute <InteractiveCommandAttribute>()
where c.IsStatic && attr != null && (String.Compare(attr.Name, cmd, StringComparison.OrdinalIgnoreCase) == 0 || String.Compare(attr.Short, cmd, StringComparison.OrdinalIgnoreCase) == 0)
select c).FirstOrDefault();
if (mi == null)
{
throw new Exception($"Command '{cmd}' not found.");
}
var parameterInfo = mi.GetParameters();
var parameters = new object[parameterInfo.Length];
if (parameterInfo.Length > 0) // bind arguments
{
for (var i = 0; i < parameterInfo.Length; i++)
{
if (i < argArray.Length) // convert argument
{
parameters[i] = Procs.ChangeType(argArray[i], parameterInfo[i].ParameterType);
}
else
{
parameters[i] = parameterInfo[i].DefaultValue;
}
}
}
// execute command
object r;
if (mi.ReturnType == typeof(Task)) // async
{
var t = (Task)mi.Invoke(null, parameters);
t.Wait();
r = null;
}
else
{
r = mi.Invoke(null, parameters);
}
if (r != null)
{
view.WriteObject(r);
}
} // proc RunCommand
} // proc CreateException
private XElement CreateMember(object member, object value, Type type = null)
{
var x = new XElement("v",
member is int?new XAttribute("i", member) : new XAttribute("n", member.ToString()),
new XAttribute("t", LuaType.GetType(type ?? (value != null ? value.GetType() : typeof(object))).AliasOrFullName)
);
if (value != null)
{
x.Add(new XText(Procs.ChangeType <string>(value)));
}
return(x);
} // func CreateMember
} // func GetWebScopeExpression
private static void CreateArgumentExpressionsByInfo(dynamic alternateParameterInfo, ParameterInfo parameterInfo, out ConstantExpression parameterName, out Expression parameterDefault)
{
var parameterNameString = (string)(alternateParameterInfo?.Name ?? parameterInfo.Name);
var parameterDefaultValue = (object)(alternateParameterInfo?.Default ?? parameterInfo.DefaultValue);
if (parameterNameString == null)
{
throw new ArgumentNullException(nameof(parameterName));
}
parameterName = Expression.Constant(parameterNameString, typeof(string));
parameterDefault = parameterDefaultValue == DBNull.Value || parameterDefaultValue == null
? (Expression)Expression.Default(parameterInfo.ParameterType)
: Expression.Constant(Procs.ChangeType(parameterDefaultValue, parameterInfo.ParameterType), parameterInfo.ParameterType);
} // func CreateArgumentExpressionsByInfo
} // func GetPublicMemberList
internal static object GetConvertedValue(PpsDataColumnDefinition columnInfo, object value)
{
if (value != null) // unpack data type
{
if (columnInfo.IsRelationColumn && value is PpsDataRow parentRow)
{
if (parentRow.Table.TableDefinition != columnInfo.ParentColumn.Table)
{
throw new InvalidCastException($"The row (from table '{parentRow.Table.TableName}') is not a member of the parent table ({columnInfo.ParentColumn.Table.Name})");
}
value = parentRow[columnInfo.ParentColumn.Index];
}
else if (!columnInfo.IsExtended)
{
value = Procs.ChangeType(value, columnInfo.DataType);
}
}
return(value);
} // func GetConvertedValue
} // proc NextCursorAsync
private async Task NextCursorCountAsync(LuaTable table)
{
// get parameter
var cursor = GetCursor(table);
var count = Procs.ChangeType <int>(table.GetMemberValue("count") ?? -1);
// collect rows
var rows = new LuaTable();
while (count-- > 0 && cursor.MoveNext())
{
rows.Add(cursor.GetCurrentRow());
}
// send result
await PushPacketAsync(new LuaTable()
{
["id"] = cursor.Id,
["row"] = rows.Length == 0 ? null : rows
});
} // proc NextCursorCountAsync
private void LuaPrint(params object[] values)
{
string text;
if (values == null || values.Length == 0)
{
return;
}
if (values.Length == 1)
{
if (values[0] is string)
{
text = (string)values[0];
}
else
{
text = Procs.ChangeType <string>(values[0]);
}
}
else
{
text = String.Join(" ", values.Select(c => Procs.ChangeType <string>(c)));
}
if (textOutput != null)
{
textOutput.WriteLine(text);
}
else if (streamOutput != null)
{
var b = encoding.GetBytes(text);
streamOutput.Write(b, 0, b.Length);
}
else
{
throw new ArgumentException("out is not open.");
}
} // proc OnPrint
} // ctor
public string FormatValue(string value)
{
try
{
var v = Procs.ChangeType(value, DataType);
if (String.IsNullOrEmpty(format))
{
return(v.ToString());
}
else if (format[0] == '{')
{
return(String.Format(format, v));
}
else
{
return(v is IFormattable f?f.ToString(format, CultureInfo.CurrentCulture) : v.ToString());
}
}
catch
{
return(value);
}
} // func FormatValue
} // ctor
private static object GetConfigurationValueSingle(IDEConfigurationValue attr, string value)
{
var type = attr.Type;
if (type == typeof(LuaType))
{
if (value == null)
{
value = attr.DefaultValue ?? "object";
}
return(LuaType.GetType(value, false, false).Type);
}
else if (type == typeof(Encoding))
{
if (String.IsNullOrEmpty(value))
{
value = attr.DefaultValue;
}
if (String.IsNullOrEmpty(value))
{
return(Encoding.Default);
}
else if (Int32.TryParse(value, out var codePage))
{
return(Encoding.GetEncoding(codePage));
}
else
{
return(Encoding.GetEncoding(value));
}
}
else if (type == typeof(CultureInfo))
{
return(String.IsNullOrEmpty(value)
? CultureInfo.GetCultureInfo(attr.DefaultValue)
: CultureInfo.GetCultureInfo(value));
}
else if (type == typeof(DirectoryInfo))
{
return(String.IsNullOrEmpty(value)
? null
: new DirectoryInfo(value));
}
else if (type == typeof(SecureString))
{
try
{
return(Passwords.DecodePassword(value));
}
catch
{
return(null);
}
}
else if (type == typeof(FileSize))
{
return(FileSize.TryParse(value ?? attr.DefaultValue, out var fileSize)
? fileSize
: FileSize.Empty);
}
else
{
try
{
return(Procs.ChangeType(value ?? attr.DefaultValue, type));
}
catch
{
return(Procs.ChangeType(attr.DefaultValue, type));
}
}
} // func GetConfigurationValue
} // ctor
protected override string FormatValueCore(object value)
=> base.FormatValueCore(Procs.ChangeType(value, type));
/// <summary></summary>
/// <param name="x"></param>
protected override void Read(XElement x)
{
var t = x?.Element("c")?.Value;
currentValue = t ?? Procs.ChangeType(t, Column.DataType);
} // proc Read
} // proc Dispose
#endregion
#region -- IEnumerator ------------------------------------------------------------
private bool MoveNext(bool headerOnly)
{
switch (state)
{
#region -- ReadingState.Unread --
case ReadingState.Unread:
// open the xml stream
xml = owner.request.GetXmlStreamAsync(owner.path, owner.acceptedMimeType).Result;
xml.Read();
if (xml.NodeType == XmlNodeType.XmlDeclaration)
{
xml.Read();
}
if (xml.NodeType != XmlNodeType.Element || xml.LocalName != xnView.LocalName)
{
throw new InvalidDataException($"Expected \"{xnView}\", read \"{xml.LocalName}\".");
}
xml.Read();
if (xml.NodeType != XmlNodeType.Element || xml.LocalName != xnFields.LocalName)
{
throw new InvalidDataException($"Expected \"{xnFields}\", read \"{xml.LocalName}\".");
}
var viewColumns = new List <ViewDataColumn>();
var fields = (XElement)XNode.ReadFrom(xml);
foreach (var field in fields.Elements())
{
var columnName = field.Name.LocalName;
var columnDataType = LuaType.GetType(field.GetAttribute("type", "string"), lateAllowed: false).Type;
var columnId = field.GetAttribute("field", String.Empty);
var attributes = new PropertyDictionary();
// add colum id
if (!String.IsNullOrEmpty(columnId))
{
attributes.SetProperty("field", typeof(string), columnId);
}
foreach (var c in field.Elements("attribute"))
{
if (c.IsEmpty)
{
continue;
}
var attributeName = c.GetAttribute("name", String.Empty);
if (String.IsNullOrEmpty(attributeName))
{
continue;
}
attributes.SetProperty(attributeName, LuaType.GetType(c.GetAttribute("type", "string"), lateAllowed: false).Type, c.Value);
} // foreach c
viewColumns.Add(new ViewDataColumn(columnName, columnDataType, attributes));
} // foreach field
if (viewColumns.Count < 1)
{
throw new InvalidDataException("No header found.");
}
columns = viewColumns.ToArray();
state = ReadingState.FetchFirstRow;
if (headerOnly)
{
return(true);
}
else
{
goto case ReadingState.FetchFirstRow;
}
#endregion
#region -- ReadingState.FetchFirstRow --
case ReadingState.FetchFirstRow:
if (xml.NodeType != XmlNodeType.Element || xml.LocalName != xnRows.LocalName)
{
throw new InvalidDataException($"Expected \"{xnRows}\", read \"{xml.LocalName}\".");
}
if (xml.IsEmptyElement)
{
xml.Read();
if (xml.NodeType != XmlNodeType.EndElement || xml.LocalName != xnView.LocalName)
{
throw new InvalidDataException($"Expected \"{xnView}\", read \"{xml.LocalName}\".");
}
xml.Read();
if (!xml.EOF)
{
throw new InvalidDataException("Unexpected eof.");
}
state = ReadingState.Complete;
goto case ReadingState.Complete;
} // if xml.IsEmptyElement
else
{
xml.Read();
state = ReadingState.FetchRows;
goto case ReadingState.FetchRows;
}
#endregion
#region -- ReadingState.FetchRows --
case ReadingState.FetchRows:
if (xml.NodeType != XmlNodeType.Element || xml.LocalName != xnRow.LocalName)
{
throw new InvalidDataException($"Expected \"r\", read \"{xml.LocalName}\".");
}
var values = new object[columns.Length];
if (!xml.IsEmptyElement)
{
var rowData = (XElement)XNode.ReadFrom(xml);
foreach (var column in rowData.Elements())
{
var columnIndex = Array.FindIndex(columns, c => String.Compare(c.Name, column.Name.LocalName, StringComparison.OrdinalIgnoreCase) == 0);
if (columnIndex != -1)
{
values[columnIndex] = Procs.ChangeType(column.Value, columns[columnIndex].DataType);
}
}
} // if xml.IsEmptyElement
else
{
// Without a call to XNode.ReadFrom() it's necessary to read to the next node.
xml.Read();
}
currentRow = new ViewDataRow(this, values);
if (xml.NodeType == XmlNodeType.Element && xml.LocalName == xnRow.LocalName)
{
return(true);
}
if (xml.NodeType != XmlNodeType.EndElement || xml.LocalName != xnRows.LocalName)
{
throw new InvalidDataException($"Expected \"{xnRows}\", read \"{xml.LocalName}\".");
}
xml.Read();
if (xml.NodeType != XmlNodeType.EndElement || xml.LocalName != xnView.LocalName)
{
throw new InvalidDataException($"Expected \"{xnView}\", read \"{xml.LocalName}\".");
}
xml.Read();
if (!xml.EOF)
{
throw new InvalidDataException("Unexpected eof.");
}
state = ReadingState.Complete;
return(true);
#endregion
case ReadingState.Complete:
return(false);
default:
throw new InvalidOperationException("The state of the object is invalid.");
} // switch state
} // func MoveNext
} // proc Reset
private object GetValueIntern(int columnIndex)
{
// get value
var value = owner.CoreReader[columnIndex];
var column = owner.Columns?[columnIndex];
if (column == null)
{
return(null); // no column defined
}
// convert
if (column.Converter != null)
{
return(column.Converter(value));
}
else if (column.DataType == typeof(decimal))
{
return(Decimal.Parse(value, NumberStyles.Currency | NumberStyles.Float, column.FormatProvider));
}
else if (column.DataType == typeof(double))
{
return(Double.Parse(value, NumberStyles.Currency | NumberStyles.Float, column.FormatProvider));
}
else if (column.DataType == typeof(float))
{
return(Single.Parse(value, NumberStyles.Currency | NumberStyles.Float, column.FormatProvider));
}
else if (column.DataType == typeof(byte))
{
return(Byte.Parse(value, NumberStyles.Integer, column.FormatProvider));
}
else if (column.DataType == typeof(sbyte))
{
return(SByte.Parse(value, NumberStyles.Integer, column.FormatProvider));
}
else if (column.DataType == typeof(ushort))
{
return(UInt16.Parse(value, NumberStyles.Integer, column.FormatProvider));
}
else if (column.DataType == typeof(short))
{
return(Int16.Parse(value, NumberStyles.Integer, column.FormatProvider));
}
else if (column.DataType == typeof(uint))
{
return(UInt32.Parse(value, NumberStyles.Integer, column.FormatProvider));
}
else if (column.DataType == typeof(int))
{
return(Int32.Parse(value, NumberStyles.Integer, column.FormatProvider));
}
else if (column.DataType == typeof(ulong))
{
return(UInt64.Parse(value, NumberStyles.Integer, column.FormatProvider));
}
else if (column.DataType == typeof(long))
{
return(Int64.Parse(value, NumberStyles.Integer, column.FormatProvider));
}
else if (column.DataType == typeof(DateTime))
{
return(DateTime.Parse(value, column.FormatProvider, DateTimeStyles.AssumeLocal));
}
else if (column.DataType == typeof(string))
{
return(value);
}
else
{
return(Procs.ChangeType(value, column.DataType));
}
} // func GetValue
private CollectionViewSource LuaCreateSource(object collection)
{
var collectionArgs = collection as LuaTable;
if (collectionArgs != null)
{
collection = collectionArgs.GetMemberValue("Source");
}
if (collection == null)
{
throw new ArgumentNullException(nameof(collection));
}
// get containted list
if (collection is IListSource listSource)
{
collection = listSource.GetList();
}
// function views
if (!(collection is IEnumerable) && Lua.RtInvokeable(collection))
{
collection = new LuaFunctionEnumerator(collection);
}
var collectionViewSource = new CollectionViewSource();
using (collectionViewSource.DeferRefresh())
{
collectionViewSource.Source = collection;
if (collectionArgs != null)
{
if (collectionArgs.GetMemberValue(nameof(CollectionView.SortDescriptions)) is LuaTable t)
{
foreach (var col in t.ArrayList.OfType <string>())
{
if (String.IsNullOrEmpty(col))
{
continue;
}
string propertyName;
ListSortDirection direction;
if (col[0] == '+')
{
propertyName = col.Substring(1);
direction = ListSortDirection.Ascending;
}
else if (col[0] == '-')
{
propertyName = col.Substring(1);
direction = ListSortDirection.Descending;
}
else
{
propertyName = col;
direction = ListSortDirection.Ascending;
}
collectionViewSource.SortDescriptions.Add(new SortDescription(propertyName, direction));
}
}
// todo: beist sich mit CanFilter
var viewFilter = collectionArgs.GetMemberValue("ViewFilter");
if (Lua.RtInvokeable(viewFilter))
{
collectionViewSource.Filter += (sender, e) => e.Accepted = Procs.ChangeType <bool>(new LuaResult(Lua.RtInvoke(viewFilter, e.Item)));
}
}
}
if (collectionViewSource.View == null)
{
throw new ArgumentNullException("Could not create a collection view.");
}
return(collectionViewSource);
} // func LuaCreateSource
/// <summary>Is the tag value equal.</summary> /// <param name="otherValue"></param> /// <returns></returns> public bool IsValueEqual(object otherValue) => Equals(value, Procs.ChangeType(otherValue, GetTypeFromClass(cls)));
public object GetAttribute(string name)
{
var attribute = attributes.FirstOrDefault(c => String.Compare(c.Name.LocalName, name, StringComparison.OrdinalIgnoreCase) == 0);
if (attribute == null)
{
throw new ArgumentException(String.Format("@{0} is not defined.", name));
}
var attributeValue = element.Attribute(attribute.Name)?.Value ?? attribute.DefaultValue;
if (attribute.TypeName == "LuaType")
{
if (attributeValue == null)
{
attributeValue = "object";
}
return(LuaType.GetType(attributeValue, false, false).Type);
}
else if (attribute.TypeName == "EncodingType")
{
int codePage;
if (String.IsNullOrEmpty(attributeValue))
{
attributeValue = attribute.DefaultValue;
}
if (String.IsNullOrEmpty(attributeValue))
{
return(Encoding.Default);
}
else if (int.TryParse(attributeValue, out codePage))
{
return(Encoding.GetEncoding(codePage));
}
else
{
return(Encoding.GetEncoding(attributeValue));
}
}
else if (attribute.TypeName == "language")
{
return(String.IsNullOrEmpty(attributeValue) ?
CultureInfo.GetCultureInfo(attribute.DefaultValue) :
CultureInfo.GetCultureInfo(attributeValue));
}
else if (attribute.TypeName == "PathType")
{
if (String.IsNullOrEmpty(attributeValue))
{
return(null);
}
return(new DirectoryInfo(attributeValue));
}
else
{
var type = attribute.Type;
try
{
return(Procs.ChangeType(attributeValue, type));
}
catch
{
return(Procs.ChangeType(attribute.DefaultValue, type));
}
}
} // func GetAttribute
} // ctor
public T GetAttribute <T>(string name)
=> Procs.ChangeType <T>(GetAttribute(name));
