workspace_ng.h

Go to the documentation of this file.

/* Copyright (C) 2004-2012 Oliver Lemke <olemke@core-dump.info>
  
   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 of the
   License, 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 WORKSPACE_NG_INCLUDED
#define WORKSPACE_NG_INCLUDED
 
#include <map>
#include <memory>
#include <stack>
#include <vector>
 
#include "array.h"
#include "arts_omp.h"
#include "wsv_aux.h"
 
struct WorkspaceVariableStruct final {
  std::shared_ptr<void> wsv;
  bool initialized;
};
 
using WorkspaceVariable = stack<WorkspaceVariableStruct, std::vector<WorkspaceVariableStruct>>;
 
struct WorkspaceBorrowGuard final {
  WorkspaceVariable &wsv;
  ~WorkspaceBorrowGuard() noexcept { wsv.pop(); };
};
 
class Workspace final : public std::enable_shared_from_this<Workspace> {
  Workspace();
 
  Workspace(const Workspace &workspace);
 
  void claim_agenda_ownership();
 
 public:
  Array<WorkspaceVariable> ws;
 
  using wsv_data_type = Array<WsvRecord>;
  std::shared_ptr<wsv_data_type> wsv_data_ptr;
 
  using WsvMap_type = map<String, Index>;
  std::shared_ptr<WsvMap_type> WsvMap_ptr;
 
  Workspace* original_workspace;
 
  [[nodiscard]] static std::shared_ptr<Workspace> create();
 
  [[nodiscard]] std::shared_ptr<Workspace> shallowcopy() const;
 
  Workspace(Workspace&&) noexcept = default;
 
  void set_empty(Index i);
 
  void duplicate(Index i);
 
  [[nodiscard]] bool is_initialized(Index i) const;
 
  [[nodiscard]] Index depth(Index i) const;
 
  void pop(Index i);
 
  void emplace(Index);
 
  template <typename T>
  WorkspaceBorrowGuard borrow(Index i, T &wsv) {
    using U = std::remove_cv_t<T>;
    std::shared_ptr<U> wsv_ptr(const_cast<U *>(&wsv), [](U *) {});
    WorkspaceVariableStruct wsvs;
    wsvs.initialized = true;
    wsvs.wsv = wsv_ptr;
    ws[i].push(wsvs);
    return {ws[i]};
  }
 
  template <typename T>
  WorkspaceBorrowGuard borrow_uninitialized(Index i, T &wsv) {
    using U = std::remove_cv_t<T>;
    std::shared_ptr<U> wsv_ptr(const_cast<U *>(&wsv), [](U *) {});
    WorkspaceVariableStruct wsvs;
    wsvs.initialized = false;
    wsvs.wsv = wsv_ptr;
    ws[i].push(wsvs);
    return {ws[i]};
  }
 
  template <typename T>
  void push_move(Index i, std::shared_ptr<T> &&wsv_ptr) {
    WorkspaceVariableStruct wsvs;
    wsvs.initialized = true;
    wsvs.wsv = std::forward<std::shared_ptr<T>>(wsv_ptr);
    ws[i].push(std::move(wsvs));
  }
 
  [[nodiscard]] Index nelem() const { return ws.nelem(); }
 
  Index add_wsv(const WsvRecord &wsv);
 
  std::shared_ptr<void> operator[](Index i);
 
  template <class T>
  T* get(const char *name) {
    if (const Index pos = WsvMap_ptr -> at(name); is_initialized(pos)) {
      return static_cast<T*>(ws[pos].top().wsv.get());
    }
    return nullptr;
  }
 
  void swap(Workspace &other) noexcept;
 
  template <typename OutputStream>
  void PrintWsvName(OutputStream &outstream, Index i) const {
    outstream << (*wsv_data_ptr)[i].Name() << "(" << i << ") ";
  }
 
  std::shared_ptr<Workspace> deepcopy();
 
  wsv_data_type wsvs(const ArrayOfIndex&) const;
  ArrayOfIndex wsvs(const wsv_data_type&);
};
 
template <typename T>
concept CopyConstructor = requires(const T& a) {{ T{a} };};
 
template <typename T>
concept ShallowCopyConstructor = requires(const T& a) {a.shallowcopy();};
 
template <typename T>
concept CanCopy = CopyConstructor<T> or ShallowCopyConstructor<T>;
 
 
template <typename T>
std::shared_ptr<T> get_shallow_copy(const T& x) {
  if constexpr (ShallowCopyConstructor<T>) return x.shallowcopy();
  else { T mout{x}; return std::make_shared<T>(std::move(mout)); }
}
 
template <CanCopy T>
class OmpParallelCopyGuard {
  T &orig;
  bool do_copy;
  std::shared_ptr<T> copy;
 
 public:
  OmpParallelCopyGuard(T &ws) 
    : orig(ws),
      do_copy(not arts_omp_in_parallel() and arts_omp_get_max_threads() not_eq 1),
      copy(nullptr) {}
 
  OmpParallelCopyGuard(T &ws, bool do_copy_manually)
    : orig(ws), do_copy(do_copy_manually), copy(nullptr) {}
 
  OmpParallelCopyGuard(const OmpParallelCopyGuard &cp)
    : orig(cp.orig),
      do_copy(cp.do_copy),
      copy(do_copy ? get_shallow_copy(orig) : nullptr) {}
 
  operator T &() { return copy ? *copy : orig; }
 
  operator const T &() const { return copy ? *copy : orig; }
};
 
using WorkspaceOmpParallelCopyGuard = OmpParallelCopyGuard<Workspace>;
 
#endif /* WORKSPACE_NG_INCLUDED */