Tpetra_Transform.hpp

// @HEADER
// *****************************************************************************
//          Tpetra: Templated Linear Algebra Services Package
//
// Copyright 2008 NTESS and the Tpetra contributors.
// SPDX-License-Identifier: BSD-3-Clause
// *****************************************************************************
// @HEADER
 
#ifndef TPETRA_TRANSFORM_HPP
#define TPETRA_TRANSFORM_HPP

 
#include <Teuchos_RCP.hpp>
#include <Teuchos_GlobalMPISession.hpp>
 
namespace Tpetra {


 
template <typename T, typename U>
class Transform {
 public:
 
  using OriginalType      = Teuchos::RCP<T>;
  using OriginalConstType = Teuchos::RCP<const T>;
  using NewType           = Teuchos::RCP<U>;
  using NewConstType      = Teuchos::RCP<const U>;


  virtual ~Transform() = default;


  virtual NewType operator()(const OriginalType& orig) = 0;

  virtual void fwd() = 0;

  virtual void rvs() = 0;



  virtual void analyze(const OriginalType& orig);

  virtual NewType construct();

  virtual bool isConstructed();

 
 protected:
  Transform()
    : origObj_(Teuchos::null)
    , newObj_(Teuchos::null) {}
 
  OriginalType origObj_;
  NewType newObj_;
 
 private:
  Transform(const Transform<T, U>& src)
    : origObj_(src.origObj_)
    , newObj_(src.newObj_) {}
 
  Transform<T, U>& operator=(const Transform<T, U>& src) {
    // Not currently supported.
    Teuchos::GlobalMPISession::abort();
    return (*this);
  }
 
};  // end class Transform
 
template <typename T, typename U>
void Transform<T, U>::
    analyze(const OriginalType& orig) {
  origObj_ = orig;
  newObj_  = Teuchos::rcp_dynamic_cast<U>(origObj_);
  return;
}
 
template <typename T, typename U>
typename Transform<T, U>::NewType
Transform<T, U>::
    construct() {
  return newObj_;
}
 
template <typename T, typename U>
bool Transform<T, U>::
    isConstructed() {
  return (newObj_ != Teuchos::null);
}
 
template <typename T, typename U>
class StructuralTransform : public Transform<T, U> {
 public:
  void fwd() { return; }
  void rvs() { return; }
 
  virtual ~StructuralTransform() = default;
};
 
template <typename T>
class SameTypeTransform : public Transform<T, T> {
 public:
  using TransformType = Teuchos::RCP<T>;
 
  virtual ~SameTypeTransform() = default;
};
 
template <typename T>
class StructuralSameTypeTransform : public SameTypeTransform<T> {
 public:
  void fwd() { return; }
  void rvs() { return; }
 
  virtual ~StructuralSameTypeTransform() = default;
};
 
//  template<typename T>
//  class InPlaceTransform : public SameTypeTransform<T>
//  {
//   public:
//    typename Transform<T,T>::NewTypeRef
//    operator()
//    ( typename Transform<T,T>::OriginalTypeRef orig )
//    { this->origObj_ = &orig;
//      this->newObj_ = &orig;
//      return orig;
//    }
//
//    virtual ~InPlaceTransform() = default;
//  };
 
template <typename T>
class ViewTransform : public SameTypeTransform<T> {
 public:
  void fwd() { return; }
  void rvs() { return; }
 
  virtual ~ViewTransform() = default;
};
 
}  // namespace Tpetra
 
#endif  // TPETRA_TRANSFORM_HPP