IDatabaseTable.h

Go to the documentation of this file.

#ifndef GUM_IDATABASE_TABLE_H
#define GUM_IDATABASE_TABLE_H

#include <cstddef>
#include <utility>
#include <string>
#include <cstring>
#include <memory>
#include <vector>
#include <mutex>

#include <agrum/agrum.h>
#include <agrum/core/thread.h>
#include <agrum/core/OMPThreads.h>
#include <agrum/learning/database/DBCell.h>
#include <agrum/learning/database/DBRow.h>
#include <agrum/learning/database/DBHandler.h>
#include <agrum/learning/database/DBTranslator.h>


namespace gum {

  namespace learning {

    template < template < typename > class ALLOC, bool ENABLE_INSERT >
    struct IDatabaseTableInsert4DBCell;

    template < template < typename > class ALLOC >
    struct IDatabaseTableInsert4DBCell< ALLOC, true > {
      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 > > >;



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


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


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


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


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


      virtual void insertRows(const DBVector< DBVector< std::string > >& new_rows);
    };


    template < template < typename > class ALLOC >
    struct IDatabaseTableInsert4DBCell< ALLOC, false > {
      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 > > >;


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


      virtual void insertRows(const DBVector< DBVector< std::string > >& new_rows);
    };


    template < typename T_DATA,
               template < typename > class ALLOC = std::allocator >
    class IDatabaseTable
        : public IDatabaseTableInsert4DBCell<
             ALLOC,
             !std::is_same< T_DATA, DBCell >::value >
        , private ALLOC< T_DATA > {
      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 > >;


      enum IsMissing : char { False, True };


      class Handler : public DBHandler< T_DATA, ALLOC > {
        public:
        using iterator_category = std::random_access_iterator_tag;
        using value_type = typename DBHandler< T_DATA, ALLOC >::value_type;
        using reference = value_type&;
        using const_reference = const value_type&;
        using pointer = value_type*;
        using const_pointer = const value_type*;
        using difference_type = std::ptrdiff_t;
        using allocator_type = ALLOC< T_DATA >;


        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 > > >;


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


        Handler(const IDatabaseTable< T_DATA, ALLOC >& db);


        Handler(const Handler& h);


        Handler(Handler&& h);

        virtual ~Handler();


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

        virtual Handler& operator=(const Handler&);

        virtual Handler& operator=(Handler&&);


        virtual Handler& operator++() final;


        virtual Handler& operator--() final;


        virtual Handler& operator+=(const std::size_t i) final;


        virtual Handler& operator-=(const std::size_t i) final;

        virtual bool operator==(const Handler& handler) const final;

        virtual bool operator!=(const Handler& handler) const final;


        virtual const_reference operator*() const final;


        virtual const_pointer operator->() const final;



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


        virtual std::size_t size() const final;

        virtual std::size_t DBSize() const final;


        virtual const_reference rowSafe() const final;


        virtual reference rowSafe() final;


        virtual const_reference row() const final;


        virtual reference row() final;

        virtual void nextRow() final;

        virtual std::size_t numRow() const final;

        virtual bool hasRows() const final;

        virtual void reset() final;

        virtual Handler begin() const;

        virtual Handler end() const;


        virtual void setRange(std::size_t begin, std::size_t end) final;

        virtual std::pair< std::size_t, std::size_t > range() const final;

        virtual const DBVector< std::string >& variableNames() const final;

        virtual std::size_t nbVariables() const final;


        virtual const IDatabaseTable< T_DATA, ALLOC >& database() const;



#ifndef DOXYGEN_SHOULD_SKIP_THIS

        protected:
        const IDatabaseTable< T_DATA, ALLOC >* __db;


        const Matrix< T_DATA >* __row;

        std::size_t __index{std::size_t(0)};

        std::size_t __begin_index{std::size_t(0)};

        std::size_t __end_index{std::size_t(0)};

        friend class IDatabaseTable< T_DATA, ALLOC >;

#endif /* DOXYGEN_SHOULD_SKIP_THIS */
      };


      class HandlerSafe : public Handler {
        public:
        using iterator_category = std::random_access_iterator_tag;
        using value_type = typename Handler::value_type;
        using reference = value_type&;
        using const_reference = const value_type&;
        using pointer = value_type*;
        using const_pointer = const value_type*;
        using difference_type = std::ptrdiff_t;
        using allocator_type = ALLOC< T_DATA >;

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


        HandlerSafe(const IDatabaseTable< T_DATA, ALLOC >& db);

        HandlerSafe(const HandlerSafe& h);

        HandlerSafe(HandlerSafe&& h);

        virtual ~HandlerSafe();


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

        virtual HandlerSafe& operator=(const HandlerSafe&);

        virtual HandlerSafe& operator=(const Handler&);

        virtual HandlerSafe& operator=(HandlerSafe&&);

        virtual HandlerSafe& operator=(Handler&&);



#ifndef DOXYGEN_SHOULD_SKIP_THIS

        private:
        void __attachHandler();

        void __detachHandler();

        friend class IDatabaseTable< T_DATA, ALLOC >;

#endif /* DOXYGEN_SHOULD_SKIP_THIS */
      };


      using value_type = Row< T_DATA >;
      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 const_iterator = const Handler;
      using const_iterator_safe = const HandlerSafe;
      using allocator_type = ALLOC< T_DATA >;


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

      template < template < typename > class VARALLOC,
                 template < typename >
                 class MISSALLOC >
      IDatabaseTable(
         const MissingValType< MISSALLOC >& missing_symbols,
         const std::vector< std::string, VARALLOC< std::string > >& var_names,
         const ALLOC< T_DATA >&                                     alloc);

      IDatabaseTable(const IDatabaseTable< T_DATA, ALLOC >& from);

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

      IDatabaseTable(IDatabaseTable< T_DATA, ALLOC >&& from);

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

      virtual IDatabaseTable< T_DATA, ALLOC >* clone() const = 0;

      virtual IDatabaseTable< T_DATA, ALLOC >*
         clone(const allocator_type& alloc) const = 0;

      virtual ~IDatabaseTable();



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

      iterator begin() const;

      iterator_safe beginSafe() const;

      const iterator& end() const noexcept;

      const iterator_safe& endSafe() const noexcept;



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

      const Matrix< T_DATA >& content() const noexcept;

      iterator handler() const;

      iterator_safe handlerSafe() const;


      const DBVector< std::string >& variableNames() const noexcept;


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


      template < template < typename > class OTHER_ALLOC >
      void setVariableNames(
         const std::vector< std::string, OTHER_ALLOC< std::string > >& names,
         const bool from_external_object = true);


      const std::string& variableName(const std::size_t k) const;


      std::size_t columnFromVariableName(const std::string& name) const;


      DBVector< std::size_t >
         columnsFromVariableName(const std::string& name) const;

      std::size_t nbVariables() const noexcept;

      std::size_t nbRows() const noexcept;

      std::size_t size() const noexcept;

      bool empty() const noexcept;


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

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

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

      using IDatabaseTableInsert4DBCell<
         ALLOC,
         !std::is_same< T_DATA, DBCell >::value >::insertRow;


      template < template < typename > class OTHER_ALLOC >
      void insertRow(
         const std::vector< std::string, OTHER_ALLOC< std::string > >& new_row);


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


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

      using IDatabaseTableInsert4DBCell<
         ALLOC,
         !std::is_same< T_DATA, DBCell >::value >::insertRows;


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


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


      void eraseRow(std::size_t index);


      void eraseFirstRow();


      void eraseLastRow();


      void eraseFirstRows(const std::size_t k);


      void eraseLastRows(const std::size_t k);


      void eraseRows(std::size_t deb, std::size_t end);

      void eraseAllRows();

      virtual void clear();

      ALLOC< T_DATA > getAllocator() const;

      const DBVector< std::string >& missingSymbols() const;

      bool hasMissingValues() const;

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


      void setMaxNbThreads(const std::size_t nb) const;

      std::size_t nbThreads() const;

      void setMinNbRowsPerThread(const std::size_t nb) const;

      std::size_t minNbRowsPerThread() const;

      void setAllRowsWeight(const double new_weight);


      void setWeight(const std::size_t i, const double weight);


      double weight(const std::size_t i) const;

      double weight() const;



      protected:
      DBVector< std::string > _variable_names;

      // the vector of DBRows containing all the raw data
      Matrix< T_DATA > _rows;

      // the set of string corresponding to missing values
      DBVector< std::string > _missing_symbols;

      // a vector indicating which rows have missing values (char != 0)
      DBVector< IsMissing > _has_row_missing_val;

      // the maximal number of threads that the database can use
      mutable std::size_t _max_nb_threads{
         std::size_t(gum::getMaxNumberOfThreads())};

      // the min number of rows that a thread should process in a
      // multithreading context
      mutable std::size_t _min_nb_rows_per_thread{100};


      bool _isRowSizeOK(const std::size_t size) const;

      IDatabaseTable< T_DATA, ALLOC >&
         operator=(const IDatabaseTable< T_DATA, ALLOC >& from);

      IDatabaseTable< T_DATA, ALLOC >&
         operator=(IDatabaseTable< T_DATA, ALLOC >&& from);


#ifndef DOXYGEN_SHOULD_SKIP_THIS

      private:
      // the list of handlers currently attached to the database
      /* this is useful when the database is resized */
      mutable DBVector< HandlerSafe* > __list_of_safe_handlers;

      // a mutex to safely add/remove handlers in __list_of_safe_handlers
      mutable std::mutex __safe_handlers_mutex;

      // the end iterator for the database
      Handler* __end{nullptr};

      // the safe end iterator for the database
      iterator_safe* __end_safe{nullptr};

      void __attachHandler(HandlerSafe* handler) const;

      void __detachHandler(HandlerSafe* handler) const;

      void __updateHandlers(std::size_t new_size) const;

      // create the end iterators
      void __createEndIterators();

#endif /* DOXYGEN_SHOULD_SKIP_THIS */


      friend class Handler;
      friend class HandlerSafe;
    };

  } /* namespace learning */

} /* namespace gum */

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

#endif /* GUM_IDATABASE_TABLE_H */