public void Move(IValue row, int offset)
{
row = row.GetRawValue();
int indexSource;
if (row is ValueTreeRow)
{
indexSource = _rows.IndexOf(row as ValueTreeRow);
}
else if (row.DataType == Machine.DataType.Number)
{
indexSource = decimal.ToInt32(row.AsNumber());
}
else
{
throw RuntimeException.InvalidArgumentType();
}
if (indexSource < 0 || indexSource >= _rows.Count())
{
throw RuntimeException.InvalidArgumentValue();
}
int indexDestination = (indexSource + offset) % _rows.Count();
while (indexDestination < 0)
{
indexDestination += _rows.Count();
}
ValueTreeRow tmp = _rows[indexSource];
if (indexSource < indexDestination)
{
_rows.Insert(indexDestination + 1, tmp);
_rows.RemoveAt(indexSource);
}
else
{
_rows.RemoveAt(indexSource);
_rows.Insert(indexDestination, tmp);
}
}
public static T ConvertParam <T>(IValue value, T defaultValue)
{
var type = typeof(T);
object valueObj = ConvertParam(value, type);
if (valueObj == null)
{
return(defaultValue);
}
try
{
return((T)valueObj);
}
catch (InvalidCastException)
{
throw RuntimeException.InvalidArgumentType();
}
}
public void Write(IValue filenameOrStream)
{
if (filenameOrStream.DataType == DataType.String)
{
var filename = filenameOrStream.AsString();
using (var fs = new FileStream(filename, FileMode.Create, FileAccess.Write))
{
fs.Write(_buffer, 0, _buffer.Length);
}
}
else if (filenameOrStream.AsObject() is IStreamWrapper stream)
{
stream.GetUnderlyingStream().Write(_buffer, 0, _buffer.Length);
}
else
{
throw RuntimeException.InvalidArgumentType("filenameOrStream");
}
}
public ValueTable.ValueTable GetMethodsTable(IValue target)
{
var result = new ValueTable.ValueTable();
if (target.DataType == DataType.Object)
{
FillMethodsTableForObject(target.AsObject(), result);
}
else if (target.DataType == DataType.Type)
{
FillMethodsTableForType(target.GetRawValue() as TypeTypeValue, result);
}
else
{
throw RuntimeException.InvalidArgumentType();
}
return(result);
}
public static HttpRequestContext Constructor(IValue resource, IValue headers = null)
{
var ctx = new HttpRequestContext {
ResourceAddress = resource.AsString()
};
if (headers == null)
{
return(ctx);
}
if (!(headers.GetRawValue() is MapImpl headersMap))
{
throw RuntimeException.InvalidArgumentType();
}
ctx.Headers = headersMap;
return(ctx);
}
private static IXSDirective CreateIXSDirective(XmlSchemaExternal xmlSchemaExternal)
{
if (xmlSchemaExternal is XmlSchemaImport import)
{
return(new XSImport(import));
}
else if (xmlSchemaExternal is XmlSchemaInclude include)
{
return(new XSInclude(include));
}
else if (xmlSchemaExternal is XmlSchemaRedefine redefine)
{
return(new XSRedefine(redefine));
}
throw RuntimeException.InvalidArgumentType();
}
public ArrayImpl FindRows(IValue Filter)
{
if (!(Filter is StructureImpl))
{
throw RuntimeException.InvalidArgumentType();
}
ArrayImpl Result = new ArrayImpl();
foreach (ValueTableRow row in _rows)
{
if (CheckFilterCriteria(row, Filter as StructureImpl))
{
Result.Add(row);
}
}
return(Result);
}
public void Записать(object filenameOrStream)
{
if (filenameOrStream is string)
{
var filename = filenameOrStream as string;
using (var fs = new FileStream(filename, FileMode.Create, FileAccess.Write))
{
fs.Write(_buffer, 0, _buffer.Length);
}
}
//else if(filenameOrStream is IStreamWrapper stream)
//{
// stream.GetUnderlyingStream().Write(_buffer, 0, _buffer.Length);
//}
else
{
throw RuntimeException.InvalidArgumentType("filenameOrStream");
}
}
public ValueTable.ValueTable GetPropertiesTable(IValue target)
{
ValueTable.ValueTable result = new ValueTable.ValueTable();
if (target.DataType == DataType.Object)
{
FillPropertiesTable(result, target.AsObject().GetProperties());
}
else if (target.DataType == DataType.Type)
{
var type = target.GetRawValue() as TypeTypeValue;
FillPropertiesTableForType(type, result);
}
else
{
throw RuntimeException.InvalidArgumentType();
}
return(result);
}
public void AddHandler(
IRuntimeContextInstance eventSource,
string eventName,
IRuntimeContextInstance handlerTarget,
string handlerMethod)
{
if (!(handlerTarget is ScriptDrivenObject handlerScript))
{
throw RuntimeException.InvalidArgumentType("handlerTarget");
}
if (!_registeredHandlers.TryGetValue(eventSource, out var handlers))
{
handlers = new Dictionary <string, HandlersList>();
handlers[eventName] = new HandlersList();
_registeredHandlers[eventSource] = handlers;
}
handlers[eventName].Add(handlerScript, handlerMethod);
}
public void CopyTo(IValue targetStream, int bufferSize = 0)
{
IStreamWrapper sw = targetStream.GetRawValue() as IStreamWrapper;
if (sw == null)
{
throw RuntimeException.InvalidArgumentType("targetStream");
}
var stream = sw.GetUnderlyingStream();
if (bufferSize == 0)
{
_underlyingStream.CopyTo(stream);
}
else
{
_underlyingStream.CopyTo(stream, bufferSize);
}
}
public void Append(IValue toAdd)
{
byte[] buffer = null;
if (toAdd.DataType == DataType.String)
{
buffer = Encoding.UTF8.GetBytes(toAdd.AsString());
}
else if (toAdd.DataType == DataType.Object)
{
try
{
var binaryData = toAdd as BinaryDataContext;
buffer = binaryData.Buffer;
}
catch
{
throw RuntimeException.InvalidArgumentType();
}
}
AddStream(new MemoryStream(buffer));
}
public static IRuntimeContextInstance ConstructByQualifiers(
IValue types,
IValue numberQualifiers = null,
IValue stringQualifiers = null,
IValue dateQualifiers = null,
IValue binaryDataQualifiers = null)
{
var _types = ConstructTypeList(types);
if (_types == null)
{
throw RuntimeException.InvalidArgumentType(nameof(types));
}
var paramNumberQ = numberQualifiers?.GetRawValue() as NumberQualifiers;
var paramStringQ = stringQualifiers?.GetRawValue() as StringQualifiers;
var paramDateQ = dateQualifiers?.GetRawValue() as DateQualifiers;
var paramBinaryDataQ = binaryDataQualifiers?.GetRawValue() as BinaryDataQualifiers;
return(new TypeDescription(_types, paramNumberQ, paramStringQ, paramDateQ, paramBinaryDataQ));
}
public ArrayImpl FindRows(IValue filter)
{
var filterStruct = filter.GetRawValue() as StructureImpl;
if (filterStruct == null)
{
throw RuntimeException.InvalidArgumentType();
}
ArrayImpl Result = new ArrayImpl();
foreach (ValueTableRow row in _rows)
{
if (CheckFilterCriteria(row, filterStruct))
{
Result.Add(row);
}
}
return(Result);
}
private IEnumerable <ValueTableRow> GetRowsEnumByArray(IValue Rows)
{
IEnumerable <ValueTableRow> requestedRows;
var rowsArray = Rows.GetRawValue() as ArrayImpl;
if (rowsArray == null)
{
throw RuntimeException.InvalidArgumentType();
}
requestedRows = rowsArray.Select(x =>
{
var vtr = x.GetRawValue() as ValueTableRow;
if (vtr == null || vtr.Owner() != this)
{
throw RuntimeException.InvalidArgumentValue();
}
return(vtr);
});
return(requestedRows);
}
public ValueTable.ValueTable GetPropertiesTable(IValue target)
{
ValueTable.ValueTable result = new ValueTable.ValueTable();
if (target.DataType == DataType.Object)
{
FillPropertiesTable(result, target.AsObject().GetProperties());
}
else if (target.DataType == DataType.Type)
{
var type = target.GetRawValue() as TypeTypeValue;
var clrType = GetReflectableClrType(type);
var magicCaller = CreatePropertiesMapper(clrType);
FillPropertiesTable(result, magicCaller.GetProperties());
}
else
{
throw RuntimeException.InvalidArgumentType();
}
return(result);
}
private byte[] GetBytes <T>(Converter <T, byte[]> converterOverload, T value, IValue byteOrder = null)
{
byte[] bytes;
if (byteOrder == null)
{
bytes = converterOverload(value);
}
else
{
try
{
var order = (ByteOrderEnum)(object)byteOrder.GetRawValue();
Converter.IsLittleEndian = order == ByteOrderEnum.LittleEndian;
bytes = converterOverload(value);
}
catch (InvalidCastException)
{
throw RuntimeException.InvalidArgumentType();
}
}
return(bytes);
}
internal static string XMLStringIValue(IValue value)
{
switch (value.DataType)
{
case DataType.Undefined:
return("");
case DataType.String:
return(value.AsString());
case DataType.Boolean:
return(XmlConvert.ToString(value.AsBoolean()));
case DataType.Date:
return(XmlConvert.ToString(value.AsDate(), XmlDateTimeSerializationMode.Unspecified));
case DataType.Number:
return(XmlConvert.ToString(value.AsNumber()));
default:
throw RuntimeException.InvalidArgumentType();
}
}
private void SetMinOccurs(XmlSchemaParticle particle, IValue minOccurs)
{
if (minOccurs.DataType == DataType.Undefined)
{
particle.MinOccursString = null;
}
else if (minOccurs.DataType == DataType.Number)
{
decimal number = minOccurs.AsNumber();
if (number >= 0)
{
particle.MinOccurs = number;
}
else
{
throw RuntimeException.InvalidArgumentValue();
}
}
else
{
throw RuntimeException.InvalidArgumentType();
}
}
public void Open(IValue filenameOrStream, string password = null, FileNamesEncodingInZipFile encoding = FileNamesEncodingInZipFile.Auto)
{
// f**k non-russian encodings on non-ascii files
ZipFile.DefaultEncoding = Encoding.GetEncoding(866);
if (filenameOrStream.DataType == DataType.String)
{
_zip = ZipFile.Read(filenameOrStream.AsString(), new ReadOptions {
Encoding = ChooseEncoding(encoding)
});
}
else if (filenameOrStream.AsObject() is IStreamWrapper stream)
{
_zip = ZipFile.Read(stream.GetUnderlyingStream(), new ReadOptions {
Encoding = ChooseEncoding(encoding)
});
}
else
{
throw RuntimeException.InvalidArgumentType(nameof(filenameOrStream));
}
_zip.Password = password;
}
