microbenchmark-adaptor.hpp

Go to the documentation of this file.

/*
  MICROBENCHMARK-ADAPTOR.hpp  -  helper to support microbenchmarks

  Copyright (C)         Lumiera.org
    2023,               Hermann Vosseler <Ichthyostega@web.de>

  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 LIB_TEST_MICROBENCHMARK_ADAPTOR_H
#define LIB_TEST_MICROBENCHMARK_ADAPTOR_H


#include "lib/meta/function.hpp"
#include "lib/meta/util.hpp"

namespace lib {
namespace test{
namespace microbenchmark {
  
  using lib::meta::enable_if;
  using std::is_arithmetic;
  using std::is_same;
  using std::__and_;
  using std::__not_;
  
  
  template<class SIG, typename SEL=void>
  struct Adaptor
    {
      static_assert (not sizeof(SIG), "Unable to adapt given functor.");
    };
  
  template<>
  struct Adaptor<size_t(size_t)>
    {
      template<typename FUN>
      static decltype(auto)
      wrap (FUN&& fun)
        {
          return std::forward<FUN>(fun);
        }
    };
  
  template<>
  struct Adaptor<void(void)>
    {
      template<typename FUN>
      static auto
      wrap (FUN&& fun)
        {
          return [functor=std::forward<FUN>(fun)]
                 (size_t)
                    {
                      functor();
                      return size_t(1);
                    };
        }
    };
  
  template<typename ON, typename IN>
  struct Adaptor<ON(IN),               enable_if<__and_<is_arithmetic<IN>, __not_<is_same<IN,size_t>>
                                                       ,is_arithmetic<ON>, __not_<is_same<ON,size_t>>
                                                       >>>
    {
      template<typename FUN>
      static auto
      wrap (FUN&& fun)
        {
          return [functor=std::forward<FUN>(fun)]
                 (size_t i)
                    {
                      return size_t(functor(i));
                    };
        }
    };
  
  template<typename ON>
  struct Adaptor<ON(void),             enable_if<__and_<is_arithmetic<ON>, __not_<is_same<ON,size_t>>
                                                       >>>
    {
      template<typename FUN>
      static auto
      wrap (FUN&& fun)
        {
          return [functor=std::forward<FUN>(fun)]
                 (size_t)
                    {
                      return size_t(functor());
                    };
        }
    };
  
  template<typename IN>
  struct Adaptor<void(IN),             enable_if<__and_<is_arithmetic<IN>, __not_<is_same<IN,size_t>>
                                                       >>>
    {
      template<typename FUN>
      static auto
      wrap (FUN&& fun)
        {
          return [functor=std::forward<FUN>(fun)]
                 (size_t i)
                    {
                      functor(i);
                      return size_t(1);
                    };
        }
    };
  
  
  
  template<typename FUN>
  inline decltype(auto)
  adapted4benchmark (FUN&& fun)
  {
    static_assert (lib::meta::_Fun<FUN>(), "Need something function-like.");
    static_assert (lib::meta::_Fun<FUN>::ARITY <=1, "Function with zero or one argument required.");
    
    using Sig = typename lib::meta::_Fun<FUN>::Sig;
    
    return Adaptor<Sig>::wrap (std::forward<FUN> (fun));
  }
  
  
  
}}} // namespace lib::test::microbenchmark
#endif /*LIB_TEST_MICROBENCHMARK_ADAPTOR_H*/