public void Notify(IElevator elevator)
{
isOccupied.Remove(elevator.GetId());
int value = 0;
log.TryRemove(elevator.GetId(), out value);
}
// ReSharper disable once TooManyDependencies
public OutputService(IBuilding building, IElevator elevator,
ILogger <OutputService> logger,
IEventStreamService eventStreamService,
IHubContext <ElevatorHub, IElevatorHub> hub,
ISettingsService settingsService)
{
_building = building;
_logger = logger;
_eventStreamService = eventStreamService;
_hub = hub;
_elevator = elevator;
_settingsService = settingsService;
_tokenSource = new CancellationTokenSource();
_token = _tokenSource.Token;
_building.SubscribeToPersonActions(personAction =>
{
_history.Add(personAction);
if (_history.Count > 100)
{
_history.RemoveAt(0);
}
}, _token);
_eventStreamService.SubscribeToGeneration(genAction =>
{
if (genAction == "FINISHED")
{
_logger.LogInformation($"History count: {_history.Count}");
}
}, _token);
_elevator.SubscribeToElevatorActions(OnElevatorAction);
}
public ElevatorSystemController(
IUnityContainer container,
IRegionManager regionManager,
IEventAggregator eventAggregator,
IElevator elevatorService,
ILoggerFacade logger)
{
if (container == null)
{
throw new ArgumentNullException("container");
}
if (regionManager == null)
{
throw new ArgumentNullException("regionManager");
}
if (eventAggregator == null)
{
throw new ArgumentNullException("eventAggregator");
}
if (elevatorService == null)
{
throw new ArgumentNullException("elevatorService");
}
if (logger == null)
{
throw new ArgumentException(" logger");
}
this._eventAggregator = eventAggregator;
this._elevatorService = elevatorService;
this._logger = logger;
//InitializeElevator with default value
InitializeElevatorService();
this._eventAggregator.GetEvent <ElevatorControlSystemBackgroundEvent>().Subscribe(ElevatorFloorControlSystem, ThreadOption.BackgroundThread, false);
}
// ReSharper disable once TooManyDependencies
public Building(IElevator elevator, ILogger <Building> logger, ISettingsService settingsService,
IEventStreamService eventStreamService)
{
_logger = logger;
Floors = new Dictionary <int, IFloor>();
for (var i = 0; i < settingsService.FloorCount; i++)
{
Floors.Add(i, new Floor(i, settingsService.MaxPersonsPerBuilding / settingsService.FloorCount));
}
Elevator = elevator;
_controlParameterSubscription = eventStreamService.ControlParameterObservable.Subscribe(cp =>
{
if (string.Compare(cp.ParameterName, "MaxPersonsPerBuilding", StringComparison.OrdinalIgnoreCase) !=
0)
{
return;
}
if (!int.TryParse(cp.ParameterValue.ToString(), out var personsPerBuilding))
{
return;
}
var personsPerFloor = personsPerBuilding / settingsService.FloorCount;
Floors.Values.ToList().ForEach(f => f.MaxPersons = personsPerFloor);
});
}
bool CheckElevatorAndPassenger(uint floor, IElevator e)
{
ElevatorStatus status = e.CurrentStatus;
return((status.CurrentDirection == Direction.No) &&
(status.CurrentFloor == floor));
}
public void ElevatorStopped(object sender, EventArgs e)
{
IElevator elev = (IElevator)sender;
ElevStoppedEventArgs args = (ElevStoppedEventArgs)e;
if (args.StoppedFloor == _sourceFloor && !_isInside && UpDown == elev.HistoryDirection && !_isArrived)
{
EnterElevator(args.Scheduler, args.Tick, elev);
}
if (args.StoppedFloor == _targetFloor && _isInside && _myElev == elev)
{
LeaveElevator(args.Tick, elev);
}
if (_isArrived)
{
elev.UnregStopHandler(StopAlarmHandler);
}
//if (CheckElevatorAndPassenger(this.SourceFloor, args.StoppedElevator))
//{
// this._TargetReqTime = Elevator.SenElevator.SenClock.Ticks;
// StudentScheduler.QueueTargetFloor(this);
//}
//else
//{
// Console.WriteLine("passenger can't enter into elevator");
//}
return;
}
private async Task RunJourney(Request request, IElevator elevator)
{
//Move the Elevator in the correct direction until it reaches the request floor
while (elevator.GetCurrentFloor() != request.Floor)
{
await elevator.MoveBetweenFloors();
//If we come across any Floors that have requests in our Direction (among other conditions) then stop to pick them up and remove the Request
if (ElevatorShouldMakeEnroutePickup(elevator))
{
Console.WriteLine($"[{DateTime.Now.ToLongTimeString()}] Elevator stopped to make {requestList.FirstOrDefault(x => x.Floor == elevator.GetCurrentFloor()).RequestType} request pickup " +
$"on Floor: {elevator.GetCurrentFloor()} en-route to Floor: {request.Floor}");
elevator.RunEnroutePickupRoutine(request);
requestList.RemoveAll(x => x.Floor == elevator.GetCurrentFloor());
}
//Elevator cant travel in this direction any further
if (elevator.IsAtFloorRangeLimit())
{
break;
}
}
Console.WriteLine($"[{DateTime.Now.ToLongTimeString()}] Elevator {elevator.GetId()} completed {request.RequestType} request for Floor: {elevator.GetCurrentFloor()}");
}
public GoToCommand(IElevator elevator, int floorNumber)
{
Data = floorNumber;
Elevator = elevator;
_action = () => { Elevator.RequestElevator(new FloorRequest {
From = Elevator.CurrentFloor.FloorNumber, To = floorNumber
}); };
}
public void Star(IElevator elevator)
{
dispathcer.Interval = new TimeSpan(0, 0, 3);
dispathcer.Tick += (s, a) =>
{
elevator.ExecuteCalls();
};
dispathcer.Start();
}
public DayOneSolver(FileReader fileReader)
{
_fileReader = fileReader;
var input = _fileReader.ReadLine("Day1/input.txt").ToArray();
_parsedInput = input[0].ToCharArray().ToList();
_elevator = new Elevator();
}
public Agent(string name, SecurityLevel securityLevel, IElevator elevator)
{
currentFloor = FloorLevel.G; // The initial floor
this.Name = name;
this.elevator = elevator;
this.SecurityLevel = securityLevel;
this.ResetEvent = new AutoResetEvent(false);
random = new Random();
}
public int GetMostPriorityFloor(IElevator elevator)
{
var min = priorityDict.Keys.Min();
int result = -1;
priorityDict.TryRemove(min, out result);
log.TryAdd(elevator.GetId(), min);
isOccupied.Add(elevator.GetId());
return(result);
}
private void InitElevators(int NoOfElevators)
{
ElevatorFactory elevatorFactory = new ElevatorFactory();
for (int i = 1; i <= NoOfElevators; i++)
{
IElevator elevator = elevatorFactory.GetElevator();
elevator.ElevatorId = i;
elevator.ElevatorName = "E" + i.ToString();
Elevators.Add(elevator);
}
}
private void LeaveElevator(int tick, IElevator elev)
{
// Added by Xiaobin
SenElevator senElev = elev as SenElevator;
senElev.AddCapability(_weight);
Console.WriteLine("[Passenger] {0} leave elevator {1}, floor {2}",
_name, elev.ID, _targetFloor);
_reqCompleteTime = tick;
_isArrived = true;
_isInside = false;
}
public Person(IElevator elevator, int sourceFloor, int destinationFloor, float weight)
{
this.elevator = elevator;
this.weight = weight;
this.sourceFloor = sourceFloor;
this.destinationFloor = destinationFloor;
elevator.Door.DoorOpened += HandleDoorOpened;
timerWait.AutoReset = false;
timerWait.Elapsed += HandleTimerWait;
timerWait.Enabled = true;
}
public ElevatorService(IBuilding building, IElevator elevator, ILogger <ElevatorService> logger)
{
this.building = building;
this.elevator = elevator;
this.logger = logger;
this.cancellationToken = this.cancellationTokenSource.Token;
this.elevator.SubscribeToElevatorCompletion(OnElevatorStateReadyToChange, cancellationToken);
if (this.elevator.State == ElevatorState.None)
{
this.elevator.Open();
}
}
public MainWindow()
{
InitializeComponent();
txtElevator.AppendText("Start \r\n");
CreateFloorButton();
CreateCabinButton();
_elevator = new Elevator(txtElevator);
_elevator.CreateFloorButton(_dictionaryFloorButton);
_elevator.CreateCabinButton(_dictionaryCabinButton);
CreateLevels();
_elevator.CreateDisplay(lblDisplayFloor, lblDisplayCabin);
_timeSensor.Star(_elevator);
cmbFloor.SelectionChanged += selection;
}
public void PlayerSendsElevatorToFloorWhereFloorButtonIsPressed()
{
// Arrange
var elevator = new MockElevator();
var elevators = new IElevator[] { elevator };
var floors = new IFloor[] { new MockFloor(1), new MockFloor(2) };
yourPlayer.Init(elevators, floors);
// Act
(floors[1] as MockFloor)?.TestInvokeDownButtonPressedEvent(elevators);
// Assert
Assert.True(elevator.CalledMethods.Contains("GoToFloor(2)"));
}
public PassengerReq(RequestType type, int time, int floor, Direction direction)
{
_type = type;
_reqtime = time;
if (type == RequestType.DirectionReq)
{
_directionReqSrc = floor;
_direction = direction;
}
else
{
_destinationReqDst = floor;
}
_inElevator = null;
}
public async Task <int> RunElevatorManager()
{
if (!ElevatorManagerInitialisation())
{
return(-1);
}
PrintControlledElevatorState();
PrintRemainingRequests(requestList);
//The ElevatorManager never sleeps, it checks for a new Request to pick up at set intervals
while (true)
{
try
{
if (requestList.Count == 0)
{
//Wait before checking the Request list again
Thread.Sleep(1000);
continue;
}
Request floorRequest = requestList[0];
IElevator elevator = ChooseElevatorDependingOnRequestType(floorRequest);
if (elevator == null)
{
//Wait 1 second before checking for an available Elevator again
Thread.Sleep(1000);
continue;
}
//An Elevator was found to service the Request, it can be removed
requestList.RemoveAt(0);
await MakeElevatorJourney(floorRequest, elevator);
PrintControlledElevatorState();
PrintRemainingRequests(requestList);
}
catch (Exception)
{
throw;
}
}
}
public MainWindow()
{
InitializeComponent();
CreateCabinButton();
CreateFloorButton();
txtElevator.AppendText("Start \r\n");
_elevator = new Elevator(txtElevator, lblDisplayFloor, lblDisplayCabin, _dictionaryFloorButton, _dictionaryCabinButton);
CreateFloor();
btnDown.Visibility = Visibility.Hidden;
lblDisplayCabin.Content = "0";
lblDisplayFloor.Content = "0";
_timeSensor.Star(_elevator);
cmbFloor.SelectionChanged += selection;
}
private bool AssignBestElevator(int floor)
{
bool elevatorAssigned = false;
//Identify available elevators
List <IElevator> availableElevators = GetAvailableElevators(floor);
//Now pick the best option from all available elevators
IElevator closestElevator = GetNearestElevator(floor, availableElevators);
if (closestElevator != null)
{
closestElevator.SetDestinationFloor(floor);
elevatorAssigned = true;
}
return(elevatorAssigned);
}
public string Press(IFloor floor, List <IElevator> elevators)
{
try
{
//gets the optimal elevator
IElevator optimalElevator = GetOptimalElevator(floor, elevators);
//move the elevator to the required floor
optimalElevator.MoveTo(floor.FloorId, ButtonDirection);
return(optimalElevator.ElevatorName);
}
catch (Exception ex)
{
Logger.Log(string.Format("Message: {0}; StackTrace: {1}", ex.Message, ex.StackTrace), LogType.Error);
}
return(string.Empty);
}
public ElevatorWidget(IElevator elevator)
{
VBox vbox = new VBox(false, 3);
vbox.PackStart(new StatusWidget(elevator), false, false, 0);
vbox.PackStart(new HSeparator(), false, false, 0);
vbox.PackStart(new DoorWidget(elevator.Door), false, false, 0);
HBox hbox = new HBox(false, 3);
hbox.BorderWidth = 3;
hbox.PackStart(new VSeparator(), false, false, 0);
hbox.PackStart(new ButtonPanelWidget(elevator.CallButtons, 1), false, false, 0);
hbox.PackStart(new VSeparator(), false, false, 0);
hbox.PackStart(vbox, false, false, 0);
hbox.PackStart(new VSeparator(), false, false, 0);
hbox.PackStart(new ControlPanelWidget(elevator.ControlPanel), false, false, 0);
hbox.PackStart(new VSeparator(), false, false, 0);
Add(hbox);
Child.ShowAll();
}
public SigmaPassenger(
string name,
int directionReqTime,
int sourceFloor,
int targetFloor,
int weight
)
{
_directionReqTime = directionReqTime;
_sourceFloor = sourceFloor;
_targetFloor = targetFloor;
_isInside = false;
_isArrived = false;
_targetReqTime = 0;
_reqCompleteTime = 0;
_myElev = null;
_name = name;
_weight = weight;
}
public static IElevatorConsole CreateElevatorConsole(Building building, IElevator elevator)
{
IElevatorConsole console = new ElevatorConsole();
console.Controller = building.Controller;
elevator.Console = console;
elevator.Console.FloorButtons = building.Floors
.Select(floor => new GoToCommand(elevator, floor.FloorNumber))
.ToList <ICommand <int> >();
elevator.StopRequests.AddRange(
building.Floors.Select(floor => new StopRequest {
FloorNumber = floor.FloorNumber
})
);
return(console);
}
public int RequestElevator(FloorRequest request)
{
//TODO: Use extension method on IElevator[]
//TODO: Find nearest elevator moving in the correct direction and request floor on that elevator
// Simple algorithm: Find first idle elevator or first one traveling in the desired direction and dispatch request.
// If none meet these requirements, pick one at random.
// Future possible optimizations:
// Find nearest elevator moving in the correct direction and request floor on that elevator
// Find least busy elevator and dispatch request
var firstIdleElevator = _elevators.FirstOrDefault(e => (e.IsIdle || (e.DirectionOfTravel == request.Direction)));
IElevator target = firstIdleElevator != null ? firstIdleElevator : GetRandomElevator();
_log.Debug($"Dispatching floor request {request} to elevator {target.Id}.");
target.RequestFloor(request);
return(target.Id);
}
public static IElevator ChooseAppropriateAvailableElevator(this List <IElevator> elevators, int requestedFloor)
{
IElevator availableElevator = elevators.FirstOrDefault(x => x.GetOperationalState() == ElevatorOperationStatus.AVAILABLE);
if (availableElevator == null)
{
//All Elevators are busy or unavailable in some way (Maintenance mode, etc.), come back
return(null);
}
int currentSmallestDifference = GetDifferenceBetweenFloors(availableElevator.GetCurrentFloor(), requestedFloor);
//Start loop from 1 as we are checking agasint first available Elevator
foreach (IElevator elevator in elevators.Skip(1))
{
//Is the request coming from below this Elevators current floor
if (elevator.GetCurrentFloor() > requestedFloor)
{
//If another Elevator is currently travelling down then it will already pickup the request as it hits the floor
if (ElevatorIsOnACloserFloor(requestedFloor, elevator.GetCurrentFloor(), currentSmallestDifference) &&
!elevators.Any(x => x.GetOperationalState() == ElevatorOperationStatus.MOVING_DOWN))
{
availableElevator = elevator; //Our new best selection of Elevator
currentSmallestDifference = elevator.GetCurrentFloor() - requestedFloor;
}
}
else
{
if (ElevatorIsOnACloserFloor(elevator.GetCurrentFloor(), requestedFloor, currentSmallestDifference) &&
!elevators.Any(x => x.GetOperationalState() == ElevatorOperationStatus.MOVING_UP))
{
availableElevator = elevator;
currentSmallestDifference = requestedFloor - elevator.GetCurrentFloor();
}
}
}
return(availableElevator);
}
private async Task MakeElevatorJourney(Request request, IElevator elevator)
{
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine("-----Journey Cycle Started-----");
Console.ForegroundColor = ConsoleColor.White;
try
{
Console.WriteLine($"[{DateTime.Now.ToLongTimeString()}] Elevator {elevator.GetId()} responding to {request.RequestType} request for floor {request.Floor}");
//Request was on the current floor
if (elevator.GetCurrentFloor() == request.Floor)
{
elevator.ReadyElevatorForNewPassengers();
return;
}
elevator.ReadyElevatorForJourney(request);
await RunJourney(request, elevator);
elevator.ReadyElevatorForNewPassengers();
}
catch (Exception ex)
{
//Obviously log this error in reality
Console.WriteLine(ex.Message);
elevator.SetToMaintenanceMode();
_elevatorService.RaiseElevatorIssueAlert(elevator.GetId());
throw ex;
}
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine("-----Journey Cycle Complete-----");
Console.ForegroundColor = ConsoleColor.White;
}
public void EmbarkPassengers(List <IPassenger> passengers)
{
List <IPassenger> embarkedPassengers = new List <IPassenger>();
foreach (IPassenger passenger in passengers)
{
IElevator elevator = _elevators.FirstOrDefault(e => e.Floor == passenger.CurrentFloor && e.GetNumberOfPassengers() < e.MaxPassengers);
if (elevator != null)
{
bool embarked = elevator.AddPassenger(passenger);
if (embarked)
{
embarkedPassengers.Add(passenger);
}
}
}
foreach (IPassenger passenger in embarkedPassengers)
{
passengers.Remove(passenger);
}
}
private void StopAtEachFloor(IElevator elev)
{
ElevatorStatus status = elev.CurrentStatus;
if (status.CurrentDirection != Direction.No)
{
return;
}
if (IsAtTopFloor(elev))
{
elev.ReqStopAt(status.CurrentFloor - 1);
elev.HistoryDirection = Direction.Down;
}
else
{
if (IsAtBottomFloor(elev))
{
elev.ReqStopAt(status.CurrentFloor + 1);
elev.HistoryDirection = Direction.Up;
}
else
{
switch (elev.HistoryDirection)
{
case Direction.No:
case Direction.Up:
elev.ReqStopAt(status.CurrentFloor + 1);
elev.HistoryDirection = Direction.Up;
break;
case Direction.Down:
elev.ReqStopAt(status.CurrentFloor - 1);
elev.HistoryDirection = Direction.Down;
break;
}
}
}
}
private void EnterElevator(IScheduler scheduler, int tick, IElevator elev)
{
SenElevator senElev = elev as SenElevator;
if (senElev.FreeCapability >= _weight)
{
Console.WriteLine("[Passenger] {0} enter elevator {1}, at floor {2}",
_name, elev.ID, _sourceFloor);
_isInside = true;
_targetReqTime = tick;
_myElev = elev;
senElev.SubCapability(_weight);
PassengerReq req = new PassengerReq(RequestType.DestinationReq, tick, _targetFloor, Direction.No);
req.SetReqInElevator(senElev);
scheduler.QueueReq(req);
}
else if (senElev.CurrentStatus.DoorCloseOpenTicks < 4) //wait for one tick to try enter again.
{
Console.WriteLine("[Passenger] {0} can't get in due to over-weighted, press up/down again", this.Name);
scheduler.QueueReq(
new PassengerReq(RequestType.DirectionReq, tick, this._sourceFloor, this.UpDown));
}
}
public StatusWidget(IElevator elevator)
{
this.elevator = elevator;
imgUp.Pixbuf = up;
imgDown.Pixbuf = down;
label.ModifyFont(Pango.FontDescription.FromString("Arial 24"));
VBox vbox = new VBox(true, 3);
vbox.PackStart(imgUp);
vbox.PackStart(imgDown);
HBox hbox = new HBox(true, 3);
hbox.BorderWidth = 3;
hbox.PackStart(label);
hbox.PackStart(vbox);
Add(hbox);
Child.ShowAll();
UpdateInfo();
elevator.StateChanged += elevator_StateChanged;
elevator.FloorChanged += elevator_StateChanged;
}
public ElevatorStatistics(IElevator elevator)
{
this.elevator = elevator;
this.elevator.StateChanged += StateChangedHandler;
this.elevator.PersonList.PersonAdded += PersonEnteredHandler;
}
