CStringList.cpp

Go to the documentation of this file.

/* +---------------------------------------------------------------------------+
   |                     Mobile Robot Programming Toolkit (MRPT)               |
   |                          http://www.mrpt.org/                             |
   |                                                                           |
   | Copyright (c) 2005-2017, Individual contributors, see AUTHORS file        |
   | See: http://www.mrpt.org/Authors - All rights reserved.                   |
   | Released under BSD License. See details in http://www.mrpt.org/License    |
   +---------------------------------------------------------------------------+ */

#include "base-precomp.h"  // Precompiled headers


#include <mrpt/utils/CStringList.h>
#include <mrpt/utils/CFileInputStream.h>
#include <mrpt/utils/CFileOutputStream.h>
#include <mrpt/system/filesystem.h>
#include <mrpt/system/string_utils.h>
#include <mrpt/system/os.h>

using namespace mrpt::utils;
using namespace mrpt::system;
using namespace std;

// This must be added to any CSerializable class implementation file.
IMPLEMENTS_SERIALIZABLE(CStringList, CSerializable, mrpt::utils)

/*---------------------------------------------------------------
                                                Constructor
  ---------------------------------------------------------------*/
CStringList::CStringList()
{

}

/*---------------------------------------------------------------
                                                Constructor
  ---------------------------------------------------------------*/
CStringList::CStringList(const string& text)
{
        MRPT_START
        setText( text );
        MRPT_END
}


/*---------------------------------------------------------------
                                                add
  ---------------------------------------------------------------*/
void  CStringList::add( const string &str )
{
        m_strings.push_back( str );
}

/*---------------------------------------------------------------
                                                insert
  ---------------------------------------------------------------*/
void  CStringList::insert( size_t index, const string &str )
{
        MRPT_START
        if (index>=m_strings.size()) THROW_EXCEPTION("index out of bounds!");

        m_strings.insert( m_strings.begin()+index, str);

        MRPT_END
}

/*---------------------------------------------------------------
                                                set
  ---------------------------------------------------------------*/
void  CStringList::set( size_t index, const string &str )
{
        MRPT_START
        if (index>=m_strings.size()) THROW_EXCEPTION("index out of bounds!");

        m_strings[index]= str;

        MRPT_END
}


/*---------------------------------------------------------------
                                                clear
  ---------------------------------------------------------------*/
void  CStringList::clear()
{
        m_strings.clear();
}


/*---------------------------------------------------------------
                                                remove
  ---------------------------------------------------------------*/
void  CStringList::remove(size_t index)
{
        MRPT_START
        if (index>=m_strings.size()) THROW_EXCEPTION("index out of bounds!");

        m_strings.erase( m_strings.begin()+index );

        MRPT_END
}


/*---------------------------------------------------------------
                                                find
  ---------------------------------------------------------------*/
bool  CStringList::find(
        const string            &compareText,
        size_t                                  foundIndex,
        bool                                    caseSensitive) const
{
        MRPT_START

        foundIndex = 0;
        if (caseSensitive)
        {
                for (deque<string>::const_iterator it=m_strings.begin();it!=m_strings.end();++it,foundIndex++)
                        if (!os::_strcmp(compareText.c_str(),it->c_str()))
                                return true;
        }
        else
        {
                for (deque<string>::const_iterator it=m_strings.begin();it!=m_strings.end();++it,foundIndex++)
                        if (!os::_strcmpi(compareText.c_str(),it->c_str()))
                                return true;
        }

        return false;
        MRPT_END
}

/*---------------------------------------------------------------
                                                getText
  ---------------------------------------------------------------*/
void  CStringList::getText(string &outText) const
{
        MRPT_START
        deque<string>::const_iterator   it;
        size_t                                                          curPos = 0,totalLen = 0;

        // 1) Compute overall length, including 2 chars per new-line:
        // ----------------------------------------------------------------
        for (it=m_strings.begin();it!=m_strings.end();it++)
                totalLen += it->size() + 2;

        outText.resize(totalLen);

        // 2) Copy the text out:
        // ----------------------------------------------------------------
        for (it=m_strings.begin();it!=m_strings.end();it++)
        {
                os::memcpy(&outText[curPos],totalLen,it->c_str(),it->size());
                curPos+=it->size();
                outText[curPos++]='\r';
                outText[curPos++]='\n';
        }

        MRPT_END
}

/*---------------------------------------------------------------
                                                setText
  ---------------------------------------------------------------*/
void  CStringList::setText(const string &inText)
{
        MRPT_START
        mrpt::system::tokenize( inText,"\r\n",m_strings );
        MRPT_END
}

/*---------------------------------------------------------------
                                                loadFromFile
  ---------------------------------------------------------------*/
void  CStringList::loadFromFile(const string &fileName)
{
        MRPT_START

        ASSERT_( mrpt::system::fileExists(fileName) );

        CFileInputStream        fil(fileName.c_str());

        // Load the whole file into a string:
        size_t nBytes = fil.getTotalBytesCount();
        string          wholeStr;
        wholeStr.resize( nBytes );

        // "Rewind" :-)
        fil.Seek(0);
        if ( nBytes != fil.ReadBuffer( &wholeStr[0],nBytes ) )
                THROW_EXCEPTION("Error reading text from file!");

        // Parse:
        setText(wholeStr);

        MRPT_END
}

/*---------------------------------------------------------------
                                                saveToFile
  ---------------------------------------------------------------*/
void  CStringList::saveToFile(const string &fileName) const
{
        MRPT_START

        CFileOutputStream       fil(fileName.c_str());
        deque<string>::const_iterator   it;

        for (it=m_strings.begin();it!=m_strings.end();++it)
        {
                fil.WriteBuffer( it->c_str(), it->size() );
                fil.WriteBuffer( "\r\n",2 );
        }

        MRPT_END
}


/*---------------------------------------------------------------
                                                writeToStream
 ---------------------------------------------------------------*/
void  CStringList::writeToStream(mrpt::utils::CStream &out, int *out_Version) const
{
        if (out_Version)
                *out_Version = 0;
        else
        {
                uint32_t        i,N = (uint32_t) m_strings.size();

                out << N;

                for (i=0;i<N;i++)
                        out << m_strings[i];
        }

}

/*---------------------------------------------------------------
                                                readFromStream
 ---------------------------------------------------------------*/
void  CStringList::readFromStream(mrpt::utils::CStream &in, int version)
{
        switch(version)
        {
        case 0:
                {
                        uint32_t        i,N;

                        in >> N;

                        m_strings.resize(N);

                        for (i=0;i<N;i++)
                                in >> m_strings[i];

                } break;
        default:
                MRPT_THROW_UNKNOWN_SERIALIZATION_VERSION(version)

        };
}

/*---------------------------------------------------------------
                                                size
 ---------------------------------------------------------------*/
size_t  CStringList::size() const
{
        return m_strings.size();
}

/*---------------------------------------------------------------
                                                get
 ---------------------------------------------------------------*/
void  CStringList::get(size_t index, string &outText) const
{
        MRPT_START
        if (index>=m_strings.size()) THROW_EXCEPTION("index out of bounds!");

        outText = m_strings[index];

        MRPT_END
}

/*---------------------------------------------------------------
                                                operator ()
 ---------------------------------------------------------------*/
string  CStringList::operator ()(size_t index) const
{
        MRPT_START
        if (index>=m_strings.size()) THROW_EXCEPTION("index out of bounds!");

        return m_strings[index];
        MRPT_END
}

/*---------------------------------------------------------------
                                                operator ()
 ---------------------------------------------------------------*/
string&  CStringList::operator ()(size_t index)
{
        MRPT_START
        if (index>=m_strings.size()) THROW_EXCEPTION("index out of bounds!");

        return m_strings[index];
        MRPT_END
}

/*---------------------------------------------------------------
                                                get_string
 ---------------------------------------------------------------*/
string  CStringList::get_string( const string &keyName )
{
        MRPT_START
        string          strToLookFor(keyName + string("="));
        size_t                  idx = string::npos;

        for (deque<string>::iterator it=m_strings.begin();it!=m_strings.end();++it)
        {
                idx = it->find(strToLookFor);
                if (idx==0)
                        return  it->substr( strToLookFor.size() );
        }

        THROW_EXCEPTION( format("Key '%s' not found!",keyName.c_str()) );

        MRPT_END
}

/*---------------------------------------------------------------
                                                get_float
 ---------------------------------------------------------------*/
float CStringList::get_float( const string &keyName )
{
        MRPT_START
        string  s( get_string(keyName) );
        return (float)atof(s.c_str());
        MRPT_END
}

/*---------------------------------------------------------------
                                                get_int
 ---------------------------------------------------------------*/
int CStringList::get_int( const string &keyName )
{
        MRPT_START
        string  s( get_string(keyName) );
        return atoi(s.c_str());
        MRPT_END
}

/*---------------------------------------------------------------
                                                get_double
 ---------------------------------------------------------------*/
double CStringList::get_double( const string &keyName )
{
        MRPT_START
        string  s( get_string(keyName) );
        return atof(s.c_str());
        MRPT_END
}

/*---------------------------------------------------------------
                                                get_bool
 ---------------------------------------------------------------*/
bool CStringList::get_bool( const string &keyName )
{
        MRPT_START
        string  s( get_string(keyName) );
        return atoi(s.c_str())!=0;
        MRPT_END
}

/*---------------------------------------------------------------
                                                set
 ---------------------------------------------------------------*/
void  CStringList::set( const string &keyName, const string &value )
{
        MRPT_START
        string          strToLookFor(keyName + string("="));
        size_t                  idx = string::npos;

        for (deque<string>::iterator it=m_strings.begin();it!=m_strings.end();++it)
        {
                idx = it->find(strToLookFor);
                if (idx==0)
                {
                        // Replace existing string:
                        (*it) = strToLookFor + value ;
                        return;
                }
        }

        // It is a new key: Append it!
        m_strings.push_back( strToLookFor + value );

        MRPT_END
}
/*---------------------------------------------------------------
                                                set
 ---------------------------------------------------------------*/
void  CStringList::set( const string &keyName, const int &value )
{
        MRPT_START
        set(keyName,format("%i",value));
        MRPT_END
}
/*---------------------------------------------------------------
                                                set
 ---------------------------------------------------------------*/
void  CStringList::set( const string &keyName, const float &value )
{
        MRPT_START
        set(keyName,format("%.10e",value));
        MRPT_END
}

/*---------------------------------------------------------------
                                                set
 ---------------------------------------------------------------*/
void  CStringList::set( const string &keyName, const double &value )
{
        MRPT_START
        set(keyName,format("%.16e",value));
        MRPT_END
}

/*---------------------------------------------------------------
                                                set
 ---------------------------------------------------------------*/
void  CStringList::set( const string &keyName, const bool &value )
{
        MRPT_START
        set(keyName,string(value ? "1":"0"));
        MRPT_END
}