public bool AddWorkableUnitToQueue(string nom, Type model, Coordinates parkingPos, Coordinates workingPos) { //- L’usine ne peut enregistrer plus de commandes si sa queue est pleine //- L’usine ne peut construire plus de robots si son entrepôt est plein if ((Queue.Count <= this.QueueCapacity) && ((Queue.Count <= this.StorageCapacity))) { FactoryQueueElement add = new FactoryQueueElement(nom, model, parkingPos, workingPos); Queue.Enqueue(add); if (_instanceUnitFactory == null) { lock (obj) { if (_instanceUnitFactory == null) { // _instanceUnitFactory = add; } } } return(true); } else { return(false); } //- L’usine ne peut construire qu’un robot à la fois. //- On peut appeler l’ajout de commande n’importe quand //- La méthode doit retourner false si la commande n’est pas enregistrée //- La construction doit être active tant que la queue n’est pas vide ou l’entrepôt plein //- La construction d’un robot doit être simulée et prendre le temps indiqué par la propriété BuildTime du robot }
public bool AddWorkableUnitToQueue(Type model, string name, Coordinates parkingPos, Coordinates workingPos) { OnStatusChangedFactory(new StatusChangedEventArgs("Adding " + name + " to Queue ...")); if (this.Queue.Count < this.QueueCapacity && this.Storage.Count < this.StorageCapacity) { FactoryQueueElement commande = new FactoryQueueElement(name, model, parkingPos, workingPos); Queue.Add(commande); OnStatusChangedFactory(new StatusChangedEventArgs("test")); object robot = Activator.CreateInstance(model); ITestingUnit robotToTest = Activator.CreateInstance(commande.Model, new object[] { }) as ITestingUnit; robotToTest.Model = name; robotToTest.ParkingPos = parkingPos; robotToTest.WorkingPos = workingPos; Thread th = new Thread(() => { OnStatusChangedFactory(new StatusChangedEventArgs("test")); lock (thisLock) { Thread.Sleep(Convert.ToInt32(robotToTest.BuildTime) * 1000); Storage.Add(robotToTest); Queue.RemoveAt(Queue.Count - 1); QueueTime += DateTime.Now.AddSeconds(Convert.ToInt32(robotToTest.BuildTime)) - DateTime.Now; OnStatusChangedFactory(new StatusChangedEventArgs("test")); } OnStatusChangedFactory(new StatusChangedEventArgs("test 2")); }); th.Start(); return(true); } return(false); }
private void addRobotToStorage() { StatusChangedEventArgs s = new StatusChangedEventArgs(); s.NewStatus = "Robot start creation"; FactoryProgress(this, s); FactoryQueueElement first = _queue.First(); ITestingUnit toStore = ( ITestingUnit )Activator.CreateInstance(first.Model); toStore.WorkingPos = first.WorkingPos; toStore.ParkingPos = first.ParkingPos; toStore.Name = first.Name; Thread.Sleep(((int)toStore.BuildTime * 1000)); _storage.Add(toStore); StorageFreeSlots = StorageCapacity - _storage.Count(); _queue.Remove(first); QueueFreeSlots = QueueCapacity - _queue.Count(); TimeSpan sp = TimeSpan.FromSeconds(toStore.BuildTime); QueueTime = QueueTime.Subtract(sp); s.NewStatus = "Robot created"; FactoryProgress(this, s); }
/// <summary> /// Ajoute un nouvel élément à la liste de commande et relance la production si besoin /// </summary> /// <param name="inModel">Type de robot à construire</param> /// <param name="inUnitName">Nom du robot</param> /// <param name="inWorkingPos">Position de travail</param> /// <param name="inParkPos">Position de recharge</param> /// <returns></returns> public bool AddWorkableUnitToQueue(Type inModel, string inUnitName, Coordinates inWorkingPos, Coordinates inParkPos) { if (m_Queue.Count >= m_QueueCapacity) { return(false); } // l'ajoute à la liste FactoryQueueElement lOrder = new FactoryQueueElement(inUnitName, inModel, inParkPos, inWorkingPos); m_Queue.Add(lOrder); //On met à jour l'event FactoryProgressEventArgs lNewOrder = new FactoryProgressEventArgs(); lNewOrder.QueueElement = lOrder; OnStatusChanged(lNewOrder); // lance la construction si ce n'est pas déjà en cours if (!m_IsBuilding) { BuildWorkableUnit(); } return(true); }
private void BuildRobot(FactoryQueueElement queueElement) { if (queueElement == null) { return; } this.Queue.Remove(queueElement); this.QueueFreeSlots += 1; IWorkingUnit workingUnit = (IWorkingUnit)Activator.CreateInstance(queueElement.Model.UnderlyingSystemType, queueElement.Name, 0); workingUnit.Model = queueElement.Model; workingUnit.ParkingPos = queueElement.ParkingPos; workingUnit.WorkingPos = queueElement.WorkingPos; workingUnit.WorkBegins(); workingUnit.WorkEnds(); //this.Storage.Add(workingUnit); //// Usine signale que la construction d'un robot s'achève //if (this.FactoryProgress != null) //{ this.FactoryProgress(this, new EventArgs()); } TimeSpan ts = TimeSpan.FromMilliseconds(workingUnit.BuildTime); this.QueueTime = this.QueueTime.Add(ts); }
public bool CreaInstance(FactoryQueueElement felement) { lock (this) { ITestingUnit elementinstan = Construire(felement); _storage.Add(elementinstan); return(true); } }
private void BuildRobot(FactoryQueueElement newElement) { FactoryStatusArg factoryStatusArg = new FactoryStatusArg(); factoryStatusArg.QueueBot = newElement; if (FactoryStatus != null) { FactoryStatus(this, factoryStatusArg); } BaseUnit robot = (BaseUnit)Activator.CreateInstance(newElement.Model); robot.UnitStatusChanged += robotUnitStatusChanged; robot.Status = RobotStatus.Built; }
/// <summary> /// On ajoute une nouveau robot dans la file d'attente /// </summary> /// <param name="modeleName">Le modèle du robot à ajouter</param> /// <param name="unitName">Le nom du robot</param> /// <param name="parkingPos">La position de station du robot</param> /// <param name="workingPos">La position de travail du robot</param> public void AddWorkableUnitToQueue(Type modeleName, string unitName, Coordinates parkingPos, Coordinates workingPos) { // On vérifie si il reste de la place dans la file d'attente et dans l'entrepot if ((_queue.Count() < QueueCapacity) && (_storage.Count() + _queue.Count < StorageCapacity)) { // On ajoute un élément dans la file d'attente FactoryQueueElement queueElement = new FactoryQueueElement(modeleName, unitName, parkingPos, workingPos); _queue.Enqueue(queueElement); //On ajoute du temps dans la file d'attente ITestingUnit recupTime = Activator.CreateInstance(queueElement.Model, new object[] { }) as ITestingUnit; QueueTime = QueueTime.Add(new TimeSpan(0, 0, Convert.ToInt32(recupTime.BuildTime))); //Création d'un thread permettant de construire un robot (un seul robot est créé à la fois) Thread threadBuildUnit = new Thread(() => { lock (_lockBuildingUnit) { FactoryQueueElement nextQueueElement = (FactoryQueueElement)_queue.Peek(); // On récupére par reflexion les informations sur un robot ITestingUnit newUnit = Activator.CreateInstance(nextQueueElement.Model, new object[] { }) as ITestingUnit; newUnit.Model = nextQueueElement.Name; newUnit.ParkingPos = nextQueueElement.ParkingPos; newUnit.WorkingPos = nextQueueElement.WorkingPos; BuildingUnit(newUnit); } }); threadBuildUnit.Start(); } else { if (_queue.Count() >= QueueCapacity) { MessageBox.Show("Max unit in queue"); } else { MessageBox.Show("Max unit in factory"); } } }
public bool AddWorkableUnitToQueue(Type model, string name, Coordinates parkingPos, Coordinates workingPos) { var isAdded = false; if (Queue.Count < QueueCapacity) { FactoryQueueElement queueElement = new FactoryQueueElement(); queueElement.Model = model; queueElement.Name = name; queueElement.ParkingPos = parkingPos; queueElement.WorkingPos = workingPos; _iFactoryQueueElement = queueElement; Queue.Enqueue(_iFactoryQueueElement); isAdded = true; var createThread = new Thread(new ThreadStart(CreateUnit)); createThread.Start(); } return(isAdded); }
public bool AddWorkableUnitToQueue(Type model, string name, Coordinates parkingPos, Coordinates workingPos) { if (this.QueueFreeSlots > 0 && this.QueueFreeSlots <= this.QueueCapacity && this.StorageFreeSlots > 0 && this.StorageFreeSlots <= this.StorageCapacity) { // Création d'un nouveau robot à créer dans la queue FactoryQueueElement queueElement = new FactoryQueueElement(name, model, parkingPos, workingPos); this.Queue.Add(queueElement); this.QueueFreeSlots -= 1; this.StorageFreeSlots -= 1; //Parallel.Invoke(() => this.BuildRobot(queueElement)); Task task = Task.Run(() => this.BuildRobot(queueElement)); task.Wait(); return(true); } return(false); }
public bool AddWorkableUnitToQueue(Type model, string name, Coordinates parkingPos, Coordinates workingPos) { if (Queue.Count > QueueCapacity || Storage.Count > StorageCapacity) { // Ajouter le retour return(false); } FactoryQueueElement newElement = new FactoryQueueElement(); newElement.Name = name; newElement.Model = model; newElement.ParkingPos = parkingPos; newElement.WorkingPos = workingPos; Queue.Enqueue(newElement); BuildRobot(newElement); return(true); }
public bool AddWorkableUnitToQueue(Type model, string name, Coordinates parkingpos, Coordinates workingpos) { QueueFreeSlots = QueueCapacity - _queue.Count; // QFS = 5 - x StorageFreeSlots = StorageCapacity - _storage.Count; // SFS = 10 - x if ((QueueFreeSlots > 0) && (StorageFreeSlots > 0) && (StorageFreeSlots - _queue.Count > 0)) { var fqe = new FactoryQueueElement(model, name, parkingpos, workingpos); _queue.Add(fqe); if (!factoryIsUpAndRunning) { if (Monitor.TryEnter(obj)) { Monitor.Pulse(obj); Monitor.Exit(obj); } } return(true); } return(false); }
public ITestingUnit Construire(FactoryQueueElement factoryelement) { // Create an instance of the ITestingUnit type using // Activator.CreateInstance. ITestingUnit testUnit = (ITestingUnit)Activator.CreateInstance(factoryelement.Model); Thread.Sleep(TimeSpan.FromSeconds(testUnit.BuildTime)); testUnit.ParkingPos = factoryelement.ParkingPos; testUnit.WorkingPos = factoryelement.WorkingPos; testUnit.CurrentPos = factoryelement.ParkingPos; testUnit.Name = factoryelement.Name; testUnit.Model = factoryelement.Model.Name; OnStatusChanged(testUnit, new StatusChangedEventArgs() { NewStatus = "I'm building my bot.." }); QueueTime += TimeSpan.FromSeconds(testUnit.BuildTime); return(testUnit); }
/* * private void ConstructingUnitAndAddToStorage() * { * Console.Write("Construction en cours"); * //OnStatusChanged(new StatusChangedEventArgs("Starting construction of robots", queue[0], null)); * if (storage.Count < queueCapacity) * { * Thread thread = new Thread(() => * { * while (queue.Count != 0) * { * Object activ = Activator.CreateInstance(queue[0].Model); * double _buildTime = ((WorkingUnit)activ).BuildTime; * bool _isWorking = ((WorkingUnit)activ).isWorking; * string _model = queue[0].Model.Name; * string _name = queue[0].Name; * double _speed = ((WorkingUnit)activ).Speed; * Coordinates _parkingPos = queue[0].ParkingPos; * Coordinates _workingPos = queue[0].WorkingPos; * Console.WriteLine("Construction of the thread..., it takes :" + _buildTime); * Thread.Sleep(TimeSpan.FromSeconds(_buildTime)); * Console.WriteLine("End of construction"); * TestingUnit unit = new TestingUnit(_buildTime, _isWorking, _model, _name, _speed, _parkingPos, _workingPos); * Console.WriteLine("Adding unit to storage"); * storage.Add(unit); * Console.WriteLine("Unit " + unit.name + " added to storage"); * queue.Remove(queue[0]); * //OnStatusChanged(new StatusChangedEventArgs("Starting construction of robots", null, unit)); * } * }); * * thread.Name = "machine"; * thread.Start(); * * //OnStatusChanged(new StatusChangedEventArgs("Construction of robots is done", queue[0], null)); * Console.WriteLine("End of construction"); * } * else * { * Console.Write("We cannot add any robot, storage is full"); * } * } */ public void AddWorkableUnitToQueue(Type model, string name, Coordinates parkingPos, Coordinates workingPos) { FactoryQueueElement nesfqe = new FactoryQueueElement(); nesfqe.Model = model; nesfqe.Name = name; nesfqe.ParkingPos = parkingPos; nesfqe.WorkingPos = workingPos; if (queue.Count < storageCapacity - storage.Count && queue.Count < queueCapacity) { queue.Add(nesfqe); OnStatusChanged(new StatusChangedEventArgs("Adding the unit to the queue ", null, null)); Console.WriteLine("L'unité est ajouté à la queue"); //ConstructingUnitAndAddToStorage(); Thread thread = new Thread(constructionThread); thread.Start(); } else { Console.WriteLine("L'unité ne peut pas être ajouté car il ne reste plus de place"); } }
public async Task <bool> AddWorkableUnitToQueue(Type model, string name, Coordinates parkingpos, Coordinates workingpos) { FactoryQueueElement fqe = null; QueueFreeSlots = QueueCapacity - _queue.Count; StorageFreeSlots = StorageCapacity - _storage.Count; if ((QueueFreeSlots > 0) && (StorageFreeSlots > 0) && (StorageFreeSlots - _queue.Count > 0)) { fqe = new FactoryQueueElement() { Name = name, Model = model, ParkingPos = parkingpos, WorkingPos = workingpos }; _queue.Add(fqe); } bool result = await Task.Run(() => { return(CreaInstance(fqe)); }); if (_queue.Count() > 0 && result) { _queue.Remove(fqe); } return(result); }