X-Git-Url: http://g0dil.de/git?a=blobdiff_plain;f=Packets%2FParseVec.cti;h=14ac2d648093e5e8e5661ae843a5e0367e7632ac;hb=81ffa1c459b96dd44472bcef37e1e373934ee138;hp=bf4f7a9253f792fd83cb5f02b7c37af017ed057f;hpb=85ab07d100a382467a42e19d741d403a7a96c951;p=senf.git

diff --git a/Packets/ParseVec.cti b/Packets/ParseVec.cti
index bf4f7a9..14ac2d6 100644
--- a/Packets/ParseVec.cti
+++ b/Packets/ParseVec.cti
@@ -20,201 +20,368 @@
 // Free Software Foundation, Inc.,
 // 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 
-// Definition of inline template functions
+/** \file
+    \brief ParseVec inline template implementation */
 
-//#include "ParseVec.ih"
+#include "ParseVec.ih"
 
 // Custom includes
 
 #define prefix_ inline
 ///////////////////////////////cti.p///////////////////////////////////////
 
-template <class Parser, class SizeParser, class Iterator, class IPacket>
-prefix_ senf::Parse_Vector<Parser,SizeParser,Iterator,IPacket>::
-Parse_Vector(SizeParser const & size)
-    : size_(size)
+///////////////////////////////////////////////////////////////////////////
+// senf::Parse_Vector<ElementParser,Sizer>
+
+template <class ElementParser, class Sizer>
+prefix_ senf::Parse_Vector<ElementParser,Sizer>::Parse_Vector(data_iterator i, state_type s)
+    : PacketParserBase(i,s), sizer_()
 {}
 
-template <class Parser, class SizeParser, class Iterator, class IPacket>
-prefix_ senf::Parse_Vector<Parser,SizeParser,Iterator,IPacket>::
-Parse_Vector(size_parser const & size, Iterator const & i)
-    : ParserBase<Iterator,IPacket>(i), size_(size)
+template <class ElementParser, class Sizer>
+prefix_ senf::Parse_Vector<ElementParser,Sizer>::Parse_Vector(Sizer sizer, data_iterator i,
+                                                              state_type s)
+    : PacketParserBase(i,s), sizer_(sizer)
 {}
 
-template <class Parser, class SizeParser, class Iterator, class IPacket>
-prefix_ unsigned senf::Parse_Vector<Parser,SizeParser,Iterator,IPacket>::bytes()
+template <class ElementParser, class Sizer>
+prefix_ typename senf::Parse_Vector<ElementParser,Sizer>::size_type
+senf::Parse_Vector<ElementParser,Sizer>::bytes()
     const
 {
-    return Parser::bytes()*size();
+    return size()*ElementParser::fixed_bytes + sizer_.bytes(i(),state());
 }
 
-template <class Parser, class SizeParser, class Iterator, class IPacket>
-prefix_ void
-senf::Parse_Vector<Parser,SizeParser,Iterator,IPacket>::check(Iterator const & e)
+// Container interface
+
+template <class ElementParser, class Sizer>
+prefix_ typename senf::Parse_Vector<ElementParser,Sizer>::size_type
+senf::Parse_Vector<ElementParser,Sizer>::size()
     const
 {
-    return e-this->i() >= bytes();
+    return sizer_.size(i(),state());
 }
 
-template <class Parser, class SizeParser, class Iterator, class IPacket>
-prefix_ void senf::Parse_Vector<Parser,SizeParser,Iterator,IPacket>::init()
+template <class ElementParser, class Sizer>
+prefix_ bool senf::Parse_Vector<ElementParser,Sizer>::empty()
     const
 {
-    iterator e (end());
-    for (iterator i (begin()); i!=e; ++i) i->init();
+    return size()==0;
 }
 
-///////////////////////////////////////////////////////////////////////////
+template <class ElementParser, class Sizer>
+prefix_ typename senf::Parse_Vector<ElementParser,Sizer>::iterator
+senf::Parse_Vector<ElementParser,Sizer>::begin()
+    const
+{
+    return iterator(sizer_.begin(i(),state()),state());
+}
 
-template <class Parser, class SizeParser, class Iterator, class IPacket>
-prefix_ typename senf::Parse_Vector<Parser,SizeParser,Iterator,IPacket>::size_type
-senf::Parse_Vector<Parser,SizeParser,Iterator,IPacket>::size()
+template <class ElementParser, class Sizer>
+prefix_ typename senf::Parse_Vector<ElementParser,Sizer>::iterator
+senf::Parse_Vector<ElementParser,Sizer>::end()
     const
 {
-    return size_.value();
+    return boost::next(begin(),size());
 }
 
-template <class Parser, class SizeParser, class Iterator, class IPacket>
-prefix_ bool senf::Parse_Vector<Parser,SizeParser,Iterator,IPacket>::empty()
+template <class ElementParser, class Sizer>
+prefix_ typename senf::Parse_Vector<ElementParser,Sizer>::value_type
+senf::Parse_Vector<ElementParser,Sizer>::operator[](difference_type i)
     const
 {
-    return size()==0;
+    return begin()[i];
 }
 
-template <class Parser, class SizeParser, class Iterator, class IPacket>
-prefix_
-typename senf::Parse_Vector<Parser,SizeParser,Iterator,IPacket>::iterator
-senf::Parse_Vector<Parser,SizeParser,Iterator,IPacket>::begin()
+template <class ElementParser, class Sizer>
+prefix_ typename senf::Parse_Vector<ElementParser,Sizer>::value_type
+senf::Parse_Vector<ElementParser,Sizer>::front()
     const
 {
-    return iterator(this->i());
+    return begin()[0];
 }
 
-template <class Parser, class SizeParser, class Iterator, class IPacket>
-prefix_
-typename senf::Parse_Vector<Parser,SizeParser,Iterator,IPacket>::iterator
-senf::Parse_Vector<Parser,SizeParser,Iterator,IPacket>::end()
+template <class ElementParser, class Sizer>
+prefix_ typename senf::Parse_Vector<ElementParser,Sizer>::value_type
+senf::Parse_Vector<ElementParser,Sizer>::back()
     const
 {
-    return iterator(this->i()+bytes());
+    return begin()[size()-1];
 }
 
-template <class Parser, class SizeParser, class Iterator, class IPacket>
-prefix_
-typename senf::Parse_Vector<Parser,SizeParser,Iterator,IPacket>::range_type
-senf::Parse_Vector<Parser,SizeParser,Iterator,IPacket>::range()
+// Mutators
+
+template <class ElementParser, class Sizer>
+template <class Value>
+prefix_ void senf::Parse_Vector<ElementParser,Sizer>::push_back(Value value, size_type n)
     const
 {
-    return std::make_pair(begin(),end());
+    container c (*this);
+    c.push_back(value,n);
 }
 
-template <class Parser, class SizeParser, class Iterator, class IPacket>
-prefix_
-typename senf::Parse_Vector<Parser,SizeParser,Iterator,IPacket>::range_type
-senf::Parse_Vector<Parser,SizeParser,Iterator,IPacket>::value()
+template <class ElementParser, class Sizer>
+prefix_ void senf::Parse_Vector<ElementParser,Sizer>::push_back_space(size_type n)
     const
 {
-    return range();
+    container c (*this);
+    c.push_back_space(n);
 }
 
-template <class Parser, class SizeParser, class Iterator, class IPacket>
-prefix_
-typename senf::Parse_Vector<Parser,SizeParser,Iterator,IPacket>::value_type
-senf::Parse_Vector<Parser,SizeParser,Iterator,IPacket>::operator[](difference_type i)
+template <class ElementParser, class Sizer>
+template <class Value>
+prefix_ void senf::Parse_Vector<ElementParser,Sizer>::push_front(Value value, size_type n)
     const
 {
-    return begin()[i];
+    container c (*this);
+    c.push_front(value,n);
+}
+
+template <class ElementParser, class Sizer>
+prefix_ void senf::Parse_Vector<ElementParser,Sizer>::push_front_space(size_type n)
+    const
+{
+    container c (*this);
+    c.push_front_space(n);
+}
+
+template <class ElementParser, class Sizer>
+prefix_ void senf::Parse_Vector<ElementParser,Sizer>::resize(size_type n)
+    const
+{
+    container c (*this);
+    c.resize(n);
+}
+
+template <class ElementParser, class Sizer>
+template <class Value>
+prefix_ void senf::Parse_Vector<ElementParser,Sizer>::resize(size_type n, Value value)
+    const
+{
+    container c (*this);
+    c.resize(n,value);
 }
 
 ///////////////////////////////////////////////////////////////////////////
+// senf::SimpleSizeParser<SizeParser,offset>
+
+template <class SizeParser>
+prefix_ typename senf::detail::Parse_VectorN_Sizer<SizeParser>::size_type
+senf::detail::Parse_VectorN_Sizer<SizeParser>::size(iterator i, state_type s)
+    const
+{
+    return SizeParser(i,s).value();
+}
+
+template <class SizeParser>
+prefix_ void senf::detail::Parse_VectorN_Sizer<SizeParser>::size(iterator i, state_type s,
+                                                              size_type v)
+    const
+{
+    SizeParser(i,s).value(v);
+}
+
+template <class SizeParser>
+prefix_ typename senf::detail::Parse_VectorN_Sizer<SizeParser>::iterator
+senf::detail::Parse_VectorN_Sizer<SizeParser>::begin(iterator i, state_type s)
+    const
+{
+    return boost::next(i,SizeParser::fixed_bytes);
+}
+
+template <class SizeParser>
+prefix_ typename senf::detail::Parse_VectorN_Sizer<SizeParser>::size_type
+senf::detail::Parse_VectorN_Sizer<SizeParser>::bytes(iterator i, state_type s)
+    const
+{
+    return SizeParser::fixed_bytes;
+}
+
+template <class SizeParser>
+prefix_ void senf::detail::Parse_VectorN_Sizer<SizeParser>::init(iterator i, state_type s)
+    const
+{}
+
+///////////////////////////////////////////////////////////////////////////
 // senf::Parse_Vector_wrapper<Parser,SizeParser,Container>
 
-template <class Parser, class SizeParser, class Container>
-template <class P, class SP, class I, class IP>
-prefix_ senf::Parse_Vector_wrapper<Parser,SizeParser,Container>::
-Parse_Vector_wrapper(Parse_Vector<P,SP,I,IP> const & vector, Container & container)
-    : i_(vector.i()-container.begin()), size_i_(vector.size_.i()-container.begin()),
-      container_(container)
+// structors and default members
+
+// hm ... be careful here ! the data() member is called in an incompletely intitialized
+// instance. However, data() only depends on state_ which is initialized before the call. YOU MUST
+// NOT CHANGE THE ORDERING OF THE DATA MEMBERS
+template <class ElementParser, class Sizer>
+prefix_ senf::Parse_Vector_Container<ElementParser,Sizer>::
+Parse_Vector_Container(parser_type const & vector)
+    : sizer_ (vector.sizer_), state_ (vector.state()), 
+      i_ (std::distance(data().begin(),vector.i()))
 {}
 
-template <class Parser, class SizeParser, class Container>
-prefix_ typename senf::Parse_Vector_wrapper<Parser,SizeParser,Container>::size_type
-senf::Parse_Vector_wrapper<Parser,SizeParser,Container>::size()
+// accessors
+
+template <class ElementParser, class Sizer>
+prefix_ typename senf::Parse_Vector_Container<ElementParser,Sizer>::size_type
+senf::Parse_Vector_Container<ElementParser,Sizer>::size()
     const
 {
-    return SizeParser(container_.begin()+size_i_).value();
+    return sizer_.size(i(),state());
 }
 
-template <class Parser, class SizeParser, class Container>
-prefix_ bool senf::Parse_Vector_wrapper<Parser,SizeParser,Container>::empty()
+template <class ElementParser, class Sizer>
+prefix_ bool senf::Parse_Vector_Container<ElementParser,Sizer>::empty()
     const
 {
     return size() == 0;
 }
 
-template <class Parser, class SizeParser, class Container>
-prefix_ typename senf::Parse_Vector_wrapper<Parser,SizeParser,Container>::iterator
-senf::Parse_Vector_wrapper<Parser,SizeParser,Container>::begin()
+template <class ElementParser, class Sizer>
+prefix_ typename senf::Parse_Vector_Container<ElementParser,Sizer>::iterator
+senf::Parse_Vector_Container<ElementParser,Sizer>::begin()
     const
 {
-    return iterator(container_.begin() + i_);
+    return iterator(sizer_.begin(i(),state()),state());
 }
 
-template <class Parser, class SizeParser, class Container>
-prefix_ typename senf::Parse_Vector_wrapper<Parser,SizeParser,Container>::iterator
-senf::Parse_Vector_wrapper<Parser,SizeParser,Container>::end()
+template <class ElementParser, class Sizer>
+prefix_ typename senf::Parse_Vector_Container<ElementParser,Sizer>::iterator
+senf::Parse_Vector_Container<ElementParser,Sizer>::end()
     const
 {
-    return iterator(container_.begin() + i_ + Parser::bytes()*size());
+    return boost::next(begin(),size());
 }
 
-template <class Parser, class SizeParser, class Container>
-prefix_ typename senf::Parse_Vector_wrapper<Parser,SizeParser,Container>::range_type
-senf::Parse_Vector_wrapper<Parser,SizeParser,Container>::range()
+template <class ElementParser, class Sizer>
+prefix_ typename senf::Parse_Vector_Container<ElementParser,Sizer>::value_type
+senf::Parse_Vector_Container<ElementParser,Sizer>::operator[](difference_type i)
     const
 {
-    return std::make_pair(begin(), end());
+    return begin()[i];
 }
 
-template <class Parser, class SizeParser, class Container>
-prefix_ typename senf::Parse_Vector_wrapper<Parser,SizeParser,Container>::value_type
-senf::Parse_Vector_wrapper<Parser,SizeParser,Container>::operator[](difference_type i)
+template <class ElementParser, class Sizer>
+prefix_ typename senf::Parse_Vector_Container<ElementParser,Sizer>::value_type
+senf::Parse_Vector_Container<ElementParser,Sizer>::front()
     const
 {
-    return begin()[i];
+    return begin()[0];
+}
+
+template <class ElementParser, class Sizer>
+prefix_ typename senf::Parse_Vector_Container<ElementParser,Sizer>::value_type
+senf::Parse_Vector_Container<ElementParser,Sizer>::back()
+    const
+{
+    return begin()[size()-1];
+}
+
+// Mutators
+
+template <class ElementParser, class Sizer>
+template <class Value>
+prefix_ void senf::Parse_Vector_Container<ElementParser,Sizer>::insert(iterator pos,
+                                                                       Value const & t)
+{
+    *shift(pos) << t;
+}
+
+template <class ElementParser, class Sizer>
+prefix_ void senf::Parse_Vector_Container<ElementParser,Sizer>::erase(iterator pos, size_type n)
+{
+    data().erase(pos.raw(),boost::next(pos.raw(),n*ElementParser::fixed_bytes));
+    setSize(size()-n);
+}
+
+template <class ElementParser, class Sizer>
+prefix_ void senf::Parse_Vector_Container<ElementParser,Sizer>::erase(iterator f, iterator l)
+{
+    erase(f,std::distance(f,l));
+}
+
+template <class ElementParser, class Sizer>
+prefix_ void senf::Parse_Vector_Container<ElementParser,Sizer>::clear()
+{
+    erase(begin(),end());
+}
+
+template <class ElementParser, class Sizer>
+template <class Value>
+prefix_ void senf::Parse_Vector_Container<ElementParser,Sizer>::push_back(Value value,
+                                                                          size_type n)
+{
+    insert(end(),n,value);
 }
 
-template <class Parser, class SizeParser, class Container>
-prefix_ void senf::Parse_Vector_wrapper<Parser,SizeParser,Container>::shift(iterator pos,
-                                                                               size_type n)
+template <class ElementParser, class Sizer>
+prefix_ void senf::Parse_Vector_Container<ElementParser,Sizer>::push_back_space(size_type n)
 {
-    container_.insert(pos.raw(),n*Parser::bytes(),0);
-    SizeParser(container_.begin()+size_i_) += n;
+    shift(end(),n);
 }
 
-template <class Parser, class SizeParser, class Container>
-prefix_ void senf::Parse_Vector_wrapper<Parser,SizeParser,Container>::erase(iterator pos,
-                                                                               size_type n)
+template <class ElementParser, class Sizer>
+template <class Value>
+prefix_ void senf::Parse_Vector_Container<ElementParser,Sizer>::push_front(Value value,
+                                                                           size_type n)
 {
-    container_.erase(pos.raw(),pos.raw()+n*Parser::bytes());
-    SizeParser(container_.begin()+size_i_) -= n;
+    insert(begin(),n,value);
 }
 
-template <class Parser, class SizeParser, class Container>
-prefix_ void senf::Parse_Vector_wrapper<Parser,SizeParser,Container>::erase(iterator f,
-                                                                               iterator l)
+template <class ElementParser, class Sizer>
+prefix_ void senf::Parse_Vector_Container<ElementParser,Sizer>::push_front_space(size_type n)
 {
-    erase(f,l-f);
+    shift(begin(),n);
 }
 
-template <class Parser, class SizeParser, class Container>
-prefix_ void senf::Parse_Vector_wrapper<Parser,SizeParser,Container>::clear()
+// Parser interface
+
+template <class ElementParser, class Sizer>
+prefix_ typename senf::Parse_Vector_Container<ElementParser,Sizer>::parser_type
+senf::Parse_Vector_Container<ElementParser,Sizer>::parser()
+    const
+{
+    return parser_type(i(),state());
+}
+
+template <class ElementParser, class Sizer>
+prefix_ typename senf::Parse_Vector_Container<ElementParser,Sizer>::data_iterator
+senf::Parse_Vector_Container<ElementParser,Sizer>::i()
+    const
+{
+    return boost::next(data().begin(),i_);
+}
+
+template <class ElementParser, class Sizer>
+prefix_ typename senf::Parse_Vector_Container<ElementParser,Sizer>::state_type
+senf::Parse_Vector_Container<ElementParser,Sizer>::state()
+    const
+{
+    return state_;
+}
+
+template <class ElementParser, class Sizer>
+prefix_ senf::PacketData &
+senf::Parse_Vector_Container<ElementParser,Sizer>::data()
+    const
+{
+    return *state_;
+}
+
+template <class ElementParser, class Sizer>
+prefix_ typename senf::Parse_Vector_Container<ElementParser,Sizer>::size_type
+senf::Parse_Vector_Container<ElementParser,Sizer>::bytes()
+    const
+{
+    return size()*ElementParser::fixed_bytes + sizer_.bytes(i(),state());
+}
+
+// private members
+
+template <class ElementParser, class Sizer>
+prefix_ void senf::Parse_Vector_Container<ElementParser,Sizer>::setSize(size_type value)
 {
-    container_.erase(container_.begin()+i_,container_.begin()+i_+size()*Parser::bytes());
-    SizeParser(container_.begin()+size_i_) = 0;
+    sizer_.size(i(),state(),value);
 }
 
-///////////////////////////////cti.e///////////////////////////////////////
+/////////////////////////////cti.e///////////////////////////////////////
 #undef prefix_
 
 
@@ -224,4 +391,6 @@ prefix_ void senf::Parse_Vector_wrapper<Parser,SizeParser,Container>::clear()
 // c-file-style: "senf"
 // indent-tabs-mode: nil
 // ispell-local-dictionary: "american"
+// compile-command: "scons -u test"
+// comment-column: 40
 // End: