agenda_class.h

Go to the documentation of this file.

 
#ifndef agenda_class_h
#define agenda_class_h
 
 
#include "array.h"
#include "debug.h"
#include "matpack_concepts.h"
#include "mystring.h"
 
#include "messages.h"
#include "tokval.h"
#include "workspace_ng.h"
 
#include <set>
#include <utility>
#include "workspace_global_data.h"
 
template <typename OutputStream, typename Container>
void PrintWsvNames(OutputStream &outstream, const Workspace& ws, const Container &container) {
  for (typename Container::const_iterator it = container.begin();
       it != container.end();
       it++) {
    ws.PrintWsvName(outstream, *it);
  }
}
 
class MRecord;
 
 
class Agenda final {
 public:
  Agenda() = default;
  explicit Agenda(Workspace& workspace);
 
  Agenda(const Agenda& x) = default;
 
  void append(const String& methodname, const TokVal& keywordvalue);
  void check(Workspace& ws_in, const Verbosity& verbosity);
  void push_back(const MRecord& n);
  void execute(Workspace& ws_in) const;
  void resize(Index n);
  [[nodiscard]] Index nelem() const;
  Agenda& operator=(const Agenda& x);
  [[nodiscard]] const Array<MRecord>& Methods() const { return mml; }
  [[nodiscard]] bool has_method(const String& methodname) const;
  void set_methods(const Array<MRecord>& ml);
  void set_outputs_to_push_and_dup(const Verbosity& verbosity);
  [[nodiscard]] bool is_input(Workspace& ws_in, Index var) const;
  [[nodiscard]] bool is_output(Index var) const;
  void set_name(const String& nname);
  [[nodiscard]] String name() const;
  [[nodiscard]] const ArrayOfIndex& get_output2push() const { return moutput_push; }
  [[nodiscard]] 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;
  }
  [[nodiscard]] bool is_main_agenda() const { return main_agenda; }
  [[nodiscard]] bool checked() const { return mchecked; }
 
  friend ostream& operator<<(ostream& os, const Agenda& a);
 
  [[nodiscard]] bool has_same_origin(const Workspace& ws2) const;
 
  [[nodiscard]] std::shared_ptr<Workspace> workspace() const;
 
  void set_workspace(Workspace& x);
 
  Agenda deepcopy_if(Workspace&) const;
 
  [[nodiscard]] std::pair<ArrayOfIndex, ArrayOfIndex> get_global_inout() const;
 
 private:
  std::weak_ptr<Workspace> ws;      
  String mname;       
  Array<MRecord> mml; 
  ArrayOfIndex moutput_push;
 
  ArrayOfIndex moutput_dup;
 
  bool main_agenda{false};
 
  bool mchecked{false};
};
 
class MRecord {
 public:
  MRecord();
 
  explicit MRecord(Workspace& ws);
 
  MRecord(const MRecord& x) = default;
 
  MRecord(const Index id,
          ArrayOfIndex  output,
          ArrayOfIndex  input,
          const TokVal&  setvalue,
          const Agenda& tasks,
          bool internal = false);
 
  [[nodiscard]] Index Id() const { return mid; }
  [[nodiscard]] const ArrayOfIndex& Out() const { return moutput; }
  [[nodiscard]] const ArrayOfIndex& In() const { return minput; }
  [[nodiscard]] const TokVal& SetValue() const { return msetvalue; }
  [[nodiscard]] const Agenda& Tasks() const { return mtasks; }
 
  MRecord deepcopy_if(Workspace&) const;
 
 
  [[nodiscard]] bool isInternal() const { return minternal; }
 
 
  MRecord& operator=(const MRecord& x);
 
 
  void ginput_only(ArrayOfIndex& ginonly) const;
  // Output operator:
  void print(ostream& os, const String& indent) const;
 
  friend ostream& operator<<(ostream& os, const MRecord& a);
 
  void set_workspace(Workspace& x);
 
 private:
  Index mid{-1};
  ArrayOfIndex moutput;
  ArrayOfIndex minput;
  TokVal msetvalue;
  Agenda mtasks;
  bool minternal{false};
};
 
 
using ArrayOfAgenda = Array<Agenda>;
 
ArrayOfAgenda deepcopy_if(Workspace& ws, const ArrayOfAgenda& agendas);
 
#endif