mapiter.h

来自「Data Replication Prototype Using ADO」· C头文件 代码 · 共 856 行 · 第 1/3 页

typename tspmap<KEY,VALUE>::iterator
    tsp_end(CTypedPtrMap<CMapStringToPtr,KEY,VALUE> &) 
    {
    return tspmap<KEY,VALUE>::iterator();
    }


////////////////////////////////////////////////////////////////////////////////
// twomap definition/implementation
// iterator containing struct used with MFC's CTypedPtrMap<CMapWordToOb> template.
// The accessor functions are all named two_[function] to deal with an internal
// compiler error discussed in the comments at the top of the file.
template<class KEY, class VALUE>
struct twomap : public base_map<KEY, VALUE, CTypedPtrMap<CMapWordToOb, KEY, VALUE> >
    {
private:
    twomap();   // not constructable
    };

    // twomap<> returning freestanding functions
template<class KEY,class VALUE>
typename twomap<KEY,VALUE>::const_iterator
    two_begin(const CTypedPtrMap<CMapWordToOb,KEY,VALUE> &mp) 
    {
    return twomap<KEY,VALUE>::const_iterator(mp);
    }
template<class KEY,class VALUE>
typename twomap<KEY,VALUE>::iterator
    two_begin(CTypedPtrMap<CMapWordToOb,KEY,VALUE> &mp) 
    {
    return twomap<KEY,VALUE>::iterator(mp);
    }
template<class KEY,class VALUE>
typename twomap<KEY,VALUE>::const_iterator
    two_end(const CTypedPtrMap<CMapWordToOb,KEY,VALUE> &) 
    {
    return twomap<KEY,VALUE>::const_iterator();
    }
template<class KEY,class VALUE>
typename twomap<KEY,VALUE>::iterator
    two_end(CTypedPtrMap<CMapWordToOb,KEY,VALUE> &) 
    {
    return twomap<KEY,VALUE>::iterator();
    }


////////////////////////////////////////////////////////////////////////////////
// twpmap definition/implementation
// iterator containing struct used with MFC's CTypedPtrMap<CMapWordToPtr> template.
// The accessor functions are all named twp_[function] to deal with an internal
// compiler error discussed in the comments at the top of the file.
template<class KEY, class VALUE>
struct twpmap : public base_map<KEY, VALUE, CTypedPtrMap<CMapWordToPtr, KEY, VALUE> >
    {
private:
    twpmap();   // not constructable
    };

    // twpmap<> returning freestanding functions
template<class KEY,class VALUE>
typename twpmap<KEY,VALUE>::const_iterator
    twp_begin(const CTypedPtrMap<CMapWordToPtr,KEY,VALUE> &mp) 
    {
    return twpmap<KEY,VALUE>::const_iterator(mp);
    }
template<class KEY,class VALUE>
typename twpmap<KEY,VALUE>::iterator
    twp_begin(CTypedPtrMap<CMapWordToPtr,KEY,VALUE> &mp) 
    {
    return twpmap<KEY,VALUE>::iterator(mp);
    }
template<class KEY,class VALUE>
typename twpmap<KEY,VALUE>::const_iterator
    twp_end(const CTypedPtrMap<CMapWordToPtr,KEY,VALUE> &) 
    {
    return twpmap<KEY,VALUE>::const_iterator();
    }
template<class KEY,class VALUE>
typename twpmap<KEY,VALUE>::iterator
    twp_end(CTypedPtrMap<CMapWordToPtr,KEY,VALUE> &) 
    {
    return twpmap<KEY,VALUE>::iterator();
    }


////////////////////////////////////////////////////////////////////////////////
// ppmap definition/implementation
// iterator containing struct used with MFC's CMapPtrToPtr container
struct ppmap : public base_map<void *, void *, CMapPtrToPtr>
    {
private:
    ppmap();    // not constructable
    };

    // ppmap returning freestanding functions
ppmap::const_iterator begin(const CMapPtrToPtr &mp)
    {
    return ppmap::const_iterator(mp);
    }
ppmap::iterator begin(CMapPtrToPtr &mp)
    {
    return ppmap::iterator(mp);
    }
ppmap::const_iterator end(const CMapPtrToPtr &)
    {
    return ppmap::const_iterator();
    }
ppmap::iterator end(CMapPtrToPtr &)
    {
    return ppmap::iterator();
    }


////////////////////////////////////////////////////////////////////////////////
// pwmap definition/implementation
// iterator containing struct used with MFC's CMapPtrToWord container
struct pwmap : public base_map<void *, WORD, CMapPtrToWord>
    {
private:
    pwmap();    // not constructable
    };

    // pwmap returning freestanding functions
pwmap::const_iterator begin(const CMapPtrToWord &mp)
    {
    return pwmap::const_iterator(mp);
    }
pwmap::iterator begin(CMapPtrToWord &mp)
    {
    return pwmap::iterator(mp);
    }
pwmap::const_iterator end(const CMapPtrToWord &)
    {
    return pwmap::const_iterator();
    }
pwmap::iterator end(CMapPtrToWord &)
    {
    return pwmap::iterator();
    }


////////////////////////////////////////////////////////////////////////////////
// somap definition/implementation
// iterator containing struct used with MFC's CMapStringToOb container
struct somap : public base_map<CString, CObject *, CMapStringToOb>
    {
private:
    somap();    // not constructable
    };

    // somap returning freestanding functions
somap::const_iterator begin(const CMapStringToOb &mp)
    {
    return somap::const_iterator(mp);
    }
somap::iterator begin(CMapStringToOb &mp)
    {
    return somap::iterator(mp);
    }
somap::const_iterator end(const CMapStringToOb &)
    {
    return somap::const_iterator();
    }
somap::iterator end(CMapStringToOb &)
    {
    return somap::iterator();
    }


////////////////////////////////////////////////////////////////////////////////
// spmap definition/implementation
// iterator containing struct used with MFC's CMapStringToPtr container
struct spmap : public base_map<CString, void *, CMapStringToPtr>
    {
private:
    spmap();    // not constructable
    };

    // spmap returning freestanding functions
spmap::const_iterator begin(const CMapStringToPtr &mp)
    {
    return spmap::const_iterator(mp);
    }
spmap::iterator begin(CMapStringToPtr &mp)
    {
    return spmap::iterator(mp);
    }
spmap::const_iterator end(const CMapStringToPtr &)
    {
    return spmap::const_iterator();
    }
spmap::iterator end(CMapStringToPtr &)
    {
    return spmap::iterator();
    }


////////////////////////////////////////////////////////////////////////////////
// ssmap definition/implementation
// iterator containing struct used with MFC's CMapStringToString container
struct ssmap : public base_map<CString, CString, CMapStringToString>
    {
private:
    ssmap();    // not constructable
    };

    // ssmap returning freestanding functions
ssmap::const_iterator begin(const CMapStringToString &mp)
    {
    return ssmap::const_iterator(mp);
    }
ssmap::iterator begin(CMapStringToString &mp)
    {
    return ssmap::iterator(mp);
    }
ssmap::const_iterator end(const CMapStringToString &)
    {
    return ssmap::const_iterator();
    }
ssmap::iterator end(CMapStringToString &)
    {
    return ssmap::iterator();
    }


////////////////////////////////////////////////////////////////////////////////
// womap definition/implementation
// iterator containing struct used with MFC's CMapWordToOb container
struct womap : public base_map<WORD, CObject *, CMapWordToOb>
    {
private:
    womap();    // not constructable
    };

    // womap returning freestanding functions
womap::const_iterator begin(const CMapWordToOb &mp)
    {
    return womap::const_iterator(mp);
    }
womap::iterator begin(CMapWordToOb &mp)
    {
    return womap::iterator(mp);
    }
womap::const_iterator end(const CMapWordToOb &)
    {
    return womap::const_iterator();
    }
womap::iterator end(CMapWordToOb &)
    {
    return womap::iterator();
    }


////////////////////////////////////////////////////////////////////////////////
// wpmap definition/implementation
// iterator containing struct used with MFC's CMapWordToPtr container
struct wpmap : public base_map<WORD, void *, CMapWordToPtr>
    {
private:
    wpmap();    // not constructable
    };

    // wpmap returning freestanding functions
wpmap::const_iterator begin(const CMapWordToPtr &mp)
    {
    return wpmap::const_iterator(mp);
    }
wpmap::iterator begin(CMapWordToPtr &mp)
    {
    return wpmap::iterator(mp);
    }
wpmap::const_iterator end(const CMapWordToPtr &)
    {
    return wpmap::const_iterator();
    }
wpmap::iterator end(CMapWordToPtr &)
    {
    return wpmap::iterator();
    }

}   // end namespace mfciter

#endif  // _INC_MFCITER_MAPITER_H_