ParameterIterator.h

Go to the documentation of this file.

#ifndef FACE_CONTOUR_DETECTOR_PARAMETERITERATOR_H_
#define FACE_CONTOUR_DETECTOR_PARAMETERITERATOR_H_

#include <iostream>
#include <vector>

namespace face_contour_detector {

        class ParameterIteratorI {
        public:
                virtual void Next() = 0;
                virtual bool HasNext() = 0;
                virtual void Reset() = 0;
                virtual void PrintValue() = 0;
        };


        template<class T>
        class ParameterIterator : public ParameterIteratorI {
        public:
                ParameterIterator(T start, T end, T stepSize, T* target);
                ParameterIterator(const ParameterIterator& other);
                virtual void Next();
                virtual bool HasNext();
                virtual void Reset();
                virtual void PrintValue();

        protected:
                T m_start;
                T m_end;
                T m_stepSize;
                T* m_target;
        };

        template<class T>
        class ParallelParameterIterator : public ParameterIteratorI {
        public:
                ParallelParameterIterator(T start, T end, T stepSize);
                ParallelParameterIterator(const ParallelParameterIterator& other);
                virtual void Next();
                virtual bool HasNext();
                virtual void Reset();
                virtual void Add(T* target);
                virtual void PrintValue();

        protected:
                T m_start;
                T m_end;
                T m_stepSize;
                std::vector<T*> m_targets;
        };

        //Implementation

        template <class T>
        ParameterIterator<T>::ParameterIterator(T start, T end, T stepSize, T* target) : m_start(start), m_end(end), m_stepSize(stepSize), m_target(target) {
                assert(start < end);
        }
        template <class T>
        ParameterIterator<T>::ParameterIterator(const ParameterIterator& other) : m_start(other.m_start), m_end(other.m_end), m_stepSize(other.m_stepSize), m_target(other.m_target) {

        }
        template <class T>
        void ParameterIterator<T>::Next() {
                assert(m_target != 0 && HasNext());
                *m_target += m_stepSize;
        }
        template <class T>
        bool ParameterIterator<T>::HasNext() {
                assert(m_target != 0);
                return *m_target < m_end;
        }
        template <class T>
        void ParameterIterator<T>::Reset() {
                *m_target = m_start;
        }
        template <class T>
        void ParameterIterator<T>::PrintValue() {
                std::cout<<*m_target;
        }

        //ParallelParameterIterator

        template <class T>
        ParallelParameterIterator<T>::ParallelParameterIterator(T start, T end, T stepSize) : m_start(start), m_end(end), m_stepSize(stepSize) {
                assert(start < end);
        }
        template <class T>
        ParallelParameterIterator<T>::ParallelParameterIterator(const ParallelParameterIterator& other) : m_start(other.m_start), m_end(other.m_end), m_stepSize(other.m_stepSize), m_targets(other.m_targets) {

        }
        template <class T>
        void ParallelParameterIterator<T>::Next() {
                assert(HasNext());
                typename std::vector<T* >::iterator it;
                for (it = m_targets.begin(); it != m_targets.end(); it++) {
                        (*(*it)) += m_stepSize;
                }
        }
        template <class T>
        bool ParallelParameterIterator<T>::HasNext() {
                typename std::vector<T*>::iterator it;
                for (it = m_targets.begin(); it != m_targets.end(); it++) {
                        if ((*(*it)) >= m_end) {
                                return false;
                        }
                }
                return true;
        }
        template <class T>
        void ParallelParameterIterator<T>::Reset() {
                typename std::vector<T*>::iterator it;
                for (it = m_targets.begin(); it != m_targets.end(); it++) {
                        (*(*it)) = m_start;
                }
        }
        template <class T>
        void ParallelParameterIterator<T>::PrintValue() {
                typename std::vector<T*>::iterator it;
                for (it = m_targets.begin(); it != m_targets.end(); it++) {
                        std::cout<<(*(*it))<<", ";
                }
        }

        template <class T>
        void ParallelParameterIterator<T>::Add(T* target) {
                m_targets.push_back(target);
        }

} //namespace face_contour_detector

#endif /* FACE_CONTOUR_DETECTOR_PARAMETERITERATOR_H_ */