URI.h

Go to the documentation of this file.

 #pragma once
 
#include <string.h>
#include <stdexcept>
#include <set>
#include <map>
#include <vector>
 
namespace Gorgon { namespace Encoding {
    class URIError : public std::runtime_error {
    public:
        using std::runtime_error::runtime_error;
    };
 
    class URI {
    public:
        URI() = default;
 
        URI(const std::string &scheme, const std::string &host, const std::string &path, const std::string &query = "", const std::string &fragment="");
 
        URI(const std::string &scheme, const std::string &host, int port, const std::string &path, const std::string &query = "", const std::string &fragment="");
 
        URI(const std::string &str, bool inpagelink = false);
 
        URI(const char *str) : URI(std::string(str)) { }
 
        operator std::string() const;
 
        std::string Convert() const { return *this; }
 
        bool IsValid() const;
 
        operator bool() const {
            return IsValid();
        }
 
        bool operator ==(const URI &other) const;
 
        bool operator !=(const URI &other) const { return !(*this==other); }
 
        void Combine(const std::string &link);
 
        URI operator +(const std::string &link) { 
            auto t=*this; 
            t.Combine(link); 
            return t; 
        }
 
        std::string scheme;
 
        std::string host;
 
        std::string userinfo;
 
        int port = 0;
 
        std::string path;
 
        std::string query;
 
        std::string fragment;
    };
 
    class HTTPQuery {
    public:
 
        HTTPQuery() = default;
 
        HTTPQuery(std::initializer_list<std::pair<const std::string, std::string>> init);
 
        HTTPQuery(const std::string &query);
 
        operator std::string() const;
 
        std::string Convert() const { return *this; }
        
        std::string Get(const std::string &key) const {
            if(data.count(key) == 0) return "";
            
            return data.at(key);
        }
        
        std::string &operator[](const std::string &key) {
            return data[key];
        }
        
        bool Exists(const std::string &key) const {
            return data.count(key) != 0;
        }
 
        std::map<std::string, std::string> data;
    };
 
    class URIPath {
    public:
 
        URIPath() = default;
 
        URIPath(std::initializer_list<std::string> init);
 
        URIPath(const std::string &path);
 
        URIPath(const char *path) : URIPath(std::string(path)) { }
 
        operator std::string() const;
 
        bool operator ==(const URIPath &other) const;
 
        bool operator !=(const URIPath &other) const { return !(*this==other); }
        
        int GetSize() const { return (int)segments.size(); }
        
        std::string &operator[] (int ind) { return segments[ind]; }
        
        std::string Get(int ind) const { 
            if(ind==0 && segments.size()==0) return "";
            
            return segments[ind]; 
        }
        
        std::string StripFirst() { 
            if(segments.size()==0) return "";
            
            auto ret = segments.front();
            segments.erase(segments.begin());
            
            return ret; 
        }
        
        const std::string &operator[] (int ind) const { return segments[ind]; }
 
        std::string Convert() const { return *this; }
 
        void Combine(const URIPath &another);
 
        URIPath operator +(const URIPath &another) const { 
            auto newp = *this; 
            newp.Combine(another); 
            return newp;
        }
 
        URIPath &operator +=(const URIPath &another) {
            Combine(another);
            return *this;
        }
 
        void Normalize();
 
        std::vector<std::string> segments;
    };
 
    std::ostream &operator <<(std::ostream &out, const URI &uri);
 
    std::ostream &operator <<(std::ostream &out, const HTTPQuery &query);
 
    std::ostream &operator <<(std::ostream &out, const URIPath &path);
 
    std::string URIDecode(const std::string &str);
 
    std::string URIEncode(const std::string &str);
 
    std::string PCTEncode(const std::string &str, const std::set<char> &allowed, bool allowalpha=true, bool allownum=true);
    
} }