containers.hpp

Go to the documentation of this file.

/*****************************************************************************
** Ifdefs
*****************************************************************************/

#ifndef ECL_CONCEPTS_CONCEPTS_CONTAINERS_HPP_
#define ECL_CONCEPTS_CONCEPTS_CONTAINERS_HPP_

/*****************************************************************************
** Includes
*****************************************************************************/

#include <ecl/config/ecl.hpp>
#include <ecl/type_traits/fundamental_types.hpp>
#include "macros.hpp"

/*****************************************************************************
** Namespaces
*****************************************************************************/

namespace ecl {

/*****************************************************************************
** Concept [Container]
*****************************************************************************/

template <typename Implementation>
class ContainerConcept {
public:

        ecl_compile_time_concept_test(ContainerConcept)
        {
                iter = container.begin();
                iter = container.end();
                unsigned int n;
                n = container.size();
                (void) n; // remove set but not used warnings.
        }

private:
        // Putting instantiations here actually saves instantiation (which can cause a
        // problem if there is no default constructor).
        Implementation container;
        typename Implementation::iterator iter;
};
template <typename Implementation>
class DynamicContainerConcept {
public:

        ecl_compile_time_concept_test(DynamicContainerConcept)
        {
                iter = container.begin();
                iter = container.end();
                unsigned int n;
                n = container.size();
                container.resize(1);
                (void) n; // remove set but not used warnings.
        }

private:
        // Putting instantiations here actually saves instantiation (which can cause a
        // problem if there is no default constructor).
        Implementation container;
        typename Implementation::iterator iter;
};

namespace concepts {

template <typename T, bool Result=false>
class SignedByteTest {
private:
        SignedByteTest() {}
};

template <typename T>
class SignedByteTest<T,true> {
public:
        SignedByteTest() {}
};

template <typename T, bool Result=false>
class UnsignedByteTest {
private:
        UnsignedByteTest() {}
};

template <typename T>
class UnsignedByteTest<T,true> {
public:
        UnsignedByteTest() {}
};

template <typename T>
class SignedByteTestCheck : public SignedByteTest<T, ecl::is_signed_byte<T>::value > {};

template <typename T>
class UnsignedByteTestCheck : public UnsignedByteTest<T, ecl::is_unsigned_byte<T>::value > {};

template <typename T>
class ByteTest {
private:
        ByteTest() {}
};

template <>
class ByteTest<unsigned char> {
public:
        ByteTest() {}
};
template <>
class ByteTest<char> {
public:
        ByteTest() {}
};

template <>
class ByteTest<signed char> {
public:
        ByteTest() {}
};

} // namespace concepts
template <typename Implementation>
class UnsignedByteContainerConcept {
public:

        ecl_compile_time_concept_test(UnsignedByteContainerConcept)
        {
                typedef typename Implementation::value_type element_type;
                iter = container.begin();
                iter = container.end();
                unsigned int n;
                n = container.size();
                // If not a char, this results in a private call -> compile time error!
                concepts::UnsignedByteTestCheck<element_type> char_test;
                (void) n; // remove set but unused warnings.
        }

private:
        // Putting instantiations here actually saves instantiation (which can cause a
        // problem if there is no default constructor).
        Implementation container;
        typename Implementation::iterator iter;
};

template <typename Implementation>
class SignedByteContainerConcept {
public:

        ecl_compile_time_concept_test(SignedByteContainerConcept)
        {
                typedef typename Implementation::value_type element_type;
                iter = container.begin();
                iter = container.end();
                unsigned int n;
                n = container.size();
                // If not a char, this results in a private call -> compile time error!
                concepts::SignedByteTestCheck<element_type> char_test;
        }

private:
        // Putting instantiations here actually saves instantiation (which can cause a
        // problem if there is no default constructor).
        Implementation container;
        typename Implementation::iterator iter;
};

template <typename Implementation>
class ByteContainerConcept {
public:

        ecl_compile_time_concept_test(ByteContainerConcept)
        {
                typedef typename Implementation::value_type element_type;
                iter = container.begin();
                iter = container.end();
                unsigned int n;
                n = container.size();
                // If not a char, this results in a private call -> compile time error!
                concepts::ByteTest<element_type> char_test;
                (void) n; // remove set but unused warnings.
        }

private:
        // Putting instantiations here actually saves instantiation (which can cause a
        // problem if there is no default constructor).
        Implementation container;
        typename Implementation::iterator iter;
};

}; // namespace ecl

#endif /* ECL_CONCEPTS_CONCEPTS_CONTAINERS_HPP_ */