rrproj_prob.h

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

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

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

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

};

//======================================================================
//  rppEmpDowItr  -  Iterator for Emp-Days-of-week in a Problem

class rppEmpDowItr : public aipDemonItr {

public:

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

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

  virtual ~rppEmpDowItr () {}

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

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

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

};

//======================================================================
//  rppEmpOffItr  -  Iterator for Emp-Offs in a Problem

class rppEmpOffItr : public aipDemonItr {

public:

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

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

  virtual ~rppEmpOffItr () {}

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

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

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

};

//======================================================================
//  rppPosEmpItr  -  Iterator for Position-Employee pairs in a Problem

class rppPosEmpItr : public aipDemonItr {

public:

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

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

  virtual ~rppPosEmpItr () {}

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

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

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

};

//======================================================================
//  rppAssgnItr  -  Iterator for Assignments in a Problem

class rppAssgnItr : public aipDemonItr {

public:

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

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

  virtual ~rppAssgnItr () {}

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

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

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

};

//======================================================================
//  rppEmpDayPosItr  -  Iterator for historic Emp-Day-Pos in a Problem 

class rppEmpDayPosItr : public aipDemonItr {

public:

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

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

  virtual ~rppEmpDayPosItr () {}

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

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

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

};

//======================================================================
//  rppPosDayEmpItr  -  Iterator for normalized solution datam

class rppPosDayEmpItr : public aipDemonItr {

public:

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

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

  virtual ~rppPosDayEmpItr () {}

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

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

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

};

//======================================================================
//  rppProjWeekEmpDayItr -  Iterator for re-ordered normalized solution
//                             data, including a week-number

class rppProjWeekEmpDayItr : public aipDemonItr {

public:

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

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

  virtual ~rppProjWeekEmpDayItr () {}

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

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

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

};

//======================================================================
//  rppProjWeekItr  -  Iterator for output-masters (weeks in a project)

class rppProjWeekItr : public aipDemonItr {

public:

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

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

  virtual ~rppProjWeekItr () {}

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

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

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

};

//======================================================================
//  rppProjWeekEmpItr  -  Iterator for output-details (Proj-Week Emps)

class rppProjWeekEmpItr : public aipDemonItr {

public:

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

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

  virtual ~rppProjWeekEmpItr () {}

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

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

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

};

//======================================================================
//  rppFileDate  -  used to read/write dates to/from a file

class rppFileDate {

  char   m_yyyy_mm_dd[File_Date_Len+1];
  long   m_yyyymmdd;

protected:

  void reset () { m_yyyy_mm_dd[0] = '\0';  m_yyyymmdd = 0; }

public:

  rppFileDate (const char *a_yyyy_mm_dd);
  rppFileDate (long a_yyyymmdd);
  ~rppFileDate ();

  int is_valid ();

  const char * file_date () const { return m_yyyy_mm_dd; }
  long         long_date () const { return m_yyyymmdd;   }

};

//======================================================================
//  rppFileTime  -  used to read/write dates to/from a file

class rppFileTime {

  char   m_hh_mm[File_Time_Len+1];
  long   m_hhmm;

protected:

  void reset () { m_hh_mm[0] = '\0';  m_hhmm = 3333; }

public:

  rppFileTime (const char *a_hh_mm);
  rppFileTime (long a_hhmm);
  ~rppFileTime ();

  int is_valid ();

  const char * file_time () const { return m_hh_mm; }
  long         long_time () const { return m_hhmm;   }

};

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

#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.
//
//**********************************************************************