job.h

Go to the documentation of this file.

#ifndef JOB_H_
#define JOB_H_

#include <string>
#include <unordered_set>
#include <sstream>
#include <chrono>
#include <iostream>

#include "utils.h"
#include "interfaces.h"
#include "software.h"

class User;


template <class Idable>
struct IdLess
{
    bool operator()(Idable* const & lhs, Idable* const & rhs) const
    {
        return lhs->GetId() < rhs->GetId();
    }
};

typedef std::unordered_set<Software, Software::Hash> SoftwareSet;


class Job : public ISave, public IUpdate, public IPrint
{
public:

    struct PriorityLess
    {
        bool operator()(Job* const & lhs, Job* const & rhs) const
        {
            return (lhs->_priority > rhs->_priority) ||                              // Organize Jobs by priority
                   ((lhs->_priority == rhs->_priority) && (lhs->_id < rhs->_id));    // If priorities are equal organize by id
        }
    };

    Job(uint id) : _id(id), _name(""), _priority(0), _requiredRAM(0), _requiredDiskSpace(0), _totalExecutionTime(0) { }
    Job(const std::string& name, uint8 priority, double requiredRAM, double requiredDiskSpace, uint executionTime);

    uint GetId() const { return _id;}
    void SetId(uint val) { _id = val; }
    const std::string& GetName() const { return _name; } 
    uint8 GetPriority() const { return _priority; } 
    void SetPriority(uint8 val) { _priority = val; } 
    double GetRequiredRAM() const { return _requiredRAM; } 
    double GetRequiredDiskSpace() const { return _requiredDiskSpace; } 
    uint GetTotalExecutionTime() const { return _totalExecutionTime; } 
    uint GetElapsedTime() const { return _elapsedTime; } 

    double GetPrice() const { return 0.05 * _requiredRAM; } 

    bool Finished() const { return _totalExecutionTime <= _elapsedTime; } 
    void Finish() { _elapsedTime = _totalExecutionTime; } 

    bool Save(ByteBuffer& bb) const override; 
    static Job* Load(ByteBuffer& bb); 

    void Update(uint32 diff); 

    void Print(std::ostream& os = std::cout) const override;
    void PrintWithId(std::ostream& os = std::cout) const;
    static void PrintHeader(std::ostream& os = std::cout, bool withId = false);

    void AddRequiredSoftware(const Software& sw) { _requiredSoftware.insert(sw); } 

    bool IsRequiredSoftware(const Software& sw) const { return _requiredSoftware.find(sw) != _requiredSoftware.end(); }
    const SoftwareSet& GetRequiredSoftware() const { return _requiredSoftware; } 

private:
    const double _requiredRAM; 
    const double _requiredDiskSpace; 
    const uint _totalExecutionTime; 
    uint _elapsedTime; 
    uint _ms; 
    SoftwareSet _requiredSoftware; 
    uint8 _priority; 

    const std::string _name; 
    uint _id;

    static uint _maxNameLength; 

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



#endif // JOB_H_