/home/greg/src/restcgi-test/src/hdr.h

/*
Copyright (c) 2009 zooml.com

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
*/
#ifndef restcgi_hdr_h
#define restcgi_hdr_h
#include "apidefs.h"
#include "cookie.h"
#include "utils.h"
#include <string.h>
#include <string>
#include <map>
#include <iostream>
#ifdef _WIN32
#pragma warning (disable: 4251)
#endif
namespace restcgi {
    class env;
    class date_time;
    class request_hdr;
    class content_hdr;
    class RESTCGI_API hdr {
    public:
        enum fld_category {
            fc_null, 
            fc_general = 1<<0, 
            fc_request = 1<<1, 
            fc_response = 1<<2, 
            fc_other = 1<<3, 
            fc_entity_rsp = 1<<4, 
            fc_entity_cnt = 1<<5, 
        };
        class RESTCGI_API fld_traits {
        public:
            bool operator <(const fld_traits& rhs) const {return ln_ ? (rhs.ln_ ? (::strcmp(ln_, rhs.ln_) < 0) : false) : (rhs.ln_ != 0);} 
            const char* lower_name_as_cstring() const {return ln_;} 
            const char* name_as_cstring() const {return n_;} 
            fld_category category() const {return category_;} 
        private:
            friend class hdr;
            fld_traits(const char* ln, const char* n = 0, fld_category cat = fc_null);
            const char* ln_;
            const char* n_;
            fld_category category_;
        };
        class RESTCGI_API key {
        public:
            key(const std::string& name, bool lookup = false); 
            bool is_null() const {return !p_ && name_.empty();} 
            bool operator ==(const key& rhs) const {return p_ == rhs.p_ && lower_name_ == rhs.lower_name_;} 
            bool operator <(const key& rhs) const; 
            const char* name_as_cstring() const {return p_ ? p_->name_as_cstring() : name_.c_str();} 
            const char* lower_name_as_cstring() const {return p_ ? p_->lower_name_as_cstring() : lower_name_.c_str();} 
            fld_category category() const {return p_ ? p_->category() : fc_other;} 
        private:
            friend class hdr;
            key(const fld_traits* p = 0) : p_(p) {}
            const fld_traits* p_; 
            std::string name_; 
            std::string lower_name_; 
        };
        typedef std::map<key, std::string> map_type; 
        typedef map_type::const_iterator const_iterator; 
        virtual ~hdr(); 
        bool empty() const {return map_.empty();} 
        const_iterator begin() const {return map_.begin();} 
        const_iterator end() const {return map_.end();} 






        template<typename T> bool insert(const std::string& name, const T& value) {
            if (name.empty())
                return false;
            key k(name, true);
            std::string v = uripp::convert(value);
            return insert(k, v);
        }
        template<typename T> bool find(const std::string& name, T& value) const {
            if (name.empty())
                return false;
            key k(name, true);
            const_iterator it = map_.find(k);
            if (it == end())
                return false;
            try {uripp::convert(it->second, value);}
            catch (const std::exception& e) {throw_bad_request(k.name_as_cstring(), e.what());}
            return true;
        }
        bool erase(const std::string& name); 

        std::ostream& operator <<(std::ostream& os) const;
        static const fld_traits* find_fld_traits(const std::string& lower_name);
        static const char FLD_NAME_END_CHAR; 
        static const char EOL_CSTR[3]; 
    protected:
        hdr(int categories); 
        bool insert(int fld_traits_off, const std::string& v); 
        bool insert(const key& k, const std::string& value, bool update = false); 
        std::string find(int fld_traits_off) const; 
        static void throw_bad_request(const char* name, const char* what); 
        virtual void on_inserted(const_iterator it) {} 
        const int categories_; 
    private:
        friend void RESTCGI_API copy(const env& e, request_hdr& rh, content_hdr& ch);
        map_type map_;
        static const fld_traits flds_traits_[]; 
        static const fld_traits* flds_traits_end_; 
    };
    class RESTCGI_API general_hdr : public hdr, private cookies::observer {
    public:
        typedef restcgi::cookies cookies_type; 
        std::string cache_control() const; 
        bool cache_control(const std::string& v); 
        std::string connection() const; 
        bool connection(const std::string& v); 
        bool date(date_time& v, const date_time& dflt) const; 
        bool date(const date_time& v); 
        std::string pragma() const; 
        bool pragma(const std::string& v); 
        std::string trailer() const; 
        bool trailer(const std::string& v); 
        std::string transfer_encoding() const; 
        bool transfer_encoding(const std::string& v); 
        std::string upgrade() const; 
        bool upgrade(const std::string& v); 
        std::string via() const; 
        bool via(const std::string& v); 
        std::string warning() const; 
        bool warning(const std::string& v); 
        cookies_type& cookies() {return cookies_;} 
        const cookies_type& cookies() const {return cookies_;} 
    protected:
        general_hdr(int categories); 
        ~general_hdr();
    private:
        void on_inserted(const_iterator it);
        void on_updated_reset();
        void on_updated(const cookies_type& v);
        bool on_updated_;
        cookies_type cookies_;
    };
    class RESTCGI_API request_hdr : public general_hdr {
    public:
        request_hdr(); 
        std::string accept() const; 
        std::string accept_charset() const; 
        std::string accept_encoding() const; 
        std::string accept_language() const; 
        std::string authorization() const; 
        std::string expect() const; 
        std::string from() const; 
        std::string host() const; 
        std::string if_match() const; 
        bool if_modified_since(date_time& v, const date_time& dflt) const; 
        std::string if_none_match() const; 
        std::string if_range() const; 
        bool if_unmodified_since(date_time& v, const date_time& dflt) const; 
        bool max_forwards(size_t& v, size_t dflt) const; 
        std::string proxy_authorization() const; 
        std::string range() const; 
        std::string referer() const; 
        std::string te() const; 
        std::string user_agent() const; 
    };
    class RESTCGI_API response_hdr : public general_hdr {
    public:
        response_hdr(); 
        std::string accept_ranges() const; 
        bool accept_ranges(const std::string& v); 
        bool age(size_t& v, size_t dflt) const; 
        bool age(size_t v); 
        std::string allow() const; 
        bool allow(const std::string& v); 
        std::string content_location() const; 
        bool content_location(const std::string& v); 
        std::string etag() const; 
        bool etag(const std::string& v); 
        bool expires(date_time& v, const date_time& dflt) const; 
        bool expires(const date_time& v); 
        bool last_modified(date_time& v, const date_time& dflt) const; 
        bool last_modified(const date_time& v); 
        std::string location() const; 
        bool location(const std::string& v); 
        std::string proxy_authenticate() const; 
        bool proxy_authenticate(const std::string& v); 
        bool retry_after(date_time& dt, size_t& secs) const; 
        bool retry_after(const date_time& v); 
        bool retry_after(size_t v); 
        std::string server() const; 
        bool server(const std::string& v); 
        std::string vary() const; 
        bool vary(const std::string& v); 
        std::string www_authenticate() const; 
        bool www_authenticate(const std::string& v); 
    };
    class RESTCGI_API content_hdr : public hdr {
    public:
        content_hdr(); 
        std::string content_encoding() const; 
        bool content_encoding(const std::string& v); 
        std::string content_language() const; 
        bool content_language(const std::string& v); 
        bool content_length(size_t& v, size_t dflt) const; 
        bool content_length(size_t v); 
        std::string content_md5() const; 
        bool content_md5(const std::string& v); 
        std::string content_range() const; 
        bool content_range(const std::string& v); 
        std::string content_type() const; 
        bool content_type(const std::string& v); 
    };
    inline std::ostream& operator <<(std::ostream& os, const hdr& v) {return v.operator <<(os);}
    void RESTCGI_API copy(const env& e, request_hdr& rh, content_hdr& ch);
    content_hdr RESTCGI_API content_hdr_from_type(const std::string& type);
}
#endif

---