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 "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(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; }
  void find_unused_variables();
  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);

#endif