CTypeSelector.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/CTypeSelector.h>
#include <mrpt/utils/CStream.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(CTypeSelector, CSerializable, mrpt::utils)

/*---------------------------------------------------------------
                                                writeToStream
 ---------------------------------------------------------------*/
void  CTypeSelector::writeToStream(mrpt::utils::CStream &out, int *out_Version) const
{
        if (out_Version)
                *out_Version = 0;
        else
        {
                std::vector<std::string>::const_iterator        it;
                uint32_t                                                        n = (uint32_t)possibleTypes.size();

                out << n;

                for (it=possibleTypes.begin();it<possibleTypes.end();++it)
                        out << *it;

                // Selection:
                out << (uint32_t)selection;
        }

}

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

                        in >> n;

                        possibleTypes.clear();

                        for (i=0;i<n;i++)
                        {
                                std::string             aux;
                                in >> aux;
                                possibleTypes.push_back( aux );
                        }

                        // Selection:
                        in >> i; selection = i;
                } break;
        default:
                MRPT_THROW_UNKNOWN_SERIALIZATION_VERSION(version)

        };
}


/*---------------------------------------------------------------
                                                Constructor
 ---------------------------------------------------------------*/
CTypeSelector::CTypeSelector(   std::string             posibilitiesList,
                                                                std::string             defaultType )
{
        // Init:
        possibleTypes.clear();

        // Extract tokens from the string:
        mrpt::system::tokenize(posibilitiesList,",",possibleTypes);

        // Select default type:
        setType(defaultType);
}

/*---------------------------------------------------------------
                                                Destructor
 ---------------------------------------------------------------*/
CTypeSelector::~CTypeSelector()
{
}

/*---------------------------------------------------------------
                                        getType
 ---------------------------------------------------------------*/
std::string  CTypeSelector::getType()const
{
        if (selection>=possibleTypes.size())
                THROW_EXCEPTION("current selection index is out of bounds!");

        return possibleTypes[selection];
}

/*---------------------------------------------------------------
                                                setType
 ---------------------------------------------------------------*/
void  CTypeSelector::setType(const std::string  &type)
{
        size_t          i,n = possibleTypes.size();

        for (i=0;i<n;i++)
        {
                if (!os::_strcmpi(type.c_str(),possibleTypes[i].c_str()))
                {
                        // Select:
                        selection = (unsigned int)i;
                        return;
                }
        }

        // Not in the list:
        THROW_EXCEPTION_FMT("Type '%s' is not one of the posibilities", type.c_str());
}

/*---------------------------------------------------------------
                                        getTypePosibilities
 ---------------------------------------------------------------*/
void  CTypeSelector::getTypePosibilities( std::vector<std::string> &outPosibilities)const
{
        outPosibilities = possibleTypes;
}

/*---------------------------------------------------------------
                                        isType
 ---------------------------------------------------------------*/
bool    CTypeSelector::isType(const char *type) const
{
        return !strcmp( possibleTypes[selection].c_str(),type);
}

/*---------------------------------------------------------------
                                        isType
 ---------------------------------------------------------------*/
bool    CTypeSelector::isType(const std::string &type) const
{
        return !strcmp( possibleTypes[selection].c_str(),type.c_str());
}

/*---------------------------------------------------------------
                                        checkTypeIndex
 ---------------------------------------------------------------*/
int CTypeSelector::checkTypeIndex(const std::string &type) const
{
        size_t  n = possibleTypes.size();
        for (size_t i=0;i<n;i++)
                if (!os::_strcmpi(type.c_str(),possibleTypes[i].c_str()))
                        return int(i);  // Found:
        return -1; // Not found
}