PRMSystem.h

Go to the documentation of this file.

#ifndef GUM_SYSTEM_H
#define GUM_SYSTEM_H

#include <utility>
#include <string>

#include <agrum/core/hashTable.h>
#include <agrum/core/sequence.h>
#include <agrum/core/set.h>

#include <agrum/graphs/diGraph.h>

#include <agrum/BN/BayesNetFactory.h>

#include <agrum/PRM/elements/PRMObject.h>
#include <agrum/PRM/elements/PRMInstance.h>
#include <agrum/PRM/elements/PRMClass.h>

namespace gum {
  namespace prm {

    template < typename GUM_SCALAR >
    class PRMSystem : public PRMObject {
      public:
      // ========================================================================
      // ========================================================================

      explicit PRMSystem(const std::string& name);

      virtual ~PRMSystem();

      // ========================================================================
      // ========================================================================

      const DiGraph& skeleton() const;

      PRMInstance< GUM_SCALAR >& get(NodeId id);

      const PRMInstance< GUM_SCALAR >& get(NodeId id) const;

      NodeId get(const PRMInstance< GUM_SCALAR >& i) const;

      /* @todo should be removed ?
      void addArc( const std::string& u,
                   const std::string& v,
                   const std::string& ref );*/

      // ========================================================================
      // ========================================================================

      virtual PRMObject::prm_type obj_type() const;

      Size size() const;

      bool exists(const std::string& name) const;

      bool isInstantiated(const PRMClass< GUM_SCALAR >& c) const;

      bool isInstance(const std::string& name) const;

      bool isArray(const std::string& name) const;

      void groundedBN(BayesNetFactory< GUM_SCALAR >& factory) const;

      void instantiate();

      // ========================================================================
      // ========================================================================

      PRMInstance< GUM_SCALAR >& get(const std::string& name);

      const PRMInstance< GUM_SCALAR >& get(const std::string& name) const;

      const Set< PRMInstance< GUM_SCALAR >* >&
         get(const PRMClass< GUM_SCALAR >& type) const;

      NodeId add(PRMInstance< GUM_SCALAR >* i);

      // ========================================================================
      // ========================================================================

      const Sequence< PRMInstance< GUM_SCALAR >* >&
         getArray(const std::string& name) const;

      PRMClassElementContainer< GUM_SCALAR >&
         getArrayType(const std::string& name);

      const PRMClassElementContainer< GUM_SCALAR >&
         getArrayType(const std::string& name) const;

      NodeId add(const std::string& array, PRMInstance< GUM_SCALAR >* i);

      NodeId add(const std::string& array, PRMInstance< GUM_SCALAR >& i);

      void addArray(const std::string&                      array,
                    PRMClassElementContainer< GUM_SCALAR >& type);

      // ========================================================================
      // ========================================================================

      typedef
         typename NodeProperty< PRMInstance< GUM_SCALAR >* >::iterator iterator;

      iterator begin();

      const iterator& end();

      typedef typename NodeProperty< PRMInstance< GUM_SCALAR >* >::const_iterator
         const_iterator;

      const_iterator begin() const;

      const const_iterator& end() const;

      typedef
         typename Sequence< PRMInstance< GUM_SCALAR >* >::iterator array_iterator;

      array_iterator begin(const std::string& a);

      const array_iterator& end(const std::string& a);

      typedef typename Sequence< PRMInstance< GUM_SCALAR >* >::const_iterator
         const_array_iterator;

      const_array_iterator begin(const std::string& a) const;

      const const_array_iterator& end(const std::string& a) const;

      private:
      PRMSystem(const PRMSystem< GUM_SCALAR >& from);

      PRMSystem< GUM_SCALAR >& operator=(const PRMSystem< GUM_SCALAR >& from);

      // ========================================================================
      // ========================================================================

      DiGraph __skeleton;

      NodeProperty< PRMInstance< GUM_SCALAR >* > __nodeIdMap;

      HashTable< std::string, PRMInstance< GUM_SCALAR >* > __nameMap;

      HashTable< PRMClass< GUM_SCALAR >*, Set< PRMInstance< GUM_SCALAR >* >* >
         __instanceMap;

      typedef std::pair< PRMClassElementContainer< GUM_SCALAR >*,
                         Sequence< PRMInstance< GUM_SCALAR >* >* >
         model_pair;

      HashTable< std::string, model_pair > __arrayMap;

      // ========================================================================
      // ========================================================================

      void __groundRef(const PRMInstance< GUM_SCALAR >& instance,
                       BayesNetFactory< GUM_SCALAR >&   factory) const;

      void __groundAttr(const PRMInstance< GUM_SCALAR >& instance,
                        BayesNetFactory< GUM_SCALAR >&   factory) const;

      void __groundPotential(const PRMInstance< GUM_SCALAR >&  instance,
                             const PRMAttribute< GUM_SCALAR >& attr,
                             BayesNetFactory< GUM_SCALAR >&    factory) const;

      void __groundAgg(const PRMClassElement< GUM_SCALAR >& elt,
                       const std::string&                   name,
                       BayesNetFactory< GUM_SCALAR >&       factory) const;
    };


#ifndef GUM_NO_EXTERN_TEMPLATE_CLASS
    extern template class PRMSystem< double >;
#endif


  } /* namespace prm */

} /* namespace gum */

#include <agrum/PRM/elements/PRMSystem_tpl.h>

#endif   // GUM_SYSTEM_H