public override void Init()
{
this.m_currentCount = 0u;
this.m_sumOfXType = DataTypeCode.Null;
this.m_sumOfX = null;
this.m_sumOfXSquared = null;
}
public ArrayDacParameter(string name, Type memberDataType, DataTypeCode memberDataTypeCode, object[] value) : base(name, value)
{
Ensure.That(memberDataType, "memberDataType").IsNotNull();
MemberDataType = memberDataType;
MemberDataTypeCode = memberDataTypeCode;
}
public SshChannelExtendedData(uint channel, DataTypeCode dataType, byte[] data)
: this()
{
this.Channel = channel;
this.DataType = dataType;
this.Data = data;
}
// Call user function from expression value (no callinfo)
// Type check against FullDataType
AstDefCall FunvalCall(AstValue value, DataTypeCode datatype, AstNode[] args)
{
return(new AstDefCall {
Func = FindFunc(SymNames.Invoke), Code = value, DataType = datatype.Returns, Arguments = args,
NumVarArgs = args.Length,
});
}
public ArrayDacParameter(string name, Type memberDataType, DataTypeCode memberDataTypeCode, object[] value) : base(name, value)
{
Ensure.That(memberDataType, "memberDataType").IsNotNull();
MemberDataType = memberDataType;
MemberDataTypeCode = memberDataTypeCode;
}
internal override void Init()
{
m_currentCount = 0u;
m_sumOfXType = DataTypeCode.Null;
m_sumOfX = null;
m_sumOfXSquared = null;
}
public override void Update(object[] expressions, IErrorContext iErrorContext)
{
Global.Tracer.Assert(null != expressions);
Global.Tracer.Assert(1 == expressions.Length);
object obj = expressions[0];
DataTypeCode typeCode = DataAggregate.GetTypeCode(obj);
if (!DataAggregate.IsNull(typeCode))
{
if (!DataTypeUtility.IsNumeric(typeCode))
{
iErrorContext.Register(ProcessingErrorCode.rsAggregateOfNonNumericData, Severity.Warning);
throw new InvalidOperationException();
}
if (this.m_expressionType == DataTypeCode.Null)
{
this.m_expressionType = typeCode;
}
else if (typeCode != this.m_expressionType)
{
iErrorContext.Register(ProcessingErrorCode.rsAggregateOfMixedDataTypes, Severity.Warning);
throw new InvalidOperationException();
}
DataAggregate.ConvertToDoubleOrDecimal(typeCode, obj, out typeCode, out obj);
if (this.m_currentTotal == null)
{
this.m_currentTotalType = typeCode;
this.m_currentTotal = obj;
}
else
{
this.m_currentTotal = DataAggregate.Add(this.m_currentTotalType, this.m_currentTotal, typeCode, obj);
}
}
}
internal override void Update(object[] expressions, IErrorContext iErrorContext)
{
Global.Tracer.Assert(expressions != null);
Global.Tracer.Assert(1 == expressions.Length);
object doubleOrDecimalData = expressions[0];
DataTypeCode doubleOrDecimalType = DataAggregate.GetTypeCode(doubleOrDecimalData);
if (!DataAggregate.IsNull(doubleOrDecimalType))
{
if (!DataTypeUtility.IsNumeric(doubleOrDecimalType))
{
iErrorContext.Register(ProcessingErrorCode.rsAggregateOfNonNumericData, Severity.Warning);
throw new InvalidOperationException();
}
if (m_expressionType == DataTypeCode.Null)
{
m_expressionType = doubleOrDecimalType;
}
else if (doubleOrDecimalType != m_expressionType)
{
iErrorContext.Register(ProcessingErrorCode.rsAggregateOfMixedDataTypes, Severity.Warning);
throw new InvalidOperationException();
}
DataAggregate.ConvertToDoubleOrDecimal(doubleOrDecimalType, doubleOrDecimalData, out doubleOrDecimalType, out doubleOrDecimalData);
if (m_currentTotal == null)
{
m_currentTotalType = doubleOrDecimalType;
m_currentTotal = doubleOrDecimalData;
}
else
{
m_currentTotal = DataAggregate.Add(m_currentTotalType, m_currentTotal, doubleOrDecimalType, doubleOrDecimalData);
}
}
}
public DataDescriptiveRecordField(string tag, byte[] fieldControls) : base(tag)
{
int val = Int32.Parse(((char)fieldControls[0]).ToString());
DataStructureCode = (DataStructureCode)val;
val = Int32.Parse(((char)fieldControls[1]).ToString());
DataTypeCode = (DataTypeCode)val;
if (DataTypeCode == DataTypeCode.BitStringIncludingBinaryForms && (char)fieldControls[2] != '0' &&
(char)fieldControls[3] != '0')
{
throw new NotImplementedException("Processing Auxillary controls in Field Controls");
}
FieldTerminatorPrintableGraphic = (char)fieldControls[4];
UnitTerminatorPrintableGraphic = (char)fieldControls[5];
if (fieldControls.Length > 6)
{
TruncatedEscapeSequence[0] = (char)fieldControls[6];
TruncatedEscapeSequence[1] = (char)fieldControls[7];
TruncatedEscapeSequence[2] = (char)fieldControls[8];
}
}
public virtual string GetNameByType(DataTypeCode dataTypeCode)
{
switch (dataTypeCode)
{
case DataTypeCode.IntegerNumber:
return(IntegersTableName);
case DataTypeCode.FractalNumber:
return(FractalsTableName);
case DataTypeCode.Bool:
return(BooleansTableName);
case DataTypeCode.DateTime:
return(DatesTableName);
case DataTypeCode.Guid:
return(GuidsTableName);
case DataTypeCode.String:
return(StringsTableName);
case DataTypeCode.Text:
return(TextsTableName);
}
return(StringsTableName);
}
public static bool IsValueType(this DataTypeCode dataTypeCode)
{
return
(dataTypeCode != DataTypeCode.String &&
dataTypeCode != DataTypeCode.Enum &&
dataTypeCode != DataTypeCode.Text);
}
public IndexAccessor(IStructureProperty property, DataTypeCode dataTypeCode)
: base(property)
{
_callstack = GetCallstack(Property);
_callstack.Reverse();
DataTypeCode = dataTypeCode;
}
public void ReadXml(XmlReader xmlReader)
{
while (xmlReader.Read())
{
XmlNodeType nodeType = xmlReader.NodeType;
if (nodeType == XmlNodeType.Element)
{
switch (xmlReader.Name)
{
case "TypeCode":
break;
case "Value":
goto IL_005d;
default:
goto IL_0078;
}
xmlReader.Read();
this.m_dataTypeCode = (DataTypeCode)Enum.Parse(typeof(DataTypeCode), xmlReader.Value, false);
continue;
}
goto IL_0078;
IL_005d:
xmlReader.Read();
this.m_value = ObjectSerializer.Read(xmlReader, this.m_dataTypeCode);
continue;
IL_0078:
this.ReadDerivedXml(xmlReader);
}
}
// create a function value
// BUG: a persistent function must not reference a non-persistent global
public AstValue Funval(AstType rettype, IList <AstField> arguments, AstBodyStatement body)
{
var code = Code(body.Statement as AstValue, Headingof(arguments), "λ", false, body.AccumCount, body.HasWin);
return(new AstFunval {
Value = code, DataType = DataTypeCode.Get(code.DataType, code.Lookup)
});
}
private static bool IsComparableToCurrency(DataTypeCode typeCode)
{
if (typeCode - 6 <= DataTypeCode.Unknown || typeCode == DataTypeCode.Decimal)
{
return(true);
}
return(false);
}
internal static bool IsNumericDateVariant(DataTypeCode typeCode)
{
if (typeCode == DataTypeCode.Empty || typeCode - 6 <= DataTypeCode.Unknown || typeCode - 9 <= DataTypeCode.Boolean)
{
return(true);
}
return(false);
}
public static Byte ExtraeValorNumericoByteCelda(int valorCelda, string nombreCampo, GridViewDeleteEventArgs e, GridView gridview)
{
DataControlFieldCell cell = (DataControlFieldCell)gridview.Rows[e.RowIndex].Cells[valorCelda];
BoundField field = (BoundField)cell.ContainingField;
System.Collections.Specialized.OrderedDictionary dict = new System.Collections.Specialized.OrderedDictionary();
field.ExtractValuesFromCell(dict, cell, DataControlRowState.Edit, true);
return DataTypeCode.ConvertirAByte(dict[nombreCampo].ToString().Replace("$", "").Trim());
}
public StringExactMemberNode(string memberPath, Type dataType, DataTypeCode dataTypeCode, string value)
: base(memberPath, dataType, dataTypeCode)
{
if (DataTypeCode == DataTypeCode.Text)
throw new SisoDbNotSupportedException(ExceptionMessages.QxIsExactly_NotSupportedForTexts.Inject(Path));
Value = value;
}
internal static bool IsNonNumericVariant(DataTypeCode typeCode)
{
if (typeCode == DataTypeCode.Boolean || typeCode == DataTypeCode.String)
{
return(true);
}
return(false);
}
internal static bool IsLessThanCurrency(DataTypeCode typeCode)
{
if (typeCode - 6 <= DataTypeCode.Unknown)
{
return(true);
}
return(false);
}
internal static bool IsLessThanReal(DataTypeCode typeCode)
{
if (typeCode - 6 <= DataTypeCode.Unknown || typeCode == DataTypeCode.Decimal)
{
return(true);
}
return(false);
}
internal static bool IsNumericVariant(DataTypeCode typeCode)
{
if (typeCode - 6 <= DataTypeCode.Unknown || typeCode - 9 <= DataTypeCode.Unknown)
{
return(true);
}
return(false);
}
private static bool IsComparableToReal(DataTypeCode typeCode)
{
if (typeCode - 6 <= DataTypeCode.Unknown || typeCode - 10 <= DataTypeCode.Unknown)
{
return(true);
}
return(false);
}
public MemberNode(string memberPath, Type dataType, DataTypeCode dataTypeCode)
{
Ensure.That(memberPath, "memberPath").IsNotNullOrWhiteSpace();
Ensure.That(dataType, "dataType").IsNotNull();
Path = memberPath;
DataType = dataType;
DataTypeCode = dataTypeCode;
}
private SqlWhereMember()
{
_isEmpty = true;
_index = -1;
_memberPath = string.Empty;
_alias = string.Empty;
_dataType = typeof(object);
_dataTypeCode = DataTypeCode.Unknown;
}
private SqlWhereMember()
{
_isEmpty = true;
_index = -1;
_memberPath = string.Empty;
_alias = string.Empty;
_dataType = typeof(object);
_dataTypeCode = DataTypeCode.Unknown;
}
public MemberNode(string memberPath, Type dataType, DataTypeCode dataTypeCode)
{
Ensure.That(memberPath, "memberPath").IsNotNullOrWhiteSpace();
Ensure.That(dataType, "dataType").IsNotNull();
Path = memberPath;
DataType = dataType;
DataTypeCode = dataTypeCode;
}
public ArrayValueNode(Type memberDataType, DataTypeCode memberDataTypeCode, object[] value)
{
Ensure.That(memberDataType, "memberDataType").IsNotNull();
Ensure.That(value, "value").HasItems();
MemberDataType = memberDataType;
MemberDataTypeCode = memberDataTypeCode;
Value = value;
}
public ArrayValueNode(Type memberDataType, DataTypeCode memberDataTypeCode, object[] value)
{
Ensure.That(memberDataType, "memberDataType").IsNotNull();
Ensure.That(value, "value").HasItems();
MemberDataType = memberDataType;
MemberDataTypeCode = memberDataTypeCode;
Value = value;
}
public static SqlParameter Create(string name, Type dataType, DataTypeCode dataTypeCode, object[] values)
{
Ensure.That(values, "values").HasItems();
if(dataTypeCode == DataTypeCode.Unknown)
throw new SisoDbException("Don't know how to create Table param for data type code: '{0}'".Inject(dataTypeCode));
return Creators[dataTypeCode].Invoke(name, dataType, values);
}
public DataItemDescriptor(string name, Type dataType, string description, string units, int capacity)
{
this.name = name;
this.dataType = dataType;
this.description = description;
this.units = units;
this.capacity = capacity;
this.typeCode = DetermineDataTypeCode();
}
public AstType FunvalType(AstType rtntype, AstField[] argtypes)
{
var ff = argtypes.Select(a => DataColumn.Create(a.Name, a.DataType)).ToArray();
var type = DataTypeCode.Get(rtntype.DataType, ff);
return(new AstType {
DataType = type
});
}
public DataItemDescriptor(string name, Type dataType, string description, string units, int capacity)
{
this.name = name;
this.dataType = dataType;
this.description = description;
this.units = units;
this.capacity = capacity;
this.typeCode = DetermineDataTypeCode();
}
public StringExactMemberNode(string memberPath, Type dataType, DataTypeCode dataTypeCode, string value)
: base(memberPath, dataType, dataTypeCode)
{
if (DataTypeCode == DataTypeCode.Text)
{
throw new SisoDbNotSupportedException(ExceptionMessages.QxIsExactly_NotSupportedForTexts.Inject(Path));
}
Value = value;
}
public SortingNode(string memberPath, Type dataType, DataTypeCode dataTypeCode, SortDirections direction = SortDirections.Asc)
{
Ensure.That(memberPath, "memberPath").IsNotNullOrWhiteSpace();
Ensure.That(dataType, "dataType").IsNotNull();
MemberPath = memberPath;
DataType = dataType;
DataTypeCode = dataTypeCode;
Direction = direction;
}
private SqlSortingMember()
{
_isEmpty = true;
_index = -1;
_memberPath = string.Empty;
_indexStorageColumnName = string.Empty;
_direction = string.Empty;
_dataType = typeof(object);
_dataTypeCode = DataTypeCode.Unknown;
}
public SortingNode(string memberPath, Type dataType, DataTypeCode dataTypeCode, SortDirections direction = SortDirections.Asc)
{
Ensure.That(memberPath, "memberPath").IsNotNullOrWhiteSpace();
Ensure.That(dataType, "dataType").IsNotNull();
MemberPath = memberPath;
DataType = dataType;
DataTypeCode = dataTypeCode;
Direction = direction;
}
private SqlSortingMember()
{
_isEmpty = true;
_index = -1;
_memberPath = string.Empty;
_indexStorageColumnName = string.Empty;
_direction = string.Empty;
_dataType = TypeFor<object>.Type;
_dataTypeCode = DataTypeCode.Unknown;
}
public static bool IsNonNumericVariant(DataTypeCode typeCode)
{
DataTypeCode dataTypeCode = typeCode;
if (dataTypeCode != DataTypeCode.Boolean && dataTypeCode != DataTypeCode.String)
{
return(false);
}
return(true);
}
public SqlWhereMember(int index, string memberPath, Type dataType, DataTypeCode dataTypeCode)
{
Ensure.That(index, "index").IsGte(0);
Ensure.That(memberPath, "memberPath").IsNotNullOrWhiteSpace();
Ensure.That(dataType, "dataType").IsNotNull();
_isEmpty = false;
_index = index;
_memberPath = memberPath;
_alias = string.Concat("mem", _index);
_dataType = dataType;
_dataTypeCode = dataTypeCode;
}
public IncludeNode(string referencedStructureName, string idReferencePath, string objectReferencePath, Type dataType, DataTypeCode dataTypeCode)
{
Ensure.That(referencedStructureName, "referencedStructureName").IsNotNullOrWhiteSpace();
Ensure.That(idReferencePath, "idReferencePath").IsNotNullOrWhiteSpace();
Ensure.That(objectReferencePath, "objectReferencePath").IsNotNullOrWhiteSpace();
Ensure.That(dataType, "dataType").IsNotNull();
ReferencedStructureName = referencedStructureName;
IdReferencePath = idReferencePath;
ObjectReferencePath = objectReferencePath;
DataType = dataType;
DataTypeCode = dataTypeCode;
}
public SqlSortingMember(int index, string memberPath, string alias, string indexStorageColumnName, string direction, Type dataType, DataTypeCode dataTypeCode)
{
Ensure.That(index, "index").IsGte(0);
Ensure.That(memberPath, "memberPath").IsNotNullOrWhiteSpace();
Ensure.That(alias, "alias").IsNotNullOrWhiteSpace();
Ensure.That(indexStorageColumnName, "indexStorageColumnName").IsNotNullOrWhiteSpace();
Ensure.That(direction, "direction").IsNotNullOrWhiteSpace();
Ensure.That(dataType, "dataType").IsNotNull();
_isEmpty = false;
_index = index;
_memberPath = memberPath;
_alias = alias;
_indexStorageColumnName = indexStorageColumnName;
_direction = direction;
_dataType = dataType;
_dataTypeCode = dataTypeCode;
}
public StructureIndex(IStructureId structureId, string path, object value, Type dataType, DataTypeCode dataTypeCode, StructureIndexType indexType = StructureIndexType.Normal)
{
var valueIsOkType = value is string || value is ValueType;
if (value != null && !valueIsOkType)
throw new ArgumentException(ExceptionMessages.StructureIndex_ValueArgument_IncorrectType);
Ensure.That(structureId, "structureId").IsNotNull();
Ensure.That(path, "path").IsNotNullOrWhiteSpace();
Ensure.That(dataType, "dataType").IsNotNull();
StructureId = structureId;
Path = path;
Value = value;
DataType = dataType;
DataTypeCode = dataTypeCode;
IndexType = indexType;
IsUnique = indexType.IsUnique();
}
public SqlInclude(int index, string tableName, string alias, string indexValueColumnName, string memberPathReference, string objectReferencePath, Type dataType, DataTypeCode dataTypeCode)
{
Ensure.That(index, "index").IsGte(0);
Ensure.That(tableName, "tableName").IsNotNullOrWhiteSpace();
Ensure.That(alias, "alias").IsNotNullOrWhiteSpace();
Ensure.That(indexValueColumnName, "indexValueColumnName").IsNotNullOrWhiteSpace();
Ensure.That(memberPathReference, "memberPathReference").IsNotNullOrWhiteSpace();
Ensure.That(objectReferencePath, "objectReferencePath").IsNotNullOrWhiteSpace();
Ensure.That(dataType, "dataType").IsNotNull();
_isEmpty = false;
_index = index;
_tableName = tableName;
_alias = alias;
_indexValueColumnName = indexValueColumnName;
_memberPathReference = memberPathReference;
_objectReferencePath = objectReferencePath;
_dataType = dataType;
_dataTypeCode = dataTypeCode;
}
public string GetNameByType(DataTypeCode dataTypeCode)
{
switch (dataTypeCode)
{
case DataTypeCode.IntegerNumber:
return IntegersTableName;
case DataTypeCode.FractalNumber:
return FractalsTableName;
case DataTypeCode.Bool:
return BooleansTableName;
case DataTypeCode.DateTime:
return DatesTableName;
case DataTypeCode.Guid:
return GuidsTableName;
case DataTypeCode.String:
return StringsTableName;
case DataTypeCode.Text:
return TextsTableName;
}
return StringsTableName;
}
public InSetMemberNode(string memberPath, Type dataType, DataTypeCode dataTypeCode, object[] values)
: base(memberPath, dataType, dataTypeCode)
{
Values = values;
}
protected virtual IndexInsertAction CreateIndexInsertActionGroup(IStructureSchema structureSchema, IndexesTableNames indexesTableNames, DataTypeCode dataTypeCode, IStructureIndex[] indexes)
{
var container = new IndexInsertAction { Data = indexes };
switch (dataTypeCode)
{
case DataTypeCode.IntegerNumber:
if (container.Data.Length > 1)
container.Action = (data, dbClient) => dbClient.BulkInsertIndexes(new ValueTypeIndexesReader(new IndexStorageSchema(structureSchema, indexesTableNames.IntegersTableName), data));
if (container.Data.Length == 1)
container.Action = (data, dbClient) => dbClient.SingleInsertOfValueTypeIndex(data[0], indexesTableNames.IntegersTableName);
break;
case DataTypeCode.FractalNumber:
if (container.Data.Length > 1)
container.Action = (data, dbClient) => dbClient.BulkInsertIndexes(new ValueTypeIndexesReader(new IndexStorageSchema(structureSchema, indexesTableNames.FractalsTableName), data));
if (container.Data.Length == 1)
container.Action = (data, dbClient) => dbClient.SingleInsertOfValueTypeIndex(data[0], indexesTableNames.FractalsTableName);
break;
case DataTypeCode.Bool:
if (container.Data.Length > 1)
container.Action = (data, dbClient) => dbClient.BulkInsertIndexes(new ValueTypeIndexesReader(new IndexStorageSchema(structureSchema, indexesTableNames.BooleansTableName), data));
if (container.Data.Length == 1)
container.Action = (data, dbClient) => dbClient.SingleInsertOfValueTypeIndex(data[0], indexesTableNames.BooleansTableName);
break;
case DataTypeCode.DateTime:
if (container.Data.Length > 1)
container.Action = (data, dbClient) => dbClient.BulkInsertIndexes(new ValueTypeIndexesReader(new IndexStorageSchema(structureSchema, indexesTableNames.DatesTableName), data));
if (container.Data.Length == 1)
container.Action = (data, dbClient) => dbClient.SingleInsertOfValueTypeIndex(data[0], indexesTableNames.DatesTableName);
break;
case DataTypeCode.Guid:
if (container.Data.Length > 1)
container.Action = (data, dbClient) => dbClient.BulkInsertIndexes(new ValueTypeIndexesReader(new IndexStorageSchema(structureSchema, indexesTableNames.GuidsTableName), data));
if (container.Data.Length == 1)
container.Action = (data, dbClient) => dbClient.SingleInsertOfValueTypeIndex(data[0], indexesTableNames.GuidsTableName);
break;
case DataTypeCode.String:
if (container.Data.Length > 1)
container.Action = (data, dbClient) => dbClient.BulkInsertIndexes(new StringIndexesReader(new IndexStorageSchema(structureSchema, indexesTableNames.StringsTableName), data));
if (container.Data.Length == 1)
container.Action = (data, dbClient) => dbClient.SingleInsertOfStringTypeIndex(data[0], indexesTableNames.StringsTableName);
break;
case DataTypeCode.Enum:
if (container.Data.Length > 1)
container.Action = (data, dbClient) => dbClient.BulkInsertIndexes(new StringIndexesReader(new IndexStorageSchema(structureSchema, indexesTableNames.StringsTableName), data));
if (container.Data.Length == 1)
container.Action = (data, dbClient) => dbClient.SingleInsertOfStringTypeIndex(data[0], indexesTableNames.StringsTableName);
break;
case DataTypeCode.Text:
if (container.Data.Length > 1)
container.Action = (data, dbClient) => dbClient.BulkInsertIndexes(new TextIndexesReader(new IndexStorageSchema(structureSchema, indexesTableNames.TextsTableName), data));
if (container.Data.Length == 1)
container.Action = (data, dbClient) => dbClient.SingleInsertOfStringTypeIndex(data[0], indexesTableNames.TextsTableName);
break;
default:
container.Action = null;
break;
}
return container;
}
public ToLowerMemberNode(string memberPath, Type dataType, DataTypeCode dataTypeCode)
: base(memberPath, dataType, dataTypeCode) {}
public StringContainsMemberNode(string memberPath, Type dataType, DataTypeCode dataTypeCode, string value)
: base(memberPath, dataType, dataTypeCode)
{
Value = value;
}
public LikeMemberNode(string memberPath, Type dataType, DataTypeCode dataTypeCode, string value)
: base(memberPath, dataType, dataTypeCode)
{
Value = value;
}
/// <summary>
/// Given a data type, this utility method tells if it is a numeric data type.
/// </summary>
/// <param name="dataType">The data type for which method is to determine numeric/non-numeric.</param>
/// <returns>True if item is a recognized <see cref="NumericDataTypes"/> item.</returns>
public static bool CheckIsNumeric(DataTypeCode dataType)
{
ArrayList numericTypes = new ArrayList(Enum.GetValues(typeof(NumericDataTypes)));
foreach (int i in numericTypes)
{
if (i == (int)dataType)
{
return true;
}
}
return false;
}
public void IsValueType_WhenValueType_ReturnsTrue(DataTypeCode dataTypeCode)
{
Assert.IsTrue(dataTypeCode.IsValueType());
}
public NullableMemberNode(string memberPath, Type dataType, DataTypeCode dataTypeCode)
: base(ApplyPathRules(memberPath), ExtractType(dataType), dataTypeCode)
{
IsForHasValueCheck = memberPath.EndsWith(".HasValue");
}
private MemoryStream GetSendBuffer(DataTypeCode dtc) {
if (dtc == DataTypeCode.BinarySerialized) {
return new MemoryStream();
}
else {
byte[] data = null;
lock (nomBuffers) {
if (nomBuffers.Count == 0) {
data = new byte[NomSendBufferSize];
}
else {
data = nomBuffers.Pop();
}
}
return new PooledMemoryStream(data, 0, data.Length, true, true);
}
}
public StringEndsWithMemberNode(string memberPath, Type dataType, DataTypeCode dataTypeCode, string value)
: base(memberPath, dataType, dataTypeCode)
{
Value = value;
}
public void IsValueType_WhenNonValueType_ReturnsFalse(DataTypeCode dataTypeCode)
{
Assert.IsFalse(dataTypeCode.IsValueType());
}
