URL.cc

Go to the documentation of this file.

/*
 * URL.cc
 *
 * Smalltalk like class library for C++
 * Unified resource locator.
 *
 * Copyright (c) 2004 Milan Cermak
 */
/*
 * 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.1 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
 */
#include <stlib/net/URL.h>

#include <stlib/ByteArray.h>
#include <stlib/Integer.h>
#include <stlib/String.h>
#include <stlib/WriteStream.h>
#include <stlib/net/IPSocketAddress.h>

#include <stlib/Error.h>

using namespace Net;

URL::URL(String *protocol)
{
    _proto = protocol;
}

/* Class-accessing protocol */
String *URL::className(void) const
{
    return new String("URL");
}

/* Instance creation protocol */
URL *URL::fromString(String *urlString)
{
    URL *url;
    String *proto;
    long protoIdx;

    if (!urlString->includesSubcollection("://")) {
        (new Error(new String("Protocol expected in url string."),
                   new String(__PRETTY_FUNCTION__), urlString))->raise();
    }
    protoIdx = urlString->indexOf(':');
    proto = dynamic_cast<String *>(urlString->copy(0, protoIdx));
    urlString = dynamic_cast<String *>(urlString->copy(proto->size() + 3, urlString->size()));
    url = new URL(proto);
    url->parseHost(urlString);

    return url;
}

/* Initialize protocol */
void URL::parseHost(String *urlWithPath)
{
    long portIdx = urlWithPath->indexOf(':');
    long pathIdx = urlWithPath->indexOf('/');
    long fragmentIdx = urlWithPath->indexOf('#');
    long queryIdx = urlWithPath->indexOf('?');

    if (queryIdx > 0) {
        _query = dynamic_cast<String *>(urlWithPath->copy(queryIdx + 1,
                                                          urlWithPath->size()));
    } else queryIdx = urlWithPath->size();

    if (fragmentIdx > 0) {
        _fragment = dynamic_cast<String *>(urlWithPath->copy(fragmentIdx + 1,
                                                             queryIdx));
    } else fragmentIdx = queryIdx;

    if (pathIdx > 0) {
        _path = dynamic_cast<String *>(urlWithPath->copy(pathIdx + 1, fragmentIdx));
    } else pathIdx = fragmentIdx;

    if (portIdx > 0) {
        String *portStr = dynamic_cast<String *>(urlWithPath->copy(portIdx + 1,
                                                                   pathIdx));
        _port = portStr->asNumber()->asLong() & 0xffff;
    } else {
        _port = 0;
        portIdx = pathIdx;
    }

    _host = dynamic_cast<String *>(urlWithPath->copy(0, portIdx));
}

/* Accessing protocol */
String *URL::protocol(void)
{
    return _proto;
}

String *URL::host(void)
{
    return _host;
}

ByteArray *URL::hostAddress(void)
{
    return socketAddress()->hostAddress();
}

String *URL::hostAndPort(void)
{
    if (_port <= 0)
        return _host;
    return dynamic_cast<String *>(&(*_host + *(String::format(":%u", _port))));
}

String *URL::pathString(void)
{
    Stream *stream = (new String(64))->writeStream();
    stream->nextPut('/');
    stream->nextPutAll(_path);
    if (_query != nil) {
        stream->nextPut('?');
        stream->nextPutAll(_query);
    }
    return dynamic_cast<String *>(stream->contents());
}

unsigned short URL::port(void)
{
    return _port;
}

IPSocketAddress *URL::socketAddress(void)
{
    return IPSocketAddress::hostName(_host, _port);
}

/* Converting protocol */
String *URL::asString(void) const
{
    Stream *stream = (new String(64))->writeStream();
    printContentOn(stream);
    return dynamic_cast<String *>(stream->contents());
}

/* Printing protocol */
void URL::printOn(Stream *stream) const
{
    stream->nextPut('<');
    printContentOn(stream);
    stream->nextPut('>');
}

void URL::printContentOn(Stream *stream) const
{
    stream->nextPutAll(_proto);
    stream->nextPutAll("://");
    stream->nextPutAll(_host);
    if (_port > 0) {
        stream->nextPut(':');
        stream->print((long int) _port);
    }
    stream->nextPut('/');
    stream->nextPutAll(_path);
    if (_query != nil) {
        stream->nextPut('?');
        stream->nextPutAll(_query);
    }
}

---