function_scl.hpp

Go to the documentation of this file.

/*
 * $Id: function_scl.hpp 289 2012-12-04 15:32:17Z jdl3 $
 * Copyright (C) 2010, 2011, 2012, 2019, 2020 John D Lamb
 *
 * 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., 675 Mass Ave, Cambridge, MA 02139, USA.
 */
 
#ifndef CCGSL_FUNCTION_SCL_HPP
#define CCGSL_FUNCTION_SCL_HPP
 
// For std::pair
#include<utility>
// For std::swap
#if __cplusplus <= 199711L
#include<algorithm>
#endif
 
#include<gsl/gsl_math.h>
 
namespace gsl {
  class function_scl : public gsl_function {
#ifndef DOXYGEN_SKIP
  private:
    struct base_F {
      typedef double (*function_t)(double,void*);
      virtual ~base_F(){};
      virtual function_t function() = 0;
    };
    template<typename A>
    class Fx : public base_F {
    public:
      Fx( double (*const f)(A) ) : f( f ){}
      function_t function(){ return &fn; }
    private:
      double (*const f)(A);
    public:
      static double fn( double x, void* params ){
        return reinterpret_cast<Fx<A>*>( params )->f( x ); }
    };
    template<typename A>
    class Fxc : public base_F {
    public:
      Fxc( double const (*const f)(A) ) : f( f ){}
      function_t function(){ return &fn; }
    private:
      double const (*const f)(A);
    public:
      static double fn( double x, void* params ){
        return reinterpret_cast<Fxc<A>*>( params )->f( x ); }
    };
    template<typename T, typename R, typename A>
    class F : public base_F {
    public:
      F(T& c, R (T::*f)(A)) : c( c ), f(f) {}
      double operator()( double x ){ return (c.*f)( x ); }
      function_t function(){ return &function_s; }
    private:
      static double function_s( double x, void* params ){
        F<T,R,A>* const cl = reinterpret_cast<F<T,R,A>*>( params );
        return (cl->c.*cl->f)(x); }
      T& c;
      R (T::*f)(A);
    };
    template<typename T, typename R, typename A>
    class Fc : public base_F {
    public:
      Fc(T& c, R (T::*f)(A) const) : c( c ), f(f) {}
      double operator()( double x ){ return (c.*f)( x ); }
      function_t function(){ return &function_s; }
    private:
      static double function_s( double x, void* params ){
        Fc<T,R,A>* const cl = reinterpret_cast<Fc<T,R,A>*>( params );
        return (cl->c.*cl->f)(x); }
      T& c;
      R (T::*f)(A) const;
    };
    template<typename T, typename R, typename A>
    class Fv : public base_F {
    public:
      Fv(T& c, R (T::*f)(A) volatile) : c( c ), f(f) {}
      double operator()( double x ){ return (c.*f)( x ); }
      function_t function(){ return &function_s; }
    private:
      static double function_s( double x, void* params ){
        Fv<T,R,A>* const cl = reinterpret_cast<Fv<T,R,A>*>( params );
        return (cl->c.*cl->f)(x); }
      T& c;
      R (T::*f)(A) volatile;
    };
    template<typename T, typename R, typename A>
    class Fcv : public base_F {
    public:
      Fcv(T& c, R (T::*f)(A) const volatile) : c( c ), f(f) {}
      double operator()( double x ){ return (c.*f)( x ); }
      function_t function(){ return &function_s; }
    private:
      static double function_s( double x, void* params ){
        Fcv<T,R,A>* const cl = reinterpret_cast<Fcv<T,R,A>*>( params );
        return (cl->c.*cl->f)(x); }
      T& c;
      R (T::*f)(A) const volatile;
    };
#endif
    base_F* f;
    size_t* count;
  public:
    function_scl(){
      f = 0;
      function = 0;
      params = 0;
      count = 0; // initially nullptr will do
    }
    explicit function_scl( gsl_function& v ){
      // explicitly set f = 0 to indicate nothing to be deleted.
      f = 0;
      // copy
      function = v.function;
      params = v.params;
      // just plausibly we could fail to allocate count: no further action needed.
      count = new size_t;
      *count = 1; // initially there is just one reference to f
    }
    template<typename A>
    explicit function_scl( double (*const f)(A) ){
      this->f = new Fx<A>( f );
      params = this->f;
      function = dynamic_cast<Fx<A>*>(this->f)->fn;
      // just plausibly we could fail to allocate count: no further action needed.
      count = new size_t;
      *count = 1; // initially there is just one reference to f
    }
    template<typename A>
    explicit function_scl( double const (*const f)(A) ){
      this->f = new Fxc<A>( f );
      params = this->f;
      function = dynamic_cast<Fxc<A>*>(this->f)->fn;
      // just plausibly we could fail to allocate count: no further action needed.
      count = new size_t;
      *count = 1; // initially there is just one reference to f
    }
    template<typename T, typename R, typename A> function_scl( T& c, R (T::*f)(A) ){
      this->f = new F<T,R,A>( c, f );
      params = this->f;
      function = &fn;
      // just plausibly we could fail to allocate count: no further action needed.
      count = new size_t;
      *count = 1; // initially there is just one reference to f
    }
    template<typename T, typename R, typename A> function_scl( T& c, R (T::*f)(A) const){
      this->f = new Fc<T,R,A>( c, f );
      params = this->f;
      function = &fn;
      // just plausibly we could fail to allocate count: no further action needed.
      count = new size_t;
      *count = 1; // initially there is just one reference to f
    }
    template<typename T, typename R, typename A> function_scl( T& c, R (T::*f)(A) volatile){
      this->f = new Fv<T,R,A>( c, f );
      params = this->f;
      function = &fn;
      // just plausibly we could fail to allocate count: no further action needed.
      count = new size_t;
      *count = 1; // initially there is just one reference to f
    }
    template<typename T, typename R, typename A> function_scl( T& c, R (T::*f)(A)
                                   const volatile){
      this->f = new Fcv<T,R,A>( c, f );
      params = this->f;
      function = &fn;
      // just plausibly we could fail to allocate count: no further action needed.
      count = new size_t;
      *count = 1; // initially there is just one reference to f
    }
    // Copy and move constructors
    // copy constructor
    function_scl( function_scl const& v ) : f( v.f ), count( v.count ){
      function = v.function;
      params = v.params;
      if( count != 0 ) ++*count; // function_scl is now shared.
    }
    // assignment operator
    function_scl& operator=( function_scl const& v ){
      // first, possibly delete anything pointed to by this
      if( count == 0 or --*count == 0 ){
    delete f;
    delete count;
      }
      // Then copy
      f = v.f;
      function = v.function;
      params = v.params;
      count = v.count;
      if( count != 0 ) ++*count; // function_scl is now shared.
      return *this;
    }
#ifdef __GXX_EXPERIMENTAL_CXX0X__
    function_scl( function_scl&& v ) : f( v.f ), count( nullptr ){
      std::swap( function, v.function );
      std::swap( params, v.params );
      std::swap( count, v.count );
      v.f = nullptr;
    }
    function_scl& operator=( function_scl&& v ){
      std::swap( f, v.f );
      std::swap( function, v.function );
      std::swap( params, v.params );
      std::swap( count, v.count );
      return *this;
    }
#endif
    ~function_scl(){ 
      // first, possibly delete anything pointed to by f
      if( count == 0 or --*count == 0 ){
    delete f;
    delete count;
      }
    }
    static double fn( double x, void* params ){
      base_F* const b = reinterpret_cast<base_F*>( params );
      return b->function()( x, params );
    }
  };    
 
  template<typename T, typename R, typename A>
  inline function_scl make_function_scl( T& c, R (T::*f)(A) ){
    function_scl fn( c, f );
    return fn;
  }
#ifndef DOXYGEN_SKIP
  template<typename T, typename R, typename A>
  inline function_scl make_function_scl( T& c, R (T::*f)(A) const ){
    function_scl fn( c, f );
    return fn;
  }
  template<typename T, typename R, typename A>
  inline function_scl make_function_scl( T& c, R (T::*f)(A) volatile ){
    function_scl fn( c, f );
    return fn;
  }
  template<typename T, typename R, typename A>
  inline function_scl make_function_scl( T& c, R (T::*f)(A) const volatile ){
    function_scl fn( c, f );
    return fn;
  }
  inline double fn_eval( gsl_function const* const F, double const x ){
    return (F->function)( x, F->params );
  }
#endif
  inline double fn_eval( gsl_function const& F, double const x ){
    return (F.function)( x, F.params );
  }
 
}
 
#endif