/// <summary> /// Initializes a new instance of the <see cref="BasicNode"/> class. /// </summary> /// <param name="context">The node context.</param> public InputSelector(INodeContext context) : base(context, INPUT_PREFIX) { context.ThrowIfNull("context"); mTypeService = context.GetService <ITypeService>(); // Initialize the input count, allowing range 2..99. mInputCount = mTypeService.CreateInt(PortTypes.Integer, "InputCount", 2); mInputCount.MinValue = 2; mInputCount.MaxValue = 50; // Initialize inputs using a helper function that grows/shrinks the list of inputs // whenever the input count is changed mInputs = new List <AnyValueObject>(); ListHelpers.ConnectListToCounter(mInputs, mInputCount, mTypeService.GetValueObjectCreator(PortTypes.Any, INPUT_PREFIX), updateOutputValues); // Initialize the input for the index of the input to select. mSelectIndexInput = mTypeService.CreateInt(PortTypes.Integer, "InputSelectIndex"); mSelectIndexInput.MinValue = 0; mSelectIndexInput.MaxValue = mInputCount.MaxValue - 1; mSelectIndexInput.ValueSet += updateOutputValues; // Initialize the selector for "send-on-select". mSelectAction = mTypeService.CreateEnum("ESelectAction2", "SelectAction2", mSelectActionValues, "ResendCurrent"); // Initialize the output mOutput = mTypeService.CreateAny(PortTypes.Any, "Output"); }
/// <summary> /// Initializes a new instance of the <see cref="UnifiPresenceDetectionNode"/> class. /// </summary> /// <param name="context">The node context.</param> public UnifiPresenceDetectionNode(INodeContext context) : base(context) { context.ThrowIfNull("context"); // Get the TypeService from the context this.TypeService = context.GetService <ITypeService>(); this.Trigger = this.TypeService.CreateBool(PortTypes.Bool, "Trigger", false); this.BaseUrl = this.TypeService.CreateString(PortTypes.String, "BaseURL", "https://127.0.0.1:8443"); this.SiteId = this.TypeService.CreateString(PortTypes.String, "UniFi Site", "default"); this.Username = this.TypeService.CreateString(PortTypes.String, "Username", ""); this.Password = this.TypeService.CreateString(PortTypes.String, "Password", ""); this.DeviceAmount = this.TypeService.CreateInt(PortTypes.Integer, "Anzahl Geräte", 1); this.DeviceAmount.MinValue = 1; this.DeviceAmount.MaxValue = 15; this.Devices = new List <IValueObject>(); this.DeviceAmount.ValueSet += this.GenerateDevicePorts; this.ConnectedAmount = this.TypeService.CreateInt(PortTypes.Integer, "Anzahl angemeldete Clients", 0); this.IsOneConnected = this.TypeService.CreateBool(PortTypes.Bool, "Mindestens ein Device angemeldet", false); this.IsAllConnected = this.TypeService.CreateBool(PortTypes.Bool, "Alle Devices angemeldet", false); this.ConnectedPersons = this.TypeService.CreateString(PortTypes.String, "Angemeldete Personen", ""); this.Error = this.TypeService.CreateString(PortTypes.String, "Fehlermeldung", ""); this.DeviceAmount.Value = 1; this.DefinedDevicesAndPersons = new Dictionary <string, string>(); }
public TypeArgumentController(IConfiguration config, ITypeService ts, ITypeArgumentService tas, ITypeDataDefineService tds) { this._config = config; this._ts = ts; this._tas = tas; this._tds = tds; }
internal async Task InitializeAsync() { IndexCommand.ResetQueryCache(); Indexes = new List <IIndexProvider>(); ScopedIndexes = new List <Type>(); ValidateConfiguration(); _sessionPool = new ObjectPool <Session>(MakeSession, Configuration.SessionPoolSize); Dialect = SqlDialectFactory.For(Configuration.ConnectionFactory.DbConnectionType); TypeNames = new TypeService(); using (var connection = Configuration.ConnectionFactory.CreateConnection()) { await connection.OpenAsync(); using (var transaction = connection.BeginTransaction(Configuration.IsolationLevel)) { var builder = new SchemaBuilder(Configuration, transaction); await Configuration.IdGenerator.InitializeAsync(this, builder); transaction.Commit(); } } // Pre-initialize the default collection await InitializeCollectionAsync(""); }
public ItemsController(IItemService service, ISystemService systemService, ITypeService typeService, IUserItemService userItemService) { this.service = service; this.systemService = systemService; this.typeService = typeService; this.userItemService = userItemService; }
public LogMessageService(ILogConfigurationService logConfigurationService, ITypeService typeService, ILogMessageRepository repository) { this.logConfigurationService = logConfigurationService; this.typeService = typeService; this.repository = repository; base.repository = repository; }
public ModbusClientNode(INodeContext context) { context.ThrowIfNull("context"); ITypeService typeService = context.GetService <ITypeService>(); this.TimeSpan = typeService.CreateInt(PortTypes.Integer, "Abfrageinterval", 60); this.ModbusHost = typeService.CreateString(PortTypes.String, "Modbus TCP Host"); this.ModbusPort = typeService.CreateInt(PortTypes.Integer, "Port", 502); this.ModbusID = typeService.CreateInt(PortTypes.Integer, "Geräte ID", 1); this.ModbusID.MinValue = 1; this.ModbusID.MaxValue = 256; // --------------------------------------------------------------------------------------- // this.ModbusAddress1 = typeService.CreateInt(PortTypes.Integer, "Register Addresse", 1); this.ModbusAddress1.MinValue = 1; this.ModbusAddress1.MaxValue = 65535; this.FunctionCode = typeService.CreateEnum("ModbusFunction", "Funktion", FunctionCodeEnum.VALUES, FunctionCodeEnum.FC_03); this.DataType = typeService.CreateEnum("ModbusDataType", "Datentyp", DataTypeEnum.VALUES, DataTypeEnum.INT32); this.RegisterOrder = typeService.CreateEnum("ModbusRegisterOrder", "Register Reihenfolge", ByteOrderEnum.VALUES, ByteOrderEnum.LOW_HIGH); this.OutputValue1 = typeService.CreateDouble(PortTypes.Number, "Register Wert"); this.ErrorMessage = typeService.CreateString(PortTypes.String, "RAW / Error"); SchedulerService = context.GetService <ISchedulerService>(); }
public TypeHardWareConfigController(IConfiguration config, ITypeService ts, ITypeDataDefineService tds, ITypeHardwareConfigService ths) { this._config = config; this._ts = ts; this._tds = tds; this._ths = ths; }
public LimitTimeBuyController( ILimitTimeBuyService iLimitTimeBuyService, ISlideAdsService iSlideAdsService, IShopService iShopService, IProductService iProductService, IProductDescriptionTemplateService iProductDescriptionTemplateService, IShopCategoryService iShopCategoryService, ICommentService iCommentService, IConsultationService iConsultationService, ICouponService iCouponService, ICashDepositsService iCashDepositsService, ITypeService iTypeService ) { _iLimitTimeBuyService = iLimitTimeBuyService; _iSlideAdsService = iSlideAdsService; _iShopService = iShopService; _iProductService = iProductService; _iProductDescriptionTemplateService = iProductDescriptionTemplateService; _iShopCategoryService = iShopCategoryService; _iCommentService = iCommentService; _iConsultationService = iConsultationService; _iCouponService = iCouponService; _iCashDepositsService = iCashDepositsService; _iTypeService = iTypeService; }
private async void GetAttributeList() { ITypeService type_service = service_factory.CreateClient <ITypeService>(); using (type_service) { try { Task <List <AttributeType> > task = type_service.GetAttributeTypeListAsync(); await task; List <AttributeType> atttype_list = task.Result; ObservableCollection <AttributeType> atttypes = new ObservableCollection <AttributeType>(atttype_list); var acct_atts = atttype_list.Where(item => item.AttributeTypeCategory == "Company").ToList(); var gcnt_atts = atttype_list.Where(item => item.AttributeTypeCategory == "Company Contact").ToList(); var all_atts = acct_atts.Concat(gcnt_atts); List <AttributeType> available_attribute_types = new List <AttributeType>(all_atts); LoadEntityAttrbuteList(available_attribute_types); } catch (Exception ex) { DisplayErrorMessage(ex); return; } } }
public override void Process(ITypeService service, MethodDef m, MethodSpec o) { foreach (var t in o.GenericInstMethodSig.GenericArguments) { service.AddAssociatedType(m, t); } }
internal async Task InitializeAsync() { IndexCommand.ResetQueryCache(); Indexes = new List <IIndexProvider>(); ScopedIndexes = new List <Type>(); ValidateConfiguration(); _sessionPool = new ObjectPool <Session>(MakeSession, Configuration.SessionPoolSize); Dialect = SqlDialectFactory.For(Configuration.ConnectionFactory.DbConnectionType); TypeNames = new TypeService(); using (var connection = Configuration.ConnectionFactory.CreateConnection()) { await connection.OpenAsync(); using (var transaction = connection.BeginTransaction()) { var builder = new SchemaBuilder(Configuration, transaction); await Configuration.IdGenerator.InitializeAsync(this, builder); transaction.Commit(); } //)FIXME : in Oracle it's forbidden to index an already indexed column and PK/UK is already indexed //.AlterTable(LinearBlockIdGenerator.TableName, table => table // .CreateIndex("IX_Dimension", "dimension") } // Pee-initialize the default collection await InitializeCollectionAsync(Dialect.NullString); }
public Generator(GeneratorOptions options, ILogger logger = null) { Requires.NotNull(options, nameof(options)); _generationContext = new GenerationContext(); FileContentGenerated += OnFileContentGenerated; Options = options; Logger = logger; var generatorOptionsProvider = new GeneratorOptionsProvider { GeneratorOptions = options }; var internalStorage = new InternalStorage(); _fileSystem = new FileSystem(); _metadataReaderFactory = new MetadataReaderFactory(); _typeService = new TypeService(_metadataReaderFactory, generatorOptionsProvider); _typeDependencyService = new TypeDependencyService(_typeService, _metadataReaderFactory); _templateService = new TemplateService(internalStorage, generatorOptionsProvider); _tsContentGenerator = new TsContentGenerator(_typeDependencyService, _typeService, _templateService, new TsContentParser(_fileSystem), _metadataReaderFactory, generatorOptionsProvider, logger); }
public SystemBlockHandler(ITypeService typeService) { this.typeService = typeService; components = new Dictionary <ComponentType, IContainer>(); Clear(); }
public OrderComplaintController(IOrderService iOrderService, IShopService iShopService, IComplaintService iComplaintService, ITypeService iTypeService) { _iOrderService = iOrderService; _iShopService = iShopService; _iComplaintService = iComplaintService; _iTypeService = iTypeService; }
public UserOrderController( IShopBonusService iShopBonusService, ICashDepositsService iCashDepositsService, ISiteSettingService iSiteSettingService, IOrderService iOrderService, IRefundService iRefundService, ICustomerService iCustomerService, IProductService iProductService, ICouponService iCouponService, ICommentService iCommentService, IFightGroupService iFightGroupService, ITypeService iTypeService ) { _iShopBonusService = iShopBonusService; _iCashDepositsService = iCashDepositsService; _iSiteSettingService = iSiteSettingService; _iOrderService = iOrderService; _iRefundService = iRefundService; _iCustomerService = iCustomerService; _iProductService = iProductService; _iCouponService = iCouponService; _iCommentService = iCommentService; _iFightGroupService = iFightGroupService; _iTypeService = iTypeService; }
public MainPage() { InitializeComponent(); _userService = InstanceFactory.GetInstance <IUserService>(); _categoryService = InstanceFactory.GetInstance <ICategoryService>(); _typeService = InstanceFactory.GetInstance <ITypeService>(); }
public CheckpointController(ICheckpointService checkpointService, ITypeService typeService, IAdmissionService admissionService) { this.checkpointService = checkpointService; this.typeService = typeService; this.admissionService = admissionService; }
public TypeModuleFeedbackController(ITypeDataDefineService td, ITypeService ts, ITypeModuleControlService tmcs, ITypeModuleFeedbackService tfs) { this._td = td; this._ts = ts; this._tmcs = tmcs; this._tfs = tfs; }
public override void ProcessOperand(ITypeService service, MethodDef method, IList <Instruction> body, ref int index, MethodDef operand) { var currentMethod = service.GetScannedItem(method); var targetMethod = service.GetScannedItem(operand); /* //Type field scrabmble * var targetType = service.GetScannedItem(operand.DeclaringType); * if (targetType != null) { * var typeSigList = targetType.GenericCallTypes.Select(x => currentMethod?.ToGenericIfAvalible(x) ?? x).ToArray(); * new TypeSpecUser(new GenericInstSig(new ClassSig(operand.DeclaringType), typeSigList)); * } */ if (body[index].OpCode == OpCodes.Newobj) { FactoryHealper.ApplyObjectCreationProxy(service, currentMethod, body, ref index, operand); } else { FactoryHealper.ApplyCallProxy(service, currentMethod, body, ref index, operand); } if (targetMethod != null) { var typeSigList = targetMethod.GenericCallTypes.Select(x => currentMethod?.ToGenericIfAvalible(x) ?? x).ToArray(); body[index].Operand = new MethodSpecUser(operand, new GenericInstMethodSig(typeSigList)); } }
public TypeModuleControlController(ITypeDataDefineService td, ITypeService ts, ITypeModuleService tms, ITypeModuleControlService tmcs) { this._td = td; this._ts = ts; this._tms = tms; this._tmcs = tmcs; }
public TypeController(ITypeService tserv, ILevelService lserv, ICourseService cserv, ISectionService sserv) { this.typeService = tserv; this.levelService = lserv; this.courseService = cserv; this.sectionService = sserv; }
public TypeImageController(ILogger <TypeImageController> log, ITypeImageService ti, IConfiguration config, IWebHostEnvironment webHostEnvironment, ITypeService ts) { this._log = log; this._ti = ti; this._config = config; this._webHostEnvironment = webHostEnvironment; this._ts = ts; }
public FinanceFormFactory(IPaymentService paymentService, ICategoryService categoryService, ITypeService typeService, IStatusService statusService, ITemplateService paymentTemplateService) { _paymentService = paymentService; _categoryService = categoryService; _typeService = typeService; _statusService = statusService; _paymentTemplateService = paymentTemplateService; }
public TypeController(ILogger <TypeController> log, IConfiguration config, ITypeService ts, IGroupService gs, IWebHostEnvironment webHostEnvironment) { this._log = log; this._ts = ts; this._gs = gs; this._webHostEnvironment = webHostEnvironment; this._config = config; }
public TourController(ITourService tourService, ITypeService typeService, IUserService userService) { this.tourService = tourService; this.typeService = typeService; this.userService = userService; }
public ProductController(IProductService productService, ISizeService sizeService, ITypeService typeService, IOriginService originService, IModelService modelService) { _productService = productService; _sizeService = sizeService; _typeService = typeService; _originService = originService; _modelService = modelService; }
public void Dispose() { if (channel != null) { channel.Dispose(); channel = null; } }
public ProductTypeController(ITypeService iTypeService, IOperationLogService iOperationLogService, IBrandService iBrandService) { _iTypeService = iTypeService; _iOperationLogService = iOperationLogService; _iBrandService = iBrandService; }
public TradeHelper() { regionService = Himall.ServiceProvider.Instance <IRegionService> .Create; _iOrderService = Himall.ServiceProvider.Instance <IOrderService> .Create; _iMemberService = Himall.ServiceProvider.Instance <IMemberService> .Create; _iFightGroupService = Himall.ServiceProvider.Instance <IFightGroupService> .Create; _iTypeService = Himall.ServiceProvider.Instance <ITypeService> .Create; }
/// <summary> /// /// </summary> /// <param name="typeService"></param> /// <exception cref="ArgumentNullException"></exception> public IsAssignable(ITypeService typeService) { // validate arguments if (typeService == null) throw new ArgumentNullException("typeService"); this.typeService = typeService; }
/// <summary> /// Constructs a listening decorated <see cref="IRepository"/>. /// </summary> /// <param name="decoratedRepository">The <see cref="IRepository"/> being decorated.</param> /// <param name="typeService">The <see cref="ITypeService"/>.</param> public ListeningRepositoryDecorator(IRepository decoratedRepository, ITypeService typeService) : base(decoratedRepository) { // validate arguments if (typeService == null) throw new ArgumentNullException("typeService"); // set values this.typeService = typeService; }
/// <summary> /// /// </summary> /// <param name="typeService"></param> /// <exception cref="ArgumentNullException"></exception> public GetProtectedResourceDatasetTag(ITypeService typeService) { // validate arguments if (typeService == null) throw new ArgumentNullException("typeService"); // set values this.typeService = typeService; }
/// <summary> /// Constructs this processor. /// </summary> public TypeArgumentProcessor(ITypeService typeService) : base(100) { // validate arguments if (typeService == null) throw new ArgumentNullException("typeService"); // set values this.typeService = typeService; }
/// <summary> /// /// </summary> /// <param name="typeService"></param> public GroupTypeFacetsTag(ITypeService typeService) { // validate arguments if (typeService == null) throw new ArgumentNullException("typeService"); // set value this.typeService = typeService; }
/// <summary> /// /// </summary> public SchemaCreatorApplicationInitializer(ITypeService typeService) : base(20) { // validate arguments if (typeService == null) throw new ArgumentNullException("typeService"); // set values this.typeService = typeService; }
/// <summary> /// /// </summary> /// <param name="typeService"></param> /// <exception cref="ArgumentNullException"></exception> public TypeExists(ITypeService typeService) { // validate arguments if (typeService == null) throw new ArgumentNullException("typeService"); // set values this.typeService = typeService; }
/// <summary> /// Initializes a new instance of the <see cref="JetModelBinder" /> class. /// </summary> /// <param name="typeService">The type service.</param> /// <exception cref="ArgumentNullException">Thrown if <paramref name="typeService" /> is <c>null</c>.</exception> public JetModelBinder(ITypeService typeService) { if (typeService == null) { throw new ArgumentNullException(); } _typeService = typeService; }
/// <summary> /// /// </summary> /// <param name="typeService"></param> /// <exception cref="ArgumentNullException"></exception> public GetTypeDefinitionProperty(ITypeService typeService) { // validate arguments if (typeService == null) throw new ArgumentNullException("typeService"); // set values this.typeService = typeService; }
/// <summary> /// </summary> /// <param name="typeService"></param> /// <exception cref="ArgumentNullException"></exception> public UpdateNodeCommand(ITypeService typeService) { // validate arguments if (typeService == null) throw new ArgumentNullException("typeService"); // set values this.typeService = typeService; }
/// <summary> /// /// </summary> /// <param name="parser"></param> /// <param name="typeService"></param> /// <exception cref="ArgumentNullException"></exception> public RetrieveLayoutNodeTag(IQueryParser parser, ITypeService typeService) : base(parser) { // validate arguments if (typeService == null) throw new ArgumentNullException("typeService"); // set values this.typeService = typeService; }
/// <summary> /// /// </summary> /// <param name="nucleus"> </param> /// <param name="typeService"></param> /// <exception cref="ArgumentNullException"></exception> /// <exception cref="InvalidOperationException"></exception> public NodeUrlService(INucleus nucleus, ITypeService typeService) { // validate arguments if (nucleus == null) throw new ArgumentNullException("nucleus"); if (typeService == null) throw new ArgumentNullException("typeService"); // set values this.typeService = typeService; }
/// <summary> /// Constructs the index definition resolver. /// </summary> /// <param name="typeService">The <see cref="ITypeDefinition"/>.</param> /// <param name="cachingService">The <see cref="ICachingService"/>.</param> public IndexDefinitionResolver(ITypeService typeService, ICachingService cachingService) { // validate arguments if (typeService == null) throw new ArgumentNullException("typeService"); if (cachingService == null) throw new ArgumentNullException("cachingService"); // set values this.typeService = typeService; this.cachingService = cachingService; }
/// <summary> /// /// </summary> /// <param name="typeService"></param> /// <param name="parser"> </param> /// <param name="repository"></param> /// <exception cref="ArgumentNullException"></exception> public SyncTablesTag(ITypeService typeService, IQueryParser parser, SqlServerRepository repository) { // validate arguments if (typeService == null) throw new ArgumentNullException("typeService"); if (parser == null) throw new ArgumentNullException("parser"); if (repository == null) throw new ArgumentNullException("repository"); // set values this.typeService = typeService; this.parser = parser; this.repository = repository; }
public DefaultRequestRuntimeProvider(ITypeService typeService) { _typeService = typeService; }
public DefaultRequestHandlerProvider(ITypeService typeService) { _typeService = typeService; }
public DefaultRequestAuthorizerProvider(ITypeService typeService) { _typeService = typeService; }
public DefaultRequestIgnorerProvider(ITypeService typeService) { _typeService = typeService; }
public TypeController(ITypeService service) { _typeService = service; }