agenda_class.h

Go to the documentation of this file.

/* Copyright (C) 2000-2012 Stefan Buehler <sbuehler@ltu.se>
 
   This program is free software; you can redistribute it and/or modify it
   under the terms of the GNU General Public License as published by the
   Free Software Foundation; either version 2, or (at your option) any
   later version.
 
   This program 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 General Public License for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
   USA. */
 
#ifndef agenda_class_h
#define agenda_class_h
 
#include <set>
#include "messages.h"
#include "token.h"
 
class MRecord;
 
class Workspace;
 
 
class Agenda {
 public:
  Agenda()
      : mname(),
        mml(),
        moutput_push(),
        moutput_dup(),
        main_agenda(false),
        mchecked(false) { /* Nothing to do here */
  }
 
  Agenda(const Agenda& x)
      : mname(x.mname),
        mml(x.mml),
        moutput_push(x.moutput_push),
        moutput_dup(x.moutput_dup),
        main_agenda(x.main_agenda),
        mchecked(x.mchecked) { /* Nothing to do here */
  }
 
  void append(const String& methodname, const TokVal& keywordvalue);
  void check(Workspace& ws, const Verbosity& verbosity);
  void push_back(const MRecord& n);
  void execute(Workspace& ws) const;
  inline void resize(Index n);
  inline Index nelem() const;
  inline Agenda& operator=(const Agenda& x);
  const Array<MRecord>& Methods() const { return mml; }
  bool has_method(const String& methodname) const;
  void set_methods(const Array<MRecord>& ml) {
    mml = ml;
    mchecked = false;
  }
  void set_outputs_to_push_and_dup(const Verbosity& verbosity);
  bool is_input(Workspace& ws, Index var) const;
  bool is_output(Index var) const;
  void set_name(const String& nname);
  String name() const;
  const ArrayOfIndex& get_output2push() const { return moutput_push; }
  const ArrayOfIndex& get_output2dup() const { return moutput_dup; }
  void print(ostream& os, const String& indent) const;
  void set_main_agenda() {
    main_agenda = true;
    mchecked = true;
  }
  bool is_main_agenda() const { return main_agenda; }
  bool checked() const { return mchecked; }
 
 private:
  String mname;       
  Array<MRecord> mml; 
  ArrayOfIndex moutput_push;
 
  ArrayOfIndex moutput_dup;
 
  bool main_agenda;
 
  bool mchecked;
};
 
// Documentation with implementation.
ostream& operator<<(ostream& os, const Agenda& a);
 
class MRecord {
 public:
  MRecord()
      : mid(-1),
        moutput(),
        minput(),
        msetvalue(),
        mtasks(),
        minternal(false) { /* Nothing to do here. */
  }
 
  MRecord(const MRecord& x)
      : mid(x.mid),
        moutput(x.moutput),
        minput(x.minput),
        msetvalue(x.msetvalue),
        mtasks(x.mtasks),
        minternal(x.minternal) { /* Nothing to do here */
  }
 
  MRecord(const Index id,
          const ArrayOfIndex& output,
          const ArrayOfIndex& input,
          const TokVal& setvalue,
          const Agenda& tasks,
          bool internal = false)
      : mid(id),
        moutput(output),
        minput(input),
        msetvalue(setvalue),
        mtasks(tasks),
        minternal(internal) { /* Nothing to do here */
  }
 
  Index Id() const { return mid; }
  const ArrayOfIndex& Out() const { return moutput; }
  const ArrayOfIndex& In() const { return minput; }
  const TokVal& SetValue() const { return msetvalue; }
  const Agenda& Tasks() const { return mtasks; }
 
 
  bool isInternal() const { return minternal; }
 
 
  MRecord& operator=(const MRecord& x) {
    mid = x.mid;
 
    msetvalue = x.msetvalue;
 
    moutput.resize(x.moutput.nelem());
    moutput = x.moutput;
 
    minput.resize(x.minput.nelem());
    minput = x.minput;
 
    mtasks.resize(x.mtasks.nelem());
    mtasks = x.mtasks;
 
    return *this;
  }
 
 
  void ginput_only(ArrayOfIndex& ginonly) const {
    ginonly = minput;  // Input
    for (ArrayOfIndex::const_iterator j = moutput.begin(); j < moutput.end();
         ++j)
      for (ArrayOfIndex::iterator k = ginonly.begin(); k < ginonly.end(); ++k)
        if (*j == *k) {
          //              erase_vector_element(vi,k);
          k = ginonly.erase(k) - 1;
          // We need the -1 here, otherwise due to the
          // following increment we would miss the element
          // behind the erased one, which is now at the
          // position of the erased one.
        }
  }
 
  // Output operator:
  void print(ostream& os, const String& indent) const;
 
 private:
  Index mid;
  ArrayOfIndex moutput;
  ArrayOfIndex minput;
  TokVal msetvalue;
  Agenda mtasks;
  bool minternal;
};
 
 
inline void Agenda::resize(Index n) { mml.resize(n); }
 
 
inline Index Agenda::nelem() const { return mml.nelem(); }
 
 
inline void Agenda::push_back(const MRecord& n) {
  mml.push_back(n);
  mchecked = false;
}
 
 
inline Agenda& Agenda::operator=(const Agenda& x) {
  mml = x.mml;
  mname = x.mname;
  moutput_push = x.moutput_push;
  moutput_dup = x.moutput_dup;
  mchecked = x.mchecked;
  return *this;
}
 
// Documentation is with implementation.
ostream& operator<<(ostream& os, const MRecord& a);
 
typedef Array<Agenda> ArrayOfAgenda;
 
#endif