sip/resiprocate/ParserContainer.hxx

#ifndef RESIP_ParserContainer_hxx
#define RESIP_ParserContainer_hxx

#include "resiprocate/HeaderFieldValueList.hxx"
#include "resiprocate/ParserContainerBase.hxx"

namespace resip
{

template<class T>
class ParserContainer : public ParserContainerBase
{
   public:
      typedef T value_type;
      typedef value_type* pointer;
      typedef const value_type* const_pointer;
      typedef value_type& reference;
      typedef const value_type& const_reference;
      typedef ptrdiff_t difference_type;

      ParserContainer()
         : ParserContainerBase(Headers::UNKNOWN)
      {}
      
      // private to SipMessage
      ParserContainer(HeaderFieldValueList* hfvs,
                      Headers::Type type = Headers::UNKNOWN)
         : ParserContainerBase(type)
      {
         for (HeaderFieldValueList::iterator i = hfvs->begin();
              i != hfvs->end(); i++)
         {
            // create, store without copying -- 
            // keeps the HeaderFieldValue from reallocating its buffer
            mParsers.push_back(new T(*i, type));
         }
      }

      ParserContainer(const ParserContainer& other)
         : ParserContainerBase(other)
      {}

      ParserContainer& operator=(const ParserContainer& other)
      {
         return static_cast<ParserContainer&>(ParserContainerBase::operator=(other));
      }
      
      T& front() { return *static_cast<T*>(mParsers.front());}
      T& back() { return *static_cast<T*>(mParsers.back());}
      const T& front() const { return *static_cast<T*>(mParsers.front());}
      const T& back() const { return *static_cast<T*>(mParsers.back());}
      
      void push_front(const T & t) { mParsers.insert(mParsers.begin(), new T(t)); }
      void push_back(const T & t) { mParsers.push_back(new T(t)); }
            
      ParserContainer reverse() const
      {
         ParserContainer tmp(*this);
         std::reverse(tmp.mParsers.begin(), tmp.mParsers.end());
         return tmp;
      }

      // .dlb. these can be partially hoisted as well
      class const_iterator;
      
      class iterator
      {
         public:
            iterator(typename std::vector<ParserCategory*>::iterator i) : mIt(i){}
            iterator() {}

            iterator operator++() {iterator it(++mIt); return it;}
            iterator operator++(int) {iterator it(mIt++); return it;}
            iterator operator--() {iterator it(--mIt); return it;}
            iterator operator--(int) {iterator it(mIt--); return it;}
            bool operator!=(const iterator& rhs) { return mIt != rhs.mIt; }
            bool operator==(const iterator& rhs) { return mIt == rhs.mIt; }
            bool operator!=(const const_iterator& rhs) { return mIt != rhs.mIt; }
            bool operator==(const const_iterator& rhs) { return mIt == rhs.mIt; }
            iterator& operator=(const iterator& rhs) { mIt = rhs.mIt; return *this;}
            T& operator*() {return *static_cast<T*>(*mIt);}
            T* operator->() {return static_cast<T*>(*mIt);}
         private:
            typename std::vector<ParserCategory*>::iterator mIt;
            friend class const_iterator;
            friend class ParserContainer;
      };

      class const_iterator
      {
         public:
            const_iterator(std::vector<ParserCategory*>::const_iterator i) : mIt(i) {}
            const_iterator() {}

            const_iterator operator++() {const_iterator it(++mIt); return it;}
            const_iterator operator++(int) {const_iterator it(mIt++); return it;}
            const_iterator operator--() {const_iterator it(--mIt); return it;}
            const_iterator operator--(int) {const_iterator it(mIt--); return it;}
            bool operator!=(const const_iterator& rhs) { return mIt != rhs.mIt; }
            bool operator==(const const_iterator& rhs) { return mIt == rhs.mIt; }
            bool operator!=(const iterator& rhs) { return mIt != rhs.mIt; }
            bool operator==(const iterator& rhs) { return mIt == rhs.mIt; }
            const_iterator& operator=(const const_iterator& rhs) { mIt = rhs.mIt; return *this;}
            const_iterator& operator=(const iterator& rhs) { mIt = rhs.mIt; return *this;}
            const T& operator*() {return *static_cast<T*>(*mIt);}
            const T* operator->() {return static_cast<T*>(*mIt);}
         private:
            friend class iterator;
            typename std::vector<ParserCategory*>::const_iterator mIt;
      };
      
      iterator begin() { return iterator(mParsers.begin()); }
      iterator end() { return iterator(mParsers.end()); }

      iterator erase(iterator i)
      {
         delete *i.mIt;
         return iterator(mParsers.erase(i.mIt));
      }

      bool find(const T& rhs) const
      {
         for (typename std::vector<ParserCategory*>::const_iterator i = mParsers.begin();
              i != mParsers.end(); ++i)
         {
            // operator== defined by default, but often not usefully
            if (rhs.isEqual(*static_cast<T*>(*i)))
            {
               return true;
            }
         }

         return false;
      }

      const_iterator begin() const { return const_iterator(mParsers.begin()); }
      const_iterator end() const { return const_iterator(mParsers.end()); }

      virtual ParserContainerBase* clone() const
      {
         return new ParserContainer(*this);
      }
};
 
}

#endif

/* ====================================================================
 * The Vovida Software License, Version 1.0 
 * 
 * Copyright (c) 2000-2005
 * 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 * 
 * 3. The names "VOCAL", "Vovida Open Communication Application Library",
 *    and "Vovida Open Communication Application Library (VOCAL)" must
 *    not be used to endorse or promote products derived from this
 *    software without prior written permission. For written
 *    permission, please contact vocal@vovida.org.
 *
 * 4. Products derived from this software may not be called "VOCAL", nor
 *    may "VOCAL" appear in their name, without prior written
 *    permission of Vovida Networks, Inc.
 * 
 * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESSED OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE AND
 * NON-INFRINGEMENT ARE DISCLAIMED.  IN NO EVENT SHALL VOVIDA
 * NETWORKS, INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT DAMAGES
 * IN EXCESS OF $1,000, NOR FOR ANY INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
 * DAMAGE.
 * 
 * ====================================================================
 * 
 * This software consists of voluntary contributions made by Vovida
 * Networks, Inc. and many individuals on behalf of Vovida Networks,
 * Inc.  For more information on Vovida Networks, Inc., please see
 * <http://www.vovida.org/>.
 *
 */
1	#ifndef RESIP_ParserContainer_hxx
2	#define RESIP_ParserContainer_hxx
3
4	#include "resiprocate/HeaderFieldValueList.hxx"
5	#include "resiprocate/ParserContainerBase.hxx"
6
7	namespace resip
8	{
9
10	template<class T>
11	class ParserContainer : public ParserContainerBase
12	{
13	public:
14	typedef T value_type;
15	typedef value_type* pointer;
16	typedef const value_type* const_pointer;
17	typedef value_type& reference;
18	typedef const value_type& const_reference;
19	typedef ptrdiff_t difference_type;
20
21	ParserContainer()
22	: ParserContainerBase(Headers::UNKNOWN)
23	{}
24
25	// private to SipMessage
26	ParserContainer(HeaderFieldValueList* hfvs,
27	Headers::Type type = Headers::UNKNOWN)
28	: ParserContainerBase(type)
29	{
30	for (HeaderFieldValueList::iterator i = hfvs->begin();
31	i != hfvs->end(); i++)
32	{
33	// create, store without copying --
34	// keeps the HeaderFieldValue from reallocating its buffer
35	mParsers.push_back(new T(*i, type));
36	}
37	}
38
39	ParserContainer(const ParserContainer& other)
40	: ParserContainerBase(other)
41	{}
42
43	ParserContainer& operator=(const ParserContainer& other)
44	{
45	return static_cast<ParserContainer&>(ParserContainerBase::operator=(other));
46	}
47
48	T& front() { return static_cast<T>(mParsers.front());}
49	T& back() { return static_cast<T>(mParsers.back());}
50	const T& front() const { return static_cast<T>(mParsers.front());}
51	const T& back() const { return static_cast<T>(mParsers.back());}
52
53	void push_front(const T & t) { mParsers.insert(mParsers.begin(), new T(t)); }
54	void push_back(const T & t) { mParsers.push_back(new T(t)); }
55
56	ParserContainer reverse() const
57	{
58	ParserContainer tmp(*this);
59	std::reverse(tmp.mParsers.begin(), tmp.mParsers.end());
60	return tmp;
61	}
62
63	// .dlb. these can be partially hoisted as well
64	class const_iterator;
65
66	class iterator
67	{
68	public:
69	iterator(typename std::vector<ParserCategory*>::iterator i) : mIt(i){}
70	iterator() {}
71
72	iterator operator++() {iterator it(++mIt); return it;}
73	iterator operator++(int) {iterator it(mIt++); return it;}
74	iterator operator--() {iterator it(--mIt); return it;}
75	iterator operator--(int) {iterator it(mIt--); return it;}
76	bool operator!=(const iterator& rhs) { return mIt != rhs.mIt; }
77	bool operator==(const iterator& rhs) { return mIt == rhs.mIt; }
78	bool operator!=(const const_iterator& rhs) { return mIt != rhs.mIt; }
79	bool operator==(const const_iterator& rhs) { return mIt == rhs.mIt; }
80	iterator& operator=(const iterator& rhs) { mIt = rhs.mIt; return *this;}
81	T& operator() {return static_cast<T>(mIt);}
82	T* operator->() {return static_cast<T>(mIt);}
83	private:
84	typename std::vector<ParserCategory*>::iterator mIt;
85	friend class const_iterator;
86	friend class ParserContainer;
87	};
88
89	class const_iterator
90	{
91	public:
92	const_iterator(std::vector<ParserCategory*>::const_iterator i) : mIt(i) {}
93	const_iterator() {}
94
95	const_iterator operator++() {const_iterator it(++mIt); return it;}
96	const_iterator operator++(int) {const_iterator it(mIt++); return it;}
97	const_iterator operator--() {const_iterator it(--mIt); return it;}
98	const_iterator operator--(int) {const_iterator it(mIt--); return it;}
99	bool operator!=(const const_iterator& rhs) { return mIt != rhs.mIt; }
100	bool operator==(const const_iterator& rhs) { return mIt == rhs.mIt; }
101	bool operator!=(const iterator& rhs) { return mIt != rhs.mIt; }
102	bool operator==(const iterator& rhs) { return mIt == rhs.mIt; }
103	const_iterator& operator=(const const_iterator& rhs) { mIt = rhs.mIt; return *this;}
104	const_iterator& operator=(const iterator& rhs) { mIt = rhs.mIt; return *this;}
105	const T& operator() {return static_cast<T>(mIt);}
106	const T* operator->() {return static_cast<T>(mIt);}
107	private:
108	friend class iterator;
109	typename std::vector<ParserCategory*>::const_iterator mIt;
110	};
111
112	iterator begin() { return iterator(mParsers.begin()); }
113	iterator end() { return iterator(mParsers.end()); }
114
115	iterator erase(iterator i)
116	{
117	delete *i.mIt;
118	return iterator(mParsers.erase(i.mIt));
119	}
120
121	bool find(const T& rhs) const
122	{
123	for (typename std::vector<ParserCategory*>::const_iterator i = mParsers.begin();
124	i != mParsers.end(); ++i)
125	{
126	// operator== defined by default, but often not usefully
127	if (rhs.isEqual(static_cast<T>(*i)))
128	{
129	return true;
130	}
131	}
132
133	return false;
134	}
135
136	const_iterator begin() const { return const_iterator(mParsers.begin()); }
137	const_iterator end() const { return const_iterator(mParsers.end()); }
138
139	virtual ParserContainerBase* clone() const
140	{
141	return new ParserContainer(*this);
142	}
143	};
144
145	}
146
147	#endif
148
149	/* ====================================================================
150	* The Vovida Software License, Version 1.0
151	*
152	* Copyright (c) 2000-2005
153	*
154	* Redistribution and use in source and binary forms, with or without
155	* modification, are permitted provided that the following conditions
156	* are met:
157	*
158	* 1. Redistributions of source code must retain the above copyright
159	* notice, this list of conditions and the following disclaimer.
160	*
161	* 2. Redistributions in binary form must reproduce the above copyright
162	* notice, this list of conditions and the following disclaimer in
163	* the documentation and/or other materials provided with the
164	* distribution.
165	*
166	* 3. The names "VOCAL", "Vovida Open Communication Application Library",
167	* and "Vovida Open Communication Application Library (VOCAL)" must
168	* not be used to endorse or promote products derived from this
169	* software without prior written permission. For written
170	* permission, please contact vocal@vovida.org.
171	*
172	* 4. Products derived from this software may not be called "VOCAL", nor
173	* may "VOCAL" appear in their name, without prior written
174	* permission of Vovida Networks, Inc.
175	*
176	* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESSED OR IMPLIED
177	* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
178	* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE AND
179	* NON-INFRINGEMENT ARE DISCLAIMED. IN NO EVENT SHALL VOVIDA
180	* NETWORKS, INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT DAMAGES
181	* IN EXCESS OF $1,000, NOR FOR ANY INDIRECT, INCIDENTAL, SPECIAL,
182	* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
183	* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
184	* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
185	* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
186	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
187	* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
188	* DAMAGE.
189	*
190	* ====================================================================
191	*
192	* This software consists of voluntary contributions made by Vovida
193	* Networks, Inc. and many individuals on behalf of Vovida Networks,
194	* Inc. For more information on Vovida Networks, Inc., please see
195	* <http://www.vovida.org/>.
196	*
197	*/
webmaster AT resiprocate DOT org	ViewVC Help
Powered by ViewVC 1.1.27