singleVarTabu.hpp

Go to the documentation of this file.

#ifndef SingleVarTabuHppIncluded
#define SingleVarTabuHppIncluded



#include "cbls/frames/index.hpp"



openKangarooSpace



class SingleVarTabu : public TabuBase
{
    public:


        Bool TabuState(Variable * const pVariable) const;                                       



        virtual void resetTabuVars() = 0;                                                       
        virtual void tabuExecVars() = 0;                                                        
        virtual void tabuVar(Variable * const pVariable) = 0;                                   
        virtual void tabuVars(Variable * const pVariable0, Variable * const pVariable1) = 0;    
        virtual void tabuVars(Dim const VarCount, Variable * const * pVariables) = 0;           


    protected:

        class onehash
        {
            public:
                static Hash iof(Variable * const OneVar);                                       
        };


        ~SingleVarTabu();                                                                       
        SingleVarTabu(System * const pSystem);                                                  

        SingleVarTabu(SingleVarTabu && that) noexcept = delete;                                 
        SingleVarTabu(SingleVarTabu const & that) = delete;                                     
        SingleVarTabu & operator = (SingleVarTabu && that) noexcept = delete;                   
        SingleVarTabu & operator = (SingleVarTabu const & that) = delete;                       



        virtual void adjustMemAuto() override;                                                  



        virtual void setupComputation() override final;                                         



        Bool setTabuState(Variable * const pVariable);                                          
        Bool unsetTabuState(Variable * const pVariable);                                        



        #if UseArrayForVarTabuOrLockStateInsteadOfHashMap
        xb<Dim> mTabuStates;                                                                    
        #else
        xhmr<Variable *, Dim, onehash> mTabuStates;                                             
        #endif

};


typedef SingleVarTabu SvTabu;   



inline SingleVarTabu::SingleVarTabu(System * const pSystem) : TabuBase(pSystem), mTabuStates()
{
    WatchError
    setTabuFamily(identifier<SingleVarTabu>());
    CatchError
}



inline SingleVarTabu::~SingleVarTabu()
{
    WatchError
    //  nothing to be done.
    CatchError
}



inline Bool SingleVarTabu::setTabuState(Variable * const pVariable)
{
    WatchError
    #if UseArrayForVarTabuOrLockStateInsteadOfHashMap
    return (++mTabuStates[pVariable->VarSerial] == 1);
    #else
    Index tIndex = mTabuStates.insertIndexMem(pVariable, 0);
    return (++mTabuStates.Item(tIndex) == 1);
    #endif
    CatchError
}


inline Bool SingleVarTabu::unsetTabuState(Variable * const pVariable)
{
    WatchError
    #if UseArrayForVarTabuOrLockStateInsteadOfHashMap
    Warn(!mTabuStates[pVariable->VarSerial], kTabuInconsistent);
    return (--mTabuStates[pVariable->VarSerial] == 0);
    #else
    Index tIndex = mTabuStates.KeyIndex(pVariable);
    Warn(!mTabuStates.Item(tIndex), kTabuInconsistent);
    if (--mTabuStates.Item(tIndex))
        return false;
    mTabuStates.removeWithIndex(tIndex);
    return true;
    #endif
    CatchError
}


inline Bool SingleVarTabu::TabuState(Variable * const pVariable) const
{
    WatchError
    #if UseArrayForVarTabuOrLockStateInsteadOfHashMap
    return mTabuStates[pVariable->VarSerial];
    #else
    return mTabuStates.KeyExists(pVariable);
    #endif
    CatchError
}



inline void SingleVarTabu::adjustMemAuto()
{
    WatchError
    mTabuStates.adjustMemAuto();
    CatchError
}



inline void SingleVarTabu::setupComputation()
{
    WatchError
    #if UseArrayForVarTabuOrLockStateInsteadOfHashMap
    mTabuStates.allocMemSafe(SysMaster->VarCount());
    for(Serial tVarSerial = 0; tVarSerial < SysMaster->VarCount(); ++tVarSerial)
        mTabuStates.insert(0);
    #endif
    CatchError
}




inline Hash SingleVarTabu::onehash::iof(Variable * const OneVar)
{
    WatchError
    return OneVar->ExprHash;
    CatchError
}



closeKangarooSpace



#endif // SingleVarTabuHppIncluded