worker.h

#ifndef RECODEX_BROKER_WORKER_H
#define RECODEX_BROKER_WORKER_H

#include <map>
#include <memory>
#include <queue>
#include <vector>


class job_request_data
{
private:
    std::string job_id_;
    std::vector<std::string> data_;
    bool complete_;

public:
    job_request_data(const std::string &job_id, const std::vector<std::string> &additional) : complete_(true)
    {
        job_id_ = job_id;
        data_ = {"eval", job_id};
        for (auto &i : additional) {
            data_.push_back(i);
        }
    }

    job_request_data(const std::string &job_id) : job_id_(job_id), complete_(false)
    {
    }

    bool is_complete() const
    {
        return complete_;
    }

    const std::string &get_job_id() const
    {
        return job_id_;
    }

    std::vector<std::string> get() const
    {
        return data_;
    }
};

struct request {
    typedef std::multimap<std::string, std::string> headers_t;

    const headers_t headers;

    const job_request_data data;

    size_t failure_count = 0;

    request(const headers_t &headers, const job_request_data &data) : headers(headers), data(data)
    {
    }

    request(const job_request_data &data) : data(data)
    {
    }
};

class header_matcher
{
protected:
    std::string my_value_;

public:
    header_matcher(std::string my_value) : my_value_(my_value)
    {
    }

    virtual ~header_matcher()
    {
    }

    virtual bool match(const std::string &value)
    {
        return value == my_value_;
    }
};

class worker
{
public:
    typedef std::shared_ptr<request> request_ptr;

private:
    std::multimap<std::string, std::unique_ptr<header_matcher>> headers_;

    const std::multimap<std::string, std::string> headers_copy_;

    bool free_;

    std::queue<request_ptr> request_queue_;

    request_ptr current_request_;

public:
    const std::string identity;

    std::string description = "";

    const std::string hwgroup;

    size_t liveness;

    worker(const std::string &id, const std::string &hwgroup, const std::multimap<std::string, std::string> &headers);

    virtual ~worker();

    bool headers_equal(const std::multimap<std::string, std::string> &other);

    virtual bool check_header(const std::string &header, const std::string &value);

    virtual void enqueue_request(request_ptr request);

    virtual void complete_request();

    virtual request_ptr cancel_request();

    virtual bool next_request();

    virtual std::shared_ptr<const request> get_current_request() const;

    virtual std::shared_ptr<std::vector<request_ptr>> terminate();

    std::string get_description() const;
};

#endif // RECODEX_BROKER_WORKER_H