public ValueCalculatorFactory(ITypeConverter typeConverter) { if (typeConverter == null) throw new ArgumentNullException("typeConverter"); _typeConverter = typeConverter; }
/// <summary> /// Initializes a new instance of the <see cref="FileFieldMapping"/> class. /// </summary> /// <param name="property"> /// The property. /// </param> /// <param name="nameExpression"> /// The name expression. /// </param> /// <param name="contentExpression"> /// The content expression. /// </param> /// <param name="locationExpression"> /// The location expression. /// </param> /// <param name="typeConverter"> /// The type converter. /// </param> /// <param name="fileManager"> /// The file manager. /// </param> public FileFieldMapping( PropertyInfo property, MappingExpression nameExpression, MappingExpression contentExpression, MappingExpression locationExpression, ITypeConverter typeConverter, IFileManager fileManager) { if (property == null) throw new ArgumentNullException("property"); if (!typeof(IFileProcess).IsAssignableFrom(property.PropertyType)) throw new ArgumentException("The specified property is not a file field."); if (typeConverter == null) throw new ArgumentNullException("typeConverter"); if (fileManager == null) throw new ArgumentNullException("fileManager"); _property = property; _nameExpression = nameExpression; _contentExpression = contentExpression; _locationExpression = locationExpression; _typeConverter = typeConverter; _fileManager = fileManager; }
protected override void Init() { converter = Kernel.GetConversionManager(); Kernel.ComponentModelBuilder.AddContributor(new StartableContributor(converter)); InitFlag(flag ?? new LegacyStartFlag(), new StartableEvents(Kernel)); }
public static IDictionary<string, object> FormatParameters( IList<CommandActionParameter> source, IList<ParameterDescription> description, ITypeConverter converter) { // Determine parameter values Dictionary<string, object> result = new Dictionary<string, object>(); foreach (CommandActionParameter param in source) { string name = param.Name; object value = param.Value; // Find the description of the parameter ParameterDescription expectedParam = description.FirstOrDefault(p => p.Name == name); // Custom conversion value = converter.ConvertClrObject(value, expectedParam.Type); result.Add(name, value); } return result; }
protected override void Init() { converter = (ITypeConverter) Kernel.GetSubSystem(SubSystemConstants.ConversionManagerKey); Kernel.ComponentModelCreated +=OnComponentModelCreated; Kernel.ComponentRegistered +=OnComponentRegistered; }
protected virtual void AddFactories(IConfiguration facilityConfig, ITypeConverter converter) { if (facilityConfig != null) { foreach(IConfiguration config in facilityConfig.Children["factories"].Children) { String id = config.Attributes["id"]; String creation = config.Attributes["creation"]; String destruction = config.Attributes["destruction"]; Type factoryType = (Type) converter.PerformConversion( config.Attributes["interface"], typeof(Type) ); try { AddTypedFactoryEntry( new FactoryEntry(id, factoryType, creation, destruction) ); } catch(Exception) { string message = "Invalid factory entry in configuration"; throw new ConfigurationErrorsException(message); } } } }
public ValueBuilder(CultureInfo cultureInfo, ITypeConverter typeConverter) { // register custom BooleanTypeConverter, this might be a bad idea. TypeConverterAttribute converterAttribute = new TypeConverterAttribute(typeof(CustomBooleanConverter)); _typeDescriptorProvider = TypeDescriptor.AddAttributes(typeof(Boolean), converterAttribute); this._typeConverter = typeConverter; this._culture = cultureInfo; this._errorCollector = null; this._targetType = new Stack<Type>(); this._errorHandlers = new Stack<EventHandler<ErrorEventArg>>(); this.ResolveInterfaceType += (sender, args) => { if (args.RealType != null) return; if (typeof(IEnumerable) == args.InterfaceType) args.RealType = typeof(List<object>); else { Type[] genArgs; if (args.InterfaceType.IsOfGenericType(typeof(IEnumerable<>), out genArgs)) args.RealType = typeof(List<>).MakeGenericType(genArgs); if (args.InterfaceType.IsOfGenericType(typeof(IList<>), out genArgs)) args.RealType = typeof(List<>).MakeGenericType(genArgs); else if (args.InterfaceType.IsOfGenericType(typeof(IDictionary<,>), out genArgs)) args.RealType = typeof(Dictionary<,>).MakeGenericType(genArgs); else if (args.InterfaceType.IsOfGenericType(typeof(ILookup<,>), out genArgs)) args.RealType = typeof(Lookup<,>).MakeGenericType(genArgs); } }; }
/// <summary> /// Initializes a new instance of the <see cref="SingleCrossReferenceFieldMapping"/> class. /// </summary> /// <param name="property"> /// The property. /// </param> /// <param name="valueExpression"> /// The value expression. /// </param> /// <param name="isKey"> /// Specifies whether this is a key mapping. /// </param> /// <param name="typeConverter"> /// The type converter. /// </param> /// <param name="dynamicTypeManager"> /// The dynamic type manager. /// </param> /// <param name="runtimeDatabase"> /// The runtime database. /// </param> /// <param name="childMappings"> /// The child mappings. /// </param> public SingleCrossReferenceFieldMapping( PropertyInfo property, MappingExpression valueExpression, bool isKey, ITypeConverter typeConverter, IDynamicTypeManager dynamicTypeManager, IRuntimeDatabase runtimeDatabase, IEnumerable<IProcessFieldMapping> childMappings) { if (property == null) throw new ArgumentNullException("property"); var crAttribute = property.GetCustomAttribute<CrossRefFieldAttribute>(); if (crAttribute == null || crAttribute.AllowMultiple || !typeof(int?).IsAssignableFrom(property.PropertyType)) throw new ArgumentException("The specified property is not a single cross reference field."); if (typeConverter == null) throw new ArgumentNullException("typeConverter"); if (dynamicTypeManager == null) throw new ArgumentNullException("dynamicTypeManager"); if (runtimeDatabase == null) throw new ArgumentNullException("runtimeDatabase"); _property = property; _valueExpression = valueExpression; _isKey = isKey; _typeConverter = typeConverter; _dynamicTypeManager = dynamicTypeManager; _runtimeDatabase = runtimeDatabase; _childMappings = (childMappings ?? Enumerable.Empty<IProcessFieldMapping>()).ToArray(); _referencedProcessName = crAttribute.ReferenceTableName; }
public DbContainer(DbContainerParameters parameters) { this.parameters = parameters; this.logger = new Logger(); this.transformCache = new ConcurrentDictionary<string, IStoredProcedure>(); this.converter = new DefaultTypeConverter(); }
public static ITypeConverter Combine(ICustomAttributeProvider attributeProvider, ITypeConverter typeConverter) { var results = GetTypeConverters(attributeProvider); if (!results.Any()) return typeConverter; else return new CombinedTypeConverter(results.Concat(new[] { typeConverter }).ToArray()); }
public bool TryConvertTo(ITypeConverter root, TypeConversionContext context, Type convertTo, object value, out object result) { if ((Context & context) == context) { return Converter.TryConvertTo(root, context, convertTo, value, out result); } result = null; return false; }
/// <summary> /// Initializes a new instance of the <see cref="T:System.Object"/> class. /// </summary> public CollectionConverterFixture() { this.converter = new CollectionConverter(); this.context = new BindingContext() { TypeConverters = new[] { new FallbackConverter() } }; this.mockStringTypeConverter = A.Fake<ITypeConverter>(); A.CallTo(() => mockStringTypeConverter.CanConvertTo(null, null)).WithAnyArguments().Returns(true); A.CallTo(() => mockStringTypeConverter.Convert(null, null, null)).WithAnyArguments().Returns(string.Empty); }
public bool TryConvertTo(ITypeConverter root, TypeConversionContext context, Type convertTo, object value, out object result) { if (convertTo == typeof(string[]) && (value?.GetType().IsArray ?? false)) { result = new[] { string.Join(",", ((Array)value).Cast<object>().Select(x => root.ConvertTo<string>(context, x))) }; return true; } result = null; return false; }
public void AddConverter(ITypeConverter converter, int? index = null) { using (_lock.EnterWriteScope()) { if (index != null) _converters.Insert(index.Value, converter); else _converters.Add(converter); } }
public NullableConverter(Type type) { this.nullableType = type; this.simpleType = Nullable.GetUnderlyingType(type); if (this.simpleType == null) { throw new ArgumentException(TC.NullableConverterBadCtorArg, "type"); } this.simpleTypeConverter = TypeConverterRegistry.GetConverter(this.simpleType); }
/// <summary> /// Initializes a new instance of the <see cref = "RemotingInspector" /> class. /// </summary> /// <param name = "converter">The converter.</param> /// <param name = "isServer">if set to <c>true</c> is a server.</param> /// <param name = "isClient">if set to <c>true</c> is a client.</param> /// <param name = "baseUri">The base URI.</param> /// <param name = "remoteRegistry">The remote registry.</param> /// <param name = "localRegistry">The local registry.</param> public RemotingInspector(ITypeConverter converter, bool isServer, bool isClient, String baseUri, RemotingRegistry remoteRegistry, RemotingRegistry localRegistry) { this.converter = converter; this.isServer = isServer; this.isClient = isClient; this.baseUri = baseUri; this.remoteRegistry = remoteRegistry; this.localRegistry = localRegistry; }
public XmlSerializableDeserializerSelector(ICompositeObjectContextFactory objectContextFactory, ITypeConverter typeConverter) { if (objectContextFactory == null) throw new ArgumentNullException("objectContextFactory"); if (typeConverter == null) throw new ArgumentNullException("typeConverter"); _deserializer = new XmlSerializableDeserializer(objectContextFactory, typeConverter); _typeConverter = typeConverter; }
public bool TryConvertTo(ITypeConverter root, TypeConversionContext context, Type convertTo, object value, out object result) { if (convertTo.IsInstanceOfType(value)) { result = value; return true; } result = null; return false; }
public bool TryConvertTo(ITypeConverter root, TypeConversionContext context, Type convertTo, object value, out object result) { foreach (var typeConverter in typeConverters) { if (typeConverter.TryConvertTo(root, context, convertTo, value, out result)) return true; } result = null; return false; }
public NullableConverter(Type type) { this.nullableType = type; this.simpleType = Nullable.GetUnderlyingType(type); if (this.simpleType == null) { throw new ArgumentException("The specified type is not a nullable type.", "type"); } this.simpleTypeConverter = TypeConverterRegistry.GetConverter(this.simpleType); }
public CanonicalFunctionMapper(ITypeConverter converter) { this.converter = new EdmTypeConverter(converter); this.mappings = new Dictionary<string, Func<EdmFunction, Expression[], Expression>>(); this.AddStringMappings(); this.AddDateTimeMappings(); this.AddMathMappings(); this.AddBitwiseMappings(); this.AddMiscMappings(); }
/// <summary> /// Creates a new <see cref="NullableConverter"/> for the given <see cref="Nullable{T}"/> <see cref="Type"/>. /// </summary> /// <param name="type">The nullable type.</param> /// <exception cref="System.ArgumentException">type is not a nullable type.</exception> public NullableConverter( Type type ) { NullableType = type; UnderlyingType = Nullable.GetUnderlyingType( type ); if( UnderlyingType == null ) { throw new ArgumentException( "type is not a nullable type." ); } UnderlyingTypeConverter = TypeConverterFactory.GetConverter( UnderlyingType ); }
public void Add(ITypeConverter converter) { converter.Context = this; converters.Add(converter); if (!(converter is IKernelDependentConverter)) { standAloneConverters.Add(converter); } }
public object GetField(string name, object ifNull, ITypeConverter converter) { var v = GetField(name, converter); if (v == null || v == DBNull.Value) { return ifNull; } else { return v; } }
/// <summary> /// Initializes a new instance of the <see cref="SimpleValueCalculator"/> class. /// </summary> /// <param name="valueExpression"> /// The value expression. /// </param> /// <param name="valueType"> /// The value type. /// </param> /// <param name="typeConverter"> /// The type converter. /// </param> public SimpleValueCalculator(MappingExpression valueExpression, Type valueType, ITypeConverter typeConverter) { if (valueType == null) throw new ArgumentNullException("valueType"); if (typeConverter == null) throw new ArgumentNullException("typeConverter"); _valueExpression = valueExpression; _valueType = valueType; _typeConverter = typeConverter; }
protected override void Init() { converter = (ITypeConverter)Kernel.GetSubSystem(SubSystemConstants.ConversionManagerKey); Kernel.ComponentModelBuilder.AddContributor(new StartableContributor(converter)); if(optimizeForSingleInstall) { Kernel.HandlersChanged += StartAll; Kernel.ComponentRegistered += CacheForStart; return; } Kernel.ComponentRegistered +=OnComponentRegistered; }
protected override void Init() { converter = Kernel.GetConversionManager(); Kernel.ComponentModelBuilder.AddContributor(new StartableContributor(converter)); if (optimizeForSingleInstall) { Kernel.RegistrationCompleted += StartAll; Kernel.ComponentRegistered += CacheForStart; return; } Kernel.ComponentRegistered += OnComponentRegistered; }
public DataContextChangeSynchronizer(BindingSource bindingSource, BindingTarget bindingTarget, ITypeConverterProvider typeConverterProvider) { _bindingTarget = bindingTarget; Guard.ThrowIfNull(bindingTarget.Object, nameof(bindingTarget.Object)); Guard.ThrowIfNull(bindingTarget.Property, nameof(bindingTarget.Property)); Guard.ThrowIfNull(bindingSource.SourcePropertyPath, nameof(bindingSource.SourcePropertyPath)); Guard.ThrowIfNull(bindingSource.Source, nameof(bindingSource.Source)); Guard.ThrowIfNull(typeConverterProvider, nameof(typeConverterProvider)); _bindingEndpoint = new TargetBindingEndpoint(bindingTarget.Object, bindingTarget.Property); _sourceEndpoint = new ObservablePropertyBranch(bindingSource.Source, bindingSource.SourcePropertyPath); _targetPropertyTypeConverter = typeConverterProvider.GetTypeConverter(bindingTarget.Property.PropertyType); }
public bool TryConvertTo(ITypeConverter root, TypeConversionContext context, Type convertTo, object obj, out object result) { try { result = Convert.ChangeType(obj, convertTo); return true; } catch (Exception) { result = null; return false; } }
/// <summary> /// Initializes a new instance of the <see cref="ArrayValueCalculator"/> class. /// </summary> /// <param name="elementType"> /// The element type. /// </param> /// <param name="valueExpression"> /// The value expression. /// </param> /// <param name="elementCalculator"> /// The element calculator. /// </param> /// <param name="typeConverter"> /// The type converter. /// </param> public ArrayValueCalculator(Type elementType, MappingExpression valueExpression, IValueCalculator elementCalculator, ITypeConverter typeConverter) { if (elementType == null) throw new ArgumentNullException("elementType"); if (typeConverter == null) throw new ArgumentNullException("typeConverter"); _typeConverter = typeConverter; _elementType = elementType; _valueExpression = valueExpression; _elementCalculator = elementCalculator; }
private void SetUpTypeConverter() { converter = Kernel.GetSubSystem(SubSystemConstants.ConversionManagerKey) as IConversionManager; }
/// <summary> /// Specifies the <see cref="TypeConverter"/> to use /// when converting the property to and from a CSV field. /// </summary> /// <param name="typeConverter">The TypeConverter to use.</param> public virtual CsvPropertyMap TypeConverter(ITypeConverter typeConverter) { Data.TypeConverter = typeConverter; return(this); }
/// <summary> /// Gets the type of this type instance using the specified type converter. /// </summary> /// <param name="typeConverter">The type converter interface.</param> public override Type GetType(ITypeConverter typeConverter) { return(typeConverter.GetType(UserType)); }
public OperatorSetBuilder <TToken> TypeConverter <TSelf>(Action <ITypeConverter> configureConverter) { _converter = new CustomTypeConverter <TSelf>(); configureConverter(_converter); return(this); }
public static void ConfigureConverters(ITypeConverter obj) { obj.Register((object o, out long r) => CoreConverters.TryHexConvert("&H", obj, o, out r) || obj.TryCoreConvert(o, out r)) .Register((object o, out int r) => CoreConverters.TryHexConvert("&H", obj, o, out r) || obj.TryCoreConvert(o, out r)); }
/// <summary> /// Specifies the <see cref="TypeConverter"/> to use /// when converting the member to and from a CSV field. /// </summary> /// <param name="typeConverter">The TypeConverter to use.</param> public virtual MemberMap TypeConverter(ITypeConverter typeConverter) { Data.TypeConverter = typeConverter; return(this); }
internal ValuesPopulator(ITypePropertiesExtractor typePropertiesExtractor, ITypeConverter typeConverter) { _typePropertiesExtractor = typePropertiesExtractor; _typeConverter = typeConverter; }
public DictionaryToObjectConverter(ITypeConverter converter) { _converter = converter ?? throw new ArgumentNullException(nameof(converter)); }
public static object ConvertTo(this ITypeConverter converter, object value, Type to) { return(converter.ConvertTo(CultureInfo.InvariantCulture, null, value, to)); }
public static object ConvertFrom(this ITypeConverter converter, object value) { return(converter.ConvertFrom(CultureInfo.InvariantCulture, value)); }
public QueryableComparableNotEqualsHandler( ITypeConverter typeConverter, InputParser inputParser) : base(typeConverter, inputParser) { }
public TypeConverterPropertyInitializerFactory(ITypeConverter <TProperty, TInputProperty> converter) { _converter = converter; }
public bool IsPropertyTypeConverter <T>(out ITypeConverter <TProperty, T> typeConverter) { typeConverter = _converter as ITypeConverter <TProperty, T>; return(typeConverter != null); }
/// <summary> /// Sets a <see cref="ITypeConverter"/> instance to use when converting CLR types /// </summary> public Options SetTypeConverter(ITypeConverter typeConverter) { _typeConverter = typeConverter; return(this); }
private static bool HasStatelessAttributeSet(ComponentModel model, ITypeConverter converter) { return(Helpers.IsFlag(model, converter, FacilityConstants.StatelessServiceKey)); }
public FallbackConverterFixture() { this.converter = new FallbackConverter(); }
public Parser(ITypeConverter typeConverter) { _typeConverter = typeConverter; }
public CastingConverter(ITypeConverter <object> inner) { _inner = inner; }
public CsvPropertyMapping(Expression <Func <TEntity, TProperty> > property, ITypeConverter <TProperty> typeConverter) { propertyConverter = typeConverter; propertyName = ReflectionUtils.GetPropertyNameFromExpression(property); propertySetter = ReflectionUtils.CreateSetter <TEntity, TProperty>(property); }
public void RegisterTypeConverter(Type type, ITypeConverter converter) { _typeConverters.Add(type, new TypeConverterRegistration(type, converter)); }
/// <summary> /// Create a new method expression. /// The expression must be an lvalue expression or literal text. /// The expected return type may be <code>null</code>, meaning "don't care". /// If it is an lvalue expression, the parameter types must not be <code>null</code>. /// If it is literal text, the expected return type must not be <code>void</code>. </summary> /// <param name="store"> used to get the parse tree from. </param> /// <param name="functions"> the function mapper used to bind functions </param> /// <param name="variables"> the variable mapper used to bind variables </param> /// <param name="expr"> the expression string </param> /// <param name="returnType"> the expected return type (may be <code>null</code>) </param> /// <param name="paramTypes"> the expected parameter types (must not be <code>null</code> for lvalues) </param> public TreeMethodExpression(TreeStore store, FunctionMapper functions, VariableMapper variables, ITypeConverter converter, string expr, Type returnType, Type[] paramTypes) : base() { Tree tree = store.Get(expr); this.builder = store.Builder; this.bindings = tree.Bind(functions, variables, converter); this.expr = expr; this.type = returnType; this.types = paramTypes; this.node = tree.Root; this.deferred = tree.Deferred; if (node.LiteralText) { if (returnType == typeof(void)) { throw new ELException(LocalMessages.Get("error.method.literal.void", expr)); } } else if (!node.MethodInvocation) { if (!node.LeftValue) { throw new ELException(LocalMessages.Get("error.method.invalid", expr)); } if (paramTypes == null) { throw new ELException(LocalMessages.Get("error.method.notypes")); } } }
public bool TryGetField <T>(string name, int index, ITypeConverter converter, out T field) { throw new NotImplementedException(); }
/// <summary> /// Gets the type of this type instance using the specified type converter. /// </summary> /// <param name="typeConverter">The type converter interface.</param> public override Type GetType(ITypeConverter typeConverter) { return(IsVariable ? typeof(Variable) : typeof(UserType)); }
public bool TryGetField(Type type, string name, int index, ITypeConverter converter, out object field) { throw new NotImplementedException(); }
public static ITypeConverter Add(this ITypeConverter current, ITypeConverter register) { return(new CompositeConverter(current, register)); }
public T GetField <T>(string name, int index, ITypeConverter converter) { throw new NotImplementedException(); }
public object GetField(Type type, string name, int index, ITypeConverter converter) { throw new NotImplementedException(); }
public QueryableEnumNotInHandler( ITypeConverter typeConverter) : base(typeConverter) { }
public static void RegisterConverter <T>(ITypeConverter typeConverter) { RegisterConverter(typeof(T), typeConverter); }
public static ITypeConverter RemoveConverter <T>(ITypeConverter typeConverter) { return(RemoveConverter(typeof(T))); }