Headers.hpp

Go to the documentation of this file.

#pragma once
#include <chrono>
#include <Thoth/Http/Response/StatusCodeEnum.hpp>
#include <optional>
#include <format>
#include <vector>
#include <ranges>
 
#include <Thoth/Http/Request/Url.hpp>
#include <Thoth/Http/NHeaders/_base.hpp>
 
#include <Thoth/Http/NHeaders/Headers/_pch.hpp>
#include <Thoth/Http/NHeaders/Proxy/_base.hpp>
 
namespace Thoth::Http::NHeaders {
    template<bool IsConst, Serializable ...T>
    struct ListProxy;
    template<bool IsConst, Serializable ...T>
    struct ValueProxy;
}
 
 
namespace Thoth::Http {
 
    enum class VersionEnum : uint8_t;
 
 
    struct Headers {
        using HeaderKey      = NHeaders::HeaderKey;
        using HeaderKeyRef   = NHeaders::HeaderKeyRef;
 
        using HeaderValue    = NHeaders::HeaderValue;
        using HeaderValueRef = NHeaders::HeaderValueRef;
 
        using HeaderPair     = NHeaders::HeaderPair;
        using HeaderPairRef  = NHeaders::HeaderPairRef;
        using MapType        = NHeaders::MapType;
 
        using MapType        = std::vector<HeaderPair>;
 
        using IterType       = decltype(MapType{}.begin());
        using CIterType      = decltype(MapType{}.cbegin());
        using RIterType      = decltype(MapType{}.rbegin());
        using CRIterType     = decltype(MapType{}.crbegin());
 
 
        Headers();
 
        explicit Headers(const MapType& initAs);
 
        Headers(std::initializer_list<HeaderPair> init);
 
 
        template<std::ranges::input_range R>
        static WebResult<Headers> Parse(R& headers, size_t maxHeadersLength = 1<<16);
 
 
        static Headers DefaultHeaders();
 
 
        [[nodiscard]] bool Exists(HeaderKeyRef key) const;
 
        [[nodiscard]] bool Exists(HeaderPairRef p) const;
 
        [[nodiscard]] bool Exists(HeaderKeyRef key, HeaderValueRef val) const;
 
        void Add(HeaderPairRef p);
 
        void Add(HeaderKeyRef key, HeaderValueRef val);
 
 
        void Set(HeaderPairRef p);
 
        void Set(HeaderKeyRef key, HeaderValueRef val);
 
        bool Remove(HeaderPairRef p);
 
        bool Remove(HeaderKeyRef key, HeaderValueRef val);
 
        bool SetIfNull(HeaderPairRef p);
 
 
        bool SetIfNull(HeaderKeyRef key, HeaderValueRef val);
 
        std::optional<HeaderValue*> Get(HeaderKeyRef key);
 
        [[nodiscard]] std::optional<const HeaderValue*> Get(HeaderKeyRef key) const;
 
 
 
        NHeaders::ListProxy<false, NHeaders::MimeType> Accept();
        NHeaders::ListProxy<true, NHeaders::MimeType> Accept() const;
 
        NHeaders::ListProxy<false, NHeaders::AcceptEncodingEnum> AcceptEncoding();
        NHeaders::ListProxy<true, NHeaders::AcceptEncodingEnum> AcceptEncoding() const;
 
 
        NHeaders::ValueProxy<false, NHeaders::MimeType> ContentType();
        [[nodiscard]] NHeaders::ValueProxy<true, NHeaders::MimeType> ContentType() const;
 
        NHeaders::ValueProxy<false, uint64_t> ContentLength();
        [[nodiscard]] NHeaders::ValueProxy<true, uint64_t> ContentLength() const;
 
        NHeaders::ListProxy<false, NHeaders::ContentEncodingEnum> ContentEncoding();
        [[nodiscard]] NHeaders::ListProxy<true, NHeaders::ContentEncodingEnum> ContentEncoding() const;
 
        NHeaders::ListProxy<false, NHeaders::TransferEncodingEnum> TransferEncoding();
        [[nodiscard]] NHeaders::ListProxy<true, NHeaders::TransferEncodingEnum> TransferEncoding() const;
 
        NHeaders::ListProxy<false, std::string> ContentLanguage();
        [[nodiscard]] NHeaders::ListProxy<true, std::string> ContentLanguage() const;
 
        NHeaders::ValueProxy<false, std::string> ContentLocation();
        [[nodiscard]] NHeaders::ValueProxy<true, std::string> ContentLocation() const;
 
        NHeaders::ValueProxy<false, std::chrono::utc_clock::time_point> Date();
        [[nodiscard]] NHeaders::ValueProxy<true, std::chrono::utc_clock::time_point> Date() const;
 
        NHeaders::ListProxy<false, std::string> Connection();
        [[nodiscard]] NHeaders::ListProxy<true, std::string> Connection() const;
 
        NHeaders::ListProxy<false, NHeaders::Upgrade> Upgrade();
        [[nodiscard]] NHeaders::ListProxy<true, NHeaders::Upgrade> Upgrade() const;
 
        NHeaders::ListProxy<false, std::string> Trailer();
        [[nodiscard]] NHeaders::ListProxy<true, std::string> Trailer() const;
 
        NHeaders::ListProxy<false, std::string> Via();
        [[nodiscard]] NHeaders::ListProxy<true, std::string> Via() const;
 
 
 
 
        IterType begin();
        IterType end();
        [[nodiscard]] CIterType begin() const;
        [[nodiscard]] CIterType end() const;
 
        RIterType rbegin();
        RIterType rend();
        [[nodiscard]] CRIterType rbegin() const;
        [[nodiscard]] CRIterType rend() const;
 
 
 
        void Clear();
 
        [[nodiscard]] size_t Size() const;
 
        [[nodiscard]] bool Empty() const;
 
 
 
        HeaderValue& operator[](HeaderKeyRef key);
 
        bool operator==(const Headers& other) const;
    private:
        MapType _headers;
 
        friend struct std::formatter<Headers>;
    };
}
 
#include <Thoth/Http/NHeaders/Headers.tpp>