public override byte[] Encode(IFieldValue value, Group encodeTemplate, Context context,
BitVectorBuilder presenceMapBuilder)
{
var message = (Message)value;
return(message.Template.Encode(message, context));
}
public override byte[] Encode(IFieldValue value, Group encodeTemplate, Context context,
BitVectorBuilder presenceMapBuilder)
{
if (HasTypeReference)
{
context.CurrentApplicationType = TypeReference;
}
if (value == null)
{
return(_length.Encode(null, encodeTemplate, context, presenceMapBuilder));
}
var buffer = new MemoryStream();
var val = (SequenceValue)value;
int len = val.Length;
try
{
byte[] tmp = _length.Encode(new IntegerValue(len), encodeTemplate, context, presenceMapBuilder);
buffer.Write(tmp, 0, tmp.Length);
foreach (GroupValue v in val.Elements)
{
tmp = _group.Encode(v, encodeTemplate, context);
buffer.Write(tmp, 0, tmp.Length);
}
}
catch (IOException e)
{
Global.ErrorHandler.OnError(e, DynError.IoError, "An IO error occurred while encoding {0}", this);
}
return(buffer.ToArray());
}
public QueryNode(string fieldName, IFieldValue fieldValue, QueryLogic logic, QueryType type)
{
this.FieldName = fieldName;
this.FieldValue = fieldValue;
this.Logic = logic;
this.Type = type;
}
public override byte[] Encode(IFieldValue value, Group encodeTemplate, Context context,
BitVectorBuilder presenceMapBuilder)
{
if (value == null)
{
// Only encode null in the first field.
return(_fields[0].Encode(null, encodeTemplate, context, presenceMapBuilder));
}
var buffer = new MemoryStream(_fields.Length * 8);
IFieldValue[] values = _valueConverter.Split(value);
for (int i = 0; i < _fields.Length; i++)
{
try
{
byte[] tempByteArray = _fields[i].Encode(values[i], encodeTemplate, context, presenceMapBuilder);
buffer.Write(tempByteArray, 0, tempByteArray.Length);
}
catch (IOException e)
{
throw new RuntimeException(e);
}
}
return(buffer.ToArray());
}
public override byte[] Encode(IFieldValue fieldValue, Group encodeTemplate, Context context,
BitVectorBuilder presenceMapBuilder)
{
IDictionary dict = context.GetDictionary(Dictionary);
ScalarValue priorValue = context.Lookup(dict, encodeTemplate, Key);
var value = (ScalarValue)fieldValue;
if (!_operatorCodec.CanEncode(value, this))
{
Global.ErrorHandler.OnError(null, DynError.CantEncodeValue,
"The scalar {0} cannot encode the value {1}", this, value);
}
ScalarValue valueToEncode = _operatorCodec.GetValueToEncode(value, priorValue, this,
presenceMapBuilder);
if (_operator.ShouldStoreValue(value))
{
context.Store(dict, encodeTemplate, Key, value);
}
if (valueToEncode == null)
{
return(ByteUtil.EmptyByteArray);
}
byte[] encoding = _typeCodec.Encode(valueToEncode);
if (context.TraceEnabled && encoding.Length > 0)
{
context.EncodeTrace.Field(this, fieldValue, valueToEncode, encoding, presenceMapBuilder.Index);
}
return(encoding);
}
public PartialController(IUser iUser, IField iField, IFieldValue iFieldValue, ILibrary iLibrary, ICommon iCommon)
{
_iUser = iUser;
_iField = iField;
_iFieldValue = iFieldValue;
_iLibrary = iLibrary;
_iCommon = iCommon;
}
public IFieldValue Compose(IFieldValue[] values)
{
if (values[0] == null)
return null;
if (values[0] == ScalarValue.Undefined)
return ScalarValue.Undefined;
return new DecimalValue(((ScalarValue)values[1]).ToLong(), ((ScalarValue)values[0]).ToInt());
}
public TraceField(Field field, IFieldValue value, IFieldValue encoded, int pmapIndex, byte[] encoding)
{
_field = field;
_value = value;
_encoded = encoded;
_pmapIndex = pmapIndex;
_encoding = encoding;
}
public void Field(Field field, IFieldValue value, IFieldValue decodedValue, byte[] encoding, int pmapIndex)
{
var scalarDecode = new StringBuilder();
scalarDecode.Append(field.Name).Append(": ");
scalarDecode.Append(ByteUtil.ConvertByteArrayToBitString(encoding));
scalarDecode.Append(" -> ").Append(value).Append('(').Append(decodedValue).Append(')');
Print(scalarDecode);
}
public IFieldValue[] Split(IFieldValue value)
{
if (value == null)
return NullSet;
if (value == ScalarValue.Undefined)
return UndefinedSet;
var decValue = (DecimalValue) value;
return new IFieldValue[] {new IntegerValue(decValue.Exponent), new LongValue(decValue.Mantissa)};
}
public void Field(Field field, IFieldValue value, IFieldValue decodedValue, byte[] encoding, int pmapIndex)
{
var scalarDecode = new StringBuilder();
scalarDecode.Append(field.Name).Append(": ");
scalarDecode.Append(ByteUtil.ConvertByteArrayToBitString(encoding));
scalarDecode.Append(" -> ").Append(value).Append('(').Append(decodedValue).Append(')');
Print(scalarDecode);
}
public virtual IFieldValue Clone()
{
var copies = new IFieldValue[_values.Length];
for (int i = 0; i < copies.Length; i++)
{
copies[i] = _values[i].Clone();
}
return(new GroupValue(_group, copies));
}
public void SetFieldValue(string fieldName, IFieldValue value)
{
Field fld;
if (!_group.TryGetField(fieldName, out fld))
{
throw new ArgumentOutOfRangeException("fieldName", fieldName,
"Field does not exist in group " + _group);
}
SetFieldValue(_group.GetFieldIndex(fld), value);
}
public bool TryGetValue(string fieldName, out IFieldValue value)
{
int index;
if (_group.TryGetFieldIndex(fieldName, out index))
{
value = _values[index];
return(true);
}
value = null;
return(false);
}
public IFieldValue[] Split(IFieldValue value)
{
if (value == null)
{
return(NullSet);
}
if (value == ScalarValue.Undefined)
{
return(UndefinedSet);
}
var decValue = (DecimalValue)value;
return(new IFieldValue[] { new IntegerValue(decValue.Exponent), new LongValue(decValue.Mantissa) });
}
public override IFieldValue Decode(Stream inStream, Group decodeTemplate, Context context,
BitVectorReader presenceMapReader)
{
var values = new IFieldValue[_fields.Length];
for (int i = 0; i < _fields.Length; i++)
{
values[i] = _fields[i].Decode(inStream, decodeTemplate, context, presenceMapReader);
if (i == 0 && values[0] == null)
{
return(null);
}
}
return(_valueConverter.Compose(values));
}
public static Message Convert(Group group, Message groupMsg, ConversionContext context)
{
SetNameAndId(group, groupMsg);
if (group.TypeReference != null && !FastConstants.AnyType.Equals(group.TypeReference))
{
var typeRef =
new GroupValue(
(Group)SessionControlProtocol11
.TypeRef
.GetField(new QName("TypeRef", SessionControlProtocol11.Namespace)));
SetName(typeRef, group.TypeReference);
groupMsg.SetFieldValue("TypeRef", typeRef);
}
var instructions = new SequenceValue(
SessionControlProtocol11.TemplateDefinition.GetSequence("Instructions"));
if (group.TypeReference != null && !FastConstants.AnyType.Equals(group.TypeReference))
{
var typeRef =
new GroupValue(
(Group)
SessionControlProtocol11
.TypeRef
.GetField(new QName("TypeRef", SessionControlProtocol11.Namespace)));
SetName(typeRef, group.TypeReference);
groupMsg.SetFieldValue("TypeRef", typeRef);
}
Field[] fields = group.FieldDefinitions;
for (int i = group is MessageTemplate ? 1 : 0; i < fields.Length; i++)
{
Field field = fields[i];
IFieldInstructionConverter converter = context.GetConverter(field);
if (converter == null)
{
throw new InvalidOperationException("No converter found for type " + field.GetType());
}
IFieldValue v = converter.Convert(field, context);
instructions.Add(new[] { v });
}
groupMsg.SetFieldValue("Instructions", instructions);
return(groupMsg);
}
////////////////////////////////////////////////////////
/// <summary>
/// 附加值
/// </summary>
public bool appendValue()
{
if (_decriptor == null)
{
return(false);
}
var valueFctry = valueFactroyManager.getFactory(_decriptor.typeCode);
if (valueFctry != null)
{
_value = valueFctry.createValue(_decriptor.modifier);
return(true);
}
return(false);
}
public override byte[] Encode(IFieldValue value, Group encodeTemplate, Context context,
BitVectorBuilder presenceMapBuilder)
{
byte[] encoding = Encode(value, encodeTemplate, context);
if (IsOptional)
{
if (encoding.Length != 0)
{
presenceMapBuilder.Set();
}
else
{
presenceMapBuilder.Skip();
}
}
return(encoding);
}
public GroupValue(Group group, IFieldValue[] values)
{
if (group == null) throw new ArgumentNullException("group");
if (values == null) throw new ArgumentNullException("values");
_group = group;
_values = values;
Field[] flds = group.Fields;
for (int i = 0; i < flds.Length; i++)
{
var scalar = flds[i] as Scalar;
if (scalar != null && scalar.Operator.Equals(Operator.Constant) && !scalar.IsOptional)
{
values[i] = scalar.DefaultValue;
}
}
}
private static void addDocumentNode(Dictionary <string, object> imgDatas, List <object> listData, IField documentNode)
{
IFieldValue value = documentNode.Value;
if (value != null)
{
var key = documentNode.Name;
var val = value.AsString;
imgDatas.Add(key, val);
}
if (documentNode.Instances != null)
{
addDocumentNodeInstances(tempDatas, listData, documentNode.Instances);
}
else if (documentNode.Children != null)
{
//addDocumentNodeChildren(treeNode, documentNode.Children);
}
}
protected IFieldValue[] DecodeFieldValues(Stream inStream, Group template,
BitVectorReader pmapReader, Context context)
{
var values = new IFieldValue[_fields.Length];
int start = this is MessageTemplate ? 1 : 0;
for (int fieldIndex = start; fieldIndex < _fields.Length; fieldIndex++)
{
Field field = _fields[fieldIndex];
values[fieldIndex] = field.Decode(inStream, field.MessageTemplate ?? template, context, pmapReader);
}
if (pmapReader.HasMoreBitsSet)
{
Global.ErrorHandler.OnError(null, RepError.PmapTooManyBits,
"The presence map {0} has too many bits for the group {1}", pmapReader, this);
}
return(values);
}
public ViewController(
ILogger <ViewController> logger,
ILibrary iLibrary,
IUser iUser,
ILibraryType iLibraryType,
IItem iItem,
IField iField,
IDefaultField iDefaultField,
IFieldValue iFieldValue,
ICommon iCommon)
{
_logger = logger;
_iLibrary = iLibrary;
_iLibraryType = iLibraryType;
_iUser = iUser;
_iItem = iItem;
_iField = iField;
_iDefaultField = iDefaultField;
_iFieldValue = iFieldValue;
_iCommon = iCommon;
}
public override IFieldValue Decode(Stream inStream, Group decodeTemplate, Context context,
BitVectorReader pmapReader)
{
var sequenceValue = new SequenceValue(this);
IFieldValue lengthValue = _length.Decode(inStream, decodeTemplate, context, pmapReader);
if ((lengthValue == ScalarValue.Null) || (lengthValue == null))
{
return(null);
}
int len = ((IntegerValue)lengthValue).Value;
for (int i = 0; i < len; i++)
{
sequenceValue.Add(
(GroupValue)_group.Decode(inStream, decodeTemplate, context, BitVectorReader.InfiniteTrue));
}
return(sequenceValue);
}
public void TestDecode()
{
const string actual = "10000010 11100000 10000001 10000010 11100000 10000011 10000100";
Stream stream = ByteUtil.CreateByteStream(actual);
var firstNumber = new Scalar("First Number", FastType.I32, Operator.Copy, ScalarValue.Undefined, false);
var lastNumber = new Scalar("Second Number", FastType.I32, Operator.Copy, ScalarValue.Undefined, false);
var sequence1 = new Sequence("Contants", new Field[] { firstNumber, lastNumber }, false);
var sequenceValue = new SequenceValue(sequence1);
sequenceValue.Add(new IFieldValue[]
{
new IntegerValue(1), new IntegerValue(2)
});
sequenceValue.Add(new IFieldValue[]
{
new IntegerValue(3), new IntegerValue(4)
});
IFieldValue result = sequence1.Decode(stream, _template, _context, BitVectorReader.InfiniteTrue);
Assert.AreEqual(sequenceValue, result);
}
public SimpleField(IFieldValue fieldValue, string mp3tagFormat)
{
this.fieldValue = fieldValue;
this.mp3tagFormat = mp3tagFormat;
}
protected IFieldValue[] DecodeFieldValues(Stream inStream, Group template,
BitVectorReader pmapReader, Context context)
{
var values = new IFieldValue[_fields.Length];
int start = this is MessageTemplate ? 1 : 0;
for (int fieldIndex = start; fieldIndex < _fields.Length; fieldIndex++)
{
Field field = _fields[fieldIndex];
values[fieldIndex] = field.Decode(inStream, field.MessageTemplate ?? template, context, pmapReader);
}
if (pmapReader.HasMoreBitsSet)
{
Global.ErrorHandler.OnError(null, RepError.PmapTooManyBits,
"The presence map {0} has too many bits for the group {1}", pmapReader, this);
}
return values;
}
public override byte[] Encode(IFieldValue value, Group encodeTemplate, Context context,
BitVectorBuilder presenceMapBuilder)
{
if (HasTypeReference)
context.CurrentApplicationType = TypeReference;
if (value == null)
return _length.Encode(null, encodeTemplate, context, presenceMapBuilder);
var buffer = new MemoryStream();
var val = (SequenceValue) value;
int len = val.Length;
try
{
byte[] tmp = _length.Encode(new IntegerValue(len), encodeTemplate, context, presenceMapBuilder);
buffer.Write(tmp, 0, tmp.Length);
foreach (GroupValue v in val.Elements)
{
tmp = _group.Encode(v, encodeTemplate, context);
buffer.Write(tmp, 0, tmp.Length);
}
}
catch (IOException e)
{
Global.ErrorHandler.OnError(e, DynError.IoError, "An IO error occurred while encoding {0}", this);
}
return buffer.ToArray();
}
public FieldRepo(DatabaseContext dbContext, IFieldValue iFieldValue)
{
_context = dbContext;
_iFieldValue = iFieldValue;
}
public Message(MessageTemplate template, IFieldValue[] fieldValues)
: base(template, fieldValues)
{
if (template == null) throw new ArgumentNullException("template");
_template = template;
}
private BetweenQuery(FieldType type, string name, IFieldValue greaterThanEqualTo, IFieldValue lessThanEqualTo)
{
}
public abstract byte[] Encode(IFieldValue value, Group encodeTemplate, Context context,
BitVectorBuilder presenceMapBuilder);
public bool Equals(IFieldValue fieldVal)
{
return _name == fieldVal.Name && Extension.IsEqual(_value, fieldVal.Value);
}
private static IFieldValue[] InitializeFieldValues(int fieldCount)
{
var fields = new IFieldValue[fieldCount];
return fields;
}
public byte[] Encode(IFieldValue value, Group template, Context context)
{
if (value == null)
{
return(ByteUtil.EmptyByteArray);
}
var groupValue = (GroupValue)value;
if (context.TraceEnabled)
{
context.EncodeTrace.GroupStart(this);
}
var presenceMapBuilder = new BitVectorBuilder(template.MaxPresenceMapSize);
try
{
var fieldEncodings = new byte[_fields.Length][];
for (int fieldIndex = 0; fieldIndex < _fields.Length; fieldIndex++)
{
IFieldValue fieldValue = groupValue.GetValue(fieldIndex);
Field field = _fields[fieldIndex];
if (!field.IsOptional && fieldValue == null)
{
Global.ErrorHandler.OnError(null, DynError.GeneralError, "Mandatory field {0} is null", field);
// BUG? error is ignored?
}
byte[] encoding = field.Encode(fieldValue, field.MessageTemplate ?? template, context,
presenceMapBuilder);
fieldEncodings[fieldIndex] = encoding;
}
var buffer = new MemoryStream();
if (UsesPresenceMap)
{
byte[] pmap = presenceMapBuilder.BitVector.TruncatedBytes;
if (context.TraceEnabled)
{
context.EncodeTrace.Pmap(pmap);
}
buffer.Write(pmap, 0, pmap.Length);
}
foreach (var t in fieldEncodings)
{
if (t != null)
{
buffer.Write(t, 0, t.Length);
}
}
if (context.TraceEnabled)
{
context.EncodeTrace.GroupEnd();
}
return(buffer.ToArray());
}
catch (IOException e)
{
throw new RuntimeException(e);
}
}
public override byte[] Encode(IFieldValue value, Group encodeTemplate, Context context,
BitVectorBuilder presenceMapBuilder)
{
var message = (Message) value;
return message.Template.Encode(message, context);
}
/// <summary>
/// Validate this field.
/// </summary>
/// <param name="value">Value of field</param>
/// <exception cref="InvalidFieldValueException">This extension field's value is invalid</exception>
public void Validate(IFieldValue value)
{
if (value == null)
{
if (this.IsRequired)
throw new InvalidFieldValueException(string.Format(Resources.FieldValueCannotBeNull, this.Name));
}
else
{
EnumerationValueCollection selectedItems = value.Value as EnumerationValueCollection;
if ((selectedItems == null || selectedItems.Count == 0) && this.IsRequired)
throw new InvalidFieldValueException(string.Format(Resources.InvalidValueForSpecifiedField, this.Name));
if (selectedItems != null && selectedItems.Count > 0)
{
if (selectedItems.Count > 1 && this.SelectionMode == SelectionModes.Single)
throw new InvalidFieldValueException(string.Format(Resources.OnlySupportSingleSelectForSpecifiedField, this.Name));
}
List<string> allSelectionItemValues = this.Items.Select(i => i.Value).ToList();
foreach (string selectionItemValue in selectedItems)
if (!allSelectionItemValues.Contains(selectionItemValue))
throw new InvalidFieldValueException(string.Format(Resources.OptionNotDefined, selectionItemValue));
}
}
public override bool IsPresenceMapBitSet(byte[] encoding, IFieldValue fieldValue)
{
return false;
}
public IFieldValue Copy(IFieldValue Source)
{
throw new NotImplementedException();
}
public void SetFieldValue(Field field, IFieldValue value)
{
SetFieldValue(_group.GetFieldIndex(field), value);
}
public abstract bool IsPresenceMapBitSet(byte[] encoding, IFieldValue fieldValue);
public virtual void SetFieldValue(int fieldIndex, IFieldValue value)
{
_values[fieldIndex] = value;
}
public bool SetField(eRecordBuffer Buffer, long Record, long Field, bool Original, IFieldValue Value)
{
throw new NotImplementedException();
}
public void SetFieldValue(string fieldName, IFieldValue value)
{
Field fld;
if (!_group.TryGetField(fieldName, out fld))
throw new ArgumentOutOfRangeException("fieldName", fieldName,
"Field does not exist in group " + _group);
SetFieldValue(_group.GetFieldIndex(fld), value);
}
public override bool IsPresenceMapBitSet(byte[] encoding, IFieldValue fieldValue)
{
return(_operatorCodec.IsPresenceMapBitSet(encoding, fieldValue));
}
public bool TryGetValue(string fieldName, out IFieldValue value)
{
int index;
if (_group.TryGetFieldIndex(fieldName, out index))
{
value = _values[index];
return true;
}
value = null;
return false;
}
public override bool IsPresenceMapBitSet(byte[] encoding, IFieldValue fieldValue)
{
return(false);
}
public override bool IsPresenceMapBitSet(byte[] encoding, IFieldValue fieldValue)
{
return _operatorCodec.IsPresenceMapBitSet(encoding, fieldValue);
}
public override bool IsPresenceMapBitSet(byte[] encoding, IFieldValue fieldValue)
{
return _length.IsPresenceMapBitSet(encoding, fieldValue);
}
public override bool IsPresenceMapBitSet(byte[] encoding, IFieldValue fieldValue)
{
return(_length.IsPresenceMapBitSet(encoding, fieldValue));
}
public override bool IsPresenceMapBitSet(byte[] encoding, IFieldValue fieldValue)
{
return encoding.Length != 0;
}
private BetweenQuery(FieldType type, string name, IFieldValue greaterThanEqualTo, IFieldValue lessThanEqualTo)
{
}
public override byte[] Encode(IFieldValue fieldValue, Group encodeTemplate, Context context,
BitVectorBuilder presenceMapBuilder)
{
IDictionary dict = context.GetDictionary(Dictionary);
ScalarValue priorValue = context.Lookup(dict, encodeTemplate, Key);
var value = (ScalarValue) fieldValue;
if (!_operatorCodec.CanEncode(value, this))
{
Global.ErrorHandler.OnError(null, DynError.CantEncodeValue,
"The scalar {0} cannot encode the value {1}", this, value);
}
ScalarValue valueToEncode = _operatorCodec.GetValueToEncode(value, priorValue, this,
presenceMapBuilder);
if (_operator.ShouldStoreValue(value))
{
context.Store(dict, encodeTemplate, Key, value);
}
if (valueToEncode == null)
{
return ByteUtil.EmptyByteArray;
}
byte[] encoding = _typeCodec.Encode(valueToEncode);
if (context.TraceEnabled && encoding.Length > 0)
{
context.EncodeTrace.Field(this, fieldValue, valueToEncode, encoding, presenceMapBuilder.Index);
}
return encoding;
}
public virtual IFieldValue Clone()
{
var copies = new IFieldValue[_values.Length];
for (int i = 0; i < copies.Length; i++)
copies[i] = _values[i].Clone();
return new GroupValue(_group, copies);
}
private BetweenQuery(Field field, IFieldValue greaterThanEqualTo, IFieldValue lessThanEqualTo)
{
this.Field = field;
this.GreaterThanEqualTo = greaterThanEqualTo;
this.LessThanEqualTo = lessThanEqualTo;
}
public FieldValue(IFieldValue orig)
{
_name = orig.Name;
_value = orig.Value;
}
/// <summary>
/// Validate this field.
/// </summary>
/// <param name="value">Value of field</param>
/// <exception cref="InvalidFieldValueException">This extension field's value is invalid</exception>
public void Validate(IFieldValue value)
{
if (value == null)
{
if (this.IsRequired)
throw new InvalidFieldValueException(string.Format(Resources.FieldValueCannotBeNull, this.Name));
}
else
{
int argumentValue = (int)value.Value;
if (this.MaxValueSpecified && argumentValue > this.MaxValue)
throw new InvalidFieldValueException(string.Format(Resources.FieldValueGreaterThanMaximalValue, this.Name, MaxValue));
if (this.MinValueSpecified && argumentValue < this.MinValue)
throw new InvalidFieldValueException(string.Format(Resources.FieldValueLessThanMinimalValue, this.Name, MinValue));
}
}
public virtual bool IsPresenceMapBitSet(byte[] encoding, IFieldValue fieldValue)
{
return(encoding.Length != 0);
}
/// <summary>
/// Validate this field.
/// </summary>
/// <param name="value">Value of field</param>
/// <exception cref="InvalidFieldValueException">This extension field's value is invalid</exception>
public void Validate(IFieldValue value)
{
if (value == null)
{
if (this.IsRequired)
throw new InvalidFieldValueException(string.Format(Resources.FieldValueCannotBeNull, this.Name));
}
else
{
HierarchyNodeValueCollection selectedHierarchyNodes = value.Value as HierarchyNodeValueCollection;
if ((selectedHierarchyNodes == null || selectedHierarchyNodes.Count == 0) && this.IsRequired)
throw new InvalidFieldValueException(string.Format(Resources.InvalidValueForSpecifiedField, this.Name));
if (selectedHierarchyNodes != null && selectedHierarchyNodes.Count > 0)
{
if (selectedHierarchyNodes.Count > 1 && this.SelectionMode == SelectionModes.Single)
throw new InvalidFieldValueException(string.Format(Resources.OnlySupportSingleSelectForSpecifiedField, this.Name));
}
HashSet<string> hierarchyNodeValueHashSet = new HashSet<string>(GetAllDefinedHierarchyNodeValues(this.Node).Distinct());
foreach (string hierarchyNodeValue in selectedHierarchyNodes)
if (!hierarchyNodeValueHashSet.Contains(hierarchyNodeValue))
throw new InvalidFieldValueException(string.Format(Resources.NoteValueNotDefinedInHierarchy, hierarchyNodeValue));
}
}
/// <summary>
/// Validate this field.
/// </summary>
/// <param name="value">Value of field</param>
/// <exception cref="InvalidFieldValueException">This extension field's value is invalid</exception>
public void Validate(IFieldValue value)
{
if (value == null)
{
if (this.IsRequired)
throw new InvalidFieldValueException(string.Format(Resources.FieldValueCannotBeNull, this.Name));
}
else
{
DateTime argumentDateTime = (DateTime)value.Value;
if (this.MaxValue != null)
{
DateTime maxDateTime = GetDateTimeValue(this.MaxValue);
if (argumentDateTime > maxDateTime)
throw new InvalidFieldValueException(string.Format(Resources.FieldValueGreaterThanMaximalValue, this.Name, maxDateTime));
}
if (this.MinValue != null)
{
DateTime minDateTime = GetDateTimeValue(this.MinValue);
if (argumentDateTime < minDateTime)
throw new InvalidFieldValueException(string.Format(Resources.FieldValueLessThanMinimalValue, this.Name, minDateTime));
}
}
}
