gridmanager.h

Go to the documentation of this file.

#ifndef GRIDMANAGER_H_
#define GRIDMANAGER_H_

#include "utils.h"
#include "interfaces.h"
#include "machine.h"
#include "idleuser.h"


#include <map>
#include <vector>
#include <functional>
#include <set>

class Menu;
class User;
class Job;


class GridManager : public ISave, public IUpdate
{
public:
    typedef std::set<User*, IdLess<User>> UserSet;
    typedef std::set<Machine*, IdLess<Machine>> MachineSet;
    typedef std::set<PriorityMachine*, IdLess<PriorityMachine>> PriorityMachineSet;

    GridManager() {}

    ~GridManager();

    uint AddUser(User* user);

    uint AddMachine(Machine* machine);

    uint AddPriorityMachine(PriorityMachine* pMachine);

    bool RemoveUser(const User* user);

    bool RemoveUser(uint id);

    bool RemoveMachine(const Machine* machine);

    bool RemoveMachine(uint id);

    bool RemovePriorityMachine(const PriorityMachine* machine);

    bool RemovePriorityMachine(uint id);

    User* GetUser(uint id) const;

    uint GetNumberOfUsers() const { return _users.size(); }

    Machine* GetMachine(uint id) const;

    PriorityMachine* GetPriorityMachine(uint id) const;

    uint GetNumberOfMachines() const { return _machines.size(); }

    uint GetNumberOfPriorityMachines() const { return _priorityMachines.size(); }

    bool Save(ByteBuffer& bb) const override;

    void Update(uint32 diff);

    static GridManager* Load(ByteBuffer& bb);

    bool AddJobByUser(int userId, Job* job) { return AddJobByUser(GetUser(userId), job); }

    bool AddJobByUser(User* user, Job* job);

    bool RemoveMachineJob(Machine* machine, uint jobId);

    uint GetNumberOfJobs() const;

    template<class T>
    std::vector<const T*> ApplyPredicate(std::function<bool(const T*)> predicate) const;

    template<class T, class R>
    std::vector<R> ApplySelector(std::function<R(const T*)> selector, std::function<bool(const T*)> predicate) const;

    template<class T, class R>
    std::vector<R> ApplySelector(std::function<R(const T*)> selector) const;

    static Menu* GetMenu() { return _menu; } 

    const IdleUserContainer& GetIdleUsers() const { return _idleUsers; }

private:
    bool AddJob(Job* job);

    static uint _lastUserId;
    static uint _lastMachineId;

    UserSet _users;
    MachineSet _machines;
    PriorityMachineSet _priorityMachines;
    std::queue<Job*> _waitingJobs;


    static Menu* _menu; 

    IdleUserContainer _idleUsers; 

private: // no copying
    GridManager(const GridManager &);
    GridManager& operator =(GridManager const&);
};

template<class T, class R>
std::vector<R> GridManager::ApplySelector(std::function<R(const T*)> selector) const
{
    return ApplySelector<T, R>(selector, [](const T*) { return true; });
}

template<class T, class R>
std::vector<R> GridManager::ApplySelector(std::function<R(const T*)> selector, std::function<bool(const T*)> predicate) const
{
    // get all machines, jobs, etc. that match the predicate
    std::vector<const T*> ts = ApplyPredicate<T>(predicate);

    // apply our selector to the initial vector to create a new one
    std::vector<R> result;
    result.reserve(ts.size()); // max size of the resulting vector

    std::transform(ts.begin(), ts.end(), std::back_inserter(result), selector);

    return result;
}

#endif // GRIDMANAGER_H_