public ComposedScalar(ComposedScalar other)
: base(other)
{
_fastType = other._fastType;
_fields = other._fields.CloneArray();
_valueConverter = other._valueConverter;
}
public ComposedScalar(QName name, FastType fastType, Scalar[] fields, bool optional,
IComposedValueConverter valueConverter)
: base(name, optional)
{
_fields = fields;
_valueConverter = valueConverter;
_fastType = fastType;
}
public Scalar(Scalar other)
: base(other)
{
_defaultValue = (ScalarValue) other._defaultValue.Clone();
_fastType = other._fastType;
_initialValue = (ScalarValue) other._initialValue.Clone();
_operator = other._operator;
_operatorCodec = other._operatorCodec;
_typeCodec = other._typeCodec;
_dictionary = other._dictionary;
}
private Scalar(QName name, FastType fastType, Operator op, OperatorCodec operatorCodec,
ScalarValue defaultValue, bool optional)
: base(name, optional)
{
_operator = op;
_operatorCodec = operatorCodec;
_dictionary = DictionaryFields.Global;
_defaultValue = defaultValue ?? ScalarValue.Undefined;
_fastType = fastType;
_typeCodec = fastType.GetCodec(op, optional);
_initialValue = (defaultValue == null || defaultValue.IsUndefined) ? _fastType.DefaultValue : defaultValue;
op.Validate(this);
}
protected static void AssertComposedScalarField(ComposedScalar field, FastType type, String name,
Operator exponentOp,
ScalarValue exponentValue, Operator mantissaOp,
ScalarValue mantissaValue)
{
Assert.AreEqual(type, field.FastType);
Assert.AreEqual(name, field.Name);
Scalar[] fields = field.Fields;
Assert.AreEqual(exponentOp, fields[0].Operator);
Assert.AreEqual(exponentValue, fields[0].DefaultValue);
Assert.AreEqual(mantissaOp, fields[1].Operator);
Assert.AreEqual(mantissaValue, fields[1].DefaultValue);
}
public override OperatorCodec GetCodec(FastType type)
{
return OperatorCodec.CopyAll;
}
private static void ValidateDecodedValueIsCorrectForType(ScalarValue value, FastType type)
{
if (value == null)
return;
type.ValidateValue(value);
}
internal IncrementIntegerOperatorCodec(Operator op, FastType[] types)
: base(op, types)
{
}
public virtual OperatorCodec GetCodec(FastType type)
{
return OperatorCodec.GetCodec(this, type);
}
protected internal AlwaysPresentOperatorCodec(Operator op, FastType[] types)
: base(op, types)
{
}
internal DeltaIntegerOperatorCodec(Operator op, FastType[] types)
: base(op, types)
{
}
protected static void AssertScalarField(IFieldSet fieldSet, int fieldIndex, FastType type, String name,
OperatorCodec operatorCodec,
ScalarValue defaultValue)
{
var field = (Scalar) fieldSet.GetField(fieldIndex);
AssertScalarField(field, type, name);
Assert.AreEqual(operatorCodec, field.OperatorCodec);
Assert.AreEqual(defaultValue, field.DefaultValue);
}
public ComposedScalar(string name, FastType fastType, Scalar[] fields, bool optional,
IComposedValueConverter valueConverter)
: this(new QName(name), fastType, fields, optional, valueConverter)
{
}
private static void ValidateDictionaryTypeAgainstFieldType(ScalarValue priorValue, FastType type)
{
if (priorValue == null || priorValue.IsUndefined)
return;
if (!type.IsValueOf(priorValue))
{
Global.ErrorHandler.OnError(null, DynError.InvalidType,
"The value '{0}' is not valid for the type {1}", priorValue, type);
}
}
public Scalar(QName name, FastType fastType, Operator op, ScalarValue defaultValue,
bool optional)
: this(name, fastType, op, op.GetCodec(fastType), defaultValue, optional)
{
}
private static void AssertScalarField(Scalar field, FastType type, string name)
{
Assert.AreEqual(name, field.Name);
Assert.AreEqual(type, field.FastType);
}
protected static void AssertSequenceLengthField(Sequence sequence, String name, FastType type, Operator op)
{
Assert.AreEqual(type, sequence.Length.FastType);
Assert.AreEqual(name, sequence.Length.Name);
Assert.AreEqual(op, sequence.Length.Operator);
}
protected static void AssertScalarField(Scalar scalar, FastType type, String name, String id, String ns,
String dictionary, String key, String keyNamespace, Operator op,
ScalarValue defaultVal, bool optional)
{
var qname = new QName(name, ns);
Assert.AreEqual(type, scalar.FastType);
Assert.AreEqual(op, scalar.Operator);
Assert.AreEqual(qname, scalar.QName);
var keyName = new QName(key, keyNamespace);
Assert.AreEqual(keyName, scalar.Key);
if (id == null)
{
Assert.True(scalar.IsIdNull());
}
else
{
Assert.AreEqual(id, scalar.Id);
}
Assert.AreEqual(dictionary, scalar.Dictionary);
Assert.AreEqual(defaultVal, scalar.DefaultValue);
Assert.AreEqual(optional, scalar.IsOptional);
}
protected static void AssertScalarField(Scalar scalar, FastType type, String name, String id, String ns,
String dictionary, String key, Operator op,
ScalarValue defaultVal, bool optional)
{
AssertScalarField(scalar, type, name, id, ns, dictionary, key, ns, op, defaultVal, optional);
}
protected static void AssertScalarField(IFieldSet fieldSet, int fieldIndex, FastType type, String name, Operator op)
{
var field = (Scalar) fieldSet.GetField(fieldIndex);
AssertScalarField(field, type, name);
Assert.AreEqual(op, field.Operator);
}
public Scalar(string name, FastType fastType, Operator op, ScalarValue defaultValue,
bool optional)
: this(new QName(name), fastType, op, defaultValue, optional)
{
}
internal ConstantOperatorCodec(Operator op, FastType[] types)
: base(op, types)
{
}
public Scalar(QName name, FastType fastType, OperatorCodec operatorCodec, ScalarValue defaultValue,
bool optional)
: this(name, fastType, operatorCodec.Operator, operatorCodec, defaultValue, optional)
{
}
internal TailOperatorCodec(Operator op, FastType[] types)
: base(op, types)
{
}
internal DefaultOperatorCodec(Operator op, FastType[] types)
: base(op, types)
{
}
public static OperatorCodec GetCodec(Operator op, FastType type)
{
Tuple<Operator, FastType> key = Tuple.Create(op, type);
OperatorCodec codec;
if (OperatorMap.TryGetValue(key, out codec))
return codec;
Global.ErrorHandler.OnError(null, StaticError.OperatorTypeIncomp,
"The operator '{0}' is not compatible with type '{1}'", op, type);
throw new ArgumentOutOfRangeException("op" + ",type", key, "Not found");
}
