vos/corelibs/vos/url.cc

Go to the documentation of this file.

/*
    This file is part of the Virtual Object System of
    the Interreality project (http://interreality.org).

    Copyright (C) 2001-2003 Peter Amstutz

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA

    Peter Amstutz <tetron@interreality.org>
*/

#include <vos/corelibs/vos/url.hh>

using namespace VOS;

#include <sys/types.h>

/*
#ifdef HAVE_BOOST_REGEX_H
# include <boost/regex.h>
#else
extern "C" {
# include <regex.h>
}
#endif
*/

/** @file
    Implements URL.
*/

URL URL::defaults("vop", "", "4231", "");

void URL::setDefaults(const URL& u)
{
    defaults=u;
}

URL::URL() : protocol(defaults.protocol),
             host(defaults.host),
             port(defaults.port),
             path(defaults.path)
{
    makeURLstr();
}

URL::URL(const string& pr,
         const string& ho,
         const string& po,
         const string& pa)
    : protocol(pr), host(ho),
      port(po), path(pa)
{
    makeURLstr();
}

URL::URL(const string& p) throw (BadURLError)
{
    /*static regex_t url_regexp;
    static regmatch_t pmatch[7];
    bool did_regcomp = false;
    int e;

    if(! did_regcomp) {
        regcomp(&url_regexp, "^(.+)://(.+@)?([^:/]+)(:[[:digit:]]+)?(/.*)?", REG_EXTENDED);
        did_regcomp = true;
    }
    e=regexec(&url_regexp, p.c_str(), 7, pmatch, 0);
    if(e == 0) {
        LOG("url", 4, p);
        if(pmatch[1].rm_so > -1)
            protocol=p.substr(pmatch[1].rm_so, pmatch[1].rm_eo - pmatch[1].rm_so);
        else setProtocol(defaults.getProtocol());
        if(pmatch[2].rm_so > -1)
            object=p.substr(pmatch[2].rm_so, pmatch[2].rm_eo - pmatch[2].rm_so - 1);
        else setObject(defaults.getObject());
        if(pmatch[3].rm_so > -1)
            host=p.substr(pmatch[3].rm_so, pmatch[3].rm_eo - pmatch[3].rm_so);
        else setHost(defaults.getHost());
        if(pmatch[4].rm_so > -1)
            port=p.substr(pmatch[4].rm_so + 1, pmatch[4].rm_eo - (pmatch[4].rm_so + 1));
        else setPort(defaults.getPort());
        if(pmatch[5].rm_so > -1)
            path=p.substr(pmatch[5].rm_so, pmatch[5].rm_eo - pmatch[5].rm_so);
        else setPath(defaults.getPath());
    } else {
        throw BadURLError("Maelformed URL");
        }*/

    // as elegant (relatively) as using a regular expression
    // above is, there is a huge performance
    // improvement using the following code (!!!)

    port = defaults.getPort();
    path = defaults.getPath();
    host = defaults.getHost();
    protocol = defaults.getProtocol();

    unsigned int i;
    for(i = 0; i < p.size() && p[i] != ':'; i++);
    protocol = p.substr(0,i);

    unsigned int c = i+3;
    if(p.size() > i+3 && p[i+1] == '/' && p[i+2] == '/') {
        for(i+=3; i < p.size() && p[i] != ':' && p[i] != '/'; i++);
        host = p.substr(c, i - c);
        if(i < p.size()) {
            switch(p[i]) {
            case ':':
                c = ++i;
                for(; i < p.size() && p[i] != '/'; i++);
                port = p.substr(c, i - c);
            /* fall through */
            case '/':
                path = p.substr(i);
            }
        }
    } else throw BadURLError("Malformed URL");

    makeURLstr();
}

void URL::makeURLstr()
{
    urlstr.erase(urlstr.begin(), urlstr.end());
    urlstr += protocol + "://";
    urlstr += host;
    if(port != "") urlstr += ":" + port;
    urlstr += path;
    if(port != "") hostandport = host + ":" + port;
    else hostandport = host;
}

const string& URL::getProtocol() const { return protocol; }
const string& URL::getHost() const { return host; }
const string& URL::getPort() const { return port; }
const string& URL::getPath() const { return path; }
const string& URL::getHostAndPort() const { return hostandport; }
const string& URL::getString() const { return urlstr; }

void URL::setProtocol(const string& p) { protocol=p; makeURLstr(); }
void URL::setHost(const string& h) { host=h; makeURLstr(); }
void URL::setPort(const string& p) { port=p; makeURLstr(); }
void URL::setPath(const string& p) { path=p; makeURLstr(); }

void URL::setHostAndPort(const string& hp)
{
    unsigned int c = (unsigned int)hp.find(":");
    if(c != string::npos) {
        host=hp.substr(0, c);
        port=hp.substr(c+1);
    } else {
        host=hp;
        port=defaults.port;
    }
    makeURLstr();
}

---