CSimpleDatabase.h

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 |
   +------------------------------------------------------------------------+ */
#ifndef CSimpleDatabase_H
#define CSimpleDatabase_H

#include <mrpt/utils/utils_defs.h>
#include <mrpt/utils/CSerializable.h>
#include <map>

namespace mrpt
{
namespace utils
{
/**  This class implements the tables of databases.
 * \sa CSimpleDatabase \ingroup mrpt_base_grp
 */
class CSimpleDatabaseTable : public mrpt::utils::CSerializable
{
        DEFINE_SERIALIZABLE(CSimpleDatabaseTable)
   public:
        /** Default constructor
          */
        CSimpleDatabaseTable();

        /** Destructor
          */
        virtual ~CSimpleDatabaseTable();

        /** Get the count of fields.
          */
        size_t fieldsCount() const;

        /** Append a new and empty record at the end of the table, and return the
         * index of the newly added record.
          * \sa deleteRecord
          */
        size_t appendRecord();

        /** Add a new field to the table. The table is cleared in this operation. */
        void addField(const char* fieldName);

        /** Add a new field to the table. The table is cleared in this operation. */
        void addField(const std::string& fieldName) { addField(fieldName.c_str()); }
        /** Get the name of a field by its index
          * \exception std::exception On index out of bounds
          */
        std::string getFieldName(size_t fieldIndex) const;

        /** Get the index for a given field name
          * \exception std::exception On field not found
          */
        size_t fieldIndex(const char* fieldName) const;

        /** Get the index for a given field name
          * \exception std::exception On field not found
          */
        size_t fieldIndex(const std::string& fieldName) const
        {
                return fieldIndex(fieldName.c_str());
        }

        /** Get the records count in the table
          */
        size_t getRecordCount() const;

        /**  Returns the cell content of the record indicates by its index, and the
         * field indicated in "field".
          * \exception std::exception On field or record not found
          */
        std::string get(size_t recordIndex, std::string field) const;

        /**  Returns the cell content of the record indicates by its index, and the
         * field indicated by its index.
          * \exception std::exception On field or record not found
          */
        std::string get(size_t recordIndex, size_t fieldIndex) const;

        /**  Sets the cell content of the record indicates by its index, and the
         * field indicated in "field".
          * \exception std::exception On field or record not found
          */
        void set(size_t recordIndex, std::string field, std::string value);

        /**  Sets the cell content of the record indicates by its index, and the
         * field indicated by its index.
          * \exception std::exception On field or record not found
          */
        void set(size_t recordIndex, size_t fieldIndex, std::string value);

        /**  Executes a query in the table, returning the record index which a given
         * field has a given value, case insensitive, or -1 if not found.
          */
        int query(std::string field, std::string value) const;

        /** Delete the record at the given index \sa appendRecord */
        void deleteRecord(size_t recordIndex);

   private:
        /** Field names */
        vector_string field_names;
        /** Data for each cell */
        std::vector<vector_string> data;

};  // end of class definition

/**  This class impements a very simple database system. A database is
  *   a collection of tables, each one being a CSimpleDatabaseTable object.
 * Tables are
  *   a rectangular arrrangement of cells, organized as records of fields.
  *  There are XML export/import methods in saveAsXML, loadFromXML.
  *
  * \note This class is NOT safe for read/write access from different threads.
 * If needed, use critical sections.
  *
  * \sa CSimpleDatabaseTable
  */
class CSimpleDatabase : public mrpt::utils::CSerializable
{
        DEFINE_SERIALIZABLE(CSimpleDatabase)

   public:
        /** Default constructor
          */
        CSimpleDatabase();

        /** Destructor
          */
        virtual ~CSimpleDatabase();

        /** Clears the DB.
          */
        void clear();

        /** Creates a new table in the DB, initially empty.
          */
        CSimpleDatabaseTable::Ptr createTable(const std::string& name);

        /** Returns the table with the indicated name
          * \exception std::exception On table not found.
          */
        CSimpleDatabaseTable::Ptr getTable(const std::string& tableName);

        /** Deletes the given table.
          * \exception std::exception On table not found.
          */
        void dropTable(const std::string& tableName);

        /** Changes the name of a given table
          * \exception std::exception On table not found or new name already
         * existed.
          */
        void renameTable(
                const std::string& tableName, const std::string& newTableName);

        /** Returns the table by index.
          * \exception std::exception On index out of bounds
          */
        CSimpleDatabaseTable::Ptr getTable(size_t tableIndex);

        /** Returns the tables count in the DB.
          */
        size_t tablesCount() const;

        /** Returns the tables names in the DB.
          * \exception std::exception On index out of bounds
          */
        std::string tablesName(size_t tableIndex) const;

        /** Saves this database as a XML file.
          * \return false on any error, true if successful.
          * \sa loadFromXML
          */
        bool saveAsXML(const std::string& fileName) const;

        /** Loads the content of this database from a a XML file.
          * \return false on any error, true if successful.
          * \sa saveAsXML
          */
        bool loadFromXML(const std::string& fileName);

   private:
        /** The tables of the DB indexed by their names: */
        typedef std::map<std::string, CSimpleDatabaseTable::Ptr> TTableList;
        typedef std::map<std::string, CSimpleDatabaseTable::Ptr>::iterator iterator;
        typedef std::map<std::string, CSimpleDatabaseTable::Ptr>::const_iterator
                const_iterator;

        TTableList m_tables;

};  // end of class definition
}  // End of namespace
}  // End of namespace

#endif