public int CompareTo(IValue other)
{
if (other.DataType != this.DataType)
{
if (this.DataType == DataType.Boolean && other.DataType == DataType.Number ||
this.DataType == DataType.Number && other.DataType == DataType.Boolean)
{
return(AsNumber().CompareTo(other.AsNumber()));
}
else
{
throw RuntimeException.ComparisonNotSupportedException();
}
}
switch (other.DataType)
{
case Machine.DataType.Boolean:
return(AsBoolean().CompareTo(other.AsBoolean()));
case Machine.DataType.Date:
return(AsDate().CompareTo(other.AsDate()));
case Machine.DataType.Undefined:
return(0);
default:
return(AsNumber().CompareTo(other.AsNumber()));
}
}
public bool Equals(IValue other)
{
if (other.DataType == this.DataType)
{
switch (DataType)
{
case Machine.DataType.Number:
return(this.AsNumber() == other.AsNumber());
case Machine.DataType.Boolean:
return(this.AsBoolean() == other.AsBoolean());
case Machine.DataType.Date:
return(this.AsDate() == other.AsDate());
case Machine.DataType.Undefined:
return(true);
default:
return(false);
}
}
else
{
return(false);
}
}
public IValue Adjust(IValue value)
{
if (value == null || value.DataType == DataType.Undefined)
{
return(ValueFactory.Create(new DateTime(1, 1, 1)));
}
try
{
// TODO: вменяемое приведение без Попытки
var dateToAdjust = value.AsDate();
switch (DateFractions)
{
case DateFractionsEnum.Date: return(ValueFactory.Create(dateToAdjust.Date));
case DateFractionsEnum.Time: return(ValueFactory.Create(new DateTime(dateToAdjust.TimeOfDay.Ticks)));
default: return(ValueFactory.Create(dateToAdjust));
}
}
catch
{
return(ValueFactory.Create(new DateTime(1, 1, 1)));
}
}
public bool IsValueFilled(IValue value)
{
if (value.DataType == DataType.Undefined)
{
return(false);
}
else if (value.DataType == DataType.Boolean)
{
return(true);
}
else if (value.DataType == DataType.String)
{
return(!String.IsNullOrWhiteSpace(value.AsString()));
}
else if (value.DataType == DataType.Number)
{
return(value.AsNumber() != 0);
}
else if (value.DataType == DataType.Date)
{
var emptyDate = new DateTime(1, 1, 1, 0, 0, 0);
return(value.AsDate() != emptyDate);
}
else if (value.GetRawValue() is ICollectionContext)
{
var col = value.GetRawValue() as ICollectionContext;
return(col.Count() != 0);
}
else
{
return(true);
}
}
public static string Format(IValue value, string format)
{
var formatParameters = ParseParameters(format);
string formattedValue;
switch (value.BaseType)
{
case ValueTypeEnum.BOOLEAN:
formattedValue = FormatBoolean(value.AsBoolean(), formatParameters);
break;
case ValueTypeEnum.NUMBER:
formattedValue = FormatNumber(value.AsNumber(), formatParameters);
break;
case ValueTypeEnum.DATE:
formattedValue = FormatDate(value.AsDate(), formatParameters);
break;
default:
formattedValue = DefaultFormat(value, formatParameters);
break;
}
return(formattedValue);
}
public string XMLString(IValue value)
{
switch (value.DataType)
{
case DataType.Undefined:
return("");
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:
if (value.SystemType.Equals(TypeManager.GetTypeByFrameworkType(typeof(BinaryDataContext))))
{
var bdc = value.GetRawValue() as BinaryDataContext;
System.Diagnostics.Debug.Assert(bdc != null);
return(Convert.ToBase64String(bdc.Buffer, Base64FormattingOptions.InsertLineBreaks));
}
else
{
return(value.GetRawValue().AsString());
}
}
}
public static string Format(IValue value, string format)
{
var formatParameters = ParseParameters(format);
string formattedValue;
switch (value.DataType)
{
case DataType.Boolean:
formattedValue = FormatBoolean(value.AsBoolean(), formatParameters);
break;
case DataType.Number:
formattedValue = FormatNumber(value.AsNumber(), formatParameters);
break;
case DataType.Date:
formattedValue = FormatDate(value.AsDate(), formatParameters);
break;
default:
formattedValue = DefaultFormat(value, formatParameters);
break;
}
return(formattedValue);
}
public void WriteValue(IValue Value, bool UseFormatWithExponent = false)
{
if (!IsOpen())
{
NotOpenException();
}
switch (Value.DataType)
{
case DataType.String:
WriteStringValue(Value.AsString());
break;
case DataType.Number:
decimal d = Value.AsNumber();
if (d == Math.Round(d))
{
Int64 i = Convert.ToInt64(d);
if (UseFormatWithExponent)
{
_writer.WriteRawValue(string.Format(Thread.CurrentThread.CurrentCulture, "{0:E}", i));
}
else
{
_writer.WriteValue(i);
}
}
else
{
if (UseFormatWithExponent)
{
_writer.WriteRawValue(string.Format(string.Format(Thread.CurrentThread.CurrentCulture, "{0:E}", d)));
}
else
{
_writer.WriteValue(d);
}
}
break;
case DataType.Date:
_writer.WriteValue(Value.AsDate());
break;
case DataType.Boolean:
_writer.WriteValue(Value.AsBoolean());
break;
case DataType.Undefined:
_writer.WriteNull();
break;
default:
throw new RuntimeException("Тип переданного значения не поддерживается.");
}
}
public static object ConvertParam(IValue value, Type type)
{
object valueObj;
if (value == null || value.DataType == DataType.NotAValidValue)
{
return(null);
}
if (Nullable.GetUnderlyingType(type) != null)
{
return(ConvertParam(value, Nullable.GetUnderlyingType(type)));
}
if (type == typeof(IValue))
{
valueObj = value;
}
else if (type == typeof(IVariable))
{
valueObj = value;
}
else if (type == typeof(string))
{
valueObj = value.AsString();
}
else if (type == typeof(int) || type == typeof(uint) || type == typeof(short) || type == typeof(ushort) || type == typeof(byte) || type == typeof(sbyte))
{
valueObj = (int)value.AsNumber();
}
else if (type == typeof(long) || type == typeof(ulong))
{
valueObj = (long)value.AsNumber();
}
else if (type == typeof(double) || type == typeof(decimal))
{
valueObj = value.AsNumber();
}
else if (type == typeof(DateTime))
{
valueObj = value.AsDate();
}
else if (type == typeof(bool))
{
valueObj = value.AsBoolean();
}
else if (typeof(IRuntimeContextInstance).IsAssignableFrom(type))
{
valueObj = value.AsObject();
}
else
{
valueObj = CastToCLRObject(value);
}
return(valueObj);
}
public override bool Equals(IValue other)
{
if (other == null)
{
return(false);
}
return(other.DataType == DataType.Date && _value.Equals(other.AsDate()));
}
public override int CompareTo(IValue other)
{
if (other.DataType == DataType.Date)
{
return(_value.CompareTo(other.AsDate()));
}
return(base.CompareTo(other));
}
public static T ConvertParam <T>(IValue value)
{
object valueObj;
var type = typeof(T);
if (value == null)
{
valueObj = default(T);
}
else if (type == typeof(IValue))
{
valueObj = value;
}
else if (type == typeof(IVariable))
{
valueObj = value;
}
else if (type == typeof(string))
{
valueObj = value.AsString();
}
else if (type == typeof(int))
{
valueObj = (int)value.AsNumber();
}
else if (type == typeof(double) || type == typeof(decimal))
{
valueObj = value.AsNumber();
}
else if (type == typeof(DateTime))
{
valueObj = value.AsDate();
}
else if (type == typeof(bool))
{
valueObj = value.AsBoolean();
}
else if (typeof(IRuntimeContextInstance).IsAssignableFrom(type))
{
valueObj = value.AsObject();
}
else
{
valueObj = default(T);
}
try
{
return((T)valueObj);
}
catch (InvalidCastException)
{
throw RuntimeException.InvalidArgumentType();
}
}
/// <summary>
/// Разница
/// </summary>
/// <param name="left"></param>
/// <param name="right"></param>
/// <returns></returns>
public static IValue SUB(IValue left, IValue right)
{
if (left.BaseType == ValueTypeEnum.NUMBER)
{
return(Create(left.AsNumber() - right.AsNumber()));
}
if (left.BaseType == ValueTypeEnum.DATE && right.BaseType == ValueTypeEnum.NUMBER)
{
return(Create(left.AsDate().AddSeconds(-(double)right.AsNumber())));
}
if (left.BaseType == ValueTypeEnum.DATE && right.BaseType == ValueTypeEnum.DATE)
{
TimeSpan result = right.AsDate() - left.AsDate();
return(Create((decimal)result.TotalSeconds));
}
return(Create(right.AsNumber() - left.AsNumber()));
}
public int StandardTimeOffset(string timeZone = null, IValue universalTime = null)
{
try
{
return(TimeZoneConverter.StandardTimeOffset(timeZone, universalTime?.AsDate()));
}
catch (TimeZoneNotFoundException)
{
throw RuntimeException.InvalidNthArgumentValue(1);
}
}
public int CompareTo(IValue other)
{
switch (other.BaseType)
{
case ValueTypeEnum.DATE:
return(_value.CompareTo(other.AsDate()));
default:
throw new Exception("Операции сравнения на больше-меньше допустимы только для значений совпадающих примитивных типов (Булево, Число, Строка, Дата)");
}
}
public IValue ToUniversalTime(IValue localTime, string timeZone = null)
{
try
{
var dt = TimeZoneConverter.ToUniversalTime(localTime.AsDate(), timeZone);
return(ValueFactory.Create(dt));
}
catch (TimeZoneNotFoundException)
{
throw RuntimeException.InvalidNthArgumentValue(2);
}
}
public static IValue Sub(IValue op1, IValue op2)
{
if (op1.DataType == DataType.Number)
{
return(Create(op1.AsNumber() - op2.AsNumber()));
}
if (op1.DataType == DataType.Date && op2.DataType == DataType.Number)
{
var date = op1.AsDate();
var result = date.AddSeconds(-(double)op2.AsNumber());
return(Create(result));
}
if (op1.DataType == DataType.Date && op2.DataType == DataType.Date)
{
var span = op1.AsDate() - op2.AsDate();
return(Create((decimal)span.TotalSeconds));
}
// все к числовому типу.
return(Create(op1.AsNumber() - op2.AsNumber()));
}
public static object ConvertToCLRObject(IValue val)
{
object result;
if (val == null)
{
return(val);
}
switch (val.DataType)
{
case Machine.DataType.Boolean:
result = val.AsBoolean();
break;
case Machine.DataType.Date:
result = val.AsDate();
break;
case Machine.DataType.Number:
result = val.AsNumber();
break;
case Machine.DataType.String:
result = val.AsString();
break;
case Machine.DataType.Undefined:
result = null;
break;
default:
if (val.DataType == DataType.Object)
{
result = val.AsObject();
}
result = val.GetRawValue();
if (result is IObjectWrapper)
{
result = ((IObjectWrapper)result).UnderlyingObject;
}
else
{
throw new ValueMarshallingException($"Тип {val.GetType()} не поддерживает преобразование в CLR-объект");
}
break;
}
return(result);
}
/// <summary>
/// Сложение
/// </summary>
/// <param name="left"></param>
/// <param name="right"></param>
/// <returns></returns>
public static IValue ADD(IValue left, IValue right)
{
if (left.BaseType == ValueTypeEnum.STRING)
{
return(Create(left.AsString() + right.AsString()));
}
if (left.BaseType == ValueTypeEnum.DATE && right.BaseType == ValueTypeEnum.NUMBER)
{
return(Create(left.AsDate().AddSeconds((double)right.AsNumber())));
}
return(Create(left.AsNumber() + right.AsNumber()));
}
public string XMLString(IValue value)
{
switch (value.BaseType)
{
case ValueTypeEnum.BOOLEAN:
return(XmlConvert.ToString(value.AsBoolean()));
case ValueTypeEnum.DATE:
return(XmlConvert.ToString(value.AsDate(), XmlDateTimeSerializationMode.Unspecified));
case ValueTypeEnum.NUMBER:
return(XmlConvert.ToString(value.AsNumber()));
}
return(value.AsString());
}
public int CompareTo(IValue other)
{
switch (other.DataType)
{
case Machine.DataType.Boolean:
return(AsBoolean().CompareTo(other.AsBoolean()));
case Machine.DataType.Date:
return(AsDate().CompareTo(other.AsDate()));
case Machine.DataType.Undefined:
return(DataType == Machine.DataType.Undefined ? 0 : -1);
default:
return(AsNumber().CompareTo(other.AsNumber()));
}
}
public static IValue Add(IValue op1, IValue op2)
{
var type1 = op1.DataType;
if (type1 == DataType.String)
{
return(Create(op1.AsString() + op2.AsString()));
}
if (type1 == DataType.Date && op2.DataType == DataType.Number)
{
var date = op1.AsDate();
return(Create(date.AddSeconds((double)op2.AsNumber())));
}
// все к числовому типу.
return(Create(op1.AsNumber() + op2.AsNumber()));
}
public bool Equals(IValue other)
{
if (other is null)
{
return(false);
}
if (ReferenceEquals(this, other))
{
return(true);
}
if (other.BaseType == ValueTypeEnum.DATE)
{
return(_value == other.AsDate());
}
return(false);
}
public override void SetPropValue(int propNum, IValue newVal)
{
var prop = _props[propNum];
var dispId = prop.DispatchId;
try
{
try
{
object argToPass;
if (newVal.DataType == Machine.DataType.Date)
{
var date = newVal.AsDate();
if (date == DateTime.MinValue)
{
argToPass = new DateTime(100, 1, 1); // Min OLEAuth Date
}
else
{
argToPass = MarshalIValue(newVal);
}
}
else
{
argToPass = MarshalIValue(newVal);
}
DispatchUtility.InvokeSetProperty(Instance, dispId, argToPass);
}
catch (System.Reflection.TargetInvocationException e)
{
throw e.InnerException ?? e;
}
}
catch (System.MissingMemberException)
{
throw RuntimeException.PropNotFoundException(prop.Name);
}
catch (System.MemberAccessException)
{
throw RuntimeException.PropIsNotWritableException(prop.Name);
}
}
public bool ValueIsFilled(IValue value)
{
switch (value.BaseType)
{
case ValueTypeEnum.NULL:
return(false);
case ValueTypeEnum.BOOLEAN:
return(true);
case ValueTypeEnum.STRING:
return(!String.IsNullOrWhiteSpace(value.AsString()));
case ValueTypeEnum.NUMBER:
return(value.AsNumber() != 0);
case ValueTypeEnum.DATE:
var emptyDate = new DateTime(1, 1, 1, 0, 0, 0);
return(value.AsDate() != emptyDate);
case ValueTypeEnum.SCRIPT_OBJECT:
if (value.AsScriptObject().Instance != null)
{
if (typeof(IUniversalCollection).IsAssignableFrom(value.AsScriptObject().Instance.GetType()))
{
return((value.AsScriptObject().Instance as IUniversalCollection).Count() > 0);
}
else
{
return(false);
}
}
else
{
return(false);
}
default:
return(true);
}
}
public override void SetPropValue(int propNum, IValue newVal)
{
try
{
try
{
object argToPass;
if (newVal.DataType == Machine.DataType.Date)
{
var date = newVal.AsDate();
if (date == DateTime.MinValue)
{
argToPass = new DateTime(100, 1, 1); // Min OLEAuth Date
}
else
{
argToPass = MarshalIValue(newVal);
}
}
else
{
argToPass = MarshalIValue(newVal);
}
DispatchUtility.InvokeSetProperty(_instance, propNum, argToPass);
}
catch (System.Reflection.TargetInvocationException e)
{
throw e.InnerException;
}
}
catch (System.MissingMemberException)
{
throw RuntimeException.PropNotFoundException("dispid[" + propNum.ToString() + "]");
}
catch (System.MemberAccessException)
{
throw RuntimeException.PropIsNotWritableException("dispid[" + propNum.ToString() + "]");
}
}
public static object MarshalIValue(IValue val)
{
object retValue;
if (val.DataType == Machine.DataType.Date)
{
var date = val.AsDate();
if (date <= MIN_OLE_DATE)
{
retValue = MIN_OLE_DATE;
}
else
{
retValue = date;
}
}
else
{
retValue = ContextValuesMarshaller.ConvertToCLRObject(val);
}
return(retValue);
}
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();
}
}
public static string Format(IValue value, string format)
{
var formatParameters = ParseParameters(format);
string formattedValue;
switch(value.DataType)
{
case DataType.Boolean:
formattedValue = FormatBoolean(value.AsBoolean(), formatParameters);
break;
case DataType.Number:
formattedValue = FormatNumber(value.AsNumber(), formatParameters);
break;
case DataType.Date:
formattedValue = FormatDate(value.AsDate(), formatParameters);
break;
default:
formattedValue = DefaultFormat(value, formatParameters);
break;
}
return formattedValue;
}
public int CompareTo(IValue other)
{
if (other.DataType != this.DataType)
{
if (this.DataType == DataType.Boolean && other.DataType == DataType.Number
|| this.DataType == DataType.Number && other.DataType == DataType.Boolean)
{
return AsNumber().CompareTo(other.AsNumber());
}
else
{
throw RuntimeException.ComparisonNotSupportedException();
}
}
switch (other.DataType)
{
case Machine.DataType.Boolean:
return AsBoolean().CompareTo(other.AsBoolean());
case Machine.DataType.Date:
return AsDate().CompareTo(other.AsDate());
case Machine.DataType.Undefined:
return 0;
default:
return AsNumber().CompareTo(other.AsNumber());
}
}
public bool Equals(IValue other)
{
if (other.DataType == this.DataType)
{
switch (DataType)
{
case Machine.DataType.Number:
return this.AsNumber() == other.AsNumber();
case Machine.DataType.Boolean:
return this.AsBoolean() == other.AsBoolean();
case Machine.DataType.Date:
return this.AsDate() == other.AsDate();
case Machine.DataType.Undefined:
return true;
default:
return false;
}
}
else
{
return false;
}
}
public bool IsValueFilled(IValue value)
{
if (value.DataType == DataType.Undefined)
return false;
else if (value.DataType == DataType.Boolean)
return true;
else if (value.DataType == DataType.String)
return !String.IsNullOrWhiteSpace(value.AsString());
else if (value.DataType == DataType.Number)
return value.AsNumber() != 0;
else if (value.DataType == DataType.Date)
{
var emptyDate = new DateTime(1, 1, 1, 0, 0, 0);
return value.AsDate() != emptyDate;
}
else if (value.GetRawValue() is ICollectionContext)
{
var col = value.GetRawValue() as ICollectionContext;
return col.Count() != 0;
}
else
return true;
}
