[Boost-commit] svn:boost r83981 - trunk/boost

Subject: [Boost-commit] svn:boost r83981 - trunk/boost
From: vicente.botet_at_[hidden]
Date: 2013-04-20 09:50:44

Author: viboes
Date: 2013-04-20 09:50:43 EDT (Sat, 20 Apr 2013)
New Revision: 83981
URL: http://svn.boost.org/trac/boost/changeset/83981

Log:
Tokenizer: fix minor warnings.
Text files modified: 
   trunk/boost/token_functions.hpp |    32 ++++++++++++++++----------------        
   trunk/boost/token_iterator.hpp  |    16 ++++++++--------                        
   2 files changed, 24 insertions(+), 24 deletions(-)

Modified: trunk/boost/token_functions.hpp
==============================================================================
--- trunk/boost/token_functions.hpp	(original)
+++ trunk/boost/token_functions.hpp	2013-04-20 09:50:43 EDT (Sat, 20 Apr 2013)
@@ -1,6 +1,6 @@
 // Boost token_functions.hpp  ------------------------------------------------//
 
-// Copyright John R. Bandela 2001. 
+// Copyright John R. Bandela 2001.
 
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
@@ -77,12 +77,12 @@
 namespace boost{
   //===========================================================================
   // The escaped_list_separator class. Which is a model of TokenizerFunction
-  // An escaped list is a super-set of what is commonly known as a comma 
-  // separated value (csv) list.It is separated into fields by a comma or 
+  // An escaped list is a super-set of what is commonly known as a comma
+  // separated value (csv) list.It is separated into fields by a comma or
   // other character. If the delimiting character is inside quotes, then it is
   // counted as a regular character.To allow for embedded quotes in a field,
-  // there can be escape sequences using the \ much like C. 
-  // The role of the comma, the quotation mark, and the escape 
+  // there can be escape sequences using the \ much like C.
+  // The role of the comma, the quotation mark, and the escape
   // character (backslash \), can be assigned to other characters.
 
   struct escaped_list_error : public std::runtime_error{
@@ -181,7 +181,7 @@
             ++next;
             // The last character was a c, that means there is
             // 1 more blank field
-            last_ = true; 
+            last_ = true;
             return true;
           }
           else tok+=*next;
@@ -209,7 +209,7 @@
   // Assuming that the conditional will always get optimized out in the function
   // implementations, argument types are not a problem since both forms of character classifiers
   // expect an int.
-   
+
 #if !defined(BOOST_NO_CWCTYPE)
   template<typename traits, int N>
   struct traits_extension_details : public traits {
@@ -238,7 +238,7 @@
   };
 #endif
 
-    
+
   // In case there is no cwctype header, we implement the checks manually.
   // We make use of the fact that the tested categories should fit in ASCII.
   template<typename traits>
@@ -309,8 +309,8 @@
   template <>
   struct assign_or_plus_equal<std::input_iterator_tag> {
     template<class Iterator, class Token>
-    static void assign(Iterator b, Iterator e, Token &t) { }
-    template<class Token, class Value> 
+    static void assign(Iterator , Iterator , Token &) { }
+    template<class Token, class Value>
     static void plus_equal(Token &t, const Value &v) {
       t += v;
     }
@@ -444,7 +444,7 @@
     typedef tokenizer_detail::traits_extension<Tr> Traits;
     typedef std::basic_string<Char,Tr> string_type;
   public:
-    explicit 
+    explicit
     char_separator(const Char* dropped_delims,
                    const Char* kept_delims = 0,
                    empty_token_policy empty_tokens = drop_empty_tokens)
@@ -511,7 +511,7 @@
             m_output_done = true;
             assigner::assign(start,next,tok);
             return true;
-          } 
+          }
           else
             return false;
         }
@@ -524,10 +524,10 @@
             ++next;
             m_output_done = false;
           }
-        } 
+        }
         else if (m_output_done == false && is_dropped(*next)) {
           m_output_done = true;
-        } 
+        }
         else {
           if (is_dropped(*next))
             start=++next;
@@ -618,7 +618,7 @@
     }
 
   public:
-    explicit char_delimiters_separator(bool return_delims = false, 
+    explicit char_delimiters_separator(bool return_delims = false,
                                        const Char* returnable = 0,
                                        const Char* nonreturnable = 0)
       : returnable_(returnable ? returnable : string_type().c_str()),
@@ -636,7 +636,7 @@
 
      // skip past all nonreturnable delims
      // skip past the returnable only if we are not returning delims
-     for (;next!=end && ( is_nonret(*next) || (is_ret(*next) 
+     for (;next!=end && ( is_nonret(*next) || (is_ret(*next)
        && !return_delims_ ) );++next) { }
 
      if (next == end) {

Modified: trunk/boost/token_iterator.hpp
==============================================================================
--- trunk/boost/token_iterator.hpp	(original)
+++ trunk/boost/token_iterator.hpp	2013-04-20 09:50:43 EDT (Sat, 20 Apr 2013)
@@ -34,7 +34,7 @@
           , typename detail::minimum_category<
                 forward_traversal_tag
               , typename iterator_traversal<Iterator>::type
-            >::type 
+            >::type
           , const Type&
         >
   {
@@ -88,7 +88,7 @@
 
       Iterator base()const{return begin_;}
 
-      Iterator end()const{return end_;};
+      Iterator end()const{return end_;}
 
       TokenizerFunc tokenizer_function()const{return f_;}
 
@@ -101,24 +101,24 @@
 
   };
     template <
-        class TokenizerFunc = char_delimiters_separator<char>, 
+        class TokenizerFunc = char_delimiters_separator<char>,
         class Iterator = std::string::const_iterator,
         class Type = std::string
     >
     class token_iterator_generator {
 
-    private: 
+    private:
     public:
         typedef token_iterator<TokenizerFunc,Iterator,Type> type;
     };
-    
-    
+
+
     // Type has to be first because it needs to be explicitly specified
     // because there is no way the function can deduce it.
     template<class Type, class Iterator, class TokenizerFunc>
-        typename token_iterator_generator<TokenizerFunc,Iterator,Type>::type 
+        typename token_iterator_generator<TokenizerFunc,Iterator,Type>::type
     make_token_iterator(Iterator begin, Iterator end,const TokenizerFunc& fun){
-        typedef typename 
+        typedef typename
             token_iterator_generator<TokenizerFunc,Iterator,Type>::type ret_type;
         return ret_type(fun,begin,end);
     }