persistent_parameter_generator.h

Go to the documentation of this file.

#pragma once
#include <gtest/gtest.h>


namespace illumina{ namespace interop { namespace unittest {
    template<typename T>
    class argument_generator : public ::testing::internal::ParamGeneratorInterface<T>
    {
    public:
        argument_generator(const std::vector<T>& vec) : m_vec(vec){}
        ::testing::internal::ParamIteratorInterface<T>* Begin() const;
        ::testing::internal::ParamIteratorInterface<T>* End() const;

    private:
        const std::vector<T>& m_vec;
    };
    template<typename T>
    class argument_iterator : public ::testing::internal::ParamIteratorInterface<T>
    {
        typedef typename std::vector<T>::const_iterator const_iterator;
    public:
        argument_iterator(const argument_generator<T>& base, const_iterator it) : m_base(base), m_begin(it), m_current(it)
        {
        }
        virtual ~argument_iterator() {}
        virtual const ::testing::internal::ParamGeneratorInterface<T>* BaseGenerator() const
        {
            return &m_base;
        }
        virtual void Advance()
        {
            ++m_current;
        }
        virtual ::testing::internal::ParamIteratorInterface<T>* Clone() const
        {
            return new argument_iterator(*this);
        }
        virtual const T* Current() const
        {
            return &(*m_current);
        }
        virtual bool Equals(const ::testing::internal::ParamIteratorInterface<T>& other) const
        {
            return &m_base == other.BaseGenerator() &&
                    m_current == dynamic_cast<const argument_iterator<T>*>(&other)->m_current;
        }
    private:
        argument_iterator(const argument_iterator<T>& other)
                : m_base(other.m_base), m_begin(other.m_begin),
                m_current(other.m_current) {}
    private:
        const argument_generator<T>& m_base;
        const const_iterator m_begin;
        const_iterator m_current;
    };


    template<typename T>
    ::testing::internal::ParamIteratorInterface<T>* argument_generator<T>::Begin() const
    {
        return new argument_iterator<T>(*this, m_vec.begin());
    }
    template<typename T>
    ::testing::internal::ParamIteratorInterface<T>* argument_generator<T>::End() const
    {
        return new argument_iterator<T>(*this, m_vec.end());
    }

    template<typename T>
    ::testing::internal::ParamGenerator<T> PersistentValuesIn(const std::vector<T>& values) {
        return ::testing::internal::ParamGenerator<T>(new argument_generator<T>(values));
    }
}}}