ConcreteProtocol.cpp

Go to the documentation of this file.

/*

Copyright (C) 2006-2007 by Peter Dimov.

This file is part of Calitko (http://www.calitko.org).

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

Calitko 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 General Public License for more details.

You should have received a copy of the GNU General Public License
along with Calitko; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

*/

#include "Qt.h"
#include "ConcreteProtocol.h"
#include "IdentityContentLengthBodyReader.h"
#include "IdentityContentLengthBodyWriter.h"
#include "IdentityReadAllBodyReader.h"
#include "RequestHeader.h"
#include "ResponseHeader.h"
#include "Imports.cpp"

ConcreteProtocol::ConcreteProtocol()
{
}

ConcreteProtocol::~ConcreteProtocol()
{
}


Header ConcreteProtocol::createHeader (const QByteArray &rawBytes)
{
    RequestHeader requestHeader;
    if (requestHeader.parse (rawBytes))
        return requestHeader;
    ResponseHeader response;
    if (response.parse (rawBytes))
        return response;
    return Header();
}


BodyReader * ConcreteProtocol::createBodyReader (const Header &header)
{
    auto_ptr <BodyReader> bodyReader = doCreateBodyReader (*header);
    return addBodyReader (bodyReader);
}

ConcreteProtocol::ReaderPointer
ConcreteProtocol::doCreateBodyReader (const HeaderBase &header)
{
    const QByteArray encoding = header.fieldValue ("Transfer-Encoding");
    const QByteArray length = header.fieldValue ("Content-Length");

    if (encoding.isEmpty() || encoding == "identity") {
        int intLength = length.toInt();
        if (length.isEmpty() || intLength < 0)
            return ReaderPointer (new IdentityReadAllBodyReader);
        else
            return ReaderPointer
                (new IdentityContentLengthBodyReader (intLength));
    }
    Q_ASSERT (false);
    return ReaderPointer();
}


BodyWriter * ConcreteProtocol::createBodyWriter (const Header &header)
{
    auto_ptr <BodyWriter> bodyWriter = doCreateBodyWriter (*header);
    return addBodyWriter (bodyWriter);
}

ConcreteProtocol::WriterPointer
ConcreteProtocol::doCreateBodyWriter (const HeaderBase &header)
{
    const QByteArray encoding = header.fieldValue ("Transfer-Encoding");
    const QByteArray length = header.fieldValue ("Content-Length");

    if (encoding.isEmpty() || encoding == "identity") {
        int intLength = length.toInt();
        if (length.isEmpty() || intLength < 0) {
            Q_ASSERT (false); // we need a IdentityWriteAllWriter
            return WriterPointer();
        } else
            return WriterPointer
                (new IdentityContentLengthBodyWriter (intLength));
    }
    Q_ASSERT (false);
    return WriterPointer();
}


void ConcreteProtocol::destroyBodyReader (BodyReader *reader)
{
    Q_ASSERT (bodyReaders.contains (reader));
    bodyReaders.remove (reader);
    delete reader;
}


void ConcreteProtocol::destroyBodyWriter (BodyWriter *writer)
{
    Q_ASSERT (bodyWriters.contains (writer));
    bodyWriters.remove (writer);
    delete writer;
}

BodyReader * ConcreteProtocol::addBodyReader (ReaderPointer reader)
{
    Q_ASSERT (reader.get() != 0);
    Q_ASSERT (!bodyReaders.contains (reader.get()));
    bodyReaders.insert (reader.get());
    return reader.release();
}

BodyWriter * ConcreteProtocol::addBodyWriter (WriterPointer writer)
{
    Q_ASSERT (writer.get() != 0);
    Q_ASSERT (!bodyWriters.contains (writer.get()));
    bodyWriters.insert (writer.get());
    return writer.release();
}

Copyright © 2006 Peter Dimov.
Powered by Doxygen.