poolslot.h

Go to the documentation of this file.

 
#pragma once
 
#include <ogdf/lib/abacus/abacusroot.h>
#include <ogdf/lib/abacus/master.h>
#include <ogdf/lib/abacus/constraint.h>
#include <ogdf/lib/abacus/variable.h>
 
namespace abacus {
 
class Sub;
 
template<class BaseType, class CoType> class Pool;
template<class BaseType, class CoType> class PoolSlotRef;
template<class BaseType, class CoType> class StandardPool;
template<class BaseType, class CoType> class NonDuplPool;
template<class BaseType, class CoType> class CutBuffer;
 
 
 
template<class BaseType, class CoType> class OGDF_EXPORT PoolSlot : public AbacusRoot {
 
    friend class PoolSlotRef<BaseType,CoType>;
    friend class Pool<BaseType,CoType>;
    friend class StandardPool<BaseType,CoType>;
    friend class CutBuffer<BaseType,CoType>;
 
    friend class Sub;
    friend class PoolSlotRef<Constraint, Variable>;
    friend class PoolSlotRef<Variable, Constraint>;
    friend class Pool<Constraint, Variable>;
    friend class Pool<Variable, Constraint>;
    friend class StandardPool<Constraint, Variable>;
    friend class StandardPool<Variable, Constraint>;
    friend class NonDuplPool<Constraint, Variable>;
    friend class NonDuplPool<Variable, Constraint>;
    friend class CutBuffer<Constraint, Variable>;
    friend class CutBuffer<Variable, Constraint>;
 
public:
 
 
    PoolSlot(Master *master,
        Pool<BaseType, CoType> *pool,
        BaseType *convar = 0);
 
    ~PoolSlot();
 
    BaseType *conVar() const { return conVar_; }
 
 
private:
 
 
    void insert(BaseType *convar);
 
 
    int softDelete() {
        if (conVar_ == nullptr)
            return 0;
        if (conVar_->deletable() == false)
            return 1;
        hardDelete();
        return 0;
    }
 
 
    void hardDelete() {
        delete conVar_;
        conVar_ = nullptr;
    }
 
    void removeConVarFromPool() {
        pool_->removeConVar(this);
    }
 
    unsigned long version() const { return version_; }
 
    Master *master() { return master_; }
 
    const Master *master() const { return master_; }
 
    Master *master_;    
    BaseType *conVar_;      
    unsigned long version_; 
    Pool<BaseType, CoType> *pool_; 
 
 
    PoolSlot(const PoolSlot<BaseType, CoType> &rhs);
    const PoolSlot<BaseType, CoType>
        &operator=(const PoolSlot<BaseType, CoType> &rhs);
 
    OGDF_NEW_DELETE
};
 
}
 
#include <ogdf/lib/abacus/poolslot.inc>