Driver.h

// Driver.h -- The interface to the dynamic selection of decomposition
// algorithms.

/*
 * Copyright (C) 1997, 1998 Tudor Hulubei <tudor@hulubei.net>.
 *
 * This library is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as
 * published by the Free Software Foundation; either version 2, or (at
 * your option) any later version.
 *
 * This library 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 Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA,
 * 02111-1307, USA.
 */

/*
 * NOTE: This is an interal header file.
 * You should not attempt to use it directly.
 */

// $Id: Driver_8h-source.html,v 1.1 2005/05/25 12:37:18 tudor Exp $

#ifndef _CSP_KERNEL_Driver_H
#define _CSP_KERNEL_Driver_H


CSP_NAMESPACE_BEGIN(csp);


class CSP_API Decomposition;


class CSP_API Driver
{
  public:
    Driver(Problem& problem, Filter& filter) :
        m_problem(problem),
        m_filter(filter),
        m_timeLimitExceeded(false),
        m_nodeLimitExceeded(false),
        m_yields(0),
        m_voluntaryYields(0) {}

    void registerDecomposition(Decomposition& decomposition);

    void unregisterDecomposition(Decomposition& decomposition);

    size_t decompositions() const
    {
        return m_decompositions.size();
    }

    Decomposition& decomposition(size_t n) const
    {
        assert(n < m_decompositions.size());
        return *m_decompositions[n];
    }

    const Resources& resources() const
    {
        assert(m_decompositions.size() > 0);
        return m_decompositions[0]->resources();
    }

    Resources& resources()
    {
        assert(m_decompositions.size() > 0);
        return m_decompositions[0]->resources();
    }

    const timeval& timeLimit() const
    {
        assert(m_decompositions.size() > 0);
        return m_decompositions[0]->m_timeLimit;
    }

    timeval setTimeLimit(const timeval& timeLimit);

    bool timeLimitExceeded() const
    {
        return m_timeLimitExceeded;
    }

    const ulonglong nodeLimit() const
    {
        assert(m_decompositions.size() > 0);
        return m_decompositions[0]->m_nodeLimit;
    }

    ulonglong setNodeLimit(const ulonglong nodeLimit);

    bool nodeLimitExceeded() const
    {
        return m_nodeLimitExceeded;
    }

    ulonglong solutions() const;

    bool canYield(size_t index) const
    {
        return index < m_decompositions.size() - 1;
    }

    void setSolutionCallback(bool (*solutionCallback)(Decomposition&, bool&));

    ulonglong search();

    void yield(size_t fromIndex, bool voluntary);

    double staticOptimismPercentage() const
    {
        return m_decompositions[0]->staticOptimismPercentage();
    }

    void setStaticOptimismPercentage(double percentage);

    double dynamicOptimismPercentage() const
    {
        return m_decompositions[0]->dynamicOptimismPercentage();
    }

    void setDynamicOptimismPercentage(double percentage);

    ulonglong yields() const { return m_yields; }

    ulonglong voluntaryYields() const { return m_yields; }

    ulonglong totalCCKS() const;

    ulonglong failedCCKS() const;

  private:
    // The chain of decomposition algorithms.
    vector<Decomposition*> m_decompositions;

    // The problem to be solved.
    Problem& m_problem;

    // The filter.
    Filter& m_filter;

    // `true' if the search timed out.
    bool m_timeLimitExceeded;

    // `true' if the search exceeded the number of nodes allowed.
    bool m_nodeLimitExceeded;

    // The total number of times the driver's yield() method was called.
    ulonglong m_yields;

    // The number of voluntary yields.
    ulonglong m_voluntaryYields;

    Driver(const Driver&);

    Driver& operator=(const Driver&);
};


CSP_NAMESPACE_END(csp);


#endif // _CSP_KERNEL_Driver_H

// Local Variables:
// mode: C++
// End:

---