agenda_class.h

Go to the documentation of this file.

/* Copyright (C) 2000-2008 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 "token.h"
#include "messages.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(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; }
  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;}
  void find_unused_variables();
 
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() { /* Nothing to do here. */ }
 
  MRecord(const MRecord& x) : mid(x.mid),
                              moutput(x.moutput),
                              minput(x.minput),
                              msetvalue(x.msetvalue),
                              mtasks(x.mtasks)
    { /* Nothing to do here */ }
 
  MRecord(const Index id,
          const ArrayOfIndex& output,
          const ArrayOfIndex& input,
          const TokVal&       setvalue,
          const Agenda&       tasks) : mid(id),
                                              moutput(output),
                                              minput(input),
                                              msetvalue(setvalue),
                                              mtasks(tasks)
  { /* 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;    }
 
 
  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;
};
 
 
inline void Agenda::resize(Index n)
{
  mml.resize(n);
}
 
 
inline Index Agenda::nelem() const
{
  return mml.nelem();
}
 
 
 
inline void Agenda::push_back(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);
 
#endif