ArrayHandlers.h

#ifndef LINEARALGEBRA_SRC_MOLPRO_LINALG_ITERATIVESOLVER_ARRAYHANDLERS_H
#define LINEARALGEBRA_SRC_MOLPRO_LINALG_ITERATIVESOLVER_ARRAYHANDLERS_H
#include <molpro/linalg/array/default_handler.h>
 
namespace molpro::linalg {
 
namespace itsolv {
namespace util {
 
struct ArrayHandlersError : public std::logic_error {
  using std::logic_error::logic_error;
};
 
} // namespace util
 
template <typename R, typename Q = R, typename P = std::map<size_t, typename R::value_type>>
class ArrayHandlers {
protected:
  class Builder;
 
public:
  ArrayHandlers(std::shared_ptr<array::ArrayHandler<R, R>> rr, std::shared_ptr<array::ArrayHandler<Q, Q>> qq,
                std::shared_ptr<array::ArrayHandler<P, P>> pp, std::shared_ptr<array::ArrayHandler<R, Q>> rq,
                std::shared_ptr<array::ArrayHandler<R, P>> rp, std::shared_ptr<array::ArrayHandler<Q, R>> qr,
                std::shared_ptr<array::ArrayHandler<Q, P>> qp)
      : m_rr{rr}, m_qq{qq}, m_pp{pp}, m_rq{rq}, m_rp{rp}, m_qr{qr}, m_qp{qp} {}
 
  ArrayHandlers() : ArrayHandlers(Builder{}.build()){};
 
  auto& rr() { return *m_rr; }
  auto& qq() { return *m_qq; }
  auto& pp() { return *m_pp; }
  auto& rq() { return *m_rq; }
  auto& qr() { return *m_qr; } // TODO qr is not needed, by copy is implemented the wrong way around
  auto& rp() { return *m_rp; }
  auto& qp() { return *m_qp; }
 
  static Builder create() { return {}; }
 
protected:
  class Builder {
  public:
    Builder() : rr(this), qq(this), pp(this), rq(this), rp(this), qr(this), qp(this) {}
 
    ArrayHandlers build() {
      return ArrayHandlers{rr.handler(), qq.handler(), pp.handler(), rq.handler(),
                           rp.handler(), qr.handler(), qp.handler()};
    };
 
  protected:
    template <class T, class S>
    class Proxy {
    public:
      Proxy() = default;
      explicit Proxy(Builder* b) : builder(b) {}
 
      Builder& operator()(const std::shared_ptr<array::ArrayHandler<T, S>>& h) {
        m_handler = h;
        return *builder;
      }
 
      std::shared_ptr<array::ArrayHandler<T, S>> handler() const {
        if (!m_handler)
          return array::create_default_handler<T, S>();
        else
          return m_handler;
      }
 
    protected:
      Builder* builder = nullptr;
      std::shared_ptr<array::ArrayHandler<T, S>> m_handler;
    };
 
  public:
    Proxy<R, R> rr;
    Proxy<Q, Q> qq;
    Proxy<P, P> pp;
    Proxy<R, Q> rq;
    Proxy<R, P> rp;
    Proxy<Q, R> qr;
    Proxy<Q, P> qp;
  };
 
  std::shared_ptr<array::ArrayHandler<R, R>> m_rr;
  std::shared_ptr<array::ArrayHandler<Q, Q>> m_qq;
  std::shared_ptr<array::ArrayHandler<P, P>> m_pp;
  std::shared_ptr<array::ArrayHandler<R, Q>> m_rq;
  std::shared_ptr<array::ArrayHandler<R, P>> m_rp;
  std::shared_ptr<array::ArrayHandler<Q, R>> m_qr;
  std::shared_ptr<array::ArrayHandler<Q, P>> m_qp;
};
 
} // namespace itsolv
namespace iterativesolver {
using itsolv::ArrayHandlers;
} // namespace iterativesolver
} // namespace molpro::linalg
 
#endif // LINEARALGEBRA_SRC_MOLPRO_LINALG_ITERATIVESOLVER_ARRAYHANDLERS_H