Instigate Open Source Documentation

---

src/stl/_vector.hpp

Go to the documentation of this file.

#ifndef _INSTIGATE_OPEN_SOURCE_INTERNAL_HEADER_IN_CONCEPT
#error This is an internal header file used to implement Instigate STL.\
        It should never be included directly by a program.
#endif

#ifndef INSTIGATE_STL_VECTOR
#define INSTIGATE_STL_VECTOR

// headers from this project
#include "concept.hpp"

// headers from other projects
#include <generic/_assignable.hpp>
#include <generic/_default_constructible.hpp>

// headers from standard libraries
#include <cassert>

// Forward declarations
namespace instigate {
        namespace stl {
                namespace vector {
                        template<typename T>
                                struct interface;
                        template<typename T>
                                struct requirements;
                }
        }
}

template <typename T>
struct instigate::stl::vector::interface
        : instigate::generic::assignable::interface<T>
        , instigate::generic::default_constructible::interface<T>
{
        typedef typename T::size_type size_type;

        typedef typename T::value_type value_type;

        static size_type get_size(const T& x)
        {
                return x.size();
        }

        static value_type get_element(const T& x, const size_type& i)
        {
                assert(i < get_size(x));
                return x[i];
        }

        static void set_element(T& x, 
                                const size_type& i, 
                                const value_type& v)
        {
                assert(i < get_size(x));
                x[i] = v;
        }

        static void construct(T& x, const size_type& i)
        {
                x.resize(i);
        }
};


template <typename T>
struct instigate::stl::vector::requirements
{
private:
        void require_get_size(const T& x)
        {
                typedef instigate::stl::vector::interface<T> I;
                typedef typename I::size_type S;
                S s = I::get_size(x);
        }

        void require_get_element(const T& x,
                                const typename instigate::stl::
                                vector:: interface<T>::size_type& i)
        {
                typedef instigate::stl::vector::interface<T> I;
                typedef typename instigate::stl::vector::
                                                interface<T>::value_type V;
                V v = I::get_element(x, i);
        }

        void require_set_element(T& x,
                                const typename instigate::stl::
                                vector:: interface<T>::size_type& i,
                                const typename instigate::stl::
                                vector:: interface<T>::value_type& v)
        {
                typedef instigate::stl::vector::interface<T> I;
                I::set_element(x, i, v);
        }

public:
        requirements()
        {
                (void)require_get_size;
                (void)require_get_element;
                (void)require_set_element;
        }
        
private:
        requirements(const requirements&) throw();

        requirements& operator=(const requirements&) throw();


}; // struct instigate::stl::vector::requirements

// vim:et:tabstop=8:shiftwidth=8:cindent:fo=croq:textwidth=80:

#endif // INSTIGATE_STL_VECTOR

---

© Instigate CJSC, Open Source