FixedTable.cpp

Go to the documentation of this file.

/* 
 * Confdump-Agent - Dump static and runtime system configuration
 * Copyright (C) 2009-2012  Straton IT, SAS
 * 
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 3 as
 * published by the Free Software Foundation.
 * 
 * This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#include <cctype>
#include <cassert>
#include <iostream>
#include <stdexcept>
#include <string>

#include "boost/algorithm/string/trim.hpp"

#include "QVariant"

#include "Confdump/RuntimeError.hpp"
#include "Confdump/System/FixedTable.hpp"
#include "Confdump/System/ManagedElement.hpp"

using std::vector;
using std::map;
using std::string;
using std::getline;
using boost::shared_ptr;
using boost::algorithm::trim;

namespace Confdump
{

namespace System
{

FixedTable::FixedTable()
{
}

FixedTable::~FixedTable()
{
}

void FixedTable::readHeaderFrom( QString headers)
{
    //needs to be optimisated by converting each called function to use QString instead of std::String
    switch ( specification_.parsingMode() )
    {
    case UseSpecifiedHeaders:
        checkColumnPositionsFromSpecification( headers.toStdString() );
        break;

    case DetectWidthsFromHeader:
        detectColumnPositionsFromLine( headers.toStdString());
        break;
    }

    splitLineOnColumnPositions( headers.toStdString(), header_ );
}

bool FixedTable::readLineFrom( QString line, boost::shared_ptr<ManagedElement> row )
{

    vector<string> lineData;
    splitLineOnColumnPositions( line.toStdString(), lineData );
    for ( unsigned i = 0; i < lineData.size(); ++i )
    {
        string translatedHeader;
        map<string, string>::iterator translation = fieldTranslations_.find( header_[i] );
        if ( translation != fieldTranslations_.end() )
            translatedHeader = translation->second;
        else
            translatedHeader = header_[i];

        QString unicodeData( QString::fromLocal8Bit( lineData[i].c_str() ) );
        row->setProperty( translatedHeader.c_str(), unicodeData );
    }

    return true;
}

void FixedTable::detectColumnPositionsFromLine( const std::string &line )
{
    columnPositions_.clear();

    bool scanning = true;
    for ( string::size_type i = 0; i < line.size(); ++i )
    {
        if ( scanning ) // looking for the next column
        {
            if ( line[i] != ' ' )
            {
                scanning = false;
                columnPositions_.push_back( i );
            }
        }
        else // reading a column
        {
            if ( line[i] == ' ' )
            {
                scanning = true;
            }
        }
    }

    // If the line was empty, consider it as a single column
    if ( columnPositions_.empty() )
        columnPositions_.push_back( 0 );

    // For the ease of later use, add a dummy EOL end position
    columnPositions_.push_back( line.size() );
}

void FixedTable::checkColumnPositionsFromSpecification( const std::string &line )
{
    columnPositions_.clear();

    unsigned columnStart = 0;
    for ( Specification::ColumnHeadIterator head = specification_.columnHeadsBegin();
          head != specification_.columnHeadsEnd(); ++head )
    {
        if ( line.size() >= columnStart + head->skip + head->width ) // Size
        {
            string headerChunk = line.substr( columnStart + head->skip, head->width );
            trim( headerChunk );

            if ( headerChunk == head->name ) // Trimmed contents
            {
                columnPositions_.push_back( columnStart + head->skip );
                columnStart += head->skip + head->width;
            }
            else
            {
                throw RuntimeError( QObject::tr( "Expected column head '%1', got '%2'" ).arg( QString::fromStdString( head->name ) ).arg( QString::fromStdString( headerChunk ) ) );
            }
        }
        else
        {
            throw RuntimeError( QObject::tr( "Reached unexpected end of header line while reading column head '%1'" ).arg( QString::fromStdString( head->name ) ) );
        }
    }

    // For the ease of later use, add a dummy EOL end position
    columnPositions_.push_back( line.size() );
}

void FixedTable::splitLineOnColumnPositions( const std::string &line, vector<string> &row )
{
    for ( string::size_type i = 0; i < columnPositions_.size()-1; ++i )
    {
        string cell;
        if ( columnPositions_[i] < columnPositions_[i+1] - 1 )
        {
            cell = string(
                line.c_str() + columnPositions_[i],
                line.c_str() + columnPositions_[i+1] - 1 );
        }
        trim( cell );
        row.push_back( cell );
    }
}

void FixedTable::setSpecification( const Specification &spec )
{
    specification_ = spec;
}

void FixedTable::setFieldTranslations( const std::map<string, string> &translations )
{
    fieldTranslations_ = translations;
}


/*
 * FixedTable::Specification
 */

FixedTable::Specification::Specification()
{
}

FixedTable::Specification::~Specification()
{
}

FixedTable::Specification& FixedTable::Specification::addColumnHead( const std::string &name, unsigned skip, unsigned width )
{
    ColumnHead head;
    head.name = name;
    head.skip = skip;
    head.width = width;

    columnHeads_.push_back( head );

    return *this;
}

FixedTable::Specification::ColumnHeadIterator FixedTable::Specification::columnHeadsBegin() const
{
    return columnHeads_.begin();
}

FixedTable::Specification::ColumnHeadIterator FixedTable::Specification::columnHeadsEnd() const
{
    return columnHeads_.end();
}

}
}