DBRowGeneratorSet.h

Go to the documentation of this file.

#ifndef GUM_LEARNING_DBROW_GENERATOR_SET_H
#define GUM_LEARNING_DBROW_GENERATOR_SET_H

#include <vector>

#include <agrum/agrum.h>
#include <agrum/learning/database/DBRow.h>
#include <agrum/learning/database/DBTranslatedValue.h>
#include <agrum/learning/database/DBRowGenerator.h>
#include <agrum/learning/database/DBRowGeneratorWithBN.h>

namespace gum {

  namespace learning {


    template < template < typename > class ALLOC = std::allocator >
    class DBRowGeneratorSet {
      public:
      using allocator_type = ALLOC< DBTranslatedValue >;

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


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

      DBRowGeneratorSet(const DBRowGeneratorSet< ALLOC >& from);

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

      DBRowGeneratorSet(DBRowGeneratorSet< ALLOC >&& from);

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

      virtual DBRowGeneratorSet< ALLOC >* clone() const;

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

      virtual ~DBRowGeneratorSet();



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


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

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


      DBRowGenerator< ALLOC >& operator[](const std::size_t i);


      const DBRowGenerator< ALLOC >& operator[](const std::size_t i) const;



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



      template < template < template < typename > class > class Generator >
      void insertGenerator(const Generator< ALLOC >& generator);


      template < template < template < typename > class > class Generator >
      void insertGenerator(const Generator< ALLOC >& generator,
                           const std::size_t         i);

      std::size_t nbGenerators() const noexcept;

      std::size_t size() const noexcept;

      bool hasRows();


      bool setInputRow(const DBRow< DBTranslatedValue, ALLOC >& input_row);

      const DBRow< DBTranslatedValue, ALLOC >& generate();


      template < typename GUM_SCALAR >
      void setBayesNet(const BayesNet< GUM_SCALAR >& new_bn);

      void reset();

      void clear();

      void setColumnsOfInterest(
         const std::vector< std::size_t, ALLOC< std::size_t > >& cols_of_interest);

      void setColumnsOfInterest(
         std::vector< std::size_t, ALLOC< std::size_t > >&& cols_of_interest);

      const std::vector< std::size_t, ALLOC< std::size_t > >&
         columnsOfInterest() const;

      allocator_type getAllocator() const;



#ifndef DOXYGEN_SHOULD_SKIP_THIS

      private:
      // the vector of all the generators
      std::vector< DBRowGenerator< ALLOC >*, ALLOC< DBRowGenerator< ALLOC >* > >
         __generators;

      // the number of generators
      std::size_t __nb_generators{std::size_t(0)};

      // the next output row to return when method generate is called
      const DBRow< DBTranslatedValue, ALLOC >* __output_row{nullptr};

      // the generation of output rows can be viewed as the traversal of a
      // tree: each node of the tree correspond to the input row received by
      // a generator. So the root node is the row passed in argument to
      // the setInputDBrow() Method. From these input rows, generators produce
      // through their generate() method new output rows, which correspond to
      // the input rows of the next level of the tree. If we traverse this tree
      // in terms of generators rather than in terms of input rows, which makes
      // sense knowing our data structures, we need to know whether we should
      // call only Method generate() to move down the tree or whether we should
      // call first Method setInputDBrow() and then generate(). Actually, when
      // a generator receives a new input row, it should call Method
      // setInputDBrow(), which updates its data structure in order to be able
      // to subsequently produce new output rows using Method generate().
      // So, we need to discriminate between the situation in which Method
      // setInputDBrow() has already been called from the situation in which
      // we first need to call setInputDBrow(). The following vector allows this
      // discrimination: when its cells equal 0, we need to call setInputDBrow()
      // first, else when they equal 1, we just need to call the generate()
      // method.
      std::vector< int, ALLOC< int > > __setInputRow_performed;



      bool __produceNextRow(const DBRow< DBTranslatedValue, ALLOC >* input_row,
                            std::size_t                              i);

#endif /* DOXYGEN_SHOULD_SKIP_THIS */
    };

  } /* namespace learning */

} /* namespace gum */

// always include the template implementation
#include <agrum/learning/database/DBRowGeneratorSet_tpl.h>


#endif /* GUM_LEARNING_DBROW_GENERATOR_SET_H */