setInst.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2005 by Pierre-Henri WUILLEMIN et Ariele-Paolo MAESANO  *
 *                            {prenom.nom}_at_lip6.fr                      *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/
#ifndef GUM_SETINST_H
#define GUM_SETINST_H

#include <ostream>

#include <agrum/agrum.h>

#include <agrum/core/bijection.h>
#include <agrum/multidim/implementations/multiDimAdressable.h>
#include <agrum/multidim/implementations/multiDimInterface.h>

namespace gum {

  class MultiDimAdressable;

  class Instantiation;
  // ==========================================================================
  // ===                            GUM_SetInst                             ===
  // ==========================================================================
  class SetInst {
    public:
    // =========================================================================
    // =========================================================================

    SetInst();

    SetInst(const SetInst& aI);

    SetInst(const Instantiation& aI);

    SetInst& operator=(const SetInst& aI);

    SetInst(MultiDimAdressable& aMD);

    SetInst(const MultiDimAdressable& aMD);

    SetInst(MultiDimAdressable* aMD);

    SetInst(const MultiDimAdressable* aMD);

    ~SetInst();

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

    Idx nbrDim() const;

    void add(const DiscreteVariable& v);

    void erase(const DiscreteVariable& v);

    void clear();

    Size domainSize() const;

    Idx pos(const DiscreteVariable& v) const;

    Size vals(Idx i) const;

    Size vals(const DiscreteVariable& var) const;

    Size vals(const DiscreteVariable* var) const;

    Idx nbrOccurences(const DiscreteVariable& var) const;


    Idx val(Idx i) const;

    Idx val(const DiscreteVariable& var) const;

    Idx val(const DiscreteVariable* var) const;

    const DiscreteVariable& variable(Idx i) const;

    SetInst& chgVal(const DiscreteVariable& v, Idx newVal);

    SetInst& chgVal(const DiscreteVariable* v, Idx newVal);

    SetInst& chgVal(Idx varPos, Idx newVal);

    SetInst& chgVals(const DiscreteVariable& v, const Size newVal);

    SetInst& addVal(const DiscreteVariable& v, Idx newVal);

    SetInst& addVals(const DiscreteVariable& v, const Size newVal);

    SetInst& remVal(const DiscreteVariable& v, Idx newVal);

    SetInst& remVals(const DiscreteVariable& v, const Size newVal);

    SetInst& interVals(const DiscreteVariable& v, const Size newVal);

    SetInst& interVal(const DiscreteVariable& v, Idx newVal);

    SetInst& chgVals(const DiscreteVariable* v, const Size newVal);

    SetInst& addVal(const DiscreteVariable* v, Idx newVal);

    SetInst& addVals(const DiscreteVariable* v, const Size newVal);

    SetInst& remVal(const DiscreteVariable* v, Idx newVal);

    SetInst& remVals(const DiscreteVariable* v, const Size newVal);

    SetInst& interVals(const DiscreteVariable* v, const Size newVal);

    SetInst& interVal(const DiscreteVariable* v, Idx newVal);

    SetInst& chgVals(Idx varPos, const Size newVal);

    SetInst& addVal(Idx varPos, Idx newVal);

    SetInst& addVals(Idx varPos, const Size newVal);

    SetInst& remVal(Idx varPos, Idx newVal);

    SetInst& remVals(Idx varPos, const Size newVal);

    SetInst& interVals(Idx varPos, const Size newVal);

    SetInst& interVal(Idx varPos, Idx newVal);

    SetInst& chgDifVal(Idx varPos, const Size newVal);

    SetInst& chgValIn(const SetInst& i);

    bool contains(const DiscreteVariable& v) const;

    bool contains(const DiscreteVariable* v) const;

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

    virtual bool empty() const;

    std::string toString() const;

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

    void reorder(const SetInst& i);

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

    bool inOverflow() const;

    void unsetOverflow();

    void unsetEnd();

    bool end() const;

    bool rend() const;




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

    static void assign_values(
       Bijection< const DiscreteVariable*, const DiscreteVariable* >& bij,
       const SetInst&                                                 i,
       SetInst&                                                       j);


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

    private:
    Sequence< const DiscreteVariable* > __vars;

    std::vector< Size > __vals;

    bool __overflow;

    void __swap(Idx i, Idx j);

    void __chgVal(Idx varPos, Idx newVal);

    void __chgVals(Idx varPos, const Size newVal);

    void __add(const DiscreteVariable& v);

    void __erase(const DiscreteVariable& v);

    void __init(MultiDimAdressable* master);
  };

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

  gum::SetInst& operator<<(gum::SetInst& inst, const gum::DiscreteVariable& i);

  gum::SetInst& operator>>(gum::SetInst& inst, const gum::DiscreteVariable& i);

} /* namespace gum */

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

#endif /* GUM_SetInst_H */