instantiation.h

Go to the documentation of this file.

#ifndef GUM_INSTANTIATION_H
#define GUM_INSTANTIATION_H

#include <ostream>
#include <sstream>

#include <agrum/agrum.h>

#include <agrum/tools/core/hashTable.h>
#include <agrum/tools/multidim/implementations/multiDimInterface.h>

namespace gum {

  class MultiDimAdressable;
  // =========================================================================
  // ===                           GUM_INSTANTIATION                       ===
  // =========================================================================
  class Instantiation: public MultiDimInterface {
    public:
    // =========================================================================
    // =========================================================================

    Instantiation();

    Instantiation(const Instantiation& aI, const bool notifyMaster = true);

    Instantiation& operator=(const Instantiation& aI);

    Instantiation(MultiDimAdressable& aMD);

    Instantiation(const MultiDimAdressable& aMD);

    Instantiation(MultiDimAdressable* aMD);

    Instantiation(const MultiDimAdressable* aMD);

    ~Instantiation();

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

    Idx nbrDim() const final;

    void add(const DiscreteVariable& v) final;

    void erase(const DiscreteVariable& v) final;
    void erase(const std::string& name);

    void clear();

    Size domainSize() const final;

    Idx pos(const DiscreteVariable& v) const final;

    Idx val(Idx i) const;

    Idx val(const DiscreteVariable& var) const;
    Idx val(const std::string& name) const;

    Idx valFromPtr(const DiscreteVariable* pvar) const;

    const DiscreteVariable& variable(Idx i) const final;

    const DiscreteVariable& variable(const std::string& name) const final;

    Instantiation& chgVal(const DiscreteVariable& v, Idx newval);

    Instantiation& chgVal(const DiscreteVariable* v, Idx newval);

    Instantiation& chgVal(Idx varPos, Idx newval);

    Instantiation& chgVal(const std::string& var, Idx newval);

    Instantiation& chgVal(const std::string& var, const std::string& newval);

    Instantiation& setVals(const Instantiation& i);

    void setValsFrom(
       const HashTable< const DiscreteVariable*, const DiscreteVariable* >& map,
       const Instantiation& external);

    bool contains(const DiscreteVariable& v) const final;
    bool contains(const std::string& name) const;

    bool contains(const DiscreteVariable* v) const;

    const Sequence< const DiscreteVariable* >& variablesSequence() const final;

    virtual bool empty() const final;

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

    bool inOverflow() const;

    void unsetOverflow();

    void unsetEnd();

    bool end() const;

    bool rend() const;

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

    void inc();

    void dec();

    void incIn(const Instantiation& i);

    void decIn(const Instantiation& i);

    void incOut(const Instantiation& i);

    void decOut(const Instantiation& i);

    void incNotVar(const DiscreteVariable& v);

    void decNotVar(const DiscreteVariable& v);

    void incVar(const DiscreteVariable& v);

    void decVar(const DiscreteVariable& v);

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

    void setFirst();

    void setLast();

    void setFirstIn(const Instantiation& i);

    void setLastIn(const Instantiation& i);

    void setFirstOut(const Instantiation& i);

    void setLastOut(const Instantiation& i);

    void setFirstNotVar(const DiscreteVariable& v);

    void setLastNotVar(const DiscreteVariable& v);

    void setFirstVar(const DiscreteVariable& v);

    void setLastVar(const DiscreteVariable& v);

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

    bool actAsSlave(MultiDimAdressable& aMD);

    bool forgetMaster();

    bool isSlave() const;

    bool isMaster(const MultiDimAdressable* m) const;

    bool isMaster(const MultiDimAdressable& m) const;

    void synchronizeWithMaster(const MultiDimAdressable* m);

    void addWithMaster(const MultiDimAdressable* m, const DiscreteVariable& v);

    void eraseWithMaster(const MultiDimAdressable* m, const DiscreteVariable& v);

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

    bool operator==(const Instantiation& other) const;

    Instantiation& operator++();

    Instantiation& operator--();

    Instantiation& operator+=(Size depl);

    Instantiation& operator-=(Size depl);

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

    Idx hamming() const;

    std::string toString() const;

    void reorder(const Sequence< const DiscreteVariable* >& v);

    void reorder(const Instantiation& i);


    protected:
    virtual void _replace(const DiscreteVariable* x,
                          const DiscreteVariable* y) final;

    private:
    MultiDimAdressable* __master;

    Sequence< const DiscreteVariable* > __vars;

    std::vector< Idx > __vals;

    bool __overflow;

    void __swap(Idx i, Idx j);

    void __chgVal(Idx varPos, Idx newVal);

    void __add(const DiscreteVariable& v);

    void __erase(const DiscreteVariable& v);

    void __notifiedDimChanged(const Sequence< const DiscreteVariable* >& v);

    void __init(MultiDimAdressable* master);

    void __reorder(const Sequence< const DiscreteVariable* >& v);

    void __masterChangeNotification(Idx varPos, Idx newVal, Idx oldVal) const;
    void __masterFirstNotification() const;
    void __masterIncNotification() const;
    void __masterLastNotification() const;
    void __masterDecNotification() const;
  };

  std::ostream& operator<<(std::ostream&, const Instantiation&);

  template <>
  // class HashFunc< Instantiation > : public HashFuncBase< Instantiation > {
  class HashFunc< Instantiation >: public HashFuncBase< Instantiation > {
    public:
    static Size castToSize(const Instantiation& key);

    virtual Size operator()(const Instantiation& key) const override final;
  };
} /* namespace gum */

#ifndef GUM_NO_INLINE
#  include <agrum/tools/multidim/instantiation_inl.h>
#endif /* GUM_NO_INLINE */

#endif /* GUM_INSTANTIATION_H */