DBTranslatorSet.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_LEARNING_DB_TRANSLATOR_SET_H
#define GUM_LEARNING_DB_TRANSLATOR_SET_H

#include <vector>
#include <limits>
#include <type_traits>

#include <agrum/agrum.h>
#include <agrum/learning/database/DBTranslator.h>
#include <agrum/learning/database/DBTranslator4LabelizedVariable.h>
#include <agrum/learning/database/DBTranslator4DiscretizedVariable.h>
#include <agrum/learning/database/DBTranslator4RangeVariable.h>
#include <agrum/learning/database/DBTranslator4ContinuousVariable.h>


namespace gum {

  namespace learning {

    template < template < typename > class ALLOC = std::allocator >
    class DBTranslatorSet {
      public:
      using allocator_type = typename DBTranslator< ALLOC >::allocator_type;

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


      DBTranslatorSet(const allocator_type& alloc = allocator_type());

      DBTranslatorSet(const DBTranslatorSet< ALLOC >& from);

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

      DBTranslatorSet(DBTranslatorSet< ALLOC >&& from);

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

      virtual DBTranslatorSet< ALLOC >* clone() const;

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

      virtual ~DBTranslatorSet();


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


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

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


      DBTranslator< ALLOC >& operator[](const std::size_t k);


      const DBTranslator< ALLOC >& operator[](const std::size_t k) const;



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



      template < template < template < typename > class > class Translator >
      std::size_t insertTranslator(const Translator< ALLOC >& translator,
                                   const std::size_t          column,
                                   const bool unique_column = true);

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

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

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


      DBTranslator< ALLOC >& translator(const std::size_t k);


      const DBTranslator< ALLOC >& translator(const std::size_t k) const;


      DBTranslator< ALLOC >& translatorSafe(const std::size_t k);


      const DBTranslator< ALLOC >& translatorSafe(const std::size_t k) const;


      template < template < typename > class OTHER_ALLOC >
      DBTranslatedValue translate(
         const std::vector< std::string, OTHER_ALLOC< std::string > >& row,
         const std::size_t                                             k) const;

      template < template < typename > class OTHER_ALLOC >
      DBTranslatedValue translateSafe(
         const std::vector< std::string, OTHER_ALLOC< std::string > >& row,
         const std::size_t                                             k) const;


      std::string translateBack(const DBTranslatedValue translated_val,
                                const std::size_t       k) const;

      std::string translateBackSafe(const DBTranslatedValue translated_val,
                                    const std::size_t       k) const;

      bool isMissingValue(const DBTranslatedValue translated_val,
                          const std::size_t       k) const;

      bool isMissingValueSafe(const DBTranslatedValue translated_val,
                              const std::size_t       k) const;


      std::size_t domainSize(const std::size_t k) const;


      std::size_t domainSizeSafe(const std::size_t k) const;


      const Variable& variable(const std::size_t k) const;


      const Variable& variableSafe(const std::size_t k) const;

      bool needsReordering(const std::size_t k) const;


      bool needsReorderingSafe(const std::size_t k) const;

      HashTable< std::size_t,
                 std::size_t,
                 ALLOC< std::pair< std::size_t, std::size_t > > >
         reorder(const std::size_t k);


      HashTable< std::size_t,
                 std::size_t,
                 ALLOC< std::pair< std::size_t, std::size_t > > >
         reorderSafe(const std::size_t k);

      std::size_t inputColumn(const std::size_t k) const;

      std::size_t inputColumnSafe(const std::size_t k) const;

      std::size_t highestInputColumn() const;

      void clear();

      std::size_t nbTranslators() const;

      std::size_t size() const;

      allocator_type getAllocator() const;

      const std::vector< DBTranslator< ALLOC >*, ALLOC< DBTranslator< ALLOC >* > >&
         translators() const;


#ifndef DOXYGEN_SHOULD_SKIP_THIS

      private:
      // the set of all the translators
      std::vector< DBTranslator< ALLOC >*, ALLOC< DBTranslator< ALLOC >* > >
         __translators;

      // a vector indicating which column of the original database each
      // translator should translate
      std::vector< std::size_t, ALLOC< std::size_t > > __columns;

      // the highest column index read by the translators
      std::size_t __highest_column{std::size_t(0)};

      void __copy(const DBTranslatorSet< ALLOC >& from,
                  const allocator_type&           alloc);

#endif /* DOXYGEN_SHOULD_SKIP_THIS */
    };

  } /* namespace learning */

} /* namespace gum */

// always include templated implementation
#include <agrum/learning/database/DBTranslatorSet_tpl.h>

#endif /* GUM_LEARNING_DB_TRANSLATOR_SET_H */