proxy_parameter_generator.h

Go to the documentation of this file.

#pragma once
#include <gtest/gtest.h>
#include "interop/util/type_traits.h"
#include "interop/util/static_assert.h"


namespace illumina{ namespace interop { namespace unittest
{

    template<typename T, typename Proxy>
    class proxy_argument_generator : public ::testing::internal::ParamGeneratorInterface< typename T::parent_type >
    {
    public:
        proxy_argument_generator(T& obj, const std::vector<Proxy>& vec) : m_vec(vec), m_object(obj){}
        virtual ~proxy_argument_generator(){}
        ::testing::internal::ParamIteratorInterface< typename T::parent_type >* Begin() const;
        ::testing::internal::ParamIteratorInterface< typename T::parent_type >* End() const;

    private:
        const std::vector<Proxy>& m_vec;
        T& m_object;
    };
    template<typename T, typename Proxy>
    class proxy_argument_iterator : public ::testing::internal::ParamIteratorInterface< typename T::parent_type >
    {
        typedef typename std::vector< Proxy >::const_iterator const_iterator;
    public:
        proxy_argument_iterator(T& obj,
                                const proxy_argument_generator<T,Proxy>& base,
                                const_iterator it,
                                const_iterator it_end) :
                m_base(base), m_begin(it), m_current(it), m_end(it_end), m_object(obj)
        {
            static_assert(!is_pointer<T>::value, "This class does not free memory and should not take a pointer");
            if(m_current < m_end)
            {
                m_current_val=m_object(*m_current);
            }
        }
        virtual ~proxy_argument_iterator()
        {
        }
        virtual const ::testing::internal::ParamGeneratorInterface< typename T::parent_type >* BaseGenerator() const
        {
            return &m_base;
        }
        virtual void Advance()
        {
            if(m_current_val == 0 || m_current_val->advance())
            {
                ++m_current;
                if(m_current < m_end)
                {
                    m_current_val=m_object(*m_current);
                }
            }
        }
        virtual ::testing::internal::ParamIteratorInterface< typename T::parent_type >* Clone() const
        {
            return new proxy_argument_iterator(*this);
        }
        virtual const typename T::parent_type* Current() const
        {
            return &m_current_val;
        }
        virtual bool Equals(const ::testing::internal::ParamIteratorInterface< typename T::parent_type >& other) const
        {
            return &m_base == other.BaseGenerator() &&
                    m_current == dynamic_cast<const proxy_argument_iterator<T,Proxy>*>(&other)->m_current;
        }

    private:
        proxy_argument_iterator(const proxy_argument_iterator<T,Proxy>& other)
                : m_base(other.m_base), m_begin(other.m_begin),
                m_current(other.m_current), m_end(other.m_end), m_object(other.m_object)
        {
            if(m_current < m_end) m_current_val=m_object(*m_current);
        }

    private:
        const proxy_argument_generator<T,Proxy>& m_base;
        const const_iterator m_begin;
        const_iterator m_current;
        const_iterator m_end;
        T& m_object;
        mutable typename T::parent_type m_current_val;
    };


    template<typename T, typename Proxy>
    ::testing::internal::ParamIteratorInterface< typename T::parent_type >* proxy_argument_generator<T,Proxy>::Begin() const
    {
        return new proxy_argument_iterator<T,Proxy>(m_object, *this, m_vec.begin(), m_vec.end());
    }
    template<typename T, typename Proxy>
    ::testing::internal::ParamIteratorInterface< typename T::parent_type >* proxy_argument_generator<T,Proxy>::End() const
    {
        return new proxy_argument_iterator<T,Proxy>(m_object, *this, m_vec.end(), m_vec.end());
    }

    template<typename T, typename Proxy>
    ::testing::internal::ParamGenerator< typename T::parent_type > ProxyValuesIn(T& object, const std::vector<Proxy>& values)
    {
        return ::testing::internal::ParamGenerator< typename T::parent_type >(new proxy_argument_generator<T, Proxy>(object, values));
    }
}}}