Map.h

Go to the documentation of this file.

/*****************************************************************************
 * Copyright (c) 2011-2012 The SkelCL Team as listed in CREDITS.txt          *
 * http://skelcl.uni-muenster.de                                             *
 *                                                                           *
 * This file is part of SkelCL.                                              *
 * SkelCL is available under multiple licenses.                              *
 * The different licenses are subject to terms and condition as provided     *
 * in the files specifying the license. See "LICENSE.txt" for details        *
 *                                                                           *
 *****************************************************************************
 *                                                                           *
 * SkelCL 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 3 of the License, or         *
 * (at your option) any later version. See "LICENSE-gpl.txt" for details.    *
 *                                                                           *
 * SkelCL 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.                              *
 *                                                                           *
 *****************************************************************************
 *                                                                           *
 * For non-commercial academic use see the license specified in the file     *
 * "LICENSE-academic.txt".                                                   *
 *                                                                           *
 *****************************************************************************
 *                                                                           *
 * If you are interested in other licensing models, including a commercial-  *
 * license, please contact the author at michel.steuwer@uni-muenster.de      *
 *                                                                           *
 *****************************************************************************/
 

#ifndef MAP_H_
#define MAP_H_

#include <istream>
#include <string>

#include "detail/MapHelper.h"
#include "detail/Skeleton.h"
#include "detail/skelclDll.h"

namespace skelcl {

class Index;
class IndexPoint;
class Source;
template <typename> class Out;
namespace detail { class Program; }

template<typename> class Map;


//
template<typename Tin, typename Tout>
class Map<Tout(Tin)> : public detail::Skeleton,
                       private detail::MapHelper<Tout(Tin)> {
public:
  Map<Tout(Tin)>(const Source& source,
                 const std::string& funcName = std::string("func"));

  template <template <typename> class C,
            typename... Args>
  C<Tout> operator()(const C<Tin>& input,
                     Args&&... args) const;

  template <template <typename> class C,
            typename... Args>
  C<Tout>& operator()(Out<C<Tout>> output,
                      const C<Tin>&  input,
                      Args&&... args) const;

private:
  template <template <typename> class C,
            typename... Args>
  void execute(C<Tout>& output,
               const C<Tin>& input,
               Args&&... args) const;

  detail::Program createAndBuildProgram(const std::string& source,
                                        const std::string& funcName) const;
};

template<typename Tin>
class Map<void(Tin)> : public detail::Skeleton,
                       private detail::MapHelper<void(Tin)> {
public:
  Map<void(Tin)>(const Source& source,
                 const std::string& funcName = std::string("func"));

  template <template <typename> class C,
            typename... Args>
  void operator()(const C<Tin>& input,
                  Args&&... args) const;

private:
  template <template <typename> class C,
            typename... Args>
  void execute(const C<Tin>& input,
               Args&&... args) const;

  detail::Program createAndBuildProgram(const std::string& source,
                                        const std::string& funcName) const;
};

template<typename Tout>
class Map<Tout(Index)> : public detail::Skeleton,
                         private detail::MapHelper<Tout(Index)> {
public:
  Map<Tout(Index)>(const Source& source,
                   const std::string& funcName = std::string("func"));

  template <typename... Args>
  Vector<Tout> operator()(const Vector<Index>& input,
                          Args&&... args) const;

  template <typename... Args>
  Vector<Tout>& operator()(Out<Vector<Tout>> output,
                           const Vector<Index>& input,
                           Args&&... args) const;

private:
  template <typename... Args>
  void execute(Vector<Tout>& output,
               const Vector<Index>& input,
               Args&&... args) const;
  
  detail::Program createAndBuildProgram(const std::string& source,
                                        const std::string& funcName) const;
};

template<>
class SKELCL_DLL Map<void(Index)> : public detail::Skeleton,
                                    private detail::MapHelper<void(Index)> {
public:
  Map(const Source& source, const std::string& funcName = std::string("func"));

  template <typename... Args>
  void operator()(const Vector<Index>& input,
                  Args&&... args) const;

private:
  template <typename... Args>
  void execute(const Vector<Index>& input,
               Args&&... args) const;

  detail::Program createAndBuildProgram(const std::string& source,
                                        const std::string& funcName) const;
};

template<typename Tout>
class Map<Tout(IndexPoint)> : public detail::Skeleton,
                              private detail::MapHelper<Tout(IndexPoint)> {
public:
  Map<Tout(IndexPoint)>(const Source& source,
                        const std::string& funcName = std::string("func"));
  
  template <typename... Args>
  Matrix<Tout> operator()(const Matrix<IndexPoint>& input,
                          Args&&... args) const;
  
  template <typename... Args>
  Matrix<Tout>& operator()(Out<Matrix<Tout>> output,
                           const Matrix<IndexPoint>& input,
                           Args&&... args) const;
  
private:
  template <typename... Args>
  void execute(Matrix<Tout>& output,
               const Matrix<IndexPoint>& input,
               Args&&... args) const;
  
  detail::Program createAndBuildProgram(const std::string& source,
                                        const std::string& funcName) const;
};

template<>
class SKELCL_DLL Map<void(IndexPoint)>
  : public detail::Skeleton, private detail::MapHelper<void(IndexPoint)> {
public:
  Map(const Source& source, const std::string& funcName = std::string("func"));
  
  template <typename... Args>
  void operator()(const Matrix<IndexPoint>& input,
                  Args&&... args) const;
  
private:
  template <typename... Args>
  void execute(const Matrix<IndexPoint>& input,
               Args&&... args) const;
  
  detail::Program createAndBuildProgram(const std::string& source,
                                        const std::string& funcName) const;
};

} // namespace skelcl

// including the definition of the templates
#include "detail/MapDef.h"

#endif // MAP_H_