Packets/80221Bundle: renamed MIHTLVLengthParser to MIHLengthParser

git-svn-id: https://svn.berlios.de/svnroot/repos/senf/trunk@1809 270642c3-0616-0410-b53a-bc976706d245

diff --git a/senf/Packets/80221Bundle/Exceptions.hh b/senf/Packets/80221Bundle/Exceptions.hh
index 60b4369..69f867e 100644 (file)
--- a/senf/Packets/80221Bundle/Exceptions.hh
+++ b/senf/Packets/80221Bundle/Exceptions.hh
@@ -35,10 +35,10 @@
 
 namespace senf {
 
-    struct MIHTLVLengthException : public senf::Exception
+    struct MIHLengthException : public senf::Exception
     {
-        MIHTLVLengthException()
-          : senf::Exception("MIHTLVLengthException") {}
+        MIHLengthException()
+          : senf::Exception("MIHLengthException") {}
     };
 
     struct InvalidMIHPacketException : public senf::Exception

diff --git a/senf/Packets/80221Bundle/TLVParser.cc b/senf/Packets/80221Bundle/TLVParser.cc
index 7474b0b..10f5381 100644 (file)
--- a/senf/Packets/80221Bundle/TLVParser.cc
+++ b/senf/Packets/80221Bundle/TLVParser.cc
@@ -58,7 +58,7 @@ prefix_ void senf::MIHBaseTLVParser::validateType(boost::uint8_t expectedType)
         throw InvalidMIHPacketException("wrong TLV type. expected ") << unsigned(expectedType) << " got " << unsigned(type());
 }
 
-prefix_ void senf::MIHBaseTLVParser::validateTypeLength(boost::uint8_t expectedType, MIHTLVLengthParser::value_type expectedLength)
+prefix_ void senf::MIHBaseTLVParser::validateTypeLength(boost::uint8_t expectedType, MIHLengthParser::value_type expectedLength)
     const
 {
     validateType( expectedType);
@@ -70,7 +70,7 @@ prefix_ void senf::MIHBaseTLVParser::validateTypeLength(boost::uint8_t expectedT
 //-/////////////////////////////////////////////////////////////////////////////////////////////////
 // senf::MIHBaseListTLVParser
 
-prefix_ void senf::MIHBaseListTLVParser::maxListSize(MIHTLVLengthParser::value_type maxl)
+prefix_ void senf::MIHBaseListTLVParser::maxListSize(MIHLengthParser::value_type maxl)
     const
 {
     protect(), listSize_().capacity( maxl);
@@ -109,9 +109,9 @@ prefix_ void senf::MIHFIdTLVParser::maxIdLength(boost::uint8_t maxl)
 }
 
 prefix_ senf::safe_data_iterator senf::MIHFIdTLVParser::resizeValueField(
-        MIHTLVLengthParser::value_type size)
+        MIHLengthParser::value_type size)
 {
-    MIHTLVLengthParser::value_type current_length ( idLength());
+    MIHLengthParser::value_type current_length ( idLength());
     idLength_() << size;
     length_() << size + idLength_().bytes();
 
@@ -312,9 +312,9 @@ prefix_ void senf::MIHValidTimeIntervalTLVParser::validate()
 }
 
 //-/////////////////////////////////////////////////////////////////////////////////////////////////
-// senf::MIHTLVLengthParser
+// senf::MIHLengthParser
 
-prefix_ senf::MIHTLVLengthParser::value_type senf::MIHTLVLengthParser::value() const
+prefix_ senf::MIHLengthParser::value_type senf::MIHLengthParser::value() const
 {
     switch (bytes() ) {
     case 1:
@@ -328,39 +328,39 @@ prefix_ senf::MIHTLVLengthParser::value_type senf::MIHTLVLengthParser::value() c
     case 5:
         return parse<UInt32Parser>( 1 ).value() + (underflow_flag() ? 0 : 128u);
     default:
-        throw( MIHTLVLengthException());
+        throw( MIHLengthException());
     };
 }
 
-prefix_ void senf::MIHTLVLengthParser::value(value_type const & v)
+prefix_ void senf::MIHLengthParser::value(value_type const & v)
 {
     switch (bytes() ) {
     case 1:
-        if (v > 128) throw( MIHTLVLengthException());
+        if (v > 128) throw( MIHLengthException());
         length_field() = v;
         return;
     case 2:
-        if (v > UInt8Parser::max_value + 128) throw( MIHTLVLengthException());
+        if (v > UInt8Parser::max_value + 128) throw( MIHLengthException());
         parse<UInt8Parser>(1) = v - (v>128 ? 128 : 0);
         break;
     case 3:
-        if (v > UInt16Parser::max_value + 128) throw( MIHTLVLengthException());
+        if (v > UInt16Parser::max_value + 128) throw( MIHLengthException());
         parse<UInt16Parser>(1) = v - (v>128 ? 128 : 0);
         break;;
     case 4:
-        if (v > UInt24Parser::max_value + 128) throw( MIHTLVLengthException());
+        if (v > UInt24Parser::max_value + 128) throw( MIHLengthException());
         parse<UInt24Parser>(1) = v - (v>128 ? 128 : 0);
         break;
     case 5:
         parse<UInt32Parser>(1) = v - (v>128 ? 128 : 0);
         break;
     default:
-        throw( MIHTLVLengthException());
+        throw( MIHLengthException());
     };
     underflow_flag() = (v <= 128);
 }
 
-prefix_ senf::MIHTLVLengthParser::value_type senf::MIHTLVLengthParser::capacity()
+prefix_ senf::MIHLengthParser::value_type senf::MIHLengthParser::capacity()
     const
 {
     switch (bytes() ) {
@@ -375,23 +375,23 @@ prefix_ senf::MIHTLVLengthParser::value_type senf::MIHTLVLengthParser::capacity(
     case 5:
         return UInt32Parser::max_value;
     default:
-        throw( MIHTLVLengthException());
+        throw( MIHLengthException());
     };
 }
 
-prefix_ senf::MIHTLVLengthParser const & senf::MIHTLVLengthParser::operator= (value_type other)
+prefix_ senf::MIHLengthParser const & senf::MIHLengthParser::operator= (value_type other)
 {
     value(other);
     return *this;
 }
 
-prefix_ void senf::MIHTLVLengthParser::init() const
+prefix_ void senf::MIHLengthParser::init() const
 {
     defaultInit();
     extended_length_flag() = false;
 }
 
-prefix_ void senf::MIHTLVLengthParser::finalize()
+prefix_ void senf::MIHLengthParser::finalize()
 {
     value_type v = value();
     size_type b = bytes();
@@ -414,7 +414,7 @@ prefix_ void senf::MIHTLVLengthParser::finalize()
     if (b != 5) resize_(5);
 }
 
-prefix_ void senf::MIHTLVLengthParser::capacity(MIHTLVLengthParser::value_type v)
+prefix_ void senf::MIHLengthParser::capacity(MIHLengthParser::value_type v)
 {
     if (v <= 128)
         return;
@@ -434,7 +434,7 @@ prefix_ void senf::MIHTLVLengthParser::capacity(MIHTLVLengthParser::value_type v
     if (b < 5) resize_(5);
 }
 
-prefix_ void senf::MIHTLVLengthParser::resize_(size_type size)
+prefix_ void senf::MIHLengthParser::resize_(size_type size)
 {
     value_type v = value();
     resize(bytes(), size);

diff --git a/senf/Packets/80221Bundle/TLVParser.cci b/senf/Packets/80221Bundle/TLVParser.cci
index eb7361e..13b37b7 100644 (file)
--- a/senf/Packets/80221Bundle/TLVParser.cci
+++ b/senf/Packets/80221Bundle/TLVParser.cci
@@ -36,9 +36,9 @@
 //-/////////////////////////////////////////////////////////////////////////////////////////////////
 
 //-/////////////////////////////////////////////////////////////////////////////////////////////////
-// MIHTLVLengthParser
+// MIHLengthParser
 
-prefix_ senf::MIHTLVLengthParser::size_type senf::MIHTLVLengthParser::bytes() const
+prefix_ senf::MIHLengthParser::size_type senf::MIHLengthParser::bytes() const
 {
     return 1 + ( length_field()<=128 ? 0 : fixed_length_field());
 }
@@ -149,7 +149,7 @@ prefix_ bool senf::MIHFIdTLVParser::valueEquals( MIHFId const & id)
 //-/////////////////////////////////////////////////////////////////////////////////////////////////
 // MIHBaseTLVParser
 
-prefix_ void senf::MIHBaseTLVParser::maxLength(MIHTLVLengthParser::value_type maxl)
+prefix_ void senf::MIHBaseTLVParser::maxLength(MIHLengthParser::value_type maxl)
     const
 {
     protect(), length_().capacity(maxl);

diff --git a/senf/Packets/80221Bundle/TLVParser.hh b/senf/Packets/80221Bundle/TLVParser.hh
index f454d08..e27deaa 100644 (file)
--- a/senf/Packets/80221Bundle/TLVParser.hh
+++ b/senf/Packets/80221Bundle/TLVParser.hh
@@ -40,12 +40,12 @@
 
 namespace senf {
 
-    class MIHTLVLengthParser
-        : public detail::packet::IntParserOps<MIHTLVLengthParser, boost::uint32_t>,
+    class MIHLengthParser
+        : public detail::packet::IntParserOps<MIHLengthParser, boost::uint32_t>,
           public PacketParserBase
     {
     public:
-        MIHTLVLengthParser(data_iterator i, state_type s) : PacketParserBase(i,s) {}
+        MIHLengthParser(data_iterator i, state_type s) : PacketParserBase(i,s) {}
 
         typedef boost::uint32_t value_type;
         static const size_type init_bytes = 1;
@@ -55,7 +55,7 @@ namespace senf {
         value_type value() const;
         void value(value_type const & v);
 
-        MIHTLVLengthParser const & operator= (value_type other);
+        MIHLengthParser const & operator= (value_type other);
         size_type bytes() const;
         void init() const;
 
@@ -79,7 +79,7 @@ namespace senf {
 
          MIHBaseTLVParser is the abstract base class for MIH TLV parsers. It defines the
          \ref type() field as an \ref senf::UInt8Parser and the \ref length() field as a
-         MIHTLVLengthParser. The length field is read-only.
+         MIHLengthParser. The length field is read-only.
 
          To create your own \c TLVParser you have to inherit from MIHBaseTLVParser (don't
          forget \ref SENF_PARSER_INHERIT) and define the \c value field. In the following example
@@ -98,7 +98,7 @@ namespace senf {
          example adding more than 21 MACAddresses to the vector will throw a TLVLengthException
          if you don't call \c maxLength( \e some_value) before.
 
-         \see MIHTLVLengthParser \n
+         \see MIHLengthParser \n
            MIHGenericTLVParser \n
      */
     class MIHBaseTLVParser : public PacketParserBase
@@ -106,7 +106,7 @@ namespace senf {
     public:
 #       include SENF_PARSER()
         SENF_PARSER_FIELD    ( type,   UInt8Parser        );
-        SENF_PARSER_FIELD_RO ( length, MIHTLVLengthParser );
+        SENF_PARSER_FIELD_RO ( length, MIHLengthParser );
         SENF_PARSER_FINALIZE ( MIHBaseTLVParser           );
 
         /** \brief shrink size of the TLV length field to minimum
@@ -124,10 +124,10 @@ namespace senf {
             The size of the length field will be increased if necessary.
             \param v maximum value of length field
          */
-        void maxLength(MIHTLVLengthParser::value_type maxl) const;
+        void maxLength(MIHLengthParser::value_type maxl) const;
 
         void validateType(boost::uint8_t type) const;
-        void validateTypeLength(boost::uint8_t type, MIHTLVLengthParser::value_type length) const;
+        void validateTypeLength(boost::uint8_t type, MIHLengthParser::value_type length) const;
     };
 
 
@@ -142,7 +142,7 @@ namespace senf {
 
         void init() const {
             defaultInit();
-            maxLength( MIHTLVLengthParser::max_value);
+            maxLength( MIHLengthParser::max_value);
         }
 
         using base::init;
@@ -157,10 +157,10 @@ namespace senf {
     {
     #   include SENF_PARSER()
         SENF_PARSER_INHERIT  ( MIHBaseTLVParser );
-        SENF_PARSER_FIELD_RO ( listSize, MIHTLVLengthParser );
+        SENF_PARSER_FIELD_RO ( listSize, MIHLengthParser );
         SENF_PARSER_FINALIZE ( MIHBaseListTLVParser );
 
-        void maxListSize(MIHTLVLengthParser::value_type maxl) const;
+        void maxListSize(MIHLengthParser::value_type maxl) const;
     };
 
     template <class Self>
@@ -185,7 +185,7 @@ namespace senf {
     {
     #   include SENF_PARSER()
         SENF_PARSER_INHERIT  ( MIHBaseTLVParser );
-        SENF_PARSER_FIELD_RO ( idLength, MIHTLVLengthParser );
+        SENF_PARSER_FIELD_RO ( idLength, MIHLengthParser );
         SENF_PARSER_LABEL    ( idValue          );
         SENF_PARSER_SKIP     ( idLength(), 0    );
         SENF_PARSER_FINALIZE ( MIHFIdTLVParser  );
@@ -230,7 +230,7 @@ namespace senf {
 
     private:
         /// resize the packet after the length field to given size
-        senf::safe_data_iterator resizeValueField(MIHTLVLengthParser::value_type size);
+        senf::safe_data_iterator resizeValueField(MIHLengthParser::value_type size);
 
         data_iterator valueBegin() const;
         data_iterator valueEnd() const;

diff --git a/senf/Packets/80221Bundle/TLVParser.test.cc b/senf/Packets/80221Bundle/TLVParser.test.cc
index 6503ff6..449b402 100644 (file)
--- a/senf/Packets/80221Bundle/TLVParser.test.cc
+++ b/senf/Packets/80221Bundle/TLVParser.test.cc
@@ -134,7 +134,7 @@ SENF_AUTO_UNIT_TEST(MIHGenericTLVParser_create_with_extended_length)
     PacketInterpreterBase::ptr p (PacketInterpreter<VoidPacket>::create(
             senf::PacketInterpreterBase::size_type(2u)));
     MIHGenericTLVParser tlvParser( p->data().begin(), &p->data());
-    tlvParser.maxLength( MIHTLVLengthParser::max_value);
+    tlvParser.maxLength( MIHLengthParser::max_value);
     tlvParser.type() = 42u;
     tlvParser.value( value);
     tlvParser.finalize();
@@ -164,7 +164,7 @@ SENF_AUTO_UNIT_TEST(MIHGenericTLVParser_create_invalid)
     for (unsigned i=0; i<sizeof(value); i++)
         value[i] = i;
 
-    BOOST_CHECK_THROW( tlvParser.value( value), MIHTLVLengthException);
+    BOOST_CHECK_THROW( tlvParser.value( value), MIHLengthException);
     tlvParser.maxLength( sizeof(value));
     tlvParser.value( value);
     tlvParser.finalize();