[ros-vision-opencv] 01/03: Revert "remove embedded boost copy"
Jochen Sprickerhof
jspricke-guest at moszumanska.debian.org
Sat Jan 2 12:09:32 UTC 2016
This is an automated email from the git hooks/post-receive script.
jspricke-guest pushed a commit to branch master
in repository ros-vision-opencv.
commit 281407726afbe4e7a78b307cafcbaf5c94c8f491
Author: Jochen Sprickerhof <git at jochen.sprickerhof.de>
Date: Sat Jan 2 13:00:59 2016 +0100
Revert "remove embedded boost copy"
This reverts commit ce2f2b66b5b9aed25f6a3ffba7a3eec0fd5c9957.
---
cv_bridge/src/boost/README | 2 +
cv_bridge/src/boost/core/scoped_enum.hpp | 192 +++++++++
cv_bridge/src/boost/endian/conversion.hpp | 488 ++++++++++++++++++++++
cv_bridge/src/boost/endian/detail/intrinsic.hpp | 64 +++
cv_bridge/src/boost/predef/detail/_cassert.h | 17 +
cv_bridge/src/boost/predef/detail/endian_compat.h | 26 ++
cv_bridge/src/boost/predef/detail/test.h | 17 +
cv_bridge/src/boost/predef/library/c/_prefix.h | 13 +
cv_bridge/src/boost/predef/library/c/gnu.h | 61 +++
cv_bridge/src/boost/predef/make.h | 89 ++++
cv_bridge/src/boost/predef/os/android.h | 45 ++
cv_bridge/src/boost/predef/os/bsd.h | 103 +++++
cv_bridge/src/boost/predef/os/bsd/bsdi.h | 48 +++
cv_bridge/src/boost/predef/os/bsd/dragonfly.h | 50 +++
cv_bridge/src/boost/predef/os/bsd/free.h | 60 +++
cv_bridge/src/boost/predef/os/bsd/net.h | 84 ++++
cv_bridge/src/boost/predef/os/bsd/open.h | 171 ++++++++
cv_bridge/src/boost/predef/os/ios.h | 51 +++
cv_bridge/src/boost/predef/os/macos.h | 65 +++
cv_bridge/src/boost/predef/other/endian.h | 204 +++++++++
cv_bridge/src/boost/predef/version_number.h | 53 +++
debian/copyright | 37 ++
22 files changed, 1940 insertions(+)
diff --git a/cv_bridge/src/boost/README b/cv_bridge/src/boost/README
new file mode 100644
index 0000000..f3a3d3c
--- /dev/null
+++ b/cv_bridge/src/boost/README
@@ -0,0 +1,2 @@
+this code is taken from Boost at https://github.com/boostorg/endian.git
+We should remove this folder once Boost 1.58 or above is the default.
diff --git a/cv_bridge/src/boost/core/scoped_enum.hpp b/cv_bridge/src/boost/core/scoped_enum.hpp
new file mode 100644
index 0000000..78c548b
--- /dev/null
+++ b/cv_bridge/src/boost/core/scoped_enum.hpp
@@ -0,0 +1,192 @@
+// scoped_enum.hpp ---------------------------------------------------------//
+
+// Copyright Beman Dawes, 2009
+// Copyright (C) 2011-2012 Vicente J. Botet Escriba
+// Copyright (C) 2012 Anthony Williams
+
+// Distributed under the Boost Software License, Version 1.0.
+// See http://www.boost.org/LICENSE_1_0.txt
+
+#ifndef BOOST_CORE_SCOPED_ENUM_HPP
+#define BOOST_CORE_SCOPED_ENUM_HPP
+
+#include <boost/config.hpp>
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+#pragma once
+#endif
+
+namespace boost
+{
+
+#ifdef BOOST_NO_CXX11_SCOPED_ENUMS
+
+ /**
+ * Meta-function to get the native enum type associated to an enum class or its emulation.
+ */
+ template <typename EnumType>
+ struct native_type
+ {
+ /**
+ * The member typedef type names the native enum type associated to the scoped enum,
+ * which is it self if the compiler supports scoped enums or EnumType::enum_type if it is an emulated scoped enum.
+ */
+ typedef typename EnumType::enum_type type;
+ };
+
+ /**
+ * Casts a scoped enum to its underlying type.
+ *
+ * This function is useful when working with scoped enum classes, which doens't implicitly convert to the underlying type.
+ * @param v A scoped enum.
+ * @returns The underlying type.
+ * @throws No-throws.
+ */
+ template <typename UnderlyingType, typename EnumType>
+ UnderlyingType underlying_cast(EnumType v)
+ {
+ return v.get_underlying_value_();
+ }
+
+ /**
+ * Casts a scoped enum to its native enum type.
+ *
+ * This function is useful to make programs portable when the scoped enum emulation can not be use where native enums can.
+ *
+ * EnumType the scoped enum type
+ *
+ * @param v A scoped enum.
+ * @returns The native enum value.
+ * @throws No-throws.
+ */
+ template <typename EnumType>
+ inline
+ typename EnumType::enum_type native_value(EnumType e)
+ {
+ return e.get_native_value_();
+ }
+
+#else // BOOST_NO_CXX11_SCOPED_ENUMS
+
+ template <typename EnumType>
+ struct native_type
+ {
+ typedef EnumType type;
+ };
+
+ template <typename UnderlyingType, typename EnumType>
+ UnderlyingType underlying_cast(EnumType v)
+ {
+ return static_cast<UnderlyingType>(v);
+ }
+
+ template <typename EnumType>
+ inline
+ EnumType native_value(EnumType e)
+ {
+ return e;
+ }
+
+#endif // BOOST_NO_CXX11_SCOPED_ENUMS
+}
+
+
+#ifdef BOOST_NO_CXX11_SCOPED_ENUMS
+
+#ifndef BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
+
+#define BOOST_SCOPED_ENUM_UT_DECLARE_CONVERSION_OPERATOR \
+ explicit operator underlying_type() const BOOST_NOEXCEPT { return get_underlying_value_(); }
+
+#else
+
+#define BOOST_SCOPED_ENUM_UT_DECLARE_CONVERSION_OPERATOR
+
+#endif
+
+/**
+ * Start a declaration of a scoped enum.
+ *
+ * @param EnumType The new scoped enum.
+ * @param UnderlyingType The underlying type.
+ */
+#define BOOST_SCOPED_ENUM_UT_DECLARE_BEGIN(EnumType, UnderlyingType) \
+ struct EnumType { \
+ typedef void is_boost_scoped_enum_tag; \
+ typedef UnderlyingType underlying_type; \
+ EnumType() BOOST_NOEXCEPT {} \
+ explicit EnumType(underlying_type v) BOOST_NOEXCEPT : v_(v) {} \
+ underlying_type get_underlying_value_() const BOOST_NOEXCEPT { return v_; } \
+ BOOST_SCOPED_ENUM_UT_DECLARE_CONVERSION_OPERATOR \
+ private: \
+ underlying_type v_; \
+ typedef EnumType self_type; \
+ public: \
+ enum enum_type
+
+#define BOOST_SCOPED_ENUM_DECLARE_END2() \
+ enum_type get_native_value_() const BOOST_NOEXCEPT { return enum_type(v_); } \
+ friend bool operator ==(self_type lhs, self_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)==enum_type(rhs.v_); } \
+ friend bool operator ==(self_type lhs, enum_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)==rhs; } \
+ friend bool operator ==(enum_type lhs, self_type rhs) BOOST_NOEXCEPT { return lhs==enum_type(rhs.v_); } \
+ friend bool operator !=(self_type lhs, self_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)!=enum_type(rhs.v_); } \
+ friend bool operator !=(self_type lhs, enum_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)!=rhs; } \
+ friend bool operator !=(enum_type lhs, self_type rhs) BOOST_NOEXCEPT { return lhs!=enum_type(rhs.v_); } \
+ friend bool operator <(self_type lhs, self_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)<enum_type(rhs.v_); } \
+ friend bool operator <(self_type lhs, enum_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)<rhs; } \
+ friend bool operator <(enum_type lhs, self_type rhs) BOOST_NOEXCEPT { return lhs<enum_type(rhs.v_); } \
+ friend bool operator <=(self_type lhs, self_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)<=enum_type(rhs.v_); } \
+ friend bool operator <=(self_type lhs, enum_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)<=rhs; } \
+ friend bool operator <=(enum_type lhs, self_type rhs) BOOST_NOEXCEPT { return lhs<=enum_type(rhs.v_); } \
+ friend bool operator >(self_type lhs, self_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)>enum_type(rhs.v_); } \
+ friend bool operator >(self_type lhs, enum_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)>rhs; } \
+ friend bool operator >(enum_type lhs, self_type rhs) BOOST_NOEXCEPT { return lhs>enum_type(rhs.v_); } \
+ friend bool operator >=(self_type lhs, self_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)>=enum_type(rhs.v_); } \
+ friend bool operator >=(self_type lhs, enum_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)>=rhs; } \
+ friend bool operator >=(enum_type lhs, self_type rhs) BOOST_NOEXCEPT { return lhs>=enum_type(rhs.v_); } \
+ };
+
+#define BOOST_SCOPED_ENUM_DECLARE_END(EnumType) \
+ ; \
+ EnumType(enum_type v) BOOST_NOEXCEPT : v_(v) {} \
+ BOOST_SCOPED_ENUM_DECLARE_END2()
+
+/**
+ * Starts a declaration of a scoped enum with the default int underlying type.
+ *
+ * @param EnumType The new scoped enum.
+ */
+#define BOOST_SCOPED_ENUM_DECLARE_BEGIN(EnumType) \
+ BOOST_SCOPED_ENUM_UT_DECLARE_BEGIN(EnumType,int)
+
+/**
+ * Name of the native enum type.
+ *
+ * @param EnumType The new scoped enum.
+ */
+#define BOOST_SCOPED_ENUM_NATIVE(EnumType) EnumType::enum_type
+/**
+ * Forward declares an scoped enum.
+ *
+ * @param EnumType The scoped enum.
+ */
+#define BOOST_SCOPED_ENUM_FORWARD_DECLARE(EnumType) struct EnumType
+
+#else // BOOST_NO_CXX11_SCOPED_ENUMS
+
+#define BOOST_SCOPED_ENUM_UT_DECLARE_BEGIN(EnumType,UnderlyingType) enum class EnumType : UnderlyingType
+#define BOOST_SCOPED_ENUM_DECLARE_BEGIN(EnumType) enum class EnumType
+#define BOOST_SCOPED_ENUM_DECLARE_END2()
+#define BOOST_SCOPED_ENUM_DECLARE_END(EnumType) ;
+
+#define BOOST_SCOPED_ENUM_NATIVE(EnumType) EnumType
+#define BOOST_SCOPED_ENUM_FORWARD_DECLARE(EnumType) enum class EnumType
+
+#endif // BOOST_NO_CXX11_SCOPED_ENUMS
+
+// Deprecated macros
+#define BOOST_SCOPED_ENUM_START(name) BOOST_SCOPED_ENUM_DECLARE_BEGIN(name)
+#define BOOST_SCOPED_ENUM_END BOOST_SCOPED_ENUM_DECLARE_END2()
+#define BOOST_SCOPED_ENUM(name) BOOST_SCOPED_ENUM_NATIVE(name)
+
+#endif // BOOST_CORE_SCOPED_ENUM_HPP
diff --git a/cv_bridge/src/boost/endian/conversion.hpp b/cv_bridge/src/boost/endian/conversion.hpp
new file mode 100644
index 0000000..7c145d9
--- /dev/null
+++ b/cv_bridge/src/boost/endian/conversion.hpp
@@ -0,0 +1,488 @@
+// boost/endian/conversion.hpp -------------------------------------------------------//
+
+// Copyright Beman Dawes 2010, 2011, 2014
+
+// Distributed under the Boost Software License, Version 1.0.
+// http://www.boost.org/LICENSE_1_0.txt
+
+#ifndef BOOST_ENDIAN_CONVERSION_HPP
+#define BOOST_ENDIAN_CONVERSION_HPP
+
+#include <boost/config.hpp>
+#include <boost/predef/detail/endian_compat.h>
+#include <boost/cstdint.hpp>
+#include <boost/endian/detail/intrinsic.hpp>
+#include <boost/core/scoped_enum.hpp>
+#include <boost/static_assert.hpp>
+#include <algorithm>
+#include <cstring> // for memcpy
+
+//------------------------------------- synopsis ---------------------------------------//
+
+namespace boost
+{
+namespace endian
+{
+ BOOST_SCOPED_ENUM_START(order)
+ {
+ big, little,
+# ifdef BOOST_BIG_ENDIAN
+ native = big
+# else
+ native = little
+# endif
+ }; BOOST_SCOPED_ENUM_END
+
+//--------------------------------------------------------------------------------------//
+// //
+// return-by-value interfaces //
+// suggested by Phil Endecott //
+// //
+// user-defined types (UDTs) //
+// //
+// All return-by-value conversion function templates are required to be implemented in //
+// terms of an unqualified call to "endian_reverse(x)", a function returning the //
+// value of x with endianness reversed. This provides a customization point for any //
+// UDT that provides a "endian_reverse" free-function meeting the requirements. //
+// It must be defined in the same namespace as the UDT itself so that it will be found //
+// by argument dependent lookup (ADL). //
+// //
+//--------------------------------------------------------------------------------------//
+
+ // customization for exact-length arithmetic types. See doc/conversion.html/#FAQ.
+ // Note: The omission of an overloads for the arithmetic type (typically long, or
+ // long long) not assigned to one of the exact length typedefs is a deliberate
+ // design decision. Such overloads would be non-portable and thus error prone.
+
+ inline int8_t endian_reverse(int8_t x) BOOST_NOEXCEPT;
+ inline int16_t endian_reverse(int16_t x) BOOST_NOEXCEPT;
+ inline int32_t endian_reverse(int32_t x) BOOST_NOEXCEPT;
+ inline int64_t endian_reverse(int64_t x) BOOST_NOEXCEPT;
+ inline uint8_t endian_reverse(uint8_t x) BOOST_NOEXCEPT;
+ inline uint16_t endian_reverse(uint16_t x) BOOST_NOEXCEPT;
+ inline uint32_t endian_reverse(uint32_t x) BOOST_NOEXCEPT;
+ inline uint64_t endian_reverse(uint64_t x) BOOST_NOEXCEPT;
+
+ // reverse byte order unless native endianness is big
+ template <class EndianReversible >
+ inline EndianReversible big_to_native(EndianReversible x) BOOST_NOEXCEPT;
+ // Returns: x if native endian order is big, otherwise endian_reverse(x)
+ template <class EndianReversible >
+ inline EndianReversible native_to_big(EndianReversible x) BOOST_NOEXCEPT;
+ // Returns: x if native endian order is big, otherwise endian_reverse(x)
+
+ // reverse byte order unless native endianness is little
+ template <class EndianReversible >
+ inline EndianReversible little_to_native(EndianReversible x) BOOST_NOEXCEPT;
+ // Returns: x if native endian order is little, otherwise endian_reverse(x)
+ template <class EndianReversible >
+ inline EndianReversible native_to_little(EndianReversible x) BOOST_NOEXCEPT;
+ // Returns: x if native endian order is little, otherwise endian_reverse(x)
+
+ // generic conditional reverse byte order
+ template <BOOST_SCOPED_ENUM(order) From, BOOST_SCOPED_ENUM(order) To,
+ class EndianReversible>
+ inline EndianReversible conditional_reverse(EndianReversible from) BOOST_NOEXCEPT;
+ // Returns: If From == To have different values, from.
+ // Otherwise endian_reverse(from).
+ // Remarks: The From == To test, and as a consequence which form the return takes, is
+ // is determined at compile time.
+
+ // runtime conditional reverse byte order
+ template <class EndianReversible >
+ inline EndianReversible conditional_reverse(EndianReversible from,
+ BOOST_SCOPED_ENUM(order) from_order, BOOST_SCOPED_ENUM(order) to_order)
+ BOOST_NOEXCEPT;
+ // Returns: from_order == to_order ? from : endian_reverse(from).
+
+ //------------------------------------------------------------------------------------//
+
+
+ // Q: What happended to bswap, htobe, and the other synonym functions based on names
+ // popularized by BSD, OS X, and Linux?
+ // A: Turned out these may be implemented as macros on some systems. Ditto POSIX names
+ // for such functionality. Since macros would cause endless problems with functions
+ // of the same names, and these functions are just synonyms anyhow, they have been
+ // removed.
+
+
+ //------------------------------------------------------------------------------------//
+ // //
+ // reverse in place interfaces //
+ // //
+ // user-defined types (UDTs) //
+ // //
+ // All reverse in place function templates are required to be implemented in terms //
+ // of an unqualified call to "endian_reverse_inplace(x)", a function reversing //
+ // the endianness of x, which is a non-const reference. This provides a //
+ // customization point for any UDT that provides a "reverse_inplace" free-function //
+ // meeting the requirements. The free-function must be declared in the same //
+ // namespace as the UDT itself so that it will be found by argument-dependent //
+ // lookup (ADL). //
+ // //
+ //------------------------------------------------------------------------------------//
+
+ // reverse in place
+ template <class EndianReversible>
+ inline void endian_reverse_inplace(EndianReversible& x) BOOST_NOEXCEPT;
+ // Effects: x = endian_reverse(x)
+
+ // reverse in place unless native endianness is big
+ template <class EndianReversibleInplace>
+ inline void big_to_native_inplace(EndianReversibleInplace& x) BOOST_NOEXCEPT;
+ // Effects: none if native byte-order is big, otherwise endian_reverse_inplace(x)
+ template <class EndianReversibleInplace>
+ inline void native_to_big_inplace(EndianReversibleInplace& x) BOOST_NOEXCEPT;
+ // Effects: none if native byte-order is big, otherwise endian_reverse_inplace(x)
+
+ // reverse in place unless native endianness is little
+ template <class EndianReversibleInplace>
+ inline void little_to_native_inplace(EndianReversibleInplace& x) BOOST_NOEXCEPT;
+ // Effects: none if native byte-order is little, otherwise endian_reverse_inplace(x);
+ template <class EndianReversibleInplace>
+ inline void native_to_little_inplace(EndianReversibleInplace& x) BOOST_NOEXCEPT;
+ // Effects: none if native byte-order is little, otherwise endian_reverse_inplace(x);
+
+ // generic conditional reverse in place
+ template <BOOST_SCOPED_ENUM(order) From, BOOST_SCOPED_ENUM(order) To,
+ class EndianReversibleInplace>
+ inline void conditional_reverse_inplace(EndianReversibleInplace& x) BOOST_NOEXCEPT;
+
+ // runtime reverse in place
+ template <class EndianReversibleInplace>
+ inline void conditional_reverse_inplace(EndianReversibleInplace& x,
+ BOOST_SCOPED_ENUM(order) from_order, BOOST_SCOPED_ENUM(order) to_order)
+ BOOST_NOEXCEPT;
+
+//----------------------------------- end synopsis -------------------------------------//
+
+ namespace detail
+ {
+ // generic reverse function template implementation approach using std::reverse
+ // suggested by Mathias Gaunard. Primary motivation for inclusion is to have an
+ // independent implementation to test against.
+
+ template <class T>
+ inline T std_endian_reverse(T x) BOOST_NOEXCEPT
+ {
+ T tmp(x);
+ std::reverse(
+ reinterpret_cast<unsigned char*>(&tmp),
+ reinterpret_cast<unsigned char*>(&tmp) + sizeof(T));
+ return tmp;
+ }
+
+ // conditional unaligned reverse copy, patterned after std::reverse_copy
+ template <class T>
+ inline void big_reverse_copy(T from, char* to) BOOST_NOEXCEPT;
+ template <class T>
+ inline void big_reverse_copy(const char* from, T& to) BOOST_NOEXCEPT;
+ template <class T>
+ inline void little_reverse_copy(T from, char* to) BOOST_NOEXCEPT;
+ template <class T>
+ inline void little_reverse_copy(const char* from, T& to) BOOST_NOEXCEPT;
+ } // namespace detail
+
+//--------------------------------------------------------------------------------------//
+// //
+// return-by-value implementation //
+// //
+// -- portable approach suggested by tymofey, with avoidance of undefined behavior //
+// as suggested by Giovanni Piero Deretta, with a further refinement suggested //
+// by Pyry Jahkola. //
+// -- intrinsic approach suggested by reviewers, and by David Stone, who provided //
+// his Boost licensed macro implementation (detail/intrinsic.hpp) //
+// //
+//--------------------------------------------------------------------------------------//
+
+ inline int8_t endian_reverse(int8_t x) BOOST_NOEXCEPT
+ {
+ return x;
+ }
+
+ inline int16_t endian_reverse(int16_t x) BOOST_NOEXCEPT
+ {
+# ifdef BOOST_ENDIAN_NO_INTRINSICS
+ return (static_cast<uint16_t>(x) << 8)
+ | (static_cast<uint16_t>(x) >> 8);
+# else
+ return BOOST_ENDIAN_INTRINSIC_BYTE_SWAP_2(static_cast<uint16_t>(x));
+# endif
+ }
+
+ inline int32_t endian_reverse(int32_t x) BOOST_NOEXCEPT
+ {
+# ifdef BOOST_ENDIAN_NO_INTRINSICS
+ uint32_t step16;
+ step16 = static_cast<uint32_t>(x) << 16 | static_cast<uint32_t>(x) >> 16;
+ return
+ ((static_cast<uint32_t>(step16) << 8) & 0xff00ff00)
+ | ((static_cast<uint32_t>(step16) >> 8) & 0x00ff00ff);
+# else
+ return BOOST_ENDIAN_INTRINSIC_BYTE_SWAP_4(static_cast<uint32_t>(x));
+# endif
+ }
+
+ inline int64_t endian_reverse(int64_t x) BOOST_NOEXCEPT
+ {
+# ifdef BOOST_ENDIAN_NO_INTRINSICS
+ uint64_t step32, step16;
+ step32 = static_cast<uint64_t>(x) << 32 | static_cast<uint64_t>(x) >> 32;
+ step16 = (step32 & 0x0000FFFF0000FFFFULL) << 16
+ | (step32 & 0xFFFF0000FFFF0000ULL) >> 16;
+ return static_cast<int64_t>((step16 & 0x00FF00FF00FF00FFULL) << 8
+ | (step16 & 0xFF00FF00FF00FF00ULL) >> 8);
+# else
+ return BOOST_ENDIAN_INTRINSIC_BYTE_SWAP_8(static_cast<uint64_t>(x));
+# endif
+ }
+
+ inline uint8_t endian_reverse(uint8_t x) BOOST_NOEXCEPT
+ {
+ return x;
+ }
+
+ inline uint16_t endian_reverse(uint16_t x) BOOST_NOEXCEPT
+ {
+# ifdef BOOST_ENDIAN_NO_INTRINSICS
+ return (x << 8)
+ | (x >> 8);
+# else
+ return BOOST_ENDIAN_INTRINSIC_BYTE_SWAP_2(x);
+# endif
+ }
+
+ inline uint32_t endian_reverse(uint32_t x) BOOST_NOEXCEPT
+ {
+# ifdef BOOST_ENDIAN_NO_INTRINSICS
+ uint32_t step16;
+ step16 = x << 16 | x >> 16;
+ return
+ ((step16 << 8) & 0xff00ff00)
+ | ((step16 >> 8) & 0x00ff00ff);
+# else
+ return BOOST_ENDIAN_INTRINSIC_BYTE_SWAP_4(x);
+# endif
+ }
+
+ inline uint64_t endian_reverse(uint64_t x) BOOST_NOEXCEPT
+ {
+# ifdef BOOST_ENDIAN_NO_INTRINSICS
+ uint64_t step32, step16;
+ step32 = x << 32 | x >> 32;
+ step16 = (step32 & 0x0000FFFF0000FFFFULL) << 16
+ | (step32 & 0xFFFF0000FFFF0000ULL) >> 16;
+ return (step16 & 0x00FF00FF00FF00FFULL) << 8
+ | (step16 & 0xFF00FF00FF00FF00ULL) >> 8;
+# else
+ return BOOST_ENDIAN_INTRINSIC_BYTE_SWAP_8(x);
+# endif
+ }
+
+ template <class EndianReversible >
+ inline EndianReversible big_to_native(EndianReversible x) BOOST_NOEXCEPT
+ {
+# ifdef BOOST_BIG_ENDIAN
+ return x;
+# else
+ return endian_reverse(x);
+# endif
+ }
+
+ template <class EndianReversible >
+ inline EndianReversible native_to_big(EndianReversible x) BOOST_NOEXCEPT
+ {
+# ifdef BOOST_BIG_ENDIAN
+ return x;
+# else
+ return endian_reverse(x);
+# endif
+ }
+
+ template <class EndianReversible >
+ inline EndianReversible little_to_native(EndianReversible x) BOOST_NOEXCEPT
+ {
+# ifdef BOOST_LITTLE_ENDIAN
+ return x;
+# else
+ return endian_reverse(x);
+# endif
+ }
+
+ template <class EndianReversible >
+ inline EndianReversible native_to_little(EndianReversible x) BOOST_NOEXCEPT
+ {
+# ifdef BOOST_LITTLE_ENDIAN
+ return x;
+# else
+ return endian_reverse(x);
+# endif
+ }
+
+ namespace detail
+ {
+ // Primary template and specializations to support endian_reverse().
+ // See rationale in endian_reverse() below.
+ template <BOOST_SCOPED_ENUM(order) From, BOOST_SCOPED_ENUM(order) To,
+ class EndianReversible>
+ class value_converter ; // primary template
+ template <class T> class value_converter <order::big, order::big, T>
+ {public: T operator()(T x) BOOST_NOEXCEPT {return x;}};
+ template <class T> class value_converter <order::little, order::little, T>
+ {public: T operator()(T x) BOOST_NOEXCEPT {return x;}};
+ template <class T> class value_converter <order::big, order::little, T>
+ {public: T operator()(T x) BOOST_NOEXCEPT {return endian_reverse(x);}};
+ template <class T> class value_converter <order::little, order::big, T>
+ {public: T operator()(T x) BOOST_NOEXCEPT {return endian_reverse(x);}};
+ }
+
+ // generic conditional reverse
+ template <BOOST_SCOPED_ENUM(order) From, BOOST_SCOPED_ENUM(order) To,
+ class EndianReversible>
+ inline EndianReversible conditional_reverse(EndianReversible from) BOOST_NOEXCEPT {
+ // work around lack of function template partial specialization by instantiating
+ // a function object of a class that is partially specialized on the two order
+ // template parameters, and then calling its operator().
+ detail::value_converter <From, To, EndianReversible> tmp;
+ return tmp(from);
+ }
+
+ // runtime conditional reverse
+ template <class EndianReversible >
+ inline EndianReversible conditional_reverse(EndianReversible from,
+ BOOST_SCOPED_ENUM(order) from_order, BOOST_SCOPED_ENUM(order) to_order) BOOST_NOEXCEPT
+ {
+ return from_order == to_order ? from : endian_reverse(from);
+ }
+
+//--------------------------------------------------------------------------------------//
+// reverse-in-place implementation //
+//--------------------------------------------------------------------------------------//
+
+ // reverse in place
+ template <class EndianReversible>
+ inline void endian_reverse_inplace(EndianReversible& x) BOOST_NOEXCEPT
+ {
+ x = endian_reverse(x);
+ }
+
+ template <class EndianReversibleInplace>
+# ifdef BOOST_BIG_ENDIAN
+ inline void big_to_native_inplace(EndianReversibleInplace&) BOOST_NOEXCEPT {}
+# else
+ inline void big_to_native_inplace(EndianReversibleInplace& x) BOOST_NOEXCEPT
+ { endian_reverse_inplace(x); }
+# endif
+ template <class EndianReversibleInplace>
+# ifdef BOOST_BIG_ENDIAN
+ inline void native_to_big_inplace(EndianReversibleInplace&) BOOST_NOEXCEPT {}
+# else
+ inline void native_to_big_inplace(EndianReversibleInplace& x) BOOST_NOEXCEPT
+ {
+ endian_reverse_inplace(x);
+ }
+# endif
+
+ template <class EndianReversibleInplace>
+# ifdef BOOST_LITTLE_ENDIAN
+ inline void little_to_native_inplace(EndianReversibleInplace&) BOOST_NOEXCEPT {}
+# else
+ inline void little_to_native_inplace(EndianReversibleInplace& x) BOOST_NOEXCEPT
+ { endian_reverse_inplace(x); }
+# endif
+ template <class EndianReversibleInplace>
+# ifdef BOOST_LITTLE_ENDIAN
+ inline void native_to_little_inplace(EndianReversibleInplace&) BOOST_NOEXCEPT {}
+# else
+ inline void native_to_little_inplace(EndianReversibleInplace& x) BOOST_NOEXCEPT
+ {
+ endian_reverse_inplace(x);
+ }
+# endif
+
+ namespace detail
+ {
+ // Primary template and specializations support generic
+ // endian_reverse_inplace().
+ // See rationale in endian_reverse_inplace() below.
+ template <BOOST_SCOPED_ENUM(order) From, BOOST_SCOPED_ENUM(order) To,
+ class EndianReversibleInplace>
+ class converter; // primary template
+ template <class T> class converter<order::big, order::big, T>
+ {public: void operator()(T&) BOOST_NOEXCEPT {/*no effect*/}};
+ template <class T> class converter<order::little, order::little, T>
+ {public: void operator()(T&) BOOST_NOEXCEPT {/*no effect*/}};
+ template <class T> class converter<order::big, order::little, T>
+ {public: void operator()(T& x) BOOST_NOEXCEPT { endian_reverse_inplace(x); }};
+ template <class T> class converter<order::little, order::big, T>
+ {public: void operator()(T& x) BOOST_NOEXCEPT { endian_reverse_inplace(x); }};
+ } // namespace detail
+
+ // generic conditional reverse in place
+ template <BOOST_SCOPED_ENUM(order) From, BOOST_SCOPED_ENUM(order) To,
+ class EndianReversibleInplace>
+ inline void conditional_reverse_inplace(EndianReversibleInplace& x) BOOST_NOEXCEPT
+ {
+ // work around lack of function template partial specialization by instantiating
+ // a function object of a class that is partially specialized on the two order
+ // template parameters, and then calling its operator().
+ detail::converter<From, To, EndianReversibleInplace> tmp;
+ tmp(x); // call operator ()
+ }
+
+ // runtime reverse in place
+ template <class EndianReversibleInplace>
+ inline void conditional_reverse_inplace(EndianReversibleInplace& x,
+ BOOST_SCOPED_ENUM(order) from_order, BOOST_SCOPED_ENUM(order) to_order)
+ BOOST_NOEXCEPT
+ {
+ if (from_order != to_order)
+ endian_reverse_inplace(x);
+ }
+
+
+ namespace detail
+ {
+ template <class T>
+ inline void big_reverse_copy(T from, char* to) BOOST_NOEXCEPT
+ {
+# ifdef BOOST_BIG_ENDIAN
+ std::memcpy(to, reinterpret_cast<const char*>(&from), sizeof(T));
+# else
+ std::reverse_copy(reinterpret_cast<const char*>(&from),
+ reinterpret_cast<const char*>(&from) + sizeof(T), to);
+# endif
+ }
+ template <class T>
+ inline void big_reverse_copy(const char* from, T& to) BOOST_NOEXCEPT
+ {
+# ifdef BOOST_BIG_ENDIAN
+ std::memcpy(reinterpret_cast<char*>(&to), from, sizeof(T));
+# else
+ std::reverse_copy(from, from + sizeof(T), reinterpret_cast<char*>(&to));
+# endif
+ }
+ template <class T>
+ inline void little_reverse_copy(T from, char* to) BOOST_NOEXCEPT
+ {
+# ifdef BOOST_LITTLE_ENDIAN
+ std::memcpy(to, reinterpret_cast<const char*>(&from), sizeof(T));
+# else
+ std::reverse_copy(reinterpret_cast<const char*>(&from),
+ reinterpret_cast<const char*>(&from) + sizeof(T), to);
+# endif
+ }
+ template <class T>
+ inline void little_reverse_copy(const char* from, T& to) BOOST_NOEXCEPT
+ {
+# ifdef BOOST_LITTLE_ENDIAN
+ std::memcpy(reinterpret_cast<char*>(&to), from, sizeof(T));
+# else
+ std::reverse_copy(from, from + sizeof(T), reinterpret_cast<char*>(&to));
+# endif
+ }
+ } // namespace detail
+} // namespace endian
+} // namespace boost
+
+#endif // BOOST_ENDIAN_CONVERSION_HPP
diff --git a/cv_bridge/src/boost/endian/detail/intrinsic.hpp b/cv_bridge/src/boost/endian/detail/intrinsic.hpp
new file mode 100644
index 0000000..6ead681
--- /dev/null
+++ b/cv_bridge/src/boost/endian/detail/intrinsic.hpp
@@ -0,0 +1,64 @@
+// endian/detail/intrinsic.hpp -------------------------------------------------------//
+
+// Copyright (C) 2012 David Stone
+// Copyright Beman Dawes 2013
+
+// Distributed under the Boost Software License, Version 1.0.
+// http://www.boost.org/LICENSE_1_0.txt
+
+#ifndef BOOST_ENDIAN_INTRINSIC_HPP
+#define BOOST_ENDIAN_INTRINSIC_HPP
+
+// Allow user to force BOOST_ENDIAN_NO_INTRINSICS in case they aren't available for a
+// particular platform/compiler combination. Please report such platform/compiler
+// combinations to the Boost mailing list.
+#ifndef BOOST_ENDIAN_NO_INTRINSICS
+
+#ifndef __has_builtin // Optional of course
+ #define __has_builtin(x) 0 // Compatibility with non-clang compilers
+#endif
+
+// GCC and Clang recent versions provide intrinsic byte swaps via builtins
+#if (defined(__clang__) && __has_builtin(__builtin_bswap32) && __has_builtin(__builtin_bswap64)) \
+ || (defined(__GNUC__ ) && \
+ (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)))
+# define BOOST_ENDIAN_INTRINSIC_MSG "__builtin_bswap16, etc."
+// prior to 4.8, gcc did not provide __builtin_bswap16 on some platforms so we emulate it
+// see http://gcc.gnu.org/bugzilla/show_bug.cgi?id=52624
+// Clang has a similar problem, but their feature test macros make it easier to detect
+# if (defined(__clang__) && __has_builtin(__builtin_bswap16)) \
+ || (defined(__GNUC__) &&(__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)))
+# define BOOST_ENDIAN_INTRINSIC_BYTE_SWAP_2(x) __builtin_bswap16(x)
+# else
+# define BOOST_ENDIAN_INTRINSIC_BYTE_SWAP_2(x) __builtin_bswap32((x) << 16)
+# endif
+# define BOOST_ENDIAN_INTRINSIC_BYTE_SWAP_4(x) __builtin_bswap32(x)
+# define BOOST_ENDIAN_INTRINSIC_BYTE_SWAP_8(x) __builtin_bswap64(x)
+
+// Linux systems provide the byteswap.h header, with
+#elif defined(__linux__)
+// don't check for obsolete forms defined(linux) and defined(__linux) on the theory that
+// compilers that predefine only these are so old that byteswap.h probably isn't present.
+# define BOOST_ENDIAN_INTRINSIC_MSG "byteswap.h bswap_16, etc."
+# include <byteswap.h>
+# define BOOST_ENDIAN_INTRINSIC_BYTE_SWAP_2(x) bswap_16(x)
+# define BOOST_ENDIAN_INTRINSIC_BYTE_SWAP_4(x) bswap_32(x)
+# define BOOST_ENDIAN_INTRINSIC_BYTE_SWAP_8(x) bswap_64(x)
+
+#elif defined(_MSC_VER)
+// Microsoft documents these as being compatible since Windows 95 and specificly
+// lists runtime library support since Visual Studio 2003 (aka 7.1).
+# define BOOST_ENDIAN_INTRINSIC_MSG "cstdlib _byteswap_ushort, etc."
+# include <cstdlib>
+# define BOOST_ENDIAN_INTRINSIC_BYTE_SWAP_2(x) _byteswap_ushort(x)
+# define BOOST_ENDIAN_INTRINSIC_BYTE_SWAP_4(x) _byteswap_ulong(x)
+# define BOOST_ENDIAN_INTRINSIC_BYTE_SWAP_8(x) _byteswap_uint64(x)
+#else
+# define BOOST_ENDIAN_NO_INTRINSICS
+# define BOOST_ENDIAN_INTRINSIC_MSG "no byte swap intrinsics"
+#endif
+
+#elif !defined(BOOST_ENDIAN_INTRINSIC_MSG)
+# define BOOST_ENDIAN_INTRINSIC_MSG "no byte swap intrinsics"
+#endif // BOOST_ENDIAN_NO_INTRINSICS
+#endif // BOOST_ENDIAN_INTRINSIC_HPP
diff --git a/cv_bridge/src/boost/predef/detail/_cassert.h b/cv_bridge/src/boost/predef/detail/_cassert.h
new file mode 100644
index 0000000..940e944
--- /dev/null
+++ b/cv_bridge/src/boost/predef/detail/_cassert.h
@@ -0,0 +1,17 @@
+/*
+Copyright Rene Rivera 2011-2012
+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)
+*/
+
+#ifndef BOOST_PREDEF_DETAIL__CASSERT_H
+#define BOOST_PREDEF_DETAIL__CASSERT_H
+
+#if defined(__cplusplus)
+#include <cassert>
+#else
+#include <assert.h>
+#endif
+
+#endif
diff --git a/cv_bridge/src/boost/predef/detail/endian_compat.h b/cv_bridge/src/boost/predef/detail/endian_compat.h
new file mode 100644
index 0000000..7725e68
--- /dev/null
+++ b/cv_bridge/src/boost/predef/detail/endian_compat.h
@@ -0,0 +1,26 @@
+/*
+Copyright Rene Rivera 2013
+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)
+*/
+
+#ifndef BOOST_PREDEF_DETAIL_ENDIAN_COMPAT_H
+#define BOOST_PREDEF_DETAIL_ENDIAN_COMPAT_H
+
+#include <boost/predef/other/endian.h>
+
+#if BOOST_ENDIAN_BIG_BYTE
+# define BOOST_BIG_ENDIAN
+# define BOOST_BYTE_ORDER 4321
+#endif
+#if BOOST_ENDIAN_LITTLE_BYTE
+# define BOOST_LITTLE_ENDIAN
+# define BOOST_BYTE_ORDER 1234
+#endif
+#if BOOST_ENDIAN_LITTLE_WORD
+# define BOOST_PDP_ENDIAN
+# define BOOST_BYTE_ORDER 2134
+#endif
+
+#endif
diff --git a/cv_bridge/src/boost/predef/detail/test.h b/cv_bridge/src/boost/predef/detail/test.h
new file mode 100644
index 0000000..546a9e4
--- /dev/null
+++ b/cv_bridge/src/boost/predef/detail/test.h
@@ -0,0 +1,17 @@
+/*
+Copyright Rene Rivera 2011-2012
+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)
+*/
+
+#ifndef BOOST_PREDEF_DETAIL_TEST_H
+#define BOOST_PREDEF_DETAIL_TEST_H
+
+#if !defined(BOOST_PREDEF_INTERNAL_GENERATE_TESTS)
+
+#define BOOST_PREDEF_DECLARE_TEST(x,s)
+
+#endif
+
+#endif
diff --git a/cv_bridge/src/boost/predef/library/c/_prefix.h b/cv_bridge/src/boost/predef/library/c/_prefix.h
new file mode 100644
index 0000000..12bcb0f
--- /dev/null
+++ b/cv_bridge/src/boost/predef/library/c/_prefix.h
@@ -0,0 +1,13 @@
+/*
+Copyright Rene Rivera 2008-2013
+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)
+*/
+
+#ifndef BOOST_PREDEF_LIBRARY_C__PREFIX_H
+#define BOOST_PREDEF_LIBRARY_C__PREFIX_H
+
+#include <boost/predef/detail/_cassert.h>
+
+#endif
diff --git a/cv_bridge/src/boost/predef/library/c/gnu.h b/cv_bridge/src/boost/predef/library/c/gnu.h
new file mode 100644
index 0000000..9e4ca89
--- /dev/null
+++ b/cv_bridge/src/boost/predef/library/c/gnu.h
@@ -0,0 +1,61 @@
+/*
+Copyright Rene Rivera 2008-2015
+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)
+*/
+
+#ifndef BOOST_PREDEF_LIBRARY_C_GNU_H
+#define BOOST_PREDEF_LIBRARY_C_GNU_H
+
+#include <boost/predef/version_number.h>
+#include <boost/predef/make.h>
+
+#include <boost/predef/library/c/_prefix.h>
+
+#if defined(__STDC__)
+#include <stddef.h>
+#elif defined(__cplusplus)
+#include <cstddef>
+#endif
+
+/*`
+[heading `BOOST_LIB_C_GNU`]
+
+[@http://en.wikipedia.org/wiki/Glibc GNU glibc] Standard C library.
+Version number available as major, and minor.
+
+[table
+ [[__predef_symbol__] [__predef_version__]]
+
+ [[`__GLIBC__`] [__predef_detection__]]
+ [[`__GNU_LIBRARY__`] [__predef_detection__]]
+
+ [[`__GLIBC__`, `__GLIBC_MINOR__`] [V.R.0]]
+ [[`__GNU_LIBRARY__`, `__GNU_LIBRARY_MINOR__`] [V.R.0]]
+ ]
+ */
+
+#define BOOST_LIB_C_GNU BOOST_VERSION_NUMBER_NOT_AVAILABLE
+
+#if defined(__GLIBC__) || defined(__GNU_LIBRARY__)
+# undef BOOST_LIB_C_GNU
+# if defined(__GLIBC__)
+# define BOOST_LIB_C_GNU \
+ BOOST_VERSION_NUMBER(__GLIBC__,__GLIBC_MINOR__,0)
+# else
+# define BOOST_LIB_C_GNU \
+ BOOST_VERSION_NUMBER(__GNU_LIBRARY__,__GNU_LIBRARY_MINOR__,0)
+# endif
+#endif
+
+#if BOOST_LIB_C_GNU
+# define BOOST_LIB_C_GNU_AVAILABLE
+#endif
+
+#define BOOST_LIB_C_GNU_NAME "GNU"
+
+#endif
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_LIB_C_GNU,BOOST_LIB_C_GNU_NAME)
diff --git a/cv_bridge/src/boost/predef/make.h b/cv_bridge/src/boost/predef/make.h
new file mode 100644
index 0000000..4f2f9ee
--- /dev/null
+++ b/cv_bridge/src/boost/predef/make.h
@@ -0,0 +1,89 @@
+/*
+Copyright Rene Rivera 2008-2015
+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)
+*/
+#include <boost/predef/detail/test.h>
+
+#ifndef BOOST_PREDEF_MAKE_H
+#define BOOST_PREDEF_MAKE_H
+
+/*
+Shorthands for the common version number formats used by vendors...
+*/
+
+/*`
+[heading `BOOST_PREDEF_MAKE_..` macros]
+
+These set of macros decompose common vendor version number
+macros which are composed version, revision, and patch digits.
+The naming convention indicates:
+
+* The base of the specified version number. "`BOOST_PREDEF_MAKE_0X`" for
+ hexadecimal digits, and "`BOOST_PREDEF_MAKE_10`" for decimal digits.
+* The format of the vendor version number. Where "`V`" indicates the version digits,
+ "`R`" indicates the revision digits, "`P`" indicates the patch digits, and "`0`"
+ indicates an ignored digit.
+
+Macros are:
+*/
+/*` `BOOST_PREDEF_MAKE_0X_VRP(V)` */
+#define BOOST_PREDEF_MAKE_0X_VRP(V) BOOST_VERSION_NUMBER((V&0xF00)>>8,(V&0xF0)>>4,(V&0xF))
+/*` `BOOST_PREDEF_MAKE_0X_VVRP(V)` */
+#define BOOST_PREDEF_MAKE_0X_VVRP(V) BOOST_VERSION_NUMBER((V&0xFF00)>>8,(V&0xF0)>>4,(V&0xF))
+/*` `BOOST_PREDEF_MAKE_0X_VRPP(V)` */
+#define BOOST_PREDEF_MAKE_0X_VRPP(V) BOOST_VERSION_NUMBER((V&0xF000)>>12,(V&0xF00)>>8,(V&0xFF))
+/*` `BOOST_PREDEF_MAKE_0X_VVRR(V)` */
+#define BOOST_PREDEF_MAKE_0X_VVRR(V) BOOST_VERSION_NUMBER((V&0xFF00)>>8,(V&0xFF),0)
+/*` `BOOST_PREDEF_MAKE_0X_VRRPPPP(V)` */
+#define BOOST_PREDEF_MAKE_0X_VRRPPPP(V) BOOST_VERSION_NUMBER((V&0xF000000)>>24,(V&0xFF0000)>>16,(V&0xFFFF))
+/*` `BOOST_PREDEF_MAKE_0X_VVRRP(V)` */
+#define BOOST_PREDEF_MAKE_0X_VVRRP(V) BOOST_VERSION_NUMBER((V&0xFF000)>>12,(V&0xFF0)>>4,(V&0xF))
+/*` `BOOST_PREDEF_MAKE_0X_VRRPP000(V)` */
+#define BOOST_PREDEF_MAKE_0X_VRRPP000(V) BOOST_VERSION_NUMBER((V&0xF0000000)>>28,(V&0xFF00000)>>20,(V&0xFF000)>>12)
+/*` `BOOST_PREDEF_MAKE_0X_VVRRPP(V)` */
+#define BOOST_PREDEF_MAKE_0X_VVRRPP(V) BOOST_VERSION_NUMBER((V&0xFF0000)>>16,(V&0xFF00)>>8,(V&0xFF))
+/*` `BOOST_PREDEF_MAKE_10_VPPP(V)` */
+#define BOOST_PREDEF_MAKE_10_VPPP(V) BOOST_VERSION_NUMBER(((V)/1000)%10,0,(V)%1000)
+/*` `BOOST_PREDEF_MAKE_10_VRP(V)` */
+#define BOOST_PREDEF_MAKE_10_VRP(V) BOOST_VERSION_NUMBER(((V)/100)%10,((V)/10)%10,(V)%10)
+/*` `BOOST_PREDEF_MAKE_10_VRP000(V)` */
+#define BOOST_PREDEF_MAKE_10_VRP000(V) BOOST_VERSION_NUMBER(((V)/100000)%10,((V)/10000)%10,((V)/1000)%10)
+/*` `BOOST_PREDEF_MAKE_10_VRPP(V)` */
+#define BOOST_PREDEF_MAKE_10_VRPP(V) BOOST_VERSION_NUMBER(((V)/1000)%10,((V)/100)%10,(V)%100)
+/*` `BOOST_PREDEF_MAKE_10_VRR(V)` */
+#define BOOST_PREDEF_MAKE_10_VRR(V) BOOST_VERSION_NUMBER(((V)/100)%10,(V)%100,0)
+/*` `BOOST_PREDEF_MAKE_10_VRRPP(V)` */
+#define BOOST_PREDEF_MAKE_10_VRRPP(V) BOOST_VERSION_NUMBER(((V)/10000)%10,((V)/100)%100,(V)%100)
+/*` `BOOST_PREDEF_MAKE_10_VRR000(V)` */
+#define BOOST_PREDEF_MAKE_10_VRR000(V) BOOST_VERSION_NUMBER(((V)/100000)%10,((V)/1000)%100,0)
+/*` `BOOST_PREDEF_MAKE_10_VV00(V)` */
+#define BOOST_PREDEF_MAKE_10_VV00(V) BOOST_VERSION_NUMBER(((V)/100)%100,0,0)
+/*` `BOOST_PREDEF_MAKE_10_VVRR(V)` */
+#define BOOST_PREDEF_MAKE_10_VVRR(V) BOOST_VERSION_NUMBER(((V)/100)%100,(V)%100,0)
+/*` `BOOST_PREDEF_MAKE_10_VVRRPP(V)` */
+#define BOOST_PREDEF_MAKE_10_VVRRPP(V) BOOST_VERSION_NUMBER(((V)/10000)%100,((V)/100)%100,(V)%100)
+/*` `BOOST_PREDEF_MAKE_10_VVRR0PP00(V)` */
+#define BOOST_PREDEF_MAKE_10_VVRR0PP00(V) BOOST_VERSION_NUMBER(((V)/10000000)%100,((V)/100000)%100,((V)/100)%100)
+/*` `BOOST_PREDEF_MAKE_10_VVRR0PPPP(V)` */
+#define BOOST_PREDEF_MAKE_10_VVRR0PPPP(V) BOOST_VERSION_NUMBER(((V)/10000000)%100,((V)/100000)%100,(V)%10000)
+/*` `BOOST_PREDEF_MAKE_10_VVRR00PP00(V)` */
+#define BOOST_PREDEF_MAKE_10_VVRR00PP00(V) BOOST_VERSION_NUMBER(((V)/100000000)%100,((V)/1000000)%100,((V)/100)%100)
+/*`
+[heading `BOOST_PREDEF_MAKE_*..` date macros]
+
+Date decomposition macros return a date in the relative to the 1970
+Epoch date. If the month is not available, January 1st is used as the month and day.
+If the day is not available, but the month is, the 1st of the month is used as the day.
+*/
+/*` `BOOST_PREDEF_MAKE_DATE(Y,M,D)` */
+#define BOOST_PREDEF_MAKE_DATE(Y,M,D) BOOST_VERSION_NUMBER((Y)%10000-1970,(M)%100,(D)%100)
+/*` `BOOST_PREDEF_MAKE_YYYYMMDD(V)` */
+#define BOOST_PREDEF_MAKE_YYYYMMDD(V) BOOST_PREDEF_MAKE_DATE(((V)/10000)%10000,((V)/100)%100,(V)%100)
+/*` `BOOST_PREDEF_MAKE_YYYY(V)` */
+#define BOOST_PREDEF_MAKE_YYYY(V) BOOST_PREDEF_MAKE_DATE(V,1,1)
+/*` `BOOST_PREDEF_MAKE_YYYYMM(V)` */
+#define BOOST_PREDEF_MAKE_YYYYMM(V) BOOST_PREDEF_MAKE_DATE((V)/100,(V)%100,1)
+
+#endif
diff --git a/cv_bridge/src/boost/predef/os/android.h b/cv_bridge/src/boost/predef/os/android.h
new file mode 100644
index 0000000..00836e7
--- /dev/null
+++ b/cv_bridge/src/boost/predef/os/android.h
@@ -0,0 +1,45 @@
+/*
+Copyright Rene Rivera 2015
+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)
+*/
+
+#ifndef BOOST_PREDEF_OS_ADROID_H
+#define BOOST_PREDEF_OS_ADROID_H
+
+#include <boost/predef/version_number.h>
+#include <boost/predef/make.h>
+
+/*`
+[heading `BOOST_OS_ANDROID`]
+
+[@http://en.wikipedia.org/wiki/Android_%28operating_system%29 Android] operating system.
+
+[table
+ [[__predef_symbol__] [__predef_version__]]
+
+ [[`__ANDROID__`] [__predef_detection__]]
+ ]
+ */
+
+#define BOOST_OS_ANDROID BOOST_VERSION_NUMBER_NOT_AVAILABLE
+
+#if !defined(BOOST_PREDEF_DETAIL_OS_DETECTED) && ( \
+ defined(__ANDROID__) \
+ )
+# undef BOOST_OS_ANDROID
+# define BOOST_OS_ANDROID BOOST_VERSION_NUMBER_AVAILABLE
+#endif
+
+#if BOOST_OS_ANDROID
+# define BOOST_OS_ANDROID_AVAILABLE
+# include <boost/predef/detail/os_detected.h>
+#endif
+
+#define BOOST_OS_ANDROID_NAME "Android"
+
+#endif
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_OS_ANDROID,BOOST_OS_ANDROID_NAME)
diff --git a/cv_bridge/src/boost/predef/os/bsd.h b/cv_bridge/src/boost/predef/os/bsd.h
new file mode 100644
index 0000000..fad9aed
--- /dev/null
+++ b/cv_bridge/src/boost/predef/os/bsd.h
@@ -0,0 +1,103 @@
+/*
+Copyright Rene Rivera 2008-2015
+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)
+*/
+
+#ifndef BOOST_PREDEF_OS_BSD_H
+#define BOOST_PREDEF_OS_BSD_H
+
+/* Special case: OSX will define BSD predefs if the sys/param.h
+ * header is included. We can guard against that, but only if we
+ * detect OSX first. Hence we will force include OSX detection
+ * before doing any BSD detection.
+ */
+#include <boost/predef/os/macos.h>
+
+#include <boost/predef/version_number.h>
+#include <boost/predef/make.h>
+
+/*`
+[heading `BOOST_OS_BSD`]
+
+[@http://en.wikipedia.org/wiki/Berkeley_Software_Distribution BSD] operating system.
+
+BSD has various branch operating systems possible and each detected
+individually. This detects the following variations and sets a specific
+version number macro to match:
+
+* `BOOST_OS_BSD_DRAGONFLY` [@http://en.wikipedia.org/wiki/DragonFly_BSD DragonFly BSD]
+* `BOOST_OS_BSD_FREE` [@http://en.wikipedia.org/wiki/Freebsd FreeBSD]
+* `BOOST_OS_BSD_BSDI` [@http://en.wikipedia.org/wiki/BSD/OS BSDi BSD/OS]
+* `BOOST_OS_BSD_NET` [@http://en.wikipedia.org/wiki/Netbsd NetBSD]
+* `BOOST_OS_BSD_OPEN` [@http://en.wikipedia.org/wiki/Openbsd OpenBSD]
+
+[note The general `BOOST_OS_BSD` is set in all cases to indicate some form
+of BSD. If the above variants is detected the corresponding macro is also set.]
+
+[table
+ [[__predef_symbol__] [__predef_version__]]
+
+ [[`BSD`] [__predef_detection__]]
+ [[`_SYSTYPE_BSD`] [__predef_detection__]]
+
+ [[`BSD4_2`] [4.2.0]]
+ [[`BSD4_3`] [4.3.0]]
+ [[`BSD4_4`] [4.4.0]]
+ [[`BSD`] [V.R.0]]
+ ]
+ */
+
+#include <boost/predef/os/bsd/bsdi.h>
+#include <boost/predef/os/bsd/dragonfly.h>
+#include <boost/predef/os/bsd/free.h>
+#include <boost/predef/os/bsd/open.h>
+#include <boost/predef/os/bsd/net.h>
+
+#ifndef BOOST_OS_BSD
+#define BOOST_OS_BSD BOOST_VERSION_NUMBER_NOT_AVAILABLE
+#endif
+
+#if !defined(BOOST_PREDEF_DETAIL_OS_DETECTED) && ( \
+ defined(BSD) || \
+ defined(_SYSTYPE_BSD) \
+ )
+# undef BOOST_OS_BSD
+# include <sys/param.h>
+# if !defined(BOOST_OS_BSD) && defined(BSD4_4)
+# define BOOST_OS_BSD BOOST_VERSION_NUMBER(4,4,0)
+# endif
+# if !defined(BOOST_OS_BSD) && defined(BSD4_3)
+# define BOOST_OS_BSD BOOST_VERSION_NUMBER(4,3,0)
+# endif
+# if !defined(BOOST_OS_BSD) && defined(BSD4_2)
+# define BOOST_OS_BSD BOOST_VERSION_NUMBER(4,2,0)
+# endif
+# if !defined(BOOST_OS_BSD) && defined(BSD)
+# define BOOST_OS_BSD BOOST_PREDEF_MAKE_10_VVRR(BSD)
+# endif
+# if !defined(BOOST_OS_BSD)
+# define BOOST_OS_BSD BOOST_VERSION_NUMBER_AVAILABLE
+# endif
+#endif
+
+#if BOOST_OS_BSD
+# define BOOST_OS_BSD_AVAILABLE
+# include <boost/predef/detail/os_detected.h>
+#endif
+
+#define BOOST_OS_BSD_NAME "BSD"
+
+#else
+
+#include <boost/predef/os/bsd/bsdi.h>
+#include <boost/predef/os/bsd/dragonfly.h>
+#include <boost/predef/os/bsd/free.h>
+#include <boost/predef/os/bsd/open.h>
+#include <boost/predef/os/bsd/net.h>
+
+#endif
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_OS_BSD,BOOST_OS_BSD_NAME)
diff --git a/cv_bridge/src/boost/predef/os/bsd/bsdi.h b/cv_bridge/src/boost/predef/os/bsd/bsdi.h
new file mode 100644
index 0000000..afdcd3e
--- /dev/null
+++ b/cv_bridge/src/boost/predef/os/bsd/bsdi.h
@@ -0,0 +1,48 @@
+/*
+Copyright Rene Rivera 2012-2015
+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)
+*/
+
+#ifndef BOOST_PREDEF_OS_BSD_BSDI_H
+#define BOOST_PREDEF_OS_BSD_BSDI_H
+
+#include <boost/predef/os/bsd.h>
+
+/*`
+[heading `BOOST_OS_BSD_BSDI`]
+
+[@http://en.wikipedia.org/wiki/BSD/OS BSDi BSD/OS] operating system.
+
+[table
+ [[__predef_symbol__] [__predef_version__]]
+
+ [[`__bsdi__`] [__predef_detection__]]
+ ]
+ */
+
+#define BOOST_OS_BSD_BSDI BOOST_VERSION_NUMBER_NOT_AVAILABLE
+
+#if !defined(BOOST_PREDEF_DETAIL_OS_DETECTED) && ( \
+ defined(__bsdi__) \
+ )
+# ifndef BOOST_OS_BSD_AVAILABLE
+# define BOOST_OS_BSD BOOST_VERSION_NUMBER_AVAILABLE
+# define BOOST_OS_BSD_AVAILABLE
+# endif
+# undef BOOST_OS_BSD_BSDI
+# define BOOST_OS_BSD_BSDI BOOST_VERSION_NUMBER_AVAILABLE
+#endif
+
+#if BOOST_OS_BSD_BSDI
+# define BOOST_OS_BSD_BSDI_AVAILABLE
+# include <boost/predef/detail/os_detected.h>
+#endif
+
+#define BOOST_OS_BSD_BSDI_NAME "BSDi BSD/OS"
+
+#endif
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_OS_BSD_BSDI,BOOST_OS_BSD_BSDI_NAME)
diff --git a/cv_bridge/src/boost/predef/os/bsd/dragonfly.h b/cv_bridge/src/boost/predef/os/bsd/dragonfly.h
new file mode 100644
index 0000000..1d07579
--- /dev/null
+++ b/cv_bridge/src/boost/predef/os/bsd/dragonfly.h
@@ -0,0 +1,50 @@
+/*
+Copyright Rene Rivera 2012-2015
+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)
+*/
+
+#ifndef BOOST_PREDEF_OS_BSD_DRAGONFLY_H
+#define BOOST_PREDEF_OS_BSD_DRAGONFLY_H
+
+#include <boost/predef/os/bsd.h>
+
+/*`
+[heading `BOOST_OS_BSD_DRAGONFLY`]
+
+[@http://en.wikipedia.org/wiki/DragonFly_BSD DragonFly BSD] operating system.
+
+[table
+ [[__predef_symbol__] [__predef_version__]]
+
+ [[`__DragonFly__`] [__predef_detection__]]
+ ]
+ */
+
+#define BOOST_OS_BSD_DRAGONFLY BOOST_VERSION_NUMBER_NOT_AVAILABLE
+
+#if !defined(BOOST_PREDEF_DETAIL_OS_DETECTED) && ( \
+ defined(__DragonFly__) \
+ )
+# ifndef BOOST_OS_BSD_AVAILABLE
+# define BOOST_OS_BSD BOOST_VERSION_NUMBER_AVAILABLE
+# define BOOST_OS_BSD_AVAILABLE
+# endif
+# undef BOOST_OS_BSD_DRAGONFLY
+# if defined(__DragonFly__)
+# define BOOST_OS_DRAGONFLY_BSD BOOST_VERSION_NUMBER_AVAILABLE
+# endif
+#endif
+
+#if BOOST_OS_BSD_DRAGONFLY
+# define BOOST_OS_BSD_DRAGONFLY_AVAILABLE
+# include <boost/predef/detail/os_detected.h>
+#endif
+
+#define BOOST_OS_BSD_DRAGONFLY_NAME "DragonFly BSD"
+
+#endif
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_OS_BSD_DRAGONFLY,BOOST_OS_BSD_DRAGONFLY_NAME)
diff --git a/cv_bridge/src/boost/predef/os/bsd/free.h b/cv_bridge/src/boost/predef/os/bsd/free.h
new file mode 100644
index 0000000..248011a
--- /dev/null
+++ b/cv_bridge/src/boost/predef/os/bsd/free.h
@@ -0,0 +1,60 @@
+/*
+Copyright Rene Rivera 2012-2015
+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)
+*/
+
+#ifndef BOOST_PREDEF_OS_BSD_FREE_H
+#define BOOST_PREDEF_OS_BSD_FREE_H
+
+#include <boost/predef/os/bsd.h>
+
+/*`
+[heading `BOOST_OS_BSD_FREE`]
+
+[@http://en.wikipedia.org/wiki/Freebsd FreeBSD] operating system.
+
+[table
+ [[__predef_symbol__] [__predef_version__]]
+
+ [[`__FreeBSD__`] [__predef_detection__]]
+
+ [[`__FreeBSD_version`] [V.R.P]]
+ ]
+ */
+
+#define BOOST_OS_BSD_FREE BOOST_VERSION_NUMBER_NOT_AVAILABLE
+
+#if !defined(BOOST_PREDEF_DETAIL_OS_DETECTED) && ( \
+ defined(__FreeBSD__) \
+ )
+# ifndef BOOST_OS_BSD_AVAILABLE
+# define BOOST_OS_BSD BOOST_VERSION_NUMBER_AVAILABLE
+# define BOOST_OS_BSD_AVAILABLE
+# endif
+# undef BOOST_OS_BSD_FREE
+# if defined(__FreeBSD_version)
+# if __FreeBSD_version < 500000
+# define BOOST_OS_BSD_FREE \
+ BOOST_PREDEF_MAKE_10_VRP000(__FreeBSD_version)
+# else
+# define BOOST_OS_BSD_FREE \
+ BOOST_PREDEF_MAKE_10_VRR000(__FreeBSD_version)
+# endif
+# else
+# define BOOST_OS_BSD_FREE BOOST_VERSION_NUMBER_AVAILABLE
+# endif
+#endif
+
+#if BOOST_OS_BSD_FREE
+# define BOOST_OS_BSD_FREE_AVAILABLE
+# include <boost/predef/detail/os_detected.h>
+#endif
+
+#define BOOST_OS_BSD_FREE_NAME "Free BSD"
+
+#endif
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_OS_BSD_FREE,BOOST_OS_BSD_FREE_NAME)
diff --git a/cv_bridge/src/boost/predef/os/bsd/net.h b/cv_bridge/src/boost/predef/os/bsd/net.h
new file mode 100644
index 0000000..387cbde
--- /dev/null
+++ b/cv_bridge/src/boost/predef/os/bsd/net.h
@@ -0,0 +1,84 @@
+/*
+Copyright Rene Rivera 2012-2015
+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)
+*/
+
+#ifndef BOOST_PREDEF_OS_BSD_NET_H
+#define BOOST_PREDEF_OS_BSD_NET_H
+
+#include <boost/predef/os/bsd.h>
+
+/*`
+[heading `BOOST_OS_BSD_NET`]
+
+[@http://en.wikipedia.org/wiki/Netbsd NetBSD] operating system.
+
+[table
+ [[__predef_symbol__] [__predef_version__]]
+
+ [[`__NETBSD__`] [__predef_detection__]]
+ [[`__NetBSD__`] [__predef_detection__]]
+
+ [[`__NETBSD_version`] [V.R.P]]
+ [[`NetBSD0_8`] [0.8.0]]
+ [[`NetBSD0_9`] [0.9.0]]
+ [[`NetBSD1_0`] [1.0.0]]
+ [[`__NetBSD_Version`] [V.R.P]]
+ ]
+ */
+
+#define BOOST_OS_BSD_NET BOOST_VERSION_NUMBER_NOT_AVAILABLE
+
+#if !defined(BOOST_PREDEF_DETAIL_OS_DETECTED) && ( \
+ defined(__NETBSD__) || defined(__NetBSD__) \
+ )
+# ifndef BOOST_OS_BSD_AVAILABLE
+# define BOOST_OS_BSD BOOST_VERSION_NUMBER_AVAILABLE
+# define BOOST_OS_BSD_AVAILABLE
+# endif
+# undef BOOST_OS_BSD_NET
+# if defined(__NETBSD__)
+# if defined(__NETBSD_version)
+# if __NETBSD_version < 500000
+# define BOOST_OS_BSD_NET \
+ BOOST_PREDEF_MAKE_10_VRP000(__NETBSD_version)
+# else
+# define BOOST_OS_BSD_NET \
+ BOOST_PREDEF_MAKE_10_VRR000(__NETBSD_version)
+# endif
+# else
+# define BOOST_OS_BSD_NET BOOST_VERSION_NUMBER_AVAILABLE
+# endif
+# elif defined(__NetBSD__)
+# if !defined(BOOST_OS_BSD_NET) && defined(NetBSD0_8)
+# define BOOST_OS_BSD_NET BOOST_VERSION_NUMBER(0,8,0)
+# endif
+# if !defined(BOOST_OS_BSD_NET) && defined(NetBSD0_9)
+# define BOOST_OS_BSD_NET BOOST_VERSION_NUMBER(0,9,0)
+# endif
+# if !defined(BOOST_OS_BSD_NET) && defined(NetBSD1_0)
+# define BOOST_OS_BSD_NET BOOST_VERSION_NUMBER(1,0,0)
+# endif
+# if !defined(BOOST_OS_BSD_NET) && defined(__NetBSD_Version)
+# define BOOST_OS_BSD_NET \
+ BOOST_PREDEF_MAKE_10_VVRR00PP00(__NetBSD_Version)
+# endif
+# if !defined(BOOST_OS_BSD_NET)
+# define BOOST_OS_BSD_NET BOOST_VERSION_NUMBER_AVAILABLE
+# endif
+# endif
+#endif
+
+#if BOOST_OS_BSD_NET
+# define BOOST_OS_BSD_NET_AVAILABLE
+# include <boost/predef/detail/os_detected.h>
+#endif
+
+#define BOOST_OS_BSD_NET_NAME "DragonFly BSD"
+
+#endif
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_OS_BSD_NET,BOOST_OS_BSD_NET_NAME)
diff --git a/cv_bridge/src/boost/predef/os/bsd/open.h b/cv_bridge/src/boost/predef/os/bsd/open.h
new file mode 100644
index 0000000..423103a
--- /dev/null
+++ b/cv_bridge/src/boost/predef/os/bsd/open.h
@@ -0,0 +1,171 @@
+/*
+Copyright Rene Rivera 2012-2015
+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)
+*/
+
+#ifndef BOOST_PREDEF_OS_BSD_OPEN_H
+#define BOOST_PREDEF_OS_BSD_OPEN_H
+
+#include <boost/predef/os/bsd.h>
+
+/*`
+[heading `BOOST_OS_BSD_OPEN`]
+
+[@http://en.wikipedia.org/wiki/Openbsd OpenBSD] operating system.
+
+[table
+ [[__predef_symbol__] [__predef_version__]]
+
+ [[`__OpenBSD__`] [__predef_detection__]]
+
+ [[`OpenBSD2_0`] [2.0.0]]
+ [[`OpenBSD2_1`] [2.1.0]]
+ [[`OpenBSD2_2`] [2.2.0]]
+ [[`OpenBSD2_3`] [2.3.0]]
+ [[`OpenBSD2_4`] [2.4.0]]
+ [[`OpenBSD2_5`] [2.5.0]]
+ [[`OpenBSD2_6`] [2.6.0]]
+ [[`OpenBSD2_7`] [2.7.0]]
+ [[`OpenBSD2_8`] [2.8.0]]
+ [[`OpenBSD2_9`] [2.9.0]]
+ [[`OpenBSD3_0`] [3.0.0]]
+ [[`OpenBSD3_1`] [3.1.0]]
+ [[`OpenBSD3_2`] [3.2.0]]
+ [[`OpenBSD3_3`] [3.3.0]]
+ [[`OpenBSD3_4`] [3.4.0]]
+ [[`OpenBSD3_5`] [3.5.0]]
+ [[`OpenBSD3_6`] [3.6.0]]
+ [[`OpenBSD3_7`] [3.7.0]]
+ [[`OpenBSD3_8`] [3.8.0]]
+ [[`OpenBSD3_9`] [3.9.0]]
+ [[`OpenBSD4_0`] [4.0.0]]
+ [[`OpenBSD4_1`] [4.1.0]]
+ [[`OpenBSD4_2`] [4.2.0]]
+ [[`OpenBSD4_3`] [4.3.0]]
+ [[`OpenBSD4_4`] [4.4.0]]
+ [[`OpenBSD4_5`] [4.5.0]]
+ [[`OpenBSD4_6`] [4.6.0]]
+ [[`OpenBSD4_7`] [4.7.0]]
+ [[`OpenBSD4_8`] [4.8.0]]
+ [[`OpenBSD4_9`] [4.9.0]]
+ ]
+ */
+
+#define BOOST_OS_BSD_OPEN BOOST_VERSION_NUMBER_NOT_AVAILABLE
+
+#if !defined(BOOST_PREDEF_DETAIL_OS_DETECTED) && ( \
+ defined(__OpenBSD__) \
+ )
+# ifndef BOOST_OS_BSD_AVAILABLE
+# define BOOST_OS_BSD BOOST_VERSION_NUMBER_AVAILABLE
+# define BOOST_OS_BSD_AVAILABLE
+# endif
+# undef BOOST_OS_BSD_OPEN
+# if !defined(BOOST_OS_BSD_OPEN) && defined(OpenBSD2_0)
+# define BOOST_OS_BSD_OPEN BOOST_VERSION_NUMBER(2,0,0)
+# endif
+# if !defined(BOOST_OS_BSD_OPEN) && defined(OpenBSD2_1)
+# define BOOST_OS_BSD_OPEN BOOST_VERSION_NUMBER(2,1,0)
+# endif
+# if !defined(BOOST_OS_BSD_OPEN) && defined(OpenBSD2_2)
+# define BOOST_OS_BSD_OPEN BOOST_VERSION_NUMBER(2,2,0)
+# endif
+# if !defined(BOOST_OS_BSD_OPEN) && defined(OpenBSD2_3)
+# define BOOST_OS_BSD_OPEN BOOST_VERSION_NUMBER(2,3,0)
+# endif
+# if !defined(BOOST_OS_BSD_OPEN) && defined(OpenBSD2_4)
+# define BOOST_OS_BSD_OPEN BOOST_VERSION_NUMBER(2,4,0)
+# endif
+# if !defined(BOOST_OS_BSD_OPEN) && defined(OpenBSD2_5)
+# define BOOST_OS_BSD_OPEN BOOST_VERSION_NUMBER(2,5,0)
+# endif
+# if !defined(BOOST_OS_BSD_OPEN) && defined(OpenBSD2_6)
+# define BOOST_OS_BSD_OPEN BOOST_VERSION_NUMBER(2,6,0)
+# endif
+# if !defined(BOOST_OS_BSD_OPEN) && defined(OpenBSD2_7)
+# define BOOST_OS_BSD_OPEN BOOST_VERSION_NUMBER(2,7,0)
+# endif
+# if !defined(BOOST_OS_BSD_OPEN) && defined(OpenBSD2_8)
+# define BOOST_OS_BSD_OPEN BOOST_VERSION_NUMBER(2,8,0)
+# endif
+# if !defined(BOOST_OS_BSD_OPEN) && defined(OpenBSD2_9)
+# define BOOST_OS_BSD_OPEN BOOST_VERSION_NUMBER(2,9,0)
+# endif
+# if !defined(BOOST_OS_BSD_OPEN) && defined(OpenBSD3_0)
+# define BOOST_OS_BSD_OPEN BOOST_VERSION_NUMBER(3,0,0)
+# endif
+# if !defined(BOOST_OS_BSD_OPEN) && defined(OpenBSD3_1)
+# define BOOST_OS_BSD_OPEN BOOST_VERSION_NUMBER(3,1,0)
+# endif
+# if !defined(BOOST_OS_BSD_OPEN) && defined(OpenBSD3_2)
+# define BOOST_OS_BSD_OPEN BOOST_VERSION_NUMBER(3,2,0)
+# endif
+# if !defined(BOOST_OS_BSD_OPEN) && defined(OpenBSD3_3)
+# define BOOST_OS_BSD_OPEN BOOST_VERSION_NUMBER(3,3,0)
+# endif
+# if !defined(BOOST_OS_BSD_OPEN) && defined(OpenBSD3_4)
+# define BOOST_OS_BSD_OPEN BOOST_VERSION_NUMBER(3,4,0)
+# endif
+# if !defined(BOOST_OS_BSD_OPEN) && defined(OpenBSD3_5)
+# define BOOST_OS_BSD_OPEN BOOST_VERSION_NUMBER(3,5,0)
+# endif
+# if !defined(BOOST_OS_BSD_OPEN) && defined(OpenBSD3_6)
+# define BOOST_OS_BSD_OPEN BOOST_VERSION_NUMBER(3,6,0)
+# endif
+# if !defined(BOOST_OS_BSD_OPEN) && defined(OpenBSD3_7)
+# define BOOST_OS_BSD_OPEN BOOST_VERSION_NUMBER(3,7,0)
+# endif
+# if !defined(BOOST_OS_BSD_OPEN) && defined(OpenBSD3_8)
+# define BOOST_OS_BSD_OPEN BOOST_VERSION_NUMBER(3,8,0)
+# endif
+# if !defined(BOOST_OS_BSD_OPEN) && defined(OpenBSD3_9)
+# define BOOST_OS_BSD_OPEN BOOST_VERSION_NUMBER(3,9,0)
+# endif
+# if !defined(BOOST_OS_BSD_OPEN) && defined(OpenBSD4_0)
+# define BOOST_OS_BSD_OPEN BOOST_VERSION_NUMBER(4,0,0)
+# endif
+# if !defined(BOOST_OS_BSD_OPEN) && defined(OpenBSD4_1)
+# define BOOST_OS_BSD_OPEN BOOST_VERSION_NUMBER(4,1,0)
+# endif
+# if !defined(BOOST_OS_BSD_OPEN) && defined(OpenBSD4_2)
+# define BOOST_OS_BSD_OPEN BOOST_VERSION_NUMBER(4,2,0)
+# endif
+# if !defined(BOOST_OS_BSD_OPEN) && defined(OpenBSD4_3)
+# define BOOST_OS_BSD_OPEN BOOST_VERSION_NUMBER(4,3,0)
+# endif
+# if !defined(BOOST_OS_BSD_OPEN) && defined(OpenBSD4_4)
+# define BOOST_OS_BSD_OPEN BOOST_VERSION_NUMBER(4,4,0)
+# endif
+# if !defined(BOOST_OS_BSD_OPEN) && defined(OpenBSD4_5)
+# define BOOST_OS_BSD_OPEN BOOST_VERSION_NUMBER(4,5,0)
+# endif
+# if !defined(BOOST_OS_BSD_OPEN) && defined(OpenBSD4_6)
+# define BOOST_OS_BSD_OPEN BOOST_VERSION_NUMBER(4,6,0)
+# endif
+# if !defined(BOOST_OS_BSD_OPEN) && defined(OpenBSD4_7)
+# define BOOST_OS_BSD_OPEN BOOST_VERSION_NUMBER(4,7,0)
+# endif
+# if !defined(BOOST_OS_BSD_OPEN) && defined(OpenBSD4_8)
+# define BOOST_OS_BSD_OPEN BOOST_VERSION_NUMBER(4,8,0)
+# endif
+# if !defined(BOOST_OS_BSD_OPEN) && defined(OpenBSD4_9)
+# define BOOST_OS_BSD_OPEN BOOST_VERSION_NUMBER(4,9,0)
+# endif
+# if !defined(BOOST_OS_BSD_OPEN)
+# define BOOST_OS_BSD_OPEN BOOST_VERSION_NUMBER_AVAILABLE
+# endif
+#endif
+
+#if BOOST_OS_BSD_OPEN
+# define BOOST_OS_BSD_OPEN_AVAILABLE
+# include <boost/predef/detail/os_detected.h>
+#endif
+
+#define BOOST_OS_BSD_OPEN_NAME "OpenBSD"
+
+#endif
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_OS_BSD_OPEN,BOOST_OS_BSD_OPEN_NAME)
diff --git a/cv_bridge/src/boost/predef/os/ios.h b/cv_bridge/src/boost/predef/os/ios.h
new file mode 100644
index 0000000..f853815
--- /dev/null
+++ b/cv_bridge/src/boost/predef/os/ios.h
@@ -0,0 +1,51 @@
+/*
+Copyright Franz Detro 2014
+Copyright Rene Rivera 2015
+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)
+*/
+
+#ifndef BOOST_PREDEF_OS_IOS_H
+#define BOOST_PREDEF_OS_IOS_H
+
+#include <boost/predef/version_number.h>
+#include <boost/predef/make.h>
+
+/*`
+[heading `BOOST_OS_IOS`]
+
+[@http://en.wikipedia.org/wiki/iOS iOS] operating system.
+
+[table
+ [[__predef_symbol__] [__predef_version__]]
+
+ [[`__APPLE__`] [__predef_detection__]]
+ [[`__MACH__`] [__predef_detection__]]
+ [[`__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__`] [__predef_detection__]]
+
+ [[`__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__`] [__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__*1000]]
+ ]
+ */
+
+#define BOOST_OS_IOS BOOST_VERSION_NUMBER_NOT_AVAILABLE
+
+#if !defined(BOOST_PREDEF_DETAIL_OS_DETECTED) && ( \
+ defined(__APPLE__) && defined(__MACH__) && \
+ defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) \
+ )
+# undef BOOST_OS_IOS
+# define BOOST_OS_IOS (__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__*1000)
+#endif
+
+#if BOOST_OS_IOS
+# define BOOST_OS_IOS_AVAILABLE
+# include <boost/predef/detail/os_detected.h>
+#endif
+
+#define BOOST_OS_IOS_NAME "iOS"
+
+#endif
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_OS_IOS,BOOST_OS_IOS_NAME)
diff --git a/cv_bridge/src/boost/predef/os/macos.h b/cv_bridge/src/boost/predef/os/macos.h
new file mode 100644
index 0000000..4afb30d
--- /dev/null
+++ b/cv_bridge/src/boost/predef/os/macos.h
@@ -0,0 +1,65 @@
+/*
+Copyright Rene Rivera 2008-2015
+Copyright Franz Detro 2014
+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)
+*/
+
+#ifndef BOOST_PREDEF_OS_MACOS_H
+#define BOOST_PREDEF_OS_MACOS_H
+
+/* Special case: iOS will define the same predefs as MacOS, and additionally
+ '__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__'. We can guard against that,
+ but only if we detect iOS first. Hence we will force include iOS detection
+ * before doing any MacOS detection.
+ */
+#include <boost/predef/os/ios.h>
+
+#include <boost/predef/version_number.h>
+#include <boost/predef/make.h>
+
+/*`
+[heading `BOOST_OS_MACOS`]
+
+[@http://en.wikipedia.org/wiki/Mac_OS Mac OS] operating system.
+
+[table
+ [[__predef_symbol__] [__predef_version__]]
+
+ [[`macintosh`] [__predef_detection__]]
+ [[`Macintosh`] [__predef_detection__]]
+ [[`__APPLE__`] [__predef_detection__]]
+ [[`__MACH__`] [__predef_detection__]]
+
+ [[`__APPLE__`, `__MACH__`] [10.0.0]]
+ [[ /otherwise/ ] [9.0.0]]
+ ]
+ */
+
+#define BOOST_OS_MACOS BOOST_VERSION_NUMBER_NOT_AVAILABLE
+
+#if !defined(BOOST_PREDEF_DETAIL_OS_DETECTED) && ( \
+ defined(macintosh) || defined(Macintosh) || \
+ (defined(__APPLE__) && defined(__MACH__)) \
+ )
+# undef BOOST_OS_MACOS
+# if !defined(BOOST_OS_MACOS) && defined(__APPLE__) && defined(__MACH__)
+# define BOOST_OS_MACOS BOOST_VERSION_NUMBER(10,0,0)
+# endif
+# if !defined(BOOST_OS_MACOS)
+# define BOOST_OS_MACOS BOOST_VERSION_NUMBER(9,0,0)
+# endif
+#endif
+
+#if BOOST_OS_MACOS
+# define BOOST_OS_MACOS_AVAILABLE
+# include <boost/predef/detail/os_detected.h>
+#endif
+
+#define BOOST_OS_MACOS_NAME "Mac OS"
+
+#endif
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_OS_MACOS,BOOST_OS_MACOS_NAME)
diff --git a/cv_bridge/src/boost/predef/other/endian.h b/cv_bridge/src/boost/predef/other/endian.h
new file mode 100644
index 0000000..6d1f43f
--- /dev/null
+++ b/cv_bridge/src/boost/predef/other/endian.h
@@ -0,0 +1,204 @@
+/*
+Copyright Rene Rivera 2013-2015
+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)
+*/
+
+#ifndef BOOST_PREDEF_ENDIAN_H
+#define BOOST_PREDEF_ENDIAN_H
+
+#include <boost/predef/version_number.h>
+#include <boost/predef/make.h>
+#include <boost/predef/library/c/gnu.h>
+#include <boost/predef/os/macos.h>
+#include <boost/predef/os/bsd.h>
+#include <boost/predef/os/android.h>
+
+/*`
+[heading `BOOST_ENDIAN_*`]
+
+Detection of endian memory ordering. There are four defined macros
+in this header that define the various generally possible endian
+memory orderings:
+
+* `BOOST_ENDIAN_BIG_BYTE`, byte-swapped big-endian.
+* `BOOST_ENDIAN_BIG_WORD`, word-swapped big-endian.
+* `BOOST_ENDIAN_LITTLE_BYTE`, byte-swapped little-endian.
+* `BOOST_ENDIAN_LITTLE_WORD`, word-swapped little-endian.
+
+The detection is conservative in that it only identifies endianness
+that it knows for certain. In particular bi-endianness is not
+indicated as is it not practically possible to determine the
+endianness from anything but an operating system provided
+header. And the currently known headers do not define that
+programatic bi-endianness is available.
+
+This implementation is a compilation of various publicly available
+information and acquired knowledge:
+
+# The indispensable documentation of "Pre-defined Compiler Macros"
+ [@http://sourceforge.net/p/predef/wiki/Endianness Endianness].
+# The various endian specifications available in the
+ [@http://wikipedia.org/ Wikipedia] computer architecture pages.
+# Generally available searches for headers that define endianness.
+ */
+
+#define BOOST_ENDIAN_BIG_BYTE BOOST_VERSION_NUMBER_NOT_AVAILABLE
+#define BOOST_ENDIAN_BIG_WORD BOOST_VERSION_NUMBER_NOT_AVAILABLE
+#define BOOST_ENDIAN_LITTLE_BYTE BOOST_VERSION_NUMBER_NOT_AVAILABLE
+#define BOOST_ENDIAN_LITTLE_WORD BOOST_VERSION_NUMBER_NOT_AVAILABLE
+
+/* GNU libc provides a header defining __BYTE_ORDER, or _BYTE_ORDER.
+ * And some OSs provide some for of endian header also.
+ */
+#if !BOOST_ENDIAN_BIG_BYTE && !BOOST_ENDIAN_BIG_WORD && \
+ !BOOST_ENDIAN_LITTLE_BYTE && !BOOST_ENDIAN_LITTLE_WORD
+# if BOOST_LIB_C_GNU || BOOST_OS_ANDROID
+# include <endian.h>
+# else
+# if BOOST_OS_MACOS
+# include <machine/endian.h>
+# else
+# if BOOST_OS_BSD
+# if BOOST_OS_BSD_OPEN
+# include <machine/endian.h>
+# else
+# include <sys/endian.h>
+# endif
+# endif
+# endif
+# endif
+# if defined(__BYTE_ORDER)
+# if defined(__BIG_ENDIAN) && (__BYTE_ORDER == __BIG_ENDIAN)
+# undef BOOST_ENDIAN_BIG_BYTE
+# define BOOST_ENDIAN_BIG_BYTE BOOST_VERSION_NUMBER_AVAILABLE
+# endif
+# if defined(__LITTLE_ENDIAN) && (__BYTE_ORDER == __LITTLE_ENDIAN)
+# undef BOOST_ENDIAN_LITTLE_BYTE
+# define BOOST_ENDIAN_LITTLE_BYTE BOOST_VERSION_NUMBER_AVAILABLE
+# endif
+# if defined(__PDP_ENDIAN) && (__BYTE_ORDER == __PDP_ENDIAN)
+# undef BOOST_ENDIAN_LITTLE_WORD
+# define BOOST_ENDIAN_LITTLE_WORD BOOST_VERSION_NUMBER_AVAILABLE
+# endif
+# endif
+# if !defined(__BYTE_ORDER) && defined(_BYTE_ORDER)
+# if defined(_BIG_ENDIAN) && (_BYTE_ORDER == _BIG_ENDIAN)
+# undef BOOST_ENDIAN_BIG_BYTE
+# define BOOST_ENDIAN_BIG_BYTE BOOST_VERSION_NUMBER_AVAILABLE
+# endif
+# if defined(_LITTLE_ENDIAN) && (_BYTE_ORDER == _LITTLE_ENDIAN)
+# undef BOOST_ENDIAN_LITTLE_BYTE
+# define BOOST_ENDIAN_LITTLE_BYTE BOOST_VERSION_NUMBER_AVAILABLE
+# endif
+# if defined(_PDP_ENDIAN) && (_BYTE_ORDER == _PDP_ENDIAN)
+# undef BOOST_ENDIAN_LITTLE_WORD
+# define BOOST_ENDIAN_LITTLE_WORD BOOST_VERSION_NUMBER_AVAILABLE
+# endif
+# endif
+#endif
+
+/* Built-in byte-swpped big-endian macros.
+ */
+#if !BOOST_ENDIAN_BIG_BYTE && !BOOST_ENDIAN_BIG_WORD && \
+ !BOOST_ENDIAN_LITTLE_BYTE && !BOOST_ENDIAN_LITTLE_WORD
+# if (defined(__BIG_ENDIAN__) && !defined(__LITTLE_ENDIAN__)) || \
+ (defined(_BIG_ENDIAN) && !defined(_LITTLE_ENDIAN)) || \
+ defined(__ARMEB__) || \
+ defined(__THUMBEB__) || \
+ defined(__AARCH64EB__) || \
+ defined(_MIPSEB) || \
+ defined(__MIPSEB) || \
+ defined(__MIPSEB__)
+# undef BOOST_ENDIAN_BIG_BYTE
+# define BOOST_ENDIAN_BIG_BYTE BOOST_VERSION_NUMBER_AVAILABLE
+# endif
+#endif
+
+/* Built-in byte-swpped little-endian macros.
+ */
+#if !BOOST_ENDIAN_BIG_BYTE && !BOOST_ENDIAN_BIG_WORD && \
+ !BOOST_ENDIAN_LITTLE_BYTE && !BOOST_ENDIAN_LITTLE_WORD
+# if (defined(__LITTLE_ENDIAN__) && !defined(__BIG_ENDIAN__)) || \
+ (defined(_LITTLE_ENDIAN) && !defined(_BIG_ENDIAN)) || \
+ defined(__ARMEL__) || \
+ defined(__THUMBEL__) || \
+ defined(__AARCH64EL__) || \
+ defined(_MIPSEL) || \
+ defined(__MIPSEL) || \
+ defined(__MIPSEL__)
+# undef BOOST_ENDIAN_LITTLE_BYTE
+# define BOOST_ENDIAN_LITTLE_BYTE BOOST_VERSION_NUMBER_AVAILABLE
+# endif
+#endif
+
+/* Some architectures are strictly one endianess (as opposed
+ * the current common bi-endianess).
+ */
+#if !BOOST_ENDIAN_BIG_BYTE && !BOOST_ENDIAN_BIG_WORD && \
+ !BOOST_ENDIAN_LITTLE_BYTE && !BOOST_ENDIAN_LITTLE_WORD
+# include <boost/predef/architecture.h>
+# if BOOST_ARCH_M68K || \
+ BOOST_ARCH_PARISC || \
+ BOOST_ARCH_SPARC || \
+ BOOST_ARCH_SYS370 || \
+ BOOST_ARCH_SYS390 || \
+ BOOST_ARCH_Z
+# undef BOOST_ENDIAN_BIG_BYTE
+# define BOOST_ENDIAN_BIG_BYTE BOOST_VERSION_NUMBER_AVAILABLE
+# endif
+# if BOOST_ARCH_AMD64 || \
+ BOOST_ARCH_IA64 || \
+ BOOST_ARCH_X86 || \
+ BOOST_ARCH_BLACKFIN
+# undef BOOST_ENDIAN_LITTLE_BYTE
+# define BOOST_ENDIAN_LITTLE_BYTE BOOST_VERSION_NUMBER_AVAILABLE
+# endif
+#endif
+
+/* Windows on ARM, if not otherwise detected/specified, is always
+ * byte-swaped little-endian.
+ */
+#if !BOOST_ENDIAN_BIG_BYTE && !BOOST_ENDIAN_BIG_WORD && \
+ !BOOST_ENDIAN_LITTLE_BYTE && !BOOST_ENDIAN_LITTLE_WORD
+# if BOOST_ARCH_ARM
+# include <boost/predef/os/windows.h>
+# if BOOST_OS_WINDOWS
+# undef BOOST_ENDIAN_LITTLE_BYTE
+# define BOOST_ENDIAN_LITTLE_BYTE BOOST_VERSION_NUMBER_AVAILABLE
+# endif
+# endif
+#endif
+
+#if BOOST_ENDIAN_BIG_BYTE
+# define BOOST_ENDIAN_BIG_BYTE_AVAILABLE
+#endif
+#if BOOST_ENDIAN_BIG_WORD
+# define BOOST_ENDIAN_BIG_WORD_BYTE_AVAILABLE
+#endif
+#if BOOST_ENDIAN_LITTLE_BYTE
+# define BOOST_ENDIAN_LITTLE_BYTE_AVAILABLE
+#endif
+#if BOOST_ENDIAN_LITTLE_WORD
+# define BOOST_ENDIAN_LITTLE_WORD_BYTE_AVAILABLE
+#endif
+
+#define BOOST_ENDIAN_BIG_BYTE_NAME "Byte-Swapped Big-Endian"
+#define BOOST_ENDIAN_BIG_WORD_NAME "Word-Swapped Big-Endian"
+#define BOOST_ENDIAN_LITTLE_BYTE_NAME "Byte-Swapped Little-Endian"
+#define BOOST_ENDIAN_LITTLE_WORD_NAME "Word-Swapped Little-Endian"
+
+#endif
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_ENDIAN_BIG_BYTE,BOOST_ENDIAN_BIG_BYTE_NAME)
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_ENDIAN_BIG_WORD,BOOST_ENDIAN_BIG_WORD_NAME)
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_ENDIAN_LITTLE_BYTE,BOOST_ENDIAN_LITTLE_BYTE_NAME)
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_ENDIAN_LITTLE_WORD,BOOST_ENDIAN_LITTLE_WORD_NAME)
diff --git a/cv_bridge/src/boost/predef/version_number.h b/cv_bridge/src/boost/predef/version_number.h
new file mode 100644
index 0000000..3903a36
--- /dev/null
+++ b/cv_bridge/src/boost/predef/version_number.h
@@ -0,0 +1,53 @@
+/*
+Copyright Rene Rivera 2005, 2008-2013
+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)
+*/
+
+#ifndef BOOST_PREDEF_VERSION_NUMBER_H
+#define BOOST_PREDEF_VERSION_NUMBER_H
+
+/*`
+[heading `BOOST_VERSION_NUMBER`]
+
+``
+BOOST_VERSION_NUMBER(major,minor,patch)
+``
+
+Defines standard version numbers, with these properties:
+
+* Decimal base whole numbers in the range \[0,1000000000).
+ The number range is designed to allow for a (2,2,5) triplet.
+ Which fits within a 32 bit value.
+* The `major` number can be in the \[0,99\] range.
+* The `minor` number can be in the \[0,99\] range.
+* The `patch` number can be in the \[0,99999\] range.
+* Values can be specified in any base. As the defined value
+ is an constant expression.
+* Value can be directly used in both preprocessor and compiler
+ expressions for comparison to other similarly defined values.
+* The implementation enforces the individual ranges for the
+ major, minor, and patch numbers. And values over the ranges
+ are truncated (modulo).
+
+*/
+#define BOOST_VERSION_NUMBER(major,minor,patch) \
+ ( (((major)%100)*10000000) + (((minor)%100)*100000) + ((patch)%100000) )
+
+#define BOOST_VERSION_NUMBER_MAX \
+ BOOST_VERSION_NUMBER(99,99,99999)
+
+#define BOOST_VERSION_NUMBER_ZERO \
+ BOOST_VERSION_NUMBER(0,0,0)
+
+#define BOOST_VERSION_NUMBER_MIN \
+ BOOST_VERSION_NUMBER(0,0,1)
+
+#define BOOST_VERSION_NUMBER_AVAILABLE \
+ BOOST_VERSION_NUMBER_MIN
+
+#define BOOST_VERSION_NUMBER_NOT_AVAILABLE \
+ BOOST_VERSION_NUMBER_ZERO
+
+#endif
diff --git a/debian/copyright b/debian/copyright
index aba794b..e8c8383 100644
--- a/debian/copyright
+++ b/debian/copyright
@@ -8,6 +8,15 @@ Copyright: 2008, 2009, 2011, 2012, Willow Garage, Inc.
2015, Tal Regev
License: BSD-3-clause
+Files: cv_bridge/src/boost/*
+Copyright: 2008-2015 Rene Rivera
+ 2009-2011,2013,2014 Beman Dawes
+ 2014, Franz Detro
+ 2011-2012, Vicente J. Botet Escriba
+ 2012, Anthony Williams
+ 2012, David Stone
+License: BSL-1.0
+
Files: cv_bridge/src/module.hpp
Copyright: 2014, Open Source Robotics Foundation, Inc
License: Apache-2.0
@@ -100,3 +109,31 @@ License: Apache-2.0
.
A copy of the license should be found on this system in
/usr/share/common-licenses/Apache-2.0
+
+License: BSL-1.0
+ Boost Software License - Version 1.0 - August 17th, 2003
+ .
+ Permission is hereby granted, free of charge, to any person or
+ organization obtaining a copy of the software and accompanying
+ documentation covered by this license (the "Software") to use,
+ reproduce, display, distribute, execute, and transmit the Software,
+ and to prepare derivative works of the Software, and to permit
+ third-parties to whom the Software is furnished to do so, all subject
+ to the following:
+ .
+ The copyright notices in the Software and this entire statement,
+ including the above license grant, this restriction and the following
+ disclaimer, must be included in all copies of the Software, in whole
+ or in part, and all derivative works of the Software, unless such
+ copies or derivative works are solely in the form of
+ machine-executable object code generated by a source language
+ processor.
+ .
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE AND
+ NON-INFRINGEMENT. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR ANYONE
+ DISTRIBUTING THE SOFTWARE BE LIABLE FOR ANY DAMAGES OR OTHER
+ LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+ OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE.
\ No newline at end of file
--
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/debian-science/packages/ros/ros-vision-opencv.git
More information about the debian-science-commits
mailing list