added scheduler watchdog members to sys/scheduler console dir

[senf.git] / senf / Packets / ListParser.hh

diff --git a/senf/Packets/ListParser.hh b/senf/Packets/ListParser.hh
index d7c19a1..654559a 100644 (file)
--- a/senf/Packets/ListParser.hh
+++ b/senf/Packets/ListParser.hh
@@ -31,7 +31,7 @@
 #include "PacketParser.hh"
 
 //#include "ListParser.mpp"
-///////////////////////////////hh.p////////////////////////////////////////
+//-/////////////////////////////////////////////////////////////////////////////////////////////////
 
 namespace senf {
 
@@ -62,8 +62,8 @@ namespace senf {
         API however you will need to instantiate a container wrapper for the list. See \ref
         packet_usage_fields_collection.
 
-        \see 
-            \ref How to access \ref packet_usage_fields_collection
+        \see
+            How to access \ref packet_usage_fields_collection \n
             SENF_PARSER_LIST() macro used to define list fields \n
             ListParser_Container list container wrapper API \n
             ExampleListPolicy
@@ -89,7 +89,7 @@ namespace senf {
 
         static const size_type init_bytes = ListPolicy::init_bytes;
 
-        ///////////////////////////////////////////////////////////////////////////
+        //-////////////////////////////////////////////////////////////////////////
         // Container interface
 
         typedef typename ListPolicy::element_type value_type;
@@ -120,7 +120,7 @@ namespace senf {
         This is the container wrapper used for list parsers. The container wrapper will stay valid
         after changing the collection. However the container still depends on the packet and will be
         invalidated if the Packet is deallocated or if the packet size is changed from without the
-        container wrapper (more precisely, it is invalided if the insertion/deletion happens before
+        container wrapper (more precisely, it is invalidated if the insertion/deletion happens before
         the vector in the packet data).
 
         The vector container wrapper provides a complete STL random-access sequence interface.
@@ -138,7 +138,7 @@ namespace senf {
         : private ListPolicy
     {
     public:
-        ///////////////////////////////////////////////////////////////////////////
+        //-////////////////////////////////////////////////////////////////////////
         // Types
 
         typedef ListPolicy policy;
@@ -151,9 +151,9 @@ namespace senf {
         typedef iterator const_iterator;
         typedef PacketParserBase::state_type state_type;
 
-        ///////////////////////////////////////////////////////////////////////////
+        //-////////////////////////////////////////////////////////////////////////
         ///\name Structors and default members
-        ///@{
+        //\{
 
         // no default constructor
         // default copy
@@ -163,11 +163,11 @@ namespace senf {
         ListParser_Container(parser_type const & list);
         ~ListParser_Container();
 
-        ///@}
-        ///////////////////////////////////////////////////////////////////////////
+        //\}
+        //-////////////////////////////////////////////////////////////////////////
 
         ///\name Accessors
-        ///@{
+        //\{
 
         size_type size() const;
         bool empty() const;
@@ -178,9 +178,9 @@ namespace senf {
         value_type front() const;
         value_type back() const;
 
-        ///@}
+        //\}
         ///\name Mutators
-        ///@{
+        //\{
 
         // All these operations can be quite inefficient depending on the list type
         value_type shift(iterator pos, size_type n=1);
@@ -207,10 +207,10 @@ namespace senf {
         void                        resize           (size_type n);
         template <class Value> void resize           (size_type n, Value value);
 
-        ///@}
+        //\}
 
         ///\name Parser interface
-        ///@{
+        //\{
 
         parser_type parser() const;
         data_iterator i() const;
@@ -220,7 +220,7 @@ namespace senf {
         size_type bytes() const;
         void init() const;
 
-        ///@}
+        //\}
 
     private:
         friend class detail::ListParser_Iterator<ListParser_Container>;
@@ -240,7 +240,7 @@ namespace senf {
         // Define the list
         SENF_PARSER_LIST ( list, list_size_, EltParser );
         \endcode
-        
+
         Here \c EltParser can be an arbitrary parser and need not have a fixed size.
 
         \warning Realize, that the \a size field is controlled by the list parser. This field
@@ -261,7 +261,7 @@ namespace senf {
 
         <tr><td>\c transform(\a transform, \c bytes(\a size))</td><td>The \a transform is applied to
         the \a size value. The value is then interpreted containing the list size in bytes not
-        number of elements</td> 
+        number of elements</td>
         </table>
 
         The optional \a transform is a class with the following layout
@@ -272,7 +272,7 @@ namespace senf {
             static value_type get(other_type v);
             static other_type set(value_type v);
         };
-        \endcode 
+        \endcode
 
         \c other_type is \a size ::\c value_type, the type of the value returned by the \a size
         field, whereas the \c value_type typedef is the arbitrary return type of the transform.
@@ -297,7 +297,7 @@ namespace senf {
         \param[in] size name of field giving the list size
         \param[in] elt_type list element type
 
-        \see 
+        \see
             How to use \ref packet_usage_fields_collection \n
             senf::ListParser the list parser API for list field access
             senf::ListParser_Container the list parser container API for list field access
@@ -320,7 +320,7 @@ namespace senf {
 
 }
 
-///////////////////////////////hh.e////////////////////////////////////////
+//-/////////////////////////////////////////////////////////////////////////////////////////////////
 #endif
 #if !defined(HH_SENF_Packets_Packets__decls_) && !defined(HH_SENF_Packets_ListParser_i_)
 #define HH_SENF_Packets_ListParser_i_