fusionContext.h

Go to the documentation of this file.

// =========================================================================
#ifndef GUM_FUSION_CONTEXT_H
#define GUM_FUSION_CONTEXT_H
// =========================================================================
#include <agrum/core/multiPriorityQueue.h>
// =========================================================================
#include <agrum/graphs/graphElements.h>
// =========================================================================
#include <agrum/FMDP/learning/core/templateStrategy.h>
#include <agrum/FMDP/learning/datastructure/leaves/abstractLeaf.h>
#include <agrum/FMDP/learning/datastructure/leaves/leafPair.h>
// =========================================================================

namespace gum {

  typedef HashTableConstIteratorSafe< LeafPair*, std::vector< Size > >
     pair_iterator;


  template < bool isInitial = false >
  class FusionContext {
    public:
    // ==========================================================================
    // ==========================================================================

    // ###################################################################
    // ###################################################################
    FusionContext(AbstractLeaf*);

    // ###################################################################
    // ###################################################################
    ~FusionContext();

    // ============================================================================
    // ============================================================================
    void* operator new(size_t s) {
      return SmallObjectAllocator::instance().allocate(s);
    }
    void operator delete(void* p) {
      SmallObjectAllocator::instance().deallocate(p, sizeof(FusionContext));
    }


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

    // ###################################################################
    // ###################################################################
    public:
    bool containsAssociatedLeaf(AbstractLeaf* l) {
      return __containsAssociatedLeaf(l, Int2Type< isInitial >());
    }

    private:
    bool __containsAssociatedLeaf(AbstractLeaf* l, Int2Type< false >) {
      return __leaf2Pair.exists(l);
    }
    bool __containsAssociatedLeaf(AbstractLeaf*, Int2Type< true >) {
      return false;
    }

    // ###################################################################
    // ###################################################################
    public:
    bool associateLeaf(AbstractLeaf* l) {
      return __associateLeaf(l, Int2Type< isInitial >());
    }

    private:
    bool __associateLeaf(AbstractLeaf*, Int2Type< false >);
    bool __associateLeaf(AbstractLeaf*, Int2Type< true >) { return false; }


    // ###################################################################
    // ###################################################################
    public:
    bool updateAssociatedLeaf(AbstractLeaf* l) {
      return __updateAssociatedLeaf(l, Int2Type< isInitial >());
    }

    private:
    bool __updateAssociatedLeaf(AbstractLeaf*, Int2Type< false >);
    bool __updateAssociatedLeaf(AbstractLeaf*, Int2Type< true >) { return false; }

    public:
    bool updateAllAssociatedLeaves() {
      return __updateAllAssociatedLeaves(Int2Type< isInitial >());
    }

    private:
    bool __updateAllAssociatedLeaves(Int2Type< false >);
    bool __updateAllAssociatedLeaves(Int2Type< true >) { return false; }


    // ###################################################################
    // ###################################################################
    public:
    bool deassociateLeaf(AbstractLeaf* l) {
      return __deassociateLeaf(l, Int2Type< isInitial >());
    }

    private:
    bool __deassociateLeaf(AbstractLeaf*, Int2Type< false >);
    bool __deassociateLeaf(AbstractLeaf*, Int2Type< true >) { return false; }


    public:
    // ==========================================================================
    // ==========================================================================

    // ###################################################################
    // ###################################################################
    bool addPair(LeafPair* p);

    // ###################################################################
    // ###################################################################
    bool updatePair(LeafPair* p);

    // ###################################################################
    // ###################################################################
    bool removePair(LeafPair* p);


    pair_iterator beginPairs() { return __pairsHeap.allValues().beginSafe(); }
    pair_iterator endPairs() { return __pairsHeap.allValues().endSafe(); }


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

    // ###################################################################
    // ###################################################################
    LeafPair* top() { return !__pairsHeap.empty() ? __pairsHeap.top() : nullptr; }

    // ###################################################################
    // ###################################################################
    double topLikelyhood() {
      return !__pairsHeap.empty() ? __pairsHeap.topPriority() : 1.0;
    }


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

    // ###################################################################
    // ###################################################################
    AbstractLeaf* leaf() { return __leaf; }

    // ###################################################################
    // ###################################################################
    LeafPair* leafAssociatedPair(AbstractLeaf* l) {
      return __leaf2Pair.getWithDefault(l, nullptr);
    }

    // ###################################################################
    // ###################################################################
    public:
    Set< LeafPair* > associatedPairs() {
      return __associatedPairs(Int2Type< isInitial >());
    }

    private:
    Set< LeafPair* > __associatedPairs(Int2Type< false >);
    Set< LeafPair* > __associatedPairs(Int2Type< true >) {
      return Set< LeafPair* >();
    }

    public:
    std::string toString();

    private:
    MultiPriorityQueue< LeafPair*, double, std::less< double > > __pairsHeap;

    HashTable< AbstractLeaf*, LeafPair* > __leaf2Pair;

    AbstractLeaf* __leaf;
  };


} /* namespace gum */

#include <agrum/FMDP/learning/datastructure/leaves/fusionContext_tpl.h>

#endif   // GUM_FUSION_CONTEXT_H