//==========================================================================;
//
// fwdseq.h : forward sequence infrastructure to extend the dshow stuff so that it
// works nicely from c++
// Copyright (c) Microsoft Corporation 1995-1999.
//
/////////////////////////////////////////////////////////////////////////////

#pragma once

#ifndef FWDSEQ_H
#define FWDSEQ_H

#include <arity.h>

template<class Base, class Enumerator_Type, class Value_Type,
         class Base_Inner = Base,
         class Enumerator_Type_Inner = Enumerator_Type,
         class Value_Type_Inner = Value_Type,
         class Allocator = typename Value_Type::stl_allocator>  class Forward_Sequence;

// NOTE: all of this stuff with the indirected static templated functions for fetch, reset, next
// is to get around an assortment of compiler bugs.
// a) you can't have a pointer to a member function as a template parm if it references earlier template parms
// b) in the initializations of these fetch,reset,next functions if we globally initialize the
// constructor isn't getting called and the vtable isn't set up.  hence we create them off the
// heap at runtime.

// enumerator_iterator
// this is an stl based forward iterator for dealing with legacy com enumerators with no prev method
template<
    class Enumerator_Type,
    class Value_Type,
    class Enumerator_Type_Inner = Enumerator_Type,
    class Value_Type_Inner = Value_Type,
    class difference_type = ptrdiff_t
    > class enumerator_iterator : public std::iterator<std::forward_iterator_tag, Value_Type, difference_type> {
public:
    // these are for com enumerators so use __stdcall version of binders
    static std_arity0pmf<Enumerator_Type_Inner, HRESULT> *Reset;
    static std_arity1pmf<Enumerator_Type_Inner, Value_Type_Inner *, HRESULT> *Next;

        inline enumerator_iterator(const Enumerator_Type e = Enumerator_Type(), const Value_Type c = Value_Type()) : enumerator_state(e), current_value(c) {
                if (enumerator_state != NULL) {
                        if (!current_value) {
#ifdef FORWARD_TRACE
                TRACELM(TRACE_PAINT, "enumerator_iterator constructor, attempting reset");
#endif
                                Enumerator_Type_Inner *peti = enumerator_state;
                                HRESULT hr = (*Reset)(*peti);
                                if (SUCCEEDED(hr)) {
                                        Value_Type temp_val;
#ifdef FORWARD_TRACE
                    TRACELM(TRACE_PAINT, "enumerator_iterator constructor, attempting next()");
#endif
                                        hr = (*Next)(*peti, &temp_val);
                                        if (SUCCEEDED(hr) && hr != S_FALSE) {
                                                current_value = temp_val;
#ifdef FORWARD_TRACE
                                                TRACELSM(TRACE_PAINT, (dbgDump << "enumerator_iterator constructor, set to first value = " << current_value), "");
#endif
                                        }
#ifdef FORWARD_TRACE
                                TRACELSM(TRACE_PAINT, (dbgDump << "enumerator_iterator constructor, next() hr = " << hr), "");
#endif
                                }
                        }
                } else {
                        current_value = Value_Type();
                }
#ifdef FORWARD_TRACE
        TRACELM(TRACE_PAINT, "enumerator_iterator constructor complete");
#endif
        }
        inline enumerator_iterator(const enumerator_iterator &e) : enumerator_state(e.enumerator_state), current_value(e.current_value) {}

        inline Value_Type operator*() const     { return current_value; }
        inline enumerator_iterator& operator++() {
                if (enumerator_state) {
                        Value_Type temp_val;
                        Enumerator_Type_Inner *peti = enumerator_state;
                        HRESULT hr = (*Next)(*peti, &temp_val);
                        if (SUCCEEDED(hr) && (hr != S_FALSE)) {
                                current_value = temp_val;
                        } else {
                                current_value = Value_Type();
                        }
                } else {
                        current_value = Value_Type();
                }
                return (*this);
        }
        inline enumerator_iterator operator++(int)      {
                enumerator_iterator Tmp = *this;
                ++*this;
                return (Tmp);
        }
        inline enumerator_iterator& operator=(const enumerator_iterator &e) {
                if (&e != this) {
                        enumerator_state = e.enumerator_state;
                        current_value = e.current_value;
                }
                return *this;
        }
        inline bool operator==(const enumerator_iterator& e) const {
#ifdef FORWARD_TRACE
                TRACELSM(TRACE_PAINT, (dbgDump << "enumerator_iterator operator==() current_value = " << current_value << " e.current_value = " << e.current_value), "");
#endif
                return (current_value == e.current_value);
        }
        inline bool operator!=(const enumerator_iterator& e) const
                {return (!(*this == e)); }
        inline Value_Type CurrentValue() const
                {return current_value; }
        protected:
                Enumerator_Type enumerator_state;
                Value_Type current_value;
};

// const_enumerator_iterator
template<class Enumerator_Type, class Value_Type,
                 class Enumerator_Type_Inner = Enumerator_Type,
                 class Value_Type_Inner = Value_Type,
                 class difference_type = ptrdiff_t> class const_enumerator_iterator :
                        public enumerator_iterator<Enumerator_Type, 
                                                   Value_Type,                                                                           
                                                   Enumerator_Type_Inner, 
                                                   Value_Type_Inner, 
                                                   difference_type> {
public:
        inline const_enumerator_iterator(const Enumerator_Type e = Enumerator_Type(), const Value_Type c = Value_Type()) :
                enumerator_iterator<Enumerator_Type, 
                                    Value_Type,
                                    Enumerator_Type_Inner, 
                                    Value_Type_Inner, 
                                    difference_type>(e, c) {}
        inline const_enumerator_iterator(const enumerator_iterator<Enumerator_Type, 
                                                                   Value_Type,
                                                                   Enumerator_Type_Inner,
                                                                   Value_Type_Inner, 
                                                                   difference_type> &e) :
                enumerator_iterator<Enumerator_Type, 
                                    Value_Type,
                                    Enumerator_Type_Inner, 
                                    Value_Type_Inner, 
                                    difference_type>(e) {}
        inline const_enumerator_iterator(const const_enumerator_iterator &e) :
                        enumerator_iterator<Enumerator_Type, 
                                            Value_Type,
                                            Enumerator_Type_Inner, 
                                            Value_Type_Inner, 
                                            difference_type>(e) {}
        inline const Value_Type operator*() const {
        return enumerator_iterator<Enumerator_Type, 
                                   Value_Type,
                                   Enumerator_Type_Inner,
                                   Value_Type_Inner, 
                                   difference_type>::operator*(); }
        inline const_enumerator_iterator& operator=(const const_enumerator_iterator &e) {
                if (&e != this) {
                        enumerator_iterator<Enumerator_Type, 
                                            Value_Type,
                                            Enumerator_Type_Inner,
                                            Value_Type_Inner, 
                                            difference_type>::operator=(e);
                }
                return *this;
        }
};

// this is a stl based template for containing legacy com collections
// this is *almost* a standard stl sequence container class.  the reason its
// not a complete sequence container is because for many of the com enumerators we have no prev method
// and therefore, no efficient way of reverse iterating through the collection.
// so we can't provide a bidirectional iterator only a forward one.
// call this a forward sequence container if you will

// Base is smart pointer wrapper class being contained in this container
// Base_Inner is actual wrapped class that the smart pointer class contains(usually com IXXX).
// if you're making a forward_sequence out of some ordinary class instead of a smart pointer class
// then use the default and make both Base_Inner == Base
template<
    class Base,
    class Enumerator_Type,
    class Value_Type,
    class Base_Inner /*= Base */,
    class Enumerator_Type_Inner /*= Enumerator_Type */,
    class Value_Type_Inner /*= Value_Type */,
    class Allocator /*= Value_Type::stl_allocator */
>  class Forward_Sequence : public Base {
public:

    Forward_Sequence(REFCLSID rclsid, LPUNKNOWN pUnkOuter = NULL, DWORD dwClsContext = CLSCTX_ALL) : Base(rclsid, pUnkOuter, dwClsContext) {}
    virtual ~Forward_Sequence() {}

    typedef typename Allocator::value_type value_type;
        typedef typename Allocator::value_type& reference;
        typedef const typename Allocator::value_type& const_reference;
        typedef typename Allocator::size_type size_type;
        typedef typename Allocator::difference_type difference_type;



    // the compiler doesn't recognize this typedef in this template.  but, derived classes
    // can refer to it.
    typedef std_arity1pmf<Base_Inner, Enumerator_Type_Inner **, HRESULT> FetchType;

    static FetchType* Fetch;

    virtual FetchType* GetFetch() const {
        return Fetch;
    }

        typedef enumerator_iterator<Enumerator_Type, 
                                    Value_Type, 
                                    Enumerator_Type_Inner, 
                                    Value_Type_Inner, 
                                    difference_type> iterator;
        friend iterator;

        typedef const_enumerator_iterator<Enumerator_Type, 
                                          Value_Type, 
                                          Enumerator_Type_Inner, 
                                          Value_Type_Inner, 
                                          difference_type> const_iterator;
        friend const_iterator;

        Forward_Sequence() {}
        Forward_Sequence(const Forward_Sequence &a) : Base(a) { }
        Forward_Sequence(const Base &a) : Base(a) {}
        Forward_Sequence(Base_Inner *p) : Base(p) {}
		Forward_Sequence(IUnknown *p) : Base(p) {}
        iterator begin() {
                Enumerator_Type temp_enum;
                if (!(*this)) {
                    return iterator();
                }
#ifdef FORWARD_TRACE
        TRACELM(TRACE_DETAIL, "iterator ForwardSequence::begin() attempting fetch");
#endif
        Base_Inner *peti = *this;
        HRESULT hr = (*(GetFetch()))(*peti, &temp_enum);
                if (SUCCEEDED(hr)) {
#ifdef FORWARD_TRACE
            TRACELM(TRACE_DETAIL, "iterator ForwardSequence::begin() fetch succeeded");
#endif
                        return iterator(temp_enum);
                } else {
#ifdef FORWARD_TRACE
            TRACELM(TRACE_DETAIL, "iterator ForwardSequence::begin() fetch failed");
#endif
                        return iterator();
                }
        }
        const_iterator begin() const {
                Enumerator_Type temp_enum;
#ifdef FORWARD_TRACE
        TRACELM(TRACE_DETAIL, "const_iterator ForwardSequence::begin() attempting fetch");
#endif
        Base_Inner *peti = *this;
                HRESULT hr = (*(GetFetch()))(*peti, &temp_enum);
                if (SUCCEEDED(hr)) {
#ifdef FORWARD_TRACE
            TRACELM(TRACE_DETAIL, "const_iterator ForwardSequence::begin() fetch succeeded");
#endif
            return iterator(temp_enum);
                } else {
#ifdef FORWARD_TRACE
            TRACELM(TRACE_DETAIL, "const_iterator ForwardSequence::begin() fetch failed");
#endif
                        return iterator();
                }
        }

        iterator end() {
#ifdef FORWARD_TRACE
            TRACELM(TRACE_DETAIL, "iterator ForwardSequence::end()");
#endif
            return iterator();
        }
        const_iterator end() const { return const_iterator(); }

};


#endif
// end of file fwdseq.h