/// <summary> /// Creates the capsule. /// </summary> /// <param name="name">The name.</param> /// <param name="fields">The fields.</param> /// <returns></returns> public static FastClass CreateCapsule(String name, params CapsuleField[] fields) { ModuleBuilder moduleBuilder = GetModuleBuilder(); TypeBuilder typeBuilder = moduleBuilder.DefineType( name, TypeAttributes.Public | TypeAttributes.Class | TypeAttributes.AutoClass | TypeAttributes.AnsiClass | TypeAttributes.BeforeFieldInit | TypeAttributes.AutoLayout, typeof(object)); foreach (CapsuleField field in fields) { typeBuilder.DefineField( field.Name, field.Type, FieldAttributes.Public); } #if NETFULL return(FastClass.Create(typeBuilder.CreateType())); #elif NETSTANDARD return(FastClass.Create(typeBuilder.CreateTypeInfo().AsType())); #else #error "building unknown version of codebase" #endif }
/// <summary> /// Ctor. /// </summary> /// <param name="statement">the statement.</param> /// <param name="subscriber">is the receiver to method invocations</param> /// <param name="method">is the method to deliver to</param> /// <param name="componentType">Type of the component.</param> /// <param name="engineImportService">The engine import service.</param> public ResultDeliveryStrategyTypeArr(EPStatement statement, Object subscriber, MethodInfo method, Type componentType, EngineImportService engineImportService) { _statement = statement; _subscriber = subscriber; _fastMethod = FastClass.CreateMethod(method); _componentType = componentType; }
/// <summary> /// Static constructor /// </summary> static AssertProxy() { AssertFail = message => System.Diagnostics.Debug.Assert(true, message); // See if NUnit is loaded into the domain. If it is, then by default, we will switch to using it. // Remember, you can change whatever you'd like about how the AssertProxy class works by simply // changing the AssertFail property. var appDomain = AppDomain.CurrentDomain; var assemblies = appDomain.GetAssemblies(); var appTypes = assemblies.SelectMany(assembly => assembly.GetTypes()).ToArray(); var nunitAssertionType = TypeHelper.ResolveType("NUnit.Framework.Assert", false); if (nunitAssertionType != null) { var asFastClass = FastClass.Create(nunitAssertionType); if (asFastClass != null) { var asFastMethod = asFastClass.GetMethod("Fail", new Type[] { typeof(string) }); if (asFastMethod != null) { AssertFail = message => asFastMethod.InvokeStatic(message); } } } }
private ArrayFastPropertyGetter MakeGetter(int index) { FastClass fastClass = FastClass.Create(typeof(SupportBeanComplexProps)); FastMethod method = fastClass.GetMethod("GetArrayProperty", new Type[0]); return(new ArrayFastPropertyGetter(method, index, SupportEventAdapterService.Service)); }
private KeyedFastPropertyGetter MakeGetterTwo(String key) { FastClass fastClassTwo = FastClass.Create(typeof(SupportBeanCombinedProps.NestedLevOne)); FastMethod methodTwo = fastClassTwo.GetMethod("GetMapped", new[] { typeof(string) }); return(new KeyedFastPropertyGetter(methodTwo, key, SupportEventAdapterService.Service)); }
private KeyedFastPropertyGetter MakeGetterOne(int index) { FastClass fastClassOne = FastClass.Create(typeof(SupportBeanCombinedProps)); FastMethod methodOne = fastClassOne.GetMethod("GetIndexed", new[] { typeof(int) }); return(new KeyedFastPropertyGetter(methodOne, index, _container.Resolve <EventAdapterService>())); }
/// <summary> /// Constructs a wrapper around the target constructor. /// </summary> /// <param name="_fastClass">The _fast class.</param> /// <param name="constructor">The constructor.</param> internal FastConstructor(FastClass _fastClass, ConstructorInfo constructor) { // Store the class that spawned us this._fastClass = _fastClass; _targetConstructor = constructor; int uid = System.Threading.Interlocked.Increment(ref _constructorIdCounter); // Create a unique name for the method String dynamicMethodName = "_CGLibC_" + this._fastClass.Id + "_" + uid; // Generate the method _dynamicMethod = new DynamicMethod( dynamicMethodName, MethodAttributes.Public | MethodAttributes.Static, CallingConventions.Standard, typeof(Object), new Type[] { typeof(Object), typeof(Object[]) }, _targetConstructor.Module, true); EmitInvoker(_targetConstructor, _dynamicMethod.GetILGenerator()); _invoker = (Invoker)_dynamicMethod.CreateDelegate(typeof(Invoker)); }
/// <summary> /// Ctor. /// </summary> /// <param name="statementName">Name of the statement.</param> /// <param name="subscriber">is the subscriber to deliver to</param> /// <param name="method">the method to invoke</param> public ResultDeliveryStrategyObjectArr(String statementName, Object subscriber, MethodInfo method) { _statementName = statementName; _subscriber = subscriber; FastClass fastClass = FastClass.Create(subscriber.GetType()); _fastMethod = fastClass.GetMethod(method); }
public void MissingConstructorShouldReturnNull() { var clazzType = FastClass.Create(typeof(ClassA)); var constructor = clazzType.GetConstructor(typeof(double)); Assert.That(constructor, Is.Null); }
public SignalHandlerDefaultWInvoke(Object target, MethodInfo method) { Target = target; FastClass fastClass = FastClass.Create(target.GetType()); FastMethod = fastClass.GetMethod(method); }
public SignalHandlerDefaultWInvoke(Object target, MethodInfo method, EngineImportService engineImportService) { Target = target; FastClass fastClass = FastClass.Create(target.GetType()); Method = fastClass.GetMethod(method); }
/// <summary> /// Ctor. /// </summary> /// <param name="statementName">Name of the statement.</param> /// <param name="subscriber">the object to deliver to</param> /// <param name="method">the delivery method</param> /// <param name="columnNames">the column names for the map</param> public ResultDeliveryStrategyMap(String statementName, Object subscriber, MethodInfo method, String[] columnNames) { _statementName = statementName; _subscriber = subscriber; FastClass fastClass = FastClass.Create(subscriber.GetType()); _fastMethod = fastClass.GetMethod(method); _columnNames = columnNames; }
private static BeanInstantiator ResolveFactoryMethod(BeanEventType beanEventType, EngineImportService engineImportService) { string factoryMethodName = beanEventType.FactoryMethodName; int lastDotIndex = factoryMethodName.LastIndexOf('.'); if (lastDotIndex == -1) { try { MethodInfo method = engineImportService.ResolveMethod( beanEventType.UnderlyingType, factoryMethodName, new Type[0], new bool[0], new bool[0]); if (beanEventType.FastClass != null) { return(new BeanInstantiatorByFactoryFastClass(beanEventType.FastClass.GetMethod(method))); } else { return(new BeanInstantiatorByFactoryReflection(method)); } } catch (EngineImportException e) { string message = string.Format( "Failed to resolve configured factory method '{0}' expected to exist for class '{1}'", factoryMethodName, beanEventType.UnderlyingType); Log.Info(message, e); throw new EventBeanManufactureException(message, e); } } string className = factoryMethodName.Substring(0, lastDotIndex); string methodName = factoryMethodName.Substring(lastDotIndex + 1); try { MethodInfo method = engineImportService.ResolveMethod(className, methodName, new Type[0], new bool[0], new bool[0]); if (beanEventType.FastClass != null) { FastClass fastClassFactory = FastClass.Create(method.DeclaringType); return(new BeanInstantiatorByFactoryFastClass(fastClassFactory.GetMethod(method))); } else { return(new BeanInstantiatorByFactoryReflection(method)); } } catch (EngineImportException e) { String message = "Failed to resolve configured factory method '" + methodName + "' expected to exist for class '" + className + "'"; Log.Info(message, e); throw new EventBeanManufactureException(message, e); } }
private CGLibPropertyGetter MakeGetter(Type clazz, string propertyName) { var fastClass = FastClass.Create(clazz); var baseProperty = clazz.GetProperty(propertyName); var fastProperty = fastClass.GetProperty(baseProperty); var getter = new CGLibPropertyGetter(baseProperty, fastProperty, _container.Resolve <EventAdapterService>()); return(getter); }
public void CacheShouldReturnSameClass() { var sampleClassA = FastClass.Create(typeof(ClassA)); var sampleClassB = FastClass.Create(typeof(ClassA)); Assert.That(sampleClassA, Is.Not.Null); Assert.That(sampleClassB, Is.Not.Null); Assert.That(sampleClassA, Is.SameAs(sampleClassB)); }
private CGLibPropertyGetter MakeGetter(Type clazz, string propertyName) { var fastClass = FastClass.Create(clazz); var baseProperty = clazz.GetProperty(propertyName); var fastProperty = fastClass.GetProperty(baseProperty); var getter = new CGLibPropertyGetter(baseProperty, fastProperty, SupportEventAdapterService.Service); return(getter); }
public void SetUp() { _bean = SupportBeanComplexProps.MakeDefaultBean(); _theEvent = SupportEventBeanFactory.CreateObject(_bean); FastClass fastClass = FastClass.Create(typeof(SupportBeanComplexProps)); FastMethod method = fastClass.GetMethod("GetIndexed", new Type[] { typeof(int) }); _getter = new KeyedFastPropertyGetter(method, 1, SupportEventAdapterService.Service); }
/// <summary> /// Ctor. /// </summary> /// <param name="statementName">Name of the statement.</param> /// <param name="subscriber">is the receiver to method invocations</param> /// <param name="method">is the method to deliver to</param> public ResultDeliveryStrategyTypeArr(String statementName, Object subscriber, MethodInfo method) { _statementName = statementName; _subscriber = subscriber; FastClass fastClass = FastClass.Create(subscriber.GetType()); _fastMethod = fastClass.GetMethod(method); _componentType = method.GetParameters()[0].ParameterType.GetElementType(); }
public void TestGetGetter() { FastClass fastClass = FastClass.Create(typeof(SupportBeanPropertyNames)); EventBean bean = SupportEventBeanFactory.CreateObject(new SupportBeanPropertyNames()); MethodInfo method = typeof(SupportBeanPropertyNames).GetProperty("A").GetGetMethod(); EventPropertyGetter getter = PropertyHelper.GetGetter("A", method, fastClass, _container.Resolve <EventAdapterService>()); Assert.AreEqual("", getter.Get(bean)); }
/// <summary> /// Constructs a wrapper around the target field. /// </summary> /// <param name="_fastClass">The _fast class.</param> /// <param name="field">The field.</param> internal FastField(FastClass _fastClass, FieldInfo field) { // Store the class that spawned us fastClass = _fastClass; // Field we will be get/setting targetField = field; CreateDynamicGetMethod(field); CreateDynamicSetMethod(field); }
/// <summary> /// Constructs a wrapper around the target property. /// </summary> /// <param name="_fastClass">The _fast class.</param> /// <param name="property">The property.</param> internal FastProperty(FastClass _fastClass, PropertyInfo property) { // Store the class that spawned us fastClass = _fastClass; // Property we will be get/setting targetProperty = property; CreateDynamicGetMethod(property); CreateDynamicSetMethod(property); }
private CGLibPropertyGetter MakeCGIGetter(Type clazz, String propertyName) { FastClass fastClass = FastClass.Create(clazz); PropertyInfo propertyInfo = clazz.GetProperty(propertyName); FastProperty fastProp = fastClass.GetProperty(propertyInfo); CGLibPropertyGetter getter = new CGLibPropertyGetter(propertyInfo, fastProp, SupportEventAdapterService.Service); return(getter); }
/// <summary> /// Return a writer for writing a single property value. /// </summary> /// <param name="propertyName">to write to</param> /// <returns> /// null or writer if writable /// </returns> public EventPropertyWriter GetWriter(String propertyName) { if (_writeablePropertyDescriptors == null) { InitializeWriters(); } var pair = _writerMap.Get(propertyName); if (pair != null) { return(pair.Second); } var property = PropertyParser.ParseAndWalk(propertyName, false); if (property is MappedProperty) { var mapProp = (MappedProperty)property; var methodName = string.Format("Set{0}", mapProp.PropertyNameAtomic); var methodInfo = UnderlyingType.GetMethod( methodName, BindingFlags.Public | BindingFlags.Instance, null, new Type[] { typeof(string), typeof(object) }, null); if (methodInfo == null) { Log.Info("Failed to find mapped property '" + mapProp.PropertyNameAtomic + "' for writing to property '" + propertyName + "'"); return(null); } var fastMethod = FastClass.GetMethod(methodInfo); return(new BeanEventPropertyWriterMapProp(UnderlyingType, fastMethod, mapProp.Key)); } if (property is IndexedProperty) { var indexedProp = (IndexedProperty)property; var methodName = string.Format("Set{0}", indexedProp.PropertyNameAtomic); var methodInfo = UnderlyingType.GetMethod( methodName, BindingFlags.Public | BindingFlags.Instance, null, new Type[] { typeof(int), typeof(object) }, null); if (methodInfo == null) { Log.Info("Failed to find mapped property '" + indexedProp.PropertyNameAtomic + "' for writing to property '" + propertyName + "'"); return(null); } var fastMethod = FastClass.GetMethod(methodInfo); return(new BeanEventPropertyWriterIndexedProp(UnderlyingType, fastMethod, indexedProp.Index)); } return(null); }
public void CanSetPrivateFields() { var constValue = 10000; var instance = new ClassA(); var clazzType = FastClass.Create(typeof(ClassA)); var clazzField = clazzType.GetField("privateIntValue"); Assert.That(clazzField, Is.Not.Null); clazzField.Set(instance, constValue); Assert.That(instance.PrivateIntValue, Is.EqualTo(constValue)); }
protected EPDataFlowEmitter1Stream1TargetBase(int operatorNum, DataFlowSignalManager signalManager, SignalHandler signalHandler, EPDataFlowEmitterExceptionHandler exceptionHandler, ObjectBindingPair target) { OperatorNum = operatorNum; SignalManager = signalManager; SignalHandler = signalHandler; ExceptionHandler = exceptionHandler; var fastClass = FastClass.Create(target.Target.GetType()); _fastMethod = fastClass.GetMethod(target.Binding.ConsumingBindingDesc.Method); TargetObject = target.Target; }
/// <summary> /// Ctor. /// </summary> /// <param name="statement">The statement.</param> /// <param name="subscriber">the object to deliver to</param> /// <param name="method">the delivery method</param> /// <param name="columnNames">the column names for the map</param> /// <param name="importService">The engine import service.</param> public ResultDeliveryStrategyMap( EPStatement statement, object subscriber, MethodInfo method, string[] columnNames, ImportService importService) { _statement = statement; _subscriber = subscriber; _fastMethod = FastClass.CreateMethod(method); _columnNames = columnNames; }
public void CanCallDefaultConstructor() { var clazzType = FastClass.Create(typeof(ClassA)); var constructor = clazzType.GetDefaultConstructor(); Assert.That(constructor, Is.Not.Null); var instance = constructor.New(); Assert.That(instance, Is.Not.Null); Assert.That(instance, Is.InstanceOf <ClassA>()); }
private FastMethod GetFastMethod(Type clazz) { try { MethodInfo method = _engineImportService.ResolveMethod(clazz, _methodName, _parameterTypes, new bool[_parameterTypes.Length], new bool[_parameterTypes.Length]); FastClass declaringClass = FastClass.Create(method.DeclaringType); return(declaringClass.GetMethod(method)); } catch (Exception) { Log.Debug("Not resolved for class '" + clazz.Name + "' method '" + _methodName + "'"); } return(null); }
public void CanGetPublicFields() { var constValue = 2000; var instance = new ClassA(); instance.publicIntValue = constValue; var clazzType = FastClass.Create(typeof(ClassA)); var clazzField = clazzType.GetField("publicIntValue"); Assert.That(clazzField, Is.Not.Null); Assert.That(clazzField.Get(instance), Is.EqualTo(constValue)); Assert.That(instance.publicIntValue, Is.EqualTo(constValue)); }
public void CanUseMoreThanOneArgument() { var instanceA = new ClassA(); var clazzType = FastClass.Create(typeof(ClassA)); Assert.That( clazzType.GetMethod("InstanceMethod2").Invoke(instanceA, 1, 2), Is.EqualTo(3)); Assert.That( clazzType.GetMethod("InstanceMethod3").Invoke(instanceA, 3, 4, 5), Is.EqualTo(12)); Assert.That( clazzType.GetMethod("InstanceMethod4").Invoke(instanceA, 6, 7, 8, 9), Is.EqualTo(30)); }