public void Cointeiners_Creating() { Point <int> point3D = new Point <int>(3, 3, 3); Point <int> point2D = new Point <int>(2, 2); Position <int> position3D = new Position <int>(); Position <int> position2D = new Position <int>(); Matrix <int> matrix_1 = new Matrix <int>(); Matrix <int> matrix_2 = new Matrix <int>(); Container <int> container_1 = new Container <int>(); Container <int> container_2 = new Container <int>(); Containers <int> containers = new Containers <int>(); position3D.Add(point3D); position3D.Add(point3D); position3D.Add(point3D); matrix_1.Add(position3D); matrix_1.Add(position3D); container_1.Add(matrix_1); container_1.Add(matrix_1); container_2.Add(matrix_1); containers.Add(container_1); containers.Add(container_1); Assert.IsNotEmpty(containers); Assert.True(containers.ContainerSize == containers.Count); Assert.Throws <ContainerRulesException>(() => containers.Add(container_2)); }
public void CollectionRule2() //The number of data points at each XYZ position will be the same for all positions on a matrix and across equivalent matrix indexes across containers. { Point <int> point3D = new Point <int>(3, 3, 3); Point <int> point2D = new Point <int>(2, 2); Position <int> position3D_1 = new Position <int>(); Position <int> position3D_2 = new Position <int>(); Position <int> position2D_1 = new Position <int>(); Position <int> position2D_2 = new Position <int>(); Matrix <int> matrix_1 = new Matrix <int>(); Matrix <int> matrix_2 = new Matrix <int>(); Container <int> container_1 = new Container <int>(); Container <int> container_2 = new Container <int>(); Containers <int> containers = new Containers <int>(); position3D_1.Add(point3D); position3D_2.Add(point3D); position3D_2.Add(point3D); position2D_1.Add(point2D); position2D_1.Add(point2D); position2D_2.Add(point2D); matrix_1.Add(position3D_1); matrix_1.Add(position3D_2); matrix_2.Add(position2D_1); matrix_2.Add(position2D_2); container_1.Add(matrix_1); container_1.Add(matrix_2); container_1.Add(matrix_1); container_2.Add(matrix_1); container_2.Add(matrix_2); container_2.Add(matrix_1); containers.Add(container_1); containers.Add(container_2); containers.Add(container_1); }
/// <remarks></remarks> public Maybe <T> UpsertBlobOrSkip <T>( string containerName, string blobName, Func <Maybe <T> > insert, Func <T, Maybe <T> > update, IDataSerializer serializer = null) { lock (_syncRoot) { Maybe <T> input; if (Containers.ContainsKey(containerName)) { if (Containers[containerName].BlobNames.Contains(blobName)) { var blobData = Containers[containerName].GetBlob(blobName); input = blobData == null ? Maybe <T> .Empty : (T)blobData; } else { input = Maybe <T> .Empty; } } else { Containers.Add(containerName, new MockContainer()); input = Maybe <T> .Empty; } var output = input.HasValue ? update(input.Value) : insert(); if (output.HasValue) { Containers[containerName].SetBlob(blobName, output.Value); } return(output); } }
public override void Init() { Containers.Add(new PlayNavigationContainer(GameManager)); Containers.Add(new CalendarContainer(GameManager)); SelectContainer(Containers[0]); }
/// <summary> /// Creates a re-occurring job scheduler. /// </summary> /// <param name="queueConnection">Queue and connection information.</param> /// <returns></returns> public IJobSchedulerLastKnownEvent CreateJobSchedulerLastKnownEvent(QueueConnection queueConnection) { var container = _createContainerInternal().Create(QueueContexts.ProducerMethodQueue, _registerService, queueConnection, _transportInit, ConnectionTypes.Send, x => { }, _setOptions); Containers.Add(container); return(container.GetInstance <IJobSchedulerLastKnownEvent>()); }
/* ---------------------------------------------------- */ // メソッド /* ---------------------------------------------------- */ public void Initialize() { for (int i = -numofBackwardContainer; i <= numofForwardContainer; i++) { Containers.Add(new ImgContainer(i)); } }
public static void AddContainer(int _id, int idNode) { Container cont = new Container(_id, Graph.FindNodeById(idNode)); Containers.Add(cont); OnCreateContainer?.Invoke(cont); }
/// <summary> /// Constructs an instance from the dynamic network information returned by /// the Docker engine. /// </summary> /// <param name="source">The dynamic source value.</param> internal DockerNetwork(dynamic source) : this() { this.Inner = source; this.Name = source.Name; this.Id = source.Id; this.Scope = source.Scope; this.Driver = source.Driver; this.EnableIPv6 = source.EnableIPv6; this.Internal = source.Internal; this.Ipam = new DockerNetworkIpam(source.IPAM); foreach (var item in source.Containers) { Containers.Add(new DockerNetworkContainer(item)); } foreach (var item in source.Options) { Options.Add(item.Name, item.Value.ToString()); } foreach (var item in source.Labels) { Labels.Add(item.Name, item.Value.ToString()); } }
/// <summary> /// Creates the task factory. /// </summary> /// <returns></returns> public ITaskFactory CreateTaskFactory() { var container = _createContainerInternal().Create(QueueContexts.TaskFactory, _registerService, _transportInit, x => { }, _setOptions); Containers.Add(container); return(CreateTaskFactoryInternal(container.GetInstance <ATaskScheduler>(), true)); }
public void Add_DiffNumberOfPositionIn3DIndexedMatrices_ExceptionThrown() { var container = new Container <int>(); var list = new List <Matrix <int> >(); for (int i = 0; i < _matrices.Count; i++) { if (i == 1) { list.Add(Matrix <int> .CreateMatrix(Point <int> .PointType.Point3d, 10)); } else { list.Add(Matrix <int> .CreateMatrix(Point <int> .PointType.Point3d, 9)); } } foreach (var item in list) { container.Add(item); } var containers = new Containers <int>(); containers.Add(container); }
public void AddContainer(StorageContainer container) { Containers.Add(container); TotalStorageSpace = Containers.Sum(p => p.Size); Available += container.Size; }
protected override IStatement ConvertFor(IForStatement ifs) { var loopSize = Recognizer.LoopSizeExpression(ifs); if (!((loopSize is IVariableReferenceExpression) || (loopSize is IArrayIndexerExpression) || (loopSize is IArgumentReferenceExpression) || (loopSize is ILiteralExpression) || (loopSize is IPropertyReferenceExpression))) { Error("Invalid expression type for the size of a loop (" + loopSize.GetType().Name + "): " + loopSize); return(ifs); } if (loopSize is ILiteralExpression) { // remove loops that execute for 0 iterations int loopSizeAsInt = (int)((ILiteralExpression)loopSize).Value; if (loopSizeAsInt == 0) { return(null); } } Containers c = Containers.GetContainersNeededForExpression(context, loopSize); c.Add(ifs); IVariableDeclaration loopVar = Recognizer.LoopVariable(ifs); context.InputAttributes.Remove <Containers>(loopVar); context.InputAttributes.Set(loopVar, c); return(base.ConvertFor(ifs)); }
public override void Init() { Containers.Add(new NavigationContainer(this.GameManager)); Containers.Add(new MainMenuHelpContainer(GameManager)); SelectContainer(Containers[0]); }
private static void Register(RootDependencyContainer container) { if (!Containers.Contains(container)) { Containers.Add(container); } }
public void InjectModule(ModuleInfo objModule) { bool bSuccess = true; try { if (!Common.Globals.IsAdminControl()) { PaneControl.Controls.Add(new LiteralControl("<a name=\"" + objModule.ModuleID.ToString() + "\"></a>")); } Containers.Container ctlContainer = LoadModuleContainer(objModule); Containers.Add(ctlContainer.ID, ctlContainer); if (Common.Globals.IsLayoutMode() && Common.Globals.IsAdminControl() == false) { Panel ctlDragDropContainer = new Panel(); System.Web.UI.Control ctlTitle = ctlContainer.FindControl("dnnTitle"); ctlDragDropContainer.ID = ctlContainer.ID + "_DD"; PaneControl.Controls.Add(ctlDragDropContainer); ctlDragDropContainer.Controls.Add(ctlContainer); if (ctlTitle != null) { if (ctlTitle.Controls.Count > 0) { ctlTitle = ctlTitle.Controls[0]; } } //if (ctlDragDropContainer != null && ctlTitle != null) //{ // ClientAPI.EnableContainerDragAndDrop(ctlTitle, ctlDragDropContainer, objModule.ModuleID); // ClientAPI.RegisterPostBackEventHandler(PaneControl, "MoveToPane", ModuleMoveToPanePostBack, false); //} } else { PaneControl.Controls.Add(ctlContainer); } ctlContainer.SetModuleConfiguration(objModule); if (PaneControl.Visible == false) { PaneControl.Visible = true; } } catch (Exception exc) { ModuleLoadException lex; lex = new ModuleLoadException(string.Format(Skin.MODULEADD_ERROR, PaneControl.ID.ToString()), exc); if (TabPermissionController.CanAdminPage()) { PaneControl.Controls.Add(new ErrorContainer(PortalSettings, Skin.MODULELOAD_ERROR, lex).Container); } Exceptions.LogException(exc); bSuccess = false; throw lex; } if (!bSuccess) { throw new ModuleLoadException(); } }
public MyCosmosDbDescriptor() { DatabaseId = "MyDB"; ClientOptions.ApplicationName = "MyAppName"; Containers.Add(new MyCosmosDbContainerDescriptor()); }
/// <summary> /// Creates the consumer method queue scheduler. /// </summary> /// <param name="queue">The queue.</param> /// <param name="connection">The connection.</param> /// <param name="factory">The factory.</param> /// <param name="workGroup">The work group.</param> /// <param name="internalFactory">if set to <c>true</c> [internal factory].</param> /// <returns></returns> private IConsumerMethodQueueScheduler CreateConsumerMethodQueueSchedulerInternal(string queue, string connection, ITaskFactory factory, IWorkGroup workGroup, bool internalFactory) { Guard.NotNullOrEmpty(() => queue, queue); Guard.NotNullOrEmpty(() => connection, connection); IContainer container; if (internalFactory) //we own factory { if (workGroup == null) { container = _createContainerInternal() .Create(QueueContexts.ConsumerMethodQueueScheduler, _registerService, queue, connection, _transportInit, ConnectionTypes.Receive, serviceRegister => serviceRegister.Register(() => factory, LifeStyles.Singleton) .Register <IWorkGroup>(() => new WorkGroupNoOp(), LifeStyles.Singleton) .Register(() => factory.Scheduler, LifeStyles.Singleton), _setOptions); } else { container = _createContainerInternal() .Create(QueueContexts.ConsumerMethodQueueScheduler, _registerService, queue, connection, _transportInit, ConnectionTypes.Receive, serviceRegister => serviceRegister.Register(() => factory, LifeStyles.Singleton) .Register(() => workGroup, LifeStyles.Singleton) .Register(() => factory.Scheduler, LifeStyles.Singleton), _setOptions); } } else //someone else owns factory { if (workGroup == null) { container = _createContainerInternal() .Create(QueueContexts.ConsumerMethodQueueScheduler, _registerService, queue, connection, _transportInit, ConnectionTypes.Receive, serviceRegister => serviceRegister.RegisterNonScopedSingleton(factory) .Register <IWorkGroup>(() => new WorkGroupNoOp(), LifeStyles.Singleton) .RegisterNonScopedSingleton(factory.Scheduler), _setOptions); } else { container = _createContainerInternal() .Create(QueueContexts.ConsumerMethodQueueScheduler, _registerService, queue, connection, _transportInit, ConnectionTypes.Receive, serviceRegister => serviceRegister.RegisterNonScopedSingleton(factory) .Register(() => workGroup, LifeStyles.Singleton) .RegisterNonScopedSingleton(factory.Scheduler), _setOptions); } } Containers.Add(container); return(container.GetInstance <IConsumerMethodQueueScheduler>()); }
/// <summary>Creates the method consumer queue.</summary> /// <param name="queueConnection">Queue and connection information.</param> /// <param name="registerServiceInternal">overrides for the internal container</param> /// <returns></returns> public IConsumerMethodQueue CreateMethodConsumer(QueueConnection queueConnection, Action <IContainer> registerServiceInternal) { Guard.NotNull(() => queueConnection, queueConnection); var container = _createContainerInternal().Create(QueueContexts.ConsumerMethodQueue, _registerService, queueConnection, _transportInit, ConnectionTypes.Receive, registerServiceInternal, _setOptions); Containers.Add(container); return(container.GetInstance <IConsumerMethodQueue>()); }
/// <summary> /// Creates a new instance of <see cref="IQueueStatus" /> /// </summary> /// <returns></returns> public IQueueStatus CreateStatus() { //when creating a status module outside of the queue itself, use a no-op system information module var container = _createContainerInternal().Create(QueueContexts.QueueStatus, _registerService, _transportInit, x => { }, _setOptions); Containers.Add(container); return(container.GetInstance <IQueueStatus>()); }
/// <summary> /// Creates a new status provider. /// </summary> /// <returns></returns> public IQueueStatusProvider CreateStatusProvider <TTransportInit>(Action <IContainer> registerService, string queue, string connection) where TTransportInit : ITransportInit, new() { var creator = new QueueContainer <TTransportInit>(registerService); Containers.Add(creator); return(creator.CreateStatusProvider(queue, connection)); }
/// <summary> /// Creates an async consumer queue /// </summary> /// <param name="queueConnection">Queue and connection information.</param> /// <returns></returns> public IConsumerQueueAsync CreateConsumerAsync(QueueConnection queueConnection) { Guard.NotNull(() => queueConnection, queueConnection); var container = _createContainerInternal().Create(QueueContexts.ConsumerQueueAsync, _registerService, queueConnection, _transportInit, ConnectionTypes.Receive, x => { }, _setOptions); Containers.Add(container); return(container.GetInstance <IConsumerQueueAsync>()); }
/// <summary> Adds a new container information object to this descriptive information </summary> /// <param name="Container_Type"> General type of this container ( usually 'box', 'folder', etc.. )</param> /// <param name="Container_Title"> Title or label for this container</param> public void Add_Container(string Container_Type, string Container_Title) { if (Containers == null) { Containers = new List <Parent_Container_Info>(); } Containers.Add(new Parent_Container_Info(Container_Type, Container_Title)); }
// Puts valuable containers, if any on top. private void MoveValuableToTop() { if (HaValuable) { var valContainer = (ValuableContainer)Containers.Find(v => v.TopStackAllowed == false); Containers.Remove(valContainer); Containers.Add(valContainer); } }
private CloudBlobContainer GetContainer(string containerName) { if (!Containers.ContainsKey(containerName)) { Containers.Add(containerName, GetClient().GetContainerReference(containerName)); Containers[containerName].CreateIfNotExistsAsync().Wait(); } return(Containers[containerName]); }
/// <summary> /// SetPosition make's sure that valuable containers get placed on top. /// </summary> public void SetPosition() { if (Containers.Find(x => (x.Valuable)) != null) { var valuable = Containers[0]; Containers.RemoveAt(0); Containers.Add(valuable); } ; }
private Containers GetContainers() { var containers = new Containers(); foreach (var container in openContainers.Reverse()) { containers.Add(Containers.CreateContainer(container)); } return(containers); }
/// <summary> /// Creates a producer queue for executing linq expressions. /// </summary> /// <param name="queueConnection">Queue and connection information.</param> /// <returns></returns> public IProducerMethodJobQueue CreateMethodJobProducer( QueueConnection queueConnection) { Guard.NotNull(() => queueConnection, queueConnection); var container = _createContainerInternal().Create(QueueContexts.ProducerMethodQueue, _registerService, queueConnection, _transportInit, ConnectionTypes.Send, x => { }, _setOptions); Containers.Add(container); return(container.GetInstance <IProducerMethodJobQueue>()); }
/// <summary> /// Creates the method consumer queue. /// </summary> /// <param name="queue">The queue.</param> /// <param name="connection">The connection.</param> /// <returns></returns> public IConsumerMethodQueue CreateMethodConsumer(string queue, string connection) { Guard.NotNullOrEmpty(() => queue, queue); Guard.NotNullOrEmpty(() => connection, connection); var container = _createContainerInternal().Create(QueueContexts.ConsumerMethodQueue, _registerService, queue, connection, _transportInit, ConnectionTypes.Receive, x => { }, _setOptions); Containers.Add(container); return(container.GetInstance <IConsumerMethodQueue>()); }
/// <summary> /// Creates an async consumer queue that uses a task scheduler. The default task factory will be used. /// </summary> /// <param name="queueConnection">Queue and connection information.</param> /// <returns></returns> public IConsumerMethodQueueScheduler CreateConsumerMethodQueueScheduler(QueueConnection queueConnection) { Guard.NotNull(() => queueConnection, queueConnection); var schedulerCreator = new SchedulerContainer(_registerService); var factory = schedulerCreator.CreateTaskFactory(); factory.Scheduler.Start(); Containers.Add(schedulerCreator); return(CreateConsumerMethodQueueSchedulerInternal(queueConnection, factory, null, true)); }
/// <summary> /// Creates a producer queue. /// </summary> /// <typeparam name="TMessage">The type of the message.</typeparam> /// <param name="queueConnection">Queue and connection information.</param> /// <returns></returns> public IProducerQueue <TMessage> CreateProducer <TMessage>( QueueConnection queueConnection) where TMessage : class { Guard.NotNull(() => queueConnection, queueConnection); var container = _createContainerInternal().Create(QueueContexts.ProducerQueue, _registerService, queueConnection, _transportInit, ConnectionTypes.Send, x => { }, _setOptions); Containers.Add(container); return(container.GetInstance <IProducerQueue <TMessage> >()); }