Header.cpp

Go to the documentation of this file.

/*

Copyright (C) 2005-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 "Header.h"
#include <algorithm>
#include <functional>

using namespace Http;

namespace Http {

class HeaderPrivate
{
public:
    inline virtual              ~HeaderPrivate() {}

    struct FieldInfo
    {
        QString                 originalCaseFieldName;
        QStringList             fieldValues;

        FieldInfo() : originalCaseFieldName(), fieldValues() {}
    };

    QMap <QString, FieldInfo>   fields;
    QStringList                 orderedFieldList;
    bool                        valid;

    HeaderPrivate() :   fields(), orderedFieldList(), valid (false) {}
};

} // namespace Http;

Header::Header()
    : d(new HeaderPrivate)
{
    d->valid = true;
}

Header::Header (const Header &header)
    : d(new HeaderPrivate)
{
    d->valid            = header.d->valid;
    d->fields           = header.d->fields;
    d->orderedFieldList = header.d->orderedFieldList;
}

Header::Header (const QString &str)
    : d(new HeaderPrivate)
{
    d->valid = parse(str);
}

Header::~Header()
{
    delete d;
}

Header & Header::operator= (const Header &header)
{
    d->valid            = header.d->valid;
    d->fields           = header.d->fields;
    d->orderedFieldList = header.d->orderedFieldList;
    return *this;
}

bool Header::operator== (const Header &other) const
{
    return toString() == other.toString();
}

bool Header::operator!= (const Header &other) const
{
    return !(*this == other);
}

bool Header::isValid() const
{
    return d->valid;
}

struct lineAppender : public std::unary_function<QString, void>
{
    QStringList& m_lines;
    lineAppender( QStringList& lines ) : m_lines( lines ) {
    }
    void operator()(QString& line) {
        if (!line.isEmpty()) {
            if (line[0].isSpace()) {
                if (!m_lines.isEmpty()) {
                    m_lines.last() += " ";
                    m_lines.last() += line.trimmed();
                }
            } else {
                m_lines.append(line);
            }
        }
    }
};

QStringList Header::splitStringIntoLines (const QString &str)
{
    QStringList lst;
    int pos = str.indexOf('\n');
    if (pos > 0 && str.at(pos - 1) == '\r')
        lst = str.trimmed().split("\r\n");
    else
        lst = str.trimmed().split("\n");
    lst.removeAll(QString()); // No empties
    return lst;
}

bool Header::parseAllLines (const QStringList& lines)
{
    int number = 0;
    QStringList::const_iterator it = lines.begin();
    for(; it != lines.end(); ++it) {
        if (!parseLine(*it, number++)) {
            return false;
        }
    }
    return true;
}

bool Header::parse (const QString &str)
{
    d->fields.clear();
    d->orderedFieldList.clear();
    d->valid = true;

    QStringList lst = splitStringIntoLines (str);
    if (lst.isEmpty())
        return true;

    QStringList lines;
    std::for_each (lst.begin(), lst.end(), lineAppender(lines));
    d->valid = parseAllLines (lines);
    return d->valid;
}

void Header::setValid (bool v)
{
    d->valid = v;
}

QString Header::fieldValue (const QString &fieldName) const
{
    QString nameLower (fieldName.toLower());
    if (!d->fields.contains (nameLower))
        return QString();
    else
        return d->fields [nameLower].fieldValues.join (", ");
}

QStringList Header::fields() const
{
    return d->fields.keys();
}

bool Header::hasField (const QString &fieldName) const
{
    return d->fields.contains (fieldName.toLower());
}

void Header::setFieldValue (const QString &fieldName,
                            const QString &fieldValue)
{
    QString nameLower (fieldName.toLower());
    // Make sure old values are discarded.
    d->fields.remove (nameLower);
    addFieldValues(fieldName, fieldValue.split(",", QString::SkipEmptyParts));
}

void Header::addFieldValue (const QString &fieldName,
                            const QString &fieldValue)
{
    QString nameLower (fieldName.toLower());
    d->fields [nameLower].fieldValues.push_back (fieldValue.trimmed());
    // We may have just created a new field:
    d->fields [nameLower].originalCaseFieldName = fieldName;
    if (!d->orderedFieldList.contains (nameLower))
        d->orderedFieldList.append (nameLower);
}

void Header::addFieldValues (const QString &fieldName,
                             const QStringList &fieldValues)
{
    foreach (QString value, fieldValues)
        addFieldValue (fieldName, value);
}

QStringList Header::fieldValues (const QString &fieldName) const
{
    QString nameLower (fieldName.toLower());
    if (!d->fields.contains (nameLower))
        return QStringList();
    else
        return d->fields [nameLower].fieldValues;
}

void Header::removeField (const QString &fieldName)
{
    QString nameLower (fieldName.toLower());
    if (d->fields.contains (nameLower)) {
        d->fields.remove (nameLower);
        d->orderedFieldList.removeAt (d->orderedFieldList.indexOf (nameLower));
    }
}

bool Header::parseLine (const QString &line, int)
{
    int i = line.indexOf(':');
    if (i == -1)
        return false;

    addFieldValues (line.left (i).trimmed (),
                    line.mid (i + 1).split (",", QString::SkipEmptyParts));
    return true;
}

QString Header::toString() const
{
    if (!isValid())
        return "";

    QString ret = "";

    foreach (QString fieldName, d->orderedFieldList) {
        int oldLength = ret.length();
        ret += d->fields [fieldName].originalCaseFieldName + ":";
        foreach (QString value, d->fields [fieldName].fieldValues) {
            // +1 for " ", +1 for ","
            if (ret.length() - oldLength + value.length() + 1 > 80) {
                // +2 because of "\r\n"; the "\t" counts for the next line
                oldLength = ret.length() + 2;
                ret += "\r\n\t" + value.trimmed() + ",";
            }
            else
                ret += " " + value.trimmed() + ",";
        }
        if (d->fields [fieldName].fieldValues.size() > 0)
            ret.chop(1); // Remove the last ",".
        ret += "\r\n"; // Terminate the line with CRLF.
    }
    return ret;
}

Copyright © 2006 Peter Dimov.
Powered by Doxygen.