ROL_VectorClone.hpp

Go to the documentation of this file.

#pragma once
#ifndef ROL_VECTORCLONE_HPP
#define ROL_VECTORCLONE_HPP

// @HEADER
// *****************************************************************************
//               Rapid Optimization Library (ROL) Package
//
// Copyright 2014 NTESS and the ROL contributors.
// SPDX-License-Identifier: BSD-3-Clause
// *****************************************************************************
// @HEADER

#include "ROL_Vector.hpp"
#include <exception>
#include <typeinfo>
#include <utility>
#include <map>

namespace ROL {

namespace details {

template<typename Real>
class VectorClone {
private:

  Ptr<Vector<Real>> vec_;
  bool is_allocated_;

public:

  VectorClone() : vec_(nullPtr), is_allocated_(false) {}

  Ptr<Vector<Real>> operator() ( const Vector<Real>& x ) {
    if( is_allocated_ ) {
      if( typeid(x) != typeid(*vec_) )
        throw std::logic_error("Argument and member vector types are different!");
      if( x.dimension() != vec_->dimension() )
        throw std::logic_error("Argument and member vector types have different dimensions!");
    }
    else {
      vec_ = x.clone();
      is_allocated_ = true;
    }
    return vec_;
  }

  Ptr<Vector<Real>> operator() ( const Ptr<const Vector<Real>>& x ) {
    if( is_allocated_ ) {
      if( typeid(*x) != typeid(*vec_) )
        throw std::logic_error("Argument and member vector types are different!");
      if( x->dimension() != vec_->dimension() )
        throw std::logic_error("Argument and member vector types have different dimensions!");
    }
    else {
      vec_ = x->clone();
      is_allocated_ = true;
    }
    return vec_;
  }
}; // VectorClone



template<typename Real, typename KeyType=const char*>
class VectorCloneMap {
private:
  std::map<KeyType, VectorClone<Real>> clones_;
 
  template<typename First, typename...Rest>
  void Constructor_Impl( First first, Rest... rest ) {
    clones_[static_cast<KeyType>(first)] = VectorClone<Real>();
    Constructor_Impl( rest... );
  }

  template<typename First>
  void Constructor_Impl( First first ) {
    clones_[static_cast<KeyType>(first)] = VectorClone<Real>();
  }

public:

  template<typename... Keys>
  VectorCloneMap( Keys&&...keys ) {
    Constructor_Impl( keys... );
  }

  Ptr<Vector<Real>> operator() ( const Vector<Real>& x, KeyType key ) {
    return clones_[key](x);
  }

   Ptr<Vector<Real>> operator() ( const Ptr<const Vector<Real>>& x, KeyType key ) {
    return clones_[key](x);
  }
}; // VectorCloneMap





} // namespace details

using details::VectorClone;
using details::VectorCloneMap;

} // namespace ROL


#endif // ROL_VECTORCLONE_HPP