method_check.hpp

Go to the documentation of this file.

/*
 * Copyright 2008,2009,2010,2011,2012 Stephan Ossowski, Korbinian Schneeberger,
 * Felix Ott, Joerg Hagmann, Alf Scotland, Sebastian Bender
 * 
 * This file is part of SHORE.
 * 
 * SHORE 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.
 * 
 * SHORE 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 SHORE.  If not, see <http://www.gnu.org/licenses/>.
 */


#ifndef SHORE_PROCESSING_METHODCHECK_HPP__
#define SHORE_PROCESSING_METHODCHECK_HPP__

namespace shore {

class member_check_defs
{
 private:

        class cannot_mix
        { 
                char m;
        };

        class can_mix
        {
                cannot_mix m[2];
        };

        template<typename U, U t>
        class instantiate_test
        {}; 

        member_check_defs();
};


template<typename T> 
class has_next
:member_check_defs
{
 private:

        struct interference 
        { 
                void next()
                {} 
        };

        struct mixed
        :public T,public interference
        {}; 

        template<typename U> 
        static can_mix deduce(U *,instantiate_test<void (interference::*)(),&U::next> * =0); 

        static cannot_mix deduce(...); 

 public:

        static const bool value = sizeof(cannot_mix) == sizeof(deduce((mixed*)(0))); 
}; 

template<typename T>
const bool has_next<T>::value;


template<typename T> 
class has_prepare
:member_check_defs
{
 private:

        struct interference 
        { 
                void prepare()
                {} 
        };

        struct mixed
        :public T,public interference
        {}; 

        template<typename U> 
        static can_mix deduce(U *,instantiate_test<void (interference::*)(),&U::prepare> * =0); 

        static cannot_mix deduce(...); 

 public:

        static const bool value = sizeof(cannot_mix) == sizeof(deduce((mixed*)(0))); 
}; 

template<typename T>
const bool has_prepare<T>::value;


template<typename T> 
class has_flush
:member_check_defs
{
 private:

        struct interference 
        { 
                void flush()
                {} 
        };

        struct mixed
        :public T,public interference
        {}; 

        template<typename U> 
        static can_mix deduce(U *,instantiate_test<void (interference::*)(),&U::flush> * =0); 

        static cannot_mix deduce(...); 

 public:

        static const bool value = sizeof(cannot_mix) == sizeof(deduce((mixed*)(0))); 
}; 

template<typename T>
const bool has_flush<T>::value;


template<typename T> 
class has_get_name
:member_check_defs
{
 private:

        struct interference 
        { 
                void get_name()
                {} 
        };

        struct mixed
        :public T,public interference
        {}; 

        template<typename U> 
        static can_mix deduce(U *,instantiate_test<void (interference::*)(),&U::get_name> * =0); 

        static cannot_mix deduce(...); 

 public:

        static const bool value = sizeof(cannot_mix) == sizeof(deduce((mixed*)(0))); 
}; 

template<typename T>
const bool has_get_name<T>::value;


template<typename T> 
class has_dump
:member_check_defs
{
 private:

        struct interference 
        { 
                void dump()
                {} 
        };

        struct mixed
        :public T,public interference
        {}; 

        template<typename U> 
        static can_mix deduce(U *,instantiate_test<void (interference::*)(),&U::dump> * =0); 

        static cannot_mix deduce(...); 

 public:

        static const bool value = sizeof(cannot_mix) == sizeof(deduce((mixed*)(0))); 
}; 

template<typename T>
const bool has_dump<T>::value;

} // namespace shore

#endif // SHORE_PROCESSING_METHODCHECK_HPP__