protected internal ValueNode(string value, ValueNodeType valueType)
{
if (string.IsNullOrEmpty(value))
{
throw new ArgumentException("Value can´t be null or empty", "value");
}
_value = value;
_valueType = valueType;
}
protected internal ValueNode(string value, ValueNodeType valueType)
{
if (string.IsNullOrEmpty(value))
{
throw new ArgumentException("Value can´t be null or empty", "value");
}
_value = value;
_valueType = valueType;
}
protected internal ValueNode(string value, string valueType)
{
if (string.IsNullOrEmpty(value))
{
throw new ArgumentException("Value can´t be null or empty", "value");
}
if (string.IsNullOrEmpty(valueType))
{
throw new ArgumentException("ValueType can´t be null or empty", "valueType");
}
_value = value;
_valueType = (ValueNodeType)Enum.Parse(typeof(ValueNodeType), valueType);
}
protected internal ValueNode(string value, string valueType)
{
if (string.IsNullOrEmpty(value))
{
throw new ArgumentException("Value can´t be null or empty", "value");
}
if (string.IsNullOrEmpty(valueType))
{
throw new ArgumentException("ValueType can´t be null or empty", "valueType");
}
_value = value;
_valueType = (ValueNodeType) Enum.Parse(typeof (ValueNodeType), valueType);
}
/// <summary>
/// Expected null, boolean, integer, number
/// </summary>
/// <param name="segment"></param>
/// <param name="valueType"></param>
/// <param name="parentIndex"></param>
/// <returns></returns>
static JsonValue ParsePrimitive(Utf8String segment, ValueNodeType valueType, int parentIndex)
{
int i = 1;
for (; i < segment.ByteLength; ++i)
{
if (Char.IsWhiteSpace((char)segment[i])
|| segment[i] == '}'
|| segment[i] == ']'
|| segment[i] == ','
|| segment[i] == ':'
)
{
break;
}
}
return new JsonValue(segment.Subbytes(0, i), valueType, parentIndex);
}
/// <summary>
/// Expected null, boolean, integer, number
/// </summary>
/// <param name="segment"></param>
/// <param name="valueType"></param>
/// <param name="parentIndex"></param>
/// <returns></returns>
static JsonTreeNode ParsePrimitive(JsonTreeNode tree, Utf8String segment, ValueNodeType valueType)
{
int i = 1;
for (; i < segment.ByteLength; ++i)
{
if (Char.IsWhiteSpace((char)segment[i]) ||
segment[i] == '}' ||
segment[i] == ']' ||
segment[i] == ',' ||
segment[i] == ':'
)
{
break;
}
}
return(tree.AddValue(segment.Subbytes(0, i).Bytes, valueType));
}
protected internal CAMLValueNode(string value, ValueNodeType valueType)
: base(value, valueType)
{
}
public MsgPackValue New(ArraySegment <byte> bytes, ValueNodeType valueType, int parentIndex)
{
throw new NotImplementedException();
}
public JsonTreeNode AddValue(ArraySegment <byte> bytes, ValueNodeType valueType)
{
return(AddValue(default(JsonValue).New(bytes, valueType, ValueIndex)));
}
public virtual ValueNode CreateValueNode(string value, ValueNodeType valueType)
{
return(new ValueNode(value, valueType));
}
public void AddValue(ArraySegment <byte> bytes, ValueNodeType valueType)
{
m_Values.Add(default(T).New(bytes, valueType, ValueIndex));
}
public abstract string Evaluate(List<string> header, List<string> data, out ValueNodeType nodetype);
public static ValueNodeBase CreateNewNode(ValueNodeType vType, XElement xml)
{
switch (vType)
{
case ValueNodeType.String:
case ValueNodeType.Int:
case ValueNodeType.Float:
return new NumericalValueNode(vType, xml);
case ValueNodeType.Date:
case ValueNodeType.DateSpan:
return new DateValueNode(vType, xml);
case ValueNodeType.Field:
return new FieldValueNode(vType, xml);
default:
throw new ArgumentOutOfRangeException("vType");
}
}
private string FinishEvaluation(ValueNodeType nodetype1, ValueNodeType nodetype2)
{
double _numerical1, _numerical2, result;
if (string.IsNullOrWhiteSpace(Vals[0]) || !double.TryParse(Vals[0], out _numerical1))
return null;
if (!string.IsNullOrWhiteSpace(Vals[1]) || !double.TryParse(Vals[1], out _numerical2))
return null;
switch (Op)
{
case ValueOperand.NoOp:
result = _numerical1;
break;
case ValueOperand.Plus:
result = _numerical1 + _numerical1;
break;
case ValueOperand.Minus:
result = _numerical1 - _numerical1;
break;
case ValueOperand.Times:
result = _numerical1*_numerical1;
break;
case ValueOperand.DividedBy:
result = _numerical1/_numerical1;
break;
default:
throw new ArgumentOutOfRangeException("Op");
}
if (NodeType == ValueNodeType.Int)
{
var resultInt = (int) Math.Floor(result);
return resultInt.ToString();
}
return result.ToString("n");
}
public NumericalValueNode(ValueNodeType nodeType, XElement xml)
: base(nodeType, xml)
{
}
public MsgPackValue New(ArraySegment <byte> bytes, ValueNodeType valueType, int parentIndex)
{
return(new MsgPackValue(bytes, parentIndex));
}
public override ValueNode CreateValueNode(string value, ValueNodeType valueType)
{
return(new CAMLValueNode(value, valueType));
}
public virtual ValueNode CreateValueNode(string value, ValueNodeType valueType)
{
return new ValueNode(value, valueType);
}
public override string Evaluate(XElement data, out ValueNodeType nodetype)
{
nodetype = NodeType;
if (Simple) return Vals[0];
try
{
var nodetype1 = NodeType;
var nodetype2 = NodeType;
if (Nodes[0] != null) Vals[0] = Nodes[0].Evaluate(data, out nodetype1);
if (Nodes[1] != null) Vals[1] = Nodes[1].Evaluate(data, out nodetype2);
return FinishEvaluation(nodetype1, nodetype2);
}
catch (Exception ex)
{
if (BoostLog.Instance != null)
BoostLog.Instance.WriteEntry(EventLogEntryType.Error,
string.Format("Error evaluating NumericalValueNode. Val1 = {0}. Val2 = {1}", Vals[0], Vals[1]),
ex);
return null;
}
}
public JsonValue(Utf8String segment, ValueNodeType valueType, int parentIndex) : this()
{
Segment = segment;
ValueType = valueType;
ParentIndex = parentIndex;
}
protected ValueNodeBase(ValueNodeType nodeType, XElement xml)
{
NodeType = nodeType;
Vals = new string[2];
Nodes = new ValueNodeBase[2];
ParseXml(xml);
}
public JsonValue New(ArraySegment <byte> bytes, ValueNodeType valueType, int parentIndex)
{
return(new JsonValue(new Utf8String(bytes), valueType, parentIndex));
}
public abstract string Evaluate(XElement data, out ValueNodeType nodetype);
public DateValueNode(ValueNodeType nodeType, XElement xml)
: base(nodeType, xml)
{
}
protected internal CAMLValueNode(string value, ValueNodeType valueType)
: base(value, valueType)
{
}
public override string Evaluate(XElement data, out ValueNodeType nodetype)
{
nodetype = NodeType;
if (Simple) return CheckValue(Vals[0]);
try
{
//only simle date nodes can exist without nodes
//otherwise we'd need to know the node type for each val
if (Nodes[0] == null || Nodes[1] == null)
throw new Exception("All non-simple date nodes must have two sub-nodes");
ValueNodeType nodetype1, nodetype2;
Vals[0] = Nodes[0].Evaluate(data, out nodetype1);
Vals[1] = Nodes[1].Evaluate(data, out nodetype2);
return FinishEvaluation(nodetype1, nodetype2, out nodetype);
}
catch (Exception ex)
{
if (BoostLog.Instance != null)
BoostLog.Instance.WriteEntry(EventLogEntryType.Error,
string.Format("Error evaluating DateValueNode. Val1 = {0}. Val2 = {1}", Vals[0], Vals[1]),
ex);
return null;
}
}
public ListTreeNode <T> AddValue(ArraySegment <byte> bytes, ValueNodeType valueType)
{
return(AddValue(default(T).New(bytes, valueType, ValueIndex)));
}
private string FinishEvaluation(ValueNodeType nodetype1, ValueNodeType nodetype2, out ValueNodeType nodetype)
{
//for NoOp, just return the value of the first node
if (Op != ValueOperand.NoOp)
{
nodetype = nodetype1;
return Vals[0];
}
//Oterwise valid ops depend whether the values are dates or datespans (3 cases)
//case 1: two dates
if (nodetype1 == ValueNodeType.Date
&& nodetype2 == ValueNodeType.Date)
{
if (Op != ValueOperand.Minus)
throw new Exception(string.Format("Two dates can only be subtracted. {0} cannot be evaluated", Op.ToString()));
DateTime date1, date2;
if (!Input.TryGetDate(out date1, Vals[0], DateReversed))
throw new Exception(string.Format("Illegal DateTime: {0} cannot be evaluated", Vals[0]));
if (!Input.TryGetDate(out date2, Vals[1], DateReversed))
throw new Exception(string.Format("Illegal DateTime: {0} cannot be evaluated", Vals[1]));
var result = date1 - date2;
nodetype = ValueNodeType.DateSpan;
if (Units == ValueUnits.General) Units = ValueUnits.Minutes;
return Input.EncodeTimeSpan(result, Units);
}
//case 2: two timespans
if (nodetype1 == ValueNodeType.DateSpan
&& nodetype2 == ValueNodeType.DateSpan)
{
TimeSpan span1, span2, result;
ValueUnits units1, units2;
if (!Input.TryGetTimeSpan(Vals[0], out span1, out units1))
throw new Exception(string.Format("Illegal timespan. {0} cannot be evaluated", Vals[0]));
if (!Input.TryGetTimeSpan(Vals[1], out span2, out units2))
throw new Exception(string.Format("Illegal timespan. {0} cannot be evaluated", Vals[1]));
switch (Op)
{
case ValueOperand.Plus:
result = span1 + span2;
break;
case ValueOperand.Minus:
result = span1 - span2;
break;
default:
throw new Exception(string.Format("Two time spans can only be added or subtracted. {0} cannot be evaluated",
Op.ToString()));
}
nodetype = ValueNodeType.DateSpan;
if (Units == ValueUnits.General) Units = units1;
return Input.EncodeTimeSpan(result, Units);
}
//case 3: one value is a timespan and the other is a date
DateTime date;
TimeSpan span;
ValueUnits units;
if (nodetype1 == ValueNodeType.DateSpan)
{
if (!Input.TryGetDate(out date, Vals[0], DateReversed))
throw new Exception(string.Format("Illegal DateTime: {0} cannot be evaluated", Vals[0]));
if (!Input.TryGetTimeSpan(Vals[1], out span, out units))
throw new Exception(string.Format("Illegal timespan. {0} cannot be evaluated", Vals[1]));
}
else
{
if (!Input.TryGetDate(out date, Vals[1], DateReversed))
throw new Exception(string.Format("Illegal DateTime: {0} cannot be evaluated", Vals[1]));
if (!Input.TryGetTimeSpan(Vals[0], out span, out units))
throw new Exception(string.Format("Illegal timespan. {0} cannot be evaluated", Vals[0]));
}
var subtract = false;
switch (Op)
{
case ValueOperand.Plus:
break;
case ValueOperand.Minus:
subtract = true;
break;
default:
throw new Exception(string.Format("Two time spans can only be added or subtracted. {0} cannot be evaluated",
Op.ToString()));
}
int val;
switch (units)
{
case ValueUnits.Days:
val = subtract ? span.Days : -1*span.Days;
date = date.AddDays(val);
break;
case ValueUnits.Hours:
val = subtract ? span.Hours : -1*span.Hours;
date = date.AddHours(val);
break;
case ValueUnits.Minutes:
case ValueUnits.General:
val = subtract ? span.Minutes : -1*span.Minutes;
date = date.AddMinutes(val);
break;
default:
throw new ArgumentOutOfRangeException();
}
nodetype = ValueNodeType.Date;
return date.ToString("G");
}
public static IJsonSchemaValidator Create(ValueNodeType valueType,
Type t = null,
BaseJsonSchemaAttribute a = null,
ItemJsonSchemaAttribute ia = null)
{
switch (valueType)
{
case ValueNodeType.Integer:
{
var v = new JsonIntValidator();
if (a != null)
{
if (!double.IsNaN(a.Minimum))
{
v.Minimum = (int)a.Minimum;
}
if (a.ExclusiveMinimum)
{
v.ExclusiveMinimum = a.ExclusiveMinimum;
}
if (!double.IsNaN(a.Maximum))
{
v.Maximum = (int)a.Maximum;
}
if (a.ExclusiveMaximum)
{
v.ExclusiveMaximum = a.ExclusiveMaximum;
}
if (a.MultipleOf != 0)
{
v.MultipleOf = (int)a.MultipleOf;
}
}
return(v);
}
case ValueNodeType.Number:
{
var v = new JsonNumberValidator();
if (a != null)
{
if (!double.IsNaN(a.Minimum))
{
v.Minimum = (int)a.Minimum;
}
if (a.ExclusiveMinimum)
{
v.ExclusiveMinimum = a.ExclusiveMinimum;
}
if (!double.IsNaN(a.Maximum))
{
v.Maximum = (int)a.Maximum;
}
if (a.ExclusiveMaximum)
{
v.ExclusiveMaximum = a.ExclusiveMaximum;
}
if (a.MultipleOf != 0)
{
v.MultipleOf = (int)a.MultipleOf;
}
}
return(v);
}
case ValueNodeType.String:
{
var v = new JsonStringValidator();
if (a != null)
{
if (a.Pattern != null)
{
v.Pattern = new System.Text.RegularExpressions.Regex(a.Pattern);
}
}
return(v);
}
case ValueNodeType.Boolean:
return(new JsonBoolValidator());
case ValueNodeType.Array:
{
var v = new JsonArrayValidator();
if (a != null)
{
if (a.MinItems != 0)
{
v.MinItems = a.MinItems;
}
if (a.MaxItems != 0)
{
v.MaxItems = a.MaxItems;
}
if (t != null)
{
if (ia == null)
{
ia = new ItemJsonSchemaAttribute();
}
Type elementType = null;
if (t.IsArray)
{
elementType = t.GetElementType();
}
else if (t.GetIsGenericList())
{
elementType = t.GetGenericArguments().First();
}
if (elementType != null)
{
/*
* var sub = new JsonSchema
* {
* SkipComparison = ia.SkipSchemaComparison,
* Validator = Create(elementType, ia, null)
* };
*/
var sub = JsonSchema.FromType(elementType, ia, null);
v.Items = sub;
}
}
}
return(v);
}
case ValueNodeType.Object:
{
if (t.GetIsGenericDictionary())
{
var genericFactory =
typeof(JsonDictionaryValidator).GetMethod("Create",
BindingFlags.Static | BindingFlags.Public);
var factory = genericFactory.MakeGenericMethod(t.GetGenericArguments()[1]);
var v = factory.Invoke(null, null) as IJsonSchemaValidator;
return(v);
}
else
{
var v = new JsonObjectValidator();
if (a != null)
{
if (a.MinProperties > 0)
{
v.MinProperties = a.MinProperties;
}
// props
foreach (var prop in GetProperties(t, a.ExportFlags))
{
v.Properties.Add(prop.Key, prop.Schema);
if (prop.Required)
{
v.Required.Add(prop.Key);
}
if (prop.Dependencies != null)
{
v.Dependencies.Add(prop.Key, prop.Dependencies);
}
}
}
if (ia != null)
{
var sub = new JsonSchema
{
SkipComparison = ia.SkipSchemaComparison,
Validator = Create(typeof(object), ia, null)
};
v.AdditionalProperties = sub;
}
return(v);
}
}
default:
throw new NotImplementedException();
}
}
//protected FieldValueNode(ValueNodeType nodeType, ValueOperand op = ValueOperand.NoOp, string val1 = null, string val2 = null, bool simple = true)
public FieldValueNode(ValueNodeType nodeType, XElement xml)
: base(nodeType, xml)
{
}
public override string Evaluate(XElement data, out ValueNodeType nodetype)
{
//return node type is based on what the field evaluates to
nodetype = ValueNodeType.String; //default is a string
if (data == null) return null; //no data to evaluate
try
{
var val = Input.GetValue(data, Name);
if (string.IsNullOrEmpty(val)) return null; //no data matches this field
return FinishEvaluation(val, ref nodetype);
}
catch (Exception ex)
{
if (BoostLog.Instance != null)
BoostLog.Instance.WriteEntry(EventLogEntryType.Error,
string.Format("Error evaluating NumericalValueNode. Val1 = {0}. Val2 = {1}", Vals[0], Vals[1]),
ex);
return null;
}
}
private string FinishEvaluation(string val, ref ValueNodeType nodetype)
{
//determine node type
DateTime testDate;
TimeSpan testSpan;
ValueUnits testUnits;
int testInt;
float testFloat;
if (Input.TryGetDate(out testDate, val, DateReversed))
nodetype = ValueNodeType.Date;
else if (Input.TryGetTimeSpan(val, out testSpan, out testUnits))
nodetype = ValueNodeType.DateSpan;
else if (int.TryParse(val, out testInt))
nodetype = ValueNodeType.Int;
else if (float.TryParse(val, out testFloat))
nodetype = ValueNodeType.Float;
return val;
}
public void AddValue(ArraySegment <byte> bytes, ValueNodeType valueType)
{
throw new NotImplementedException();
}
public override ValueNode CreateValueNode(string value, ValueNodeType valueType)
{
return new CAMLValueNode(value, valueType);
}