type_constructor.hpp

Go to the documentation of this file.

/*
Copyright (c) 2014, Sam Schetterer, Nathan Kutz, University of Washington
Authors: Sam Schetterer
All rights reserved.

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.

2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

*/
#pragma once
#ifndef TYPE_CONSTRUCTOR_HPP
#define TYPE_CONSTRUCTOR_HPP
#include "vartype.hpp"
#include "defs.hpp"
#include "types/example_type.hpp"
#include <type_traits>
//
//There has to be a better way to combine this and satisfy the compiler...
//

/*
 * Function to iterate over a list of types, helps satisfy the compiler 
 */

class typelist_checker{};
class blacklist_checker{};
template<class ...P>
class typelist:public typelist_checker{
    template<class Tout, template<class> class Toh, template <class, class> class Tcr, class Tf, class ...Tl>
        static  Toh<Tout>* __create(const vartype* tval){

            static_assert(std::is_floating_point<typename float_traits<Tf>::type>::value,
                    "The float_traits of the current class is not a floating point type");
            if(tval->compare<Tf>()){
                return new Tcr<Tf, Tout>();
            }
            else return __create<Tout, Toh, Tcr, Tl...>(tval);
        }
    template<class Tout, template<class> class Toh, template <class, class> class Tcr>
        static  Toh<Tout>* __create(const vartype* tval){
            //has failed creation process
            std::string val("Type ");
            val.append(tval->vname());
            val.append(" is not recognized as a valid input type for ");
            val.append(typeid(Tout).name());
            err(val, "typelist::__create", "utils/type_constructor.hpp", FATAL_ERROR);
            return 0;//This simply satisfies static analyzers, err will always exit in this case
        }
    template<class Tout, template<class> class Toh, template<class, class> class Tcr>
        static void create(Toh<Tout>** in, const vartype* val){
            (*in)= __create<Tout, Toh, Tcr, P...>(val);
        }
    public:
    typelist(){};
    template<template<class> class U>
        friend class type_constructor;
};
template<class ...P>
class blacklist:public blacklist_checker{
    //The extra template parameter seems to help the compiler
    // instantiate the recursion so it stays. It isn't part of the outer face so
    // whatever works.
    template<class Tout, class Tf, class ...Tl>
        static  bool __check(const vartype* tval){
            if(tval->compare<Tf>()){
                //has failed blacklist
                //
                return true;
            }
            else return __check<Tout, Tl...>(tval);
        }
    template<class Tout>
        static  bool __check(const vartype* tval){
            //has passed
            return false;//This simply satisfies static analyzers, err will always exit in this case
        }
    static bool check(const vartype* val){
        return __check<int, P...>(val);
    }
    public:
        blacklist(){};
    template< template<class> class U>
        friend class type_constructor;
};


template<template<class> class Tin>
class type_constructor{
    template<class Tout>
        class _ttype{
            public:
                virtual std::shared_ptr<Tout> create() = 0;
                virtual ~_ttype(){}
        };
    template<class Tval, class Tout>
        class ttype: public _ttype<Tout>{
            public:
                std::shared_ptr<Tout> create(){
                    return std::make_shared<Tin<Tval> >();
                }
                virtual ~ttype(){}
        };

    public:

    typedef typelist<comp, double, float, example_type> std_type_list;


    template<class Tout, 
        class = typename std::enable_if<std::is_base_of<vartype, Tout>::value >::type>
            static void create(std::shared_ptr<Tout>* in, const vartype* tval){
                _ttype<Tout>* temp;
                std_type_list::create<Tout, _ttype, ttype>(&temp, tval);
                (*in) = temp->create();
                delete temp;
            }
    //This is an identical verison of above, except is accepts a blacklist against the standard typelist
    template<class Tl,class Tout, 
        class = typename std::enable_if<std::is_base_of<vartype, Tout>::value >::type,
        class = typename std::enable_if<std::is_base_of<blacklist_checker, Tl>::value >::type>
            static void create(std::shared_ptr<Tout>* in, const vartype* tval){
                _ttype<Tout>* temp;
                if(Tl::check(tval)){
                    std::string val("Type ");
                    val.append(tval->vname());
                    val.append(" is blacklisted as an input type for ");
                    val.append(typeid(Tout).name());
                    err(val, "type_constructor::create", "utils/type_constructor.hpp", FATAL_ERROR);
                }
                std_type_list::create<Tout, _ttype, ttype>(&temp, tval);
                (*in) = temp->create();
                delete temp;
            }

    //The list type is unspecified, so you can call this with a blacklist, a whitelist, or neither
    template<class Tout>
        static std::shared_ptr<Tout> create(const vartype* tval){
            std::shared_ptr<Tout> rval;
            type_constructor<Tin>::create<Tout>(&rval, tval);
            return rval;
        }
    template<class Tl, class Tout>
        static std::shared_ptr<Tout> create(const vartype* tval, const Tl blist){
            std::shared_ptr<Tout> rval;
            type_constructor<Tin>::create<Tl, Tout>(&rval, tval, blist);
            return rval;
        }
};
#endif