BcpsObjectPool.h

Go to the documentation of this file.

/*===========================================================================*
 * This file is part of the Branch, Constrain and Price Software (BiCePS)    *
 *                                                                           *
 * BiCePS is distributed under the Eclipse Public License as part of the     *
 * COIN-OR repository (http://www.coin-or.org).                              *
 *                                                                           *
 * Authors:                                                                  *
 *                                                                           *
 *          Yan Xu, Lehigh University                                        *
 *          Ted Ralphs, Lehigh University                                    *
 *                                                                           *
 * Conceptual Design:                                                        *
 *                                                                           *
 *          Yan Xu, Lehigh University                                        *
 *          Ted Ralphs, Lehigh University                                    *
 *          Laszlo Ladanyi, IBM T.J. Watson Research Center                  *
 *          Matthew Saltzman, Clemson University                             *
 *                                                                           *
 * Copyright (C) 2001-2013, Lehigh University, Yan Xu, and Ted Ralphs.       *
 * All Rights Reserved.                                                      *
 *===========================================================================*/

#ifndef BcpsObjectPool_h_
#define BcpsObjectPool_h_

#include <vector>

#include "AlpsKnowledgePool.h"

#include "BcpsObject.h"

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

class BcpsObjectPool : public AlpsKnowledgePool {

 protected:

    std::vector<AlpsKnowledge *> objects_;

 public:

    BcpsObjectPool() {}
    virtual ~BcpsObjectPool() {
        if (! objects_.empty()) {
            freeGuts();
        }
    }
    
    inline void freeGuts() {
        for (int i = static_cast<int> (objects_.size() - 1); i > -1; --i) {
            delete objects_[i];
        }
        objects_.clear();
    }
    
    inline void clear(){ objects_.clear(); }
    
    virtual void addKnowledge(AlpsKnowledge * nk, double priority) { 
        objects_.push_back(nk);
    }
 
    virtual int getNumKnowledges() const {
        return static_cast<int>(objects_.size());
    }

    virtual std::pair<AlpsKnowledge*, double> getKnowledge() const {
        return std::make_pair(objects_[0], 0.0);
    }

    virtual bool hasKnowledge() const
        { return objects_.empty() ? false : true; }

    void deleteObject(int k) { 
        assert(k > -1 && k < ((int)objects_.size()));
        
        AlpsKnowledge *objectK = getObject(k);
        std::vector<AlpsKnowledge *>::iterator pos;
        pos = objects_.begin() + k;
        objects_.erase(pos);
        
        // Free memory of object k.
        delete objectK;
    }

    const std::vector<AlpsKnowledge *>& getObjects() const { return objects_; }

    AlpsKnowledge *getObject(int k) const { return objects_[k]; }
};

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

class BcpsConstraintPool : public BcpsObjectPool {
 public:
    BcpsConstraintPool() {}
    virtual ~BcpsConstraintPool() {}

    void addConstraint(BcpsConstraint * con) { objects_.push_back(con); }

    void deleteConstraint(int k) { deleteObject(k); }
    
    int getNumConstraints() const { return getNumKnowledges(); }
    
    const std::vector<AlpsKnowledge *>& getConstraints() const {return objects_;}

    AlpsKnowledge *getConstraint(int k) const {return getObject(k);}
};

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

class BcpsVariablePool : public BcpsObjectPool {
 public:
    BcpsVariablePool() {}
    virtual ~BcpsVariablePool() {}

    void addVariable(BcpsVariable * var) { objects_.push_back(var); }

    void deleteVariable(int k) { deleteObject(k); }

    int getNumVariables() const { return getNumKnowledges(); }

    const std::vector<AlpsKnowledge *>& getVariables() const {return objects_;}

    AlpsKnowledge *getVariable(int k) const {return getObject(k);}
};

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

#endif // End of file