[ros-vision-opencv] 01/02: Rebasing and adding a patch to compile in Jessie
Leopold Palomo-Avellaneda
leo at alaxarxa.net
Tue Jun 27 08:13:01 UTC 2017
This is an automated email from the git hooks/post-receive script.
lepalom-guest pushed a commit to branch debian-robotics
in repository ros-vision-opencv.
commit 1fb1bc3d7b8d2adb084542be3362dd2b3d597de1
Author: Leopold Palomo-Avellaneda <leo at alaxarxa.net>
Date: Mon Oct 24 08:45:45 2016 +0200
Rebasing and adding a patch to compile in Jessie
---
debian/patches/0001-Add-CMakeLists.txt.patch | 6 +-
.../0003-Add-boost-files-to-build-in-jessie.patch | 2078 ++++++++++++++++++++
debian/patches/series | 1 +
3 files changed, 2082 insertions(+), 3 deletions(-)
diff --git a/debian/patches/0001-Add-CMakeLists.txt.patch b/debian/patches/0001-Add-CMakeLists.txt.patch
index 7a18f02..9be5c76 100644
--- a/debian/patches/0001-Add-CMakeLists.txt.patch
+++ b/debian/patches/0001-Add-CMakeLists.txt.patch
@@ -3,13 +3,13 @@ Date: Tue, 4 Aug 2015 20:13:40 +0200
Subject: Add CMakeLists.txt
---
- CMakeLists.txt | 7 +++++++
- 1 file changed, 7 insertions(+)
+ CMakeLists.txt | 6 ++++++
+ 1 file changed, 6 insertions(+)
create mode 100644 CMakeLists.txt
diff --git a/CMakeLists.txt b/CMakeLists.txt
new file mode 100644
-index 0000000..ac2897b
+index 0000000..ea6edcf
--- /dev/null
+++ b/CMakeLists.txt
@@ -0,0 +1,6 @@
diff --git a/debian/patches/0003-Add-boost-files-to-build-in-jessie.patch b/debian/patches/0003-Add-boost-files-to-build-in-jessie.patch
new file mode 100644
index 0000000..92fe4d9
--- /dev/null
+++ b/debian/patches/0003-Add-boost-files-to-build-in-jessie.patch
@@ -0,0 +1,2078 @@
+From: Leopold Palomo-Avellaneda <leo at alaxarxa.net>
+Date: Mon, 24 Oct 2016 08:37:40 +0200
+Subject: Add boost files to build in jessie
+
+---
+ 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 +++
+ 21 files changed, 1903 insertions(+)
+ create mode 100644 cv_bridge/src/boost/README
+ create mode 100644 cv_bridge/src/boost/core/scoped_enum.hpp
+ create mode 100644 cv_bridge/src/boost/endian/conversion.hpp
+ create mode 100644 cv_bridge/src/boost/endian/detail/intrinsic.hpp
+ create mode 100644 cv_bridge/src/boost/predef/detail/_cassert.h
+ create mode 100644 cv_bridge/src/boost/predef/detail/endian_compat.h
+ create mode 100644 cv_bridge/src/boost/predef/detail/test.h
+ create mode 100644 cv_bridge/src/boost/predef/library/c/_prefix.h
+ create mode 100644 cv_bridge/src/boost/predef/library/c/gnu.h
+ create mode 100644 cv_bridge/src/boost/predef/make.h
+ create mode 100644 cv_bridge/src/boost/predef/os/android.h
+ create mode 100644 cv_bridge/src/boost/predef/os/bsd.h
+ create mode 100644 cv_bridge/src/boost/predef/os/bsd/bsdi.h
+ create mode 100644 cv_bridge/src/boost/predef/os/bsd/dragonfly.h
+ create mode 100644 cv_bridge/src/boost/predef/os/bsd/free.h
+ create mode 100644 cv_bridge/src/boost/predef/os/bsd/net.h
+ create mode 100644 cv_bridge/src/boost/predef/os/bsd/open.h
+ create mode 100644 cv_bridge/src/boost/predef/os/ios.h
+ create mode 100644 cv_bridge/src/boost/predef/os/macos.h
+ create mode 100644 cv_bridge/src/boost/predef/other/endian.h
+ create mode 100644 cv_bridge/src/boost/predef/version_number.h
+
+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/patches/series b/debian/patches/series
index c0916ef..81a53d8 100644
--- a/debian/patches/series
+++ b/debian/patches/series
@@ -1,2 +1,3 @@
0001-Add-CMakeLists.txt.patch
0002-Add-Debian-specific-SOVERSION.patch
+0003-Add-boost-files-to-build-in-jessie.patch
--
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