httpheaders.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_HTTP
#include <functional>
#include <promeki/function.h>
#include <promeki/namespace.h>
#include <promeki/string.h>
#include <promeki/stringlist.h>
#include <promeki/list.h>
#include <promeki/sharedptr.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class HttpHeaders {
                PROMEKI_SHARED_FINAL(HttpHeaders)
        public:
                using Ptr = SharedPtr<HttpHeaders>;
 
                using List = ::promeki::List<HttpHeaders>;
 
                using PtrList = ::promeki::List<Ptr>;
 
                HttpHeaders() = default;
 
                void set(const String &name, const String &value);
 
                void add(const String &name, const String &value);
 
                void remove(const String &name);
 
                bool contains(const String &name) const;
 
                String value(const String &name, const String &defaultValue = String()) const;
 
                StringList values(const String &name) const;
 
                void clear();
 
                int count() const;
 
                bool isEmpty() const { return count() == 0; }
 
                void forEach(Function<void(const String &name, const String &value)> func) const;
 
                bool operator==(const HttpHeaders &other) const;
 
                bool operator!=(const HttpHeaders &other) const { return !(*this == other); }
 
                static String foldName(const String &s);
 
        private:
                struct Entry {
                                using List = ::promeki::List<Entry>;
                                String name; 
                                String value;
                };
 
                // Parallel index: lower-case key -> indices in _entries.
                // Stored as a small associative container; we intentionally
                // use a plain list-of-pairs because typical header counts
                // are well under 30 and the constant-factor wins.
                struct KeyBucket {
                                using List = ::promeki::List<KeyBucket>;
                                using IndexList = ::promeki::List<size_t>;
                                String    lower;
                                IndexList indices;
                };
 
                // Per-name lookup uses the lower-cased name as the
                // index into _index, which holds a list of indices
                // into _entries.  This preserves arrival order across
                // names and supports duplicates without a multimap.
                Entry::List     _entries;
                KeyBucket::List _index;
 
                size_t findBucket(const String &lower) const;
                size_t getOrCreateBucket(const String &lower);
};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_HTTP