HeaderBase.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 "HeaderBase.h"
#include "Imports.cpp"

HeaderBase::HeaderBase()
 :  d_ptr (new Data)
{
}

HeaderBase::HeaderBase (Data *d)
 :  d_ptr (d)
{
}

HeaderBase::~HeaderBase()
{
}

bool HeaderBase::operator== (const HeaderBase &other) const
{
    return toRawBytes() == other.toRawBytes();
}

bool HeaderBase::operator!= (const HeaderBase &other) const
{
    return !operator== (other);
}

auto_ptr <DataBase> HeaderBase::copy() const
{
    return auto_ptr <DataBase> (new HeaderBase (*this));
}


bool HeaderBase::parse (const QByteArray &rawBytes)
{
    auto_ptr <DataBase> tmpCopy = copy();
    HeaderBase &tempHeader = dynamic_cast <HeaderBase &> (*tmpCopy);
    if (tempHeader.doParse (rawBytes)) {
        *this = tempHeader;
        return true;
    } else {
        return false;
    }
}


QByteArray HeaderBase::toRawBytes() const
{
    Q_SD (const Data);
    QByteArray ret = rawStartLine();
    foreach (const QByteArray &fieldName, d->orderedFieldList)
        ret += rawHeaderLine (fieldName);
    ret += "\r\n"; // Add the final <CR><LF>.
    return ret;
}


QByteArray HeaderBase::fieldValue (const QByteArray &fieldName) const
{
    Q_SD (const Data);
    QByteArray nameLower = fieldName.toLower();
    if (!d->fieldValues.contains (nameLower))
        return QByteArray();
    else {
        QByteArray res;
        foreach (const QByteArray &value, d->fieldValues [nameLower])
            res += value + ", ";
        res.chop (2); // the last ", "
        return res;
    }
}


QList <QByteArray> HeaderBase::fields() const
{
    Q_SD (const Data);
    return d->fieldValues.keys();
}


bool HeaderBase::hasField (const QByteArray &fieldName) const
{
    Q_SD (const Data);
    return d->fieldValues.contains (fieldName.toLower());
}


QList <QByteArray> HeaderBase::fieldValues (const QByteArray &fieldName) const
{
    Q_SD (const Data);
    QByteArray nameLower = fieldName.toLower();
    if (!d->fieldValues.contains (nameLower))
        return QList <QByteArray>();
    else
        return d->fieldValues [nameLower];
}


void HeaderBase::setFieldValue (const QByteArray &fieldName,
                            const QByteArray &fieldValue)
{
    removeField (fieldName);
    addFieldValues (fieldName, fieldValue.split (','));
}


void HeaderBase::addFieldValue (const QByteArray &fieldName,
                                const QByteArray &fieldValue)
{
    Q_SD (Data);
    QByteArray nameLower = fieldName.toLower();
    QByteArray trimmedValue = fieldValue.trimmed();
    if (trimmedValue != "") // Don't add empty values:
        d->fieldValues [nameLower].push_back (fieldValue.trimmed());
    else
        d->fieldValues [nameLower]; // Makes sure nameLower is added in the map.
    d->originalCaseFieldNames [nameLower] = fieldName;
    if (!d->orderedFieldList.contains (nameLower))
        d->orderedFieldList.append (nameLower);
}


void HeaderBase::addFieldValues (const QByteArray &fieldName,
                             const QList <QByteArray> &fieldValues)
{
    foreach (const QByteArray &value, fieldValues)
        addFieldValue (fieldName, value);
}


void HeaderBase::removeField (const QByteArray &fieldName)
{
    Q_SD (Data);
    QByteArray nameLower (fieldName.toLower());
    if (d->fieldValues.contains (nameLower)) {
        d->fieldValues.remove (nameLower);
        d->originalCaseFieldNames.remove (nameLower);
        d->orderedFieldList.removeAll (nameLower);
    }
}

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


QByteArray HeaderBase::rawStartLine() const
{
    return QByteArray();
}

QByteArray HeaderBase::rawHeaderLine (const QByteArray &fieldName) const
{
    Q_SD (const Data);
    QByteArray ret;
    int oldLength = ret.length(); // == 0
    ret += d->originalCaseFieldNames [fieldName] + ":";
    foreach (const QByteArray &value, d->fieldValues [fieldName]) {
        // +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 + ",";
        }
        else
            ret += " " + value + ",";
    }
    if (d->fieldValues [fieldName].size() > 0)
        ret.chop(1); // Remove the last ",".
    ret += "\r\n"; // Terminate the line with <CR><LF>.
    return ret;
}


bool HeaderBase::doParse (const QByteArray &rawBytes)
{
    QList <QByteArray> lst = splitStringIntoLines (rawBytes);
    if (lst.isEmpty())
        return true;

    QList <QByteArray> lines;
    std::for_each (lst.begin(), lst.end(), lineAppender(lines));
    return parseAllLines (lines);
}


QList <QByteArray> HeaderBase::splitStringIntoLines (const QByteArray &str)
{
    QByteArray normalizedStr = str;
    normalizedStr.replace ("\r\n", "\n");
    QList <QByteArray> lines = normalizedStr.split('\n');
    lines.removeAll(QByteArray()); // No empties
    return lines;
}


bool HeaderBase::parseAllLines (const QList <QByteArray> &lines)
{
    QList <QByteArray>::const_iterator it = lines.begin();
    if (it != lines.end())
        if (!parseStartLine (*it++))
            return false;
    for(; it != lines.end(); ++it)
        if (!parseHeaderLine(*it))
            return false;
    return true;
}


bool HeaderBase::parseStartLine (const QByteArray &line)
{
    return parseHeaderLine (line);
}


bool HeaderBase::parseHeaderLine (const QByteArray &line)
{
    int i = line.indexOf(':');
    if (i == -1)
        return false;

    addFieldValue (line.left (i).trimmed (), line.mid (i + 1));
    return true;
}

Copyright © 2006 Peter Dimov.
Powered by Doxygen.