Use boost string algorithms.

author: Remko Tronçon <git@el-tramo.be> 2011-02-13 10:13:40 (GMT)
committer: Remko Tronçon <git@el-tramo.be> 2011-02-13 10:37:59 (GMT)
commit: 6872dd34f88b08568a4784fe46373a0af0b69165 (patch)
tree: d14eddb94afbfedb045510ba2d455d110d19b71f
parent: b734b6a5986703b6b10ea548c93af11f9df771bf (diff)
download: swift-contrib-6872dd34f88b08568a4784fe46373a0af0b69165.zip
swift-contrib-6872dd34f88b08568a4784fe46373a0af0b69165.tar.bz2
25 files changed, 3509 insertions, 13 deletions
diff --git a/3rdParty/Boost/src/boost/algorithm/string.hpp b/3rdParty/Boost/src/boost/algorithm/string.hpp
new file mode 100644
index 0000000..0771517
--- /dev/null
+++ b/3rdParty/Boost/src/boost/algorithm/string.hpp
@@ -0,0 +1,31 @@
+//  Boost string_algo library string_algo.hpp header file  ---------------------------//
+
+//  Copyright Pavol Droba 2002-2004.
+//
+// Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//          http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org/ for updates, documentation, and revision history.
+
+#ifndef BOOST_STRING_ALGO_HPP
+#define BOOST_STRING_ALGO_HPP
+
+/*! \file
+    Cumulative include for string_algo library
+*/
+
+#include <boost/algorithm/string/std_containers_traits.hpp>
+#include <boost/algorithm/string/trim.hpp>
+#include <boost/algorithm/string/case_conv.hpp>
+#include <boost/algorithm/string/predicate.hpp>
+#include <boost/algorithm/string/find.hpp>
+#include <boost/algorithm/string/split.hpp>
+#include <boost/algorithm/string/join.hpp>
+#include <boost/algorithm/string/replace.hpp>
+#include <boost/algorithm/string/erase.hpp>
+#include <boost/algorithm/string/classification.hpp>
+#include <boost/algorithm/string/find_iterator.hpp>
+
+
+#endif  // BOOST_STRING_ALGO_HPP
diff --git a/3rdParty/Boost/src/boost/algorithm/string/classification.hpp b/3rdParty/Boost/src/boost/algorithm/string/classification.hpp
new file mode 100644
index 0000000..ca43602
--- /dev/null
+++ b/3rdParty/Boost/src/boost/algorithm/string/classification.hpp
@@ -0,0 +1,312 @@
+//  Boost string_algo library classification.hpp header file  ---------------------------//
+
+//  Copyright Pavol Droba 2002-2003.
+//
+// Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//          http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org/ for updates, documentation, and revision history.
+
+#ifndef BOOST_STRING_CLASSIFICATION_HPP
+#define BOOST_STRING_CLASSIFICATION_HPP
+
+#include <algorithm>
+#include <locale>
+#include <boost/range/value_type.hpp>
+#include <boost/range/as_literal.hpp>
+#include <boost/algorithm/string/detail/classification.hpp>
+#include <boost/algorithm/string/predicate_facade.hpp>
+
+
+/*! \file
+    Classification predicates are included in the library to give 
+    some more convenience when using algorithms like \c trim() and \c all(). 
+    They wrap functionality of STL classification functions ( e.g. \c std::isspace() )
+    into generic functors. 
+*/
+
+namespace boost {
+    namespace algorithm {
+
+//  classification functor generator -------------------------------------//
+
+        //! is_classified predicate
+        /*!
+            Construct the \c is_classified predicate. This predicate holds if the input is
+            of specified \c std::ctype category.
+
+            \param Type A \c std::ctype category
+            \param Loc A locale used for classification
+            \return An instance of the \c is_classified predicate 
+        */
+        inline detail::is_classifiedF
+        is_classified(std::ctype_base::mask Type, const std::locale& Loc=std::locale())
+        {
+            return detail::is_classifiedF(Type, Loc);
+        }
+
+        //! is_space predicate
+        /*!
+            Construct the \c is_classified predicate for the \c ctype_base::space category.   
+
+            \param Loc A locale used for classification
+            \return An instance of the \c is_classified predicate
+        */
+        inline detail::is_classifiedF 
+        is_space(const std::locale& Loc=std::locale())
+        {
+            return detail::is_classifiedF(std::ctype_base::space, Loc);
+        }
+
+        //! is_alnum predicate
+        /*!
+            Construct the \c is_classified predicate for the \c ctype_base::alnum category.   
+
+            \param Loc A locale used for classification
+            \return An instance of the \c is_classified predicate 
+        */
+        inline detail::is_classifiedF 
+        is_alnum(const std::locale& Loc=std::locale())
+        {
+            return detail::is_classifiedF(std::ctype_base::alnum, Loc);
+        }
+
+        //! is_alpha predicate
+        /*!
+            Construct the \c is_classified predicate for the \c ctype_base::alpha category.   
+
+            \param Loc A locale used for classification
+            \return An instance of the \c is_classified predicate 
+        */
+        inline detail::is_classifiedF 
+        is_alpha(const std::locale& Loc=std::locale())
+        {
+            return detail::is_classifiedF(std::ctype_base::alpha, Loc);
+        }
+
+        //! is_cntrl predicate
+        /*!
+            Construct the \c is_classified predicate for the \c ctype_base::cntrl category.   
+
+            \param Loc A locale used for classification
+            \return An instance of the \c is_classified predicate 
+        */
+        inline detail::is_classifiedF 
+        is_cntrl(const std::locale& Loc=std::locale())
+        {
+            return detail::is_classifiedF(std::ctype_base::cntrl, Loc);
+        }
+
+        //! is_digit predicate
+        /*!
+            Construct the \c is_classified predicate for the \c ctype_base::digit category.   
+
+            \param Loc A locale used for classification
+            \return An instance of the \c is_classified predicate 
+        */
+        inline detail::is_classifiedF 
+        is_digit(const std::locale& Loc=std::locale())
+        {
+            return detail::is_classifiedF(std::ctype_base::digit, Loc);
+        }
+
+        //! is_graph predicate
+        /*!
+            Construct the \c is_classified predicate for the \c ctype_base::graph category.   
+
+            \param Loc A locale used for classification
+            \return An instance of the \c is_classified predicate 
+        */
+        inline detail::is_classifiedF
+        is_graph(const std::locale& Loc=std::locale())
+        {
+            return detail::is_classifiedF(std::ctype_base::graph, Loc);
+        }
+
+        //! is_lower predicate
+        /*!
+            Construct the \c is_classified predicate for the \c ctype_base::lower category.   
+
+            \param Loc A locale used for classification
+            \return An instance of \c is_classified predicate 
+        */
+        inline detail::is_classifiedF 
+        is_lower(const std::locale& Loc=std::locale())
+        {
+            return detail::is_classifiedF(std::ctype_base::lower, Loc);
+        }
+
+        //! is_print predicate
+        /*!
+            Construct the \c is_classified predicate for the \c ctype_base::print category.   
+
+            \param Loc A locale used for classification
+            \return An instance of the \c is_classified predicate 
+        */
+        inline detail::is_classifiedF 
+        is_print(const std::locale& Loc=std::locale())
+        {
+            return detail::is_classifiedF(std::ctype_base::print, Loc);
+        }
+
+        //! is_punct predicate
+        /*!
+            Construct the \c is_classified predicate for the \c ctype_base::punct category.   
+
+            \param Loc A locale used for classification
+            \return An instance of the \c is_classified predicate 
+        */
+        inline detail::is_classifiedF 
+        is_punct(const std::locale& Loc=std::locale())
+        {
+            return detail::is_classifiedF(std::ctype_base::punct, Loc);
+        }
+
+        //! is_upper predicate
+        /*!
+            Construct the \c is_classified predicate for the \c ctype_base::upper category.   
+
+            \param Loc A locale used for classification
+            \return An instance of the \c is_classified predicate 
+        */
+        inline detail::is_classifiedF 
+        is_upper(const std::locale& Loc=std::locale())
+        {
+            return detail::is_classifiedF(std::ctype_base::upper, Loc);
+        }
+
+        //! is_xdigit predicate
+        /*!
+            Construct the \c is_classified predicate for the \c ctype_base::xdigit category.  
+
+            \param Loc A locale used for classification
+            \return An instance of the \c is_classified predicate 
+        */
+        inline detail::is_classifiedF 
+        is_xdigit(const std::locale& Loc=std::locale())
+        {
+            return detail::is_classifiedF(std::ctype_base::xdigit, Loc);
+        }
+
+        //! is_any_of predicate
+        /*!
+            Construct the \c is_any_of predicate. The predicate holds if the input
+            is included in the specified set of characters.
+
+            \param Set A set of characters to be recognized
+            \return An instance of the \c is_any_of predicate 
+        */
+        template<typename RangeT>
+        inline detail::is_any_ofF<
+            BOOST_STRING_TYPENAME range_value<RangeT>::type> 
+        is_any_of( const RangeT& Set )
+        {
+            iterator_range<BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> lit_set(boost::as_literal(Set));
+            return detail::is_any_ofF<BOOST_STRING_TYPENAME range_value<RangeT>::type>(lit_set); 
+        }
+
+        //! is_from_range predicate
+        /*!
+            Construct the \c is_from_range predicate. The predicate holds if the input
+            is included in the specified range. (i.e. From <= Ch <= To )
+
+            \param From The start of the range
+            \param To The end of the range
+            \return An instance of the \c is_from_range predicate 
+        */
+        template<typename CharT>
+        inline detail::is_from_rangeF<CharT> is_from_range(CharT From, CharT To)
+        {
+            return detail::is_from_rangeF<CharT>(From,To); 
+        }
+        
+        // predicate combinators ---------------------------------------------------//
+
+        //! predicate 'and' composition predicate
+        /*!
+            Construct the \c class_and predicate. This predicate can be used
+            to logically combine two classification predicates. \c class_and holds,
+            if both predicates return true.
+
+            \param Pred1 The first predicate
+            \param Pred2 The second predicate
+            \return An instance of the \c class_and predicate     
+        */
+        template<typename Pred1T, typename Pred2T>
+        inline detail::pred_andF<Pred1T, Pred2T>
+        operator&&( 
+            const predicate_facade<Pred1T>& Pred1, 
+            const predicate_facade<Pred2T>& Pred2 )
+        {    
+            // Doing the static_cast with the pointer instead of the reference
+            // is a workaround for some compilers which have problems with
+            // static_cast's of template references, i.e. CW8. /grafik/
+            return detail::pred_andF<Pred1T,Pred2T>(
+                *static_cast<const Pred1T*>(&Pred1), 
+                *static_cast<const Pred2T*>(&Pred2) );
+        }
+
+        //! predicate 'or' composition predicate
+        /*!
+            Construct the \c class_or predicate. This predicate can be used
+            to logically combine two classification predicates. \c class_or holds,
+            if one of the predicates return true.
+
+            \param Pred1 The first predicate
+            \param Pred2 The second predicate
+            \return An instance of the \c class_or predicate     
+        */
+        template<typename Pred1T, typename Pred2T>
+        inline detail::pred_orF<Pred1T, Pred2T>
+        operator||( 
+            const predicate_facade<Pred1T>& Pred1, 
+            const predicate_facade<Pred2T>& Pred2 )
+        {    
+            // Doing the static_cast with the pointer instead of the reference
+            // is a workaround for some compilers which have problems with
+            // static_cast's of template references, i.e. CW8. /grafik/
+            return detail::pred_orF<Pred1T,Pred2T>(
+                *static_cast<const Pred1T*>(&Pred1), 
+                *static_cast<const Pred2T*>(&Pred2));
+        }
+
+        //! predicate negation operator
+        /*!
+            Construct the \c class_not predicate. This predicate represents a negation. 
+            \c class_or holds if of the predicates return false.
+
+            \param Pred The predicate to be negated
+            \return An instance of the \c class_not predicate     
+        */
+        template<typename PredT>
+        inline detail::pred_notF<PredT>
+        operator!( const predicate_facade<PredT>& Pred )
+        {
+            // Doing the static_cast with the pointer instead of the reference
+            // is a workaround for some compilers which have problems with
+            // static_cast's of template references, i.e. CW8. /grafik/
+            return detail::pred_notF<PredT>(*static_cast<const PredT*>(&Pred)); 
+        }
+
+    } // namespace algorithm
+
+    // pull names to the boost namespace
+    using algorithm::is_classified;
+    using algorithm::is_space;
+    using algorithm::is_alnum;
+    using algorithm::is_alpha;
+    using algorithm::is_cntrl;
+    using algorithm::is_digit;
+    using algorithm::is_graph;
+    using algorithm::is_lower;
+    using algorithm::is_upper;
+    using algorithm::is_print;
+    using algorithm::is_punct;
+    using algorithm::is_xdigit;
+    using algorithm::is_any_of;
+    using algorithm::is_from_range;
+
+} // namespace boost
+
+#endif  // BOOST_STRING_PREDICATE_HPP
diff --git a/3rdParty/Boost/src/boost/algorithm/string/detail/classification.hpp b/3rdParty/Boost/src/boost/algorithm/string/detail/classification.hpp
new file mode 100644
index 0000000..fb43955
--- /dev/null
+++ b/3rdParty/Boost/src/boost/algorithm/string/detail/classification.hpp
@@ -0,0 +1,353 @@
+//  Boost string_algo library classification.hpp header file  ---------------------------//
+
+//  Copyright Pavol Droba 2002-2003.
+// 
+// Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//          http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org/ for updates, documentation, and revision history.
+
+#ifndef BOOST_STRING_CLASSIFICATION_DETAIL_HPP
+#define BOOST_STRING_CLASSIFICATION_DETAIL_HPP
+
+#include <boost/algorithm/string/config.hpp>
+#include <algorithm>
+#include <functional>
+#include <locale>
+
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+
+#include <boost/algorithm/string/predicate_facade.hpp>
+#include <boost/type_traits/remove_const.hpp>
+
+namespace boost {
+    namespace algorithm {
+        namespace detail {
+
+//  classification functors -----------------------------------------------//
+
+   // is_classified functor
+            struct is_classifiedF :
+                public predicate_facade<is_classifiedF>
+            {
+                // Boost.ResultOf support
+                typedef bool result_type;
+
+                // Constructor from a locale
+                is_classifiedF(std::ctype_base::mask Type, std::locale const & Loc = std::locale()) :
+                    m_Type(Type), m_Locale(Loc) {}
+                // Operation
+                template<typename CharT>
+                bool operator()( CharT Ch ) const
+                {
+                    return std::use_facet< std::ctype<CharT> >(m_Locale).is( m_Type, Ch );
+                }
+
+                #if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x582) && !defined(_USE_OLD_RW_STL)
+                    template<>
+                    bool operator()( char const Ch ) const
+                    {
+                        return std::use_facet< std::ctype<char> >(m_Locale).is( m_Type, Ch );
+                    }
+                #endif
+
+            private:
+                std::ctype_base::mask m_Type;
+                std::locale m_Locale;
+            };
+
+
+            // is_any_of functor
+            /*
+                returns true if the value is from the specified set
+            */
+            template<typename CharT>
+            struct is_any_ofF :
+                public predicate_facade<is_any_ofF<CharT> >
+            {
+            private:
+                // set cannot operate on const value-type
+                typedef typename ::boost::remove_const<CharT>::type set_value_type;
+
+            public:     
+                // Boost.ResultOf support
+                typedef bool result_type;
+
+                // Constructor
+                template<typename RangeT>
+                is_any_ofF( const RangeT& Range ) : m_Size(0)
+                {
+                    // Prepare storage
+                    m_Storage.m_dynSet=0;
+
+                    std::size_t Size=::boost::distance(Range);
+                    m_Size=Size;
+                    set_value_type* Storage=0;
+
+                    if(use_fixed_storage(m_Size))
+                    {
+                        // Use fixed storage
+                        Storage=&m_Storage.m_fixSet[0];
+                    }
+                    else
+                    {
+                        // Use dynamic storage
+                        m_Storage.m_dynSet=new set_value_type[m_Size];
+                        Storage=m_Storage.m_dynSet;
+                    }
+
+                    // Use fixed storage
+                    ::std::copy(::boost::begin(Range), ::boost::end(Range), Storage);
+                    ::std::sort(Storage, Storage+m_Size);
+                }
+
+                // Copy constructor
+                is_any_ofF(const is_any_ofF& Other) : m_Size(Other.m_Size)
+                {
+                    // Prepare storage
+                    m_Storage.m_dynSet=0;               
+                    const set_value_type* SrcStorage=0;
+                    set_value_type* DestStorage=0;
+
+                    if(use_fixed_storage(m_Size))
+                    {
+                        // Use fixed storage
+                        DestStorage=&m_Storage.m_fixSet[0];
+                        SrcStorage=&Other.m_Storage.m_fixSet[0];
+                    }
+                    else
+                    {
+                        // Use dynamic storage
+                        m_Storage.m_dynSet=new set_value_type[m_Size];
+                        DestStorage=m_Storage.m_dynSet;
+                        SrcStorage=Other.m_Storage.m_dynSet;
+                    }
+
+                    // Use fixed storage
+                    ::memcpy(DestStorage, SrcStorage, sizeof(set_value_type)*m_Size);
+                }
+
+                // Destructor
+                ~is_any_ofF()
+                {
+                    if(!use_fixed_storage(m_Size) && m_Storage.m_dynSet!=0)
+                    {
+                        delete [] m_Storage.m_dynSet;
+                    }
+                }
+
+                // Assignment
+                is_any_ofF& operator=(const is_any_ofF& Other)
+                {
+                    // Handle self assignment
+                    if(this==&Other) return *this;
+
+                    // Prepare storage             
+                    const set_value_type* SrcStorage;
+                    set_value_type* DestStorage;
+
+                    if(use_fixed_storage(Other.m_Size))
+                    {
+                        // Use fixed storage
+                        DestStorage=&m_Storage.m_fixSet[0];
+                        SrcStorage=&Other.m_Storage.m_fixSet[0];
+
+                        // Delete old storage if was present
+                        if(!use_fixed_storage(m_Size) && m_Storage.m_dynSet!=0)
+                        {
+                            delete [] m_Storage.m_dynSet;
+                        }
+
+                        // Set new size
+                        m_Size=Other.m_Size;
+                    }
+                    else
+                    {
+                        // Other uses dynamic storage
+                        SrcStorage=Other.m_Storage.m_dynSet;
+
+                        // Check what kind of storage are we using right now
+                        if(use_fixed_storage(m_Size))
+                        {
+                            // Using fixed storage, allocate new
+                            set_value_type* pTemp=new set_value_type[Other.m_Size];
+                            DestStorage=pTemp;
+                            m_Storage.m_dynSet=pTemp;
+                            m_Size=Other.m_Size;
+                        }
+                        else
+                        {
+                            // Using dynamic storage, check if can reuse
+                            if(m_Storage.m_dynSet!=0 && m_Size>=Other.m_Size && m_Size<Other.m_Size*2)
+                            {
+                                // Reuse the current storage
+                                DestStorage=m_Storage.m_dynSet;
+                                m_Size=Other.m_Size;
+                            }
+                            else
+                            {
+                                // Allocate the new one
+                                set_value_type* pTemp=new set_value_type[Other.m_Size];
+                                DestStorage=pTemp;
+                        
+                                // Delete old storage if necessary
+                                if(m_Storage.m_dynSet!=0)
+                                {
+                                    delete [] m_Storage.m_dynSet;
+                                }
+                                // Store the new storage
+                                m_Storage.m_dynSet=pTemp;
+                                // Set new size
+                                m_Size=Other.m_Size;
+                            }
+                        }
+                    }
+
+                    // Copy the data
+                    ::memcpy(DestStorage, SrcStorage, sizeof(set_value_type)*m_Size);
+
+                    return *this;
+                }
+
+                // Operation
+                template<typename Char2T>
+                bool operator()( Char2T Ch ) const
+                {
+                    const set_value_type* Storage=
+                        (use_fixed_storage(m_Size))
+                        ? &m_Storage.m_fixSet[0]
+                        : m_Storage.m_dynSet;
+
+                    return ::std::binary_search(Storage, Storage+m_Size, Ch);
+                }
+            private:
+                // check if the size is eligible for fixed storage
+                static bool use_fixed_storage(std::size_t size)
+                {
+                    return size<=sizeof(set_value_type*)*2;
+                }
+
+
+            private:
+                // storage
+                // The actual used storage is selected on the type
+                union
+                {
+                    set_value_type* m_dynSet;
+                    set_value_type m_fixSet[sizeof(set_value_type*)*2];
+                } 
+                m_Storage;
+        
+                // storage size
+                ::std::size_t m_Size;
+            };
+
+            // is_from_range functor
+            /*
+                returns true if the value is from the specified range.
+                (i.e. x>=From && x>=To)
+            */
+            template<typename CharT>
+            struct is_from_rangeF :
+                public predicate_facade< is_from_rangeF<CharT> >
+            {
+                // Boost.ResultOf support
+                typedef bool result_type;
+
+                // Constructor
+                is_from_rangeF( CharT From, CharT To ) : m_From(From), m_To(To) {}
+
+                // Operation
+                template<typename Char2T>
+                bool operator()( Char2T Ch ) const
+                {
+                    return ( m_From <= Ch ) && ( Ch <= m_To );
+                }
+
+            private:
+                CharT m_From;
+                CharT m_To;
+            };
+
+            // class_and composition predicate
+            template<typename Pred1T, typename Pred2T>
+            struct pred_andF :
+                public predicate_facade< pred_andF<Pred1T,Pred2T> >
+            {
+            public:
+
+                // Boost.ResultOf support
+                typedef bool result_type;
+
+                // Constructor
+                pred_andF( Pred1T Pred1, Pred2T Pred2 ) :
+                    m_Pred1(Pred1), m_Pred2(Pred2) {}
+
+                // Operation
+                template<typename CharT>
+                bool operator()( CharT Ch ) const
+                {
+                    return m_Pred1(Ch) && m_Pred2(Ch);
+                }
+
+            private:
+                Pred1T m_Pred1;
+                Pred2T m_Pred2;
+            };
+
+            // class_or composition predicate
+            template<typename Pred1T, typename Pred2T>
+            struct pred_orF :
+                public predicate_facade< pred_orF<Pred1T,Pred2T> >
+            {
+            public:
+                // Boost.ResultOf support
+                typedef bool result_type;
+
+                // Constructor
+                pred_orF( Pred1T Pred1, Pred2T Pred2 ) :
+                    m_Pred1(Pred1), m_Pred2(Pred2) {}
+
+                // Operation
+                template<typename CharT>
+                bool operator()( CharT Ch ) const
+                {
+                    return m_Pred1(Ch) || m_Pred2(Ch);
+                }
+
+            private:
+                Pred1T m_Pred1;
+                Pred2T m_Pred2;
+            };
+
+            // class_not composition predicate
+            template< typename PredT >
+            struct pred_notF :
+                public predicate_facade< pred_notF<PredT> >
+            {
+            public:
+                // Boost.ResultOf support
+                typedef bool result_type;
+
+                // Constructor
+                pred_notF( PredT Pred ) : m_Pred(Pred) {}
+
+                // Operation
+                template<typename CharT>
+                bool operator()( CharT Ch ) const
+                {
+                    return !m_Pred(Ch);
+                }
+
+            private:
+                PredT m_Pred;
+            };
+
+        } // namespace detail
+    } // namespace algorithm
+} // namespace boost
+
+
+#endif  // BOOST_STRING_CLASSIFICATION_DETAIL_HPP
diff --git a/3rdParty/Boost/src/boost/algorithm/string/detail/find_iterator.hpp b/3rdParty/Boost/src/boost/algorithm/string/detail/find_iterator.hpp
new file mode 100644
index 0000000..c76993a
--- /dev/null
+++ b/3rdParty/Boost/src/boost/algorithm/string/detail/find_iterator.hpp
@@ -0,0 +1,87 @@
+//  Boost string_algo library find_iterator.hpp header file  ---------------------------//
+
+//  Copyright Pavol Droba 2002-2003.
+//
+// Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//          http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org/ for updates, documentation, and revision history.
+
+#ifndef BOOST_STRING_FIND_ITERATOR_DETAIL_HPP
+#define BOOST_STRING_FIND_ITERATOR_DETAIL_HPP
+
+#include <boost/algorithm/string/config.hpp>
+#include <boost/range/iterator_range.hpp>
+#include <boost/iterator/iterator_facade.hpp>
+#include <boost/iterator/iterator_categories.hpp>
+#include <boost/function.hpp>
+
+namespace boost {
+    namespace algorithm { 
+        namespace detail {
+
+//  find_iterator base -----------------------------------------------//
+
+            // Find iterator base
+            template<typename IteratorT>
+            class find_iterator_base
+            {
+            protected:
+                // typedefs
+                typedef IteratorT input_iterator_type;
+                typedef iterator_range<IteratorT> match_type;
+                typedef function2<
+                    match_type, 
+                    input_iterator_type, 
+                    input_iterator_type> finder_type;
+                
+            protected:
+            // Protected construction/destruction
+
+                // Default constructor
+                find_iterator_base() {};
+                // Copy construction
+                find_iterator_base( const find_iterator_base& Other ) :
+                    m_Finder(Other.m_Finder) {}
+                
+                // Constructor
+                template<typename FinderT>
+                find_iterator_base( FinderT Finder, int ) :
+                    m_Finder(Finder) {}
+
+                // Destructor
+                ~find_iterator_base() {}
+
+                // Find operation
+                match_type do_find( 
+                    input_iterator_type Begin,
+                    input_iterator_type End ) const
+                {
+                    if (!m_Finder.empty())
+                    {
+                        return m_Finder(Begin,End);
+                    }
+                    else
+                    {
+                        return match_type(End,End);
+                    }
+                }
+
+                // Check
+                bool is_null() const
+                {
+                    return m_Finder.empty();
+                }
+
+            private:
+                // Finder
+                finder_type m_Finder;
+            };
+
+       } // namespace detail
+    } // namespace algorithm
+} // namespace boost
+
+
+#endif  // BOOST_STRING_FIND_ITERATOR_DETAIL_HPP
diff --git a/3rdParty/Boost/src/boost/algorithm/string/detail/predicate.hpp b/3rdParty/Boost/src/boost/algorithm/string/detail/predicate.hpp
new file mode 100644
index 0000000..5acf3cc
--- /dev/null
+++ b/3rdParty/Boost/src/boost/algorithm/string/detail/predicate.hpp
@@ -0,0 +1,77 @@
+//  Boost string_algo library predicate.hpp header file  ---------------------------//
+
+//  Copyright Pavol Droba 2002-2003.
+//
+// Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//          http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org/ for updates, documentation, and revision history.
+
+#ifndef BOOST_STRING_PREDICATE_DETAIL_HPP
+#define BOOST_STRING_PREDICATE_DETAIL_HPP
+
+#include <iterator>
+#include <boost/algorithm/string/find.hpp>
+
+namespace boost {
+    namespace algorithm {
+        namespace detail {
+
+//  ends_with predicate implementation ----------------------------------//
+
+            template< 
+                typename ForwardIterator1T, 
+                typename ForwardIterator2T,
+                typename PredicateT>
+            inline bool ends_with_iter_select( 
+                ForwardIterator1T Begin, 
+                ForwardIterator1T End, 
+                ForwardIterator2T SubBegin,
+                ForwardIterator2T SubEnd,
+                PredicateT Comp,
+                std::bidirectional_iterator_tag)
+            {
+                ForwardIterator1T it=End;
+                ForwardIterator2T pit=SubEnd;
+                for(;it!=Begin && pit!=SubBegin;)
+                {
+                    if( !(Comp(*(--it),*(--pit))) )
+                        return false;
+                }
+
+                return pit==SubBegin;
+            }
+
+            template< 
+                typename ForwardIterator1T, 
+                typename ForwardIterator2T,
+                typename PredicateT>
+            inline bool ends_with_iter_select( 
+                ForwardIterator1T Begin, 
+                ForwardIterator1T End, 
+                ForwardIterator2T SubBegin,
+                ForwardIterator2T SubEnd,
+                PredicateT Comp,
+                std::forward_iterator_tag)
+            {
+                if ( SubBegin==SubEnd )
+                {
+                    // empty subsequence check
+                    return true;
+                }
+
+                iterator_range<ForwardIterator1T> Result
+                    =last_finder( 
+                        ::boost::make_iterator_range(SubBegin, SubEnd),
+                        Comp)(Begin, End);
+
+                return !Result.empty() && Result.end()==End;
+            }
+
+        } // namespace detail
+    } // namespace algorithm
+} // namespace boost
+
+
+#endif  // BOOST_STRING_PREDICATE_DETAIL_HPP
diff --git a/3rdParty/Boost/src/boost/algorithm/string/detail/trim.hpp b/3rdParty/Boost/src/boost/algorithm/string/detail/trim.hpp
new file mode 100644
index 0000000..1233e49
--- /dev/null
+++ b/3rdParty/Boost/src/boost/algorithm/string/detail/trim.hpp
@@ -0,0 +1,95 @@
+//  Boost string_algo library trim.hpp header file  ---------------------------//
+
+//  Copyright Pavol Droba 2002-2003.
+//
+// Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//          http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org/ for updates, documentation, and revision history.
+
+#ifndef BOOST_STRING_TRIM_DETAIL_HPP
+#define BOOST_STRING_TRIM_DETAIL_HPP
+
+#include <boost/algorithm/string/config.hpp>
+#include <boost/detail/iterator.hpp>
+
+namespace boost {
+    namespace algorithm {
+        namespace detail {
+
+//  trim iterator helper -----------------------------------------------//
+
+            template< typename ForwardIteratorT, typename PredicateT >
+            inline ForwardIteratorT trim_end_iter_select( 
+                ForwardIteratorT InBegin, 
+                ForwardIteratorT InEnd, 
+                PredicateT IsSpace,
+                std::forward_iterator_tag )
+            {
+                ForwardIteratorT TrimIt=InBegin;
+
+                for( ForwardIteratorT It=InBegin; It!=InEnd; ++It )
+                {
+                    if ( !IsSpace(*It) ) 
+                    {
+                        TrimIt=It;
+                        ++TrimIt;
+                    }
+                }
+
+                return TrimIt;
+            }
+
+            template< typename ForwardIteratorT, typename PredicateT >
+            inline ForwardIteratorT trim_end_iter_select( 
+                ForwardIteratorT InBegin, 
+                ForwardIteratorT InEnd, 
+                PredicateT IsSpace,
+                std::bidirectional_iterator_tag )
+            {
+                for( ForwardIteratorT It=InEnd; It!=InBegin;  )
+                {
+                    if ( !IsSpace(*(--It)) )
+                        return ++It;
+                }
+
+                return InBegin;
+            }
+   // Search for first non matching character from the beginning of the sequence
+            template< typename ForwardIteratorT, typename PredicateT >
+            inline ForwardIteratorT trim_begin( 
+                ForwardIteratorT InBegin, 
+                ForwardIteratorT InEnd, 
+                PredicateT IsSpace )
+            {
+                ForwardIteratorT It=InBegin;
+                for(; It!=InEnd; ++It )
+                {
+                    if (!IsSpace(*It))
+                        return It;
+                }
+
+                return It;
+            }
+
+            // Search for first non matching character from the end of the sequence
+            template< typename ForwardIteratorT, typename PredicateT >
+            inline ForwardIteratorT trim_end( 
+                ForwardIteratorT InBegin, 
+                ForwardIteratorT InEnd, 
+                PredicateT IsSpace )
+            {
+                typedef BOOST_STRING_TYPENAME boost::detail::
+                    iterator_traits<ForwardIteratorT>::iterator_category category;
+
+                return ::boost::algorithm::detail::trim_end_iter_select( InBegin, InEnd, IsSpace, category() );
+            }
+
+
+        } // namespace detail
+    } // namespace algorithm
+} // namespace boost
+
+
+#endif  // BOOST_STRING_TRIM_DETAIL_HPP
diff --git a/3rdParty/Boost/src/boost/algorithm/string/find.hpp b/3rdParty/Boost/src/boost/algorithm/string/find.hpp
new file mode 100644
index 0000000..304646d
--- /dev/null
+++ b/3rdParty/Boost/src/boost/algorithm/string/find.hpp
@@ -0,0 +1,334 @@
+//  Boost string_algo library find.hpp header file  ---------------------------//
+
+//  Copyright Pavol Droba 2002-2003.
+//
+// Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//          http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org/ for updates, documentation, and revision history.
+
+#ifndef BOOST_STRING_FIND_HPP
+#define BOOST_STRING_FIND_HPP
+
+#include <boost/algorithm/string/config.hpp>
+
+#include <boost/range/iterator_range.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/iterator.hpp>
+#include <boost/range/as_literal.hpp>
+
+#include <boost/algorithm/string/finder.hpp>
+#include <boost/algorithm/string/compare.hpp>
+#include <boost/algorithm/string/constants.hpp>
+
+/*! \file
+    Defines a set of find algorithms. The algorithms are searching
+    for a substring of the input. The result is given as an \c iterator_range
+    delimiting the substring.
+*/
+
+namespace boost {
+    namespace algorithm {
+
+//  Generic find -----------------------------------------------//
+
+        //! Generic find algorithm
+        /*!
+            Search the input using the given finder.
+
+            \param Input A string which will be searched.
+            \param Finder Finder object used for searching.
+            \return 
+                An \c iterator_range delimiting the match. 
+                Returned iterator is either \c RangeT::iterator or 
+                \c RangeT::const_iterator, depending on the constness of 
+                the input parameter.
+        */
+        template<typename RangeT, typename FinderT>
+        inline iterator_range< 
+            BOOST_STRING_TYPENAME range_iterator<RangeT>::type>
+        find( 
+            RangeT& Input, 
+            const FinderT& Finder)
+        {
+            iterator_range<BOOST_STRING_TYPENAME range_iterator<RangeT>::type> lit_input(::boost::as_literal(Input));
+
+            return Finder(::boost::begin(lit_input),::boost::end(lit_input));
+        }
+
+//  find_first  -----------------------------------------------//
+
+        //! Find first algorithm
+        /*!
+            Search for the first occurrence of the substring in the input. 
+            
+            \param Input A string which will be searched.
+            \param Search A substring to be searched for.
+            \return 
+                An \c iterator_range delimiting the match. 
+                Returned iterator is either \c RangeT::iterator or 
+                \c RangeT::const_iterator, depending on the constness of 
+                the input parameter.
+
+              \note This function provides the strong exception-safety guarantee
+        */
+        template<typename Range1T, typename Range2T>
+        inline iterator_range< 
+            BOOST_STRING_TYPENAME range_iterator<Range1T>::type>
+        find_first( 
+            Range1T& Input, 
+            const Range2T& Search)
+        {
+            return ::boost::algorithm::find(Input, ::boost::algorithm::first_finder(Search));
+        }
+
+        //! Find first algorithm ( case insensitive )
+        /*!
+            Search for the first occurence of the substring in the input. 
+            Searching is case insensitive.
+            
+            \param Input A string which will be searched.
+            \param Search A substring to be searched for.
+            \param Loc A locale used for case insensitive comparison
+            \return 
+                An \c iterator_range delimiting the match. 
+                Returned iterator is either \c Range1T::iterator or 
+                \c Range1T::const_iterator, depending on the constness of 
+                the input parameter.
+
+            \note This function provides the strong exception-safety guarantee
+        */
+        template<typename Range1T, typename Range2T>
+        inline iterator_range< 
+            BOOST_STRING_TYPENAME range_iterator<Range1T>::type>
+        ifind_first( 
+            Range1T& Input, 
+            const Range2T& Search,
+            const std::locale& Loc=std::locale())
+        {
+            return ::boost::algorithm::find(Input, ::boost::algorithm::first_finder(Search,is_iequal(Loc)));
+        }
+
+//  find_last  -----------------------------------------------//
+
+        //! Find last algorithm
+        /*!
+            Search for the last occurrence of the substring in the input. 
+            
+            \param Input A string which will be searched.
+            \param Search A substring to be searched for.
+            \return 
+                An \c iterator_range delimiting the match. 
+                Returned iterator is either \c Range1T::iterator or 
+                \c Range1T::const_iterator, depending on the constness of 
+                the input parameter.
+
+            \note This function provides the strong exception-safety guarantee
+        */
+        template<typename Range1T, typename Range2T>
+        inline iterator_range< 
+            BOOST_STRING_TYPENAME range_iterator<Range1T>::type>
+        find_last( 
+            Range1T& Input, 
+            const Range2T& Search)
+        {
+            return ::boost::algorithm::find(Input, ::boost::algorithm::last_finder(Search));
+        }
+
+        //! Find last algorithm ( case insensitive )
+        /*!
+            Search for the last match a string in the input. 
+            Searching is case insensitive.
+            
+            \param Input A string which will be searched.
+            \param Search A substring to be searched for.
+            \param Loc A locale used for case insensitive comparison
+            \return 
+                An \c iterator_range delimiting the match. 
+                Returned iterator is either \c Range1T::iterator or 
+                \c Range1T::const_iterator, depending on the constness of 
+                the input parameter.
+        
+            \note This function provides the strong exception-safety guarantee    
+        */
+        template<typename Range1T, typename Range2T>
+        inline iterator_range< 
+            BOOST_STRING_TYPENAME range_iterator<Range1T>::type>
+        ifind_last( 
+            Range1T& Input, 
+            const Range2T& Search,
+            const std::locale& Loc=std::locale())
+        {
+            return ::boost::algorithm::find(Input, ::boost::algorithm::last_finder(Search, is_iequal(Loc)));
+        }
+
+//  find_nth ----------------------------------------------------------------------//
+
+        //! Find n-th algorithm 
+        /*!
+            Search for the n-th (zero-indexed) occurrence of the substring in the 
+            input.         
+            
+            \param Input A string which will be searched.
+            \param Search A substring to be searched for.
+            \param Nth An index (zero-indexed) of the match to be found.
+                For negative N, the matches are counted from the end of string.
+            \return 
+                An \c iterator_range delimiting the match. 
+                Returned iterator is either \c Range1T::iterator or 
+                \c Range1T::const_iterator, depending on the constness of 
+                the input parameter.
+        */
+        template<typename Range1T, typename Range2T>
+        inline iterator_range< 
+            BOOST_STRING_TYPENAME range_iterator<Range1T>::type>
+        find_nth( 
+            Range1T& Input, 
+            const Range2T& Search,
+            int Nth)
+        {
+            return ::boost::algorithm::find(Input, ::boost::algorithm::nth_finder(Search,Nth));
+        }
+
+        //! Find n-th algorithm ( case insensitive ).
+        /*!
+            Search for the n-th (zero-indexed) occurrence of the substring in the 
+            input. Searching is case insensitive.
+            
+            \param Input A string which will be searched.
+            \param Search A substring to be searched for.
+            \param Nth An index (zero-indexed) of the match to be found. 
+                For negative N, the matches are counted from the end of string.
+            \param Loc A locale used for case insensitive comparison
+            \return 
+                An \c iterator_range delimiting the match. 
+                Returned iterator is either \c Range1T::iterator or 
+                \c Range1T::const_iterator, depending on the constness of 
+                the input parameter.
+
+
+            \note This function provides the strong exception-safety guarantee
+        */
+        template<typename Range1T, typename Range2T>
+        inline iterator_range< 
+            BOOST_STRING_TYPENAME range_iterator<Range1T>::type>
+        ifind_nth( 
+            Range1T& Input, 
+            const Range2T& Search,
+            int Nth,
+            const std::locale& Loc=std::locale())
+        {
+            return ::boost::algorithm::find(Input, ::boost::algorithm::nth_finder(Search,Nth,is_iequal(Loc)));
+        }
+
+//  find_head ----------------------------------------------------------------------//
+
+        //! Find head algorithm
+        /*!
+            Get the head of the input. Head is a prefix of the string of the 
+            given size. If the input is shorter then required, whole input if considered 
+            to be the head.
+
+            \param Input An input string
+            \param N Length of the head
+                For N>=0, at most N characters are extracted.
+                For N<0, size(Input)-|N| characters are extracted.
+            \return 
+                An \c iterator_range delimiting the match. 
+                Returned iterator is either \c Range1T::iterator or 
+                \c Range1T::const_iterator, depending on the constness of 
+                the input parameter.
+
+            \note This function provides the strong exception-safety guarantee
+        */
+        template<typename RangeT>
+        inline iterator_range< 
+            BOOST_STRING_TYPENAME range_iterator<RangeT>::type>
+        find_head( 
+            RangeT& Input, 
+            int N)
+        {
+            return ::boost::algorithm::find(Input, ::boost::algorithm::head_finder(N));
+        }
+
+//  find_tail ----------------------------------------------------------------------//
+
+        //! Find tail algorithm
+        /*!
+            Get the tail of the input. Tail is a suffix of the string of the 
+            given size. If the input is shorter then required, whole input if considered 
+            to be the tail.
+
+            \param Input An input string
+            \param N Length of the tail. 
+                For N>=0, at most N characters are extracted.
+                For N<0, size(Input)-|N| characters are extracted.
+            \return 
+                An \c iterator_range delimiting the match. 
+                Returned iterator is either \c RangeT::iterator or 
+                \c RangeT::const_iterator, depending on the constness of 
+                the input parameter.
+
+
+            \note This function provides the strong exception-safety guarantee
+        */
+        template<typename RangeT>
+        inline iterator_range< 
+            BOOST_STRING_TYPENAME range_iterator<RangeT>::type>
+        find_tail( 
+            RangeT& Input, 
+            int N)
+        {
+            return ::boost::algorithm::find(Input, ::boost::algorithm::tail_finder(N));
+        }
+
+//  find_token --------------------------------------------------------------------//
+
+        //! Find token algorithm
+        /*!
+            Look for a given token in the string. Token is a character that matches the
+            given predicate.
+            If the "token compress mode" is enabled, adjacent tokens are considered to be one match.
+            
+            \param Input A input string.
+            \param Pred An unary predicate to identify a token
+            \param eCompress Enable/Disable compressing of adjacent tokens
+            \return 
+                An \c iterator_range delimiting the match. 
+                Returned iterator is either \c RangeT::iterator or 
+                \c RangeT::const_iterator, depending on the constness of 
+                the input parameter.
+        
+            \note This function provides the strong exception-safety guarantee    
+        */
+        template<typename RangeT, typename PredicateT>
+        inline iterator_range< 
+            BOOST_STRING_TYPENAME range_iterator<RangeT>::type>
+        find_token( 
+            RangeT& Input,
+            PredicateT Pred,
+            token_compress_mode_type eCompress=token_compress_off)
+        {
+            return ::boost::algorithm::find(Input, ::boost::algorithm::token_finder(Pred, eCompress));
+        }
+
+    } // namespace algorithm
+
+    // pull names to the boost namespace
+    using algorithm::find;
+    using algorithm::find_first;
+    using algorithm::ifind_first;
+    using algorithm::find_last;
+    using algorithm::ifind_last;
+    using algorithm::find_nth;
+    using algorithm::ifind_nth;
+    using algorithm::find_head;
+    using algorithm::find_tail;
+    using algorithm::find_token;
+
+} // namespace boost
+
+
+#endif  // BOOST_STRING_FIND_HPP
diff --git a/3rdParty/Boost/src/boost/algorithm/string/find_iterator.hpp b/3rdParty/Boost/src/boost/algorithm/string/find_iterator.hpp
new file mode 100644
index 0000000..72696c7
--- /dev/null
+++ b/3rdParty/Boost/src/boost/algorithm/string/find_iterator.hpp
@@ -0,0 +1,375 @@
+//  Boost string_algo library find_iterator.hpp header file  ---------------------------//
+
+//  Copyright Pavol Droba 2002-2004.
+//
+// Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//          http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org/ for updates, documentation, and revision history.
+
+#ifndef BOOST_STRING_FIND_ITERATOR_HPP
+#define BOOST_STRING_FIND_ITERATOR_HPP
+
+#include <boost/algorithm/string/config.hpp>
+#include <boost/iterator/iterator_facade.hpp>
+#include <boost/iterator/iterator_categories.hpp>
+
+#include <boost/range/iterator_range.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/iterator.hpp>
+#include <boost/range/as_literal.hpp>
+
+#include <boost/algorithm/string/detail/find_iterator.hpp>
+
+/*! \file
+    Defines find iterator classes. Find iterator repeatedly applies a Finder
+    to the specified input string to search for matches. Dereferencing
+    the iterator yields the current match or a range between the last and the current
+    match depending on the iterator used.
+*/
+
+namespace boost {
+    namespace algorithm { 
+
+//  find_iterator -----------------------------------------------//
+
+        //! find_iterator
+        /*!    
+            Find iterator encapsulates a Finder and allows
+            for incremental searching in a string.
+            Each increment moves the iterator to the next match.
+
+            Find iterator is a readable forward traversal iterator.
+
+            Dereferencing the iterator yields an iterator_range delimiting
+            the current match.
+        */
+        template<typename IteratorT>
+        class find_iterator : 
+            public iterator_facade<
+                find_iterator<IteratorT>,
+                const iterator_range<IteratorT>,
+                forward_traversal_tag >,
+            private detail::find_iterator_base<IteratorT>
+        {
+        private:
+            // facade support
+            friend class ::boost::iterator_core_access;
+
+        private:
+        // typedefs
+
+            typedef detail::find_iterator_base<IteratorT> base_type;
+            typedef BOOST_STRING_TYPENAME 
+                base_type::input_iterator_type input_iterator_type;
+            typedef BOOST_STRING_TYPENAME 
+                base_type::match_type match_type;
+
+        public:
+            //! Default constructor
+            /*!
+                Construct null iterator. All null iterators are equal.
+
+                \post eof()==true
+            */
+            find_iterator() {}
+
+            //! Copy constructor
+            /*!
+                Construct a copy of the find_iterator
+            */
+            find_iterator( const find_iterator& Other ) :
+                base_type(Other),
+                m_Match(Other.m_Match),
+                m_End(Other.m_End) {}
+
+            //! Constructor
+            /*!
+                Construct new find_iterator for a given finder
+                and a range.
+            */
+            template<typename FinderT>
+            find_iterator(
+                    IteratorT Begin,
+                    IteratorT End,
+                    FinderT Finder ) :
+                detail::find_iterator_base<IteratorT>(Finder,0),
+                m_Match(Begin,Begin),
+                m_End(End)
+            {
+                increment();
+            }
+
+            //! Constructor
+            /*!
+                Construct new find_iterator for a given finder
+                and a range.
+            */
+            template<typename FinderT, typename RangeT>
+            find_iterator(
+                    RangeT& Col,
+                    FinderT Finder ) :
+                detail::find_iterator_base<IteratorT>(Finder,0)
+            {
+                iterator_range<BOOST_STRING_TYPENAME range_iterator<RangeT>::type> lit_col(::boost::as_literal(Col));
+                m_Match=::boost::make_iterator_range(::boost::begin(lit_col), ::boost::begin(lit_col));
+                m_End=::boost::end(lit_col);
+
+                increment();
+            }
+
+        private:
+        // iterator operations
+
+            // dereference
+            const match_type& dereference() const
+            {
+                return m_Match;
+            }
+
+            // increment
+            void increment()
+            {
+                m_Match=this->do_find(m_Match.end(),m_End);
+            }
+
+            // comparison
+            bool equal( const find_iterator& Other ) const
+            {
+                bool bEof=eof();
+                bool bOtherEof=Other.eof();
+
+                return bEof || bOtherEof ? bEof==bOtherEof :
+                    (
+                        m_Match==Other.m_Match &&
+                        m_End==Other.m_End 
+                    );
+            }
+
+        public:
+        // operations
+
+            //! Eof check
+            /*!
+                Check the eof condition. Eof condition means that
+                there is nothing more to be searched i.e. find_iterator
+                is after the last match.
+            */
+            bool eof() const
+            {
+                return 
+                    this->is_null() || 
+                    ( 
+                        m_Match.begin() == m_End &&
+                        m_Match.end() == m_End
+                    );
+            }
+
+        private:
+        // Attributes
+            match_type m_Match;
+            input_iterator_type m_End;
+        };
+
+        //! find iterator construction helper
+        /*!
+         *    Construct a find iterator to iterate through the specified string
+         */
+        template<typename RangeT, typename FinderT>
+        inline find_iterator< 
+            BOOST_STRING_TYPENAME range_iterator<RangeT>::type>
+        make_find_iterator(
+            RangeT& Collection,
+            FinderT Finder)
+        {
+            return find_iterator<BOOST_STRING_TYPENAME range_iterator<RangeT>::type>(
+                Collection, Finder);
+        }
+
+//  split iterator -----------------------------------------------//
+
+        //! split_iterator
+        /*!    
+            Split iterator encapsulates a Finder and allows
+            for incremental searching in a string.
+            Unlike the find iterator, split iterator iterates
+            through gaps between matches.
+
+            Find iterator is a readable forward traversal iterator.
+
+            Dereferencing the iterator yields an iterator_range delimiting
+            the current match.
+        */
+        template<typename IteratorT>
+        class split_iterator : 
+            public iterator_facade<
+                split_iterator<IteratorT>,
+                const iterator_range<IteratorT>,
+                forward_traversal_tag >,
+            private detail::find_iterator_base<IteratorT>
+        {
+        private:
+            // facade support
+            friend class ::boost::iterator_core_access;
+
+        private:
+        // typedefs
+
+            typedef detail::find_iterator_base<IteratorT> base_type;
+            typedef BOOST_STRING_TYPENAME 
+                base_type::input_iterator_type input_iterator_type;
+            typedef BOOST_STRING_TYPENAME 
+                base_type::match_type match_type;
+
+        public:
+            //! Default constructor
+            /*!
+                Construct null iterator. All null iterators are equal.
+    
+                \post eof()==true
+            */
+            split_iterator() {}
+            //! Copy constructor
+            /*!
+                Construct a copy of the split_iterator
+            */
+            split_iterator( const split_iterator& Other ) :
+                base_type(Other),
+                m_Match(Other.m_Match),
+                m_Next(Other.m_Next),
+                m_End(Other.m_End),
+                m_bEof(Other.m_bEof)
+            {}
+
+            //! Constructor
+            /*!
+                Construct new split_iterator for a given finder
+                and a range.
+            */
+            template<typename FinderT>
+            split_iterator(
+                    IteratorT Begin,
+                    IteratorT End,
+                    FinderT Finder ) :
+                detail::find_iterator_base<IteratorT>(Finder,0),
+                m_Match(Begin,Begin),
+                m_Next(Begin),
+                m_End(End),
+                m_bEof(false)
+            {
+                increment();
+            }
+            //! Constructor
+            /*!
+                Construct new split_iterator for a given finder
+                and a collection.
+            */
+            template<typename FinderT, typename RangeT>
+            split_iterator(
+                    RangeT& Col,
+                    FinderT Finder ) :
+                detail::find_iterator_base<IteratorT>(Finder,0),
+                m_bEof(false)
+            {
+                iterator_range<BOOST_STRING_TYPENAME range_iterator<RangeT>::type> lit_col(::boost::as_literal(Col));
+                m_Match=make_iterator_range(::boost::begin(lit_col), ::boost::begin(lit_col));
+                m_Next=::boost::begin(lit_col);
+                m_End=::boost::end(lit_col);
+
+                increment();
+            }
+
+
+        private:
+        // iterator operations
+
+            // dereference
+            const match_type& dereference() const
+            {
+                return m_Match;
+            }
+
+            // increment
+            void increment()
+            {
+                match_type FindMatch=this->do_find( m_Next, m_End );
+
+                if(FindMatch.begin()==m_End && FindMatch.end()==m_End)
+                {
+                    if(m_Match.end()==m_End)
+                    {
+                        // Mark iterator as eof
+                        m_bEof=true;
+                    }
+                }
+
+                m_Match=match_type( m_Next, FindMatch.begin() );
+                m_Next=FindMatch.end();
+            }
+
+            // comparison
+            bool equal( const split_iterator& Other ) const
+            {
+                bool bEof=eof();
+                bool bOtherEof=Other.eof();
+
+                return bEof || bOtherEof ? bEof==bOtherEof :
+                    (
+                        m_Match==Other.m_Match &&
+                        m_Next==Other.m_Next &&
+                        m_End==Other.m_End
+                    );
+            }
+
+        public:
+        // operations
+
+            //! Eof check
+            /*!
+                Check the eof condition. Eof condition means that
+                there is nothing more to be searched i.e. find_iterator
+                is after the last match.
+            */
+            bool eof() const
+            {
+                return this->is_null() || m_bEof;
+            }
+
+        private:
+        // Attributes
+            match_type m_Match;
+            input_iterator_type m_Next;
+            input_iterator_type m_End;
+            bool m_bEof;
+        };
+
+        //! split iterator construction helper
+        /*!
+         *    Construct a split iterator to iterate through the specified collection
+         */
+        template<typename RangeT, typename FinderT>
+        inline split_iterator< 
+            BOOST_STRING_TYPENAME range_iterator<RangeT>::type>
+        make_split_iterator(
+            RangeT& Collection,
+            FinderT Finder)
+        {
+            return split_iterator<BOOST_STRING_TYPENAME range_iterator<RangeT>::type>(
+                Collection, Finder);
+        }
+
+
+    } // namespace algorithm
+
+    // pull names to the boost namespace
+    using algorithm::find_iterator;
+    using algorithm::make_find_iterator;
+    using algorithm::split_iterator;
+    using algorithm::make_split_iterator;
+
+} // namespace boost
+
+
+#endif  // BOOST_STRING_FIND_ITERATOR_HPP
diff --git a/3rdParty/Boost/src/boost/algorithm/string/iter_find.hpp b/3rdParty/Boost/src/boost/algorithm/string/iter_find.hpp
new file mode 100644
index 0000000..9e0245f
--- /dev/null
+++ b/3rdParty/Boost/src/boost/algorithm/string/iter_find.hpp
@@ -0,0 +1,193 @@
+//  Boost string_algo library iter_find.hpp header file  ---------------------------//
+
+//  Copyright Pavol Droba 2002-2003.
+//
+// Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//          http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org/ for updates, documentation, and revision history.
+
+#ifndef BOOST_STRING_ITER_FIND_HPP
+#define BOOST_STRING_ITER_FIND_HPP
+
+#include <boost/algorithm/string/config.hpp>
+#include <algorithm>
+#include <iterator>
+#include <boost/iterator/transform_iterator.hpp>
+
+#include <boost/range/iterator_range.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/iterator.hpp>
+#include <boost/range/value_type.hpp>
+#include <boost/range/as_literal.hpp>
+
+#include <boost/algorithm/string/concept.hpp>
+#include <boost/algorithm/string/find_iterator.hpp>
+#include <boost/algorithm/string/detail/util.hpp>
+
+/*! \file
+    Defines generic split algorithms. Split algorithms can be 
+    used to divide a sequence into several part according 
+    to a given criteria. Result is given as a 'container 
+    of containers' where elements are copies or references 
+    to extracted parts.
+
+    There are two algorithms provided. One iterates over matching
+    substrings, the other one over the gaps between these matches.
+*/
+
+namespace boost {
+    namespace algorithm {
+
+//  iterate find ---------------------------------------------------//
+
+        //! Iter find algorithm
+        /*!
+            This algorithm executes a given finder in iteration on the input,
+            until the end of input is reached, or no match is found.
+            Iteration is done using built-in find_iterator, so the real 
+            searching is performed only when needed.
+            In each iteration new match is found and added to the result.
+
+            \param Result A 'container container' to contain the result of search.
+                Both outer and inner container must have constructor taking a pair
+                of iterators as an argument.
+                Typical type of the result is 
+                    \c std::vector<boost::iterator_range<iterator>>
+                (each element of such a vector will container a range delimiting 
+                a match).
+            \param Input A container which will be searched.
+            \param Finder A Finder object used for searching
+            \return A reference the result
+
+            \note Prior content of the result will be overwritten.
+        */
+        template< 
+            typename SequenceSequenceT,
+            typename RangeT,
+            typename FinderT >
+        inline SequenceSequenceT&
+        iter_find(
+            SequenceSequenceT& Result,
+            RangeT& Input,
+            FinderT Finder )
+        {
+            BOOST_CONCEPT_ASSERT((
+                FinderConcept<
+                    FinderT,
+                    BOOST_STRING_TYPENAME range_iterator<RangeT>::type>
+                ));
+
+            iterator_range<BOOST_STRING_TYPENAME range_iterator<RangeT>::type> lit_input(::boost::as_literal(Input));
+
+            typedef BOOST_STRING_TYPENAME 
+                range_iterator<RangeT>::type input_iterator_type;
+            typedef find_iterator<input_iterator_type> find_iterator_type;
+            typedef detail::copy_iterator_rangeF<
+                BOOST_STRING_TYPENAME 
+                    range_value<SequenceSequenceT>::type,
+                input_iterator_type> copy_range_type;
+            
+            input_iterator_type InputEnd=::boost::end(lit_input);
+
+            typedef transform_iterator<copy_range_type, find_iterator_type>
+                transform_iter_type;
+    
+            transform_iter_type itBegin=
+                ::boost::make_transform_iterator( 
+                    find_iterator_type( ::boost::begin(lit_input), InputEnd, Finder ),
+                    copy_range_type());
+            
+            transform_iter_type itEnd=
+                ::boost::make_transform_iterator( 
+                    find_iterator_type(),
+                    copy_range_type());
+
+            SequenceSequenceT Tmp(itBegin, itEnd);
+                        
+            Result.swap(Tmp);
+            return Result;
+        }
+
+//  iterate split ---------------------------------------------------//
+
+        //! Split find algorithm
+        /*!
+            This algorithm executes a given finder in iteration on the input,
+            until the end of input is reached, or no match is found.
+            Iteration is done using built-in find_iterator, so the real 
+            searching is performed only when needed.
+            Each match is used as a separator of segments. These segments are then
+            returned in the result.
+
+            \param Result A 'container container' to container the result of search.
+                Both outer and inner container must have constructor taking a pair
+                of iterators as an argument.
+                Typical type of the result is 
+                    \c std::vector<boost::iterator_range<iterator>>
+                (each element of such a vector will container a range delimiting 
+                a match).
+            \param Input A container which will be searched.
+            \param Finder A finder object used for searching
+            \return A reference the result
+
+            \note Prior content of the result will be overwritten.
+        */
+        template< 
+            typename SequenceSequenceT,
+            typename RangeT,
+            typename FinderT >
+        inline SequenceSequenceT&
+        iter_split(
+            SequenceSequenceT& Result,
+            RangeT& Input,
+            FinderT Finder )
+        {
+            BOOST_CONCEPT_ASSERT((
+                FinderConcept<FinderT,
+                BOOST_STRING_TYPENAME range_iterator<RangeT>::type>
+                ));
+
+            iterator_range<BOOST_STRING_TYPENAME range_iterator<RangeT>::type> lit_input(::boost::as_literal(Input));
+
+            typedef BOOST_STRING_TYPENAME 
+                range_iterator<RangeT>::type input_iterator_type;
+            typedef split_iterator<input_iterator_type> find_iterator_type;
+            typedef detail::copy_iterator_rangeF<
+                BOOST_STRING_TYPENAME 
+                    range_value<SequenceSequenceT>::type,
+                input_iterator_type> copy_range_type;
+            
+            input_iterator_type InputEnd=::boost::end(lit_input);
+
+            typedef transform_iterator<copy_range_type, find_iterator_type>
+                transform_iter_type;
+    
+            transform_iter_type itBegin=
+                ::boost::make_transform_iterator( 
+                    find_iterator_type( ::boost::begin(lit_input), InputEnd, Finder ),
+                    copy_range_type() );
+
+            transform_iter_type itEnd=
+                ::boost::make_transform_iterator( 
+                    find_iterator_type(),
+                    copy_range_type() );
+            
+            SequenceSequenceT Tmp(itBegin, itEnd);
+
+            Result.swap(Tmp);
+            return Result;
+        }
+
+    } // namespace algorithm
+
+    // pull names to the boost namespace
+    using algorithm::iter_find;
+    using algorithm::iter_split;
+
+} // namespace boost
+
+
+#endif  // BOOST_STRING_ITER_FIND_HPP
diff --git a/3rdParty/Boost/src/boost/algorithm/string/join.hpp b/3rdParty/Boost/src/boost/algorithm/string/join.hpp
new file mode 100644
index 0000000..b871eb4
--- /dev/null
+++ b/3rdParty/Boost/src/boost/algorithm/string/join.hpp
@@ -0,0 +1,145 @@
+//  Boost string_algo library join.hpp header file  ---------------------------//
+
+//  Copyright Pavol Droba 2002-2006.
+//
+// Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//          http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org/ for updates, documentation, and revision history.
+
+#ifndef BOOST_STRING_JOIN_HPP
+#define BOOST_STRING_JOIN_HPP
+
+#include <boost/algorithm/string/config.hpp>
+#include <boost/algorithm/string/detail/sequence.hpp>
+#include <boost/range/value_type.hpp>
+#include <boost/range/as_literal.hpp>
+
+/*! \file
+    Defines join algorithm. 
+
+    Join algorithm is a counterpart to split algorithms.
+    It joins strings from a 'list' by adding user defined separator.
+    Additionally there is a version that allows simple filtering
+    by providing a predicate.
+*/
+
+namespace boost {
+    namespace algorithm {
+
+//  join --------------------------------------------------------------//
+
+        //! Join algorithm
+        /*!
+            This algorithm joins all strings in a 'list' into one long string.
+            Segments are concatenated by given separator.
+
+            \param Input A container that holds the input strings. It must be a container-of-containers.
+            \param Separator A string that will separate the joined segments.
+            \return Concatenated string.
+
+            \note This function provides the strong exception-safety guarantee
+        */
+        template< typename SequenceSequenceT, typename Range1T>
+        inline typename range_value<SequenceSequenceT>::type 
+        join(
+            const SequenceSequenceT& Input,
+            const Range1T& Separator)
+        {
+            // Define working types
+            typedef typename range_value<SequenceSequenceT>::type ResultT;
+            typedef typename range_const_iterator<SequenceSequenceT>::type InputIteratorT;
+
+            // Parse input
+            InputIteratorT itBegin=::boost::begin(Input);
+            InputIteratorT itEnd=::boost::end(Input);
+
+            // Construct container to hold the result
+            ResultT Result;
+            
+            // Append first element
+            if(itBegin!=itEnd)
+            {
+                detail::insert(Result, ::boost::end(Result), *itBegin);
+                ++itBegin;
+            }
+
+            for(;itBegin!=itEnd; ++itBegin)
+            {
+                // Add separator
+                detail::insert(Result, ::boost::end(Result), ::boost::as_literal(Separator));
+                // Add element
+                detail::insert(Result, ::boost::end(Result), *itBegin);
+            }
+
+            return Result;
+        }
+
+// join_if ----------------------------------------------------------//
+
+        //! Conditional join algorithm
+        /*!
+            This algorithm joins all strings in a 'list' into one long string.
+            Segments are concatenated by given separator. Only segments that
+            satisfy the predicate will be added to the result.
+
+            \param Input A container that holds the input strings. It must be a container-of-containers.
+            \param Separator A string that will separate the joined segments.
+            \param Pred A segment selection predicate
+            \return Concatenated string.
+
+            \note This function provides the strong exception-safety guarantee
+        */
+        template< typename SequenceSequenceT, typename Range1T, typename PredicateT>
+        inline typename range_value<SequenceSequenceT>::type 
+        join_if(
+            const SequenceSequenceT& Input,
+            const Range1T& Separator,
+            PredicateT Pred)
+        {
+            // Define working types
+            typedef typename range_value<SequenceSequenceT>::type ResultT;
+            typedef typename range_const_iterator<SequenceSequenceT>::type InputIteratorT;
+
+            // Parse input
+            InputIteratorT itBegin=::boost::begin(Input);
+            InputIteratorT itEnd=::boost::end(Input);
+
+            // Construct container to hold the result
+            ResultT Result;
+
+            // Roll to the first element that will be added
+            while(itBegin!=itEnd && !Pred(*itBegin)) ++itBegin;
+            // Add this element
+            if(itBegin!=itEnd)
+            {
+                detail::insert(Result, ::boost::end(Result), *itBegin);
+                ++itBegin;
+            }
+
+            for(;itBegin!=itEnd; ++itBegin)
+            {
+                if(Pred(*itBegin))
+                {
+                    // Add separator
+                    detail::insert(Result, ::boost::end(Result), ::boost::as_literal(Separator));
+                    // Add element
+                    detail::insert(Result, ::boost::end(Result), *itBegin);
+                }
+            }
+
+            return Result;
+        }
+
+    } // namespace algorithm
+
+    // pull names to the boost namespace
+    using algorithm::join;
+    using algorithm::join_if;
+
+} // namespace boost
+
+
+#endif  // BOOST_STRING_JOIN_HPP
+
diff --git a/3rdParty/Boost/src/boost/algorithm/string/predicate.hpp b/3rdParty/Boost/src/boost/algorithm/string/predicate.hpp
new file mode 100644
index 0000000..6642f42
--- /dev/null
+++ b/3rdParty/Boost/src/boost/algorithm/string/predicate.hpp
@@ -0,0 +1,475 @@
+//  Boost string_algo library predicate.hpp header file  ---------------------------//
+
+//  Copyright Pavol Droba 2002-2003.
+//
+// Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//          http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org/ for updates, documentation, and revision history.
+
+#ifndef BOOST_STRING_PREDICATE_HPP
+#define BOOST_STRING_PREDICATE_HPP
+
+#include <boost/algorithm/string/config.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/iterator.hpp>
+#include <boost/range/const_iterator.hpp>
+#include <boost/range/as_literal.hpp>
+#include <boost/range/iterator_range.hpp>
+
+#include <boost/algorithm/string/compare.hpp>
+#include <boost/algorithm/string/find.hpp>
+#include <boost/algorithm/string/detail/predicate.hpp>
+
+/*! \file boost/algorithm/string/predicate.hpp
+    Defines string-related predicates. 
+    The predicates determine whether a substring is contained in the input string 
+    under various conditions: a string starts with the substring, ends with the 
+    substring, simply contains the substring or if both strings are equal.
+    Additionaly the algorithm \c all() checks all elements of a container to satisfy a 
+    condition.
+
+    All predicates provide the strong exception guarantee.
+*/
+
+namespace boost {
+    namespace algorithm {
+
+//  starts_with predicate  -----------------------------------------------//
+
+        //! 'Starts with' predicate
+        /*!
+            This predicate holds when the test string is a prefix of the Input.
+            In other words, if the input starts with the test.
+            When the optional predicate is specified, it is used for character-wise
+            comparison.
+
+            \param Input An input sequence
+            \param Test A test sequence
+            \param Comp An element comparison predicate
+            \return The result of the test
+
+              \note This function provides the strong exception-safety guarantee
+        */
+        template<typename Range1T, typename Range2T, typename PredicateT>
+            inline bool starts_with( 
+            const Range1T& Input, 
+            const Range2T& Test,
+            PredicateT Comp)
+        {
+            iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range1T>::type> lit_input(::boost::as_literal(Input));
+            iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range2T>::type> lit_test(::boost::as_literal(Test));
+
+            typedef BOOST_STRING_TYPENAME 
+                range_const_iterator<Range1T>::type Iterator1T;
+            typedef BOOST_STRING_TYPENAME 
+                range_const_iterator<Range2T>::type Iterator2T;
+
+            Iterator1T InputEnd=::boost::end(lit_input);
+            Iterator2T TestEnd=::boost::end(lit_test);
+
+            Iterator1T it=::boost::begin(lit_input);
+            Iterator2T pit=::boost::begin(lit_test);
+            for(;
+                it!=InputEnd && pit!=TestEnd;
+                ++it,++pit)
+            {
+                if( !(Comp(*it,*pit)) )
+                    return false;
+            }
+
+            return pit==TestEnd;
+        }
+
+        //! 'Starts with' predicate
+        /*!
+            \overload
+        */
+        template<typename Range1T, typename Range2T>
+        inline bool starts_with( 
+            const Range1T& Input, 
+            const Range2T& Test)
+        {
+            return ::boost::algorithm::starts_with(Input, Test, is_equal());
+        }
+
+        //! 'Starts with' predicate ( case insensitive )
+        /*!
+            This predicate holds when the test string is a prefix of the Input.
+            In other words, if the input starts with the test.
+            Elements are compared case insensitively.
+
+            \param Input An input sequence
+            \param Test A test sequence
+            \param Loc A locale used for case insensitive comparison
+            \return The result of the test
+
+            \note This function provides the strong exception-safety guarantee
+        */
+        template<typename Range1T, typename Range2T>
+        inline bool istarts_with( 
+            const Range1T& Input, 
+            const Range2T& Test,
+            const std::locale& Loc=std::locale())
+        {
+            return ::boost::algorithm::starts_with(Input, Test, is_iequal(Loc));
+        }
+
+
+//  ends_with predicate  -----------------------------------------------//
+
+        //! 'Ends with' predicate
+        /*!
+            This predicate holds when the test string is a suffix of the Input.
+            In other words, if the input ends with the test.
+            When the optional predicate is specified, it is used for character-wise
+            comparison.
+
+
+            \param Input An input sequence
+            \param Test A test sequence
+            \param Comp An element comparison predicate
+            \return The result of the test
+
+              \note This function provides the strong exception-safety guarantee
+        */
+        template<typename Range1T, typename Range2T, typename PredicateT>
+        inline bool ends_with( 
+            const Range1T& Input, 
+            const Range2T& Test,
+            PredicateT Comp)
+        {
+            iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range1T>::type> lit_input(::boost::as_literal(Input));
+            iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range2T>::type> lit_test(::boost::as_literal(Test));
+
+            typedef BOOST_STRING_TYPENAME 
+                range_const_iterator<Range1T>::type Iterator1T;
+            typedef BOOST_STRING_TYPENAME boost::detail::
+                iterator_traits<Iterator1T>::iterator_category category;
+
+            return detail::
+                ends_with_iter_select( 
+                    ::boost::begin(lit_input), 
+                    ::boost::end(lit_input), 
+                    ::boost::begin(lit_test), 
+                    ::boost::end(lit_test), 
+                    Comp,
+                    category());
+        }
+
+
+        //! 'Ends with' predicate
+        /*!
+            \overload
+        */
+        template<typename Range1T, typename Range2T>
+        inline bool ends_with( 
+            const Range1T& Input, 
+            const Range2T& Test)
+        {
+            return ::boost::algorithm::ends_with(Input, Test, is_equal());
+        }
+
+        //! 'Ends with' predicate ( case insensitive )
+        /*!
+            This predicate holds when the test container is a suffix of the Input.
+            In other words, if the input ends with the test.
+            Elements are compared case insensitively.
+
+            \param Input An input sequence
+            \param Test A test sequence
+            \param Loc A locale used for case insensitive comparison
+            \return The result of the test
+
+            \note This function provides the strong exception-safety guarantee
+        */
+        template<typename Range1T, typename Range2T>
+        inline bool iends_with( 
+            const Range1T& Input, 
+            const Range2T& Test,
+            const std::locale& Loc=std::locale())
+        {
+            return ::boost::algorithm::ends_with(Input, Test, is_iequal(Loc));
+        }
+
+//  contains predicate  -----------------------------------------------//
+
+        //! 'Contains' predicate
+        /*!
+            This predicate holds when the test container is contained in the Input.
+            When the optional predicate is specified, it is used for character-wise
+            comparison.
+
+            \param Input An input sequence
+            \param Test A test sequence
+            \param Comp An element comparison predicate
+            \return The result of the test
+
+               \note This function provides the strong exception-safety guarantee
+        */
+        template<typename Range1T, typename Range2T, typename PredicateT>
+        inline bool contains( 
+            const Range1T& Input, 
+            const Range2T& Test,
+            PredicateT Comp)
+        {
+            iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range1T>::type> lit_input(::boost::as_literal(Input));
+            iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range2T>::type> lit_test(::boost::as_literal(Test));
+
+            if (::boost::empty(lit_test))
+            {
+                // Empty range is contained always
+                return true;
+            }
+            
+            // Use the temporary variable to make VACPP happy
+            bool bResult=(::boost::algorithm::first_finder(lit_test,Comp)(::boost::begin(lit_input), ::boost::end(lit_input)));
+            return bResult;
+        }
+
+        //! 'Contains' predicate
+        /*!
+            \overload
+        */
+        template<typename Range1T, typename Range2T>
+        inline bool contains( 
+            const Range1T& Input, 
+            const Range2T& Test)
+        {
+            return ::boost::algorithm::contains(Input, Test, is_equal());
+        }
+
+        //! 'Contains' predicate ( case insensitive )
+        /*!
+            This predicate holds when the test container is contained in the Input.
+            Elements are compared case insensitively.
+
+            \param Input An input sequence
+            \param Test A test sequence
+            \param Loc A locale used for case insensitive comparison
+            \return The result of the test
+
+            \note This function provides the strong exception-safety guarantee
+        */
+        template<typename Range1T, typename Range2T>
+        inline bool icontains( 
+            const Range1T& Input, 
+            const Range2T& Test, 
+            const std::locale& Loc=std::locale())
+        {
+            return ::boost::algorithm::contains(Input, Test, is_iequal(Loc));
+        }
+
+//  equals predicate  -----------------------------------------------//
+
+        //! 'Equals' predicate
+        /*!
+            This predicate holds when the test container is equal to the
+            input container i.e. all elements in both containers are same.
+            When the optional predicate is specified, it is used for character-wise
+            comparison.
+
+            \param Input An input sequence
+            \param Test A test sequence
+            \param Comp An element comparison predicate
+            \return The result of the test
+
+            \note This is a two-way version of \c std::equal algorithm
+
+            \note This function provides the strong exception-safety guarantee
+        */
+        template<typename Range1T, typename Range2T, typename PredicateT>
+        inline bool equals( 
+            const Range1T& Input, 
+            const Range2T& Test,
+            PredicateT Comp)
+        {
+            iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range1T>::type> lit_input(::boost::as_literal(Input));
+            iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range2T>::type> lit_test(::boost::as_literal(Test));
+
+            typedef BOOST_STRING_TYPENAME 
+                range_const_iterator<Range1T>::type Iterator1T;
+            typedef BOOST_STRING_TYPENAME 
+                range_const_iterator<Range2T>::type Iterator2T;
+                
+            Iterator1T InputEnd=::boost::end(lit_input);
+            Iterator2T TestEnd=::boost::end(lit_test);
+
+            Iterator1T it=::boost::begin(lit_input);
+            Iterator2T pit=::boost::begin(lit_test);
+            for(;
+                it!=InputEnd && pit!=TestEnd;
+                ++it,++pit)
+            {
+                if( !(Comp(*it,*pit)) )
+                    return false;
+            }
+
+            return  (pit==TestEnd) && (it==InputEnd);
+        }
+
+        //! 'Equals' predicate
+        /*!
+            \overload
+        */
+        template<typename Range1T, typename Range2T>
+        inline bool equals( 
+            const Range1T& Input, 
+            const Range2T& Test)
+        {
+            return ::boost::algorithm::equals(Input, Test, is_equal());
+        }
+
+        //! 'Equals' predicate ( case insensitive )
+        /*!
+            This predicate holds when the test container is equal to the
+            input container i.e. all elements in both containers are same.
+            Elements are compared case insensitively.
+
+            \param Input An input sequence
+            \param Test A test sequence
+            \param Loc A locale used for case insensitive comparison
+            \return The result of the test
+
+            \note This is a two-way version of \c std::equal algorithm
+
+            \note This function provides the strong exception-safety guarantee
+        */
+        template<typename Range1T, typename Range2T>
+        inline bool iequals( 
+            const Range1T& Input, 
+            const Range2T& Test,
+            const std::locale& Loc=std::locale())
+        {
+            return ::boost::algorithm::equals(Input, Test, is_iequal(Loc));
+        }
+
+// lexicographical_compare predicate -----------------------------//
+
+        //! Lexicographical compare predicate
+        /*!
+             This predicate is an overload of std::lexicographical_compare
+             for range arguments
+
+             It check whether the first argument is lexicographically less
+             then the second one.
+
+             If the optional predicate is specified, it is used for character-wise
+             comparison
+
+             \param Arg1 First argument 
+             \param Arg2 Second argument
+             \param Pred Comparison predicate
+             \return The result of the test
+
+             \note This function provides the strong exception-safety guarantee
+         */
+        template<typename Range1T, typename Range2T, typename PredicateT>
+        inline bool lexicographical_compare(
+            const Range1T& Arg1,
+            const Range2T& Arg2,
+            PredicateT Pred)
+        {
+            iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range1T>::type> lit_arg1(::boost::as_literal(Arg1));
+            iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range2T>::type> lit_arg2(::boost::as_literal(Arg2));
+
+            return std::lexicographical_compare(
+                ::boost::begin(lit_arg1),
+                ::boost::end(lit_arg1),
+                ::boost::begin(lit_arg2),
+                ::boost::end(lit_arg2),
+                Pred);
+        }
+
+        //! Lexicographical compare predicate
+        /*!
+            \overload
+         */
+        template<typename Range1T, typename Range2T>
+            inline bool lexicographical_compare(
+            const Range1T& Arg1,
+            const Range2T& Arg2)
+        {
+            return ::boost::algorithm::lexicographical_compare(Arg1, Arg2, is_less());
+        }
+
+        //! Lexicographical compare predicate (case-insensitive)
+        /*!
+            This predicate is an overload of std::lexicographical_compare
+            for range arguments.
+            It check whether the first argument is lexicographically less
+            then the second one.
+            Elements are compared case insensitively
+
+
+             \param Arg1 First argument 
+             \param Arg2 Second argument
+             \param Loc A locale used for case insensitive comparison
+             \return The result of the test
+
+             \note This function provides the strong exception-safety guarantee
+         */
+        template<typename Range1T, typename Range2T>
+        inline bool ilexicographical_compare(
+            const Range1T& Arg1,
+            const Range2T& Arg2,
+            const std::locale& Loc=std::locale())
+        {
+            return ::boost::algorithm::lexicographical_compare(Arg1, Arg2, is_iless(Loc));
+        }
+        
+
+//  all predicate  -----------------------------------------------//
+
+        //! 'All' predicate
+        /*!
+            This predicate holds it all its elements satisfy a given 
+            condition, represented by the predicate.
+            
+            \param Input An input sequence
+            \param Pred A predicate
+            \return The result of the test
+
+            \note This function provides the strong exception-safety guarantee
+        */
+        template<typename RangeT, typename PredicateT>
+        inline bool all( 
+            const RangeT& Input, 
+            PredicateT Pred)
+        {
+            iterator_range<BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> lit_input(::boost::as_literal(Input));
+
+            typedef BOOST_STRING_TYPENAME 
+                range_const_iterator<RangeT>::type Iterator1T;
+
+            Iterator1T InputEnd=::boost::end(lit_input);
+            for( Iterator1T It=::boost::begin(lit_input); It!=InputEnd; ++It)
+            {
+                if (!Pred(*It))
+                    return false;
+            }
+            
+            return true;
+        }
+
+    } // namespace algorithm
+
+    // pull names to the boost namespace
+    using algorithm::starts_with;
+    using algorithm::istarts_with;
+    using algorithm::ends_with;
+    using algorithm::iends_with;
+    using algorithm::contains;
+    using algorithm::icontains;
+    using algorithm::equals;
+    using algorithm::iequals;
+    using algorithm::all;
+    using algorithm::lexicographical_compare;
+    using algorithm::ilexicographical_compare;
+
+} // namespace boost
+
+
+#endif  // BOOST_STRING_PREDICATE_HPP
diff --git a/3rdParty/Boost/src/boost/algorithm/string/predicate_facade.hpp b/3rdParty/Boost/src/boost/algorithm/string/predicate_facade.hpp
new file mode 100644
index 0000000..c8319f7
--- /dev/null
+++ b/3rdParty/Boost/src/boost/algorithm/string/predicate_facade.hpp
@@ -0,0 +1,42 @@
+//  Boost string_algo library predicate_facade.hpp header file  ---------------------------//
+
+//  Copyright Pavol Droba 2002-2003.
+//
+// Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//          http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org/ for updates, documentation, and revision history.
+
+#ifndef BOOST_STRING_PREDICATE_FACADE_HPP
+#define BOOST_STRING_PREDICATE_FACADE_HPP
+
+#include <boost/algorithm/string/config.hpp>
+
+/*
+ \file boost/algorith/string/predicate_facade.hpp
+ This file containes predicate_facade definition. This template class is used
+ to identify classification predicates, so they can be combined using
+ composition operators.
+*/
+
+namespace boost {
+    namespace algorithm {
+
+//  predicate facade ------------------------------------------------------//
+
+        //! Predicate facade
+        /*!
+            This class allows to recognize classification
+            predicates, so that they can be combined using
+            composition operators.
+            Every classification predicate must be derived from this class.
+        */
+        template<typename Derived>
+        struct predicate_facade {};
+
+    } // namespace algorithm
+} // namespace boost
+
+
+#endif  // BOOST_STRING_CLASSIFICATION_DETAIL_HPP
diff --git a/3rdParty/Boost/src/boost/algorithm/string/split.hpp b/3rdParty/Boost/src/boost/algorithm/string/split.hpp
new file mode 100644
index 0000000..cae712c
--- /dev/null
+++ b/3rdParty/Boost/src/boost/algorithm/string/split.hpp
@@ -0,0 +1,163 @@
+//  Boost string_algo library split.hpp header file  ---------------------------//
+
+//  Copyright Pavol Droba 2002-2006.
+//
+// Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//          http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org/ for updates, documentation, and revision history.
+
+#ifndef BOOST_STRING_SPLIT_HPP
+#define BOOST_STRING_SPLIT_HPP
+
+#include <boost/algorithm/string/config.hpp>
+
+#include <boost/algorithm/string/iter_find.hpp>
+#include <boost/algorithm/string/finder.hpp>
+#include <boost/algorithm/string/compare.hpp>
+
+/*! \file
+    Defines basic split algorithms. 
+    Split algorithms can be used to divide a string
+    into several parts according to given criteria.
+    
+    Each part is copied and added as a new element to the
+    output container.
+    Thus the result container must be able to hold copies
+    of the matches (in a compatible structure like std::string) or
+    a reference to it (e.g. using the iterator range class).
+    Examples of such a container are \c std::vector<std::string>
+    or \c std::list<boost::iterator_range<std::string::iterator>>
+*/
+
+namespace boost {
+    namespace algorithm {
+
+//  find_all  ------------------------------------------------------------//
+
+        //! Find all algorithm
+        /*!
+            This algorithm finds all occurrences of the search string
+            in the input.
+            
+            Each part is copied and added as a new element to the
+            output container.
+            Thus the result container must be able to hold copies
+            of the matches (in a compatible structure like std::string) or
+            a reference to it (e.g. using the iterator range class).
+            Examples of such a container are \c std::vector<std::string>
+            or \c std::list<boost::iterator_range<std::string::iterator>>
+
+            \param Result A container that can hold copies of references to the substrings
+            \param Input A container which will be searched.
+            \param Search A substring to be searched for.
+            \return A reference the result
+
+            \note Prior content of the result will be overwritten.
+
+            \note This function provides the strong exception-safety guarantee
+        */
+        template< typename SequenceSequenceT, typename Range1T, typename Range2T >
+        inline SequenceSequenceT& find_all(
+            SequenceSequenceT& Result,
+            Range1T& Input,
+            const Range2T& Search)
+        {
+            return ::boost::algorithm::iter_find(
+                Result,
+                Input,
+                ::boost::algorithm::first_finder(Search) );        
+        }
+
+        //! Find all algorithm ( case insensitive ) 
+        /*!
+            This algorithm finds all occurrences of the search string
+            in the input. 
+            Each part is copied and added as a new element to the
+            output container. Thus the result container must be able to hold copies
+            of the matches (in a compatible structure like std::string) or
+            a reference to it (e.g. using the iterator range class).
+            Examples of such a container are \c std::vector<std::string>
+            or \c std::list<boost::iterator_range<std::string::iterator>>
+
+            Searching is case insensitive.
+
+            \param Result A container that can hold copies of references to the substrings
+            \param Input A container which will be searched.
+            \param Search A substring to be searched for.
+            \param Loc A locale used for case insensitive comparison
+            \return A reference the result
+
+            \note Prior content of the result will be overwritten.
+
+            \note This function provides the strong exception-safety guarantee
+        */
+        template< typename SequenceSequenceT, typename Range1T, typename Range2T >
+        inline SequenceSequenceT& ifind_all(
+            SequenceSequenceT& Result,
+            Range1T& Input,
+            const Range2T& Search,
+            const std::locale& Loc=std::locale() )
+        {
+            return ::boost::algorithm::iter_find(
+                Result,
+                Input,
+                ::boost::algorithm::first_finder(Search, is_iequal(Loc) ) );        
+        }
+
+
+//  tokenize  -------------------------------------------------------------//
+
+        //! Split algorithm
+        /*! 
+            Tokenize expression. This function is equivalent to C strtok. Input
+            sequence is split into tokens, separated by separators. Separators 
+            are given by means of the predicate.
+
+            Each part is copied and added as a new element to the
+            output container.
+            Thus the result container must be able to hold copies
+            of the matches (in a compatible structure like std::string) or
+            a reference to it (e.g. using the iterator range class).
+            Examples of such a container are \c std::vector<std::string>
+            or \c std::list<boost::iterator_range<std::string::iterator>>
+    
+            \param Result A container that can hold copies of references to the substrings          
+            \param Input A container which will be searched.
+            \param Pred A predicate to identify separators. This predicate is 
+                supposed to return true if a given element is a separator.
+            \param eCompress If eCompress argument is set to token_compress_on, adjacent 
+                separators are merged together. Otherwise, every two separators
+                delimit a token.
+            \return A reference the result
+
+            \note Prior content of the result will be overwritten.
+
+            \note This function provides the strong exception-safety guarantee
+        */
+        template< typename SequenceSequenceT, typename RangeT, typename PredicateT >
+        inline SequenceSequenceT& split(
+            SequenceSequenceT& Result,
+            RangeT& Input,
+            PredicateT Pred,
+            token_compress_mode_type eCompress=token_compress_off )
+        {
+            return ::boost::algorithm::iter_split(
+                Result,
+                Input,
+                ::boost::algorithm::token_finder( Pred, eCompress ) );         
+        }
+
+    } // namespace algorithm
+
+    // pull names to the boost namespace
+    using algorithm::find_all;
+    using algorithm::ifind_all;
+    using algorithm::split;    
+
+} // namespace boost
+
+
+#endif  // BOOST_STRING_SPLIT_HPP
+
diff --git a/3rdParty/Boost/src/boost/algorithm/string/std/list_traits.hpp b/3rdParty/Boost/src/boost/algorithm/string/std/list_traits.hpp
new file mode 100644
index 0000000..ce2379d
--- /dev/null
+++ b/3rdParty/Boost/src/boost/algorithm/string/std/list_traits.hpp
@@ -0,0 +1,85 @@
+//  Boost string_algo library list_traits.hpp header file  ---------------------------//
+
+//  Copyright Pavol Droba 2002-2003.
+//
+// Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//          http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org/ for updates, documentation, and revision history.
+
+#ifndef BOOST_STRING_STD_LIST_TRAITS_HPP
+#define BOOST_STRING_STD_LIST_TRAITS_HPP
+
+#include <boost/algorithm/string/yes_no_type.hpp>
+#include <list>
+#include <boost/algorithm/string/sequence_traits.hpp>
+
+namespace boost {
+    namespace algorithm {
+
+//  std::list<> traits  -----------------------------------------------//
+
+#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+
+        // stable iterators tester
+        template<typename T, typename AllocT>
+        yes_type has_stable_iterators_tester( const ::std::list<T,AllocT>* );
+
+        // const time insert tester
+        template<typename T, typename AllocT>
+        yes_type has_const_time_insert_tester( const ::std::list<T,AllocT>* );
+
+        // const time erase tester
+        template<typename T, typename AllocT>
+        yes_type has_const_time_erase_tester( const ::std::list<T,AllocT>* );
+
+
+#else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+
+        // stable iterators trait
+        template<typename T, typename AllocT>
+        class has_stable_iterators< ::std::list<T,AllocT> >
+        {
+        public:
+#if BOOST_WORKAROUND( __IBMCPP__, <= 600 )
+            enum { value = true };
+#else
+            BOOST_STATIC_CONSTANT(bool, value=true);
+#endif // BOOST_WORKAROUND( __IBMCPP__, <= 600 )
+            typedef mpl::bool_<has_stable_iterators<T>::value> type;
+        };
+
+        // const time insert trait
+        template<typename T, typename AllocT>
+        class has_const_time_insert< ::std::list<T,AllocT> >
+        {
+        public:
+#if BOOST_WORKAROUND( __IBMCPP__, <= 600 )
+            enum { value = true };
+#else
+            BOOST_STATIC_CONSTANT(bool, value=true);
+#endif // BOOST_WORKAROUND( __IBMCPP__, <= 600 )
+            typedef mpl::bool_<has_const_time_insert<T>::value> type;
+        };
+
+        // const time erase trait
+        template<typename T, typename AllocT>
+        class has_const_time_erase< ::std::list<T,AllocT> >
+        {
+        public:
+#if BOOST_WORKAROUND( __IBMCPP__, <= 600 )
+            enum { value = true };
+#else
+            BOOST_STATIC_CONSTANT(bool, value=true);
+#endif // BOOST_WORKAROUND( __IBMCPP__, <= 600 )
+            typedef mpl::bool_<has_const_time_erase<T>::value> type;
+        };
+#endif
+
+
+    } // namespace algorithm
+} // namespace boost
+
+
+#endif  // BOOST_STRING_STD_LIST_TRAITS_HPP
diff --git a/3rdParty/Boost/src/boost/algorithm/string/std/slist_traits.hpp b/3rdParty/Boost/src/boost/algorithm/string/std/slist_traits.hpp
new file mode 100644
index 0000000..7b915a3
--- /dev/null
+++ b/3rdParty/Boost/src/boost/algorithm/string/std/slist_traits.hpp
@@ -0,0 +1,85 @@
+//  Boost string_algo library slist_traits.hpp header file  ---------------------------//
+
+//  Copyright Pavol Droba 2002-2003. 
+//
+// Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//          http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org/ for updates, documentation, and revision history.
+
+#ifndef BOOST_STRING_STD_SLIST_TRAITS_HPP
+#define BOOST_STRING_STD_SLIST_TRAITS_HPP
+
+#include <boost/algorithm/string/config.hpp>
+#include <boost/algorithm/string/yes_no_type.hpp>
+#include BOOST_SLIST_HEADER 
+#include <boost/algorithm/string/sequence_traits.hpp>
+
+namespace boost {
+    namespace algorithm {
+
+//  SGI's std::slist<> traits  -----------------------------------------------//
+
+#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+
+        // stable iterators tester
+        template<typename T, typename AllocT>
+        yes_type has_stable_iterators_tester( const BOOST_STD_EXTENSION_NAMESPACE::slist<T,AllocT>* );
+
+        // const time insert tester
+        template<typename T, typename AllocT>
+        yes_type has_const_time_insert_tester( const BOOST_STD_EXTENSION_NAMESPACE::slist<T,AllocT>* );
+
+        // const time erase tester
+        template<typename T, typename AllocT>
+        yes_type has_const_time_erase_tester( const BOOST_STD_EXTENSION_NAMESPACE::slist<T,AllocT>* );
+
+#else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+
+    // stable iterators trait
+        template<typename T, typename AllocT>
+        class has_stable_iterators< BOOST_STD_EXTENSION_NAMESPACE::slist<T,AllocT> >
+        {
+        public:
+#if BOOST_WORKAROUND( __IBMCPP__, <= 600 )
+            enum { value = true };
+#else
+            BOOST_STATIC_CONSTANT(bool, value=true);
+#endif // BOOST_WORKAROUND( __IBMCPP__, <= 600 )
+            typedef mpl::bool_<has_stable_iterators<T>::value> type;
+        };
+
+    // const time insert trait
+        template<typename T, typename AllocT>
+        class has_const_time_insert< BOOST_STD_EXTENSION_NAMESPACE::slist<T,AllocT> >
+        {
+        public:
+#if BOOST_WORKAROUND( __IBMCPP__, <= 600 )
+            enum { value = true };
+#else
+            BOOST_STATIC_CONSTANT(bool, value=true);
+#endif // BOOST_WORKAROUND( __IBMCPP__, <= 600 )
+            typedef mpl::bool_<has_const_time_insert<T>::value> type;
+        };
+
+    // const time erase trait
+        template<typename T, typename AllocT>
+        class has_const_time_erase< BOOST_STD_EXTENSION_NAMESPACE::slist<T,AllocT> >
+        {
+        public:
+#if BOOST_WORKAROUND( __IBMCPP__, <= 600 )
+            enum { value = true };
+#else
+            BOOST_STATIC_CONSTANT(bool, value=true);
+#endif // BOOST_WORKAROUND( __IBMCPP__, <= 600 )
+            typedef mpl::bool_<has_const_time_erase<T>::value> type;
+        };
+#endif
+
+
+    } // namespace algorithm
+} // namespace boost
+
+
+#endif  // BOOST_STRING_STD_LIST_TRAITS_HPP
diff --git a/3rdParty/Boost/src/boost/algorithm/string/std/string_traits.hpp b/3rdParty/Boost/src/boost/algorithm/string/std/string_traits.hpp
new file mode 100644
index 0000000..c466d26
--- /dev/null
+++ b/3rdParty/Boost/src/boost/algorithm/string/std/string_traits.hpp
@@ -0,0 +1,52 @@
+//  Boost string_algo library string_traits.hpp header file  ---------------------------//
+
+//  Copyright Pavol Droba 2002-2003.
+//
+// Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//          http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org/ for updates, documentation, and revision history.
+
+#ifndef BOOST_STRING_STD_STRING_TRAITS_HPP
+#define BOOST_STRING_STD_STRING_TRAITS_HPP
+
+#include <boost/algorithm/string/yes_no_type.hpp>
+#include <string>
+#include <boost/algorithm/string/sequence_traits.hpp>
+
+namespace boost {
+    namespace algorithm {
+
+//  std::basic_string<> traits  -----------------------------------------------//
+
+#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+
+        // native replace tester
+        template<typename T, typename TraitsT, typename AllocT>
+        yes_type has_native_replace_tester( const std::basic_string<T, TraitsT, AllocT>* );
+
+#else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+
+    // native replace trait
+        template<typename T, typename TraitsT, typename AllocT>
+        class has_native_replace< std::basic_string<T, TraitsT, AllocT> >
+        {
+        public:
+#if BOOST_WORKAROUND( __IBMCPP__, <= 600 )
+            enum { value = true } ;
+#else
+            BOOST_STATIC_CONSTANT(bool, value=true);
+#endif // BOOST_WORKAROUND( __IBMCPP__, <= 600 )
+
+        typedef mpl::bool_<has_native_replace<T>::value> type;
+        };
+
+
+#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+
+    } // namespace algorithm
+} // namespace boost
+
+
+#endif  // BOOST_STRING_LIST_TRAITS_HPP
diff --git a/3rdParty/Boost/src/boost/algorithm/string/std_containers_traits.hpp b/3rdParty/Boost/src/boost/algorithm/string/std_containers_traits.hpp
new file mode 100644
index 0000000..3f02246
--- /dev/null
+++ b/3rdParty/Boost/src/boost/algorithm/string/std_containers_traits.hpp
@@ -0,0 +1,26 @@
+//  Boost string_algo library std_containers_traits.hpp header file  ---------------------------//
+
+//  Copyright Pavol Droba 2002-2003.
+//
+// Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//          http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org/ for updates, documentation, and revision history.
+
+#ifndef BOOST_STRING_STD_CONTAINERS_TRAITS_HPP
+#define BOOST_STRING_STD_CONTAINERS_TRAITS_HPP
+
+/*!\file 
+    This file includes sequence traits for stl containers.
+*/
+
+#include <boost/config.hpp>
+#include <boost/algorithm/string/std/string_traits.hpp>
+#include <boost/algorithm/string/std/list_traits.hpp>
+
+#ifdef BOOST_HAS_SLIST
+#   include <boost/algorithm/string/std/slist_traits.hpp>
+#endif
+
+#endif  // BOOST_STRING_STD_CONTAINERS_TRAITS_HPP
diff --git a/3rdParty/Boost/src/boost/algorithm/string/trim.hpp b/3rdParty/Boost/src/boost/algorithm/string/trim.hpp
new file mode 100644
index 0000000..eb408a3
--- /dev/null
+++ b/3rdParty/Boost/src/boost/algorithm/string/trim.hpp
@@ -0,0 +1,398 @@
+//  Boost string_algo library trim.hpp header file  ---------------------------//
+
+//  Copyright Pavol Droba 2002-2003.
+//
+// Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//          http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org/ for updates, documentation, and revision history.
+
+#ifndef BOOST_STRING_TRIM_HPP
+#define BOOST_STRING_TRIM_HPP
+
+#include <boost/algorithm/string/config.hpp>
+
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/const_iterator.hpp>
+#include <boost/range/as_literal.hpp>
+#include <boost/range/iterator_range.hpp>
+
+#include <boost/algorithm/string/detail/trim.hpp>
+#include <boost/algorithm/string/classification.hpp>
+#include <locale>
+
+/*! \file
+    Defines trim algorithms.
+    Trim algorithms are used to remove trailing and leading spaces from a 
+    sequence (string). Space is recognized using given locales.
+
+    Parametric (\c _if) variants use a predicate (functor) to select which characters
+    are to be trimmed.. 
+    Functions take a selection predicate as a parameter, which is used to determine 
+    whether a character is a space. Common predicates are provided in classification.hpp header.
+
+*/
+
+namespace boost {
+    namespace algorithm {
+
+    //  left trim  -----------------------------------------------//
+
+
+        //! Left trim - parametric
+        /*!
+            Remove all leading spaces from the input. 
+            The supplied predicate is used to determine which characters are considered spaces.
+            The result is a trimmed copy of the input. It is returned as a sequence 
+            or copied to the output iterator
+
+            \param Output An output iterator to which the result will be copied
+            \param Input An input range
+            \param IsSpace An unary predicate identifying spaces
+            \return 
+                An output iterator pointing just after the last inserted character or
+                a copy of the input
+
+               \note The second variant of this function provides the strong exception-safety guarantee
+        */
+        template<typename OutputIteratorT, typename RangeT, typename PredicateT>
+        inline OutputIteratorT trim_left_copy_if( 
+            OutputIteratorT Output,
+            const RangeT& Input,
+            PredicateT IsSpace)
+        {
+            iterator_range<BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> lit_range(::boost::as_literal(Input));
+
+            std::copy( 
+                ::boost::algorithm::detail::trim_begin( 
+                    ::boost::begin(lit_range), 
+                    ::boost::end(lit_range), 
+                    IsSpace ),
+                ::boost::end(lit_range),
+                Output);
+
+            return Output;
+        }
+
+        //! Left trim - parametric
+        /*!
+            \overload
+        */
+        template<typename SequenceT, typename PredicateT>
+        inline SequenceT trim_left_copy_if(const SequenceT& Input, PredicateT IsSpace)
+        {
+            return SequenceT( 
+                ::boost::algorithm::detail::trim_begin( 
+                    ::boost::begin(Input), 
+                    ::boost::end(Input), 
+                    IsSpace ),
+                ::boost::end(Input));
+        }
+
+        //! Left trim - parametric
+        /*!
+            Remove all leading spaces from the input. 
+            The result is a trimmed copy of the input.
+
+            \param Input An input sequence
+            \param Loc a locale used for 'space' classification
+            \return A trimmed copy of the input
+
+            \note This function provides the strong exception-safety guarantee
+        */
+        template<typename SequenceT>
+        inline SequenceT trim_left_copy(const SequenceT& Input, const std::locale& Loc=std::locale())
+        {
+            return            
+                ::boost::algorithm::trim_left_copy_if(
+                    Input, 
+                    is_space(Loc));
+        }
+
+        //! Left trim
+        /*!
+            Remove all leading spaces from the input. The supplied predicate is 
+            used to determine which characters are considered spaces.
+            The input sequence is modified in-place.
+
+            \param Input An input sequence
+            \param IsSpace An unary predicate identifying spaces
+        */
+        template<typename SequenceT, typename PredicateT>
+        inline void trim_left_if(SequenceT& Input, PredicateT IsSpace)
+        {
+            Input.erase( 
+                ::boost::begin(Input),
+                ::boost::algorithm::detail::trim_begin( 
+                    ::boost::begin(Input), 
+                    ::boost::end(Input), 
+                    IsSpace));
+        }
+
+        //! Left trim
+        /*!
+            Remove all leading spaces from the input.
+            The Input sequence is modified in-place.
+
+            \param Input An input sequence
+            \param Loc A locale used for 'space' classification
+        */
+        template<typename SequenceT>
+        inline void trim_left(SequenceT& Input, const std::locale& Loc=std::locale())
+        {
+            ::boost::algorithm::trim_left_if( 
+                Input, 
+                is_space(Loc));
+        }
+
+    //  right trim  -----------------------------------------------//
+
+        //! Right trim - parametric
+        /*!
+            Remove all trailing spaces from the input.             
+            The supplied predicate is used to determine which characters are considered spaces.
+            The result is a trimmed copy of the input. It is returned as a sequence 
+            or copied to the output iterator
+
+            \param Output An output iterator to which the result will be copied
+            \param Input An input range
+            \param IsSpace An unary predicate identifying spaces
+            \return 
+                An output iterator pointing just after the last inserted character or
+                a copy of the input
+
+             \note The second variant of this function provides the strong exception-safety guarantee
+        */
+        template<typename OutputIteratorT, typename RangeT, typename PredicateT>
+        inline OutputIteratorT trim_right_copy_if( 
+            OutputIteratorT Output,
+            const RangeT& Input,
+            PredicateT IsSpace )
+        {
+            iterator_range<BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> lit_range(::boost::as_literal(Input));
+         
+            std::copy( 
+                ::boost::begin(lit_range),
+                ::boost::algorithm::detail::trim_end( 
+                    ::boost::begin(lit_range), 
+                    ::boost::end(lit_range), 
+                    IsSpace ),
+                Output );
+
+            return Output;
+        }
+
+        //! Right trim - parametric
+        /*!
+            \overload
+         */
+        template<typename SequenceT, typename PredicateT>
+        inline SequenceT trim_right_copy_if(const SequenceT& Input, PredicateT IsSpace)
+        {
+            return SequenceT( 
+                ::boost::begin(Input),
+                ::boost::algorithm::detail::trim_end( 
+                    ::boost::begin(Input), 
+                    ::boost::end(Input), 
+                    IsSpace)
+                );
+        }
+
+        //! Right trim
+        /*!
+            Remove all trailing spaces from the input. 
+            The result is a trimmed copy of the input
+
+            \param Input An input sequence
+            \param Loc A locale used for 'space' classification
+            \return A trimmed copy of the input
+
+            \note This function provides the strong exception-safety guarantee
+        */
+        template<typename SequenceT>
+        inline SequenceT trim_right_copy(const SequenceT& Input, const std::locale& Loc=std::locale())
+        {
+            return 
+                ::boost::algorithm::trim_right_copy_if( 
+                    Input, 
+                    is_space(Loc));
+        }
+
+            
+        //! Right trim - parametric
+        /*!
+            Remove all trailing spaces from the input.
+            The supplied predicate is used to determine which characters are considered spaces.
+            The input sequence is modified in-place.
+
+            \param Input An input sequence
+            \param IsSpace An unary predicate identifying spaces
+        */
+        template<typename SequenceT, typename PredicateT>
+        inline void trim_right_if(SequenceT& Input, PredicateT IsSpace)
+        {
+            Input.erase(
+                ::boost::algorithm::detail::trim_end( 
+                    ::boost::begin(Input), 
+                    ::boost::end(Input), 
+                    IsSpace ),
+                ::boost::end(Input)
+                );
+        }
+
+
+        //! Right trim
+        /*!
+            Remove all trailing spaces from the input. 
+            The input sequence is modified in-place.
+
+            \param Input An input sequence
+            \param Loc A locale used for 'space' classification
+        */
+        template<typename SequenceT>
+        inline void trim_right(SequenceT& Input, const std::locale& Loc=std::locale())
+        {
+            ::boost::algorithm::trim_right_if(
+                Input, 
+                is_space(Loc) );
+        }
+
+    //  both side trim  -----------------------------------------------//
+
+        //! Trim - parametric
+        /*!
+            Remove all trailing and leading spaces from the input. 
+            The supplied predicate is used to determine which characters are considered spaces.
+            The result is a trimmed copy of the input. It is returned as a sequence 
+            or copied to the output iterator
+
+            \param Output An output iterator to which the result will be copied
+            \param Input An input range
+            \param IsSpace An unary predicate identifying spaces
+            \return 
+                An output iterator pointing just after the last inserted character or
+                a copy of the input
+
+             \note The second variant of this function provides the strong exception-safety guarantee
+        */
+        template<typename OutputIteratorT, typename RangeT, typename PredicateT>
+        inline OutputIteratorT trim_copy_if( 
+            OutputIteratorT Output,
+            const RangeT& Input,
+            PredicateT IsSpace)
+        {
+            iterator_range<BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> lit_range(::boost::as_literal(Input));
+
+            BOOST_STRING_TYPENAME 
+                range_const_iterator<RangeT>::type TrimEnd=
+                ::boost::algorithm::detail::trim_end( 
+                    ::boost::begin(lit_range), 
+                    ::boost::end(lit_range), 
+                    IsSpace);
+
+            std::copy( 
+                detail::trim_begin( 
+                    ::boost::begin(lit_range), TrimEnd, IsSpace),
+                TrimEnd,
+                Output
+                );
+
+            return Output;
+        }
+
+        //! Trim - parametric
+        /*!
+            \overload
+         */
+        template<typename SequenceT, typename PredicateT>
+        inline SequenceT trim_copy_if(const SequenceT& Input, PredicateT IsSpace)
+        {
+            BOOST_STRING_TYPENAME 
+                range_const_iterator<SequenceT>::type TrimEnd=
+                    ::boost::algorithm::detail::trim_end( 
+                        ::boost::begin(Input), 
+                        ::boost::end(Input), 
+                        IsSpace);
+
+            return SequenceT( 
+                detail::trim_begin( 
+                    ::boost::begin(Input), 
+                    TrimEnd, 
+                    IsSpace),
+                TrimEnd
+                );
+        }
+
+        //! Trim
+        /*!
+            Remove all leading and trailing spaces from the input. 
+            The result is a trimmed copy of the input
+
+            \param Input An input sequence
+            \param Loc A locale used for 'space' classification
+            \return A trimmed copy of the input
+
+            \note This function provides the strong exception-safety guarantee
+        */
+        template<typename SequenceT>
+        inline SequenceT trim_copy( const SequenceT& Input, const std::locale& Loc=std::locale() )
+        {
+            return
+                ::boost::algorithm::trim_copy_if(
+                    Input, 
+                    is_space(Loc) );
+        }
+     
+        //! Trim
+        /*!
+            Remove all leading and trailing spaces from the input. 
+            The supplied predicate is used to determine which characters are considered spaces.
+            The input sequence is modified in-place.
+
+            \param Input An input sequence
+            \param IsSpace An unary predicate identifying spaces
+        */
+        template<typename SequenceT, typename PredicateT>
+        inline void trim_if(SequenceT& Input, PredicateT IsSpace)
+        {
+            ::boost::algorithm::trim_right_if( Input, IsSpace );
+            ::boost::algorithm::trim_left_if( Input, IsSpace );
+        }
+
+        //! Trim
+        /*!
+            Remove all leading and trailing spaces from the input. 
+            The input sequence is modified in-place.
+
+            \param Input An input sequence
+            \param Loc A locale used for 'space' classification
+        */
+        template<typename SequenceT>
+        inline void trim(SequenceT& Input, const std::locale& Loc=std::locale())
+        {
+            ::boost::algorithm::trim_if(
+                Input, 
+                is_space( Loc ) );
+        }
+
+    } // namespace algorithm 
+
+    // pull names to the boost namespace
+    using algorithm::trim_left;
+    using algorithm::trim_left_if;
+    using algorithm::trim_left_copy;
+    using algorithm::trim_left_copy_if;
+    using algorithm::trim_right;
+    using algorithm::trim_right_if;
+    using algorithm::trim_right_copy;
+    using algorithm::trim_right_copy_if;
+    using algorithm::trim;
+    using algorithm::trim_if;
+    using algorithm::trim_copy;
+    using algorithm::trim_copy_if;
+
+} // namespace boost
+
+#endif  // BOOST_STRING_TRIM_HPP
diff --git a/3rdParty/Boost/update.sh b/3rdParty/Boost/update.sh
index 5e5a9ef..4be35df 100755
--- a/3rdParty/Boost/update.sh
+++ b/3rdParty/Boost/update.sh
@@ -31,6 +31,7 @@ fi
 	variant.hpp \
 	regex.hpp \
 	boost/unordered_map.hpp \
+	boost/algorithm/string.hpp \
 	$TARGET_DIR
 
 rm -rf $TARGET_DIR/libs/config
diff --git a/Swift/QtUI/tmp/QtContextMenu.cpp b/Swift/QtUI/tmp/QtContextMenu.cpp
new file mode 100644
index 0000000..c74fb31
--- /dev/null
+++ b/Swift/QtUI/tmp/QtContextMenu.cpp
@@ -0,0 +1,14 @@
+/*
+ * Copyright (c) 2010 Kevin Smith
+ * Licensed under the GNU General Public License v3.
+ * See Documentation/Licenses/GPLv3.txt for more information.
+ */
+
+#include "ContextMenus/QtContextMenu.h"
+
+namespace Swift {
+
+QtContextMenu::~QtContextMenu() {
+}
+
+}
diff --git a/Swift/QtUI/tmp/QtContextMenu.h b/Swift/QtUI/tmp/QtContextMenu.h
new file mode 100644
index 0000000..9e73ef9
--- /dev/null
+++ b/Swift/QtUI/tmp/QtContextMenu.h
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2010 Kevin Smith
+ * Licensed under the GNU General Public License v3.
+ * See Documentation/Licenses/GPLv3.txt for more information.
+ */
+
+#pragma once
+
+namespace Swift {
+	class RosterItem;
+	class QtContextMenu {
+		public:
+			virtual ~QtContextMenu();
+
+			virtual void show(RosterItem* item) = 0;
+	};
+}
diff --git a/Swift/QtUI/tmp/QtRosterContextMenu.cpp b/Swift/QtUI/tmp/QtRosterContextMenu.cpp
new file mode 100644
index 0000000..a59a2f7
--- /dev/null
+++ b/Swift/QtUI/tmp/QtRosterContextMenu.cpp
@@ -0,0 +1,108 @@
+/*
+ * Copyright (c) 2010 Kevin Smith
+ * Licensed under the GNU General Public License v3.
+ * See Documentation/Licenses/GPLv3.txt for more information.
+ */
+
+#include "Swift/QtUI/ContextMenus/QtRosterContextMenu.h"
+
+#include <QInputDialog>
+#include <QLineEdit>
+#include <QMenu>
+#include <QDebug>
+#include <QDialog>
+#include <QMessageBox>
+
+#include <boost/shared_ptr.hpp>
+#include <boost/smart_ptr/make_shared.hpp>
+
+#include "Swiften/Roster/ContactRosterItem.h"
+#include "Swiften/Roster/GroupRosterItem.h"
+#include "Swiften/Base/String.h"
+#include "Swiften/Roster/Roster.h"
+#include "Swift/Controllers/UIEvents/UIEvent.h"
+#include "Swift/Controllers/UIEvents/RemoveRosterItemUIEvent.h"
+#include "Swift/Controllers/UIEvents/RenameRosterItemUIEvent.h"
+#include "Swift/QtUI/QtSwiftUtil.h"
+#include "Swift/QtUI/QtEditContactDialog.h"
+
+
+namespace Swift {
+
+QtRosterContextMenu::QtRosterContextMenu(UIEventStream* eventStream, QtTreeWidget* treeWidget) : eventStream_(eventStream), treeWidget_(treeWidget), item_(NULL) {
+}
+
+void QtRosterContextMenu::show(RosterItem* item) {
+	ContactRosterItem* contact = dynamic_cast<ContactRosterItem*>(item);
+	item_ = item;
+	QMenu contextMenu;
+	if (contact) {
+		contextMenu.addAction("Edit", this, SLOT(handleEditContact()));
+	}
+	GroupRosterItem* group = dynamic_cast<GroupRosterItem*>(item);
+	if (group) {
+		contextMenu.addAction("Rename", this, SLOT(handleRenameGroup()));
+	}
+	contextMenu.exec(QCursor::pos());
+}
+
+void QtRosterContextMenu::handleEditContact() {
+	ContactRosterItem* contact = dynamic_cast<ContactRosterItem*>(item_);
+	assert(contact);
+
+	// Figure out all the groups the contact is in
+	QList<QString> allGroups;
+	foreach (RosterItem* item, treeWidget_->getRoster()->getRoot()->getChildren()) {
+		GroupRosterItem* group = dynamic_cast<GroupRosterItem*>(item);
+		if (group) {
+			allGroups.push_back(P2QSTRING(group->getDisplayName()));
+		}
+	}
+
+	QtEditContactDialog editDialog(contact, allGroups, eventStream_);
+
+	if (groupDialog.exec() == QDialog::Accepted) {
+		eventStream_->send(groupDialog.getRegroupEvent());
+	}
+
+	/*	ContactRosterItem* contact = dynamic_cast<ContactRosterItem*>(item_);
+	QMessageBox msgBox;
+	msgBox.setWindowTitle("Confirm contact deletion");
+	msgBox.setText("Are you sure you want to delete this contact?");
+	msgBox.setInformativeText(QString("This will remove the contact '%1' from all groups they may be in.").arg(P2QSTRING(contact->getJID().toString())));
+	msgBox.setStandardButtons(QMessageBox::Yes | QMessageBox::No);
+	msgBox.setDefaultButton(QMessageBox::Yes);
+	int ret = msgBox.exec();
+	if (ret == QMessageBox::Yes) {
+		eventStream_->send(boost::shared_ptr<UIEvent>(new RemoveRosterItemUIEvent(contact->getJID())));
+	}*/
+
+
+/*	bool ok;
+	QString newName = QInputDialog::getText(NULL, "Rename contact", "New name for " + P2QSTRING(item_->getDisplayName()), QLineEdit::Normal, P2QSTRING(item_->getDisplayName()), &ok);
+	if (ok) {
+		eventStream_->send(boost::shared_ptr<UIEvent>(new RenameRosterItemUIEvent(contact->getJID(), Q2PSTRING(newName))));
+	}*/
+}
+
+void QtRosterContextMenu::handleRenameGroup() {
+	/*
+	GroupRosterItem* group = dynamic_cast<GroupRosterItem*>(item_);
+	assert(group);
+	bool ok;
+	QString newName = QInputDialog::getText(NULL, "Rename group", "New name for " + P2QSTRING(item_->getDisplayName()), QLineEdit::Normal, P2QSTRING(item_->getDisplayName()), &ok);
+	if (ok) {
+		std::vector<String> addedGroups;
+		std::vector<String> removedGroups;
+		addedGroups.push_back(Q2PSTRING(newName));
+		removedGroups.push_back(group->getDisplayName());
+		foreach (RosterItem* child, group->getChildren()) {
+			ContactRosterItem* contact = dynamic_cast<ContactRosterItem*>(child);
+			assert(contact);
+			eventStream_->send(boost::make_shared<RegroupRosterItemUIEvent>(contact->getJID(), addedGroups, removedGroups));
+		}
+	}
+	*/
+}
+
+}
diff --git a/Swift/QtUI/tmp/QtRosterContextMenu.h b/Swift/QtUI/tmp/QtRosterContextMenu.h
new file mode 100644
index 0000000..2357735
--- /dev/null
+++ b/Swift/QtUI/tmp/QtRosterContextMenu.h
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2010 Kevin Smith
+ * Licensed under the GNU General Public License v3.
+ * See Documentation/Licenses/GPLv3.txt for more information.
+ */
+
+#pragma once
+
+#include <QObject>
+
+#include "Swift/QtUI/ContextMenus/QtContextMenu.h"
+#include "Swift/QtUI/Roster/QtTreeWidget.h"
+#include "Swift/Controllers/UIEvents/UIEventStream.h"
+
+namespace Swift {
+	class RosterItem;
+	class QtRosterContextMenu : public QObject, public QtContextMenu {
+		Q_OBJECT
+		public:
+			QtRosterContextMenu(UIEventStream* eventStream, QtTreeWidget* treeWidget);
+			void show(RosterItem* item);
+
+		private slots:
+			void handleRenameGroup();
+			void handleEditContact();
+
+		private:
+			UIEventStream* eventStream_;
+			QtTreeWidget* treeWidget_;
+			RosterItem* item_;
+	};
+}
diff --git a/Swiften/Base/String.cpp b/Swiften/Base/String.cpp
index f549e6e..17d49c2 100644
--- a/Swiften/Base/String.cpp
+++ b/Swiften/Base/String.cpp
@@ -96,12 +96,6 @@ void String::replaceAll(char c, const String& s) {
 	}
 }
 
-String String::getLowerCase() const {
-	std::string lower(data_);
-	std::transform(lower.begin(), lower.end(), lower.begin(), ::tolower);
-	return String(lower);
-}
-
 std::vector<String> String::split(char c) const {
 	assert((c & 0x80) == 0);
 	std::vector<String> result;
diff --git a/Swiften/Base/String.h b/Swiften/Base/String.h
index b05edba..c87d82b 100644
--- a/Swiften/Base/String.h
+++ b/Swiften/Base/String.h
@@ -4,8 +4,9 @@
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 
-#ifndef SWIFTEN_STRING_H
-#define SWIFTEN_STRING_H
+#pragma once
+
+#include <boost/algorithm/string.hpp>
 
 #include <ostream>
 #include <string>
@@ -48,7 +49,10 @@ namespace Swift {
 			std::vector<String> split(char c) const;
 
 			size_t getLength() const;
-			String getLowerCase() const;
+
+			String getLowerCase() const {
+				return boost::to_lower_copy(data_);
+			}
 
 			void removeAll(char c);
 
@@ -59,7 +63,7 @@ namespace Swift {
 			}
 
 			bool beginsWith(const String& s) const {
-				return data_.substr(0, s.data_.size()) == s;
+				return boost::starts_with(data_, s.data_);
 			}
 
 			bool endsWith(char c) const { 
@@ -67,7 +71,7 @@ namespace Swift {
 			}
 
 			bool endsWith(const String& s) const {
-				return data_.substr(data_.size() - s.data_.size(), data_.npos) == s;
+				return boost::ends_with(data_, s.data_);
 			}
 
 			String getSubstring(size_t begin, size_t end) const {
@@ -139,5 +143,3 @@ namespace Swift {
 			std::string data_;
 	};
 }
-
-#endif
author	Remko Tronçon <git@el-tramo.be>	2011-02-13 10:13:40 (GMT)
committer	Remko Tronçon <git@el-tramo.be>	2011-02-13 10:37:59 (GMT)
commit	6872dd34f88b08568a4784fe46373a0af0b69165 (patch)
tree	d14eddb94afbfedb045510ba2d455d110d19b71f
parent	b734b6a5986703b6b10ea548c93af11f9df771bf (diff)
download	swift-contrib-6872dd34f88b08568a4784fe46373a0af0b69165.zip swift-contrib-6872dd34f88b08568a4784fe46373a0af0b69165.tar.bz2