private static Type FindInterfaceImplementation( IDictionary <string, Object> properties, Type topClass, EngineImportService engineImportService) { var message = "Failed to find implementation for interface " + Name.Clean(topClass); // Allow to populate the special "class" field if (!properties.ContainsKey(CLASS_PROPERTY_NAME)) { throw new ExprValidationException( message + ", for interfaces please specified the '" + CLASS_PROPERTY_NAME + "' field that provides the class name either as a simple class name or fully qualified"); } Type clazz = null; var className = (string)properties.Get(CLASS_PROPERTY_NAME); try { clazz = TypeHelper.GetClassForName(className, engineImportService.GetClassForNameProvider()); } catch (TypeLoadException) { if (!className.Contains(".")) { className = topClass.Namespace + "." + className; try { clazz = TypeHelper.GetClassForName(className, engineImportService.GetClassForNameProvider()); } catch (TypeLoadException) { } } if (clazz == null) { throw new ExprValidationPropertyException(message + ", could not find class by name '" + className + "'"); } } if (!TypeHelper.IsSubclassOrImplementsInterface(clazz, topClass)) { throw new ExprValidationException( message + ", class " + clazz.GetCleanName() + " does not implement the interface"); } return(clazz); }
private ICollection <Type> GetClassSet(string[] classIdentifiers, EngineImportService engineImportService) { var classList = new HashSet <Type>(); foreach (String className in classIdentifiers) { // try the primitive names including "string" var clazz = TypeHelper.GetPrimitiveTypeForName(className.Trim()); if (clazz != null) { classList.Add(clazz); classList.Add(clazz.GetBoxedType()); continue; } // try to look up the class, not a primitive type name try { clazz = TypeHelper.GetClassForName(className.Trim(), engineImportService.GetClassForNameProvider()); } catch (TypeLoadException e) { throw new ExprValidationException("Class as listed in is function by name '" + className + "' cannot be loaded", e); } // Add primitive and boxed types, or type itself if not built-in classList.Add(clazz.GetPrimitiveType()); classList.Add(clazz.GetBoxedType()); } return(classList); }
public void Init(ConfigurationEngineDefaults.AvroSettings avroSettings, EngineImportService engineImportService) { _avroSettings = avroSettings; if (avroSettings.TypeRepresentationMapperClass != null) { _optionalTypeMapper = TypeHelper.Instantiate <TypeRepresentationMapper>( avroSettings.TypeRepresentationMapperClass, engineImportService.GetClassForNameProvider()); } if (avroSettings.ObjectValueTypeWidenerFactoryClass != null) { _optionalWidenerFactory = TypeHelper.Instantiate <ObjectValueTypeWidenerFactory>( avroSettings.ObjectValueTypeWidenerFactoryClass, engineImportService.GetClassForNameProvider()); } }
public void AddEventType(string eventTypeName, Properties typeMap) { CheckTableExists(eventTypeName); IDictionary <string, Object> types = TypeHelper.GetClassObjectFromPropertyTypeNames( typeMap, _engineImportService.GetClassForNameProvider()); try { _eventAdapterService.AddNestableMapType(eventTypeName, types, null, false, true, true, false, false); } catch (EventAdapterException t) { throw new ConfigurationException(t.Message, t); } }
private void HandleAddPluggableObject( String factoryClassName, String @namespace, String name, PluggableObjectType type, Object optionalCustomConfig, EngineImportService engineImportService) { if (factoryClassName == null) { throw new ConfigurationException("Factory class name has not been supplied for object '" + name + "'"); } if (@namespace == null) { throw new ConfigurationException("Namespace name has not been supplied for object '" + name + "'"); } if (name == null) { throw new ConfigurationException("Name has not been supplied for object in namespace '" + @namespace + "'"); } try { var clazz = engineImportService.GetClassForNameProvider().ClassForName(factoryClassName); var namespaceMap = Pluggables.Get(@namespace); if (namespaceMap == null) { namespaceMap = new Dictionary <String, Pair <Type, PluggableObjectEntry> >(); Pluggables.Put(@namespace, namespaceMap); } namespaceMap.Put( name, new Pair <Type, PluggableObjectEntry>(clazz, new PluggableObjectEntry(type, optionalCustomConfig))); } catch (TypeLoadException e) { throw new ConfigurationException("View factory class " + factoryClassName + " could not be loaded", e); } }
internal static ExceptionHandlingService InitExceptionHandling( string engineURI, ConfigurationEngineDefaults.ExceptionHandlingConfig exceptionHandling, ConfigurationEngineDefaults.ConditionHandlingConfig conditionHandling, EngineImportService engineImportService) { IList <ExceptionHandler> exceptionHandlers; if (exceptionHandling.HandlerFactories == null || exceptionHandling.HandlerFactories.IsEmpty()) { exceptionHandlers = Collections.GetEmptyList <ExceptionHandler>(); } else { exceptionHandlers = new List <ExceptionHandler>(); var context = new ExceptionHandlerFactoryContext(engineURI); foreach (var className in exceptionHandling.HandlerFactories) { try { var factory = TypeHelper.Instantiate <ExceptionHandlerFactory>( className, engineImportService.GetClassForNameProvider()); var handler = factory.GetHandler(context); if (handler == null) { Log.Warn( "Exception handler factory '" + className + "' returned a null handler, skipping factory"); continue; } exceptionHandlers.Add(handler); } catch (Exception ex) { throw new ConfigurationException( "Exception initializing exception handler from exception handler factory '" + className + "': " + ex.Message, ex); } } } IList <ConditionHandler> conditionHandlers; if (conditionHandling.HandlerFactories == null || conditionHandling.HandlerFactories.IsEmpty()) { conditionHandlers = Collections.GetEmptyList <ConditionHandler>(); } else { conditionHandlers = new List <ConditionHandler>(); var context = new ConditionHandlerFactoryContext(engineURI); foreach (var className in conditionHandling.HandlerFactories) { try { var factory = TypeHelper.Instantiate <ConditionHandlerFactory>( className, engineImportService.GetClassForNameProvider()); var handler = factory.GetHandler(context); if (handler == null) { Log.Warn( "Condition handler factory '" + className + "' returned a null handler, skipping factory"); continue; } conditionHandlers.Add(handler); } catch (Exception ex) { throw new ConfigurationException( "Exception initializing exception handler from exception handler factory '" + className + "': " + ex.Message, ex); } } } return(new ExceptionHandlingService( engineURI, exceptionHandlers, conditionHandlers)); }
public static ExprNode TryResolveAsAggregation( EngineImportService engineImportService, bool distinct, string functionName, LazyAllocatedMap <ConfigurationPlugInAggregationMultiFunction, PlugInAggregationMultiFunctionFactory> plugInAggregations, string engineURI) { try { AggregationFunctionFactory aggregationFactory = engineImportService.ResolveAggregationFactory(functionName); return(new ExprPlugInAggNode(distinct, aggregationFactory, functionName)); } catch (EngineImportUndefinedException) { // Not an aggregation function } catch (EngineImportException e) { throw new IllegalStateException("Error resolving aggregation: " + e.Message, e); } // try plug-in aggregation multi-function ConfigurationPlugInAggregationMultiFunction config = engineImportService.ResolveAggregationMultiFunction(functionName); if (config != null) { PlugInAggregationMultiFunctionFactory factory = plugInAggregations.Map.Get(config); if (factory == null) { factory = TypeHelper.Instantiate <PlugInAggregationMultiFunctionFactory>(config.MultiFunctionFactoryClassName, engineImportService.GetClassForNameProvider()); plugInAggregations.Map.Put(config, factory); } factory.AddAggregationFunction( new PlugInAggregationMultiFunctionDeclarationContext( functionName.ToLowerInvariant(), distinct, engineURI, config)); return(new ExprPlugInAggMultiFunctionNode(distinct, config, factory, functionName)); } // try built-in expanded set of aggregation functions return(engineImportService.ResolveAggExtendedBuiltin(functionName, distinct)); }