Best Design for HTTP Headers Container C++

Question

I'm writing an HTTP client in C++11/14 (VS 2015) for practice with asynchronous and network programming using ASIO (standalone, not boost, by the way, so please refrain from boost-specific solutions). This is a fairly basic question, but I nonetheless would appreciate an answer.

struct Header {
    Header(const std::string& key, const std::string& val); // initializes key/val
    std::string key, val;
    bool operator==(const Header& header); // returns true if key/val are equal
    friend std::ostream& operator<<(std::ostream& os, const Header& header) {
        os << header.key << ": " << header.val;
        return os;
    }
};

I've run into an issue, though. Some HTTP headers can be repeated. Others should not be. In particular, when I generate the "Host: website.com" header, I want to check and see if the user has not already input a Host parameter.

• My initial thought was to use std::unordered_set<Header> and provide a hash function that only hashes the Key value, thus preventing duplicates. However, some headers are perfectly valid to duplicate. Set-Cookie for example

• I then thought of creating a vector similar to this:

  static const std::unordered_set<std::string, HashIgnoreCase>& AllowedDuplicates{
      "set-cookie",
      "cookie",
  }; // HashIgnoreCase uses std::hash<std::string> on lowercase-converted strings.
  

  Then use that to check user-provided values. However, this seemed ugly since I'd have on std::unordered_set<Header> for most headers and a std::vector<Header> for the duplicate headers.

• Another idea would be to completely restrict the user from providing headers that should be singular, such as throwing an exception (or some clever static_assert) to prevent values like "Host" and "Content-Length" from being provided by the user, but that seems functionally restrictive, which is not typically my goal.

What would be the best way to go about this?

Answer 1

My understanding from here: https://stackoverflow.com/a/4371395/493106

is that headers can only be repeated if they could be combined into a single comma separated list.

That seems to imply that a normal map would be fine but if you try to add a new header that already exists, you just append "," then the new value onto the end of the old one.

Answer 2

Expanding on my comment...

You simply try to find the header in the map, and if it's in the map and it's not allowed multiple times.

You can use a normal vector or array of strings to store allowed duplicates, and do a simple search for it there.

Perhaps something like this

std::unodered_multimap<std::string, std::string> headers;
std::array<std::string, 2> allowed_duplicates = {{
    "set-cookie", "cookie"
}};

void add_header(std::string const& header, std::string const& data)
{
    if (headers.find(header) != headers.end())
    {
        // Header found, check if it's allowed multiple times
        if (std::find(allowed_duplicates.begin(),
                      allowed_duplicates.end(), header) == allowed_duplicates.end())
        {
            // Not found, the header is not allowed multiple times
            return;
        }
    }

    // Header is allowed
    headers.emplace(std::make_pair(header, data));
}