acl.hpp

#pragma once

#include <zk/config.hpp>

#include <initializer_list>
#include <iosfwd>
#include <string>
#include <utility>
#include <vector>

#include "forwards.hpp"

namespace zk
{

enum class permission : unsigned int
{
    none    = 0b00000, 
    read    = 0b00001, 
    write   = 0b00010, 
    create  = 0b00100, 
    erase   = 0b01000, 
    admin   = 0b10000, 
    all     = 0b11111, 
};

constexpr permission operator|(permission a, permission b)
{
    return permission(static_cast<unsigned int>(a) | static_cast<unsigned int>(b));
}

constexpr permission operator&(permission a, permission b)
{
    return permission(static_cast<unsigned int>(a) & static_cast<unsigned int>(b));
}

constexpr permission operator~(permission a)
{
    return permission(~static_cast<unsigned int>(a));
}

constexpr bool allows(permission self, permission perform)
{
    return (self & perform) == perform;
}

std::ostream& operator<<(std::ostream&, const permission&);

std::string to_string(const permission&);

class acl_rule final
{
public:
    acl_rule(std::string scheme, std::string id, permission permissions);

    ~acl_rule() noexcept;

    const std::string& scheme() const
    {
        return _scheme;
    }

    const std::string& id() const
    {
        return _id;
    }

    const permission& permissions() const
    {
        return _permissions;
    }

private:
    std::string _scheme;
    std::string _id;
    permission  _permissions;
};

std::size_t hash(const acl_rule&);

[[gnu::pure]] bool operator==(const acl_rule& lhs, const acl_rule& rhs);
[[gnu::pure]] bool operator!=(const acl_rule& lhs, const acl_rule& rhs);
[[gnu::pure]] bool operator< (const acl_rule& lhs, const acl_rule& rhs);
[[gnu::pure]] bool operator<=(const acl_rule& lhs, const acl_rule& rhs);
[[gnu::pure]] bool operator> (const acl_rule& lhs, const acl_rule& rhs);
[[gnu::pure]] bool operator>=(const acl_rule& lhs, const acl_rule& rhs);

std::ostream& operator<<(std::ostream&, const acl_rule&);

std::string to_string(const acl_rule&);

class acl final
{
public:
    using iterator       = std::vector<acl_rule>::iterator;
    using const_iterator = std::vector<acl_rule>::const_iterator;
    using size_type      = std::size_t;

public:
    acl() = default;

    acl(std::vector<acl_rule> rules) noexcept;

    acl(std::initializer_list<acl_rule> rules) :
            acl(std::vector<acl_rule>(rules))
    { }

    ~acl() noexcept;

    size_type size() const { return _impl.size(); }

    const acl_rule& operator[](size_type idx) const { return _impl[idx]; }

    iterator begin()              { return _impl.begin(); }
    const_iterator begin() const  { return _impl.begin(); }
    const_iterator cbegin() const { return _impl.begin(); }

    iterator end()              { return _impl.end(); }
    const_iterator end() const  { return _impl.end(); }
    const_iterator cend() const { return _impl.end(); }

    void reserve(size_type sz) { _impl.reserve(sz); }

    template <typename... TArgs>
    void emplace_back(TArgs&&... args)
    {
        _impl.emplace_back(std::forward<TArgs>(args)...);
    }

private:
    std::vector<acl_rule> _impl;
};

[[gnu::pure]] bool operator==(const acl& lhs, const acl& rhs);
[[gnu::pure]] bool operator!=(const acl& lhs, const acl& rhs);

std::ostream& operator<<(std::ostream&, const acl&);

std::string to_string(const acl& self);

class acls
{
public:
    static const acl& creator_all();

    static const acl& open_unsafe();

    static const acl& read_unsafe();
};

}

namespace std
{

template <>
class hash<zk::acl_rule>
{
public:
    using argument_type = zk::acl_rule;
    using result_type   = std::size_t;

    result_type operator()(const argument_type& x) const
    {
        return zk::hash(x);
    }
};

}