databaseTable.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2005 by Christophe GONZALES and Pierre-Henri WUILLEMIN  *
 *   {prenom.nom}_at_lip6.fr                                               *
 *                                                                         *
 *   This program 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.                                   *
 *                                                                         *
 *   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, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/
#ifndef GUM_DATABASE_TABLE_H
#define GUM_DATABASE_TABLE_H

#include <numeric>
#include <algorithm>
#include <functional>
#include <exception>
#include <vector>

#include <agrum/agrum.h>
#include <agrum/core/math/math.h>
#include <agrum/core/set.h>
#include <agrum/core/thread.h>
#include <agrum/learning/database/DBCell.h>
#include <agrum/learning/database/DBRow.h>
#include <agrum/learning/database/DBTranslatedValue.h>
#include <agrum/learning/database/IDatabaseTable.h>
#include <agrum/learning/database/DBTranslatorSet.h>
#include <agrum/learning/database/DBTranslator4ContinuousVariable.h>

namespace gum {

  namespace learning {

    template < template < typename > class ALLOC = std::allocator >
    class DatabaseTable : public IDatabaseTable< DBTranslatedValue, ALLOC > {
      public:
      template < typename TX_DATA >
      using DBVector = std::vector< TX_DATA, ALLOC< TX_DATA > >;

      template < typename TX_DATA >
      using Row = DBRow< TX_DATA, ALLOC >;

      template < typename TX_DATA >
      using Matrix =
         std::vector< DBRow< TX_DATA, ALLOC >, ALLOC< DBRow< TX_DATA, ALLOC > > >;

      template < template < typename > class XALLOC >
      using MissingValType = std::vector< std::string, XALLOC< std::string > >;

      using Handler = typename IDatabaseTable< DBTranslatedValue, ALLOC >::Handler;

      using HandlerSafe =
         typename IDatabaseTable< DBTranslatedValue, ALLOC >::HandlerSafe;

      using IsMissing =
         typename IDatabaseTable< DBTranslatedValue, ALLOC >::IsMissing;

      using value_type = Row< DBTranslatedValue >;
      using reference = value_type&;
      using const_reference = const value_type&;
      using pointer = value_type*;
      using const_pointer = const value_type*;
      using size_type = std::size_t;
      using difference_type = std::ptrdiff_t;
      using iterator = Handler;
      using iterator_safe = HandlerSafe;
      using allocator_type = ALLOC< DBTranslatedValue >;


      // ##########################################################################
      // ##########################################################################

      template < template < typename > class XALLOC >
      DatabaseTable(
         const MissingValType< XALLOC >& missing_symbols,
         const DBTranslatorSet< ALLOC >& translators = DBTranslatorSet< ALLOC >(),
         const allocator_type&           alloc = allocator_type());

      DatabaseTable(
         const DBTranslatorSet< ALLOC >& translators = DBTranslatorSet< ALLOC >(),
         const allocator_type&           alloc = allocator_type());

      DatabaseTable(const DatabaseTable< ALLOC >& from);

      DatabaseTable(const DatabaseTable< ALLOC >& from,
                    const allocator_type&         alloc);

      DatabaseTable(DatabaseTable< ALLOC >&& from);

      DatabaseTable(DatabaseTable< ALLOC >&& from, const allocator_type& alloc);

      virtual DatabaseTable< ALLOC >* clone() const final;

      virtual DatabaseTable< ALLOC >*
         clone(const allocator_type& alloc) const final;

      virtual ~DatabaseTable();


      // ##########################################################################
      // ##########################################################################

      DatabaseTable< ALLOC >& operator=(const DatabaseTable< ALLOC >& from);

      DatabaseTable< ALLOC >& operator=(DatabaseTable< ALLOC >&& from);



      // ##########################################################################
      // ##########################################################################


      std::size_t insertTranslator(const DBTranslator< ALLOC >& translator,
                                   const std::size_t            input_column,
                                   const bool unique_column = true);


      std::size_t insertTranslator(const Variable&   var,
                                   const std::size_t input_column,
                                   const bool        unique_column = true);


      template < template < typename > class XALLOC >
      std::size_t insertTranslator(
         const Variable&                                   var,
         const std::size_t                                 input_column,
         std::vector< std::string, XALLOC< std::string > > missing_symbols,
         const bool                                        unique_column = true);

      void eraseTranslators(const std::size_t k,
                            const bool        k_is_input_col = false);

      const DBTranslatorSet< ALLOC >& translatorSet() const;

      const DBTranslator< ALLOC >&
         translator(const std::size_t k, const bool k_is_input_col = false) const;

      const Variable& variable(const std::size_t k,
                               const bool        k_is_input_col = false) const;

      using IDatabaseTable< DBTranslatedValue, ALLOC >::setVariableNames;


      virtual void setVariableNames(
         const std::vector< std::string, ALLOC< std::string > >& names,
         const bool from_external_object = true) final;

      virtual void ignoreColumn(const std::size_t k,
                                const bool from_external_object = true) final;


      virtual const DBVector< std::size_t > ignoredColumns() const final;

      virtual const DBVector< std::size_t > inputColumns() const final;

      std::size_t domainSize(const std::size_t k,
                             const bool        k_is_input_col = false) const;

      DBVector< std::size_t > domainSizes() const;

      bool needsReordering(const std::size_t k,
                           const bool        k_is_input_col = false) const;

      void reorder(const std::size_t k, const bool k_is_input_col = false);


      void reorder();

      using IDatabaseTable< DBTranslatedValue, ALLOC >::insertRow;


      virtual void insertRow(
         const std::vector< std::string, ALLOC< std::string > >& new_row) final;


      virtual void insertRow(Row< DBTranslatedValue >&& new_row,
                             const IsMissing contains_missing_data) final;


      virtual void insertRow(const Row< DBTranslatedValue >& new_row,
                             const IsMissing contains_missing_data) final;


      virtual void insertRow(const Row< DBCell >& new_row) final;


      virtual void insertRow(Row< DBCell >&& new_row) final;


      virtual void
         insertRows(Matrix< DBTranslatedValue >&& new_rows,
                    const DBVector< IsMissing >&  rows_have_missing_vals) final;


      virtual void
         insertRows(const Matrix< DBTranslatedValue >& new_rows,
                    const DBVector< IsMissing >& rows_have_missing_vals) final;


      virtual void insertRows(Matrix< DBCell >&& new_rows) final;


      virtual void insertRows(const Matrix< DBCell >& new_rows) final;

      virtual void clear() final;

      // substitutes the kth translator by another one
      /* The method checks that:
       * 1/ it is possible to get back the original values of the database
       *    for the rows already translated.
       * 2/ that the new translator is capable of translating these values.
       *
       * If both checks passed, then it replaces the kth translator
       * by the one passed in arguments and retranslates with it the kth
       * cell of all the rows already contained in the database */



#ifndef DOXYGEN_SHOULD_SKIP_THIS

      private:
      DBTranslatorSet< ALLOC > __translators;

      Set< std::size_t, ALLOC< std::size_t > > __ignored_cols;

      bool __isRowCompatible(const Row< DBTranslatedValue >& row) const;

      std::size_t __getKthIndex(const std::size_t k,
                                const bool        k_is_input_col) const;

      DBVector< std::size_t > __getKthIndices(const std::size_t k,
                                              const bool k_is_input_col) const;


      template < typename Functor1, typename Functor2 >
      void __threadProcessDatabase(Functor1& exec_func, Functor2& undo_func);

#endif /* DOXYGEN_SHOULD_SKIP_THIS */
    };

  } /* namespace learning */

} /* namespace gum */

#include <agrum/learning/database/databaseTable_tpl.h>

#endif /* GUM_DATABASE_TABLE_H */