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