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> {
 public:
  Array<WorkspaceVariable> ws;
 
  std::shared_ptr<Array<WsvRecord>> wsv_data_ptr;
 
  std::shared_ptr<map<String, Index>> WsvMap_ptr;
 
  Workspace* original_workspace;
 
  Workspace();
 
  Workspace(const Workspace &workspace);
 
  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(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> shared_ptr() {return shared_from_this();}
};
 
template <class 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 ? new T{orig} : nullptr) {}
 
  operator T &() { return copy ? *copy : orig; }
 
  operator const T &() const { return copy ? *copy : orig; }
};
 
using WorkspaceOmpParallelCopyGuard = OmpParallelCopyGuard<Workspace>;
 
#endif /* WORKSPACE_NG_INCLUDED */