public void GetType_should_return_mapped_type_when_type_is_registered() { var typeDescription = new TypeDescription("test", new IPropertyDescription[0]); var generatedType = new GeneratedType("test", typeof(int), typeDescription); typeMapper.RegisterNewType(typeDescription, generatedType); var result = typeMapper.GetType(this.GetType()); Assert.AreEqual(result, this.GetType()); }
private void BuildDictionary( DataType dataType, Type type, TypeDescription typeDescription, bool inputGraph, IEnumerable<Type> ancestors, MemberDescription memberDescription) { var types = type.GetGenericDictionaryTypes(); dataType.IsDictionary = true; dataType.Comments = memberDescription.WhenNotNull(x => x.Comments).OtherwiseDefault() ?? dataType.Comments; dataType.DictionaryEntry = new DictionaryEntry { KeyName = memberDescription.WhenNotNull(x => x.DictionaryEntry.KeyName).OtherwiseDefault() ?? typeDescription.WhenNotNull(x => x.DictionaryEntry.KeyName).OtherwiseDefault(), KeyComments = memberDescription.WhenNotNull(x => x.DictionaryEntry.KeyComments).OtherwiseDefault() ?? typeDescription.WhenNotNull(x => x.DictionaryEntry.KeyComments).OtherwiseDefault(), KeyType = BuildGraph(dataType, types.Key, inputGraph, ancestors), ValueComments = memberDescription.WhenNotNull(x => x.DictionaryEntry.ValueComments).OtherwiseDefault() ?? typeDescription.WhenNotNull(x => x.DictionaryEntry.ValueComments).OtherwiseDefault(), ValueType = BuildGraph(dataType, types.Value, inputGraph, ancestors) }; }
public void LoadField(string fieldName) { var firstVar = _evaluator.Pop(); var vreg = SetNewVReg(); var computedType = firstVar.ComputedType(); if (computedType.ClrType.IsByRef) { computedType = new TypeDescription(computedType.ClrType.GetElementType()); } vreg.FixedType = new TypeDescription( computedType.ClrType.LocateField(fieldName).FieldType); var assignment = new FieldGetter { AssignedTo = vreg, FieldName = fieldName, Instance = (LocalVariable)firstVar }; AddOperation(OperationKind.GetField, assignment); }
/// <summary> /// Helper function. Enumerate all the objects in the dump /// </summary> /// <param name="path">path of the dump</param> /// <param name="typeDescription"></param> /// <param name="shardIndex"></param> /// <returns></returns> public static IEnumerable <CachedObject> ObjectsInDump(string path, TypeDescription typeDescription, int shardIndex = -1) { var fileMask = shardIndex != -1 ? $"{typeDescription.FullTypeName}_shard{shardIndex:D4}*.txt" : $"{typeDescription.FullTypeName}_shard*.txt"; var files = Directory.GetFiles(path, fileMask); foreach (var file in files) { var content = File.ReadAllText(file); var parts = content.Split(new[] { "\\-" }, StringSplitOptions.RemoveEmptyEntries) .Select(txt => txt.Trim()).Where(t => !string.IsNullOrWhiteSpace(t)).ToList(); foreach (var part in parts) { var cachedObject = CachedObject.PackJson(part, typeDescription); yield return(cachedObject); } } }
/// <summary> /// 将Map平台AppForm格式xml字符串转换为实体对象集合 /// </summary> /// <remarks> /// <list type="bullet"> /// <item><description>xml结构为3层,第1层被忽略,第2层为数据库表名,第3层为字段名</description></item> /// <item><description>xml结构第2层节点必须包含keyname,keyvalue属性,keyvalue属性可以为空</description></item> /// <item><description>如果类,属性存在Alias别名标记,则按照别名赋值,否则按照类名,属性名赋值</description></item> /// </list> /// </remarks> /// <example> /// <para>下面的代码演示了从ConvertXmlToList()方法的用法</para> /// <code> /// <![CDATA[ /// using System; /// using System.Collections.Generic; /// using System.Linq; /// using System.Text; /// /// //引入命名空间 /// using Hack.Fast.Extensions; /// using Hack.Fast.Extensions.Xml; /// using Hack.Fast.Extensions.DAL; /// namespace Demo /// { /// public class DemoBusiness /// { /// public void Demo(){ /// string xml = @"<UserData> /// <cb_Contract keyname="ContractGUID" keyvalue=""> /// <ContractName>测试合同一</ContractName> /// <ContractCode>HT-001</ContractCode> /// ...其他值 /// </cb_Contract> /// <cb_Contract keyname="ContractGUID" keyvalue=""> /// <ContractName>测试合同二</ContractName> /// <ContractCode>HT-002</ContractCode> /// ...其他值 /// </cb_Contract> /// </UserData>"; /// /// List<CbContract> contracts = XmlDataEntity.ConvertXmlToList<CbContract>(xml); /// /// foreach(CbContract contract in contracts){ /// //主键为空,表示是新增 /// if (contract.ContractGUID == Guid.Empty){ /// contract.ContractGUID = Guid.NewGuid(); /// //插入到数据库 /// contract.Insert(); /// } /// else{ /// //更新到数据库 /// contract.Update(); /// } /// } /// } /// } /// } /// ]]> /// </code> /// </example> /// <typeparam name="T">实体类型</typeparam> /// <param name="xml">xml字符串</param> /// <returns>实体对象集合</returns> public static List <T> ConvertXmlToList <T>(string xml) where T : BaseEntity, new() { if (string.IsNullOrEmpty(xml)) { throw new ArgumentNullException("xml"); } Type type = typeof(T); TypeDescription description = TypeDescriptionCache.GetTypeDiscription(type); if (description.ExecuteFunc == null) { throw BaseEntity.GetNonStandardExecption(type); } try { return(description.ExecuteFunc(12, new object[] { xml }) as List <T>); } catch (System.Exception ex) { //这里不希望调用者看到代码生成器产生的代码结构,于是在这里抛出捕获到的异常 throw ex; } }
/// <summary> /// Initialize an empty datastore from a type description /// </summary> /// <param name="typeDescription"></param> /// <param name="evictionPolicy"></param> public DataStore(TypeDescription typeDescription, EvictionPolicy evictionPolicy) { TypeDescription = typeDescription ?? throw new ArgumentNullException(nameof(typeDescription)); EvictionPolicy = evictionPolicy ?? throw new ArgumentNullException(nameof(evictionPolicy)); //initialize the primary key dictionary _dataByPrimaryKey = new Dictionary <KeyValue, CachedObject>(); //initialize the unique keys dictionaries (une by unique key) _dataByUniqueKey = new Dictionary <string, Dictionary <KeyValue, CachedObject> >(); foreach (var keyInfo in typeDescription.UniqueKeyFields) { _dataByUniqueKey.Add(keyInfo.Name, new Dictionary <KeyValue, CachedObject>()); } //initialize the indexes (one by index key) _dataByIndexKey = new Dictionary <string, IndexBase>(); // scalar indexed fields foreach (var indexField in typeDescription.IndexFields) { var index = IndexFactory.CreateIndex(indexField); _dataByIndexKey.Add(indexField.Name, index); } // list indexed fields foreach (var indexField in typeDescription.ListFields) { var index = IndexFactory.CreateIndex(indexField); _dataByIndexKey.Add(indexField.Name, index); } }
internal static List <T> ToList <T>(DataTable table, TypeDescription description) where T : class, new() { Type type = typeof(T); Dictionary <string, DbMapInfo> dict = description.MemberDict; List <T> list = new List <T>(); foreach (DataRow row in table.Rows) { T obj = Activator.CreateInstance(type) as T; for (int i = 0; i < table.Columns.Count; i++) { string name = table.Columns[i].ColumnName; DbMapInfo info; if (dict.TryGetValue(name, out info)) { object val = row[i]; if (val != null && DBNull.Value.Equals(val) == false) { if (info.AttrColumn != null && info.AttrColumn.TimeStamp) { info.PropertyInfo.FastSetValue(obj, val.ConvertToTimeStamp(info.PropertyInfo.PropertyType)); } else { info.PropertyInfo.FastSetValue(obj, val.Convert(info.PropertyInfo.PropertyType)); } } } } list.Add(obj); } return(list); }
public void testDecimalMerge() { TypeDescription schema = TypeDescription.createDecimal() .withPrecision(38).withScale(16); ColumnStatisticsImpl stats1 = ColumnStatisticsImpl.create(schema); ColumnStatisticsImpl stats2 = ColumnStatisticsImpl.create(schema); stats1.updateDecimal(HiveDecimal.create(10)); stats1.updateDecimal(HiveDecimal.create(100)); stats2.updateDecimal(HiveDecimal.create(1)); stats2.updateDecimal(HiveDecimal.create(1000)); stats1.merge(stats2); DecimalColumnStatistics typed = (DecimalColumnStatistics)stats1; Assert.Equal(1, typed.getMinimum().longValue()); Assert.Equal(1000, typed.getMaximum().longValue()); stats1.reset(); stats1.updateDecimal(HiveDecimal.create(-10)); stats1.updateDecimal(HiveDecimal.create(10000)); stats1.merge(stats2); Assert.Equal(-10, typed.getMinimum().longValue()); Assert.Equal(10000, typed.getMaximum().longValue()); }
private void AddPreDestroyMethodPoints(TypeDescription description, MethodInfo[] methods) { List <OrderedInjectionPoint> orderedInjectionPoints = new List <OrderedInjectionPoint> (); foreach (MethodInfo method in methods) { object[] injections = method.GetCustomAttributes(PRE_DESTROY_ATTRIBUTE_TYPE, true); if (injections.Length == 0) { continue; } PreDestroy attr = injections [0] as PreDestroy; PreDestroyInjectionPoint injectionPoint = new PreDestroyInjectionPoint(attr.order, method); orderedInjectionPoints.Add(injectionPoint); } orderedInjectionPoints.Sort(SortInjectionPoints); foreach (PreDestroyInjectionPoint point in orderedInjectionPoints) { description.AddPreDestroyMethod(point); } }
private static Expression ConvertToNullable(Expression notNullableExpression, TypeDescription typeDescription) { if (notNullableExpression == null) { throw new ArgumentNullException("notNullableExpression"); } if (typeDescription != null && notNullableExpression.Type != typeDescription) { throw new ArgumentException("Wrong type description.", "typeDescription"); } if (typeDescription == null) { typeDescription = TypeDescription.GetTypeDescription(notNullableExpression.Type); } if (typeDescription.CanBeNull == false) { return(Expression.Convert(notNullableExpression, typeDescription.GetNullableType())); } else { return(notNullableExpression); } }
private void AddPostConstructMethodPoints(TypeDescription description, MethodInfo[] methods) { List <OrderedInjectionPoint> orderedInjectionPoints = new List <OrderedInjectionPoint> (); foreach (MethodInfo method in methods) { object[] injections = method.GetCustomAttributes(POST_CONSTRUCT_ATTRIBUTE_TYPE, true); if (injections.Length == 0) { continue; } PostConstruct attr = injections [0] as PostConstruct; PostConstructInjectionPoint injectionPoint = new PostConstructInjectionPoint(attr.order, method); orderedInjectionPoints.Add(injectionPoint); } orderedInjectionPoints.Sort(SortInjectionPoints); foreach (OrderedInjectionPoint point in orderedInjectionPoints) { description.AddInjectionPoint(point); } }
private void BuildDictionary( DataType dataType, Type type, TypeDescription typeDescription, bool inputGraph, IEnumerable <Type> ancestors, MemberDescription memberDescription) { var types = type.GetGenericDictionaryTypes(); dataType.IsDictionary = true; dataType.Comments = memberDescription.WhenNotNull(x => x.Comments).OtherwiseDefault() ?? dataType.Comments; dataType.DictionaryEntry = new DictionaryEntry { KeyName = memberDescription.WhenNotNull(x => x.DictionaryEntry.KeyName).OtherwiseDefault() ?? typeDescription.WhenNotNull(x => x.DictionaryEntry.KeyName).OtherwiseDefault(), KeyComments = memberDescription.WhenNotNull(x => x.DictionaryEntry.KeyComments).OtherwiseDefault() ?? typeDescription.WhenNotNull(x => x.DictionaryEntry.KeyComments).OtherwiseDefault(), KeyType = BuildGraph(dataType, types.Key, inputGraph, ancestors), ValueComments = memberDescription.WhenNotNull(x => x.DictionaryEntry.ValueComments).OtherwiseDefault() ?? typeDescription.WhenNotNull(x => x.DictionaryEntry.ValueComments).OtherwiseDefault(), ValueType = BuildGraph(dataType, types.Value, inputGraph, ancestors) }; }
public static void GetHashCode___Should_be_equal___When_objects_have_the_same_property_values() { // Arrange var typeDescription1A = new TypeDescription(); var typeDescription1B = new TypeDescription { AssemblyQualifiedName = null, Name = null, Namespace = null }; var typeDescription2A = A.Dummy <TypeDescription>(); var typeDescription2B = new TypeDescription { AssemblyQualifiedName = typeDescription2A.AssemblyQualifiedName, Name = typeDescription2A.Name, Namespace = typeDescription2A.Namespace }; // Act var hash1A = typeDescription1A.GetHashCode(); var hash1B = typeDescription1B.GetHashCode(); var hash2A = typeDescription2A.GetHashCode(); var hash2B = typeDescription2B.GetHashCode(); // Assert hash1A.Should().Be(hash1B); hash2A.Should().Be(hash2B); }
public void LoadStaticField(FieldInfo operand) { var vreg = SetNewVReg(); var fieldName = operand.Name; var declaringType = operand.DeclaringType; if (declaringType == typeof(IntPtr) && fieldName == "Zero") { var voidPtr = new TypeDescription(typeof(IntPtr)); vreg.FixedType = voidPtr; var nullPtrAssign = new Assignment { AssignedTo = vreg, Right = new ConstValue(0) { FixedType = voidPtr } }; AddOperation(nullPtrAssign); return; } vreg.FixedType = new TypeDescription(declaringType.LocateField(fieldName, true).FieldType); var typeData = new TypeDescription(declaringType); var assignment = new Assignment { AssignedTo = vreg, Right = new StaticFieldGetter { FieldName = fieldName, DeclaringType = typeData } }; AddOperation(assignment); }
public static bool IsString(this TypeDescription typeDescription) { return(typeDescription.TypeString.StartsWith("string", StringComparison.CurrentCulture)); }
public static bool IsUint(this TypeDescription typeDescription) { return(!typeDescription.IsDynamicArray() && !typeDescription.IsStaticArray() && typeDescription.TypeString.StartsWith("uint", StringComparison.CurrentCulture)); }
public static Tuple <Matrix, Vector, TypeDescription> Convert <T>(IEnumerable <T> examples, TypeDescription description = null) { var t = typeof(T); Dictionary <Object, int> labelsDictionary = new Dictionary <Object, int>(); int labelsCounter = 0; Dictionary <int, Object> labelsDictionaryReversed = new Dictionary <int, Object>(); // build up type descriptions along with dictionary if (description == null) { description = GetDescription(t) .BuildDictionaries <T>(examples); } // number of examples var n = examples.Count(); // this in essence counts all non-string properties singly // and adds the correspondin dictionary lengths for all // string features var d = description.Features .Where(p => !(p is StringProperty)).Count() + description.Features .Where(p => p is StringProperty) .Aggregate(0, (no, p) => no += (p as StringProperty).Dictionary.Length); var X = new double[n, d]; var Y = new double[n]; int i = 0; foreach (var example in examples) { int j = 0; foreach (var f in description.Features) { var item = Conversion.Converter.GetItem <T>(example, f); if (f is StringProperty) { var s = f as StringProperty; var wc = GetWordCount((string)item, s); for (int k = 0; k < wc.Length; k++) { X[i, j] = wc[k]; j++; } } else { X[i, j] = Conversion.Converter.Convert(item); j++; } } // getting label var y = Conversion.Converter.GetItem <T>(example, description.Label); //building the labesl dictionary - because later we have to work with doubles/integers //which represent the labels if (!labelsDictionary.ContainsKey(y)) { labelsDictionary.Add(y, labelsCounter); labelsDictionaryReversed.Add(labelsCounter, y); labelsCounter++; } Y[i] = labelsDictionary[y]; i++; } description.Label.Labels = labelsDictionaryReversed.Select(x => x.Value).ToArray(); // create vectors for each example return(new Tuple <Matrix, Vector, TypeDescription>( new Matrix(X), new Vector(Y), description)); }
private static bool TryConvertInPlace(ref Expression expression, TypeDescription targetType, out float quality) { if (expression == null) { throw new ArgumentNullException("expression"); } if (targetType == null) { throw new ArgumentNullException("targetType"); } quality = TypeConversion.QUALITY_NO_CONVERSION; var targetTypeUnwrap = targetType.IsNullable ? targetType.UnderlyingType : targetType; // try to convert value of constant var constantExpression = default(ConstantExpression); if (TryExposeConstant(expression, out constantExpression) == false) { return(false); } var constantValue = constantExpression.Value; var constantType = TypeDescription.GetTypeDescription(constantExpression.Type); var constantTypeUnwrap = constantType.IsNullable ? constantType.UnderlyingType : constantType; if (constantValue == null && constantType.DefaultExpression != constantExpression && targetType.CanBeNull) { quality = TypeConversion.QUALITY_SAME_TYPE; expression = Expression.Constant(null, targetType); return(true); } else if (constantValue == null) { return(false); } var constantTypeCode = constantTypeUnwrap.TypeCode; var convertibleToExpectedType = default(bool); // ReSharper disable RedundantCast // ReSharper disable once SwitchStatementMissingSomeCases switch (targetTypeUnwrap.TypeCode) { case TypeCode.Byte: convertibleToExpectedType = IsInRange(constantValue, constantTypeCode, byte.MinValue, byte.MaxValue); break; case TypeCode.SByte: convertibleToExpectedType = IsInRange(constantValue, constantTypeCode, sbyte.MinValue, (ulong)sbyte.MaxValue); break; case TypeCode.Char: case TypeCode.UInt16: convertibleToExpectedType = IsInRange(constantValue, constantTypeCode, ushort.MinValue, ushort.MaxValue); break; case TypeCode.Int16: convertibleToExpectedType = IsInRange(constantValue, constantTypeCode, short.MinValue, (ulong)short.MaxValue); break; case TypeCode.UInt32: convertibleToExpectedType = IsInRange(constantValue, constantTypeCode, uint.MinValue, uint.MaxValue); break; case TypeCode.Int32: convertibleToExpectedType = IsInRange(constantValue, constantTypeCode, int.MinValue, int.MaxValue); break; case TypeCode.UInt64: convertibleToExpectedType = IsInRange(constantValue, constantTypeCode, (long)ulong.MinValue, ulong.MaxValue); break; case TypeCode.Int64: convertibleToExpectedType = IsInRange(constantValue, constantTypeCode, long.MinValue, long.MaxValue); break; case TypeCode.Double: case TypeCode.Decimal: case TypeCode.Single: convertibleToExpectedType = NumberUtils.IsSignedInteger(constantTypeCode) || NumberUtils.IsUnsignedInteger(constantTypeCode); break; default: convertibleToExpectedType = false; break; } // ReSharper restore RedundantCast if (!convertibleToExpectedType) { return(false); } var newValue = Convert.ChangeType(constantValue, targetTypeUnwrap.TypeCode, Constants.DefaultFormatProvider); expression = Expression.Constant(newValue, targetType); quality = TypeConversion.QUALITY_IN_PLACE_CONVERSION; // converted in-place return(true); }
private static TypeDescription GetTypeDescription(Type sourceClass) { var propertySource = new ClassSource(sourceClass); var typeDesctiption = new TypeDescription(sourceClass.FullName, propertySource.GetProperties()); return typeDesctiption; }
/// <summary> /// Initialize for a specified cacheable data type /// </summary> /// <param name="type"></param> public QueryBuilder(Type type) { var clientTypeDescription = ClientSideTypeDescription.RegisterType(type); _typeDescription = clientTypeDescription.AsTypeDescription; }
public NullableSerializer(TypeDescription description) { this.typeDescription = description; }
private static bool TryPromoteNumberBinaryOperation(ref Expression leftOperand, TypeDescription leftType, ref Expression rightOperand, TypeDescription rightType, ExpressionType type, out Expression operation) { if (leftOperand == null) { throw new ArgumentNullException("leftOperand"); } if (leftType == null) { throw new ArgumentNullException("leftType"); } if (rightOperand == null) { throw new ArgumentNullException("rightOperand"); } if (rightType == null) { throw new ArgumentNullException("rightType"); } operation = null; var leftTypeUnwrap = leftType.IsNullable ? leftType.UnderlyingType : leftType; var rightTypeUnwrap = rightType.IsNullable ? rightType.UnderlyingType : rightType; var leftTypeCode = leftTypeUnwrap.TypeCode; var rightTypeCode = rightTypeUnwrap.TypeCode; var promoteLeftToNullable = leftType.IsNullable || rightType.IsNullable; var promoteRightToNullable = rightType.IsNullable || (type != ExpressionType.Coalesce && promoteLeftToNullable); if (leftTypeUnwrap == rightTypeUnwrap) { if (leftTypeCode >= TypeCode.SByte && leftTypeCode <= TypeCode.UInt16) { // expand smaller integers to int32 leftOperand = Expression.Convert(leftOperand, promoteLeftToNullable ? TypeDescription.Int32Type.GetNullableType() : TypeDescription.Int32Type); rightOperand = Expression.Convert(rightOperand, promoteRightToNullable ? TypeDescription.Int32Type.GetNullableType() : TypeDescription.Int32Type); return(false); } } else if (leftTypeCode == TypeCode.Decimal || rightTypeCode == TypeCode.Decimal) { if (leftTypeCode == TypeCode.Double || leftTypeCode == TypeCode.Single || rightTypeCode == TypeCode.Double || rightTypeCode == TypeCode.Single) { return(false); // will throw exception } if (leftTypeCode == TypeCode.Decimal) { rightOperand = Expression.Convert(rightOperand, promoteRightToNullable ? typeof(decimal?) : typeof(decimal)); } else { leftOperand = Expression.Convert(leftOperand, promoteLeftToNullable ? typeof(decimal?) : typeof(decimal)); } } else if (leftTypeCode == TypeCode.Double || rightTypeCode == TypeCode.Double) { if (leftTypeCode == TypeCode.Double) { rightOperand = Expression.Convert(rightOperand, promoteRightToNullable ? typeof(double?) : typeof(double)); } else { leftOperand = Expression.Convert(leftOperand, promoteLeftToNullable ? typeof(double?) : typeof(double)); } } else if (leftTypeCode == TypeCode.Single || rightTypeCode == TypeCode.Single) { if (leftTypeCode == TypeCode.Single) { rightOperand = Expression.Convert(rightOperand, promoteRightToNullable ? typeof(float?) : typeof(float)); } else { leftOperand = Expression.Convert(leftOperand, promoteLeftToNullable ? typeof(float?) : typeof(float)); } } else if (leftTypeCode == TypeCode.UInt64) { var quality = 0.0f; var rightOperandTmp = rightOperand; var expectedRightType = promoteRightToNullable ? typeof(ulong?) : typeof(ulong); if (NumberUtils.IsSignedInteger(rightTypeCode) && TryMorphType(ref rightOperandTmp, expectedRightType, out quality) == false) { return(false); // will throw exception } rightOperand = rightOperandTmp; rightOperand = rightOperand.Type != expectedRightType?Expression.Convert(rightOperand, expectedRightType) : rightOperand; } else if (rightTypeCode == TypeCode.UInt64) { var quality = 0.0f; var leftOperandTmp = leftOperand; var expectedLeftType = promoteLeftToNullable ? typeof(ulong?) : typeof(ulong); if (NumberUtils.IsSignedInteger(leftTypeCode) && TryMorphType(ref leftOperandTmp, expectedLeftType, out quality) == false) { return(false); // will throw exception } leftOperand = leftOperandTmp; leftOperand = leftOperand.Type != expectedLeftType?Expression.Convert(leftOperand, expectedLeftType) : leftOperand; } else if (leftTypeCode == TypeCode.Int64 || rightTypeCode == TypeCode.Int64) { if (leftTypeCode == TypeCode.Int64) { rightOperand = Expression.Convert(rightOperand, promoteRightToNullable ? typeof(long?) : typeof(long)); } else { leftOperand = Expression.Convert(leftOperand, promoteLeftToNullable ? typeof(long?) : typeof(long)); } } else if ((leftTypeCode == TypeCode.UInt32 && NumberUtils.IsSignedInteger(rightTypeCode)) || (rightTypeCode == TypeCode.UInt32 && NumberUtils.IsSignedInteger(leftTypeCode))) { rightOperand = Expression.Convert(rightOperand, promoteRightToNullable ? typeof(long?) : typeof(long)); leftOperand = Expression.Convert(leftOperand, promoteLeftToNullable ? typeof(long?) : typeof(long)); } else if (leftTypeCode == TypeCode.UInt32 || rightTypeCode == TypeCode.UInt32) { if (leftTypeCode == TypeCode.UInt32) { rightOperand = Expression.Convert(rightOperand, promoteRightToNullable ? typeof(uint?) : typeof(uint)); } else { leftOperand = Expression.Convert(leftOperand, promoteLeftToNullable ? typeof(uint?) : typeof(uint)); } } else { rightOperand = Expression.Convert(rightOperand, promoteRightToNullable ? typeof(int?) : typeof(int)); leftOperand = Expression.Convert(leftOperand, promoteLeftToNullable ? typeof(int?) : typeof(int)); } if (promoteLeftToNullable) { leftOperand = ConvertToNullable(leftOperand, null); } if (promoteRightToNullable) { rightOperand = ConvertToNullable(rightOperand, null); } return(false); }
public static TypeDescription CreateTypeDescription(global::System.Collections.ObjectModel.ObservableCollection<string> types, NumberQualifiers numberQualifiers) { TypeDescription typeDescription = new TypeDescription(); if ((types == null)) { throw new global::System.ArgumentNullException("types"); } typeDescription.Types = types; if ((numberQualifiers == null)) { throw new global::System.ArgumentNullException("numberQualifiers"); } typeDescription.NumberQualifiers = numberQualifiers; return typeDescription; }
private TypeExpression(NRefactory.AstType astType, TypeDescription typeDescription, IScope scope, INRefcatoryExpressionVisitor visitor) : base(scope, visitor) { _astType = astType; _typeDescription = typeDescription; }
private static TypeDescription GetTypeDescription(MethodInfo method) { var propertySource = new MethodSource(method); var typeDescription = new TypeDescription(method.DeclaringType.FullName + "+" + method.Name, propertySource.GetProperties()); return typeDescription; }
// TODO: Provide a better way to check for array type public static bool IsStaticArray(this TypeDescription typeDescription) { var match = Regex.Match(typeDescription.TypeString, @".*\[\d+\]").Success; return(match); }
public void AddTypeDescription(Type type, TypeDescription description) { _typeDescriptor.AddDescription(type, description); }
private void CrawlRawObjectData(PackedMemorySnapshot packedMemorySnapshot, StartIndices startIndices, BytesAndOffset bytesAndOffset, TypeDescription typeDescription, bool useStaticFields, int indexOfFrom, List <Connection> out_connections, List <PackedManagedObject> out_managedObjects) { var fields = useStaticFields ? _staticFields[typeDescription.typeIndex] : _instanceFields[typeDescription.typeIndex]; foreach (var field in fields) { var fieldType = packedMemorySnapshot.typeDescriptions[field.typeIndex]; var fieldLocation = bytesAndOffset.Add(field.offset - (useStaticFields ? 0 : _virtualMachineInformation.objectHeaderSize)); if (fieldType.isValueType) { CrawlRawObjectData(packedMemorySnapshot, startIndices, fieldLocation, fieldType, false, indexOfFrom, out_connections, out_managedObjects); continue; } //temporary workaround for a bug in 5.3b4 and earlier where we would get literals returned as fields with offset 0. soon we'll be able to remove this code. bool gotException = false; try { fieldLocation.ReadPointer(); } catch (ArgumentException) { UnityEngine.Debug.LogWarningFormat("Skipping field {0} on type {1}", field.name, typeDescription.name); UnityEngine.Debug.LogWarningFormat("FieldType.name: {0}", fieldType.name); gotException = true; } if (!gotException) { CrawlPointer(packedMemorySnapshot, startIndices, fieldLocation.ReadPointer(), indexOfFrom, out_connections, out_managedObjects); } } }
private static bool TryPromoteEnumBinaryOperation(ref Expression leftOperand, TypeDescription leftType, ref Expression rightOperand, TypeDescription rightType, ExpressionType type, out Expression operation) { if (leftOperand == null) { throw new ArgumentNullException("leftOperand"); } if (leftType == null) { throw new ArgumentNullException("leftType"); } if (rightOperand == null) { throw new ArgumentNullException("rightOperand"); } if (rightType == null) { throw new ArgumentNullException("rightType"); } operation = null; var leftTypeUnwrap = leftType.IsNullable ? leftType.UnderlyingType : leftType; var rightTypeUnwrap = rightType.IsNullable ? rightType.UnderlyingType : rightType; var promoteToNullable = leftType.IsNullable != rightType.IsNullable; // enum + number if (leftTypeUnwrap.IsEnum && rightTypeUnwrap.IsNumber && (type == ExpressionType.Add || type == ExpressionType.AddChecked || type == ExpressionType.Subtract || type == ExpressionType.SubtractChecked)) { var integerType = leftTypeUnwrap.UnderlyingType; leftOperand = Expression.Convert(leftOperand, promoteToNullable ? integerType.GetNullableType() : integerType); if (promoteToNullable) { rightOperand = ConvertToNullable(rightOperand, leftType); } switch (type) { case ExpressionType.Add: operation = Expression.Add(leftOperand, rightOperand); break; case ExpressionType.AddChecked: operation = Expression.AddChecked(leftOperand, rightOperand); break; case ExpressionType.Subtract: operation = Expression.Subtract(leftOperand, rightOperand); break; case ExpressionType.SubtractChecked: operation = Expression.SubtractChecked(leftOperand, rightOperand); break; default: throw new InvalidOperationException("Only subtraction and addition with numbers are promoted."); } operation = Expression.Convert(operation, promoteToNullable ? leftTypeUnwrap.GetNullableType() : leftTypeUnwrap); return(true); } // number + enum else if (rightTypeUnwrap.IsEnum && leftTypeUnwrap.IsNumber && (type == ExpressionType.Add || type == ExpressionType.AddChecked || type == ExpressionType.Subtract || type == ExpressionType.SubtractChecked)) { var integerType = rightTypeUnwrap.UnderlyingType; rightOperand = Expression.ConvertChecked(rightOperand, promoteToNullable ? integerType.GetNullableType() : integerType); if (promoteToNullable) { leftOperand = ConvertToNullable(leftOperand, rightType); } operation = Expression.MakeBinary(type, leftOperand, rightOperand); operation = Expression.Convert(operation, promoteToNullable ? rightTypeUnwrap.GetNullableType() : rightTypeUnwrap); return(true); } // null + nullable-enum else if (IsNull(leftOperand) && rightType.CanBeNull) { leftType = rightType; leftOperand = rightType.DefaultExpression; } // nullable-enum + null else if (IsNull(rightOperand) && leftType.CanBeNull) { rightType = leftType; rightOperand = leftType.DefaultExpression; } // enum OP enum else if (rightTypeUnwrap == leftTypeUnwrap && (type == ExpressionType.And || type == ExpressionType.Or || type == ExpressionType.ExclusiveOr || type == ExpressionType.GreaterThan || type == ExpressionType.GreaterThanOrEqual || type == ExpressionType.LessThan || type == ExpressionType.LessThanOrEqual)) { var integerType = rightTypeUnwrap.UnderlyingType; rightOperand = Expression.ConvertChecked(rightOperand, promoteToNullable ? integerType.GetNullableType() : integerType); leftOperand = Expression.Convert(leftOperand, promoteToNullable ? integerType.GetNullableType() : integerType); operation = Expression.MakeBinary(type, leftOperand, rightOperand); return(true); } // [not]nullable + [not]nullable else if (promoteToNullable) { leftOperand = ConvertToNullable(leftOperand, leftType); if (type != ExpressionType.Coalesce) { rightOperand = ConvertToNullable(rightOperand, rightType); } } return(false); }
public static IReadOnlyList <TypeDescription> HandlersFor(this IEnumerable <TypeDescription> types, TypeDescription type) { var eventHandlers = types.EventHandlersFor(type); var commandHandler = types.CommandHandlerFor(type); if (commandHandler == null) { return(eventHandlers); } return(eventHandlers.Concat(new[] { commandHandler }).ToList()); }
private static TypeDescription GetTypeDescription(string typeName, IDictionary<string, Type> properties) { var propertySource = new DictionarySource(properties); var typeDescription = new TypeDescription(typeName, propertySource.GetProperties()); return typeDescription; }
private bool CanBeInstantiated(Type type) { TypeDescription description = _typeDescriptor.GetDescription(type); return(description.ctor != null); }
public void SetUp() { generator = new PocoEmitGenertor(); typeMapper = new DefaultTypeMapper(new Dictionary<ITypeDescription, IGeneratedType>()); typeDescription = new TypeDescription("Sample.Class", new List<IPropertyDescription>() { new PropertyDescription("Number", typeof(int)), new PropertyDescription("Text", typeof(string)) }); }
private static bool TryFindConversion(ref Expression expression, TypeDescription actualType, TypeDescription targetType, out float quality) { if (expression == null) { throw new ArgumentNullException("expression"); } if (actualType == null) { throw new ArgumentNullException("actualType"); } if (targetType == null) { throw new ArgumentNullException("targetType"); } quality = TypeConversion.QUALITY_NO_CONVERSION; var actualTypeUnwrap = actualType.IsNullable ? actualType.UnderlyingType : actualType; var targetTypeUnwrap = targetType.IsNullable ? targetType.UnderlyingType : targetType; // converting null to nullable-or-reference if (targetType.CanBeNull && IsNull(expression)) { expression = targetType.DefaultExpression; quality = TypeConversion.QUALITY_SAME_TYPE; // exact type (null) return(true); } // converting value to nullable value e.g. T to T? if (targetTypeUnwrap == actualType) { expression = Expression.Convert(expression, targetType); quality = TypeConversion.QUALITY_IN_PLACE_CONVERSION; return(true); } var conversion = default(TypeConversion); if (TypeConversion.TryGetTypeConversion(actualTypeUnwrap, targetTypeUnwrap, out conversion) == false || conversion.Quality <= TypeConversion.QUALITY_NO_CONVERSION) { return(false); } // implicit convertion on expectedType if (conversion.Implicit != null && conversion.Implicit.TryMakeConversion(expression, out expression, checkedConversion: true)) { quality = TypeConversion.QUALITY_IMPLICIT_CONVERSION; return(true); } expression = Expression.Convert(expression, targetType); quality = conversion.Quality; return(true); }
/// <summary> /// Инициализирует объект типа Teleform.Reporting.Type. /// </summary> /// <param name="name">Имя типа.</param> /// <param name="accessibleFormats">Коллекция поддерживаемых форматов.</param> /// <exception cref="ArgumentNullException">Значения параметра name или accessibleFormats суть null.</exception> /// <exception cref="ArgumentException">Параметр accessibleFormats представляет пустую коллекцию.</exception> public Type(string name, string runtimeType, IEnumerable <Format> accessibleFormats, IEnumerable <Operator> accessibleOperators, IEnumerable <AggregateFunction> accessibleAggregateFunctions, TypeDescription typeDescription, long minValue, long maxValue, string pattern, string patternDescription, Format defaultFormat, int?length, int?viewLength) { if (name == null) { throw new ArgumentNullException("name", "message is here"); } if (runtimeType == null) { throw new ArgumentNullException("clrType", string.Format("Для типа {0} не заполнено поле runTimeTypeID в таблице [Typing].[BusinessType]", name)); } if (accessibleFormats == null) { throw new ArgumentNullException("accessibleFormats", string.Format("Коллекция доступных форматов типа '{0}' не является допустимой.", name)); } if (accessibleFormats.Count() == 0) { throw new ArgumentException( string.Format("Коллекция доступных форматов типа '{0}' пуста.", name), "accessibleFormats"); } Description = typeDescription; //Numeric = Description.HasFlag(TypeDescription.Number); this.minValue = minValue; this.maxValue = maxValue; Pattern = pattern; PatternDescription = patternDescription; Length = length; ViewLength = viewLength; Name = name; RuntimeType = runtimeType; if (defaultFormat == null) { DefaultFormat = new Format(0, "General", "", "", null, "{0}", null); } else { DefaultFormat = defaultFormat; } this.accessibleFormats = new List <Format>(accessibleFormats); if (accessibleOperators != null) { this.accessibleOperators = accessibleOperators.OrderBy(o => o.Order).ToList(); } else { this.accessibleOperators = Enumerable.Empty <Operator>(); } if (accessibleAggregateFunctions != null) { this.accessibleAggregateFunctions = new List <AggregateFunction>(accessibleAggregateFunctions); } else { this.accessibleAggregateFunctions = Enumerable.Empty <AggregateFunction>(); } if (!types.Keys.Contains(name)) { types.Add(name, this); } }
private void BuildArray( DataType dataType, Type type, TypeDescription typeDescription, bool inputGraph, IEnumerable<Type> ancestors, MemberDescription memberDescription) { dataType.IsArray = true; dataType.Comments = memberDescription.WhenNotNull(x => x.Comments).OtherwiseDefault() ?? dataType.Comments; var itemType = BuildGraph(dataType, type.GetListElementType(), inputGraph, ancestors); dataType.ArrayItem = new ArrayItem { Name = memberDescription.WhenNotNull(x => x.ArrayItem.Name).OtherwiseDefault() ?? typeDescription.WhenNotNull(x => x.ArrayItem.Name).OtherwiseDefault() ?? itemType.Name, Comments = memberDescription.WhenNotNull(x => x.ArrayItem.Comments).OtherwiseDefault() ?? typeDescription.ArrayItem.WhenNotNull(x => x.Comments).OtherwiseDefault(), Type = itemType }; }
private DataSet MainDataBind(TypeDescription td) { DataSet ds = null; //кэш для различных мероприятий if (Cache["results"+ddEventList.SelectedValue+"_"+ddStatType.SelectedValue] == null) { SqlConnection conn = new SqlConnection(System.Configuration.ConfigurationSettings.AppSettings["DBConn"]); try { conn.Open(); SqlCommand cmd = new SqlCommand(); cmd.CommandType = CommandType.StoredProcedure; cmd.Connection = conn; cmd.CommandText = td.StProcName; if (!td.IsExtended) { cmd.Parameters.Add("@AId_Competition",Convert.ToInt32(ddEventList.SelectedValue)); } else { switch (td. ExtIdType) { case 1: cmd.Parameters.Add("@AId_Competition",Convert.ToInt32(ddEventList.SelectedValue)); cmd.Parameters.Add("@AID_UserPosition",td.ExtId); break; case 2: cmd.Parameters.Add("@AId_Competition",Convert.ToInt32(ddEventList.SelectedValue)); cmd.Parameters.Add("@AID_AntiUserPosition",td.ExtId); break; case 3: cmd.Parameters.Add("@AId_Competition",Convert.ToInt32(ddEventList.SelectedValue)); cmd.Parameters.Add("@AID_GameType",td.ExtId); break; } } SqlDataAdapter da = new SqlDataAdapter(cmd); ds = new DataSet(); da.Fill(ds); Cache.Insert("results"+ddEventList.SelectedValue+"_"+ddStatType.SelectedValue, ds, null, System.Web.Caching.Cache.NoAbsoluteExpiration, TimeSpan.FromMinutes(3)); } catch (Exception exc) { Response.Write(exc.Message); } finally { conn.Close(); } } else { ds = (DataSet)Cache["results"+ddEventList.SelectedValue+"_"+ddStatType.SelectedValue]; } return ds; }
public static string GetArgumentsAsTextWithEscaping(this MethodInterpreter interpreter, ClosureEntities closureEntities) { var method = interpreter.Method; var parameterInfos = method.GetParameters(); var escapingBools = method.BuildEscapingBools(closureEntities); var sb = new StringBuilder(); var index = 0; var analyze = interpreter.AnalyzeProperties; if (!method.IsStatic) { var parameterData = analyze.GetVariableData(new LocalVariable { VarName = "_this", Kind = VariableKind.Argument, Id = 0 }); if (parameterData != EscapingMode.Unused) { TypeDescription argumentTypeDescription = UsedTypeList.Set(method.DeclaringType.GetReversedMappedType(closureEntities) ?? method.DeclaringType.GetMappedType(closureEntities), closureEntities); var thisText = String.Format("const {0}& _this", argumentTypeDescription.GetClrType(closureEntities).ToCppName()); // all "_this" should be smart pointers //For some reason at three Virtual Test 4 fails this, is something wrong with the escaping ? // if ((!escapingBools[0])) // { // thisText = String.Format("{0} _this", // argumentTypeDescription.ClrType.ToCppName(true, EscapingMode.Pointer)); // } sb.Append(thisText); index++; } } var isFirst = index == 0; for (index = 0; index < parameterInfos.Length; index++) { var parameterInfo = parameterInfos[index]; var parameterData = analyze.GetVariableData(new LocalVariable() { Kind = VariableKind.Argument, VarName = parameterInfo.Name }); if (parameterData == EscapingMode.Unused) { continue; } if (isFirst) { isFirst = false; } else { sb.Append(", "); } var isSmartPtr = escapingBools[index]; var nonEscapingMode = isSmartPtr ? EscapingMode.Smart : EscapingMode.Pointer; var parameterType = parameterInfo.ParameterType.GetReversedMappedType(closureEntities); var argumentTypeDescription = UsedTypeList.Set(parameterType, closureEntities); sb.AppendFormat("{0} {1}", argumentTypeDescription.GetClrType(closureEntities).ToCppName(nonEscapingMode, isPInvoke: method.IsPinvoke()), //Handle byref parameterInfo.Name); } return(sb.ToString()); }
/// <summary> /// Returns the types with a method handling <paramref name="type"/> as an event. /// </summary> public static IReadOnlyList <TypeDescription> EventHandlersFor(this IEnumerable <TypeDescription> types, TypeDescription type) { return(types .Where(t => t.IsClass() && t.ImplementsType("Pitstop.Infrastructure.Messaging.IMessageHandlerCallback")) .Where(t => t.Methods.Any(m => m.Name == "HandleAsync" && m.Parameters.Any(p => p.Type.EndsWith("." + type.Name, StringComparison.Ordinal)))) .ToList()); }
/// <summary> /// Create from a <see cref="TypeDescription" /> /// </summary> /// <param name="typeDescription"></param> public QueryBuilder(TypeDescription typeDescription) { _typeDescription = typeDescription ?? throw new ArgumentNullException(nameof(typeDescription)); }
public static IReadOnlyList <TypeDescription> GetSourceCommands(this IEnumerable <TypeDescription> types, TypeDescription type) { var commands = from t in types from m in t.Methods from s in m.Statements from i in FlattenStatements(s).OfType <InvocationDescription>() where i.ContainingType.EndsWith(type.Name) && i.Name == type.Name select types.First(i.ContainingType); return(commands.ToList()); }