convar.h

Go to the documentation of this file.

 
#pragma once
 
#include <ogdf/lib/abacus/abacusroot.h>
 
#pragma GCC visibility push(default)
namespace abacus {
 
class Master;
class Sub;
class Variable;
class Constraint;
 
template<class BaseType, class CoType> class PoolSlot;
template<class BaseType, class CoType> class PoolSlotRef;
template<class BaseType, class CoType> class StandardPool;
template<class BaseType, class CoType> class CutBuffer;
 
 
 
class OGDF_EXPORT ConVar : public AbacusRoot {
 
    friend class PoolSlot<Constraint, Variable>;
    friend class PoolSlot<Variable, Constraint>;
    friend class PoolSlotRef<Constraint, Variable>;
    friend class PoolSlotRef<Variable, Constraint>;
    friend class StandardPool<Constraint, Variable>;
    friend class StandardPool<Variable, Constraint>;
    friend class CutBuffer<Constraint, Variable>;
    friend class CutBuffer<Variable, Constraint>;
    friend class Sub;
 
public:
 
 
    ConVar (Master *master, const Sub *sub, bool dynamic, bool local) :
        master_(master),
        sub_(sub),
        expanded_(false),
        nReferences_(0),
        dynamic_(dynamic),
        nActive_(0),
        nLocks_(0),
        local_(local)
    { }
 
    virtual ~ConVar();
 
 
 
    bool active() const { return (nActive_ != 0); }
 
 
    bool local() const { return local_; }
 
    bool global() const { return !local_; }
 
 
 
    virtual bool dynamic() const { return dynamic_; }
 
 
 
    bool expanded() const { return expanded_; }
 
 
 
    virtual void expand() const { }
 
 
    virtual void compress() const { }
 
 
    virtual bool deletable() const {
        return !(nReferences_ || nLocks_);
    }
 
 
 
    virtual void print(std::ostream &out) const;
 
 
    const Sub *sub() const { return sub_; }
 
 
 
    void sub(Sub *sub) { sub_ = sub; }
 
 
 
    virtual unsigned hashKey() const;
 
 
    virtual const char *name() const;
 
 
    virtual bool equal(const ConVar *cv) const;
 
 
    virtual double rank() const { return 0; }
 
protected:
 
    Master *master_; 
 
 
    const Sub *sub_;
 
    mutable bool expanded_; 
 
    int nReferences_; 
 
    bool dynamic_;
 
 
    int nActive_;
 
    int nLocks_; 
 
    bool local_; 
 
private:
 
 
    void _expand() const;
 
 
 
    void _compress() const;
 
 
    void activate() { ++nActive_; }
 
 
 
    void deactivate();
 
 
    int nReferences() const { return nReferences_; }
 
 
 
    void addReference() { ++nReferences_; }
 
 
 
    void removeReference();
 
 
    bool locked() const { return (nLocks_ != 0); }
 
 
    void lock() { ++nLocks_; }
 
 
    void unlock();
 
};
 
 
inline ConVar::~ConVar()
{
#ifdef OGDF_DEBUG
    if (nActive_) {
        Logger::ifout() << "ConVar::~ConVar(): constraint/variable still active: \ncounter = " << nActive_ << "\n";
    }
 
    if (nLocks_) {
        Logger::ifout() << "ConVar::~ConVar(): constraint/variable has still " << nLocks_ << " locks\n";
    }
 
#ifndef OGDF_USE_ASSERT_EXCEPTIONS // do not throw exceptions in destructor
    OGDF_ASSERT(nActive_ == 0);
    OGDF_ASSERT(nLocks_ == 0);
#endif
#endif
}
 
 
inline void ConVar::deactivate()
{
    OGDF_ASSERT(nActive_ != 0);
    --nActive_;
}
 
 
inline void ConVar::removeReference()
{
    if(--nReferences_ < 0) {
        Logger::ifout() << "ConVar::removeReference : reference counter negative\n";
        OGDF_THROW_PARAM(AlgorithmFailureException, ogdf::AlgorithmFailureCode::Convar);
    }
}
 
 
inline void ConVar::unlock()
{
    OGDF_ASSERT(nLocks_ != 0);
    --nLocks_;
}
 
 
}
#pragma GCC visibility pop