aipreqres.h

aiParts is a set of C++ classes that can be used to develop artificial intelligence for multi-decisi

class aiprrReqDay : public aipDemon {

  aiprrRequirement  * m_req;
  aipTime             m_day;

  aiprrDecision     * m_dcsn;

  aipHHHope         * m_hope;     // how well this reqday is doing
  aipHHImportance     m_importance;

public:

  aiprrReqDay(aiprrRequirement *a_req, long a_yyyymmdd);
  virtual ~aiprrReqDay();
  void set_dcsn (aiprrDecision *a_dcsn) { m_dcsn = a_dcsn; }

  long imp () const { return m_importance.val(); }

  virtual void take_msg (aipMsg *m);
  virtual void note_aiprr_decide (aiprrDecision *d, aiprrOption *o);

  aipTime            day  () const { return m_day;  }
  aiprrRequirement * req  () const { return m_req;  }
  aiprrDecision    * dcsn () const { return m_dcsn; }

  long num_decided () const { return m_dcsn->num_decided(); }

  int is_satisfied     () const;
  int has_surplus_opts () const;

};


//======================================================================
//  aiprrResource  -  a resource that can satisfy requirements

class aiprrResource : public aipDemon {

  long              m_id;

  aiprrProblem    * m_prob;

  aipPandemonium  * m_resdays;

  aipHHHope       * m_hope;        // how well this resource is doing
  int               m_is_in_cur_solution;

protected:

  aipPandemonium  * resday_pandemonium () const {   // for iterators
    return m_resdays;
   }

public:

  aiprrResource(long a_id, aiprrProblem *a_prob);
  virtual ~aiprrResource();

  void add_resday  (aiprrResDay *x);

  virtual void take_msg (aipMsg *m);
  virtual void note_aiprr_decide (aiprrDecision *d, aiprrOption *o);

  aiprrProblem * prob () const { return m_prob; }
  long           id   () const { return m_id;   }

  aiprrResDayItr  resday_iterator() const;

};


//======================================================================
//  aiprrResDay  -  a resource on a day

class aiprrResDay : public aipDemon {

  aipTime          m_day;

  aiprrResource  * m_res;

  aipPandemonium * m_opts;    // opts where this resday is the subject

  aipHHHope      * m_hope;         // how well this resday is doing
  int              m_is_in_cur_solution;

protected:

  aipPandemonium  * opt_pandemonium () const {   // for iterators
    return m_opts;
  }

public:

  aiprrResDay(aiprrResource *a_res, long a_yyyymmdd);
  virtual ~aiprrResDay();

  void add_opt (aiprrOption *o) { m_opts->add(o); }

  virtual void take_msg (aipMsg *m);
  virtual void note_aiprr_decide (aiprrDecision *d, aiprrOption *o);

  aipTime         day () const { return m_day; }
  aiprrResource * res () const { return m_res; }

};


//======================================================================
//  aiprrRequirementItr  -  Iterator for Requirements in a Problem

class aiprrRequirementItr : public aipDemonItr {

public:

  aiprrRequirementItr (aipPandemonium *p) {
    set_demon_itr(p,0);
  }

  aiprrRequirementItr (const aiprrRequirementItr& x) {
    set_demon_itr (x.pandemonium(), x.current());
  }

  virtual ~aiprrRequirementItr () {}

  aiprrRequirementItr& operator = (const aiprrRequirementItr& x) {
    set_demon_itr(x.pandemonium(), x.current());
    return *this;
  }

  aiprrRequirement * first () {
    return (aiprrRequirement*)aipDemonItr::first();
  }

  aiprrRequirement * next () {
    return (aiprrRequirement*)aipDemonItr::next();
  }

};

//======================================================================
//  aiprrReqDayItr  -  Iterator for ReqDays of a Requirement

class aiprrReqDayItr : public aipDemonItr {

public:

  aiprrReqDayItr (aipPandemonium *p) {
    set_demon_itr(p,0);
  }

  aiprrReqDayItr (const aiprrReqDayItr& x) {
    set_demon_itr (x.pandemonium(), x.current());
  }

  virtual ~aiprrReqDayItr () {}

  aiprrReqDayItr& operator = (const aiprrReqDayItr& x) {
    set_demon_itr(x.pandemonium(), x.current());
    return *this;
  }

  aiprrReqDay * first () {
    return (aiprrReqDay*)aipDemonItr::first();
  }

  aiprrReqDay * next () {
    return (aiprrReqDay*)aipDemonItr::next();
  }

};

//======================================================================
//  aiprrResourceItr  -  Iterator for Resources in a Problem

class aiprrResourceItr : public aipDemonItr {

public:

  aiprrResourceItr (aipPandemonium *p) {
    set_demon_itr(p,0);
  }

  aiprrResourceItr (const aiprrResourceItr& x) {
    set_demon_itr (x.pandemonium(), x.current());
  }

  virtual ~aiprrResourceItr () {}

  aiprrResourceItr& operator = (const aiprrResourceItr& x) {
    set_demon_itr(x.pandemonium(), x.current());
    return *this;
  }

  aiprrResource * first () {
    return (aiprrResource*)aipDemonItr::first();
  }

  aiprrResource * next () {
    return (aiprrResource*)aipDemonItr::next();
  }

};

//======================================================================
//  aiprrResDayItr  -  Iterator for ResDays of a Resource

class aiprrResDayItr : public aipDemonItr {

public:

  aiprrResDayItr (aipPandemonium *p) {
    set_demon_itr(p,0);
  }

  aiprrResDayItr (const aiprrResDayItr& x) {
    set_demon_itr (x.pandemonium(), x.current());
  }

  virtual ~aiprrResDayItr () {}

  aiprrResDayItr& operator = (const aiprrResDayItr& x) {
    set_demon_itr(x.pandemonium(), x.current());
    return *this;
  }

  aiprrResDay * first () {
    return (aiprrResDay*)aipDemonItr::first();
  }

  aiprrResDay * next () {
    return (aiprrResDay*)aipDemonItr::next();
  }

};

//======================================================================
//  aiprrDecisionItr  -  Iterator for Decisions in a Problem

class aiprrDecisionItr : public aipDemonItr {

public:

  aiprrDecisionItr (aipPandemonium *p) {
    set_demon_itr(p,0);
  }

  aiprrDecisionItr (const aiprrDecisionItr& x) {
    set_demon_itr (x.pandemonium(), x.current());
  }

  virtual ~aiprrDecisionItr () {}

  aiprrDecisionItr& operator = (const aiprrDecisionItr& x) {
    set_demon_itr(x.pandemonium(), x.current());
    return *this;
  }

  aiprrDecision * first () {
    return (aiprrDecision*)aipDemonItr::first();
  }

  aiprrDecision * next () {
    return (aiprrDecision*)aipDemonItr::next();
  }

};

//======================================================================
//  aiprrMsg  -  message for StaffWhen problem-solving

class aiprrMsg : public aipHHMsg {

public:

  aiprrMsg (aiprrProblem *p, short typ) : aipHHMsg(p,typ) {}
  ~aiprrMsg() {}

};

//======================================================================

#endif

//======================================================================
//                           License
//
//   Permission is hereby granted, free of charge, to any
//   person obtaining a copy of this software and associated
//   documentation files (the "Software"), to deal in the Software
//   without restriction, including without limitation the rights
//   to use, copy, modify, merge, publish, distribute, sublicense,
//   and/or sell copies of the Software, and to permit persons to
//   whom the Software is furnished to do so, subject to the
//   following conditions:
//
//   The copyright notice and this license shall be included in all
//   copies or substantial portions of the Software.
//
//   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
//   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
//   OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
//   NON-INFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
//   HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
//   WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
//   FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
//   OTHER DEALINGS IN THE SOFTWARE.
//
//======================================================================