diff --git a/Utilities/BGL/boost/algorithm/minmax.hpp b/Utilities/BGL/boost/algorithm/minmax.hpp
new file mode 100755
index 0000000000000000000000000000000000000000..014a7d21ad90e02562bde551b9d384b846112b27
--- /dev/null
+++ b/Utilities/BGL/boost/algorithm/minmax.hpp
@@ -0,0 +1,47 @@
+// (C) Copyright Herve Bronnimann 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)
+
+/*
+ Revision history:
+ 1 July 2004
+ Split the code into two headers to lessen dependence on
+ Boost.tuple. (Herve)
+ 26 June 2004
+ Added the code for the boost minmax library. (Herve)
+*/
+
+#ifndef BOOST_ALGORITHM_MINMAX_HPP
+#define BOOST_ALGORITHM_MINMAX_HPP
+
+/* PROPOSED STANDARD EXTENSIONS:
+ *
+ * minmax(a, b)
+ * Effect: (b<a) ? std::make_pair(b,a) : std::make_pair(a,b);
+ *
+ * minmax(a, b, comp)
+ * Effect: comp(b,a) ? std::make_pair(b,a) : std::make_pair(a,b);
+ *
+ */
+
+#include <boost/tuple/tuple.hpp> // for using pairs with boost::cref
+#include <boost/ref.hpp>
+
+namespace boost {
+
+ template <typename T>
+ tuple< T const&, T const& >
+ minmax(T const& a, T const& b) {
+ return (b<a) ? make_tuple(cref(b),cref(a)) : make_tuple(cref(a),cref(b));
+ }
+
+ template <typename T, class BinaryPredicate>
+ tuple< T const&, T const& >
+ minmax(T const& a, T const& b, BinaryPredicate comp) {
+ return comp(b,a) ? make_tuple(cref(b),cref(a)) : make_tuple(cref(a),cref(b));
+ }
+
+} // namespace boost
+
+#endif // BOOST_ALGORITHM_MINMAX_HPP
diff --git a/Utilities/BGL/boost/algorithm/minmax_element.hpp b/Utilities/BGL/boost/algorithm/minmax_element.hpp
new file mode 100755
index 0000000000000000000000000000000000000000..996ede036d3c1d3c75f69513d7fdd3cdcb70858a
--- /dev/null
+++ b/Utilities/BGL/boost/algorithm/minmax_element.hpp
@@ -0,0 +1,551 @@
+// (C) Copyright Herve Bronnimann 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)
+
+/*
+ Revision history:
+ 1 July 2004
+ Split the code into two headers to lessen dependence on
+ Boost.tuple. (Herve)
+ 26 June 2004
+ Added the code for the boost minmax library. (Herve)
+*/
+
+#ifndef BOOST_ALGORITHM_MINMAX_ELEMENT_HPP
+#define BOOST_ALGORITHM_MINMAX_ELEMENT_HPP
+
+/* PROPOSED STANDARD EXTENSIONS:
+ *
+ * minmax_element(first, last)
+ * Effect: std::make_pair( std::min_element(first, last),
+ * std::max_element(first, last) );
+ *
+ * minmax_element(first, last, comp)
+ * Effect: std::make_pair( std::min_element(first, last, comp),
+ * std::max_element(first, last, comp) );
+ */
+
+#include <utility> // for std::pair and std::make_pair
+
+namespace boost {
+
+ namespace detail { // for obtaining a uniform version of minmax_element
+ // that compiles with VC++ 6.0 -- avoid the iterator_traits by
+ // having comparison object over iterator, not over dereferenced value
+
+ template <typename Iterator>
+ struct less_over_iter {
+ bool operator()(Iterator const& it1,
+ Iterator const& it2) const { return *it1 < *it2; }
+ };
+
+ template <typename Iterator, class BinaryPredicate>
+ struct binary_pred_over_iter {
+ explicit binary_pred_over_iter(BinaryPredicate const& p ) : m_p( p ) {}
+ bool operator()(Iterator const& it1,
+ Iterator const& it2) const { return m_p(*it1, *it2); }
+ private:
+ BinaryPredicate m_p;
+ };
+
+ // common base for the two minmax_element overloads
+
+ template <typename ForwardIter, class Compare >
+ std::pair<ForwardIter,ForwardIter>
+ basic_minmax_element(ForwardIter first, ForwardIter last, Compare comp)
+ {
+ if (first == last)
+ return std::make_pair(last,last);
+
+ ForwardIter min_result = first;
+ ForwardIter max_result = first;
+
+ // if only one element
+ ForwardIter second = first; ++second;
+ if (second == last)
+ return std::make_pair(min_result, max_result);
+
+ // treat first pair separately (only one comparison for first two elements)
+ ForwardIter potential_min_result = last;
+ if (comp(first, second))
+ max_result = second;
+ else {
+ min_result = second;
+ potential_min_result = first;
+ }
+
+ // then each element by pairs, with at most 3 comparisons per pair
+ first = ++second; if (first != last) ++second;
+ while (second != last) {
+ if (comp(first, second)) {
+ if (comp(first, min_result)) {
+ min_result = first;
+ potential_min_result = last;
+ }
+ if (comp(max_result, second))
+ max_result = second;
+ } else {
+ if (comp(second, min_result)) {
+ min_result = second;
+ potential_min_result = first;
+ }
+ if (comp(max_result, first))
+ max_result = first;
+ }
+ first = ++second;
+ if (first != last) ++second;
+ }
+
+ // if odd number of elements, treat last element
+ if (first != last) { // odd number of elements
+ if (comp(first, min_result))
+ min_result = first, potential_min_result = last;
+ else if (comp(max_result, first))
+ max_result = first;
+ }
+
+ // resolve min_result being incorrect with one extra comparison
+ // (in which case potential_min_result is necessarily the correct result)
+ if (potential_min_result != last
+ && !comp(min_result, potential_min_result))
+ min_result = potential_min_result;
+
+ return std::make_pair(min_result,max_result);
+ }
+
+ } // namespace detail
+
+ template <typename ForwardIter>
+ std::pair<ForwardIter,ForwardIter>
+ minmax_element(ForwardIter first, ForwardIter last)
+ {
+ return detail::basic_minmax_element(first, last,
+ detail::less_over_iter<ForwardIter>() );
+ }
+
+ template <typename ForwardIter, class BinaryPredicate>
+ std::pair<ForwardIter,ForwardIter>
+ minmax_element(ForwardIter first, ForwardIter last, BinaryPredicate comp)
+ {
+ return detail::basic_minmax_element(first, last,
+ detail::binary_pred_over_iter<ForwardIter,BinaryPredicate>(comp) );
+ }
+
+}
+
+/* PROPOSED BOOST EXTENSIONS
+ * In the description below, [rfirst,rlast) denotes the reversed range
+ * of [first,last). Even though the iterator type of first and last may
+ * be only a Forward Iterator, it is possible to explain the semantics
+ * by assuming that it is a Bidirectional Iterator. In the sequel,
+ * reverse(ForwardIterator&) returns the reverse_iterator adaptor.
+ * This is not how the functions would be implemented!
+ *
+ * first_min_element(first, last)
+ * Effect: std::min_element(first, last);
+ *
+ * first_min_element(first, last, comp)
+ * Effect: std::min_element(first, last, comp);
+ *
+ * last_min_element(first, last)
+ * Effect: reverse( std::min_element(reverse(last), reverse(first)) );
+ *
+ * last_min_element(first, last, comp)
+ * Effect: reverse( std::min_element(reverse(last), reverse(first), comp) );
+ *
+ * first_max_element(first, last)
+ * Effect: std::max_element(first, last);
+ *
+ * first_max_element(first, last, comp)
+ * Effect: max_element(first, last);
+ *
+ * last_max_element(first, last)
+ * Effect: reverse( std::max_element(reverse(last), reverse(first)) );
+ *
+ * last_max_element(first, last, comp)
+ * Effect: reverse( std::max_element(reverse(last), reverse(first), comp) );
+ *
+ * first_min_first_max_element(first, last)
+ * Effect: std::make_pair( first_min_element(first, last),
+ * first_max_element(first, last) );
+ *
+ * first_min_first_max_element(first, last, comp)
+ * Effect: std::make_pair( first_min_element(first, last, comp),
+ * first_max_element(first, last, comp) );
+ *
+ * first_min_last_max_element(first, last)
+ * Effect: std::make_pair( first_min_element(first, last),
+ * last_max_element(first, last) );
+ *
+ * first_min_last_max_element(first, last, comp)
+ * Effect: std::make_pair( first_min_element(first, last, comp),
+ * last_max_element(first, last, comp) );
+ *
+ * last_min_first_max_element(first, last)
+ * Effect: std::make_pair( last_min_element(first, last),
+ * first_max_element(first, last) );
+ *
+ * last_min_first_max_element(first, last, comp)
+ * Effect: std::make_pair( last_min_element(first, last, comp),
+ * first_max_element(first, last, comp) );
+ *
+ * last_min_last_max_element(first, last)
+ * Effect: std::make_pair( last_min_element(first, last),
+ * last_max_element(first, last) );
+ *
+ * last_min_last_max_element(first, last, comp)
+ * Effect: std::make_pair( last_min_element(first, last, comp),
+ * last_max_element(first, last, comp) );
+ */
+
+namespace boost {
+
+ // Min_element and max_element variants
+
+ namespace detail { // common base for the overloads
+
+ template <typename ForwardIter, class BinaryPredicate>
+ ForwardIter
+ basic_first_min_element(ForwardIter first, ForwardIter last,
+ BinaryPredicate comp)
+ {
+ if (first == last) return last;
+ ForwardIter min_result = first;
+ while (++first != last)
+ if (comp(first, min_result))
+ min_result = first;
+ return min_result;
+ }
+
+ template <typename ForwardIter, class BinaryPredicate>
+ ForwardIter
+ basic_last_min_element(ForwardIter first, ForwardIter last,
+ BinaryPredicate comp)
+ {
+ if (first == last) return last;
+ ForwardIter min_result = first;
+ while (++first != last)
+ if (!comp(min_result, first))
+ min_result = first;
+ return min_result;
+ }
+
+ template <typename ForwardIter, class BinaryPredicate>
+ ForwardIter
+ basic_first_max_element(ForwardIter first, ForwardIter last,
+ BinaryPredicate comp)
+ {
+ if (first == last) return last;
+ ForwardIter max_result = first;
+ while (++first != last)
+ if (comp(max_result, first))
+ max_result = first;
+ return max_result;
+ }
+
+ template <typename ForwardIter, class BinaryPredicate>
+ ForwardIter
+ basic_last_max_element(ForwardIter first, ForwardIter last,
+ BinaryPredicate comp)
+ {
+ if (first == last) return last;
+ ForwardIter max_result = first;
+ while (++first != last)
+ if (!comp(first, max_result))
+ max_result = first;
+ return max_result;
+ }
+
+ } // namespace detail
+
+ template <typename ForwardIter>
+ ForwardIter
+ first_min_element(ForwardIter first, ForwardIter last)
+ {
+ return detail::basic_first_min_element(first, last,
+ detail::less_over_iter<ForwardIter>() );
+ }
+
+ template <typename ForwardIter, class BinaryPredicate>
+ ForwardIter
+ first_min_element(ForwardIter first, ForwardIter last, BinaryPredicate comp)
+ {
+ return detail::basic_first_min_element(first, last,
+ detail::binary_pred_over_iter<ForwardIter,BinaryPredicate>(comp) );
+ }
+
+ template <typename ForwardIter>
+ ForwardIter
+ last_min_element(ForwardIter first, ForwardIter last)
+ {
+ return detail::basic_last_min_element(first, last,
+ detail::less_over_iter<ForwardIter>() );
+ }
+
+ template <typename ForwardIter, class BinaryPredicate>
+ ForwardIter
+ last_min_element(ForwardIter first, ForwardIter last, BinaryPredicate comp)
+ {
+ return detail::basic_last_min_element(first, last,
+ detail::binary_pred_over_iter<ForwardIter,BinaryPredicate>(comp) );
+ }
+
+ template <typename ForwardIter>
+ ForwardIter
+ first_max_element(ForwardIter first, ForwardIter last)
+ {
+ return detail::basic_first_max_element(first, last,
+ detail::less_over_iter<ForwardIter>() );
+ }
+
+ template <typename ForwardIter, class BinaryPredicate>
+ ForwardIter
+ first_max_element(ForwardIter first, ForwardIter last, BinaryPredicate comp)
+ {
+ return detail::basic_first_max_element(first, last,
+ detail::binary_pred_over_iter<ForwardIter,BinaryPredicate>(comp) );
+ }
+
+ template <typename ForwardIter>
+ ForwardIter
+ last_max_element(ForwardIter first, ForwardIter last)
+ {
+ return detail::basic_last_max_element(first, last,
+ detail::less_over_iter<ForwardIter>() );
+ }
+
+ template <typename ForwardIter, class BinaryPredicate>
+ ForwardIter
+ last_max_element(ForwardIter first, ForwardIter last, BinaryPredicate comp)
+ {
+ return detail::basic_last_max_element(first, last,
+ detail::binary_pred_over_iter<ForwardIter,BinaryPredicate>(comp) );
+ }
+
+
+ // Minmax_element variants -- comments removed
+
+ namespace detail {
+
+ template <typename ForwardIter, class BinaryPredicate>
+ std::pair<ForwardIter,ForwardIter>
+ basic_first_min_last_max_element(ForwardIter first, ForwardIter last,
+ BinaryPredicate comp)
+ {
+ if (first == last)
+ return std::make_pair(last,last);
+
+ ForwardIter min_result = first;
+ ForwardIter max_result = first;
+
+ ForwardIter second = ++first;
+ if (second == last)
+ return std::make_pair(min_result, max_result);
+
+ if (comp(second, min_result))
+ min_result = second;
+ else
+ max_result = second;
+
+ first = ++second; if (first != last) ++second;
+ while (second != last) {
+ if (!comp(second, first)) {
+ if (comp(first, min_result))
+ min_result = first;
+ if (!comp(second, max_result))
+ max_result = second;
+ } else {
+ if (comp(second, min_result))
+ min_result = second;
+ if (!comp(first, max_result))
+ max_result = first;
+ }
+ first = ++second; if (first != last) ++second;
+ }
+
+ if (first != last) {
+ if (comp(first, min_result))
+ min_result = first;
+ else if (!comp(first, max_result))
+ max_result = first;
+ }
+
+ return std::make_pair(min_result, max_result);
+ }
+
+ template <typename ForwardIter, class BinaryPredicate>
+ std::pair<ForwardIter,ForwardIter>
+ basic_last_min_first_max_element(ForwardIter first, ForwardIter last,
+ BinaryPredicate comp)
+ {
+ if (first == last) return std::make_pair(last,last);
+
+ ForwardIter min_result = first;
+ ForwardIter max_result = first;
+
+ ForwardIter second = ++first;
+ if (second == last)
+ return std::make_pair(min_result, max_result);
+
+ if (comp(max_result, second))
+ max_result = second;
+ else
+ min_result = second;
+
+ first = ++second; if (first != last) ++second;
+ while (second != last) {
+ if (comp(first, second)) {
+ if (!comp(min_result, first))
+ min_result = first;
+ if (comp(max_result, second))
+ max_result = second;
+ } else {
+ if (!comp(min_result, second))
+ min_result = second;
+ if (comp(max_result, first))
+ max_result = first;
+ }
+ first = ++second; if (first != last) ++second;
+ }
+
+ if (first != last) {
+ if (!comp(min_result, first))
+ min_result = first;
+ else if (comp(max_result, first))
+ max_result = first;
+ }
+
+ return std::make_pair(min_result, max_result);
+ }
+
+ template <typename ForwardIter, class BinaryPredicate>
+ std::pair<ForwardIter,ForwardIter>
+ basic_last_min_last_max_element(ForwardIter first, ForwardIter last,
+ BinaryPredicate comp)
+ {
+ if (first == last) return std::make_pair(last,last);
+
+ ForwardIter min_result = first;
+ ForwardIter max_result = first;
+
+ ForwardIter second = first; ++second;
+ if (second == last)
+ return std::make_pair(min_result,max_result);
+
+ ForwardIter potential_max_result = last;
+ if (comp(first, second))
+ max_result = second;
+ else {
+ min_result = second;
+ potential_max_result = second;
+ }
+
+ first = ++second; if (first != last) ++second;
+ while (second != last) {
+ if (comp(first, second)) {
+ if (!comp(min_result, first))
+ min_result = first;
+ if (!comp(second, max_result)) {
+ max_result = second;
+ potential_max_result = last;
+ }
+ } else {
+ if (!comp(min_result, second))
+ min_result = second;
+ if (!comp(first, max_result)) {
+ max_result = first;
+ potential_max_result = second;
+ }
+ }
+ first = ++second;
+ if (first != last) ++second;
+ }
+
+ if (first != last) {
+ if (!comp(min_result, first))
+ min_result = first;
+ if (!comp(first, max_result)) {
+ max_result = first;
+ potential_max_result = last;
+ }
+ }
+
+ if (potential_max_result != last
+ && !comp(potential_max_result, max_result))
+ max_result = potential_max_result;
+
+ return std::make_pair(min_result,max_result);
+ }
+
+ } // namespace detail
+
+ template <typename ForwardIter>
+ inline std::pair<ForwardIter,ForwardIter>
+ first_min_first_max_element(ForwardIter first, ForwardIter last)
+ {
+ return minmax_element(first, last);
+ }
+
+ template <typename ForwardIter, class BinaryPredicate>
+ inline std::pair<ForwardIter,ForwardIter>
+ first_min_first_max_element(ForwardIter first, ForwardIter last,
+ BinaryPredicate comp)
+ {
+ return minmax_element(first, last, comp);
+ }
+
+ template <typename ForwardIter>
+ std::pair<ForwardIter,ForwardIter>
+ first_min_last_max_element(ForwardIter first, ForwardIter last)
+ {
+ return detail::basic_first_min_last_max_element(first, last,
+ detail::less_over_iter<ForwardIter>() );
+ }
+
+ template <typename ForwardIter, class BinaryPredicate>
+ inline std::pair<ForwardIter,ForwardIter>
+ first_min_last_max_element(ForwardIter first, ForwardIter last,
+ BinaryPredicate comp)
+ {
+ return detail::basic_first_min_last_max_element(first, last,
+ detail::binary_pred_over_iter<ForwardIter,BinaryPredicate>(comp) );
+ }
+
+ template <typename ForwardIter>
+ std::pair<ForwardIter,ForwardIter>
+ last_min_first_max_element(ForwardIter first, ForwardIter last)
+ {
+ return detail::basic_last_min_first_max_element(first, last,
+ detail::less_over_iter<ForwardIter>() );
+ }
+
+ template <typename ForwardIter, class BinaryPredicate>
+ inline std::pair<ForwardIter,ForwardIter>
+ last_min_first_max_element(ForwardIter first, ForwardIter last,
+ BinaryPredicate comp)
+ {
+ return detail::basic_last_min_first_max_element(first, last,
+ detail::binary_pred_over_iter<ForwardIter,BinaryPredicate>(comp) );
+ }
+
+ template <typename ForwardIter>
+ std::pair<ForwardIter,ForwardIter>
+ last_min_last_max_element(ForwardIter first, ForwardIter last)
+ {
+ return detail::basic_last_min_last_max_element(first, last,
+ detail::less_over_iter<ForwardIter>() );
+ }
+
+ template <typename ForwardIter, class BinaryPredicate>
+ inline std::pair<ForwardIter,ForwardIter>
+ last_min_last_max_element(ForwardIter first, ForwardIter last,
+ BinaryPredicate comp)
+ {
+ return detail::basic_last_min_last_max_element(first, last,
+ detail::binary_pred_over_iter<ForwardIter,BinaryPredicate>(comp) );
+ }
+
+} // namespace boost
+
+#endif // BOOST_ALGORITHM_MINMAX_ELEMENT_HPP
diff --git a/Utilities/BGL/boost/algorithm/string.hpp b/Utilities/BGL/boost/algorithm/string.hpp
new file mode 100755
index 0000000000000000000000000000000000000000..496400dbfd45c32e39a865b322099c1547fa5b14
--- /dev/null
+++ b/Utilities/BGL/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/Utilities/BGL/boost/algorithm/string/case_conv.hpp b/Utilities/BGL/boost/algorithm/string/case_conv.hpp
new file mode 100755
index 0000000000000000000000000000000000000000..40543d04f1984d683141cbb6380c25cbe274fcab
--- /dev/null
+++ b/Utilities/BGL/boost/algorithm/string/case_conv.hpp
@@ -0,0 +1,176 @@
+// Boost string_algo library case_conv.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_CASE_CONV_HPP
+#define BOOST_STRING_CASE_CONV_HPP
+
+#include <boost/algorithm/string/config.hpp>
+#include <algorithm>
+#include <locale>
+#include <boost/iterator/transform_iterator.hpp>
+
+#include <boost/range/as_literal.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/value_type.hpp>
+
+#include <boost/algorithm/string/detail/case_conv.hpp>
+
+/*! \file
+ Defines sequence case-conversion algorithms.
+ Algorithms convert each element in the input sequence to the
+ desired case using provided locales.
+*/
+
+namespace boost {
+ namespace algorithm {
+
+// to_lower -----------------------------------------------//
+
+ //! Convert to lower case
+ /*!
+ Each element of the input sequence is converted to lower
+ case. The result is a copy of the input converted to lower case.
+ 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 Loc A locale used for conversion
+ \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>
+ inline OutputIteratorT
+ to_lower_copy(
+ OutputIteratorT Output,
+ const RangeT& Input,
+ const std::locale& Loc=std::locale())
+ {
+ return ::boost::algorithm::detail::transform_range_copy(
+ Output,
+ ::boost::as_literal(Input),
+ ::boost::algorithm::detail::to_lowerF<
+ typename range_value<RangeT>::type >(Loc));
+ }
+
+ //! Convert to lower case
+ /*!
+ \overload
+ */
+ template<typename SequenceT>
+ inline SequenceT to_lower_copy(
+ const SequenceT& Input,
+ const std::locale& Loc=std::locale())
+ {
+ return ::boost::algorithm::detail::transform_range_copy<SequenceT>(
+ Input,
+ ::boost::algorithm::detail::to_lowerF<
+ typename range_value<SequenceT>::type >(Loc));
+ }
+
+ //! Convert to lower case
+ /*!
+ Each element of the input sequence is converted to lower
+ case. The input sequence is modified in-place.
+
+ \param Input A range
+ \param Loc a locale used for conversion
+ */
+ template<typename WritableRangeT>
+ inline void to_lower(
+ WritableRangeT& Input,
+ const std::locale& Loc=std::locale())
+ {
+ ::boost::algorithm::detail::transform_range(
+ ::boost::as_literal(Input),
+ ::boost::algorithm::detail::to_lowerF<
+ typename range_value<WritableRangeT>::type >(Loc));
+ }
+
+// to_upper -----------------------------------------------//
+
+ //! Convert to upper case
+ /*!
+ Each element of the input sequence is converted to upper
+ case. The result is a copy of the input converted to upper case.
+ 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 Loc A locale used for conversion
+ \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>
+ inline OutputIteratorT
+ to_upper_copy(
+ OutputIteratorT Output,
+ const RangeT& Input,
+ const std::locale& Loc=std::locale())
+ {
+ return ::boost::algorithm::detail::transform_range_copy(
+ Output,
+ ::boost::as_literal(Input),
+ ::boost::algorithm::detail::to_upperF<
+ typename range_value<RangeT>::type >(Loc));
+ }
+
+ //! Convert to upper case
+ /*!
+ \overload
+ */
+ template<typename SequenceT>
+ inline SequenceT to_upper_copy(
+ const SequenceT& Input,
+ const std::locale& Loc=std::locale())
+ {
+ return ::boost::algorithm::detail::transform_range_copy<SequenceT>(
+ Input,
+ ::boost::algorithm::detail::to_upperF<
+ typename range_value<SequenceT>::type >(Loc));
+ }
+
+ //! Convert to upper case
+ /*!
+ Each element of the input sequence is converted to upper
+ case. The input sequence is modified in-place.
+
+ \param Input An input range
+ \param Loc a locale used for conversion
+ */
+ template<typename WritableRangeT>
+ inline void to_upper(
+ WritableRangeT& Input,
+ const std::locale& Loc=std::locale())
+ {
+ ::boost::algorithm::detail::transform_range(
+ ::boost::as_literal(Input),
+ ::boost::algorithm::detail::to_upperF<
+ typename range_value<WritableRangeT>::type >(Loc));
+ }
+
+ } // namespace algorithm
+
+ // pull names to the boost namespace
+ using algorithm::to_lower;
+ using algorithm::to_lower_copy;
+ using algorithm::to_upper;
+ using algorithm::to_upper_copy;
+
+} // namespace boost
+
+#endif // BOOST_STRING_CASE_CONV_HPP
diff --git a/Utilities/BGL/boost/algorithm/string/classification.hpp b/Utilities/BGL/boost/algorithm/string/classification.hpp
new file mode 100755
index 0000000000000000000000000000000000000000..e868b88b85d80204e0b5b350a8cfb184d747cd52
--- /dev/null
+++ b/Utilities/BGL/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/Utilities/BGL/boost/algorithm/string/compare.hpp b/Utilities/BGL/boost/algorithm/string/compare.hpp
new file mode 100755
index 0000000000000000000000000000000000000000..f610b36431337430f9440d163791b0a3e3930e09
--- /dev/null
+++ b/Utilities/BGL/boost/algorithm/string/compare.hpp
@@ -0,0 +1,199 @@
+// Boost string_algo library compare.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_COMPARE_HPP
+#define BOOST_STRING_COMPARE_HPP
+
+#include <boost/algorithm/string/config.hpp>
+#include <locale>
+
+/*! \file
+ Defines element comparison predicates. Many algorithms in this library can
+ take an additional argument with a predicate used to compare elements.
+ This makes it possible, for instance, to have case insensitive versions
+ of the algorithms.
+*/
+
+namespace boost {
+ namespace algorithm {
+
+ // is_equal functor -----------------------------------------------//
+
+ //! is_equal functor
+ /*!
+ Standard STL equal_to only handle comparison between arguments
+ of the same type. This is a less restrictive version which wraps operator ==.
+ */
+ struct is_equal
+ {
+ //! Function operator
+ /*!
+ Compare two operands for equality
+ */
+ template< typename T1, typename T2 >
+ bool operator()( const T1& Arg1, const T2& Arg2 ) const
+ {
+ return Arg1==Arg2;
+ }
+ };
+
+ //! case insensitive version of is_equal
+ /*!
+ Case insensitive comparison predicate. Comparison is done using
+ specified locales.
+ */
+ struct is_iequal
+ {
+ //! Constructor
+ /*!
+ \param Loc locales used for comparison
+ */
+ is_iequal( const std::locale& Loc=std::locale() ) :
+ m_Loc( Loc ) {}
+
+ //! Function operator
+ /*!
+ Compare two operands. Case is ignored.
+ */
+ template< typename T1, typename T2 >
+ bool operator()( const T1& Arg1, const T2& Arg2 ) const
+ {
+ #if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x564) && !defined(_USE_OLD_RW_STL)
+ return std::toupper(Arg1)==std::toupper(Arg2);
+ #else
+ return std::toupper<T1>(Arg1,m_Loc)==std::toupper<T2>(Arg2,m_Loc);
+ #endif
+ }
+
+ private:
+ std::locale m_Loc;
+ };
+
+ // is_less functor -----------------------------------------------//
+
+ //! is_less functor
+ /*!
+ Convenient version of standard std::less. Operation is templated, therefore it is
+ not required to specify the exact types upon the construction
+ */
+ struct is_less
+ {
+ //! Functor operation
+ /*!
+ Compare two operands using > operator
+ */
+ template< typename T1, typename T2 >
+ bool operator()( const T1& Arg1, const T2& Arg2 ) const
+ {
+ return Arg1<Arg2;
+ }
+ };
+
+
+ //! case insensitive version of is_less
+ /*!
+ Case insensitive comparison predicate. Comparison is done using
+ specified locales.
+ */
+ struct is_iless
+ {
+ //! Constructor
+ /*!
+ \param Loc locales used for comparison
+ */
+ is_iless( const std::locale& Loc=std::locale() ) :
+ m_Loc( Loc ) {}
+
+ //! Function operator
+ /*!
+ Compare two operands. Case is ignored.
+ */
+ template< typename T1, typename T2 >
+ bool operator()( const T1& Arg1, const T2& Arg2 ) const
+ {
+ #if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x564) && !defined(_USE_OLD_RW_STL)
+ return std::toupper(Arg1)<std::toupper(Arg2);
+ #else
+ return std::toupper<T1>(Arg1,m_Loc)<std::toupper<T2>(Arg2,m_Loc);
+ #endif
+ }
+
+ private:
+ std::locale m_Loc;
+ };
+
+ // is_not_greater functor -----------------------------------------------//
+
+ //! is_not_greater functor
+ /*!
+ Convenient version of standard std::not_greater_to. Operation is templated, therefore it is
+ not required to specify the exact types upon the construction
+ */
+ struct is_not_greater
+ {
+ //! Functor operation
+ /*!
+ Compare two operands using > operator
+ */
+ template< typename T1, typename T2 >
+ bool operator()( const T1& Arg1, const T2& Arg2 ) const
+ {
+ return Arg1<=Arg2;
+ }
+ };
+
+
+ //! case insensitive version of is_not_greater
+ /*!
+ Case insensitive comparison predicate. Comparison is done using
+ specified locales.
+ */
+ struct is_not_igreater
+ {
+ //! Constructor
+ /*!
+ \param Loc locales used for comparison
+ */
+ is_not_igreater( const std::locale& Loc=std::locale() ) :
+ m_Loc( Loc ) {}
+
+ //! Function operator
+ /*!
+ Compare two operands. Case is ignored.
+ */
+ template< typename T1, typename T2 >
+ bool operator()( const T1& Arg1, const T2& Arg2 ) const
+ {
+ #if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x564) && !defined(_USE_OLD_RW_STL)
+ return std::toupper(Arg1)<=std::toupper(Arg2);
+ #else
+ return std::toupper<T1>(Arg1,m_Loc)<=std::toupper<T2>(Arg2,m_Loc);
+ #endif
+ }
+
+ private:
+ std::locale m_Loc;
+ };
+
+
+ } // namespace algorithm
+
+ // pull names to the boost namespace
+ using algorithm::is_equal;
+ using algorithm::is_iequal;
+ using algorithm::is_less;
+ using algorithm::is_iless;
+ using algorithm::is_not_greater;
+ using algorithm::is_not_igreater;
+
+} // namespace boost
+
+
+#endif // BOOST_STRING_COMPARE_HPP
diff --git a/Utilities/BGL/boost/algorithm/string/concept.hpp b/Utilities/BGL/boost/algorithm/string/concept.hpp
new file mode 100755
index 0000000000000000000000000000000000000000..2ef4ca731679795750e45a9d2429d5a348f1deda
--- /dev/null
+++ b/Utilities/BGL/boost/algorithm/string/concept.hpp
@@ -0,0 +1,83 @@
+// Boost string_algo library concept.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_CONCEPT_HPP
+#define BOOST_STRING_CONCEPT_HPP
+
+#include <boost/concept_check.hpp>
+#include <boost/range/iterator_range.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+
+/*! \file
+ Defines concepts used in string_algo library
+*/
+
+namespace boost {
+ namespace algorithm {
+
+ //! Finder concept
+ /*!
+ Defines the Finder concept. Finder is a functor which selects
+ an arbitrary part of a string. Search is performed on
+ the range specified by starting and ending iterators.
+
+ Result of the find operation must be convertible to iterator_range.
+ */
+ template<typename FinderT, typename IteratorT>
+ struct FinderConcept
+ {
+ private:
+ typedef iterator_range<IteratorT> range;
+ public:
+ void constraints()
+ {
+ // Operation
+ r=(*pF)(i,i);
+ }
+ private:
+ range r;
+ IteratorT i;
+ FinderT* pF;
+ }; // Finder_concept
+
+
+ //! Formatter concept
+ /*!
+ Defines the Formatter concept. Formatter is a functor, which
+ takes a result from a finder operation and transforms it
+ in a specific way.
+
+ Result must be a container supported by container_traits,
+ or a reference to it.
+ */
+ template<typename FormatterT, typename FinderT, typename IteratorT>
+ struct FormatterConcept
+ {
+ public:
+ void constraints()
+ {
+ // Operation
+ ::boost::begin((*pFo)( (*pF)(i,i) ));
+ ::boost::end((*pFo)( (*pF)(i,i) ));
+ }
+ private:
+ IteratorT i;
+ FinderT* pF;
+ FormatterT *pFo;
+ }; // FormatterConcept;
+
+ } // namespace algorithm
+} // namespace boost
+
+
+
+
+#endif // BOOST_STRING_CONCEPT_HPP
diff --git a/Utilities/BGL/boost/algorithm/string/config.hpp b/Utilities/BGL/boost/algorithm/string/config.hpp
new file mode 100755
index 0000000000000000000000000000000000000000..d10c6f5d8afaae6afab4236b249446d56ba60eaa
--- /dev/null
+++ b/Utilities/BGL/boost/algorithm/string/config.hpp
@@ -0,0 +1,28 @@
+// Boost string_algo library config.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_CONFIG_HPP
+#define BOOST_STRING_CONFIG_HPP
+
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+
+#ifdef BOOST_STRING_DEDUCED_TYPENAME
+# error "macro already defined!"
+#endif
+
+#define BOOST_STRING_TYPENAME BOOST_DEDUCED_TYPENAME
+
+// Metrowerks workaround
+#if BOOST_WORKAROUND(__MWERKS__, <= 0x3003) // 8.x
+#pragma parse_func_templ off
+#endif
+
+#endif // BOOST_STRING_CONFIG_HPP
diff --git a/Utilities/BGL/boost/algorithm/string/constants.hpp b/Utilities/BGL/boost/algorithm/string/constants.hpp
new file mode 100755
index 0000000000000000000000000000000000000000..9022d43589ba6033b7e64b4bfa5be26a3869e3de
--- /dev/null
+++ b/Utilities/BGL/boost/algorithm/string/constants.hpp
@@ -0,0 +1,36 @@
+// Boost string_algo library constants.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_CONSTANTS_HPP
+#define BOOST_STRING_CONSTANTS_HPP
+
+namespace boost {
+ namespace algorithm {
+
+ //! Token compression mode
+ /*!
+ Specifies token compression mode for the token_finder.
+ */
+ enum token_compress_mode_type
+ {
+ token_compress_on, //!< Compress adjacent tokens
+ token_compress_off //!< Do not compress adjacent tokens
+ };
+
+ } // namespace algorithm
+
+ // pull the names to the boost namespace
+ using algorithm::token_compress_on;
+ using algorithm::token_compress_off;
+
+} // namespace boost
+
+#endif // BOOST_STRING_CONSTANTS_HPP
+
diff --git a/Utilities/BGL/boost/algorithm/string/detail/case_conv.hpp b/Utilities/BGL/boost/algorithm/string/detail/case_conv.hpp
new file mode 100755
index 0000000000000000000000000000000000000000..c3141e947bde4052e2e660f9a02045feeb6dbd2e
--- /dev/null
+++ b/Utilities/BGL/boost/algorithm/string/detail/case_conv.hpp
@@ -0,0 +1,121 @@
+// Boost string_algo library string_funct.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_CASE_CONV_DETAIL_HPP
+#define BOOST_STRING_CASE_CONV_DETAIL_HPP
+
+#include <boost/algorithm/string/config.hpp>
+#include <locale>
+#include <functional>
+
+namespace boost {
+ namespace algorithm {
+ namespace detail {
+
+// case conversion functors -----------------------------------------------//
+
+#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
+#pragma warning(push)
+#pragma warning(disable:4512) //assignment operator could not be generated
+#endif
+
+ // a tolower functor
+ template<typename CharT>
+ struct to_lowerF : public std::unary_function<CharT, CharT>
+ {
+ // Constructor
+ to_lowerF( const std::locale& Loc ) : m_Loc( Loc ) {}
+
+ // Operation
+ CharT operator ()( CharT Ch ) const
+ {
+ #if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x564) && !defined(_USE_OLD_RW_STL)
+ return std::tolower( Ch);
+ #else
+ return std::tolower<CharT>( Ch, m_Loc );
+ #endif
+ }
+ private:
+ const std::locale& m_Loc;
+ };
+
+ // a toupper functor
+ template<typename CharT>
+ struct to_upperF : public std::unary_function<CharT, CharT>
+ {
+ // Constructor
+ to_upperF( const std::locale& Loc ) : m_Loc( Loc ) {}
+
+ // Operation
+ CharT operator ()( CharT Ch ) const
+ {
+ #if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x564) && !defined(_USE_OLD_RW_STL)
+ return std::toupper( Ch);
+ #else
+ return std::toupper<CharT>( Ch, m_Loc );
+ #endif
+ }
+ private:
+ const std::locale& m_Loc;
+ };
+
+#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
+#pragma warning(pop)
+#endif
+
+// algorithm implementation -------------------------------------------------------------------------
+
+ // Transform a range
+ template<typename OutputIteratorT, typename RangeT, typename FunctorT>
+ OutputIteratorT transform_range_copy(
+ OutputIteratorT Output,
+ const RangeT& Input,
+ FunctorT Functor)
+ {
+ return std::transform(
+ ::boost::begin(Input),
+ ::boost::end(Input),
+ Output,
+ Functor);
+ }
+
+ // Transform a range (in-place)
+ template<typename RangeT, typename FunctorT>
+ void transform_range(
+ const RangeT& Input,
+ FunctorT Functor)
+ {
+ std::transform(
+ ::boost::begin(Input),
+ ::boost::end(Input),
+ ::boost::begin(Input),
+ Functor);
+ }
+
+ template<typename SequenceT, typename RangeT, typename FunctorT>
+ inline SequenceT transform_range_copy(
+ const RangeT& Input,
+ FunctorT Functor)
+ {
+ return SequenceT(
+ ::boost::make_transform_iterator(
+ ::boost::begin(Input),
+ Functor),
+ ::boost::make_transform_iterator(
+ ::boost::end(Input),
+ Functor));
+ }
+
+ } // namespace detail
+ } // namespace algorithm
+} // namespace boost
+
+
+#endif // BOOST_STRING_CASE_CONV_DETAIL_HPP
diff --git a/Utilities/BGL/boost/algorithm/string/detail/classification.hpp b/Utilities/BGL/boost/algorithm/string/detail/classification.hpp
new file mode 100755
index 0000000000000000000000000000000000000000..e5e09591c22bba3db21eda4172fdc068f2f17e93
--- /dev/null
+++ b/Utilities/BGL/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.Lambda support
+ template <class Args> struct sig { typedef bool 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.Lambda support
+ template <class Args> struct sig { typedef bool 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.Lambda support
+ template <class Args> struct sig { typedef bool 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.Lambda support
+ template <class Args> struct sig { typedef bool 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.Lambda support
+ template <class Args> struct sig { typedef bool 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.Lambda support
+ template <class Args> struct sig { typedef bool 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/Utilities/BGL/boost/algorithm/string/detail/find_format.hpp b/Utilities/BGL/boost/algorithm/string/detail/find_format.hpp
new file mode 100755
index 0000000000000000000000000000000000000000..1c6e006d8e20f019f3a78e17da9bedf495e5327b
--- /dev/null
+++ b/Utilities/BGL/boost/algorithm/string/detail/find_format.hpp
@@ -0,0 +1,194 @@
+// Boost string_algo library find_format.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_FORMAT_DETAIL_HPP
+#define BOOST_STRING_FIND_FORMAT_DETAIL_HPP
+
+#include <boost/algorithm/string/config.hpp>
+#include <boost/range/iterator_range.hpp>
+#include <boost/range/const_iterator.hpp>
+#include <boost/range/iterator.hpp>
+#include <boost/algorithm/string/detail/find_format_store.hpp>
+#include <boost/algorithm/string/detail/replace_storage.hpp>
+
+namespace boost {
+ namespace algorithm {
+ namespace detail {
+
+// find_format_copy (iterator variant) implementation -------------------------------//
+
+ template<
+ typename OutputIteratorT,
+ typename InputT,
+ typename FormatterT,
+ typename FindResultT,
+ typename FormatResultT >
+ inline OutputIteratorT find_format_copy_impl2(
+ OutputIteratorT Output,
+ const InputT& Input,
+ FormatterT Formatter,
+ const FindResultT& FindResult,
+ const FormatResultT& FormatResult )
+ {
+ typedef find_format_store<
+ BOOST_STRING_TYPENAME
+ range_const_iterator<InputT>::type,
+ FormatterT,
+ FormatResultT > store_type;
+
+ // Create store for the find result
+ store_type M( FindResult, FormatResult, Formatter );
+
+ if ( !M )
+ {
+ // Match not found - return original sequence
+ std::copy( ::boost::begin(Input), ::boost::end(Input), Output );
+ return Output;
+ }
+
+ // Copy the beginning of the sequence
+ std::copy( ::boost::begin(Input), ::boost::begin(M), Output );
+ // Format find result
+ // Copy formated result
+ std::copy( ::boost::begin(M.format_result()), ::boost::end(M.format_result()), Output );
+ // Copy the rest of the sequence
+ std::copy( M.end(), ::boost::end(Input), Output );
+
+ return Output;
+ }
+
+ template<
+ typename OutputIteratorT,
+ typename InputT,
+ typename FormatterT,
+ typename FindResultT >
+ inline OutputIteratorT find_format_copy_impl(
+ OutputIteratorT Output,
+ const InputT& Input,
+ FormatterT Formatter,
+ const FindResultT& FindResult )
+ {
+ return ::boost::algorithm::detail::find_format_copy_impl2(
+ Output,
+ Input,
+ Formatter,
+ FindResult,
+ Formatter(FindResult) );
+ }
+
+
+// find_format_copy implementation --------------------------------------------------//
+
+ template<
+ typename InputT,
+ typename FormatterT,
+ typename FindResultT,
+ typename FormatResultT >
+ inline InputT find_format_copy_impl2(
+ const InputT& Input,
+ FormatterT Formatter,
+ const FindResultT& FindResult,
+ const FormatResultT& FormatResult)
+ {
+ typedef find_format_store<
+ BOOST_STRING_TYPENAME
+ range_const_iterator<InputT>::type,
+ FormatterT,
+ FormatResultT > store_type;
+
+ // Create store for the find result
+ store_type M( FindResult, FormatResult, Formatter );
+
+ if ( !M )
+ {
+ // Match not found - return original sequence
+ return InputT( Input );
+ }
+
+ InputT Output;
+ // Copy the beginning of the sequence
+ insert( Output, ::boost::end(Output), ::boost::begin(Input), M.begin() );
+ // Copy formated result
+ insert( Output, ::boost::end(Output), M.format_result() );
+ // Copy the rest of the sequence
+ insert( Output, ::boost::end(Output), M.end(), ::boost::end(Input) );
+
+ return Output;
+ }
+
+ template<
+ typename InputT,
+ typename FormatterT,
+ typename FindResultT >
+ inline InputT find_format_copy_impl(
+ const InputT& Input,
+ FormatterT Formatter,
+ const FindResultT& FindResult)
+ {
+ return ::boost::algorithm::detail::find_format_copy_impl2(
+ Input,
+ Formatter,
+ FindResult,
+ Formatter(FindResult) );
+ }
+
+ // replace implementation ----------------------------------------------------//
+
+ template<
+ typename InputT,
+ typename FormatterT,
+ typename FindResultT,
+ typename FormatResultT >
+ inline void find_format_impl2(
+ InputT& Input,
+ FormatterT Formatter,
+ const FindResultT& FindResult,
+ const FormatResultT& FormatResult)
+ {
+ typedef find_format_store<
+ BOOST_STRING_TYPENAME
+ range_iterator<InputT>::type,
+ FormatterT,
+ FormatResultT > store_type;
+
+ // Create store for the find result
+ store_type M( FindResult, FormatResult, Formatter );
+
+ if ( !M )
+ {
+ // Search not found - return original sequence
+ return;
+ }
+
+ // Replace match
+ ::boost::algorithm::detail::replace( Input, M.begin(), M.end(), M.format_result() );
+ }
+
+ template<
+ typename InputT,
+ typename FormatterT,
+ typename FindResultT >
+ inline void find_format_impl(
+ InputT& Input,
+ FormatterT Formatter,
+ const FindResultT& FindResult)
+ {
+ ::boost::algorithm::detail::find_format_impl2(
+ Input,
+ Formatter,
+ FindResult,
+ Formatter(FindResult) );
+ }
+
+ } // namespace detail
+ } // namespace algorithm
+} // namespace boost
+
+#endif // BOOST_STRING_FIND_FORMAT_DETAIL_HPP
diff --git a/Utilities/BGL/boost/algorithm/string/detail/find_format_all.hpp b/Utilities/BGL/boost/algorithm/string/detail/find_format_all.hpp
new file mode 100755
index 0000000000000000000000000000000000000000..873388b0003b96342d754515927296a412837b15
--- /dev/null
+++ b/Utilities/BGL/boost/algorithm/string/detail/find_format_all.hpp
@@ -0,0 +1,263 @@
+// Boost string_algo library find_format_all.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_FORMAT_ALL_DETAIL_HPP
+#define BOOST_STRING_FIND_FORMAT_ALL_DETAIL_HPP
+
+#include <boost/algorithm/string/config.hpp>
+#include <boost/range/iterator_range.hpp>
+#include <boost/range/const_iterator.hpp>
+#include <boost/range/value_type.hpp>
+#include <boost/algorithm/string/detail/find_format_store.hpp>
+#include <boost/algorithm/string/detail/replace_storage.hpp>
+
+namespace boost {
+ namespace algorithm {
+ namespace detail {
+
+// find_format_all_copy (iterator variant) implementation ---------------------------//
+
+ template<
+ typename OutputIteratorT,
+ typename InputT,
+ typename FinderT,
+ typename FormatterT,
+ typename FindResultT,
+ typename FormatResultT >
+ inline OutputIteratorT find_format_all_copy_impl2(
+ OutputIteratorT Output,
+ const InputT& Input,
+ FinderT Finder,
+ FormatterT Formatter,
+ const FindResultT& FindResult,
+ const FormatResultT& FormatResult )
+ {
+ typedef BOOST_STRING_TYPENAME
+ range_const_iterator<InputT>::type input_iterator_type;
+
+ typedef find_format_store<
+ input_iterator_type,
+ FormatterT,
+ FormatResultT > store_type;
+
+ // Create store for the find result
+ store_type M( FindResult, FormatResult, Formatter );
+
+ // Initialize last match
+ input_iterator_type LastMatch=::boost::begin(Input);
+
+ // Iterate through all matches
+ while( M )
+ {
+ // Copy the beginning of the sequence
+ std::copy( LastMatch, M.begin(), Output );
+ // Copy formated result
+ std::copy( ::boost::begin(M.format_result()), ::boost::end(M.format_result()), Output );
+
+ // Proceed to the next match
+ LastMatch=M.end();
+ M=Finder( LastMatch, ::boost::end(Input) );
+ }
+
+ // Copy the rest of the sequence
+ std::copy( LastMatch, ::boost::end(Input), Output );
+
+ return Output;
+ }
+
+ template<
+ typename OutputIteratorT,
+ typename InputT,
+ typename FinderT,
+ typename FormatterT,
+ typename FindResultT >
+ inline OutputIteratorT find_format_all_copy_impl(
+ OutputIteratorT Output,
+ const InputT& Input,
+ FinderT Finder,
+ FormatterT Formatter,
+ const FindResultT& FindResult )
+ {
+ return ::boost::algorithm::detail::find_format_all_copy_impl2(
+ Output,
+ Input,
+ Finder,
+ Formatter,
+ FindResult,
+ Formatter(FindResult) );
+ }
+
+ // find_format_all_copy implementation ----------------------------------------------//
+
+ template<
+ typename InputT,
+ typename FinderT,
+ typename FormatterT,
+ typename FindResultT,
+ typename FormatResultT >
+ inline InputT find_format_all_copy_impl2(
+ const InputT& Input,
+ FinderT Finder,
+ FormatterT Formatter,
+ const FindResultT& FindResult,
+ const FormatResultT& FormatResult)
+ {
+ typedef BOOST_STRING_TYPENAME
+ range_const_iterator<InputT>::type input_iterator_type;
+
+ typedef find_format_store<
+ input_iterator_type,
+ FormatterT,
+ FormatResultT > store_type;
+
+ // Create store for the find result
+ store_type M( FindResult, FormatResult, Formatter );
+
+ // Initialize last match
+ input_iterator_type LastMatch=::boost::begin(Input);
+
+ // Output temporary
+ InputT Output;
+
+ // Iterate through all matches
+ while( M )
+ {
+ // Copy the beginning of the sequence
+ insert( Output, ::boost::end(Output), LastMatch, M.begin() );
+ // Copy formated result
+ insert( Output, ::boost::end(Output), M.format_result() );
+
+ // Proceed to the next match
+ LastMatch=M.end();
+ M=Finder( LastMatch, ::boost::end(Input) );
+ }
+
+ // Copy the rest of the sequence
+ ::boost::algorithm::detail::insert( Output, ::boost::end(Output), LastMatch, ::boost::end(Input) );
+
+ return Output;
+ }
+
+ template<
+ typename InputT,
+ typename FinderT,
+ typename FormatterT,
+ typename FindResultT >
+ inline InputT find_format_all_copy_impl(
+ const InputT& Input,
+ FinderT Finder,
+ FormatterT Formatter,
+ const FindResultT& FindResult)
+ {
+ return ::boost::algorithm::detail::find_format_all_copy_impl2(
+ Input,
+ Finder,
+ Formatter,
+ FindResult,
+ Formatter(FindResult) );
+ }
+
+ // find_format_all implementation ------------------------------------------------//
+
+ template<
+ typename InputT,
+ typename FinderT,
+ typename FormatterT,
+ typename FindResultT,
+ typename FormatResultT >
+ inline void find_format_all_impl2(
+ InputT& Input,
+ FinderT Finder,
+ FormatterT Formatter,
+ FindResultT FindResult,
+ FormatResultT FormatResult)
+ {
+ typedef BOOST_STRING_TYPENAME
+ range_iterator<InputT>::type input_iterator_type;
+ typedef find_format_store<
+ input_iterator_type,
+ FormatterT,
+ FormatResultT > store_type;
+
+ // Create store for the find result
+ store_type M( FindResult, FormatResult, Formatter );
+
+ // Instantiate replacement storage
+ std::deque<
+ BOOST_STRING_TYPENAME range_value<InputT>::type> Storage;
+
+ // Initialize replacement iterators
+ input_iterator_type InsertIt=::boost::begin(Input);
+ input_iterator_type SearchIt=::boost::begin(Input);
+
+ while( M )
+ {
+ // process the segment
+ InsertIt=process_segment(
+ Storage,
+ Input,
+ InsertIt,
+ SearchIt,
+ M.begin() );
+
+ // Adjust search iterator
+ SearchIt=M.end();
+
+ // Copy formated replace to the storage
+ ::boost::algorithm::detail::copy_to_storage( Storage, M.format_result() );
+
+ // Find range for a next match
+ M=Finder( SearchIt, ::boost::end(Input) );
+ }
+
+ // process the last segment
+ InsertIt=::boost::algorithm::detail::process_segment(
+ Storage,
+ Input,
+ InsertIt,
+ SearchIt,
+ ::boost::end(Input) );
+
+ if ( Storage.empty() )
+ {
+ // Truncate input
+ ::boost::algorithm::detail::erase( Input, InsertIt, ::boost::end(Input) );
+ }
+ else
+ {
+ // Copy remaining data to the end of input
+ ::boost::algorithm::detail::insert( Input, ::boost::end(Input), Storage.begin(), Storage.end() );
+ }
+ }
+
+ template<
+ typename InputT,
+ typename FinderT,
+ typename FormatterT,
+ typename FindResultT >
+ inline void find_format_all_impl(
+ InputT& Input,
+ FinderT Finder,
+ FormatterT Formatter,
+ FindResultT FindResult)
+ {
+ ::boost::algorithm::detail::find_format_all_impl2(
+ Input,
+ Finder,
+ Formatter,
+ FindResult,
+ Formatter(FindResult) );
+ }
+
+ } // namespace detail
+ } // namespace algorithm
+} // namespace boost
+
+#endif // BOOST_STRING_FIND_FORMAT_ALL_DETAIL_HPP
diff --git a/Utilities/BGL/boost/algorithm/string/detail/find_format_store.hpp b/Utilities/BGL/boost/algorithm/string/detail/find_format_store.hpp
new file mode 100755
index 0000000000000000000000000000000000000000..a91f8b2afad4ad82e2e2506c179059827c26a8e7
--- /dev/null
+++ b/Utilities/BGL/boost/algorithm/string/detail/find_format_store.hpp
@@ -0,0 +1,78 @@
+// Boost string_algo library find_format_store.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_FORMAT_STORE_DETAIL_HPP
+#define BOOST_STRING_FIND_FORMAT_STORE_DETAIL_HPP
+
+#include <boost/algorithm/string/config.hpp>
+#include <boost/range/iterator_range.hpp>
+
+namespace boost {
+ namespace algorithm {
+ namespace detail {
+
+// temporary format and find result storage --------------------------------//
+
+#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
+#pragma warning(push)
+#pragma warning(disable:4512) //assignment operator could not be generated
+#endif
+ template<
+ typename ForwardIteratorT,
+ typename FormatterT,
+ typename FormatResultT >
+ class find_format_store :
+ public iterator_range<ForwardIteratorT>
+ {
+ public:
+ // typedefs
+ typedef iterator_range<ForwardIteratorT> base_type;
+ typedef FormatterT formatter_type;
+ typedef FormatResultT format_result_type;
+
+ public:
+ // Construction
+ find_format_store(
+ const base_type& FindResult,
+ const format_result_type& FormatResult,
+ const formatter_type& Formatter ) :
+ base_type(FindResult),
+ m_FormatResult(FormatResult),
+ m_Formatter(Formatter) {}
+
+ // Assignment
+ template< typename FindResultT >
+ find_format_store& operator=( FindResultT FindResult )
+ {
+ iterator_range<ForwardIteratorT>::operator=(FindResult);
+ m_FormatResult=m_Formatter(FindResult);
+
+ return *this;
+ }
+
+ // Retrieve format result
+ const format_result_type& format_result()
+ {
+ return m_FormatResult;
+ }
+
+ private:
+ format_result_type m_FormatResult;
+ const formatter_type& m_Formatter;
+ };
+
+#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
+#pragma warning(pop)
+#endif
+ } // namespace detail
+ } // namespace algorithm
+} // namespace boost
+
+#endif // BOOST_STRING_FIND_FORMAT_STORE_DETAIL_HPP
diff --git a/Utilities/BGL/boost/algorithm/string/detail/find_iterator.hpp b/Utilities/BGL/boost/algorithm/string/detail/find_iterator.hpp
new file mode 100755
index 0000000000000000000000000000000000000000..e2d27f08682af1b2d9c155e9bd2276bad2a8d017
--- /dev/null
+++ b/Utilities/BGL/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/Utilities/BGL/boost/algorithm/string/detail/finder.hpp b/Utilities/BGL/boost/algorithm/string/detail/finder.hpp
new file mode 100755
index 0000000000000000000000000000000000000000..c418fadb558204a3c1d461f08b4d9562d5447313
--- /dev/null
+++ b/Utilities/BGL/boost/algorithm/string/detail/finder.hpp
@@ -0,0 +1,646 @@
+// Boost string_algo library finder.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_FINDER_DETAIL_HPP
+#define BOOST_STRING_FINDER_DETAIL_HPP
+
+#include <boost/algorithm/string/config.hpp>
+#include <boost/algorithm/string/constants.hpp>
+#include <boost/detail/iterator.hpp>
+
+#include <boost/range/iterator_range.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/empty.hpp>
+#include <boost/range/as_literal.hpp>
+
+namespace boost {
+ namespace algorithm {
+ namespace detail {
+
+
+// find first functor -----------------------------------------------//
+
+ // find a subsequence in the sequence ( functor )
+ /*
+ Returns a pair <begin,end> marking the subsequence in the sequence.
+ If the find fails, functor returns <End,End>
+ */
+ template<typename SearchIteratorT,typename PredicateT>
+ struct first_finderF
+ {
+ typedef SearchIteratorT search_iterator_type;
+
+ // Construction
+ template< typename SearchT >
+ first_finderF( const SearchT& Search, PredicateT Comp ) :
+ m_Search(::boost::begin(Search), ::boost::end(Search)), m_Comp(Comp) {}
+ first_finderF(
+ search_iterator_type SearchBegin,
+ search_iterator_type SearchEnd,
+ PredicateT Comp ) :
+ m_Search(SearchBegin, SearchEnd), m_Comp(Comp) {}
+
+ // Operation
+ template< typename ForwardIteratorT >
+ iterator_range<ForwardIteratorT>
+ operator()(
+ ForwardIteratorT Begin,
+ ForwardIteratorT End ) const
+ {
+ typedef iterator_range<ForwardIteratorT> result_type;
+ typedef ForwardIteratorT input_iterator_type;
+
+ // Outer loop
+ for(input_iterator_type OuterIt=Begin;
+ OuterIt!=End;
+ ++OuterIt)
+ {
+ // Sanity check
+ if( boost::empty(m_Search) )
+ return result_type( End, End );
+
+ input_iterator_type InnerIt=OuterIt;
+ search_iterator_type SubstrIt=m_Search.begin();
+ for(;
+ InnerIt!=End && SubstrIt!=m_Search.end();
+ ++InnerIt,++SubstrIt)
+ {
+ if( !( m_Comp(*InnerIt,*SubstrIt) ) )
+ break;
+ }
+
+ // Substring matching succeeded
+ if ( SubstrIt==m_Search.end() )
+ return result_type( OuterIt, InnerIt );
+ }
+
+ return result_type( End, End );
+ }
+
+ private:
+ iterator_range<search_iterator_type> m_Search;
+ PredicateT m_Comp;
+ };
+
+// find last functor -----------------------------------------------//
+
+ // find the last match a subseqeunce in the sequence ( functor )
+ /*
+ Returns a pair <begin,end> marking the subsequence in the sequence.
+ If the find fails, returns <End,End>
+ */
+ template<typename SearchIteratorT, typename PredicateT>
+ struct last_finderF
+ {
+ typedef SearchIteratorT search_iterator_type;
+ typedef first_finderF<
+ search_iterator_type,
+ PredicateT> first_finder_type;
+
+ // Construction
+ template< typename SearchT >
+ last_finderF( const SearchT& Search, PredicateT Comp ) :
+ m_Search(::boost::begin(Search), ::boost::end(Search)), m_Comp(Comp) {}
+ last_finderF(
+ search_iterator_type SearchBegin,
+ search_iterator_type SearchEnd,
+ PredicateT Comp ) :
+ m_Search(SearchBegin, SearchEnd), m_Comp(Comp) {}
+
+ // Operation
+ template< typename ForwardIteratorT >
+ iterator_range<ForwardIteratorT>
+ operator()(
+ ForwardIteratorT Begin,
+ ForwardIteratorT End ) const
+ {
+ typedef iterator_range<ForwardIteratorT> result_type;
+
+ if( boost::empty(m_Search) )
+ return result_type( End, End );
+
+ typedef BOOST_STRING_TYPENAME boost::detail::
+ iterator_traits<ForwardIteratorT>::iterator_category category;
+
+ return findit( Begin, End, category() );
+ }
+
+ private:
+ // forward iterator
+ template< typename ForwardIteratorT >
+ iterator_range<ForwardIteratorT>
+ findit(
+ ForwardIteratorT Begin,
+ ForwardIteratorT End,
+ std::forward_iterator_tag ) const
+ {
+ typedef ForwardIteratorT input_iterator_type;
+ typedef iterator_range<ForwardIteratorT> result_type;
+
+ first_finder_type first_finder(
+ m_Search.begin(), m_Search.end(), m_Comp );
+
+ result_type M=first_finder( Begin, End );
+ result_type Last=M;
+
+ while( M )
+ {
+ Last=M;
+ M=first_finder( ::boost::end(M), End );
+ }
+
+ return Last;
+ }
+
+ // bidirectional iterator
+ template< typename ForwardIteratorT >
+ iterator_range<ForwardIteratorT>
+ findit(
+ ForwardIteratorT Begin,
+ ForwardIteratorT End,
+ std::bidirectional_iterator_tag ) const
+ {
+ typedef iterator_range<ForwardIteratorT> result_type;
+ typedef ForwardIteratorT input_iterator_type;
+
+ // Outer loop
+ for(input_iterator_type OuterIt=End;
+ OuterIt!=Begin; )
+ {
+ input_iterator_type OuterIt2=--OuterIt;
+
+ input_iterator_type InnerIt=OuterIt2;
+ search_iterator_type SubstrIt=m_Search.begin();
+ for(;
+ InnerIt!=End && SubstrIt!=m_Search.end();
+ ++InnerIt,++SubstrIt)
+ {
+ if( !( m_Comp(*InnerIt,*SubstrIt) ) )
+ break;
+ }
+
+ // Substring matching succeeded
+ if( SubstrIt==m_Search.end() )
+ return result_type( OuterIt2, InnerIt );
+ }
+
+ return result_type( End, End );
+ }
+
+ private:
+ iterator_range<search_iterator_type> m_Search;
+ PredicateT m_Comp;
+ };
+
+// find n-th functor -----------------------------------------------//
+
+ // find the n-th match of a subsequence in the sequence ( functor )
+ /*
+ Returns a pair <begin,end> marking the subsequence in the sequence.
+ If the find fails, returns <End,End>
+ */
+ template<typename SearchIteratorT, typename PredicateT>
+ struct nth_finderF
+ {
+ typedef SearchIteratorT search_iterator_type;
+ typedef first_finderF<
+ search_iterator_type,
+ PredicateT> first_finder_type;
+ typedef last_finderF<
+ search_iterator_type,
+ PredicateT> last_finder_type;
+
+ // Construction
+ template< typename SearchT >
+ nth_finderF(
+ const SearchT& Search,
+ int Nth,
+ PredicateT Comp) :
+ m_Search(::boost::begin(Search), ::boost::end(Search)),
+ m_Nth(Nth),
+ m_Comp(Comp) {}
+ nth_finderF(
+ search_iterator_type SearchBegin,
+ search_iterator_type SearchEnd,
+ int Nth,
+ PredicateT Comp) :
+ m_Search(SearchBegin, SearchEnd),
+ m_Nth(Nth),
+ m_Comp(Comp) {}
+
+ // Operation
+ template< typename ForwardIteratorT >
+ iterator_range<ForwardIteratorT>
+ operator()(
+ ForwardIteratorT Begin,
+ ForwardIteratorT End ) const
+ {
+ if(m_Nth>=0)
+ {
+ return find_forward(Begin, End, m_Nth);
+ }
+ else
+ {
+ return find_backward(Begin, End, -m_Nth);
+ }
+
+ }
+
+ private:
+ // Implementation helpers
+ template< typename ForwardIteratorT >
+ iterator_range<ForwardIteratorT>
+ find_forward(
+ ForwardIteratorT Begin,
+ ForwardIteratorT End,
+ unsigned int N) const
+ {
+ typedef ForwardIteratorT input_iterator_type;
+ typedef iterator_range<ForwardIteratorT> result_type;
+
+ // Sanity check
+ if( boost::empty(m_Search) )
+ return result_type( End, End );
+
+ // Instantiate find functor
+ first_finder_type first_finder(
+ m_Search.begin(), m_Search.end(), m_Comp );
+
+ result_type M( Begin, Begin );
+
+ for( unsigned int n=0; n<=N; ++n )
+ {
+ // find next match
+ M=first_finder( ::boost::end(M), End );
+
+ if ( !M )
+ {
+ // Subsequence not found, return
+ return M;
+ }
+ }
+
+ return M;
+ }
+
+ template< typename ForwardIteratorT >
+ iterator_range<ForwardIteratorT>
+ find_backward(
+ ForwardIteratorT Begin,
+ ForwardIteratorT End,
+ unsigned int N) const
+ {
+ typedef ForwardIteratorT input_iterator_type;
+ typedef iterator_range<ForwardIteratorT> result_type;
+
+ // Sanity check
+ if( boost::empty(m_Search) )
+ return result_type( End, End );
+
+ // Instantiate find functor
+ last_finder_type last_finder(
+ m_Search.begin(), m_Search.end(), m_Comp );
+
+ result_type M( End, End );
+
+ for( unsigned int n=1; n<=N; ++n )
+ {
+ // find next match
+ M=last_finder( Begin, ::boost::begin(M) );
+
+ if ( !M )
+ {
+ // Subsequence not found, return
+ return M;
+ }
+ }
+
+ return M;
+ }
+
+
+ private:
+ iterator_range<search_iterator_type> m_Search;
+ int m_Nth;
+ PredicateT m_Comp;
+ };
+
+// find head/tail implementation helpers ---------------------------//
+
+ template<typename ForwardIteratorT>
+ iterator_range<ForwardIteratorT>
+ find_head_impl(
+ ForwardIteratorT Begin,
+ ForwardIteratorT End,
+ unsigned int N,
+ std::forward_iterator_tag )
+ {
+ typedef ForwardIteratorT input_iterator_type;
+ typedef iterator_range<ForwardIteratorT> result_type;
+
+ input_iterator_type It=Begin;
+ for(
+ unsigned int Index=0;
+ Index<N && It!=End; ++Index,++It ) {};
+
+ return result_type( Begin, It );
+ }
+
+ template< typename ForwardIteratorT >
+ iterator_range<ForwardIteratorT>
+ find_head_impl(
+ ForwardIteratorT Begin,
+ ForwardIteratorT End,
+ unsigned int N,
+ std::random_access_iterator_tag )
+ {
+ typedef ForwardIteratorT input_iterator_type;
+ typedef iterator_range<ForwardIteratorT> result_type;
+
+ if ( (End<=Begin) || ( static_cast<unsigned int>(End-Begin) < N ) )
+ return result_type( Begin, End );
+
+ return result_type(Begin,Begin+N);
+ }
+
+ // Find head implementation
+ template<typename ForwardIteratorT>
+ iterator_range<ForwardIteratorT>
+ find_head_impl(
+ ForwardIteratorT Begin,
+ ForwardIteratorT End,
+ unsigned int N )
+ {
+ typedef BOOST_STRING_TYPENAME boost::detail::
+ iterator_traits<ForwardIteratorT>::iterator_category category;
+
+ return ::boost::algorithm::detail::find_head_impl( Begin, End, N, category() );
+ }
+
+ template< typename ForwardIteratorT >
+ iterator_range<ForwardIteratorT>
+ find_tail_impl(
+ ForwardIteratorT Begin,
+ ForwardIteratorT End,
+ unsigned int N,
+ std::forward_iterator_tag )
+ {
+ typedef ForwardIteratorT input_iterator_type;
+ typedef iterator_range<ForwardIteratorT> result_type;
+
+ unsigned int Index=0;
+ input_iterator_type It=Begin;
+ input_iterator_type It2=Begin;
+
+ // Advance It2 by N increments
+ for( Index=0; Index<N && It2!=End; ++Index,++It2 ) {};
+
+ // Advance It, It2 to the end
+ for(; It2!=End; ++It,++It2 ) {};
+
+ return result_type( It, It2 );
+ }
+
+ template< typename ForwardIteratorT >
+ iterator_range<ForwardIteratorT>
+ find_tail_impl(
+ ForwardIteratorT Begin,
+ ForwardIteratorT End,
+ unsigned int N,
+ std::bidirectional_iterator_tag )
+ {
+ typedef ForwardIteratorT input_iterator_type;
+ typedef iterator_range<ForwardIteratorT> result_type;
+
+ input_iterator_type It=End;
+ for(
+ unsigned int Index=0;
+ Index<N && It!=Begin; ++Index,--It ) {};
+
+ return result_type( It, End );
+ }
+
+ template< typename ForwardIteratorT >
+ iterator_range<ForwardIteratorT>
+ find_tail_impl(
+ ForwardIteratorT Begin,
+ ForwardIteratorT End,
+ unsigned int N,
+ std::random_access_iterator_tag )
+ {
+ typedef ForwardIteratorT input_iterator_type;
+ typedef iterator_range<ForwardIteratorT> result_type;
+
+ if ( (End<=Begin) || ( static_cast<unsigned int>(End-Begin) < N ) )
+ return result_type( Begin, End );
+
+ return result_type( End-N, End );
+ }
+
+ // Operation
+ template< typename ForwardIteratorT >
+ iterator_range<ForwardIteratorT>
+ find_tail_impl(
+ ForwardIteratorT Begin,
+ ForwardIteratorT End,
+ unsigned int N )
+ {
+ typedef BOOST_STRING_TYPENAME boost::detail::
+ iterator_traits<ForwardIteratorT>::iterator_category category;
+
+ return ::boost::algorithm::detail::find_tail_impl( Begin, End, N, category() );
+ }
+
+
+
+// find head functor -----------------------------------------------//
+
+
+ // find a head in the sequence ( functor )
+ /*
+ This functor find a head of the specified range. For
+ a specified N, the head is a subsequence of N starting
+ elements of the range.
+ */
+ struct head_finderF
+ {
+ // Construction
+ head_finderF( int N ) : m_N(N) {}
+
+ // Operation
+ template< typename ForwardIteratorT >
+ iterator_range<ForwardIteratorT>
+ operator()(
+ ForwardIteratorT Begin,
+ ForwardIteratorT End ) const
+ {
+ if(m_N>=0)
+ {
+ return ::boost::algorithm::detail::find_head_impl( Begin, End, m_N );
+ }
+ else
+ {
+ iterator_range<ForwardIteratorT> Res=
+ ::boost::algorithm::detail::find_tail_impl( Begin, End, -m_N );
+
+ return ::boost::make_iterator_range(Begin, Res.begin());
+ }
+ }
+
+ private:
+ int m_N;
+ };
+
+// find tail functor -----------------------------------------------//
+
+
+ // find a tail in the sequence ( functor )
+ /*
+ This functor find a tail of the specified range. For
+ a specified N, the head is a subsequence of N starting
+ elements of the range.
+ */
+ struct tail_finderF
+ {
+ // Construction
+ tail_finderF( int N ) : m_N(N) {}
+
+ // Operation
+ template< typename ForwardIteratorT >
+ iterator_range<ForwardIteratorT>
+ operator()(
+ ForwardIteratorT Begin,
+ ForwardIteratorT End ) const
+ {
+ if(m_N>=0)
+ {
+ return ::boost::algorithm::detail::find_tail_impl( Begin, End, m_N );
+ }
+ else
+ {
+ iterator_range<ForwardIteratorT> Res=
+ ::boost::algorithm::detail::find_head_impl( Begin, End, -m_N );
+
+ return ::boost::make_iterator_range(Res.end(), End);
+ }
+ }
+
+ private:
+ int m_N;
+ };
+
+// find token functor -----------------------------------------------//
+
+ // find a token in a sequence ( functor )
+ /*
+ This find functor finds a token specified be a predicate
+ in a sequence. It is equivalent of std::find algorithm,
+ with an exception that it return range instead of a single
+ iterator.
+
+ If bCompress is set to true, adjacent matching tokens are
+ concatenated into one match.
+ */
+ template< typename PredicateT >
+ struct token_finderF
+ {
+ // Construction
+ token_finderF(
+ PredicateT Pred,
+ token_compress_mode_type eCompress=token_compress_off ) :
+ m_Pred(Pred), m_eCompress(eCompress) {}
+
+ // Operation
+ template< typename ForwardIteratorT >
+ iterator_range<ForwardIteratorT>
+ operator()(
+ ForwardIteratorT Begin,
+ ForwardIteratorT End ) const
+ {
+ typedef iterator_range<ForwardIteratorT> result_type;
+
+ ForwardIteratorT It=std::find_if( Begin, End, m_Pred );
+
+ if( It==End )
+ {
+ return result_type( End, End );
+ }
+ else
+ {
+ ForwardIteratorT It2=It;
+
+ if( m_eCompress==token_compress_on )
+ {
+ // Find first non-matching character
+ while( It2!=End && m_Pred(*It2) ) ++It2;
+ }
+ else
+ {
+ // Advance by one position
+ ++It2;
+ }
+
+ return result_type( It, It2 );
+ }
+ }
+
+ private:
+ PredicateT m_Pred;
+ token_compress_mode_type m_eCompress;
+ };
+
+// find range functor -----------------------------------------------//
+
+ // find a range in the sequence ( functor )
+ /*
+ This functor actually does not perform any find operation.
+ It always returns given iterator range as a result.
+ */
+ template<typename ForwardIterator1T>
+ struct range_finderF
+ {
+ typedef ForwardIterator1T input_iterator_type;
+ typedef iterator_range<input_iterator_type> result_type;
+
+ // Construction
+ range_finderF(
+ input_iterator_type Begin,
+ input_iterator_type End ) : m_Range(Begin, End) {}
+
+ range_finderF(const iterator_range<input_iterator_type>& Range) :
+ m_Range(Range) {}
+
+ // Operation
+ template< typename ForwardIterator2T >
+ iterator_range<ForwardIterator2T>
+ operator()(
+ ForwardIterator2T,
+ ForwardIterator2T ) const
+ {
+#if BOOST_WORKAROUND( __MWERKS__, <= 0x3003 )
+ return iterator_range<const ForwardIterator2T>(this->m_Range);
+#elif BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
+ return iterator_range<ForwardIterator2T>(m_Range.begin(), m_Range.end());
+#else
+ return m_Range;
+#endif
+ }
+
+ private:
+ iterator_range<input_iterator_type> m_Range;
+ };
+
+
+ } // namespace detail
+ } // namespace algorithm
+} // namespace boost
+
+#endif // BOOST_STRING_FINDER_DETAIL_HPP
diff --git a/Utilities/BGL/boost/algorithm/string/detail/finder_regex.hpp b/Utilities/BGL/boost/algorithm/string/detail/finder_regex.hpp
new file mode 100755
index 0000000000000000000000000000000000000000..a5239b83e9bc4431ff8e42b85d8478872f2dcc10
--- /dev/null
+++ b/Utilities/BGL/boost/algorithm/string/detail/finder_regex.hpp
@@ -0,0 +1,122 @@
+// Boost string_algo library find_regex.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_FINDER_REGEX_DETAIL_HPP
+#define BOOST_STRING_FINDER_REGEX_DETAIL_HPP
+
+#include <boost/algorithm/string/config.hpp>
+#include <boost/regex.hpp>
+
+#include <boost/range/iterator_range.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+
+namespace boost {
+ namespace algorithm {
+ namespace detail {
+
+// regex find functor -----------------------------------------------//
+
+ // regex search result
+ template<typename IteratorT>
+ struct regex_search_result :
+ public iterator_range<IteratorT>
+ {
+ typedef regex_search_result<IteratorT> type;
+ typedef iterator_range<IteratorT> base_type;
+ typedef BOOST_STRING_TYPENAME base_type::value_type value_type;
+ typedef BOOST_STRING_TYPENAME base_type::difference_type difference_type;
+ typedef BOOST_STRING_TYPENAME base_type::const_iterator const_iterator;
+ typedef BOOST_STRING_TYPENAME base_type::iterator iterator;
+ typedef boost::match_results<iterator> match_results_type;
+
+ // Construction
+
+ // Construction from the match result
+ regex_search_result( const match_results_type& MatchResults ) :
+ base_type( MatchResults[0].first, MatchResults[0].second ),
+ m_MatchResults( MatchResults ) {}
+
+ // Construction of empty match. End iterator has to be specified
+ regex_search_result( IteratorT End ) :
+ base_type( End, End ) {}
+
+ regex_search_result( const regex_search_result& Other ) :
+ base_type( Other.begin(), Other.end() ),
+ m_MatchResults( Other.m_MatchResults ) {}
+
+ // Assignment
+ regex_search_result& operator=( const regex_search_result& Other )
+ {
+ base_type::operator=( Other );
+ m_MatchResults=Other.m_MatchResults;
+ return *this;
+ }
+
+ // Match result retrival
+ const match_results_type& match_results() const
+ {
+ return m_MatchResults;
+ }
+
+ private:
+ // Saved matchresult
+ match_results_type m_MatchResults;
+ };
+
+ // find_regex
+ /*
+ Regex based search functor
+ */
+ template<typename RegExT>
+ struct find_regexF
+ {
+ typedef RegExT regex_type;
+ typedef const RegExT& regex_reference_type;
+
+ // Construction
+ find_regexF( regex_reference_type Rx, match_flag_type MatchFlags = match_default ) :
+ m_Rx(Rx), m_MatchFlags(MatchFlags) {}
+
+ // Operation
+ template< typename ForwardIteratorT >
+ regex_search_result<ForwardIteratorT>
+ operator()(
+ ForwardIteratorT Begin,
+ ForwardIteratorT End ) const
+ {
+ typedef ForwardIteratorT input_iterator_type;
+ typedef regex_search_result<ForwardIteratorT> result_type;
+
+ // instantiate match result
+ match_results<input_iterator_type> result;
+ // search for a match
+ if ( ::boost::regex_search( Begin, End, result, m_Rx, m_MatchFlags ) )
+ {
+ // construct a result
+ return result_type( result );
+ }
+ else
+ {
+ // empty result
+ return result_type( End );
+ }
+ }
+
+ private:
+ regex_reference_type m_Rx; // Regexp
+ match_flag_type m_MatchFlags; // match flags
+ };
+
+ } // namespace detail
+ } // namespace algorithm
+} // namespace boost
+
+#endif // BOOST_STRING_FIND_DETAIL_HPP
diff --git a/Utilities/BGL/boost/algorithm/string/detail/formatter.hpp b/Utilities/BGL/boost/algorithm/string/detail/formatter.hpp
new file mode 100755
index 0000000000000000000000000000000000000000..994ab24583f19fde56fae22b1436986746899583
--- /dev/null
+++ b/Utilities/BGL/boost/algorithm/string/detail/formatter.hpp
@@ -0,0 +1,94 @@
+// Boost string_algo library formatter.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_FORMATTER_DETAIL_HPP
+#define BOOST_STRING_FORMATTER_DETAIL_HPP
+
+
+#include <boost/range/iterator_range.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/const_iterator.hpp>
+
+#include <boost/algorithm/string/detail/util.hpp>
+
+// generic replace functors -----------------------------------------------//
+
+namespace boost {
+ namespace algorithm {
+ namespace detail {
+
+// const format functor ----------------------------------------------------//
+
+ // constant format functor
+ template<typename RangeT>
+ struct const_formatF
+ {
+ private:
+ typedef BOOST_STRING_TYPENAME
+ range_const_iterator<RangeT>::type format_iterator;
+ typedef iterator_range<format_iterator> result_type;
+
+ public:
+ // Construction
+ const_formatF(const RangeT& Format) :
+ m_Format(::boost::begin(Format), ::boost::end(Format)) {}
+
+ // Operation
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+ template<typename Range2T>
+ result_type& operator()(const Range2T&)
+ {
+ return m_Format;
+ }
+#endif
+
+ template<typename Range2T>
+ const result_type& operator()(const Range2T&) const
+ {
+ return m_Format;
+ }
+
+ private:
+ result_type m_Format;
+ };
+
+// identity format functor ----------------------------------------------------//
+
+ // identity format functor
+ template<typename RangeT>
+ struct identity_formatF
+ {
+ // Operation
+ template< typename Range2T >
+ const RangeT& operator()(const Range2T& Replace) const
+ {
+ return RangeT(::boost::begin(Replace), ::boost::end(Replace));
+ }
+ };
+
+// empty format functor ( used by erase ) ------------------------------------//
+
+ // empty format functor
+ template< typename CharT >
+ struct empty_formatF
+ {
+ template< typename ReplaceT >
+ empty_container<CharT> operator()(const ReplaceT&) const
+ {
+ return empty_container<CharT>();
+ }
+ };
+
+ } // namespace detail
+ } // namespace algorithm
+} // namespace boost
+
+#endif // BOOST_STRING_FORMATTER_DETAIL_HPP
diff --git a/Utilities/BGL/boost/algorithm/string/detail/formatter_regex.hpp b/Utilities/BGL/boost/algorithm/string/detail/formatter_regex.hpp
new file mode 100755
index 0000000000000000000000000000000000000000..20ebc9620963d757a5d9c95c67a94c0ddb322208
--- /dev/null
+++ b/Utilities/BGL/boost/algorithm/string/detail/formatter_regex.hpp
@@ -0,0 +1,61 @@
+// Boost string_algo library formatter_regex.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_FORMATTER_REGEX_DETAIL_HPP
+#define BOOST_STRING_FORMATTER_REGEX_DETAIL_HPP
+
+#include <boost/algorithm/string/config.hpp>
+#include <string>
+#include <boost/regex.hpp>
+#include <boost/algorithm/string/detail/finder_regex.hpp>
+
+namespace boost {
+ namespace algorithm {
+ namespace detail {
+
+// regex format functor -----------------------------------------//
+
+ // regex format functor
+ template<typename StringT>
+ struct regex_formatF
+ {
+ private:
+ typedef StringT result_type;
+ typedef BOOST_STRING_TYPENAME StringT::value_type char_type;
+
+ public:
+ // Construction
+ regex_formatF( const StringT& Fmt, match_flag_type Flags=format_default ) :
+ m_Fmt(Fmt), m_Flags( Flags ) {}
+
+ template<typename InputIteratorT>
+ result_type operator()(
+ const regex_search_result<InputIteratorT>& Replace ) const
+ {
+ if ( Replace.empty() )
+ {
+ return result_type();
+ }
+ else
+ {
+ return Replace.match_results().format( m_Fmt, m_Flags );
+ }
+ }
+ private:
+ const StringT& m_Fmt;
+ match_flag_type m_Flags;
+ };
+
+
+ } // namespace detail
+ } // namespace algorithm
+} // namespace boost
+
+#endif // BOOST_STRING_FORMATTER_DETAIL_HPP
diff --git a/Utilities/BGL/boost/algorithm/string/detail/predicate.hpp b/Utilities/BGL/boost/algorithm/string/detail/predicate.hpp
new file mode 100755
index 0000000000000000000000000000000000000000..bd95d40c870eddb2099d0f96a1fd36b8b724a5c7
--- /dev/null
+++ b/Utilities/BGL/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/Utilities/BGL/boost/algorithm/string/detail/replace_storage.hpp b/Utilities/BGL/boost/algorithm/string/detail/replace_storage.hpp
new file mode 100755
index 0000000000000000000000000000000000000000..13f4e08b47bfe16a7943a2a7728f7cc1b88f0faa
--- /dev/null
+++ b/Utilities/BGL/boost/algorithm/string/detail/replace_storage.hpp
@@ -0,0 +1,159 @@
+// Boost string_algo library replace_storage.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_REPLACE_STORAGE_DETAIL_HPP
+#define BOOST_STRING_REPLACE_STORAGE_DETAIL_HPP
+
+#include <boost/algorithm/string/config.hpp>
+#include <algorithm>
+#include <boost/mpl/bool.hpp>
+#include <boost/algorithm/string/sequence_traits.hpp>
+#include <boost/algorithm/string/detail/sequence.hpp>
+
+namespace boost {
+ namespace algorithm {
+ namespace detail {
+
+// storage handling routines -----------------------------------------------//
+
+ template< typename StorageT, typename OutputIteratorT >
+ inline OutputIteratorT move_from_storage(
+ StorageT& Storage,
+ OutputIteratorT DestBegin,
+ OutputIteratorT DestEnd )
+ {
+ OutputIteratorT OutputIt=DestBegin;
+
+ while( !Storage.empty() && OutputIt!=DestEnd )
+ {
+ *OutputIt=Storage.front();
+ Storage.pop_front();
+ ++OutputIt;
+ }
+
+ return OutputIt;
+ }
+
+ template< typename StorageT, typename WhatT >
+ inline void copy_to_storage(
+ StorageT& Storage,
+ const WhatT& What )
+ {
+ Storage.insert( Storage.end(), ::boost::begin(What), ::boost::end(What) );
+ }
+
+
+// process segment routine -----------------------------------------------//
+
+ template< bool HasStableIterators >
+ struct process_segment_helper
+ {
+ // Optimized version of process_segment for generic sequence
+ template<
+ typename StorageT,
+ typename InputT,
+ typename ForwardIteratorT >
+ ForwardIteratorT operator()(
+ StorageT& Storage,
+ InputT& /*Input*/,
+ ForwardIteratorT InsertIt,
+ ForwardIteratorT SegmentBegin,
+ ForwardIteratorT SegmentEnd )
+ {
+ // Copy data from the storage until the beginning of the segment
+ ForwardIteratorT It=::boost::algorithm::detail::move_from_storage( Storage, InsertIt, SegmentBegin );
+
+ // 3 cases are possible :
+ // a) Storage is empty, It==SegmentBegin
+ // b) Storage is empty, It!=SegmentBegin
+ // c) Storage is not empty
+
+ if( Storage.empty() )
+ {
+ if( It==SegmentBegin )
+ {
+ // Case a) everything is grand, just return end of segment
+ return SegmentEnd;
+ }
+ else
+ {
+ // Case b) move the segment backwards
+ return std::copy( SegmentBegin, SegmentEnd, It );
+ }
+ }
+ else
+ {
+ // Case c) -> shift the segment to the left and keep the overlap in the storage
+ while( It!=SegmentEnd )
+ {
+ // Store value into storage
+ Storage.push_back( *It );
+ // Get the top from the storage and put it here
+ *It=Storage.front();
+ Storage.pop_front();
+
+ // Advance
+ ++It;
+ }
+
+ return It;
+ }
+ }
+ };
+
+ template<>
+ struct process_segment_helper< true >
+ {
+ // Optimized version of process_segment for list-like sequence
+ template<
+ typename StorageT,
+ typename InputT,
+ typename ForwardIteratorT >
+ ForwardIteratorT operator()(
+ StorageT& Storage,
+ InputT& Input,
+ ForwardIteratorT InsertIt,
+ ForwardIteratorT SegmentBegin,
+ ForwardIteratorT SegmentEnd )
+
+ {
+ // Call replace to do the job
+ ::boost::algorithm::detail::replace( Input, InsertIt, SegmentBegin, Storage );
+ // Empty the storage
+ Storage.clear();
+ // Iterators were not changed, simply return the end of segment
+ return SegmentEnd;
+ }
+ };
+
+ // Process one segment in the replace_all algorithm
+ template<
+ typename StorageT,
+ typename InputT,
+ typename ForwardIteratorT >
+ inline ForwardIteratorT process_segment(
+ StorageT& Storage,
+ InputT& Input,
+ ForwardIteratorT InsertIt,
+ ForwardIteratorT SegmentBegin,
+ ForwardIteratorT SegmentEnd )
+ {
+ return
+ process_segment_helper<
+ has_stable_iterators<InputT>::value>()(
+ Storage, Input, InsertIt, SegmentBegin, SegmentEnd );
+ }
+
+
+ } // namespace detail
+ } // namespace algorithm
+} // namespace boost
+
+#endif // BOOST_STRING_REPLACE_STORAGE_DETAIL_HPP
diff --git a/Utilities/BGL/boost/algorithm/string/detail/sequence.hpp b/Utilities/BGL/boost/algorithm/string/detail/sequence.hpp
new file mode 100755
index 0000000000000000000000000000000000000000..8c8bd9755c13cde9c66138e8f857c3f48690e740
--- /dev/null
+++ b/Utilities/BGL/boost/algorithm/string/detail/sequence.hpp
@@ -0,0 +1,200 @@
+// Boost string_algo library sequence.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_DETAIL_SEQUENCE_HPP
+#define BOOST_STRING_DETAIL_SEQUENCE_HPP
+
+#include <boost/algorithm/string/config.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/logical.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+
+#include <boost/algorithm/string/sequence_traits.hpp>
+
+namespace boost {
+ namespace algorithm {
+ namespace detail {
+
+// insert helpers -------------------------------------------------//
+
+ template< typename InputT, typename ForwardIteratorT >
+ inline void insert(
+ InputT& Input,
+ BOOST_STRING_TYPENAME InputT::iterator At,
+ ForwardIteratorT Begin,
+ ForwardIteratorT End )
+ {
+ Input.insert( At, Begin, End );
+ }
+
+ template< typename InputT, typename InsertT >
+ inline void insert(
+ InputT& Input,
+ BOOST_STRING_TYPENAME InputT::iterator At,
+ const InsertT& Insert )
+ {
+ ::boost::algorithm::detail::insert( Input, At, ::boost::begin(Insert), ::boost::end(Insert) );
+ }
+
+// erase helper ---------------------------------------------------//
+
+ // Erase a range in the sequence
+ /*
+ Returns the iterator pointing just after the erase subrange
+ */
+ template< typename InputT >
+ inline typename InputT::iterator erase(
+ InputT& Input,
+ BOOST_STRING_TYPENAME InputT::iterator From,
+ BOOST_STRING_TYPENAME InputT::iterator To )
+ {
+ return Input.erase( From, To );
+ }
+
+// replace helper implementation ----------------------------------//
+
+ // Optimized version of replace for generic sequence containers
+ // Assumption: insert and erase are expensive
+ template< bool HasConstTimeOperations >
+ struct replace_const_time_helper
+ {
+ template< typename InputT, typename ForwardIteratorT >
+ void operator()(
+ InputT& Input,
+ BOOST_STRING_TYPENAME InputT::iterator From,
+ BOOST_STRING_TYPENAME InputT::iterator To,
+ ForwardIteratorT Begin,
+ ForwardIteratorT End )
+ {
+ // Copy data to the container ( as much as possible )
+ ForwardIteratorT InsertIt=Begin;
+ BOOST_STRING_TYPENAME InputT::iterator InputIt=From;
+ for(; InsertIt!=End && InputIt!=To; InsertIt++, InputIt++ )
+ {
+ *InputIt=*InsertIt;
+ }
+
+ if ( InsertIt!=End )
+ {
+ // Replace sequence is longer, insert it
+ Input.insert( InputIt, InsertIt, End );
+ }
+ else
+ {
+ if ( InputIt!=To )
+ {
+ // Replace sequence is shorter, erase the rest
+ Input.erase( InputIt, To );
+ }
+ }
+ }
+ };
+
+ template<>
+ struct replace_const_time_helper< true >
+ {
+ // Const-time erase and insert methods -> use them
+ template< typename InputT, typename ForwardIteratorT >
+ void operator()(
+ InputT& Input,
+ BOOST_STRING_TYPENAME InputT::iterator From,
+ BOOST_STRING_TYPENAME InputT::iterator To,
+ ForwardIteratorT Begin,
+ ForwardIteratorT End )
+ {
+ BOOST_STRING_TYPENAME InputT::iterator At=Input.erase( From, To );
+ if ( Begin!=End )
+ {
+ if(!Input.empty())
+ {
+ Input.insert( At, Begin, End );
+ }
+ else
+ {
+ Input.insert( Input.begin(), Begin, End );
+ }
+ }
+ }
+ };
+
+ // No native replace method
+ template< bool HasNative >
+ struct replace_native_helper
+ {
+ template< typename InputT, typename ForwardIteratorT >
+ void operator()(
+ InputT& Input,
+ BOOST_STRING_TYPENAME InputT::iterator From,
+ BOOST_STRING_TYPENAME InputT::iterator To,
+ ForwardIteratorT Begin,
+ ForwardIteratorT End )
+ {
+ replace_const_time_helper<
+ boost::mpl::and_<
+ has_const_time_insert<InputT>,
+ has_const_time_erase<InputT> >::value >()(
+ Input, From, To, Begin, End );
+ }
+ };
+
+ // Container has native replace method
+ template<>
+ struct replace_native_helper< true >
+ {
+ template< typename InputT, typename ForwardIteratorT >
+ void operator()(
+ InputT& Input,
+ BOOST_STRING_TYPENAME InputT::iterator From,
+ BOOST_STRING_TYPENAME InputT::iterator To,
+ ForwardIteratorT Begin,
+ ForwardIteratorT End )
+ {
+ Input.replace( From, To, Begin, End );
+ }
+ };
+
+// replace helper -------------------------------------------------//
+
+ template< typename InputT, typename ForwardIteratorT >
+ inline void replace(
+ InputT& Input,
+ BOOST_STRING_TYPENAME InputT::iterator From,
+ BOOST_STRING_TYPENAME InputT::iterator To,
+ ForwardIteratorT Begin,
+ ForwardIteratorT End )
+ {
+ replace_native_helper< has_native_replace<InputT>::value >()(
+ Input, From, To, Begin, End );
+ }
+
+ template< typename InputT, typename InsertT >
+ inline void replace(
+ InputT& Input,
+ BOOST_STRING_TYPENAME InputT::iterator From,
+ BOOST_STRING_TYPENAME InputT::iterator To,
+ const InsertT& Insert )
+ {
+ if(From!=To)
+ {
+ ::boost::algorithm::detail::replace( Input, From, To, ::boost::begin(Insert), ::boost::end(Insert) );
+ }
+ else
+ {
+ ::boost::algorithm::detail::insert( Input, From, ::boost::begin(Insert), ::boost::end(Insert) );
+ }
+ }
+
+ } // namespace detail
+ } // namespace algorithm
+} // namespace boost
+
+
+#endif // BOOST_STRING_DETAIL_SEQUENCE_HPP
diff --git a/Utilities/BGL/boost/algorithm/string/detail/trim.hpp b/Utilities/BGL/boost/algorithm/string/detail/trim.hpp
new file mode 100755
index 0000000000000000000000000000000000000000..b53072c0060d8333b832105ec745516e2ac41a98
--- /dev/null
+++ b/Utilities/BGL/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/Utilities/BGL/boost/algorithm/string/detail/util.hpp b/Utilities/BGL/boost/algorithm/string/detail/util.hpp
new file mode 100755
index 0000000000000000000000000000000000000000..8e03a5dbd25c47dd913ddea04e2c371a8581d8f9
--- /dev/null
+++ b/Utilities/BGL/boost/algorithm/string/detail/util.hpp
@@ -0,0 +1,106 @@
+// Boost string_algo library util.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_UTIL_DETAIL_HPP
+#define BOOST_STRING_UTIL_DETAIL_HPP
+
+#include <boost/algorithm/string/config.hpp>
+#include <functional>
+#include <boost/range/iterator_range.hpp>
+
+namespace boost {
+ namespace algorithm {
+ namespace detail {
+
+// empty container -----------------------------------------------//
+
+ // empty_container
+ /*
+ This class represents always empty container,
+ containing elements of type CharT.
+
+ It is supposed to be used in a const version only
+ */
+ template< typename CharT >
+ struct empty_container
+ {
+ typedef empty_container<CharT> type;
+ typedef CharT value_type;
+ typedef std::size_t size_type;
+ typedef std::ptrdiff_t difference_type;
+ typedef const value_type& reference;
+ typedef const value_type& const_reference;
+ typedef const value_type* iterator;
+ typedef const value_type* const_iterator;
+
+
+ // Operations
+ const_iterator begin() const
+ {
+ return reinterpret_cast<const_iterator>(0);
+ }
+
+ const_iterator end() const
+ {
+ return reinterpret_cast<const_iterator>(0);
+ }
+
+ bool empty() const
+ {
+ return false;
+ }
+
+ size_type size() const
+ {
+ return 0;
+ }
+ };
+
+// bounded copy algorithm -----------------------------------------------//
+
+ // Bounded version of the std::copy algorithm
+ template<typename InputIteratorT, typename OutputIteratorT>
+ inline OutputIteratorT bounded_copy(
+ InputIteratorT First,
+ InputIteratorT Last,
+ OutputIteratorT DestFirst,
+ OutputIteratorT DestLast )
+ {
+ InputIteratorT InputIt=First;
+ OutputIteratorT OutputIt=DestFirst;
+ for(; InputIt!=Last && OutputIt!=DestLast; InputIt++, OutputIt++ )
+ {
+ *OutputIt=*InputIt;
+ }
+
+ return OutputIt;
+ }
+
+// iterator range utilities -----------------------------------------//
+
+ // copy range functor
+ template<
+ typename SeqT,
+ typename IteratorT=BOOST_STRING_TYPENAME SeqT::const_iterator >
+ struct copy_iterator_rangeF :
+ public std::unary_function< iterator_range<IteratorT>, SeqT >
+ {
+ SeqT operator()( const iterator_range<IteratorT>& Range ) const
+ {
+ return copy_range<SeqT>(Range);
+ }
+ };
+
+ } // namespace detail
+ } // namespace algorithm
+} // namespace boost
+
+
+#endif // BOOST_STRING_UTIL_DETAIL_HPP
diff --git a/Utilities/BGL/boost/algorithm/string/erase.hpp b/Utilities/BGL/boost/algorithm/string/erase.hpp
new file mode 100755
index 0000000000000000000000000000000000000000..6e8856b3132ff597e1ad5c18dd2a1555e88bbbb9
--- /dev/null
+++ b/Utilities/BGL/boost/algorithm/string/erase.hpp
@@ -0,0 +1,844 @@
+// Boost string_algo library erase.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_ERASE_HPP
+#define BOOST_STRING_ERASE_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/const_iterator.hpp>
+
+#include <boost/algorithm/string/find_format.hpp>
+#include <boost/algorithm/string/finder.hpp>
+#include <boost/algorithm/string/formatter.hpp>
+
+/*! \file
+ Defines various erase algorithms. Each algorithm removes
+ part(s) of the input according to a searching criteria.
+*/
+
+namespace boost {
+ namespace algorithm {
+
+// erase_range -------------------------------------------------------//
+
+ //! Erase range algorithm
+ /*!
+ Remove the given range from the input. The result is a modified 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 sequence
+ \param SearchRange A range in the input to be removed
+ \return An output iterator pointing just after the last inserted character or
+ a modified copy of the input
+
+ \note The second variant of this function provides the strong exception-safety guarantee
+ */
+ template<typename OutputIteratorT, typename RangeT>
+ inline OutputIteratorT erase_range_copy(
+ OutputIteratorT Output,
+ const RangeT& Input,
+ const iterator_range<
+ BOOST_STRING_TYPENAME
+ range_const_iterator<RangeT>::type>& SearchRange )
+ {
+ return ::boost::algorithm::find_format_copy(
+ Output,
+ Input,
+ ::boost::algorithm::range_finder(SearchRange),
+ ::boost::algorithm::empty_formatter(Input) );
+ }
+
+ //! Erase range algorithm
+ /*!
+ \overload
+ */
+ template<typename SequenceT>
+ inline SequenceT erase_range_copy(
+ const SequenceT& Input,
+ const iterator_range<
+ BOOST_STRING_TYPENAME
+ range_const_iterator<SequenceT>::type>& SearchRange )
+ {
+ return ::boost::algorithm::find_format_copy(
+ Input,
+ ::boost::algorithm::range_finder(SearchRange),
+ ::boost::algorithm::empty_formatter(Input) );
+ }
+
+ //! Erase range algorithm
+ /*!
+ Remove the given range from the input.
+ The input sequence is modified in-place.
+
+ \param Input An input sequence
+ \param SearchRange A range in the input to be removed
+ */
+ template<typename SequenceT>
+ inline void erase_range(
+ SequenceT& Input,
+ const iterator_range<
+ BOOST_STRING_TYPENAME
+ range_iterator<SequenceT>::type>& SearchRange )
+ {
+ ::boost::algorithm::find_format(
+ Input,
+ ::boost::algorithm::range_finder(SearchRange),
+ ::boost::algorithm::empty_formatter(Input) );
+ }
+
+// erase_first --------------------------------------------------------//
+
+ //! Erase first algorithm
+ /*!
+ Remove the first occurrence of the substring from the input.
+ The result is a modified 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 string
+ \param Search A substring to be searched for
+ \return An output iterator pointing just after the last inserted character or
+ a modified copy of the input
+
+ \note The second variant of this function provides the strong exception-safety guarantee
+ */
+ template<
+ typename OutputIteratorT,
+ typename Range1T,
+ typename Range2T>
+ inline OutputIteratorT erase_first_copy(
+ OutputIteratorT Output,
+ const Range1T& Input,
+ const Range2T& Search )
+ {
+ return ::boost::algorithm::find_format_copy(
+ Output,
+ Input,
+ ::boost::algorithm::first_finder(Search),
+ ::boost::algorithm::empty_formatter(Input) );
+ }
+
+ //! Erase first algorithm
+ /*!
+ \overload
+ */
+ template<typename SequenceT, typename RangeT>
+ inline SequenceT erase_first_copy(
+ const SequenceT& Input,
+ const RangeT& Search )
+ {
+ return ::boost::algorithm::find_format_copy(
+ Input,
+ ::boost::algorithm::first_finder(Search),
+ ::boost::algorithm::empty_formatter(Input) );
+ }
+
+ //! Erase first algorithm
+ /*!
+ Remove the first occurrence of the substring from the input.
+ The input sequence is modified in-place.
+
+ \param Input An input string
+ \param Search A substring to be searched for.
+ */
+ template<typename SequenceT, typename RangeT>
+ inline void erase_first(
+ SequenceT& Input,
+ const RangeT& Search )
+ {
+ ::boost::algorithm::find_format(
+ Input,
+ ::boost::algorithm::first_finder(Search),
+ ::boost::algorithm::empty_formatter(Input) );
+ }
+
+// erase_first ( case insensitive ) ------------------------------------//
+
+ //! Erase first algorithm ( case insensitive )
+ /*!
+ Remove the first occurrence of the substring from the input.
+ The result is a modified copy of the input. It is returned as a sequence
+ or copied to the output iterator.
+ Searching is case insensitive.
+
+ \param Output An output iterator to which the result will be copied
+ \param Input An input string
+ \param Search A substring to be searched for
+ \param Loc A locale used for case insensitive comparison
+ \return An output iterator pointing just after the last inserted character or
+ a modified copy of the input
+
+ \note The second variant of this function provides the strong exception-safety guarantee
+ */
+ template<
+ typename OutputIteratorT,
+ typename Range1T,
+ typename Range2T>
+ inline OutputIteratorT ierase_first_copy(
+ OutputIteratorT Output,
+ const Range1T& Input,
+ const Range2T& Search,
+ const std::locale& Loc=std::locale() )
+ {
+ return ::boost::algorithm::find_format_copy(
+ Output,
+ Input,
+ ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
+ ::boost::algorithm::empty_formatter(Input) );
+ }
+
+ //! Erase first algorithm ( case insensitive )
+ /*!
+ \overload
+ */
+ template<typename SequenceT, typename RangeT>
+ inline SequenceT ierase_first_copy(
+ const SequenceT& Input,
+ const RangeT& Search,
+ const std::locale& Loc=std::locale() )
+ {
+ return ::boost::algorithm::find_format_copy(
+ Input,
+ ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
+ ::boost::algorithm::empty_formatter(Input) );
+ }
+
+ //! Erase first algorithm ( case insensitive )
+ /*!
+ Remove the first occurrence of the substring from the input.
+ The input sequence is modified in-place. Searching is case insensitive.
+
+ \param Input An input string
+ \param Search A substring to be searched for
+ \param Loc A locale used for case insensitive comparison
+ */
+ template<typename SequenceT, typename RangeT>
+ inline void ierase_first(
+ SequenceT& Input,
+ const RangeT& Search,
+ const std::locale& Loc=std::locale() )
+ {
+ ::boost::algorithm::find_format(
+ Input,
+ ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
+ ::boost::algorithm::empty_formatter(Input) );
+ }
+
+// erase_last --------------------------------------------------------//
+
+ //! Erase last algorithm
+ /*!
+ Remove the last occurrence of the substring from the input.
+ The result is a modified 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 string
+ \param Search A substring to be searched for.
+ \return An output iterator pointing just after the last inserted character or
+ a modified copy of the input
+
+ \note The second variant of this function provides the strong exception-safety guarantee
+ */
+ template<
+ typename OutputIteratorT,
+ typename Range1T,
+ typename Range2T>
+ inline OutputIteratorT erase_last_copy(
+ OutputIteratorT Output,
+ const Range1T& Input,
+ const Range2T& Search )
+ {
+ return ::boost::algorithm::find_format_copy(
+ Output,
+ Input,
+ ::boost::algorithm::last_finder(Search),
+ ::boost::algorithm::empty_formatter(Input) );
+ }
+
+ //! Erase last algorithm
+ /*!
+ \overload
+ */
+ template<typename SequenceT, typename RangeT>
+ inline SequenceT erase_last_copy(
+ const SequenceT& Input,
+ const RangeT& Search )
+ {
+ return ::boost::algorithm::find_format_copy(
+ Input,
+ ::boost::algorithm::last_finder(Search),
+ ::boost::algorithm::empty_formatter(Input) );
+ }
+
+ //! Erase last algorithm
+ /*!
+ Remove the last occurrence of the substring from the input.
+ The input sequence is modified in-place.
+
+ \param Input An input string
+ \param Search A substring to be searched for
+ */
+ template<typename SequenceT, typename RangeT>
+ inline void erase_last(
+ SequenceT& Input,
+ const RangeT& Search )
+ {
+ ::boost::algorithm::find_format(
+ Input,
+ ::boost::algorithm::last_finder(Search),
+ ::boost::algorithm::empty_formatter(Input) );
+ }
+
+// erase_last ( case insensitive ) ------------------------------------//
+
+ //! Erase last algorithm ( case insensitive )
+ /*!
+ Remove the last occurrence of the substring from the input.
+ The result is a modified copy of the input. It is returned as a sequence
+ or copied to the output iterator.
+ Searching is case insensitive.
+
+ \param Output An output iterator to which the result will be copied
+ \param Input An input string
+ \param Search A substring to be searched for
+ \param Loc A locale used for case insensitive comparison
+ \return An output iterator pointing just after the last inserted character or
+ a modified copy of the input
+
+ \note The second variant of this function provides the strong exception-safety guarantee
+ */
+ template<
+ typename OutputIteratorT,
+ typename Range1T,
+ typename Range2T>
+ inline OutputIteratorT ierase_last_copy(
+ OutputIteratorT Output,
+ const Range1T& Input,
+ const Range2T& Search,
+ const std::locale& Loc=std::locale() )
+ {
+ return ::boost::algorithm::find_format_copy(
+ Output,
+ Input,
+ ::boost::algorithm::last_finder(Search, is_iequal(Loc)),
+ ::boost::algorithm::empty_formatter(Input) );
+ }
+
+ //! Erase last algorithm ( case insensitive )
+ /*!
+ \overload
+ */
+ template<typename SequenceT, typename RangeT>
+ inline SequenceT ierase_last_copy(
+ const SequenceT& Input,
+ const RangeT& Search,
+ const std::locale& Loc=std::locale() )
+ {
+ return ::boost::algorithm::find_format_copy(
+ Input,
+ ::boost::algorithm::last_finder(Search, is_iequal(Loc)),
+ ::boost::algorithm::empty_formatter(Input) );
+ }
+
+ //! Erase last algorithm ( case insensitive )
+ /*!
+ Remove the last occurrence of the substring from the input.
+ The input sequence is modified in-place. Searching is case insensitive.
+
+ \param Input An input string
+ \param Search A substring to be searched for
+ \param Loc A locale used for case insensitive comparison
+ */
+ template<typename SequenceT, typename RangeT>
+ inline void ierase_last(
+ SequenceT& Input,
+ const RangeT& Search,
+ const std::locale& Loc=std::locale() )
+ {
+ ::boost::algorithm::find_format(
+ Input,
+ ::boost::algorithm::last_finder(Search, is_iequal(Loc)),
+ ::boost::algorithm::empty_formatter(Input) );
+ }
+
+// erase_nth --------------------------------------------------------------------//
+
+ //! Erase nth algorithm
+ /*!
+ Remove the Nth occurrence of the substring in the input.
+ The result is a modified 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 string
+ \param Search A substring to be searched for
+ \param Nth An index of the match to be replaced. The index is 0-based.
+ For negative N, matches are counted from the end of string.
+ \return An output iterator pointing just after the last inserted character or
+ a modified copy of the input
+
+ \note The second variant of this function provides the strong exception-safety guarantee
+ */
+ template<
+ typename OutputIteratorT,
+ typename Range1T,
+ typename Range2T>
+ inline OutputIteratorT erase_nth_copy(
+ OutputIteratorT Output,
+ const Range1T& Input,
+ const Range2T& Search,
+ int Nth )
+ {
+ return ::boost::algorithm::find_format_copy(
+ Output,
+ Input,
+ ::boost::algorithm::nth_finder(Search, Nth),
+ ::boost::algorithm::empty_formatter(Input) );
+ }
+
+ //! Erase nth algorithm
+ /*!
+ \overload
+ */
+ template<typename SequenceT, typename RangeT>
+ inline SequenceT erase_nth_copy(
+ const SequenceT& Input,
+ const RangeT& Search,
+ int Nth )
+ {
+ return ::boost::algorithm::find_format_copy(
+ Input,
+ ::boost::algorithm::nth_finder(Search, Nth),
+ ::boost::algorithm::empty_formatter(Input) );
+ }
+
+ //! Erase nth algorithm
+ /*!
+ Remove the Nth occurrence of the substring in the input.
+ The input sequence is modified in-place.
+
+ \param Input An input string
+ \param Search A substring to be searched for.
+ \param Nth An index of the match to be replaced. The index is 0-based.
+ For negative N, matches are counted from the end of string.
+ */
+ template<typename SequenceT, typename RangeT>
+ inline void erase_nth(
+ SequenceT& Input,
+ const RangeT& Search,
+ int Nth )
+ {
+ ::boost::algorithm::find_format(
+ Input,
+ ::boost::algorithm::nth_finder(Search, Nth),
+ ::boost::algorithm::empty_formatter(Input) );
+ }
+
+// erase_nth ( case insensitive ) ---------------------------------------------//
+
+ //! Erase nth algorithm ( case insensitive )
+ /*!
+ Remove the Nth occurrence of the substring in the input.
+ The result is a modified copy of the input. It is returned as a sequence
+ or copied to the output iterator.
+ Searching is case insensitive.
+
+ \param Output An output iterator to which the result will be copied
+ \param Input An input string
+ \param Search A substring to be searched for.
+ \param Nth An index of the match to be replaced. The index is 0-based.
+ For negative N, matches are counted from the end of string.
+ \param Loc A locale used for case insensitive comparison
+ \return An output iterator pointing just after the last inserted character or
+ a modified copy of the input
+
+ \note The second variant of this function provides the strong exception-safety guarantee
+ */
+ template<
+ typename OutputIteratorT,
+ typename Range1T,
+ typename Range2T>
+ inline OutputIteratorT ierase_nth_copy(
+ OutputIteratorT Output,
+ const Range1T& Input,
+ const Range2T& Search,
+ int Nth,
+ const std::locale& Loc=std::locale() )
+ {
+ return ::boost::algorithm::find_format_copy(
+ Output,
+ Input,
+ ::boost::algorithm::nth_finder(Search, Nth, is_iequal(Loc)),
+ ::boost::algorithm::empty_formatter(Input) );
+ }
+
+ //! Erase nth algorithm
+ /*!
+ \overload
+ */
+ template<typename SequenceT, typename RangeT>
+ inline SequenceT ierase_nth_copy(
+ const SequenceT& Input,
+ const RangeT& Search,
+ int Nth,
+ const std::locale& Loc=std::locale() )
+ {
+ return ::boost::algorithm::find_format_copy(
+ Input,
+ ::boost::algorithm::nth_finder(Search, Nth, is_iequal(Loc)),
+ empty_formatter(Input) );
+ }
+
+ //! Erase nth algorithm
+ /*!
+ Remove the Nth occurrence of the substring in the input.
+ The input sequence is modified in-place. Searching is case insensitive.
+
+ \param Input An input string
+ \param Search A substring to be searched for.
+ \param Nth An index of the match to be replaced. The index is 0-based.
+ For negative N, matches are counted from the end of string.
+ \param Loc A locale used for case insensitive comparison
+ */
+ template<typename SequenceT, typename RangeT>
+ inline void ierase_nth(
+ SequenceT& Input,
+ const RangeT& Search,
+ int Nth,
+ const std::locale& Loc=std::locale() )
+ {
+ ::boost::algorithm::find_format(
+ Input,
+ ::boost::algorithm::nth_finder(Search, Nth, is_iequal(Loc)),
+ ::boost::algorithm::empty_formatter(Input) );
+ }
+
+
+// erase_all --------------------------------------------------------//
+
+ //! Erase all algorithm
+ /*!
+ Remove all the occurrences of the string from the input.
+ The result is a modified 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 sequence
+ \param Search A substring to be searched for.
+ \return An output iterator pointing just after the last inserted character or
+ a modified copy of the input
+
+ \note The second variant of this function provides the strong exception-safety guarantee
+ */
+ template<
+ typename OutputIteratorT,
+ typename Range1T,
+ typename Range2T>
+ inline OutputIteratorT erase_all_copy(
+ OutputIteratorT Output,
+ const Range1T& Input,
+ const Range2T& Search )
+ {
+ return ::boost::algorithm::find_format_all_copy(
+ Output,
+ Input,
+ ::boost::algorithm::first_finder(Search),
+ ::boost::algorithm::empty_formatter(Input) );
+ }
+
+ //! Erase all algorithm
+ /*!
+ \overload
+ */
+ template<typename SequenceT, typename RangeT>
+ inline SequenceT erase_all_copy(
+ const SequenceT& Input,
+ const RangeT& Search )
+ {
+ return ::boost::algorithm::find_format_all_copy(
+ Input,
+ ::boost::algorithm::first_finder(Search),
+ ::boost::algorithm::empty_formatter(Input) );
+ }
+
+ //! Erase all algorithm
+ /*!
+ Remove all the occurrences of the string from the input.
+ The input sequence is modified in-place.
+
+ \param Input An input string
+ \param Search A substring to be searched for.
+ */
+ template<typename SequenceT, typename RangeT>
+ inline void erase_all(
+ SequenceT& Input,
+ const RangeT& Search )
+ {
+ ::boost::algorithm::find_format_all(
+ Input,
+ ::boost::algorithm::first_finder(Search),
+ ::boost::algorithm::empty_formatter(Input) );
+ }
+
+// erase_all ( case insensitive ) ------------------------------------//
+
+ //! Erase all algorithm ( case insensitive )
+ /*!
+ Remove all the occurrences of the string from the input.
+ The result is a modified copy of the input. It is returned as a sequence
+ or copied to the output iterator.
+ Searching is case insensitive.
+
+ \param Output An output iterator to which the result will be copied
+ \param Input An input string
+ \param Search A substring to be searched for
+ \param Loc A locale used for case insensitive comparison
+ \return An output iterator pointing just after the last inserted character or
+ a modified copy of the input
+
+ \note The second variant of this function provides the strong exception-safety guarantee
+ */
+ template<
+ typename OutputIteratorT,
+ typename Range1T,
+ typename Range2T>
+ inline OutputIteratorT ierase_all_copy(
+ OutputIteratorT Output,
+ const Range1T& Input,
+ const Range2T& Search,
+ const std::locale& Loc=std::locale() )
+ {
+ return ::boost::algorithm::find_format_all_copy(
+ Output,
+ Input,
+ ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
+ ::boost::algorithm::empty_formatter(Input) );
+ }
+
+ //! Erase all algorithm ( case insensitive )
+ /*!
+ \overload
+ */
+ template<typename SequenceT, typename RangeT>
+ inline SequenceT ierase_all_copy(
+ const SequenceT& Input,
+ const RangeT& Search,
+ const std::locale& Loc=std::locale() )
+ {
+ return ::boost::algorithm::find_format_all_copy(
+ Input,
+ ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
+ ::boost::algorithm::empty_formatter(Input) );
+ }
+
+ //! Erase all algorithm ( case insensitive )
+ /*!
+ Remove all the occurrences of the string from the input.
+ The input sequence is modified in-place. Searching is case insensitive.
+
+ \param Input An input string
+ \param Search A substring to be searched for.
+ \param Loc A locale used for case insensitive comparison
+ */
+ template<typename SequenceT, typename RangeT>
+ inline void ierase_all(
+ SequenceT& Input,
+ const RangeT& Search,
+ const std::locale& Loc=std::locale() )
+ {
+ ::boost::algorithm::find_format_all(
+ Input,
+ ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
+ ::boost::algorithm::empty_formatter(Input) );
+ }
+
+// erase_head --------------------------------------------------------------------//
+
+ //! Erase head algorithm
+ /*!
+ Remove the head from the input. The head is a prefix of a sequence of given size.
+ If the sequence is shorter then required, the whole string is
+ considered to be the head. The result is a modified 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 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 output iterator pointing just after the last inserted character or
+ a modified copy of the input
+
+ \note The second variant of this function provides the strong exception-safety guarantee
+ */
+ template<
+ typename OutputIteratorT,
+ typename RangeT>
+ inline OutputIteratorT erase_head_copy(
+ OutputIteratorT Output,
+ const RangeT& Input,
+ int N )
+ {
+ return ::boost::algorithm::find_format_copy(
+ Output,
+ Input,
+ ::boost::algorithm::head_finder(N),
+ ::boost::algorithm::empty_formatter( Input ) );
+ }
+
+ //! Erase head algorithm
+ /*!
+ \overload
+ */
+ template<typename SequenceT>
+ inline SequenceT erase_head_copy(
+ const SequenceT& Input,
+ int N )
+ {
+ return ::boost::algorithm::find_format_copy(
+ Input,
+ ::boost::algorithm::head_finder(N),
+ ::boost::algorithm::empty_formatter( Input ) );
+ }
+
+ //! Erase head algorithm
+ /*!
+ Remove the head from the input. The head is a prefix of a sequence of given size.
+ If the sequence is shorter then required, the whole string is
+ considered to be the head. The input sequence is modified in-place.
+
+ \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.
+ */
+ template<typename SequenceT>
+ inline void erase_head(
+ SequenceT& Input,
+ int N )
+ {
+ ::boost::algorithm::find_format(
+ Input,
+ ::boost::algorithm::head_finder(N),
+ ::boost::algorithm::empty_formatter( Input ) );
+ }
+
+// erase_tail --------------------------------------------------------------------//
+
+ //! Erase tail algorithm
+ /*!
+ Remove the tail from the input. The tail is a suffix of a sequence of given size.
+ If the sequence is shorter then required, the whole string is
+ considered to be the tail.
+ The result is a modified 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 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 output iterator pointing just after the last inserted character or
+ a modified copy of the input
+
+ \note The second variant of this function provides the strong exception-safety guarantee
+ */
+ template<
+ typename OutputIteratorT,
+ typename RangeT>
+ inline OutputIteratorT erase_tail_copy(
+ OutputIteratorT Output,
+ const RangeT& Input,
+ int N )
+ {
+ return ::boost::algorithm::find_format_copy(
+ Output,
+ Input,
+ ::boost::algorithm::tail_finder(N),
+ ::boost::algorithm::empty_formatter( Input ) );
+ }
+
+ //! Erase tail algorithm
+ /*!
+ \overload
+ */
+ template<typename SequenceT>
+ inline SequenceT erase_tail_copy(
+ const SequenceT& Input,
+ int N )
+ {
+ return ::boost::algorithm::find_format_copy(
+ Input,
+ ::boost::algorithm::tail_finder(N),
+ ::boost::algorithm::empty_formatter( Input ) );
+ }
+
+ //! Erase tail algorithm
+ /*!
+ Remove the tail from the input. The tail is a suffix of a sequence of given size.
+ If the sequence is shorter then required, the whole string is
+ considered to be the tail. The input sequence is modified in-place.
+
+ \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.
+ */
+ template<typename SequenceT>
+ inline void erase_tail(
+ SequenceT& Input,
+ int N )
+ {
+ ::boost::algorithm::find_format(
+ Input,
+ ::boost::algorithm::tail_finder(N),
+ ::boost::algorithm::empty_formatter( Input ) );
+ }
+
+ } // namespace algorithm
+
+ // pull names into the boost namespace
+ using algorithm::erase_range_copy;
+ using algorithm::erase_range;
+ using algorithm::erase_first_copy;
+ using algorithm::erase_first;
+ using algorithm::ierase_first_copy;
+ using algorithm::ierase_first;
+ using algorithm::erase_last_copy;
+ using algorithm::erase_last;
+ using algorithm::ierase_last_copy;
+ using algorithm::ierase_last;
+ using algorithm::erase_nth_copy;
+ using algorithm::erase_nth;
+ using algorithm::ierase_nth_copy;
+ using algorithm::ierase_nth;
+ using algorithm::erase_all_copy;
+ using algorithm::erase_all;
+ using algorithm::ierase_all_copy;
+ using algorithm::ierase_all;
+ using algorithm::erase_head_copy;
+ using algorithm::erase_head;
+ using algorithm::erase_tail_copy;
+ using algorithm::erase_tail;
+
+} // namespace boost
+
+
+#endif // BOOST_ERASE_HPP
diff --git a/Utilities/BGL/boost/algorithm/string/find.hpp b/Utilities/BGL/boost/algorithm/string/find.hpp
new file mode 100755
index 0000000000000000000000000000000000000000..5c4775a6a3864913d893873156e705554bce7e3d
--- /dev/null
+++ b/Utilities/BGL/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 head of the input. Head 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/Utilities/BGL/boost/algorithm/string/find_format.hpp b/Utilities/BGL/boost/algorithm/string/find_format.hpp
new file mode 100755
index 0000000000000000000000000000000000000000..c66c9b0ab3888334a8df67fc739ef78403f856a8
--- /dev/null
+++ b/Utilities/BGL/boost/algorithm/string/find_format.hpp
@@ -0,0 +1,287 @@
+// Boost string_algo library find_format.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_FORMAT_HPP
+#define BOOST_STRING_FIND_FORMAT_HPP
+
+#include <deque>
+#include <boost/detail/iterator.hpp>
+#include <boost/range/iterator_range.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/algorithm/string/concept.hpp>
+#include <boost/algorithm/string/detail/find_format.hpp>
+#include <boost/algorithm/string/detail/find_format_all.hpp>
+
+/*! \file
+ Defines generic replace algorithms. Each algorithm replaces
+ part(s) of the input. The part to be replaced is looked up using a Finder object.
+ Result of finding is then used by a Formatter object to generate the replacement.
+*/
+
+namespace boost {
+ namespace algorithm {
+
+// generic replace -----------------------------------------------------------------//
+
+ //! Generic replace algorithm
+ /*!
+ Use the Finder to search for a substring. Use the Formatter to format
+ this substring and replace it in the input.
+ The result is a modified 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 sequence
+ \param Finder A Finder object used to search for a match to be replaced
+ \param Formatter A Formatter object used to format a match
+ \return An output iterator pointing just after the last inserted character or
+ a modified copy of the input
+
+ \note The second variant of this function provides the strong exception-safety guarantee
+ */
+ template<
+ typename OutputIteratorT,
+ typename RangeT,
+ typename FinderT,
+ typename FormatterT>
+ inline OutputIteratorT find_format_copy(
+ OutputIteratorT Output,
+ const RangeT& Input,
+ FinderT Finder,
+ FormatterT Formatter )
+ {
+ // Concept check
+ BOOST_CONCEPT_ASSERT((
+ FinderConcept<
+ FinderT,
+ BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type>
+ ));
+ BOOST_CONCEPT_ASSERT((
+ FormatterConcept<
+ FormatterT,
+ FinderT,BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type>
+ ));
+
+ iterator_range<BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> lit_input(::boost::as_literal(Input));
+
+ return detail::find_format_copy_impl(
+ Output,
+ lit_input,
+ Formatter,
+ Finder( ::boost::begin(lit_input), ::boost::end(lit_input) ) );
+ }
+
+ //! Generic replace algorithm
+ /*!
+ \overload
+ */
+ template<
+ typename SequenceT,
+ typename FinderT,
+ typename FormatterT>
+ inline SequenceT find_format_copy(
+ const SequenceT& Input,
+ FinderT Finder,
+ FormatterT Formatter )
+ {
+ // Concept check
+ BOOST_CONCEPT_ASSERT((
+ FinderConcept<
+ FinderT,
+ BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type>
+ ));
+ BOOST_CONCEPT_ASSERT((
+ FormatterConcept<
+ FormatterT,
+ FinderT,BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type>
+ ));
+
+ return detail::find_format_copy_impl(
+ Input,
+ Formatter,
+ Finder(::boost::begin(Input), ::boost::end(Input)));
+ }
+
+ //! Generic replace algorithm
+ /*!
+ Use the Finder to search for a substring. Use the Formatter to format
+ this substring and replace it in the input. The input is modified in-place.
+
+ \param Input An input sequence
+ \param Finder A Finder object used to search for a match to be replaced
+ \param Formatter A Formatter object used to format a match
+ */
+ template<
+ typename SequenceT,
+ typename FinderT,
+ typename FormatterT>
+ inline void find_format(
+ SequenceT& Input,
+ FinderT Finder,
+ FormatterT Formatter)
+ {
+ // Concept check
+ BOOST_CONCEPT_ASSERT((
+ FinderConcept<
+ FinderT,
+ BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type>
+ ));
+ BOOST_CONCEPT_ASSERT((
+ FormatterConcept<
+ FormatterT,
+ FinderT,BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type>
+ ));
+
+ detail::find_format_impl(
+ Input,
+ Formatter,
+ Finder(::boost::begin(Input), ::boost::end(Input)));
+ }
+
+
+// find_format_all generic ----------------------------------------------------------------//
+
+ //! Generic replace all algorithm
+ /*!
+ Use the Finder to search for a substring. Use the Formatter to format
+ this substring and replace it in the input. Repeat this for all matching
+ substrings.
+ The result is a modified 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 sequence
+ \param Finder A Finder object used to search for a match to be replaced
+ \param Formatter A Formatter object used to format a match
+ \return An output iterator pointing just after the last inserted character or
+ a modified copy of the input
+
+ \note The second variant of this function provides the strong exception-safety guarantee
+ */
+ template<
+ typename OutputIteratorT,
+ typename RangeT,
+ typename FinderT,
+ typename FormatterT>
+ inline OutputIteratorT find_format_all_copy(
+ OutputIteratorT Output,
+ const RangeT& Input,
+ FinderT Finder,
+ FormatterT Formatter)
+ {
+ // Concept check
+ BOOST_CONCEPT_ASSERT((
+ FinderConcept<
+ FinderT,
+ BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type>
+ ));
+ BOOST_CONCEPT_ASSERT((
+ FormatterConcept<
+ FormatterT,
+ FinderT,BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type>
+ ));
+
+ iterator_range<BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> lit_input(::boost::as_literal(Input));
+
+ return detail::find_format_all_copy_impl(
+ Output,
+ lit_input,
+ Finder,
+ Formatter,
+ Finder(::boost::begin(lit_input), ::boost::end(lit_input)));
+ }
+
+ //! Generic replace all algorithm
+ /*!
+ \overload
+ */
+ template<
+ typename SequenceT,
+ typename FinderT,
+ typename FormatterT >
+ inline SequenceT find_format_all_copy(
+ const SequenceT& Input,
+ FinderT Finder,
+ FormatterT Formatter )
+ {
+ // Concept check
+ BOOST_CONCEPT_ASSERT((
+ FinderConcept<
+ FinderT,
+ BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type>
+ ));
+ BOOST_CONCEPT_ASSERT((
+ FormatterConcept<
+ FormatterT,
+ FinderT,BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type>
+ ));
+
+ return detail::find_format_all_copy_impl(
+ Input,
+ Finder,
+ Formatter,
+ Finder( ::boost::begin(Input), ::boost::end(Input) ) );
+ }
+
+ //! Generic replace all algorithm
+ /*!
+ Use the Finder to search for a substring. Use the Formatter to format
+ this substring and replace it in the input. Repeat this for all matching
+ substrings.The input is modified in-place.
+
+ \param Input An input sequence
+ \param Finder A Finder object used to search for a match to be replaced
+ \param Formatter A Formatter object used to format a match
+ */
+ template<
+ typename SequenceT,
+ typename FinderT,
+ typename FormatterT >
+ inline void find_format_all(
+ SequenceT& Input,
+ FinderT Finder,
+ FormatterT Formatter )
+ {
+ // Concept check
+ BOOST_CONCEPT_ASSERT((
+ FinderConcept<
+ FinderT,
+ BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type>
+ ));
+ BOOST_CONCEPT_ASSERT((
+ FormatterConcept<
+ FormatterT,
+ FinderT,BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type>
+ ));
+
+ detail::find_format_all_impl(
+ Input,
+ Finder,
+ Formatter,
+ Finder(::boost::begin(Input), ::boost::end(Input)));
+
+ }
+
+ } // namespace algorithm
+
+ // pull the names to the boost namespace
+ using algorithm::find_format_copy;
+ using algorithm::find_format;
+ using algorithm::find_format_all_copy;
+ using algorithm::find_format_all;
+
+} // namespace boost
+
+
+#endif // BOOST_STRING_FIND_FORMAT_HPP
diff --git a/Utilities/BGL/boost/algorithm/string/find_iterator.hpp b/Utilities/BGL/boost/algorithm/string/find_iterator.hpp
new file mode 100755
index 0000000000000000000000000000000000000000..53733cd0436f023c2a961e3c299dfc4ac8c5db90
--- /dev/null
+++ b/Utilities/BGL/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(false)
+ {}
+
+ //! 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/Utilities/BGL/boost/algorithm/string/finder.hpp b/Utilities/BGL/boost/algorithm/string/finder.hpp
new file mode 100755
index 0000000000000000000000000000000000000000..2ddca4d35a7bb55cb9ad3b1f16921e3a78524f11
--- /dev/null
+++ b/Utilities/BGL/boost/algorithm/string/finder.hpp
@@ -0,0 +1,270 @@
+// Boost string_algo library finder.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_FINDER_HPP
+#define BOOST_STRING_FINDER_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/const_iterator.hpp>
+
+#include <boost/algorithm/string/constants.hpp>
+#include <boost/algorithm/string/detail/finder.hpp>
+#include <boost/algorithm/string/compare.hpp>
+
+/*! \file
+ Defines Finder generators. Finder object is a functor which is able to
+ find a substring matching a specific criteria in the input.
+ Finders are used as a pluggable components for replace, find
+ and split facilities. This header contains generator functions
+ for finders provided in this library.
+*/
+
+namespace boost {
+ namespace algorithm {
+
+// Finder generators ------------------------------------------//
+
+ //! "First" finder
+ /*!
+ Construct the \c first_finder. The finder searches for the first
+ occurrence of the string in a given input.
+ The result is given as an \c iterator_range delimiting the match.
+
+ \param Search A substring to be searched for.
+ \param Comp An element comparison predicate
+ \return An instance of the \c first_finder object
+ */
+ template<typename RangeT>
+ inline detail::first_finderF<
+ BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type,
+ is_equal>
+ first_finder( const RangeT& Search )
+ {
+ return
+ detail::first_finderF<
+ BOOST_STRING_TYPENAME
+ range_const_iterator<RangeT>::type,
+ is_equal>( ::boost::as_literal(Search), is_equal() ) ;
+ }
+
+ //! "First" finder
+ /*!
+ \overload
+ */
+ template<typename RangeT,typename PredicateT>
+ inline detail::first_finderF<
+ BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type,
+ PredicateT>
+ first_finder(
+ const RangeT& Search, PredicateT Comp )
+ {
+ return
+ detail::first_finderF<
+ BOOST_STRING_TYPENAME
+ range_const_iterator<RangeT>::type,
+ PredicateT>( ::boost::as_literal(Search), Comp );
+ }
+
+ //! "Last" finder
+ /*!
+ Construct the \c last_finder. The finder searches for the last
+ occurrence of the string in a given input.
+ The result is given as an \c iterator_range delimiting the match.
+
+ \param Search A substring to be searched for.
+ \param Comp An element comparison predicate
+ \return An instance of the \c last_finder object
+ */
+ template<typename RangeT>
+ inline detail::last_finderF<
+ BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type,
+ is_equal>
+ last_finder( const RangeT& Search )
+ {
+ return
+ detail::last_finderF<
+ BOOST_STRING_TYPENAME
+ range_const_iterator<RangeT>::type,
+ is_equal>( ::boost::as_literal(Search), is_equal() );
+ }
+ //! "Last" finder
+ /*!
+ \overload
+ */
+ template<typename RangeT, typename PredicateT>
+ inline detail::last_finderF<
+ BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type,
+ PredicateT>
+ last_finder( const RangeT& Search, PredicateT Comp )
+ {
+ return
+ detail::last_finderF<
+ BOOST_STRING_TYPENAME
+ range_const_iterator<RangeT>::type,
+ PredicateT>( ::boost::as_literal(Search), Comp ) ;
+ }
+
+ //! "Nth" finder
+ /*!
+ Construct the \c nth_finder. The finder searches for the n-th (zero-indexed)
+ occurrence of the string in a given input.
+ The result is given as an \c iterator_range delimiting the match.
+
+ \param Search A substring to be searched for.
+ \param Nth An index of the match to be find
+ \param Comp An element comparison predicate
+ \return An instance of the \c nth_finder object
+ */
+ template<typename RangeT>
+ inline detail::nth_finderF<
+ BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type,
+ is_equal>
+ nth_finder(
+ const RangeT& Search,
+ int Nth)
+ {
+ return
+ detail::nth_finderF<
+ BOOST_STRING_TYPENAME
+ range_const_iterator<RangeT>::type,
+ is_equal>( ::boost::as_literal(Search), Nth, is_equal() ) ;
+ }
+ //! "Nth" finder
+ /*!
+ \overload
+ */
+ template<typename RangeT, typename PredicateT>
+ inline detail::nth_finderF<
+ BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type,
+ PredicateT>
+ nth_finder(
+ const RangeT& Search,
+ int Nth,
+ PredicateT Comp )
+ {
+ return
+ detail::nth_finderF<
+ BOOST_STRING_TYPENAME
+ range_const_iterator<RangeT>::type,
+ PredicateT>( ::boost::as_literal(Search), Nth, Comp );
+ }
+
+ //! "Head" finder
+ /*!
+ Construct the \c head_finder. The finder returns a head of a given
+ input. The head is a prefix of a string up to n elements in
+ size. If an input has less then n elements, whole input is
+ considered a head.
+ The result is given as an \c iterator_range delimiting the match.
+
+ \param N The size of the head
+ \return An instance of the \c head_finder object
+ */
+ inline detail::head_finderF
+ head_finder( int N )
+ {
+ return detail::head_finderF(N);
+ }
+
+ //! "Tail" finder
+ /*!
+ Construct the \c tail_finder. The finder returns a tail of a given
+ input. The tail is a suffix of a string up to n elements in
+ size. If an input has less then n elements, whole input is
+ considered a head.
+ The result is given as an \c iterator_range delimiting the match.
+
+ \param N The size of the head
+ \return An instance of the \c tail_finder object
+ */
+ inline detail::tail_finderF
+ tail_finder( int N )
+ {
+ return detail::tail_finderF(N);
+ }
+
+ //! "Token" finder
+ /*!
+ Construct the \c token_finder. The finder searches for a token
+ specified by a predicate. It is similar to std::find_if
+ algorithm, with an exception that it return a range of
+ instead of a single iterator.
+
+ If "compress token mode" is enabled, adjacent matching tokens are
+ concatenated into one match. Thus the finder can be used to
+ search for continuous segments of characters satisfying the
+ given predicate.
+
+ The result is given as an \c iterator_range delimiting the match.
+
+ \param Pred An element selection predicate
+ \param eCompress Compress flag
+ \return An instance of the \c token_finder object
+ */
+ template< typename PredicateT >
+ inline detail::token_finderF<PredicateT>
+ token_finder(
+ PredicateT Pred,
+ token_compress_mode_type eCompress=token_compress_off )
+ {
+ return detail::token_finderF<PredicateT>( Pred, eCompress );
+ }
+
+ //! "Range" finder
+ /*!
+ Construct the \c range_finder. The finder does not perform
+ any operation. It simply returns the given range for
+ any input.
+
+ \param Begin Beginning of the range
+ \param End End of the range
+ \param Range The range.
+ \return An instance of the \c range_finger object
+ */
+ template< typename ForwardIteratorT >
+ inline detail::range_finderF<ForwardIteratorT>
+ range_finder(
+ ForwardIteratorT Begin,
+ ForwardIteratorT End )
+ {
+ return detail::range_finderF<ForwardIteratorT>( Begin, End );
+ }
+
+ //! "Range" finder
+ /*!
+ \overload
+ */
+ template< typename ForwardIteratorT >
+ inline detail::range_finderF<ForwardIteratorT>
+ range_finder( iterator_range<ForwardIteratorT> Range )
+ {
+ return detail::range_finderF<ForwardIteratorT>( Range );
+ }
+
+ } // namespace algorithm
+
+ // pull the names to the boost namespace
+ using algorithm::first_finder;
+ using algorithm::last_finder;
+ using algorithm::nth_finder;
+ using algorithm::head_finder;
+ using algorithm::tail_finder;
+ using algorithm::token_finder;
+ using algorithm::range_finder;
+
+} // namespace boost
+
+
+#endif // BOOST_STRING_FINDER_HPP
diff --git a/Utilities/BGL/boost/algorithm/string/formatter.hpp b/Utilities/BGL/boost/algorithm/string/formatter.hpp
new file mode 100755
index 0000000000000000000000000000000000000000..017eb90b931205fc83c6409d9bb7f13fb21ed4f1
--- /dev/null
+++ b/Utilities/BGL/boost/algorithm/string/formatter.hpp
@@ -0,0 +1,103 @@
+// Boost string_algo library formatter.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_FORMATTER_HPP
+#define BOOST_STRING_FORMATTER_HPP
+
+#include <boost/detail/iterator.hpp>
+#include <boost/range/value_type.hpp>
+#include <boost/range/iterator_range.hpp>
+#include <boost/range/as_literal.hpp>
+
+#include <boost/algorithm/string/detail/formatter.hpp>
+
+/*! \file
+ Defines Formatter generators. Formatter is a functor which formats
+ a string according to given parameters. A Formatter works
+ in conjunction with a Finder. A Finder can provide additional information
+ for a specific Formatter. An example of such a cooperation is regex_finder
+ and regex_formatter.
+
+ Formatters are used as pluggable components for replace facilities.
+ This header contains generator functions for the Formatters provided in this library.
+*/
+
+namespace boost {
+ namespace algorithm {
+
+// generic formatters ---------------------------------------------------------------//
+
+ //! Constant formatter
+ /*!
+ Construct the \c const_formatter. Const formatter always returns
+ the same value, regardless of the parameter.
+
+ \param Format A predefined value used as a result for formating
+ \return An instance of the \c const_formatter object.
+ */
+ template<typename RangeT>
+ inline detail::const_formatF<
+ iterator_range<
+ BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> >
+ const_formatter(const RangeT& Format)
+ {
+ return detail::const_formatF<
+ iterator_range<
+ BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> >(::boost::as_literal(Format));
+ }
+
+ //! Identity formatter
+ /*!
+ Construct the \c identity_formatter. Identity formatter always returns
+ the parameter.
+
+ \return An instance of the \c identity_formatter object.
+ */
+ template<typename RangeT>
+ inline detail::identity_formatF<
+ iterator_range<
+ BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> >
+ identity_formatter()
+ {
+ return detail::identity_formatF<
+ iterator_range<
+ BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> >();
+ }
+
+ //! Empty formatter
+ /*!
+ Construct the \c empty_formatter. Empty formatter always returns an empty
+ sequence.
+
+ \param Input container used to select a correct value_type for the
+ resulting empty_container<>.
+ \return An instance of the \c empty_formatter object.
+ */
+ template<typename RangeT>
+ inline detail::empty_formatF<
+ BOOST_STRING_TYPENAME range_value<RangeT>::type>
+ empty_formatter(const RangeT&)
+ {
+ return detail::empty_formatF<
+ BOOST_STRING_TYPENAME range_value<RangeT>::type>();
+ }
+
+
+ } // namespace algorithm
+
+ // pull the names to the boost namespace
+ using algorithm::const_formatter;
+ using algorithm::identity_formatter;
+ using algorithm::empty_formatter;
+
+} // namespace boost
+
+
+#endif // BOOST_FORMATTER_HPP
diff --git a/Utilities/BGL/boost/algorithm/string/iter_find.hpp b/Utilities/BGL/boost/algorithm/string/iter_find.hpp
new file mode 100755
index 0000000000000000000000000000000000000000..c4a2d06bbbcfb5df88f176cc40d5943a01e72a1d
--- /dev/null
+++ b/Utilities/BGL/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/Utilities/BGL/boost/algorithm/string/join.hpp b/Utilities/BGL/boost/algorithm/string/join.hpp
new file mode 100755
index 0000000000000000000000000000000000000000..cbc98d958299f76a31eadcc74af5c71ec6fe12fd
--- /dev/null
+++ b/Utilities/BGL/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/Utilities/BGL/boost/algorithm/string/predicate.hpp b/Utilities/BGL/boost/algorithm/string/predicate.hpp
new file mode 100755
index 0000000000000000000000000000000000000000..b625405ebe8955050003d5c88aefd847722e5ef5
--- /dev/null
+++ b/Utilities/BGL/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/Utilities/BGL/boost/algorithm/string/predicate_facade.hpp b/Utilities/BGL/boost/algorithm/string/predicate_facade.hpp
new file mode 100755
index 0000000000000000000000000000000000000000..c9d4881b41150da7689c870902e0e187fc6501be
--- /dev/null
+++ b/Utilities/BGL/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/Utilities/BGL/boost/algorithm/string/regex.hpp b/Utilities/BGL/boost/algorithm/string/regex.hpp
new file mode 100755
index 0000000000000000000000000000000000000000..2af7872b79689c21fec2663cbf18687b51d385d9
--- /dev/null
+++ b/Utilities/BGL/boost/algorithm/string/regex.hpp
@@ -0,0 +1,646 @@
+// Boost string_algo library regex.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_REGEX_HPP
+#define BOOST_STRING_REGEX_HPP
+
+#include <boost/algorithm/string/config.hpp>
+#include <boost/regex.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/find_format.hpp>
+#include <boost/algorithm/string/regex_find_format.hpp>
+#include <boost/algorithm/string/formatter.hpp>
+#include <boost/algorithm/string/iter_find.hpp>
+
+/*! \file
+ Defines regex variants of the algorithms.
+*/
+
+namespace boost {
+ namespace algorithm {
+
+// find_regex -----------------------------------------------//
+
+ //! Find regex algorithm
+ /*!
+ Search for a substring matching the given regex in the input.
+
+ \param Input A container which will be searched.
+ \param Rx A regular expression
+ \param Flags Regex options
+ \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 CharT,
+ typename RegexTraitsT>
+ inline iterator_range<
+ BOOST_STRING_TYPENAME range_iterator<RangeT>::type >
+ find_regex(
+ RangeT& Input,
+ const basic_regex<CharT, RegexTraitsT>& Rx,
+ match_flag_type Flags=match_default )
+ {
+ iterator_range<BOOST_STRING_TYPENAME range_iterator<RangeT>::type> lit_input(::boost::as_literal(Input));
+
+ return ::boost::algorithm::regex_finder(Rx,Flags)(
+ ::boost::begin(lit_input), ::boost::end(lit_input) );
+ }
+
+// replace_regex --------------------------------------------------------------------//
+
+ //! Replace regex algorithm
+ /*!
+ Search for a substring matching given regex and format it with
+ the specified format.
+ The result is a modified 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 string
+ \param Rx A regular expression
+ \param Format Regex format definition
+ \param Flags Regex options
+ \return An output iterator pointing just after the last inserted character or
+ a modified copy of the input
+
+ \note The second variant of this function provides the strong exception-safety guarantee
+ */
+ template<
+ typename OutputIteratorT,
+ typename RangeT,
+ typename CharT,
+ typename RegexTraitsT,
+ typename FormatStringTraitsT, typename FormatStringAllocatorT >
+ inline OutputIteratorT replace_regex_copy(
+ OutputIteratorT Output,
+ const RangeT& Input,
+ const basic_regex<CharT, RegexTraitsT>& Rx,
+ const std::basic_string<CharT, FormatStringTraitsT, FormatStringAllocatorT>& Format,
+ match_flag_type Flags=match_default | format_default )
+ {
+ return ::boost::algorithm::find_format_copy(
+ Output,
+ Input,
+ ::boost::algorithm::regex_finder( Rx, Flags ),
+ ::boost::algorithm::regex_formatter( Format, Flags ) );
+ }
+
+ //! Replace regex algorithm
+ /*!
+ \overload
+ */
+ template<
+ typename SequenceT,
+ typename CharT,
+ typename RegexTraitsT,
+ typename FormatStringTraitsT, typename FormatStringAllocatorT >
+ inline SequenceT replace_regex_copy(
+ const SequenceT& Input,
+ const basic_regex<CharT, RegexTraitsT>& Rx,
+ const std::basic_string<CharT, FormatStringTraitsT, FormatStringAllocatorT>& Format,
+ match_flag_type Flags=match_default | format_default )
+ {
+ return ::boost::algorithm::find_format_copy(
+ Input,
+ ::boost::algorithm::regex_finder( Rx, Flags ),
+ ::boost::algorithm::regex_formatter( Format, Flags ) );
+ }
+
+ //! Replace regex algorithm
+ /*!
+ Search for a substring matching given regex and format it with
+ the specified format. The input string is modified in-place.
+
+ \param Input An input string
+ \param Rx A regular expression
+ \param Format Regex format definition
+ \param Flags Regex options
+ */
+ template<
+ typename SequenceT,
+ typename CharT,
+ typename RegexTraitsT,
+ typename FormatStringTraitsT, typename FormatStringAllocatorT >
+ inline void replace_regex(
+ SequenceT& Input,
+ const basic_regex<CharT, RegexTraitsT>& Rx,
+ const std::basic_string<CharT, FormatStringTraitsT, FormatStringAllocatorT>& Format,
+ match_flag_type Flags=match_default | format_default )
+ {
+ ::boost::algorithm::find_format(
+ Input,
+ ::boost::algorithm::regex_finder( Rx, Flags ),
+ ::boost::algorithm::regex_formatter( Format, Flags ) );
+ }
+
+// replace_all_regex --------------------------------------------------------------------//
+
+ //! Replace all regex algorithm
+ /*!
+ Format all substrings, matching given regex, with the specified format.
+ The result is a modified 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 string
+ \param Rx A regular expression
+ \param Format Regex format definition
+ \param Flags Regex options
+ \return An output iterator pointing just after the last inserted character or
+ a modified copy of the input
+
+ \note The second variant of this function provides the strong exception-safety guarantee
+ */
+ template<
+ typename OutputIteratorT,
+ typename RangeT,
+ typename CharT,
+ typename RegexTraitsT,
+ typename FormatStringTraitsT, typename FormatStringAllocatorT >
+ inline OutputIteratorT replace_all_regex_copy(
+ OutputIteratorT Output,
+ const RangeT& Input,
+ const basic_regex<CharT, RegexTraitsT>& Rx,
+ const std::basic_string<CharT, FormatStringTraitsT, FormatStringAllocatorT>& Format,
+ match_flag_type Flags=match_default | format_default )
+ {
+ return ::boost::algorithm::find_format_all_copy(
+ Output,
+ Input,
+ ::boost::algorithm::regex_finder( Rx, Flags ),
+ ::boost::algorithm::regex_formatter( Format, Flags ) );
+ }
+
+ //! Replace all regex algorithm
+ /*!
+ \overload
+ */
+ template<
+ typename SequenceT,
+ typename CharT,
+ typename RegexTraitsT,
+ typename FormatStringTraitsT, typename FormatStringAllocatorT >
+ inline SequenceT replace_all_regex_copy(
+ const SequenceT& Input,
+ const basic_regex<CharT, RegexTraitsT>& Rx,
+ const std::basic_string<CharT, FormatStringTraitsT, FormatStringAllocatorT>& Format,
+ match_flag_type Flags=match_default | format_default )
+ {
+ return ::boost::algorithm::find_format_all_copy(
+ Input,
+ ::boost::algorithm::regex_finder( Rx, Flags ),
+ ::boost::algorithm::regex_formatter( Format, Flags ) );
+ }
+
+ //! Replace all regex algorithm
+ /*!
+ Format all substrings, matching given regex, with the specified format.
+ The input string is modified in-place.
+
+ \param Input An input string
+ \param Rx A regular expression
+ \param Format Regex format definition
+ \param Flags Regex options
+ */
+ template<
+ typename SequenceT,
+ typename CharT,
+ typename RegexTraitsT,
+ typename FormatStringTraitsT, typename FormatStringAllocatorT >
+ inline void replace_all_regex(
+ SequenceT& Input,
+ const basic_regex<CharT, RegexTraitsT>& Rx,
+ const std::basic_string<CharT, FormatStringTraitsT, FormatStringAllocatorT>& Format,
+ match_flag_type Flags=match_default | format_default )
+ {
+ ::boost::algorithm::find_format_all(
+ Input,
+ ::boost::algorithm::regex_finder( Rx, Flags ),
+ ::boost::algorithm::regex_formatter( Format, Flags ) );
+ }
+
+// erase_regex --------------------------------------------------------------------//
+
+ //! Erase regex algorithm
+ /*!
+ Remove a substring matching given regex from the input.
+ The result is a modified 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 string
+ \param Rx A regular expression
+ \param Flags Regex options
+ \return An output iterator pointing just after the last inserted character or
+ a modified copy of the input
+
+ \note The second variant of this function provides the strong exception-safety guarantee
+ */
+ template<
+ typename OutputIteratorT,
+ typename RangeT,
+ typename CharT,
+ typename RegexTraitsT >
+ inline OutputIteratorT erase_regex_copy(
+ OutputIteratorT Output,
+ const RangeT& Input,
+ const basic_regex<CharT, RegexTraitsT>& Rx,
+ match_flag_type Flags=match_default )
+ {
+ return ::boost::algorithm::find_format_copy(
+ Output,
+ Input,
+ ::boost::algorithm::regex_finder( Rx, Flags ),
+ ::boost::algorithm::empty_formatter( Input ) );
+ }
+
+ //! Erase regex algorithm
+ /*!
+ \overload
+ */
+ template<
+ typename SequenceT,
+ typename CharT,
+ typename RegexTraitsT >
+ inline SequenceT erase_regex_copy(
+ const SequenceT& Input,
+ const basic_regex<CharT, RegexTraitsT>& Rx,
+ match_flag_type Flags=match_default )
+ {
+ return ::boost::algorithm::find_format_copy(
+ Input,
+ ::boost::algorithm::regex_finder( Rx, Flags ),
+ ::boost::algorithm::empty_formatter( Input ) );
+ }
+
+ //! Erase regex algorithm
+ /*!
+ Remove a substring matching given regex from the input.
+ The input string is modified in-place.
+
+ \param Input An input string
+ \param Rx A regular expression
+ \param Flags Regex options
+ */
+ template<
+ typename SequenceT,
+ typename CharT,
+ typename RegexTraitsT >
+ inline void erase_regex(
+ SequenceT& Input,
+ const basic_regex<CharT, RegexTraitsT>& Rx,
+ match_flag_type Flags=match_default )
+ {
+ ::boost::algorithm::find_format(
+ Input,
+ ::boost::algorithm::regex_finder( Rx, Flags ),
+ ::boost::algorithm::empty_formatter( Input ) );
+ }
+
+// erase_all_regex --------------------------------------------------------------------//
+
+ //! Erase all regex algorithm
+ /*!
+ Erase all substrings, matching given regex, from the input.
+ The result is a modified 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 string
+ \param Rx A regular expression
+ \param Flags Regex options
+ \return An output iterator pointing just after the last inserted character or
+ a modified copy of the input
+
+ \note The second variant of this function provides the strong exception-safety guarantee
+ */
+ template<
+ typename OutputIteratorT,
+ typename RangeT,
+ typename CharT,
+ typename RegexTraitsT >
+ inline OutputIteratorT erase_all_regex_copy(
+ OutputIteratorT Output,
+ const RangeT& Input,
+ const basic_regex<CharT, RegexTraitsT>& Rx,
+ match_flag_type Flags=match_default )
+ {
+ return ::boost::algorithm::find_format_all_copy(
+ Output,
+ Input,
+ ::boost::algorithm::regex_finder( Rx, Flags ),
+ ::boost::algorithm::empty_formatter( Input ) );
+ }
+
+ //! Erase all regex algorithm
+ /*!
+ \overload
+ */
+ template<
+ typename SequenceT,
+ typename CharT,
+ typename RegexTraitsT >
+ inline SequenceT erase_all_regex_copy(
+ const SequenceT& Input,
+ const basic_regex<CharT, RegexTraitsT>& Rx,
+ match_flag_type Flags=match_default )
+ {
+ return ::boost::algorithm::find_format_all_copy(
+ Input,
+ ::boost::algorithm::regex_finder( Rx, Flags ),
+ ::boost::algorithm::empty_formatter( Input ) );
+ }
+
+ //! Erase all regex algorithm
+ /*!
+ Erase all substrings, matching given regex, from the input.
+ The input string is modified in-place.
+
+ \param Input An input string
+ \param Rx A regular expression
+ \param Flags Regex options
+ */
+ template<
+ typename SequenceT,
+ typename CharT,
+ typename RegexTraitsT>
+ inline void erase_all_regex(
+ SequenceT& Input,
+ const basic_regex<CharT, RegexTraitsT>& Rx,
+ match_flag_type Flags=match_default )
+ {
+ ::boost::algorithm::find_format_all(
+ Input,
+ ::boost::algorithm::regex_finder( Rx, Flags ),
+ ::boost::algorithm::empty_formatter( Input ) );
+ }
+
+// find_all_regex ------------------------------------------------------------------//
+
+ //! Find all regex algorithm
+ /*!
+ This algorithm finds all substrings matching the give regex
+ 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 Rx A regular expression
+ \param Flags Regex options
+ \return A reference to 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 CharT,
+ typename RegexTraitsT >
+ inline SequenceSequenceT& find_all_regex(
+ SequenceSequenceT& Result,
+ const RangeT& Input,
+ const basic_regex<CharT, RegexTraitsT>& Rx,
+ match_flag_type Flags=match_default )
+ {
+ return ::boost::algorithm::iter_find(
+ Result,
+ Input,
+ ::boost::algorithm::regex_finder(Rx,Flags) );
+ }
+
+// split_regex ------------------------------------------------------------------//
+
+ //! Split regex algorithm
+ /*!
+ Tokenize expression. This function is equivalent to C strtok. Input
+ sequence is split into tokens, separated by separators. Separator
+ is an every match of the given regex.
+ 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 Rx A regular expression
+ \param Flags Regex options
+ \return A reference to 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 CharT,
+ typename RegexTraitsT >
+ inline SequenceSequenceT& split_regex(
+ SequenceSequenceT& Result,
+ const RangeT& Input,
+ const basic_regex<CharT, RegexTraitsT>& Rx,
+ match_flag_type Flags=match_default )
+ {
+ return ::boost::algorithm::iter_split(
+ Result,
+ Input,
+ ::boost::algorithm::regex_finder(Rx,Flags) );
+ }
+
+// join_if ------------------------------------------------------------------//
+
+#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+
+ //! Conditional join algorithm
+ /*!
+ This algorithm joins all strings in a 'list' into one long string.
+ Segments are concatenated by given separator. Only segments that
+ match the given regular expression will be added to the result
+
+ This is a specialization of join_if algorithm.
+
+ \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 Rx A regular expression
+ \param Flags Regex options
+ \return Concatenated string.
+
+ \note This function provides the strong exception-safety guarantee
+ */
+ template<
+ typename SequenceSequenceT,
+ typename Range1T,
+ typename CharT,
+ typename RegexTraitsT >
+ inline typename range_value<SequenceSequenceT>::type
+ join_if(
+ const SequenceSequenceT& Input,
+ const Range1T& Separator,
+ const basic_regex<CharT, RegexTraitsT>& Rx,
+ match_flag_type Flags=match_default )
+ {
+ // 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 &&
+ !::boost::regex_match(::boost::begin(*itBegin), ::boost::end(*itBegin), Rx, Flags)) ++itBegin;
+
+ // Add this element
+ if(itBegin!=itEnd)
+ {
+ detail::insert(Result, ::boost::end(Result), *itBegin);
+ ++itBegin;
+ }
+
+ for(;itBegin!=itEnd; ++itBegin)
+ {
+ if(::boost::regex_match(::boost::begin(*itBegin), ::boost::end(*itBegin), Rx, Flags))
+ {
+ // Add separator
+ detail::insert(Result, ::boost::end(Result), ::boost::as_literal(Separator));
+ // Add element
+ detail::insert(Result, ::boost::end(Result), *itBegin);
+ }
+ }
+
+ return Result;
+ }
+
+#else // BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+
+ //! Conditional join algorithm
+ /*!
+ This algorithm joins all strings in a 'list' into one long string.
+ Segments are concatenated by given separator. Only segments that
+ match the given regular expression will be added to the result
+
+ This is a specialization of join_if algorithm.
+
+ \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 Rx A regular expression
+ \param Flags Regex options
+ \return Concatenated string.
+
+ \note This function provides the strong exception-safety guarantee
+ */
+ template<
+ typename SequenceSequenceT,
+ typename Range1T,
+ typename CharT,
+ typename RegexTraitsT >
+ inline typename range_value<SequenceSequenceT>::type
+ join_if_regex(
+ const SequenceSequenceT& Input,
+ const Range1T& Separator,
+ const basic_regex<CharT, RegexTraitsT>& Rx,
+ match_flag_type Flags=match_default )
+ {
+ // 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 &&
+ !::boost::regex_match(::boost::begin(*itBegin), ::boost::end(*itBegin), Rx, Flags)) ++itBegin;
+
+ // Add this element
+ if(itBegin!=itEnd)
+ {
+ detail::insert(Result, ::boost::end(Result), *itBegin);
+ ++itBegin;
+ }
+
+ for(;itBegin!=itEnd; ++itBegin)
+ {
+ if(::boost::regex_match(::boost::begin(*itBegin), ::boost::end(*itBegin), Rx, Flags))
+ {
+ // Add separator
+ detail::insert(Result, ::boost::end(Result), ::boost::as_literal(Separator));
+ // Add element
+ detail::insert(Result, ::boost::end(Result), *itBegin);
+ }
+ }
+
+ return Result;
+ }
+
+
+#endif // BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+
+ } // namespace algorithm
+
+ // pull names into the boost namespace
+ using algorithm::find_regex;
+ using algorithm::replace_regex;
+ using algorithm::replace_regex_copy;
+ using algorithm::replace_all_regex;
+ using algorithm::replace_all_regex_copy;
+ using algorithm::erase_regex;
+ using algorithm::erase_regex_copy;
+ using algorithm::erase_all_regex;
+ using algorithm::erase_all_regex_copy;
+ using algorithm::find_all_regex;
+ using algorithm::split_regex;
+
+#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+ using algorithm::join_if;
+#else // BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+ using algorithm::join_if_regex;
+#endif // BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+
+} // namespace boost
+
+
+#endif // BOOST_STRING_REGEX_HPP
diff --git a/Utilities/BGL/boost/algorithm/string/regex_find_format.hpp b/Utilities/BGL/boost/algorithm/string/regex_find_format.hpp
new file mode 100755
index 0000000000000000000000000000000000000000..9f861acdf5796f60856fb4cbbce48b6e48895583
--- /dev/null
+++ b/Utilities/BGL/boost/algorithm/string/regex_find_format.hpp
@@ -0,0 +1,90 @@
+// Boost string_algo library regex_find_format.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_REGEX_FIND_FORMAT_HPP
+#define BOOST_STRING_REGEX_FIND_FORMAT_HPP
+
+#include <boost/algorithm/string/config.hpp>
+#include <boost/regex.hpp>
+#include <boost/algorithm/string/detail/finder_regex.hpp>
+#include <boost/algorithm/string/detail/formatter_regex.hpp>
+
+/*! \file
+ Defines the \c regex_finder and \c regex_formatter generators. These two functors
+ are designed to work together. \c regex_formatter uses additional information
+ about a match contained in the regex_finder search result.
+*/
+
+namespace boost {
+ namespace algorithm {
+
+// regex_finder -----------------------------------------------//
+
+ //! "Regex" finder
+ /*!
+ Construct the \c regex_finder. Finder uses the regex engine to search
+ for a match.
+ Result is given in \c regex_search_result. This is an extension
+ of the iterator_range. In addition it containes match results
+ from the \c regex_search algorithm.
+
+ \param Rx A regular expression
+ \param MatchFlags Regex search options
+ \return An instance of the \c regex_finder object
+ */
+ template<
+ typename CharT,
+ typename RegexTraitsT>
+ inline detail::find_regexF< basic_regex<CharT, RegexTraitsT> >
+ regex_finder(
+ const basic_regex<CharT, RegexTraitsT>& Rx,
+ match_flag_type MatchFlags=match_default )
+ {
+ return detail::
+ find_regexF<
+ basic_regex<CharT, RegexTraitsT> >( Rx, MatchFlags );
+ }
+
+// regex_formater ---------------------------------------------//
+
+ //! Regex formatter
+ /*!
+ Construct the \c regex_formatter. Regex formatter uses the regex engine to
+ format a match found by the \c regex_finder.
+ This formatted it designed to closely cooperate with \c regex_finder.
+
+ \param Format Regex format definition
+ \param Flags Format flags
+ \return An instance of the \c regex_formatter functor
+ */
+ template<
+ typename CharT,
+ typename TraitsT, typename AllocT >
+ inline detail::regex_formatF< std::basic_string< CharT, TraitsT, AllocT > >
+ regex_formatter(
+ const std::basic_string<CharT, TraitsT, AllocT>& Format,
+ match_flag_type Flags=format_default )
+ {
+ return
+ detail::regex_formatF< std::basic_string<CharT, TraitsT, AllocT> >(
+ Format,
+ Flags );
+ }
+
+ } // namespace algorithm
+
+ // pull the names to the boost namespace
+ using algorithm::regex_finder;
+ using algorithm::regex_formatter;
+
+} // namespace boost
+
+
+#endif // BOOST_STRING_REGEX_FIND_FORMAT_HPP
diff --git a/Utilities/BGL/boost/algorithm/string/replace.hpp b/Utilities/BGL/boost/algorithm/string/replace.hpp
new file mode 100755
index 0000000000000000000000000000000000000000..71a73f3813262faa46e71b69289bc50d36d2087c
--- /dev/null
+++ b/Utilities/BGL/boost/algorithm/string/replace.hpp
@@ -0,0 +1,928 @@
+// Boost string_algo library replace.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_REPLACE_HPP
+#define BOOST_STRING_REPLACE_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/const_iterator.hpp>
+
+#include <boost/algorithm/string/find_format.hpp>
+#include <boost/algorithm/string/finder.hpp>
+#include <boost/algorithm/string/formatter.hpp>
+#include <boost/algorithm/string/compare.hpp>
+
+/*! \file
+ Defines various replace algorithms. Each algorithm replaces
+ part(s) of the input according to set of searching and replace criteria.
+*/
+
+namespace boost {
+ namespace algorithm {
+
+// replace_range --------------------------------------------------------------------//
+
+ //! Replace range algorithm
+ /*!
+ Replace the given range in the input string.
+ The result is a modified 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 string
+ \param SearchRange A range in the input to be substituted
+ \param Format A substitute string
+ \return An output iterator pointing just after the last inserted character or
+ a modified copy of the input
+
+ \note The second variant of this function provides the strong exception-safety guarantee
+ */
+ template<
+ typename OutputIteratorT,
+ typename Range1T,
+ typename Range2T>
+ inline OutputIteratorT replace_range_copy(
+ OutputIteratorT Output,
+ const Range1T& Input,
+ const iterator_range<
+ BOOST_STRING_TYPENAME
+ range_const_iterator<Range1T>::type>& SearchRange,
+ const Range2T& Format)
+ {
+ return ::boost::algorithm::find_format_copy(
+ Output,
+ Input,
+ ::boost::algorithm::range_finder(SearchRange),
+ ::boost::algorithm::const_formatter(Format));
+ }
+
+ //! Replace range algorithm
+ /*!
+ \overload
+ */
+ template<typename SequenceT, typename RangeT>
+ inline SequenceT replace_range_copy(
+ const SequenceT& Input,
+ const iterator_range<
+ BOOST_STRING_TYPENAME
+ range_const_iterator<SequenceT>::type>& SearchRange,
+ const RangeT& Format)
+ {
+ return ::boost::algorithm::find_format_copy(
+ Input,
+ ::boost::algorithm::range_finder(SearchRange),
+ ::boost::algorithm::const_formatter(Format));
+ }
+
+ //! Replace range algorithm
+ /*!
+ Replace the given range in the input string.
+ The input sequence is modified in-place.
+
+ \param Input An input string
+ \param SearchRange A range in the input to be substituted
+ \param Format A substitute string
+ */
+ template<typename SequenceT, typename RangeT>
+ inline void replace_range(
+ SequenceT& Input,
+ const iterator_range<
+ BOOST_STRING_TYPENAME
+ range_iterator<SequenceT>::type>& SearchRange,
+ const RangeT& Format)
+ {
+ ::boost::algorithm::find_format(
+ Input,
+ ::boost::algorithm::range_finder(SearchRange),
+ ::boost::algorithm::const_formatter(Format));
+ }
+
+// replace_first --------------------------------------------------------------------//
+
+ //! Replace first algorithm
+ /*!
+ Replace the first match of the search substring in the input
+ with the format string.
+ The result is a modified 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 string
+ \param Search A substring to be searched for
+ \param Format A substitute string
+ \return An output iterator pointing just after the last inserted character or
+ a modified copy of the input
+
+ \note The second variant of this function provides the strong exception-safety guarantee
+ */
+ template<
+ typename OutputIteratorT,
+ typename Range1T,
+ typename Range2T,
+ typename Range3T>
+ inline OutputIteratorT replace_first_copy(
+ OutputIteratorT Output,
+ const Range1T& Input,
+ const Range2T& Search,
+ const Range3T& Format)
+ {
+ return ::boost::algorithm::find_format_copy(
+ Output,
+ Input,
+ ::boost::algorithm::first_finder(Search),
+ ::boost::algorithm::const_formatter(Format) );
+ }
+
+ //! Replace first algorithm
+ /*!
+ \overload
+ */
+ template<typename SequenceT, typename Range1T, typename Range2T>
+ inline SequenceT replace_first_copy(
+ const SequenceT& Input,
+ const Range1T& Search,
+ const Range2T& Format )
+ {
+ return ::boost::algorithm::find_format_copy(
+ Input,
+ ::boost::algorithm::first_finder(Search),
+ ::boost::algorithm::const_formatter(Format) );
+ }
+
+ //! Replace first algorithm
+ /*!
+ replace the first match of the search substring in the input
+ with the format string. The input sequence is modified in-place.
+
+ \param Input An input string
+ \param Search A substring to be searched for
+ \param Format A substitute string
+ */
+ template<typename SequenceT, typename Range1T, typename Range2T>
+ inline void replace_first(
+ SequenceT& Input,
+ const Range1T& Search,
+ const Range2T& Format )
+ {
+ ::boost::algorithm::find_format(
+ Input,
+ ::boost::algorithm::first_finder(Search),
+ ::boost::algorithm::const_formatter(Format) );
+ }
+
+// replace_first ( case insensitive ) ---------------------------------------------//
+
+ //! Replace first algorithm ( case insensitive )
+ /*!
+ Replace the first match of the search substring in the input
+ with the format string.
+ The result is a modified copy of the input. It is returned as a sequence
+ or copied to the output iterator.
+ Searching is case insensitive.
+
+ \param Output An output iterator to which the result will be copied
+ \param Input An input string
+ \param Search A substring to be searched for
+ \param Format A substitute string
+ \param Loc A locale used for case insensitive comparison
+ \return An output iterator pointing just after the last inserted character or
+ a modified copy of the input
+
+ \note The second variant of this function provides the strong exception-safety guarantee
+ */
+ template<
+ typename OutputIteratorT,
+ typename Range1T,
+ typename Range2T,
+ typename Range3T>
+ inline OutputIteratorT ireplace_first_copy(
+ OutputIteratorT Output,
+ const Range1T& Input,
+ const Range2T& Search,
+ const Range3T& Format,
+ const std::locale& Loc=std::locale() )
+ {
+ return ::boost::algorithm::find_format_copy(
+ Output,
+ Input,
+ ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
+ ::boost::algorithm::const_formatter(Format) );
+ }
+
+ //! Replace first algorithm ( case insensitive )
+ /*!
+ \overload
+ */
+ template<typename SequenceT, typename Range2T, typename Range1T>
+ inline SequenceT ireplace_first_copy(
+ const SequenceT& Input,
+ const Range2T& Search,
+ const Range1T& Format,
+ const std::locale& Loc=std::locale() )
+ {
+ return ::boost::algorithm::find_format_copy(
+ Input,
+ ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
+ ::boost::algorithm::const_formatter(Format) );
+ }
+
+ //! Replace first algorithm ( case insensitive )
+ /*!
+ Replace the first match of the search substring in the input
+ with the format string. Input sequence is modified in-place.
+ Searching is case insensitive.
+
+ \param Input An input string
+ \param Search A substring to be searched for
+ \param Format A substitute string
+ \param Loc A locale used for case insensitive comparison
+ */
+ template<typename SequenceT, typename Range1T, typename Range2T>
+ inline void ireplace_first(
+ SequenceT& Input,
+ const Range1T& Search,
+ const Range2T& Format,
+ const std::locale& Loc=std::locale() )
+ {
+ ::boost::algorithm::find_format(
+ Input,
+ ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
+ ::boost::algorithm::const_formatter(Format) );
+ }
+
+// replace_last --------------------------------------------------------------------//
+
+ //! Replace last algorithm
+ /*!
+ Replace the last match of the search string in the input
+ with the format string.
+ The result is a modified 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 string
+ \param Search A substring to be searched for
+ \param Format A substitute string
+ \return An output iterator pointing just after the last inserted character or
+ a modified copy of the input
+
+ \note The second variant of this function provides the strong exception-safety guarantee
+ */
+ template<
+ typename OutputIteratorT,
+ typename Range1T,
+ typename Range2T,
+ typename Range3T>
+ inline OutputIteratorT replace_last_copy(
+ OutputIteratorT Output,
+ const Range1T& Input,
+ const Range2T& Search,
+ const Range3T& Format )
+ {
+ return ::boost::algorithm::find_format_copy(
+ Output,
+ Input,
+ ::boost::algorithm::last_finder(Search),
+ ::boost::algorithm::const_formatter(Format) );
+ }
+
+ //! Replace last algorithm
+ /*!
+ \overload
+ */
+ template<typename SequenceT, typename Range1T, typename Range2T>
+ inline SequenceT replace_last_copy(
+ const SequenceT& Input,
+ const Range1T& Search,
+ const Range2T& Format )
+ {
+ return ::boost::algorithm::find_format_copy(
+ Input,
+ ::boost::algorithm::last_finder(Search),
+ ::boost::algorithm::const_formatter(Format) );
+ }
+
+ //! Replace last algorithm
+ /*!
+ Replace the last match of the search string in the input
+ with the format string. Input sequence is modified in-place.
+
+ \param Input An input string
+ \param Search A substring to be searched for
+ \param Format A substitute string
+ */
+ template<typename SequenceT, typename Range1T, typename Range2T>
+ inline void replace_last(
+ SequenceT& Input,
+ const Range1T& Search,
+ const Range2T& Format )
+ {
+ ::boost::algorithm::find_format(
+ Input,
+ ::boost::algorithm::last_finder(Search),
+ ::boost::algorithm::const_formatter(Format) );
+ }
+
+// replace_last ( case insensitive ) -----------------------------------------------//
+
+ //! Replace last algorithm ( case insensitive )
+ /*!
+ Replace the last match of the search string in the input
+ with the format string.
+ The result is a modified copy of the input. It is returned as a sequence
+ or copied to the output iterator.
+ Searching is case insensitive.
+
+ \param Output An output iterator to which the result will be copied
+ \param Input An input string
+ \param Search A substring to be searched for
+ \param Format A substitute string
+ \param Loc A locale used for case insensitive comparison
+ \return An output iterator pointing just after the last inserted character or
+ a modified copy of the input
+
+ \note The second variant of this function provides the strong exception-safety guarantee
+ */
+ template<
+ typename OutputIteratorT,
+ typename Range1T,
+ typename Range2T,
+ typename Range3T>
+ inline OutputIteratorT ireplace_last_copy(
+ OutputIteratorT Output,
+ const Range1T& Input,
+ const Range2T& Search,
+ const Range3T& Format,
+ const std::locale& Loc=std::locale() )
+ {
+ return ::boost::algorithm::find_format_copy(
+ Output,
+ Input,
+ ::boost::algorithm::last_finder(Search, is_iequal(Loc)),
+ ::boost::algorithm::const_formatter(Format) );
+ }
+
+ //! Replace last algorithm ( case insensitive )
+ /*!
+ \overload
+ */
+ template<typename SequenceT, typename Range1T, typename Range2T>
+ inline SequenceT ireplace_last_copy(
+ const SequenceT& Input,
+ const Range1T& Search,
+ const Range2T& Format,
+ const std::locale& Loc=std::locale() )
+ {
+ return ::boost::algorithm::find_format_copy(
+ Input,
+ ::boost::algorithm::last_finder(Search, is_iequal(Loc)),
+ ::boost::algorithm::const_formatter(Format) );
+ }
+
+ //! Replace last algorithm ( case insensitive )
+ /*!
+ Replace the last match of the search string in the input
+ with the format string.The input sequence is modified in-place.
+ Searching is case insensitive.
+
+ \param Input An input string
+ \param Search A substring to be searched for
+ \param Format A substitute string
+ \param Loc A locale used for case insensitive comparison
+ \return A reference to the modified input
+ */
+ template<typename SequenceT, typename Range1T, typename Range2T>
+ inline void ireplace_last(
+ SequenceT& Input,
+ const Range1T& Search,
+ const Range2T& Format,
+ const std::locale& Loc=std::locale() )
+ {
+ ::boost::algorithm::find_format(
+ Input,
+ ::boost::algorithm::last_finder(Search, is_iequal(Loc)),
+ ::boost::algorithm::const_formatter(Format) );
+ }
+
+// replace_nth --------------------------------------------------------------------//
+
+ //! Replace nth algorithm
+ /*!
+ Replace an Nth (zero-indexed) match of the search string in the input
+ with the format string.
+ The result is a modified 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 string
+ \param Search A substring to be searched for
+ \param Nth An index of the match to be replaced. The index is 0-based.
+ For negative N, matches are counted from the end of string.
+ \param Format A substitute string
+ \return An output iterator pointing just after the last inserted character or
+ a modified copy of the input
+
+ \note The second variant of this function provides the strong exception-safety guarantee
+ */
+ template<
+ typename OutputIteratorT,
+ typename Range1T,
+ typename Range2T,
+ typename Range3T>
+ inline OutputIteratorT replace_nth_copy(
+ OutputIteratorT Output,
+ const Range1T& Input,
+ const Range2T& Search,
+ int Nth,
+ const Range3T& Format )
+ {
+ return ::boost::algorithm::find_format_copy(
+ Output,
+ Input,
+ ::boost::algorithm::nth_finder(Search, Nth),
+ ::boost::algorithm::const_formatter(Format) );
+ }
+
+ //! Replace nth algorithm
+ /*!
+ \overload
+ */
+ template<typename SequenceT, typename Range1T, typename Range2T>
+ inline SequenceT replace_nth_copy(
+ const SequenceT& Input,
+ const Range1T& Search,
+ int Nth,
+ const Range2T& Format )
+ {
+ return ::boost::algorithm::find_format_copy(
+ Input,
+ ::boost::algorithm::nth_finder(Search, Nth),
+ ::boost::algorithm::const_formatter(Format) );
+ }
+
+ //! Replace nth algorithm
+ /*!
+ Replace an Nth (zero-indexed) match of the search string in the input
+ with the format string. Input sequence is modified in-place.
+
+ \param Input An input string
+ \param Search A substring to be searched for
+ \param Nth An index of the match to be replaced. The index is 0-based.
+ For negative N, matches are counted from the end of string.
+ \param Format A substitute string
+ */
+ template<typename SequenceT, typename Range1T, typename Range2T>
+ inline void replace_nth(
+ SequenceT& Input,
+ const Range1T& Search,
+ int Nth,
+ const Range2T& Format )
+ {
+ ::boost::algorithm::find_format(
+ Input,
+ ::boost::algorithm::nth_finder(Search, Nth),
+ ::boost::algorithm::const_formatter(Format) );
+ }
+
+// replace_nth ( case insensitive ) -----------------------------------------------//
+
+ //! Replace nth algorithm ( case insensitive )
+ /*!
+ Replace an Nth (zero-indexed) match of the search string in the input
+ with the format string.
+ The result is a modified copy of the input. It is returned as a sequence
+ or copied to the output iterator.
+ Searching is case insensitive.
+
+ \param Output An output iterator to which the result will be copied
+ \param Input An input string
+ \param Search A substring to be searched for
+ \param Nth An index of the match to be replaced. The index is 0-based.
+ For negative N, matches are counted from the end of string.
+ \param Format A substitute string
+ \param Loc A locale used for case insensitive comparison
+ \return An output iterator pointing just after the last inserted character or
+ a modified copy of the input
+
+ \note The second variant of this function provides the strong exception-safety guarantee
+ */
+ template<
+ typename OutputIteratorT,
+ typename Range1T,
+ typename Range2T,
+ typename Range3T>
+ inline OutputIteratorT ireplace_nth_copy(
+ OutputIteratorT Output,
+ const Range1T& Input,
+ const Range2T& Search,
+ int Nth,
+ const Range3T& Format,
+ const std::locale& Loc=std::locale() )
+ {
+ return ::boost::algorithm::find_format_copy(
+ Output,
+ Input,
+ ::boost::algorithm::nth_finder(Search, Nth, is_iequal(Loc) ),
+ ::boost::algorithm::const_formatter(Format) );
+ }
+
+ //! Replace nth algorithm ( case insensitive )
+ /*!
+ \overload
+ */
+ template<typename SequenceT, typename Range1T, typename Range2T>
+ inline SequenceT ireplace_nth_copy(
+ const SequenceT& Input,
+ const Range1T& Search,
+ int Nth,
+ const Range2T& Format,
+ const std::locale& Loc=std::locale() )
+ {
+ return ::boost::algorithm::find_format_copy(
+ Input,
+ ::boost::algorithm::nth_finder(Search, Nth, is_iequal(Loc)),
+ ::boost::algorithm::const_formatter(Format) );
+ }
+
+ //! Replace nth algorithm ( case insensitive )
+ /*!
+ Replace an Nth (zero-indexed) match of the search string in the input
+ with the format string. Input sequence is modified in-place.
+ Searching is case insensitive.
+
+ \param Input An input string
+ \param Search A substring to be searched for
+ \param Nth An index of the match to be replaced. The index is 0-based.
+ For negative N, matches are counted from the end of string.
+ \param Format A substitute string
+ \param Loc A locale used for case insensitive comparison
+ */
+ template<typename SequenceT, typename Range1T, typename Range2T>
+ inline void ireplace_nth(
+ SequenceT& Input,
+ const Range1T& Search,
+ int Nth,
+ const Range2T& Format,
+ const std::locale& Loc=std::locale() )
+ {
+ ::boost::algorithm::find_format(
+ Input,
+ ::boost::algorithm::nth_finder(Search, Nth, is_iequal(Loc)),
+ ::boost::algorithm::const_formatter(Format) );
+ }
+
+// replace_all --------------------------------------------------------------------//
+
+ //! Replace all algorithm
+ /*!
+ Replace all occurrences of the search string in the input
+ with the format string.
+ The result is a modified 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 string
+ \param Search A substring to be searched for
+ \param Format A substitute string
+ \return An output iterator pointing just after the last inserted character or
+ a modified copy of the input
+
+ \note The second variant of this function provides the strong exception-safety guarantee
+ */
+ template<
+ typename OutputIteratorT,
+ typename Range1T,
+ typename Range2T,
+ typename Range3T>
+ inline OutputIteratorT replace_all_copy(
+ OutputIteratorT Output,
+ const Range1T& Input,
+ const Range2T& Search,
+ const Range3T& Format )
+ {
+ return ::boost::algorithm::find_format_all_copy(
+ Output,
+ Input,
+ ::boost::algorithm::first_finder(Search),
+ ::boost::algorithm::const_formatter(Format) );
+ }
+
+ //! Replace all algorithm
+ /*!
+ \overload
+ */
+ template<typename SequenceT, typename Range1T, typename Range2T>
+ inline SequenceT replace_all_copy(
+ const SequenceT& Input,
+ const Range1T& Search,
+ const Range2T& Format )
+ {
+ return ::boost::algorithm::find_format_all_copy(
+ Input,
+ ::boost::algorithm::first_finder(Search),
+ ::boost::algorithm::const_formatter(Format) );
+ }
+
+ //! Replace all algorithm
+ /*!
+ Replace all occurrences of the search string in the input
+ with the format string. The input sequence is modified in-place.
+
+ \param Input An input string
+ \param Search A substring to be searched for
+ \param Format A substitute string
+ \return A reference to the modified input
+ */
+ template<typename SequenceT, typename Range1T, typename Range2T>
+ inline void replace_all(
+ SequenceT& Input,
+ const Range1T& Search,
+ const Range2T& Format )
+ {
+ ::boost::algorithm::find_format_all(
+ Input,
+ ::boost::algorithm::first_finder(Search),
+ ::boost::algorithm::const_formatter(Format) );
+ }
+
+// replace_all ( case insensitive ) -----------------------------------------------//
+
+ //! Replace all algorithm ( case insensitive )
+ /*!
+ Replace all occurrences of the search string in the input
+ with the format string.
+ The result is a modified copy of the input. It is returned as a sequence
+ or copied to the output iterator.
+ Searching is case insensitive.
+
+ \param Output An output iterator to which the result will be copied
+ \param Input An input string
+ \param Search A substring to be searched for
+ \param Format A substitute string
+ \param Loc A locale used for case insensitive comparison
+ \return An output iterator pointing just after the last inserted character or
+ a modified copy of the input
+
+ \note The second variant of this function provides the strong exception-safety guarantee
+ */
+ template<
+ typename OutputIteratorT,
+ typename Range1T,
+ typename Range2T,
+ typename Range3T>
+ inline OutputIteratorT ireplace_all_copy(
+ OutputIteratorT Output,
+ const Range1T& Input,
+ const Range2T& Search,
+ const Range3T& Format,
+ const std::locale& Loc=std::locale() )
+ {
+ return ::boost::algorithm::find_format_all_copy(
+ Output,
+ Input,
+ ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
+ ::boost::algorithm::const_formatter(Format) );
+ }
+
+ //! Replace all algorithm ( case insensitive )
+ /*!
+ \overload
+ */
+ template<typename SequenceT, typename Range1T, typename Range2T>
+ inline SequenceT ireplace_all_copy(
+ const SequenceT& Input,
+ const Range1T& Search,
+ const Range2T& Format,
+ const std::locale& Loc=std::locale() )
+ {
+ return ::boost::algorithm::find_format_all_copy(
+ Input,
+ ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
+ ::boost::algorithm::const_formatter(Format) );
+ }
+
+ //! Replace all algorithm ( case insensitive )
+ /*!
+ Replace all occurrences of the search string in the input
+ with the format string.The input sequence is modified in-place.
+ Searching is case insensitive.
+
+ \param Input An input string
+ \param Search A substring to be searched for
+ \param Format A substitute string
+ \param Loc A locale used for case insensitive comparison
+ */
+ template<typename SequenceT, typename Range1T, typename Range2T>
+ inline void ireplace_all(
+ SequenceT& Input,
+ const Range1T& Search,
+ const Range2T& Format,
+ const std::locale& Loc=std::locale() )
+ {
+ ::boost::algorithm::find_format_all(
+ Input,
+ ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
+ ::boost::algorithm::const_formatter(Format) );
+ }
+
+// replace_head --------------------------------------------------------------------//
+
+ //! Replace head algorithm
+ /*!
+ Replace the head of the input with the given format string.
+ The head is a prefix of a string of given size.
+ If the sequence is shorter then required, whole string if
+ considered to be the head.
+ The result is a modified 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 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.
+ \param Format A substitute string
+ \return An output iterator pointing just after the last inserted character or
+ a modified copy of the input
+
+ \note The second variant of this function provides the strong exception-safety guarantee
+ */
+ template<
+ typename OutputIteratorT,
+ typename Range1T,
+ typename Range2T>
+ inline OutputIteratorT replace_head_copy(
+ OutputIteratorT Output,
+ const Range1T& Input,
+ int N,
+ const Range2T& Format )
+ {
+ return ::boost::algorithm::find_format_copy(
+ Output,
+ Input,
+ ::boost::algorithm::head_finder(N),
+ ::boost::algorithm::const_formatter(Format) );
+ }
+
+ //! Replace head algorithm
+ /*!
+ \overload
+ */
+ template<typename SequenceT, typename RangeT>
+ inline SequenceT replace_head_copy(
+ const SequenceT& Input,
+ int N,
+ const RangeT& Format )
+ {
+ return ::boost::algorithm::find_format_copy(
+ Input,
+ ::boost::algorithm::head_finder(N),
+ ::boost::algorithm::const_formatter(Format) );
+ }
+
+ //! Replace head algorithm
+ /*!
+ Replace the head of the input with the given format string.
+ The head is a prefix of a string of given size.
+ If the sequence is shorter then required, the whole string is
+ considered to be the head. The input sequence is modified in-place.
+
+ \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.
+ \param Format A substitute string
+ */
+ template<typename SequenceT, typename RangeT>
+ inline void replace_head(
+ SequenceT& Input,
+ int N,
+ const RangeT& Format )
+ {
+ ::boost::algorithm::find_format(
+ Input,
+ ::boost::algorithm::head_finder(N),
+ ::boost::algorithm::const_formatter(Format) );
+ }
+
+// replace_tail --------------------------------------------------------------------//
+
+ //! Replace tail algorithm
+ /*!
+ Replace the tail of the input with the given format string.
+ The tail is a suffix of a string of given size.
+ If the sequence is shorter then required, whole string is
+ considered to be the tail.
+ The result is a modified 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 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.
+ \param Format A substitute string
+ \return An output iterator pointing just after the last inserted character or
+ a modified copy of the input
+
+ \note The second variant of this function provides the strong exception-safety guarantee
+ */
+ template<
+ typename OutputIteratorT,
+ typename Range1T,
+ typename Range2T>
+ inline OutputIteratorT replace_tail_copy(
+ OutputIteratorT Output,
+ const Range1T& Input,
+ int N,
+ const Range2T& Format )
+ {
+ return ::boost::algorithm::find_format_copy(
+ Output,
+ Input,
+ ::boost::algorithm::tail_finder(N),
+ ::boost::algorithm::const_formatter(Format) );
+ }
+
+ //! Replace tail algorithm
+ /*!
+ \overload
+ */
+ template<typename SequenceT, typename RangeT>
+ inline SequenceT replace_tail_copy(
+ const SequenceT& Input,
+ int N,
+ const RangeT& Format )
+ {
+ return ::boost::algorithm::find_format_copy(
+ Input,
+ ::boost::algorithm::tail_finder(N),
+ ::boost::algorithm::const_formatter(Format) );
+ }
+
+ //! Replace tail algorithm
+ /*!
+ Replace the tail of the input with the given format sequence.
+ The tail is a suffix of a string of given size.
+ If the sequence is shorter then required, the whole string is
+ considered to be the tail. The input sequence is modified in-place.
+
+ \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.
+ \param Format A substitute string
+ */
+ template<typename SequenceT, typename RangeT>
+ inline void replace_tail(
+ SequenceT& Input,
+ int N,
+ const RangeT& Format )
+ {
+ ::boost::algorithm::find_format(
+ Input,
+ ::boost::algorithm::tail_finder(N),
+ ::boost::algorithm::const_formatter(Format) );
+ }
+
+ } // namespace algorithm
+
+ // pull names to the boost namespace
+ using algorithm::replace_range_copy;
+ using algorithm::replace_range;
+ using algorithm::replace_first_copy;
+ using algorithm::replace_first;
+ using algorithm::ireplace_first_copy;
+ using algorithm::ireplace_first;
+ using algorithm::replace_last_copy;
+ using algorithm::replace_last;
+ using algorithm::ireplace_last_copy;
+ using algorithm::ireplace_last;
+ using algorithm::replace_nth_copy;
+ using algorithm::replace_nth;
+ using algorithm::ireplace_nth_copy;
+ using algorithm::ireplace_nth;
+ using algorithm::replace_all_copy;
+ using algorithm::replace_all;
+ using algorithm::ireplace_all_copy;
+ using algorithm::ireplace_all;
+ using algorithm::replace_head_copy;
+ using algorithm::replace_head;
+ using algorithm::replace_tail_copy;
+ using algorithm::replace_tail;
+
+} // namespace boost
+
+#endif // BOOST_REPLACE_HPP
diff --git a/Utilities/BGL/boost/algorithm/string/sequence_traits.hpp b/Utilities/BGL/boost/algorithm/string/sequence_traits.hpp
new file mode 100755
index 0000000000000000000000000000000000000000..f9f4a9c74230f4baac6985fdbe8c7db065b90738
--- /dev/null
+++ b/Utilities/BGL/boost/algorithm/string/sequence_traits.hpp
@@ -0,0 +1,193 @@
+// Boost string_algo library sequence_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_SEQUENCE_TRAITS_HPP
+#define BOOST_STRING_SEQUENCE_TRAITS_HPP
+
+#include <boost/config.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/algorithm/string/yes_no_type.hpp>
+
+/*! \file
+ Traits defined in this header are used by various algorithms to achieve
+ better performance for specific containers.
+ Traits provide fail-safe defaults. If a container supports some of these
+ features, it is possible to specialize the specific trait for this container.
+ For lacking compilers, it is possible of define an override for a specific tester
+ function.
+
+ Due to a language restriction, it is not currently possible to define specializations for
+ stl containers without including the corresponding header. To decrease the overhead
+ needed by this inclusion, user can selectively include a specialization
+ header for a specific container. They are located in boost/algorithm/string/stl
+ directory. Alternatively she can include boost/algorithm/string/std_collection_traits.hpp
+ header which contains specializations for all stl containers.
+*/
+
+namespace boost {
+ namespace algorithm {
+
+// sequence traits -----------------------------------------------//
+
+#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+
+ //! Native replace tester
+ /*!
+ Declare an override of this tester function with return
+ type boost::string_algo::yes_type for a sequence with this property.
+
+ \return yes_type if the container has basic_string like native replace
+ method.
+ */
+ no_type has_native_replace_tester(...);
+
+ //! Stable iterators tester
+ /*!
+ Declare an override of this tester function with return
+ type boost::string_algo::yes_type for a sequence with this property.
+
+ \return yes_type if the sequence's insert/replace/erase methods do not invalidate
+ existing iterators.
+ */
+ no_type has_stable_iterators_tester(...);
+
+ //! const time insert tester
+ /*!
+ Declare an override of this tester function with return
+ type boost::string_algo::yes_type for a sequence with this property.
+
+ \return yes_type if the sequence's insert method is working in constant time
+ */
+ no_type has_const_time_insert_tester(...);
+
+ //! const time erase tester
+ /*!
+ Declare an override of this tester function with return
+ type boost::string_algo::yes_type for a sequence with this property.
+
+ \return yes_type if the sequence's erase method is working in constant time
+ */
+ no_type has_const_time_erase_tester(...);
+
+#endif //BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+
+ //! Native replace trait
+ /*!
+ This trait specifies that the sequence has \c std::string like replace method
+ */
+ template< typename T >
+ class has_native_replace
+ {
+
+#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+ private:
+ static T* t;
+ public:
+ BOOST_STATIC_CONSTANT(bool, value=(
+ sizeof(has_native_replace_tester(t))==sizeof(yes_type) ) );
+#else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+ public:
+# if BOOST_WORKAROUND( __IBMCPP__, <= 600 )
+ enum { value = false };
+# else
+ BOOST_STATIC_CONSTANT(bool, value=false);
+# endif // BOOST_WORKAROUND( __IBMCPP__, <= 600 )
+#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+
+
+ typedef mpl::bool_<has_native_replace<T>::value> type;
+ };
+
+
+ //! Stable iterators trait
+ /*!
+ This trait specifies that the sequence has stable iterators. It means
+ that operations like insert/erase/replace do not invalidate iterators.
+ */
+ template< typename T >
+ class has_stable_iterators
+ {
+#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+ private:
+ static T* t;
+ public:
+ BOOST_STATIC_CONSTANT(bool, value=(
+ sizeof(has_stable_iterators_tester(t))==sizeof(yes_type) ) );
+#else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+ public:
+# if BOOST_WORKAROUND( __IBMCPP__, <= 600 )
+ enum { value = false };
+# else
+ BOOST_STATIC_CONSTANT(bool, value=false);
+# endif // BOOST_WORKAROUND( __IBMCPP__, <= 600 )
+#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+
+ typedef mpl::bool_<has_stable_iterators<T>::value> type;
+ };
+
+
+ //! Const time insert trait
+ /*!
+ This trait specifies that the sequence's insert method has
+ constant time complexity.
+ */
+ template< typename T >
+ class has_const_time_insert
+ {
+#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+ private:
+ static T* t;
+ public:
+ BOOST_STATIC_CONSTANT(bool, value=(
+ sizeof(has_const_time_insert_tester(t))==sizeof(yes_type) ) );
+#else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+ public:
+# if BOOST_WORKAROUND( __IBMCPP__, <= 600 )
+ enum { value = false };
+# else
+ BOOST_STATIC_CONSTANT(bool, value=false);
+# endif // BOOST_WORKAROUND( __IBMCPP__, <= 600 )
+#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+
+ typedef mpl::bool_<has_const_time_insert<T>::value> type;
+ };
+
+
+ //! Const time erase trait
+ /*!
+ This trait specifies that the sequence's erase method has
+ constant time complexity.
+ */
+ template< typename T >
+ class has_const_time_erase
+ {
+#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+ private:
+ static T* t;
+ public:
+ BOOST_STATIC_CONSTANT(bool, value=(
+ sizeof(has_const_time_erase_tester(t))==sizeof(yes_type) ) );
+#else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+ public:
+# if BOOST_WORKAROUND( __IBMCPP__, <= 600 )
+ enum { value = false };
+# else
+ BOOST_STATIC_CONSTANT(bool, value=false);
+# endif // BOOST_WORKAROUND( __IBMCPP__, <= 600 )
+#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+
+ typedef mpl::bool_<has_const_time_erase<T>::value> type;
+ };
+
+ } // namespace algorithm
+} // namespace boost
+
+
+#endif // BOOST_STRING_SEQUENCE_TRAITS_HPP
diff --git a/Utilities/BGL/boost/algorithm/string/split.hpp b/Utilities/BGL/boost/algorithm/string/split.hpp
new file mode 100755
index 0000000000000000000000000000000000000000..21e86c7a03d4051c9ada0aa23bb4deebc489ac55
--- /dev/null
+++ b/Utilities/BGL/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/Utilities/BGL/boost/algorithm/string/std/list_traits.hpp b/Utilities/BGL/boost/algorithm/string/std/list_traits.hpp
new file mode 100755
index 0000000000000000000000000000000000000000..3f25f6374a1d3b20cc886375d32bd649c48dfcb3
--- /dev/null
+++ b/Utilities/BGL/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/Utilities/BGL/boost/algorithm/string/std/rope_traits.hpp b/Utilities/BGL/boost/algorithm/string/std/rope_traits.hpp
new file mode 100755
index 0000000000000000000000000000000000000000..e9ae03a94ce2f643606de1508aa7a1a75423e2a4
--- /dev/null
+++ b/Utilities/BGL/boost/algorithm/string/std/rope_traits.hpp
@@ -0,0 +1,101 @@
+// 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_ROPE_TRAITS_HPP
+#define BOOST_STRING_STD_ROPE_TRAITS_HPP
+
+#include <boost/algorithm/string/yes_no_type.hpp>
+#include <rope>
+#include <boost/algorithm/string/sequence_traits.hpp>
+
+namespace boost {
+ namespace algorithm {
+
+// SGI's std::rope<> 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::rope<T, TraitsT, AllocT>* );
+
+ // stable iterators tester
+ template<typename T, typename TraitsT, typename AllocT>
+ yes_type has_stable_iterators_tester( const std::rope<T, TraitsT, AllocT>* );
+
+ // const time insert tester
+ template<typename T, typename TraitsT, typename AllocT>
+ yes_type has_const_time_insert_tester( const std::rope<T, TraitsT, AllocT>* );
+
+ // const time erase tester
+ template<typename T, typename TraitsT, typename AllocT>
+ yes_type has_const_time_erase_tester( const std::rope<T, TraitsT, AllocT>* );
+
+#else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+
+ // native replace trait
+ template<typename T, typename TraitsT, typename AllocT>
+ class has_native_replace< std::rope<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_<value> type;
+ };
+
+ // stable iterators trait
+ template<typename T, typename TraitsT, typename AllocT>
+ class has_stable_iterators< std::rope<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_<value> type;
+ };
+
+ // const time insert trait
+ template<typename T, typename TraitsT, typename AllocT>
+ class has_const_time_insert< std::rope<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_<value> type;
+ };
+
+ // const time erase trait
+ template<typename T, typename TraitsT, typename AllocT>
+ class has_const_time_erase< std::rope<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_<value> type;
+ };
+#endif
+
+
+ } // namespace algorithm
+} // namespace boost
+
+
+#endif // BOOST_STRING_ROPE_TRAITS_HPP
diff --git a/Utilities/BGL/boost/algorithm/string/std/slist_traits.hpp b/Utilities/BGL/boost/algorithm/string/std/slist_traits.hpp
new file mode 100755
index 0000000000000000000000000000000000000000..c3cfe64e6603afd36ec4695f0a4c42a53e4539e5
--- /dev/null
+++ b/Utilities/BGL/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/Utilities/BGL/boost/algorithm/string/std/string_traits.hpp b/Utilities/BGL/boost/algorithm/string/std/string_traits.hpp
new file mode 100755
index 0000000000000000000000000000000000000000..e67a49a0ad1881e3a5c30194c1ee1c67c4d2040f
--- /dev/null
+++ b/Utilities/BGL/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/Utilities/BGL/boost/algorithm/string/std_containers_traits.hpp b/Utilities/BGL/boost/algorithm/string/std_containers_traits.hpp
new file mode 100755
index 0000000000000000000000000000000000000000..28dddc75191cec655b1c0084651ac66a609b84e8
--- /dev/null
+++ b/Utilities/BGL/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/Utilities/BGL/boost/algorithm/string/trim.hpp b/Utilities/BGL/boost/algorithm/string/trim.hpp
new file mode 100755
index 0000000000000000000000000000000000000000..693804ae923acbb7d6a0658ac238cc2a391f5e7d
--- /dev/null
+++ b/Utilities/BGL/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/Utilities/BGL/boost/algorithm/string/yes_no_type.hpp b/Utilities/BGL/boost/algorithm/string/yes_no_type.hpp
new file mode 100755
index 0000000000000000000000000000000000000000..4109763c1fc51bf3ec2f1c9ae06d7de4b46616b8
--- /dev/null
+++ b/Utilities/BGL/boost/algorithm/string/yes_no_type.hpp
@@ -0,0 +1,33 @@
+// Boost string_algo library yes_no_type.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_YES_NO_TYPE_DETAIL_HPP
+#define BOOST_STRING_YES_NO_TYPE_DETAIL_HPP
+
+namespace boost {
+ namespace algorithm {
+
+ // taken from boost mailing-list
+ // when yes_no_type will become officially
+ // a part of boost distribution, this header
+ // will be deprecated
+ template<int I> struct size_descriptor
+ {
+ typedef char (& type)[I];
+ };
+
+ typedef size_descriptor<1>::type yes_type;
+ typedef size_descriptor<2>::type no_type;
+
+ } // namespace algorithm
+} // namespace boost
+
+
+#endif // BOOST_STRING_YES_NO_TYPE_DETAIL_HPP
diff --git a/Utilities/BGL/boost/algorithm/string_regex.hpp b/Utilities/BGL/boost/algorithm/string_regex.hpp
new file mode 100755
index 0000000000000000000000000000000000000000..a77d04f026a0fb82983986327e1efa6039e378d1
--- /dev/null
+++ b/Utilities/BGL/boost/algorithm/string_regex.hpp
@@ -0,0 +1,23 @@
+// Boost string_algo library string_regex.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_REGEX_HPP
+#define BOOST_STRING_ALGO_REGEX_HPP
+
+/*! \file
+ Cumulative include for string_algo library.
+ In addtion to string.hpp contains also regex-related stuff.
+*/
+
+#include <boost/regex.hpp>
+#include <boost/algorithm/string.hpp>
+#include <boost/algorithm/string/regex.hpp>
+
+#endif // BOOST_STRING_ALGO_REGEX_HPP
diff --git a/Utilities/BGL/boost/tokenizer.hpp b/Utilities/BGL/boost/tokenizer.hpp
new file mode 100755
index 0000000000000000000000000000000000000000..5164b2a9fb025e61cdd27daa87990e3c136d637e
--- /dev/null
+++ b/Utilities/BGL/boost/tokenizer.hpp
@@ -0,0 +1,98 @@
+// Boost tokenizer.hpp -----------------------------------------------------//
+
+// (c) Copyright Jeremy Siek and John R. Bandela 2001.
+
+// 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/libs/tokenizer for documenation
+
+// Revision History:
+// 03 Jul 2003 John Bandela
+// Converted to new iterator adapter
+// 02 Feb 2002 Jeremy Siek
+// Removed tabs and a little cleanup.
+
+#ifndef BOOST_TOKENIZER_JRB070303_HPP_
+#define BOOST_TOKENIZER_JRB070303_HPP_
+
+#include <boost/token_iterator.hpp>
+
+namespace boost {
+
+
+ //===========================================================================
+ // A container-view of a tokenized "sequence"
+ template <
+ typename TokenizerFunc = char_delimiters_separator<char>,
+ typename Iterator = std::string::const_iterator,
+ typename Type = std::string
+ >
+ class tokenizer {
+ private:
+ typedef token_iterator_generator<TokenizerFunc,Iterator,Type> TGen;
+
+ // It seems that MSVC does not like the unqualified use of iterator,
+ // Thus we use iter internally when it is used unqualified and
+ // the users of this class will always qualify iterator.
+ typedef typename TGen::type iter;
+
+ public:
+
+ typedef iter iterator;
+ typedef iter const_iterator;
+ typedef Type value_type;
+ typedef value_type& reference;
+ typedef const value_type& const_reference;
+ typedef value_type* pointer;
+ typedef const pointer const_pointer;
+ typedef void size_type;
+ typedef void difference_type;
+
+ tokenizer(Iterator first, Iterator last,
+ const TokenizerFunc& f = TokenizerFunc())
+ : first_(first), last_(last), f_(f) { }
+
+ template <typename Container>
+ tokenizer(const Container& c)
+ : first_(c.begin()), last_(c.end()), f_() { }
+
+ template <typename Container>
+ tokenizer(const Container& c,const TokenizerFunc& f)
+ : first_(c.begin()), last_(c.end()), f_(f) { }
+
+ void assign(Iterator first, Iterator last){
+ first_ = first;
+ last_ = last;
+ }
+
+ void assign(Iterator first, Iterator last, const TokenizerFunc& f){
+ assign(first,last);
+ f_ = f;
+ }
+
+ template <typename Container>
+ void assign(const Container& c){
+ assign(c.begin(),c.end());
+ }
+
+
+ template <typename Container>
+ void assign(const Container& c, const TokenizerFunc& f){
+ assign(c.begin(),c.end(),f);
+ }
+
+ iter begin() const { return iter(f_,first_,last_); }
+ iter end() const { return iter(f_,last_,last_); }
+
+ private:
+ Iterator first_;
+ Iterator last_;
+ TokenizerFunc f_;
+ };
+
+
+} // namespace boost
+
+#endif