Esempio n. 1
0
        public NodeFamily()
        {
            type      = typeof(T);
            activator = ObjectActivatorHelpers.GetActivator <T>();

            var fields = type.GetFields();

            foreach (var field in fields)
            {
                if (field.IsInitOnly || field.IsLiteral || field.IsStatic || !field.IsPublic)
                {
                    continue;
                }

                fieldTypes.Add(field);
                fieldSet.Add(field);
            }

            ConstituentTypes = new ConstituentTypes(fieldSet.Select(f => f.FieldType));
            isTuple          = type.Name.StartsWith(TUPLE_NAME);
            if (isTuple)
            {
                genericTypeArguments = type.GenericTypeArguments;
            }
        }
Esempio n. 2
0
        internal static T GetDefaultInstance <T>()
        {
            ConstructorInfo     ctor             = typeof(T).GetConstructors().First();
            ObjectActivator <T> createdActivator = GetActivator <T>(ctor);

            return(createdActivator(null));
        }
    // --------------------------------------------------

    void Start()
    {
        itemActivatorObject = GameObject.Find("ObjectActivatorManager");
        activationScript    = itemActivatorObject.GetComponent <ObjectActivator>();

        StartCoroutine("AddToList");
    }
        static ObjectActivator <T> GetActivator <T>(ConstructorInfo ctor)
        {
            Type type = ctor.DeclaringType;

            ParameterInfo[] paramsInfo = ctor.GetParameters();

            ParameterExpression param = Expression.Parameter(typeof(object[]), "args");

            Expression[] argsExp = new Expression[paramsInfo.Length];

            for (int i = 0; i < paramsInfo.Length; i++)
            {
                Expression index     = Expression.Constant(i);
                Type       paramType = paramsInfo[i].ParameterType;

                Expression paramAccessorExp =
                    Expression.ArrayIndex(param, index);

                Expression paramCastExp =
                    Expression.Convert(paramAccessorExp, paramType);

                argsExp[i] = paramCastExp;
            }

            NewExpression newExp = Expression.New(ctor, argsExp);

            LambdaExpression lambda = Expression.Lambda(typeof(ObjectActivator <T>), newExp, param);

            ObjectActivator <T> compiled = (ObjectActivator <T>)lambda.Compile();

            return(compiled);
        }
Esempio n. 5
0
 /// <summary>
 /// Initializes a new instance of the <see cref="ZipEntryNameSubscriptionDataSourceReader"/> class
 /// </summary>
 /// <param name="config">The subscription's configuration</param>
 /// <param name="date">The date this factory was produced to read data for</param>
 /// <param name="isLiveMode">True if we're in live mode, false for backtesting</param>
 public ZipEntryNameSubscriptionDataSourceReader(SubscriptionDataConfig config, DateTime date, bool isLiveMode)
 {
     _config     = config;
     _date       = date;
     _isLiveMode = isLiveMode;
     _factory    = _factory = (BaseData)ObjectActivator.GetActivator(config.Type).Invoke(new object[] { config.Type });
 }
Esempio n. 6
0
        public void IsFasterThanRawReflection()
        {
            int count     = 100000;
            var data      = new TradeBar(DateTime.Now, Symbols.SPY, 1m, 2m, 3m, 4m, 5);
            var stopwatch = Stopwatch.StartNew();

            for (int i = 0; i < count; i++)
            {
                var clone = Clone(data);
            }
            stopwatch.Stop();
            var elapsed1 = stopwatch.Elapsed;

            Console.WriteLine(elapsed1.TotalMilliseconds);

            stopwatch.Reset();
            stopwatch.Start();
            for (int i = 0; i < count; i++)
            {
                var clone = ObjectActivator.Clone(data);
            }
            stopwatch.Stop();
            var elapsed2 = stopwatch.Elapsed;

            Console.WriteLine(elapsed2.TotalMilliseconds);
            Assert.Less(elapsed2, elapsed1);
        }
Esempio n. 7
0
        public static TInterface NewInstance <TInterface>(Type objectType, params object[] args)
        {
            ConstructorInfo ctor = objectType.GetConstructors().First();
            ObjectActivator <TInterface> createdActivator = GetActivator <TInterface>(ctor);

            return(createdActivator(args));
        }
Esempio n. 8
0
        private bool Register(Type itemType)
        {
            if (itemType.IsInterface || itemType.IsAbstract || itemType.IsValueType || !typeof(TBaseObj).IsAssignableFrom(itemType))
            {
                //throw new Exception("Cannot register this Type!");
                return(false);
            }

            ConcurrentDictionary <string, ObjectActivator <TBaseObj> > creatorSigs = new ConcurrentDictionary <string, ObjectActivator <TBaseObj> >();

            foreach (ConstructorInfo ctorInfo in itemType.GetConstructors())
            {
                string sig = GenerateSignature(ctorInfo.GetParameters().Select(p => p.ParameterType).ToArray());
                ObjectActivator <TBaseObj> createdActivator = GenerateObjectActivator <TBaseObj>(ctorInfo);
                creatorSigs[sig] = createdActivator;
            }

            if (!m_activatorCache.TryAdd(itemType.FullName, creatorSigs))
            {
                //throw new Exception("Could not add Activator to ActivatorCache!");
                return(false);
            }

            return(true);
        }
Esempio n. 9
0
 /// <summary>
 /// Initializes a new instance of the <see cref="TextSubscriptionFactory"/> class
 /// </summary>
 /// <param name="config">The subscription's configuration</param>
 /// <param name="date">The date this factory was produced to read data for</param>
 /// <param name="isLiveMode">True if we're in live mode, false for backtesting</param>
 public TextSubscriptionFactory(SubscriptionDataConfig config, DateTime date, bool isLiveMode)
 {
     _date       = date;
     _config     = config;
     _isLiveMode = isLiveMode;
     _factory    = (BaseData)ObjectActivator.GetActivator(config.Type).Invoke(new object[0]);
 }
Esempio n. 10
0
 private AccountUser CreateBasicUser()
 {
     return(ObjectActivator.CreateInstance <AccountUser>()
            .Set(x => x.AccountId, AccountId)
            .Set(x => x.Created, Removed.AddDays(-10))
            .Set(x => x.UserRef, UserRef));
 }
Esempio n. 11
0
        public virtual object HandleVlvRequest(DirectoryConnection connection, int maxSize, ILinqToLdapLogger log)
        {
            if (Options.YieldNoResults)
            {
                var enumerator  = Options.GetEnumerator();
                var bindingAttr = new[]
                {
                    0,
                    null,
                    0,
                    enumerator
                };

                return(ObjectActivator.CreateGenericInstance(typeof(VirtualListView <>), Options.GetEnumeratorReturnType(), bindingAttr, null));
            }

            if (GetControl <SortRequestControl>(SearchRequest.Controls) == null)
            {
                throw new InvalidOperationException("Virtual List Views require a sort operation. Please include an OrderBy in your query.");
            }

            var skip = Options.SkipSize.GetValueOrDefault();

            if (GetControl <VlvRequestControl>(SearchRequest.Controls) == null)
            {
                VlvRequestControl vlvRequest =
                    new VlvRequestControl(0, Options.TakeSize.GetValueOrDefault(maxSize) - 1, skip + 1)
                {
                    IsCritical = false
                };

                SearchRequest.Controls.Add(vlvRequest);
            }

            if (log != null && log.TraceEnabled)
            {
                log.Trace(SearchRequest.ToLogString());
            }
            var response = connection.SendRequest(SearchRequest) as SearchResponse;

            response.AssertSuccess();

            AssertSortSuccess(response.Controls);

            var vlvResponse = GetControl <VlvResponseControl>(response.Controls);

            if (vlvResponse == null)
            {
                throw new InvalidOperationException("The server does not support Virtual List Views. Skip cannot be used. Please use standard paging.");
            }
            var parameters = new[]
            {
                vlvResponse.ContentCount,
                vlvResponse.ContextId,
                vlvResponse.TargetPosition,
                Options.GetEnumerator(response.Entries)
            };

            return(ObjectActivator.CreateGenericInstance(typeof(VirtualListView <>), Options.GetEnumeratorReturnType(), parameters, null));
        }
Esempio n. 12
0
        /// <summary>
        /// Gets all holdings for the account
        /// </summary>
        /// <returns>The current holdings from the account</returns>
        public override List <Holding> GetAccountHoldings()
        {
            var holdings = _accountHoldings.Select(x => (Holding)ObjectActivator.Clone(x.Value)).ToList();

            // fire up tasks to resolve the conversion rates so we can do them in parallel
            var tasks = holdings.Select(local =>
            {
                // we need to resolve the conversion rate for non-USD currencies
                if (local.Type != SecurityType.Forex)
                {
                    // this assumes all non-forex are us denominated, we should add the currency to 'holding'
                    local.ConversionRate = 1m;
                    return(null);
                }
                // if quote currency is in USD don't bother making the request
                string currency = local.Symbol.Substring(3);
                if (currency == "USD")
                {
                    local.ConversionRate = 1m;
                    return(null);
                }

                // this will allow us to do this in parallel
                return(Task.Factory.StartNew(() => local.ConversionRate = GetUsdConversion(currency)));
            }).Where(x => x != null).ToArray();

            Task.WaitAll(tasks, 5000);

            return(holdings);
        }
        public AbstractFieldNameTranslator GetFieldNameTranslator(ISearchIndex index)
        {
            SolrFieldMap           fieldMap      = index.Configuration.FieldMap as SolrFieldMap;
            SolrIndexSchema        schema        = index.Schema as SolrIndexSchema;
            ISettings              instance      = index.Locator.GetInstance <ISettings>();
            SolrIndexConfiguration configuration = index.Configuration as SolrIndexConfiguration;

            Assert.IsNotNull(fieldMap, "FieldMap is null.");
            Assert.IsNotNull(schema, "SolrSchema is null.");
            Assert.IsNotNull(instance, "Settings is null.");
            Assert.IsNotNull(configuration, "This constructor requires SolrIndexConfiguration.");
            TemplateFieldTypeResolverFactory typeResolverFactory = configuration.TemplateFieldTypeResolverFactory;

            Assert.IsNotNull(typeResolverFactory, "normalizerFactory is null.");
            TemplateFieldTypeResolver fieldTypeResolver = typeResolverFactory.Create();

            Assert.IsNotNull(fieldTypeResolver, "FieldTypeResolver is null.");
            SolrFieldConfigurationResolver configurationResolver = new SolrFieldConfigurationResolver(fieldMap, schema, fieldTypeResolver);
            var ctor = typeof(SolrFieldNameTranslator).Assembly
                       .GetType("Sitecore.ContentSearch.SolrProvider.FieldNames.CultureContextGuard")
                       .GetConstructors().First();


            ICultureContextGuard cultureContextGuard = ObjectActivator.GetActivator <ICultureContextGuard>(ctor).Invoke();

            return(new SynthesisSolrFieldNameTranslator(fieldMap, schema, instance, configurationResolver, new ExtensionStripHelper(fieldMap, schema), typeResolverFactory, cultureContextGuard));
        }
Esempio n. 14
0
        public void CreateMultipleCtor()
        {
            ActivatorTestClassMultipleCtors obj;
            Type type = typeof(ActivatorTestClassMultipleCtors);
            ObjectActivator <ActivatorTestClassMultipleCtors> activator1 = type.CreateActivator <ActivatorTestClassMultipleCtors>(typeof(int), typeof(int));
            ObjectActivator <ActivatorTestClassMultipleCtors> activator2 = type.CreateActivator <ActivatorTestClassMultipleCtors>(typeof(int));
            ObjectActivator <ActivatorTestClassMultipleCtors> activator3 = type.CreateActivator <ActivatorTestClassMultipleCtors>();

            obj = activator1(123, 123);

            Assert.IsNotNull(obj);

            Assert.AreEqual(246, obj.TestThis());

            obj = activator2(123);

            Assert.IsNotNull(obj);

            Assert.AreEqual(246, obj.TestThis());

            obj = activator3();

            Assert.IsNotNull(obj);

            Assert.AreEqual(2, obj.TestThis());
        }
        // http://rogeralsing.com/2008/02/28/linq-expressions-creating-objects/
        public static ObjectActivator GetActivator(ConstructorInfo ctor)
        {
            // Type type = ctor.DeclaringType;
            ParameterInfo[] paramsInfo = ctor.GetParameters();
            //create a single param of type object[]
            ParameterExpression param = Expression.Parameter(typeof(object[]), "args");

            Expression[] argsExp = new Expression[paramsInfo.Length];

            //pick each arg from the params array
            //and create a typed expression of them
            for (int i = 0; i < paramsInfo.Length; i++)
            {
                Expression index            = Expression.Constant(i);
                Type       paramType        = paramsInfo[i].ParameterType;
                Expression paramAccessorExp = Expression.ArrayIndex(param, index);
                Expression paramCastExp     = Expression.Convert(paramAccessorExp, paramType);
                argsExp[i] = paramCastExp;
            }

            //make a NewExpression that calls the
            //ctor with the args we just created
            NewExpression    newExp = Expression.New(ctor, argsExp);
            LambdaExpression lambda = Expression.Lambda(typeof(ObjectActivator), newExp, param);

            //compile it
            ObjectActivator compiled = (ObjectActivator)lambda.Compile();

            return(compiled);
        }
Esempio n. 16
0
        public static void Run()
        {
            CodeTimer.Initialize();
            var type = typeof(MessageTest <CmdTest>);
            var ctor = type.GetConstructors()[2];
            ObjectActivator <object> createdActivator = ActivatorHelper.GetActivator <object>(ctor);
            var    input  = new CmdTest();
            var    header = new MessageHeaderTest();
            object tmpObj = null;
            var    count  = 1000000;

            CodeTimer.Time("new instance", count, () =>
            {
                tmpObj = new MessageTest <CmdTest>(input, header);
            });

            CodeTimer.Time("exp tree", count, () =>
            {
                tmpObj = createdActivator(input, header);
            });

            CodeTimer.Time("Activator.CreateInstance", count, () =>
            {
                tmpObj = Activator.CreateInstance(type, input, header);
            });

            CodeTimer.Time("exp tree2", count, () =>
            {
                tmpObj = ActivatorHelper.CreateInstance(type, input, header);
            });
        }
Esempio n. 17
0
        public static TObject NewInstance <TObject>(params object[] args)
        {
            ConstructorInfo           ctor             = typeof(TObject).GetConstructors().First();
            ObjectActivator <TObject> createdActivator = GetActivator <TObject>(ctor);

            return(createdActivator(args));
        }
Esempio n. 18
0
        public void ClonesBaseDataDerivedTypes()
        {
            BaseData data  = new IndicatorDataPoint(Symbols.SPY, DateTime.Now, 1m);
            BaseData clone = ObjectActivator.Clone(data) as BaseData;

            Assert.IsNotNull(clone);
            Assert.IsInstanceOf(data.GetType(), clone);
            Assert.AreEqual(data.Symbol, clone.Symbol);
            Assert.AreEqual(data.Time, clone.Time);
            Assert.AreEqual(data.Value, clone.Value);

            data = new TradeBar(DateTime.Now, Symbols.SPY, 1m, 2m, 3m, 4m, 5);
            var bar = ObjectActivator.Clone(data) as TradeBar;

            Assert.IsNotNull(clone);
            Assert.IsInstanceOf(data.GetType(), bar);
            Assert.AreEqual(data.Symbol, bar.Symbol);
            Assert.AreEqual(data.Time, bar.Time);
            Assert.AreEqual(data.Value, bar.Value);
            Assert.AreEqual(((TradeBar)data).Open, bar.Open);
            Assert.AreEqual(((TradeBar)data).High, bar.High);
            Assert.AreEqual(((TradeBar)data).Low, bar.Low);
            Assert.AreEqual(((TradeBar)data).Close, bar.Close);
            Assert.AreEqual(data.Price, bar.Price);
        }
        /// <summary>
        /// Creates an enumerator to read the specified request.
        /// </summary>
        /// <param name="request">The subscription request to be read</param>
        /// <param name="dataProvider">Provider used to get data when it is not present on disk</param>
        /// <returns>An enumerator reading the subscription request</returns>
        public IEnumerator <BaseData> CreateEnumerator(SubscriptionRequest request, IDataProvider dataProvider)
        {
            var config = request.Configuration;

            // frontier value used to prevent emitting duplicate time stamps between refreshed enumerators
            // also provides some immediate fast-forward to handle spooling through remote files quickly
            var frontier = Ref.Create(DateTime.MinValue);
            var lastSourceRefreshTime = DateTime.MinValue;
            var sourceFactory         = (BaseData)ObjectActivator.GetActivator(config.Type).Invoke(new object[] { config.Type });

            // this is refreshing the enumerator stack for each new source
            var refresher = new RefreshEnumerator <BaseData>(() =>
            {
                // rate limit the refresh of this enumerator stack
                var utcNow = _timeProvider.GetUtcNow();
                var minimumTimeBetweenCalls = GetMinimumTimeBetweenCalls(config.Increment);
                if (utcNow - lastSourceRefreshTime < minimumTimeBetweenCalls)
                {
                    return(Enumerable.Empty <BaseData>().GetEnumerator());
                }

                lastSourceRefreshTime = utcNow;
                var localDate         = utcNow.ConvertFromUtc(config.ExchangeTimeZone).Date;
                var source            = sourceFactory.GetSource(config, localDate, true);

                // fetch the new source and enumerate the data source reader
                var enumerator = EnumerateDataSourceReader(config, dataProvider, frontier, source, localDate);

                if (SourceRequiresFastForward(source))
                {
                    // apply fast forward logic for file transport mediums
                    var maximumDataAge = GetMaximumDataAge(config.Increment);
                    enumerator         = new FastForwardEnumerator(enumerator, _timeProvider, config.ExchangeTimeZone, maximumDataAge);
                }
                else
                {
                    // rate limit calls to this enumerator stack
                    enumerator = new RateLimitEnumerator <BaseData>(enumerator, _timeProvider, minimumTimeBetweenCalls);
                }

                if (source.Format == FileFormat.Collection)
                {
                    // unroll collections into individual data points after fast forward/rate limiting applied
                    enumerator = enumerator.SelectMany(data =>
                    {
                        var collection = data as BaseDataCollection;
                        return(collection?.Data.GetEnumerator() ?? new List <BaseData> {
                            data
                        }.GetEnumerator());
                    });
                }

                return(enumerator);
            });

            // prevent calls to the enumerator stack if current is in the future
            var timeZoneOffsetProvider = new TimeZoneOffsetProvider(request.Security.Exchange.TimeZone, request.StartTimeUtc, request.EndTimeUtc);

            return(new FrontierAwareEnumerator(refresher, _timeProvider, timeZoneOffsetProvider));
        }
Esempio n. 20
0
        public void PythonCustomDataTypes_AreAddedToSubscriptions_Successfully()
        {
            var pythonPath = new System.IO.DirectoryInfo("RegressionAlgorithms");

            Environment.SetEnvironmentVariable("PYTHONPATH", pythonPath.FullName);

            var qcAlgorithm = new AlgorithmPythonWrapper("Test_CustomDataAlgorithm");

            // Initialize contains the statements:
            // self.AddData(Nifty, "NIFTY")
            // self.AddData(QuandlFuture, "SCF/CME_CL1_ON", Resolution.Daily)
            qcAlgorithm.Initialize();

            var niftySubscription = qcAlgorithm.SubscriptionManager.Subscriptions.FirstOrDefault(x => x.Symbol.Value == "NIFTY");

            Assert.IsNotNull(niftySubscription);

            var niftyFactory = (BaseData)ObjectActivator.GetActivator(niftySubscription.Type).Invoke(new object[] { niftySubscription.Type });

            Assert.DoesNotThrow(() => niftyFactory.GetSource(niftySubscription, DateTime.UtcNow, false));

            var quandlSubscription = qcAlgorithm.SubscriptionManager.Subscriptions.FirstOrDefault(x => x.Symbol.Value == "SCF/CME_CL1_ON");

            Assert.IsNotNull(quandlSubscription);

            var quandlFactory = (BaseData)ObjectActivator.GetActivator(quandlSubscription.Type).Invoke(new object[] { quandlSubscription.Type });

            Assert.DoesNotThrow(() => quandlFactory.GetSource(quandlSubscription, DateTime.UtcNow, false));
        }
Esempio n. 21
0
        public static Object CreateInstance(Type type, params object[] args)
        {
            var ctorCount = 0;

            if (args != null)
            {
                ctorCount = args.Length;
            }
            var key = type.FullName + "." + ctorCount.ToString();

            if (CacheMap.ContainsKey(key))
            {
                return(CacheMap[key].Invoke(args));
            }
            else
            {
                var ctor = type.GetConstructors()[ctorCount];

                ObjectActivator <Object> createdActivator = GetActivator <Object>(ctor);

                CacheMap.AddOrUpdate(key, createdActivator, (k, oldValue) => createdActivator);

                return(createdActivator.Invoke(args));
            }
        }
        private static ObjectActivator CreateObjectActivator(ConstructorInfo ctorInfo, ParameterInfo[] parameters)
        {
            //create a single param of type object[]
            ParameterExpression param = Expression.Parameter(typeof(object[]), "args");

            Expression[] argsExp = new Expression[parameters.Length];

            //pick each arg from the params array and create a typed expression of them
            for (int i = 0; i < parameters.Length; i++)
            {
                Expression index     = Expression.Constant(i);
                Type       paramType = parameters[i].ParameterType;

                Expression paramAccessorExp = Expression.ArrayIndex(param, index);
                Expression paramCastExp     = Expression.Convert(paramAccessorExp, paramType);

                argsExp[i] = paramCastExp;
            }

            // Make a NewExpression that calls the ctor with the args we just created
            NewExpression newExp = Expression.New(ctorInfo, argsExp);

            // Create a lambda with the New expression as body and our param object[] as arg
            LambdaExpression lambda = Expression.Lambda(typeof(ObjectActivator), newExp, param);

            // Compile it
            ObjectActivator compiled = (ObjectActivator)lambda.Compile();

            return(compiled);
        }
Esempio n. 23
0
        /// <summary>
        /// Creates a type with a given name
        /// </summary>
        /// <param name="type">Python object</param>
        /// <returns>Type object</returns>
        private Type CreateType(PyObject type)
        {
            PythonActivator pythonType;

            if (!_pythonActivators.TryGetValue(type.Handle, out pythonType))
            {
                AssemblyName an;
                using (Py.GIL())
                {
                    an = new AssemblyName(type.Repr().Split('\'')[1]);
                }
                var typeBuilder = AppDomain.CurrentDomain
                                  .DefineDynamicAssembly(an, AssemblyBuilderAccess.Run)
                                  .DefineDynamicModule("MainModule")
                                  .DefineType(an.Name, TypeAttributes.Class, typeof(DynamicData));

                pythonType = new PythonActivator(typeBuilder.CreateType(), type);

                ObjectActivator.AddActivator(pythonType.Type, pythonType.Factory);

                // Save to prevent future additions
                _pythonActivators.Add(type.Handle, pythonType);
            }
            return(pythonType.Type);
        }
        public void FinalizeInstanceWithDependencyDefined()
        {
            ObjectActivatorTests.TestActivator <IActivatorTest, ActivatorTest>(container =>
            {
                // Arrange...
                // ... register more items into the container...
                var newBuilder = new ContainerBuilder();
                newBuilder
                .RegisterType <ActivatorWithDependencyTest>()
                .As <IDependentActivatorTest>();
                newBuilder
                .RegisterType <ObjectPortal <IDependentActivatorTest> >()
                .As <IObjectPortal <IDependentActivatorTest> >();
                // ... append new registrations to the container given by the TestActivator Action...
                newBuilder.Update(container);
                // ... still arranging...
                var activator = new ObjectActivator(container);
                var obj       = activator.CreateInstance(typeof(IDependentActivatorTest));
                activator.InitializeInstance(obj);

                // Act...
                activator.FinalizeInstance(obj);

                // Assert...
                ActivatorWithDependencyTest target = (ActivatorWithDependencyTest)obj;
                var aDependency = target.GetType().GetProperty("ADependency", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public).GetValue(target, null);
                Assert.IsNull(aDependency);
            });
        }
Esempio n. 25
0
        /// <summary>
        /// Create new Integration Event
        /// </summary>
        /// <param name="data"></param>
        /// <param name="eventName"></param>
        /// <param name="typeOfEvent"></param>
        /// <returns></returns>
        public static IntegrationEvent CreateEventInstance(object data, Type typeOfEvent)
        {
            try
            {
                //find the contructor with one parameter which take object data type
                bool isCorrectConstructor(ConstructorInfo c)
                {
                    var parameters = c.GetParameters();

                    if (parameters.Length == 1)
                    {
                        var firstParameter = parameters.FirstOrDefault();
                        if (firstParameter?.ParameterType == data.GetType())
                        {
                            return(true);
                        }
                    }

                    return(false);
                }

                ConstructorInfo  ctor             = (typeOfEvent.GetConstructors().First(isCorrectConstructor));
                ObjectActivator  createdActivator = GetActivator(ctor);
                IntegrationEvent instance         = createdActivator(data);
                return(instance);
            }
            catch (Exception)
            {
                return(new DefaultIntegrationEvent(data, typeOfEvent.Name));
            }
        }
Esempio n. 26
0
        public void PythonCustomDataTypes_AreAddedToSubscriptions_Successfully()
        {
            var qcAlgorithm = new AlgorithmPythonWrapper("Test_CustomDataAlgorithm");

            qcAlgorithm.SubscriptionManager.SetDataManager(new DataManagerStub(qcAlgorithm));

            // Initialize contains the statements:
            // self.AddData(Nifty, "NIFTY")
            // self.AddData(CustomPythonData, "IBM", Resolution.Daily)
            qcAlgorithm.Initialize();

            var niftySubscription = qcAlgorithm.SubscriptionManager.Subscriptions.FirstOrDefault(x => x.Symbol.Value == "NIFTY");

            Assert.IsNotNull(niftySubscription);

            var niftyFactory = (BaseData)ObjectActivator.GetActivator(niftySubscription.Type).Invoke(new object[] { niftySubscription.Type });

            Assert.DoesNotThrow(() => niftyFactory.GetSource(niftySubscription, DateTime.UtcNow, false));

            var customDataSubscription = qcAlgorithm.SubscriptionManager.Subscriptions.FirstOrDefault(x => x.Symbol.Value == "IBM");

            Assert.IsNotNull(customDataSubscription);
            Assert.IsTrue(customDataSubscription.IsCustomData);
            Assert.AreEqual("custom_data.CustomPythonData", customDataSubscription.Type.ToString());

            var customDataFactory = (BaseData)ObjectActivator.GetActivator(customDataSubscription.Type).Invoke(new object[] { customDataSubscription.Type });

            Assert.DoesNotThrow(() => customDataFactory.GetSource(customDataSubscription, DateTime.UtcNow, false));
        }
Esempio n. 27
0
        public IDataSource CreateLocalDataSourceConnection(ConnectionProperties dataConnection, string pdatasourcename, string ClassDBHandlerName)
        {
            ErrorObject.Flag = Errors.Ok;
            IDataSource             ds      = null;
            ConnectionDriversConfig package = null;

            if (ConfigEditor.DataDriversClasses.Where(x => x.classHandler == ClassDBHandlerName).Any())
            {
                package = ConfigEditor.DataDriversClasses.Where(x => x.classHandler == ClassDBHandlerName).FirstOrDefault();
                string packagename = ConfigEditor.DataSourcesClasses.Where(x => x.className == package.classHandler).FirstOrDefault().PackageName;

                Type            adc  = assemblyHandler.GetType(packagename);
                ConstructorInfo ctor = adc.GetConstructors().First();
                ObjectActivator <IDataSource> createdActivator = GetActivator <IDataSource>(ctor);

                //create an instance:
                ds = createdActivator(dataConnection.ConnectionName, Logger, this, dataConnection.DatabaseType, ErrorObject);
            }


            try
            {
                if (ds != null)
                {
                    ds.Dataconnection.ConnectionProp   = dataConnection;
                    ds.Dataconnection.DataSourceDriver = package;
                    ds.Dataconnection.ReplaceValueFromConnectionString();
                    ILocalDB dB = (ILocalDB)ds;
                    DataSources.Add(ds);

                    AddLogMessage("Fail", $"Success Created Local Database  {pdatasourcename}", DateTime.Now, -1, "", Errors.Failed);
                    return(ds);
                }
                else
                {
                    AddLogMessage("Fail", "Could Find DataSource Drivers", DateTime.Now, 0, pdatasourcename, Errors.Failed);
                    return(null);
                }

                //     bool ok= dB.CreateDB();
                //      if (ok)
                //      {
                //  ds.ConnectionStatus = ds.Dataconnection.OpenConnection();
                //if (ds.ConnectionStatus == ConnectionState.Open)
                //{
                // ConfigEditor.DataConnections.Add(dataConnection);


                //}else
                //{
                //    return null;
                //}
            }
            catch (Exception ex)
            {
                AddLogMessage("Fail", $"Error in Opening Connection (Check DLL for Connection drivers,connect string, Datasource down,Firewall, .. etc)({ex.Message})", DateTime.Now, -1, "", Errors.Failed);
                return(null);
            }
        }
 /// <summary>
 /// Initializes a new instance of the <see cref="CollectionSubscriptionDataSourceReader"/> class
 /// </summary>
 /// <param name="dataCacheProvider">Used to cache data for requested from the IDataProvider</param>
 /// <param name="config">The subscription's configuration</param>
 /// <param name="date">The date this factory was produced to read data for</param>
 /// <param name="isLiveMode">True if we're in live mode, false for backtesting</param>
 public CollectionSubscriptionDataSourceReader(IDataCacheProvider dataCacheProvider, SubscriptionDataConfig config, DateTime date, bool isLiveMode)
 {
     _dataCacheProvider = dataCacheProvider;
     _date       = date;
     _config     = config;
     _isLiveMode = isLiveMode;
     _factory    = (BaseData)ObjectActivator.GetActivator(config.Type).Invoke(new object[] { config.Type });
 }
Esempio n. 29
0
 public ObjectCreator(Type type)
 {
     _objectActivator = DelegateFactory.CreateCtor(type);
     _setters = type
         .GetTypeInfo()
         .GetProperties()
         .ToDictionary(x => x.Name, x => DelegateFactory.CreatePropertySetter(x), StringComparer.OrdinalIgnoreCase);
 }
        public SeedAccountUsersJobTestsFixture AddUserOwnerRoleToReadStore()
        {
            ReadStoreUsers.Add(ObjectActivator.CreateInstance <AccountUser>()
                               .Set(x => x.UserRef, UserOwnerRole.User.Ref)
                               .Set(x => x.AccountId, UserOwnerRole.AccountId));

            return(this);
        }
Esempio n. 31
0
 public static void SetPool(ObjectActivator <T> objectGenerator)
 {
     if (_objectPools != null)
     {
         return;
     }
     _objectPools = new ObjectPool <T>(objectGenerator);
 }
 public object GetReceivedMessage(object[] obj) {
     if (activator == null) {
         var genericType = typeof(ReceivedMessage<>).MakeGenericType(MessageType);
         //object receivedMessage = Activator.CreateInstance(gt, new object[] { state.Message, msg, values });
         ConstructorInfo ctor = genericType.GetConstructors().First();
         activator = ReflectionHelper.GetActivator(ctor);
     }
     //create an instance:
     return activator(obj);
 }
Esempio n. 33
0
            public TypeActivators(Type type)
            {
                var ctors = type.GetConstructors();

                var parameterlessCtor = ctors.Where(x => x.GetParameters().Length == 0).SingleOrDefault();
                if (parameterlessCtor != default(ConstructorInfo))
                {
                    singleActivator = BuildActivator(parameterlessCtor).Value;
                }
                foreach (ConstructorInfo ctor in type.GetConstructors())
                {
                    var fpCtor = ctor;
                    var activator = BuildActivator(fpCtor);

                    var newValue = new ConcurrentDictionary<ConstructorInfo, ObjectActivator>();
                    newValue.TryAdd(fpCtor, activator.Value);

                    Func<int, ConcurrentDictionary<ConstructorInfo, ObjectActivator>, ConcurrentDictionary<ConstructorInfo, ObjectActivator>> updateAction =
                        (key, val) => { val.AddOrUpdate(fpCtor, activator.Value, (k, v) => activator.Value); return val; };

                    typeActivators.AddOrUpdate(activator.Key, newValue, updateAction);
                }
            }
			public ConstructorDefinition(object[] argValues, ObjectActivator objectActivator)
			{
				this.objectActivator = objectActivator;
				this.contructorArgValues = argValues;
			}
 /// <summary>
 /// Sets the constructor to use
 /// </summary>
 /// <param name="constructor"></param>
 public virtual void SetConstructor(ConstructorInfo constructor)
 {
     Constructor = constructor;
     _parameters = new ConstructorParameter[Constructor.GetParameters().Length];
     _factoryMethod = GetCreateDelegate();
 }