diff --git a/CMakeLists.txt b/CMakeLists.txt index 07eca0f7d2..78abf7e247 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -143,6 +143,7 @@ set(REALSENSE_HPP src/core/video.h src/core/options.h src/core/info.h + src/core/extension.h src/archive.h src/concurrency.h @@ -274,6 +275,7 @@ if(WIN32) src/core/motion.h src/core/info.h src/core/options.h + src/core/extension.h ) source_group("Header Files\\Logging" FILES @@ -363,6 +365,8 @@ if(HWM_OVER_XU) add_definitions(-DHWM_OVER_XU) endif() +add_subdirectory(realsense-file) + option(BUILD_SHARED_LIBS "Build shared library" ON) if(BUILD_SHARED_LIBS) add_library(realsense2 SHARED ${REALSENSE_CPP} ${REALSENSE_HPP} ${REALSENSE_DEF}) @@ -372,7 +376,7 @@ endif() set_target_properties(realsense2 PROPERTIES VERSION ${REALSENSE_VERSION_STRING} SOVERSION ${REALSENSE_VERSION_MAJOR}) -target_link_libraries(realsense2 ${LIBUSB1_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT}) +target_link_libraries(realsense2 realsense_file ${LIBUSB1_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT}) list(APPEND librealsense_PKG_LIBS ${CMAKE_THREAD_LIBS_INIT}) add_definitions(-DELPP_THREAD_SAFE) @@ -434,7 +438,7 @@ option(BUILD_PYTHON_BINDINGS "Build Python bindings" OFF) option(BUILD_GRAPHICAL_EXAMPLES "Build graphical examples and tools." ON) if(((BUILD_EXAMPLES AND BUILD_GRAPHICAL_EXAMPLES) OR BUILD_RS400_EXTRAS) AND WIN32) - add_subdirectory(examples/third_party/glfw) + add_subdirectory(third-party/glfw) endif() if(BUILD_EXAMPLES) diff --git a/realsense-file/3rd_party/boost/boost/assert.hpp b/realsense-file/3rd_party/boost/boost/assert.hpp new file mode 100644 index 0000000000..036b97ee95 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/assert.hpp @@ -0,0 +1,78 @@ +// +// boost/assert.hpp - BOOST_ASSERT(expr) +// BOOST_ASSERT_MSG(expr, msg) +// BOOST_VERIFY(expr) +// BOOST_VERIFY_MSG(expr, msg) +// +// Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd. +// Copyright (c) 2007, 2014 Peter Dimov +// Copyright (c) Beman Dawes 2011 +// +// 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 +// +// Note: There are no include guards. This is intentional. +// +// See http://www.boost.org/libs/assert/assert.html for documentation. +// + +// +// Stop inspect complaining about use of 'assert': +// +// boostinspect:naassert_macro +// + +// +// BOOST_ASSERT, BOOST_ASSERT_MSG +// + +#undef BOOST_ASSERT +#undef BOOST_ASSERT_MSG + +#if defined(BOOST_DISABLE_ASSERTS) || ( defined(BOOST_ENABLE_ASSERT_DEBUG_HANDLER) && defined(NDEBUG) ) + +# define BOOST_ASSERT(expr) ((void)0) +# define BOOST_ASSERT_MSG(expr, msg) ((void)0) + +#elif defined(BOOST_ENABLE_ASSERT_HANDLER) || ( defined(BOOST_ENABLE_ASSERT_DEBUG_HANDLER) && !defined(NDEBUG) ) + +#include // for BOOST_LIKELY +#include + +namespace boost +{ + void assertion_failed(char const * expr, char const * function, char const * file, long line); // user defined + void assertion_failed_msg(char const * expr, char const * msg, char const * function, char const * file, long line); // user defined +} // namespace boost + +#define BOOST_ASSERT(expr) (BOOST_LIKELY(!!(expr))? ((void)0): ::boost::assertion_failed(#expr, BOOST_CURRENT_FUNCTION, __FILE__, __LINE__)) +#define BOOST_ASSERT_MSG(expr, msg) (BOOST_LIKELY(!!(expr))? ((void)0): ::boost::assertion_failed_msg(#expr, msg, BOOST_CURRENT_FUNCTION, __FILE__, __LINE__)) + +#else + +# include // .h to support old libraries w/o - effect is the same + +# define BOOST_ASSERT(expr) assert(expr) +# define BOOST_ASSERT_MSG(expr, msg) assert((expr)&&(msg)) + +#endif + +// +// BOOST_VERIFY, BOOST_VERIFY_MSG +// + +#undef BOOST_VERIFY +#undef BOOST_VERIFY_MSG + +#if defined(BOOST_DISABLE_ASSERTS) || ( !defined(BOOST_ENABLE_ASSERT_HANDLER) && defined(NDEBUG) ) + +# define BOOST_VERIFY(expr) ((void)(expr)) +# define BOOST_VERIFY_MSG(expr, msg) ((void)(expr)) + +#else + +# define BOOST_VERIFY(expr) BOOST_ASSERT(expr) +# define BOOST_VERIFY_MSG(expr, msg) BOOST_ASSERT_MSG(expr,msg) + +#endif diff --git a/realsense-file/3rd_party/boost/boost/call_traits.hpp b/realsense-file/3rd_party/boost/boost/call_traits.hpp new file mode 100644 index 0000000000..fe8356a760 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/call_traits.hpp @@ -0,0 +1,20 @@ +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// Use, modification and distribution are subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt). +// +// See http://www.boost.org/libs/utility for most recent version including documentation. + +// See boost/detail/call_traits.hpp +// for full copyright notices. + +#ifndef BOOST_CALL_TRAITS_HPP +#define BOOST_CALL_TRAITS_HPP + +#ifndef BOOST_CONFIG_HPP +#include +#endif + +#include + +#endif // BOOST_CALL_TRAITS_HPP diff --git a/realsense-file/3rd_party/boost/boost/config.hpp b/realsense-file/3rd_party/boost/boost/config.hpp new file mode 100644 index 0000000000..41c52edf62 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/config.hpp @@ -0,0 +1,67 @@ +// Boost config.hpp configuration header file ------------------------------// + +// (C) Copyright John Maddock 2002. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org/libs/config for most recent version. + +// Boost config.hpp policy and rationale documentation has been moved to +// http://www.boost.org/libs/config +// +// CAUTION: This file is intended to be completely stable - +// DO NOT MODIFY THIS FILE! +// + +#ifndef BOOST_CONFIG_HPP +#define BOOST_CONFIG_HPP + +// if we don't have a user config, then use the default location: +#if !defined(BOOST_USER_CONFIG) && !defined(BOOST_NO_USER_CONFIG) +# define BOOST_USER_CONFIG "boost/config/user.hpp" +#if 0 +// For dependency trackers: +# include +#endif +#endif +// include it first: +#ifdef BOOST_USER_CONFIG +# include BOOST_USER_CONFIG +#endif + +// if we don't have a compiler config set, try and find one: +#if !defined(BOOST_COMPILER_CONFIG) && !defined(BOOST_NO_COMPILER_CONFIG) && !defined(BOOST_NO_CONFIG) +# include "boost/config/select_compiler_config.hpp" +#endif +// if we have a compiler config, include it now: +#ifdef BOOST_COMPILER_CONFIG +# include BOOST_COMPILER_CONFIG +#endif + +// if we don't have a std library config set, try and find one: +#if !defined(BOOST_STDLIB_CONFIG) && !defined(BOOST_NO_STDLIB_CONFIG) && !defined(BOOST_NO_CONFIG) && defined(__cplusplus) +# include "boost/config/select_stdlib_config.hpp" +#endif +// if we have a std library config, include it now: +#ifdef BOOST_STDLIB_CONFIG +# include BOOST_STDLIB_CONFIG +#endif + +// if we don't have a platform config set, try and find one: +#if !defined(BOOST_PLATFORM_CONFIG) && !defined(BOOST_NO_PLATFORM_CONFIG) && !defined(BOOST_NO_CONFIG) +# include "boost/config/select_platform_config.hpp" +#endif +// if we have a platform config, include it now: +#ifdef BOOST_PLATFORM_CONFIG +# include BOOST_PLATFORM_CONFIG +#endif + +// get config suffix code: +#include "boost/config/suffix.hpp" + +#ifdef BOOST_HAS_PRAGMA_ONCE +#pragma once +#endif + +#endif // BOOST_CONFIG_HPP diff --git a/realsense-file/3rd_party/boost/boost/config/compiler/visualc.hpp b/realsense-file/3rd_party/boost/boost/config/compiler/visualc.hpp new file mode 100644 index 0000000000..9dd56f9a50 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/config/compiler/visualc.hpp @@ -0,0 +1,294 @@ +// (C) Copyright John Maddock 2001 - 2003. +// (C) Copyright Darin Adler 2001 - 2002. +// (C) Copyright Peter Dimov 2001. +// (C) Copyright Aleksey Gurtovoy 2002. +// (C) Copyright David Abrahams 2002 - 2003. +// (C) Copyright Beman Dawes 2002 - 2003. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org for most recent version. +// +// Microsoft Visual C++ compiler setup: +// +// We need to be careful with the checks in this file, as contrary +// to popular belief there are versions with _MSC_VER with the final +// digit non-zero (mainly the MIPS cross compiler). +// +// So we either test _MSC_VER >= XXXX or else _MSC_VER < XXXX. +// No other comparisons (==, >, or <=) are safe. +// + +#define BOOST_MSVC _MSC_VER + +// +// Helper macro BOOST_MSVC_FULL_VER for use in Boost code: +// +#if _MSC_FULL_VER > 100000000 +# define BOOST_MSVC_FULL_VER _MSC_FULL_VER +#else +# define BOOST_MSVC_FULL_VER (_MSC_FULL_VER * 10) +#endif + +// Attempt to suppress VC6 warnings about the length of decorated names (obsolete): +#pragma warning( disable : 4503 ) // warning: decorated name length exceeded + +#define BOOST_HAS_PRAGMA_ONCE + +// +// versions check: +// we don't support Visual C++ prior to version 7.1: +#if _MSC_VER < 1310 +# error "Compiler not supported or configured - please reconfigure" +#endif + +#if _MSC_FULL_VER < 180020827 +# define BOOST_NO_FENV_H +#endif + +#if _MSC_VER < 1400 +// although a conforming signature for swprint exists in VC7.1 +// it appears not to actually work: +# define BOOST_NO_SWPRINTF +// Our extern template tests also fail for this compiler: +# define BOOST_NO_CXX11_EXTERN_TEMPLATE +// Variadic macros do not exist for VC7.1 and lower +# define BOOST_NO_CXX11_VARIADIC_MACROS +#endif + +#if _MSC_VER < 1500 // 140X == VC++ 8.0 +# define BOOST_NO_MEMBER_TEMPLATE_FRIENDS +#endif + +#if _MSC_VER < 1600 // 150X == VC++ 9.0 + // A bug in VC9: +# define BOOST_NO_ADL_BARRIER +#endif + + +// MSVC (including the latest checked version) has not yet completely +// implemented value-initialization, as is reported: +// "VC++ does not value-initialize members of derived classes without +// user-declared constructor", reported in 2009 by Sylvester Hesp: +// https://connect.microsoft.com/VisualStudio/feedback/details/484295 +// "Presence of copy constructor breaks member class initialization", +// reported in 2009 by Alex Vakulenko: +// https://connect.microsoft.com/VisualStudio/feedback/details/499606 +// "Value-initialization in new-expression", reported in 2005 by +// Pavel Kuznetsov (MetaCommunications Engineering): +// https://connect.microsoft.com/VisualStudio/feedback/details/100744 +// See also: http://www.boost.org/libs/utility/value_init.htm#compiler_issues +// (Niels Dekker, LKEB, May 2010) +# define BOOST_NO_COMPLETE_VALUE_INITIALIZATION + +#ifndef _NATIVE_WCHAR_T_DEFINED +# define BOOST_NO_INTRINSIC_WCHAR_T +#endif + +// +// check for exception handling support: +#if !defined(_CPPUNWIND) && !defined(BOOST_NO_EXCEPTIONS) +# define BOOST_NO_EXCEPTIONS +#endif + +// +// __int64 support: +// +#define BOOST_HAS_MS_INT64 +#if defined(_MSC_EXTENSIONS) || (_MSC_VER >= 1400) +# define BOOST_HAS_LONG_LONG +#else +# define BOOST_NO_LONG_LONG +#endif +#if (_MSC_VER >= 1400) && !defined(_DEBUG) +# define BOOST_HAS_NRVO +#endif +#if _MSC_VER >= 1600 // 160X == VC++ 10.0 +# define BOOST_HAS_PRAGMA_DETECT_MISMATCH +#endif +// +// disable Win32 API's if compiler extensions are +// turned off: +// +#if !defined(_MSC_EXTENSIONS) && !defined(BOOST_DISABLE_WIN32) +# define BOOST_DISABLE_WIN32 +#endif +#if !defined(_CPPRTTI) && !defined(BOOST_NO_RTTI) +# define BOOST_NO_RTTI +#endif + +// +// TR1 features: +// +#if _MSC_VER >= 1700 +// # define BOOST_HAS_TR1_HASH // don't know if this is true yet. +// # define BOOST_HAS_TR1_TYPE_TRAITS // don't know if this is true yet. +# define BOOST_HAS_TR1_UNORDERED_MAP +# define BOOST_HAS_TR1_UNORDERED_SET +#endif + +// +// C++0x features +// +// See above for BOOST_NO_LONG_LONG + +// C++ features supported by VC++ 10 (aka 2010) +// +#if _MSC_VER < 1600 +# define BOOST_NO_CXX11_AUTO_DECLARATIONS +# define BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS +# define BOOST_NO_CXX11_LAMBDAS +# define BOOST_NO_CXX11_RVALUE_REFERENCES +# define BOOST_NO_CXX11_STATIC_ASSERT +# define BOOST_NO_CXX11_NULLPTR +# define BOOST_NO_CXX11_DECLTYPE +#endif // _MSC_VER < 1600 + +#if _MSC_VER >= 1600 +# define BOOST_HAS_STDINT_H +#endif + +// C++11 features supported by VC++ 11 (aka 2012) +// +#if _MSC_VER < 1700 +# define BOOST_NO_CXX11_FINAL +# define BOOST_NO_CXX11_RANGE_BASED_FOR +# define BOOST_NO_CXX11_SCOPED_ENUMS +#endif // _MSC_VER < 1700 + +// C++11 features supported by VC++ 12 (aka 2013). +// +#if _MSC_FULL_VER < 180020827 +# define BOOST_NO_CXX11_DEFAULTED_FUNCTIONS +# define BOOST_NO_CXX11_DELETED_FUNCTIONS +# define BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS +# define BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS +# define BOOST_NO_CXX11_RAW_LITERALS +# define BOOST_NO_CXX11_TEMPLATE_ALIASES +# define BOOST_NO_CXX11_TRAILING_RESULT_TYPES +# define BOOST_NO_CXX11_VARIADIC_TEMPLATES +# define BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX +# define BOOST_NO_CXX11_DECLTYPE_N3276 +#endif + +// C++11 features supported by VC++ 14 (aka 2015) Preview +// +#if (_MSC_FULL_VER < 190022310) +# define BOOST_NO_CXX11_NOEXCEPT +# define BOOST_NO_CXX11_REF_QUALIFIERS +# define BOOST_NO_CXX11_USER_DEFINED_LITERALS +# define BOOST_NO_CXX11_ALIGNAS +# define BOOST_NO_CXX11_INLINE_NAMESPACES +# define BOOST_NO_CXX11_CHAR16_T +# define BOOST_NO_CXX11_CHAR32_T +# define BOOST_NO_CXX11_UNICODE_LITERALS +# define BOOST_NO_CXX14_DECLTYPE_AUTO +# define BOOST_NO_CXX14_INITIALIZED_LAMBDA_CAPTURES +# define BOOST_NO_CXX14_RETURN_TYPE_DEDUCTION +# define BOOST_NO_CXX14_BINARY_LITERALS +# define BOOST_NO_CXX14_GENERIC_LAMBDAS +#endif + +// C++11 features not supported by any versions +#define BOOST_NO_CXX11_CONSTEXPR +#define BOOST_NO_SFINAE_EXPR +#define BOOST_NO_TWO_PHASE_NAME_LOOKUP + +// C++ 14: +#if !defined(__cpp_aggregate_nsdmi) || (__cpp_aggregate_nsdmi < 201304) +# define BOOST_NO_CXX14_AGGREGATE_NSDMI +#endif +#if !defined(__cpp_constexpr) || (__cpp_constexpr < 201304) +# define BOOST_NO_CXX14_CONSTEXPR +#endif +#if (__cplusplus < 201304) // There's no SD6 check for this.... +# define BOOST_NO_CXX14_DIGIT_SEPARATORS +#endif +#if !defined(__cpp_variable_templates) || (__cpp_variable_templates < 201304) +# define BOOST_NO_CXX14_VARIABLE_TEMPLATES +#endif + +// +// prefix and suffix headers: +// +#ifndef BOOST_ABI_PREFIX +# define BOOST_ABI_PREFIX "boost/config/abi/msvc_prefix.hpp" +#endif +#ifndef BOOST_ABI_SUFFIX +# define BOOST_ABI_SUFFIX "boost/config/abi/msvc_suffix.hpp" +#endif + +#ifndef BOOST_COMPILER +// TODO: +// these things are mostly bogus. 1200 means version 12.0 of the compiler. The +// artificial versions assigned to them only refer to the versions of some IDE +// these compilers have been shipped with, and even that is not all of it. Some +// were shipped with freely downloadable SDKs, others as crosscompilers in eVC. +// IOW, you can't use these 'versions' in any sensible way. Sorry. +# if defined(UNDER_CE) +# if _MSC_VER < 1400 + // Note: I'm not aware of any CE compiler with version 13xx +# if defined(BOOST_ASSERT_CONFIG) +# error "Unknown EVC++ compiler version - please run the configure tests and report the results" +# else +# pragma message("Unknown EVC++ compiler version - please run the configure tests and report the results") +# endif +# elif _MSC_VER < 1500 +# define BOOST_COMPILER_VERSION evc8 +# elif _MSC_VER < 1600 +# define BOOST_COMPILER_VERSION evc9 +# elif _MSC_VER < 1700 +# define BOOST_COMPILER_VERSION evc10 +# elif _MSC_VER < 1800 +# define BOOST_COMPILER_VERSION evc11 +# elif _MSC_VER < 1900 +# define BOOST_COMPILER_VERSION evc12 +# elif _MSC_VER < 2000 +# define BOOST_COMPILER_VERSION evc14 +# else +# if defined(BOOST_ASSERT_CONFIG) +# error "Unknown EVC++ compiler version - please run the configure tests and report the results" +# else +# pragma message("Unknown EVC++ compiler version - please run the configure tests and report the results") +# endif +# endif +# else +# if _MSC_VER < 1310 + // Note: Versions up to 7.0 aren't supported. +# define BOOST_COMPILER_VERSION 5.0 +# elif _MSC_VER < 1300 +# define BOOST_COMPILER_VERSION 6.0 +# elif _MSC_VER < 1310 +# define BOOST_COMPILER_VERSION 7.0 +# elif _MSC_VER < 1400 +# define BOOST_COMPILER_VERSION 7.1 +# elif _MSC_VER < 1500 +# define BOOST_COMPILER_VERSION 8.0 +# elif _MSC_VER < 1600 +# define BOOST_COMPILER_VERSION 9.0 +# elif _MSC_VER < 1700 +# define BOOST_COMPILER_VERSION 10.0 +# elif _MSC_VER < 1800 +# define BOOST_COMPILER_VERSION 11.0 +# elif _MSC_VER < 1900 +# define BOOST_COMPILER_VERSION 12.0 +# elif _MSC_VER < 2000 +# define BOOST_COMPILER_VERSION 14.0 +# else +# define BOOST_COMPILER_VERSION _MSC_VER +# endif +# endif + +# define BOOST_COMPILER "Microsoft Visual C++ version " BOOST_STRINGIZE(BOOST_COMPILER_VERSION) +#endif + +// +// last known and checked version is 19.00.23918 (VC++ 2015 Update 2): +#if (_MSC_VER > 1800 && _MSC_FULL_VER > 190023918) +# if defined(BOOST_ASSERT_CONFIG) +# error "Unknown compiler version - please run the configure tests and report the results" +# else +# pragma message("Unknown compiler version - please run the configure tests and report the results") +# endif +#endif diff --git a/realsense-file/3rd_party/boost/boost/config/no_tr1/functional.hpp b/realsense-file/3rd_party/boost/boost/config/no_tr1/functional.hpp new file mode 100644 index 0000000000..08d46fc4ab --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/config/no_tr1/functional.hpp @@ -0,0 +1,28 @@ +// (C) Copyright John Maddock 2005. +// Use, modification and distribution are subject to 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) +// +// The aim of this header is just to include but to do +// so in a way that does not result in recursive inclusion of +// the Boost TR1 components if boost/tr1/tr1/functional is in the +// include search path. We have to do this to avoid circular +// dependencies: +// + +#ifndef BOOST_CONFIG_FUNCTIONAL +# define BOOST_CONFIG_FUNCTIONAL + +# ifndef BOOST_TR1_NO_RECURSION +# define BOOST_TR1_NO_RECURSION +# define BOOST_CONFIG_NO_FUNCTIONAL_RECURSION +# endif + +# include + +# ifdef BOOST_CONFIG_NO_FUNCTIONAL_RECURSION +# undef BOOST_TR1_NO_RECURSION +# undef BOOST_CONFIG_NO_FUNCTIONAL_RECURSION +# endif + +#endif diff --git a/realsense-file/3rd_party/boost/boost/config/platform/win32.hpp b/realsense-file/3rd_party/boost/boost/config/platform/win32.hpp new file mode 100644 index 0000000000..6d0ee4b3a3 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/config/platform/win32.hpp @@ -0,0 +1,82 @@ +// (C) Copyright John Maddock 2001 - 2003. +// (C) Copyright Bill Kempf 2001. +// (C) Copyright Aleksey Gurtovoy 2003. +// (C) Copyright Rene Rivera 2005. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org for most recent version. + +// Win32 specific config options: + +#define BOOST_PLATFORM "Win32" + +// Get the information about the MinGW runtime, i.e. __MINGW32_*VERSION. +#if defined(__MINGW32__) +# include <_mingw.h> +#endif + +#if defined(__GNUC__) && !defined(BOOST_NO_SWPRINTF) +# define BOOST_NO_SWPRINTF +#endif + +// Default defines for BOOST_SYMBOL_EXPORT and BOOST_SYMBOL_IMPORT +// If a compiler doesn't support __declspec(dllexport)/__declspec(dllimport), +// its boost/config/compiler/ file must define BOOST_SYMBOL_EXPORT and +// BOOST_SYMBOL_IMPORT +#ifndef BOOST_SYMBOL_EXPORT +# define BOOST_HAS_DECLSPEC +# define BOOST_SYMBOL_EXPORT __declspec(dllexport) +# define BOOST_SYMBOL_IMPORT __declspec(dllimport) +#endif + +#if defined(__MINGW32__) && ((__MINGW32_MAJOR_VERSION > 2) || ((__MINGW32_MAJOR_VERSION == 2) && (__MINGW32_MINOR_VERSION >= 0))) +# define BOOST_HAS_STDINT_H +# ifndef __STDC_LIMIT_MACROS +# define __STDC_LIMIT_MACROS +# endif +# define BOOST_HAS_DIRENT_H +# define BOOST_HAS_UNISTD_H +#endif + +#if defined(__MINGW32__) && (__GNUC__ >= 4) +// Mingw has these functions but there are persistent problems +// with calls to these crashing, so disable for now: +//# define BOOST_HAS_EXPM1 +//# define BOOST_HAS_LOG1P +# define BOOST_HAS_GETTIMEOFDAY +#endif +// +// Win32 will normally be using native Win32 threads, +// but there is a pthread library avaliable as an option, +// we used to disable this when BOOST_DISABLE_WIN32 was +// defined but no longer - this should allow some +// files to be compiled in strict mode - while maintaining +// a consistent setting of BOOST_HAS_THREADS across +// all translation units (needed for shared_ptr etc). +// + +#ifndef BOOST_HAS_PTHREADS +# define BOOST_HAS_WINTHREADS +#endif + +// +// WinCE configuration: +// +#if defined(_WIN32_WCE) || defined(UNDER_CE) +# define BOOST_NO_ANSI_APIS +// Windows CE does not have a conforming signature for swprintf +# define BOOST_NO_SWPRINTF +#else +# define BOOST_HAS_GETSYSTEMTIMEASFILETIME +# define BOOST_HAS_THREADEX +# define BOOST_HAS_GETSYSTEMTIMEASFILETIME +#endif + +#ifndef BOOST_DISABLE_WIN32 +// WEK: Added +#define BOOST_HAS_FTIME +#define BOOST_WINDOWS 1 + +#endif diff --git a/realsense-file/3rd_party/boost/boost/config/select_compiler_config.hpp b/realsense-file/3rd_party/boost/boost/config/select_compiler_config.hpp new file mode 100644 index 0000000000..42cd04d44e --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/config/select_compiler_config.hpp @@ -0,0 +1,144 @@ +// Boost compiler configuration selection header file + +// (C) Copyright John Maddock 2001 - 2003. +// (C) Copyright Martin Wille 2003. +// (C) Copyright Guillaume Melquiond 2003. +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org/ for most recent version. + +// locate which compiler we are using and define +// BOOST_COMPILER_CONFIG as needed: + +#if defined __CUDACC__ +// NVIDIA CUDA C++ compiler for GPU +# include "boost/config/compiler/nvcc.hpp" + +#endif + +#if defined(__GCCXML__) +// GCC-XML emulates other compilers, it has to appear first here! +# define BOOST_COMPILER_CONFIG "boost/config/compiler/gcc_xml.hpp" + +#elif defined(_CRAYC) +// EDG based Cray compiler: +# define BOOST_COMPILER_CONFIG "boost/config/compiler/cray.hpp" + +#elif defined __COMO__ +// Comeau C++ +# define BOOST_COMPILER_CONFIG "boost/config/compiler/comeau.hpp" + +#elif defined(__PATHSCALE__) && (__PATHCC__ >= 4) +// PathScale EKOPath compiler (has to come before clang and gcc) +# define BOOST_COMPILER_CONFIG "boost/config/compiler/pathscale.hpp" + +#elif defined(__INTEL_COMPILER) || defined(__ICL) || defined(__ICC) || defined(__ECC) +// Intel +# define BOOST_COMPILER_CONFIG "boost/config/compiler/intel.hpp" + +#elif defined __clang__ && !defined(__CUDACC__) +// when using clang and cuda at same time, you want to appear as gcc +// Clang C++ emulates GCC, so it has to appear early. +# define BOOST_COMPILER_CONFIG "boost/config/compiler/clang.hpp" + +#elif defined __DMC__ +// Digital Mars C++ +# define BOOST_COMPILER_CONFIG "boost/config/compiler/digitalmars.hpp" + +# elif defined __GNUC__ +// GNU C++: +# define BOOST_COMPILER_CONFIG "boost/config/compiler/gcc.hpp" + +#elif defined __KCC +// Kai C++ +# define BOOST_COMPILER_CONFIG "boost/config/compiler/kai.hpp" + +#elif defined __sgi +// SGI MIPSpro C++ +# define BOOST_COMPILER_CONFIG "boost/config/compiler/sgi_mipspro.hpp" + +#elif defined __DECCXX +// Compaq Tru64 Unix cxx +# define BOOST_COMPILER_CONFIG "boost/config/compiler/compaq_cxx.hpp" + +#elif defined __ghs +// Greenhills C++ +# define BOOST_COMPILER_CONFIG "boost/config/compiler/greenhills.hpp" + +#elif defined __CODEGEARC__ +// CodeGear - must be checked for before Borland +# define BOOST_COMPILER_CONFIG "boost/config/compiler/codegear.hpp" + +#elif defined __BORLANDC__ +// Borland +# define BOOST_COMPILER_CONFIG "boost/config/compiler/borland.hpp" + +#elif defined __MWERKS__ +// Metrowerks CodeWarrior +# define BOOST_COMPILER_CONFIG "boost/config/compiler/metrowerks.hpp" + +#elif defined __SUNPRO_CC +// Sun Workshop Compiler C++ +# define BOOST_COMPILER_CONFIG "boost/config/compiler/sunpro_cc.hpp" + +#elif defined __HP_aCC +// HP aCC +# define BOOST_COMPILER_CONFIG "boost/config/compiler/hp_acc.hpp" + +#elif defined(__MRC__) || defined(__SC__) +// MPW MrCpp or SCpp +# define BOOST_COMPILER_CONFIG "boost/config/compiler/mpw.hpp" + +#elif defined(__IBMCPP__) +// IBM Visual Age +# define BOOST_COMPILER_CONFIG "boost/config/compiler/vacpp.hpp" + +#elif defined(__PGI) +// Portland Group Inc. +# define BOOST_COMPILER_CONFIG "boost/config/compiler/pgi.hpp" + +#elif defined _MSC_VER +// Microsoft Visual C++ +// +// Must remain the last #elif since some other vendors (Metrowerks, for +// example) also #define _MSC_VER +# define BOOST_COMPILER_CONFIG "boost/config/compiler/visualc.hpp" + +#elif defined (BOOST_ASSERT_CONFIG) +// this must come last - generate an error if we don't +// recognise the compiler: +# error "Unknown compiler - please configure (http://www.boost.org/libs/config/config.htm#configuring) and report the results to the main boost mailing list (http://www.boost.org/more/mailing_lists.htm#main)" + +#endif + +#if 0 +// +// This section allows dependency scanners to find all the headers we *might* include: +// +#include "boost/config/compiler/gcc_xml.hpp" +#include "boost/config/compiler/cray.hpp" +#include "boost/config/compiler/comeau.hpp" +#include "boost/config/compiler/pathscale.hpp" +#include "boost/config/compiler/intel.hpp" +#include "boost/config/compiler/clang.hpp" +#include "boost/config/compiler/digitalmars.hpp" +#include "boost/config/compiler/gcc.hpp" +#include "boost/config/compiler/kai.hpp" +#include "boost/config/compiler/sgi_mipspro.hpp" +#include "boost/config/compiler/compaq_cxx.hpp" +#include "boost/config/compiler/greenhills.hpp" +#include "boost/config/compiler/codegear.hpp" +#include "boost/config/compiler/borland.hpp" +#include "boost/config/compiler/metrowerks.hpp" +#include "boost/config/compiler/sunpro_cc.hpp" +#include "boost/config/compiler/hp_acc.hpp" +#include "boost/config/compiler/mpw.hpp" +#include "boost/config/compiler/vacpp.hpp" +#include "boost/config/compiler/pgi.hpp" +#include "boost/config/compiler/visualc.hpp" + +#endif + diff --git a/realsense-file/3rd_party/boost/boost/config/select_platform_config.hpp b/realsense-file/3rd_party/boost/boost/config/select_platform_config.hpp new file mode 100644 index 0000000000..e1efad051b --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/config/select_platform_config.hpp @@ -0,0 +1,133 @@ +// Boost compiler configuration selection header file + +// (C) Copyright John Maddock 2001 - 2002. +// (C) Copyright Jens Maurer 2001. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org for most recent version. + +// locate which platform we are on and define BOOST_PLATFORM_CONFIG as needed. +// Note that we define the headers to include using "header_name" not +// in order to prevent macro expansion within the header +// name (for example "linux" is a macro on linux systems). + +#if (defined(linux) || defined(__linux) || defined(__linux__) || defined(__GNU__) || defined(__GLIBC__)) && !defined(_CRAYC) +// linux, also other platforms (Hurd etc) that use GLIBC, should these really have their own config headers though? +# define BOOST_PLATFORM_CONFIG "boost/config/platform/linux.hpp" + +#elif defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__DragonFly__) +// BSD: +# define BOOST_PLATFORM_CONFIG "boost/config/platform/bsd.hpp" + +#elif defined(sun) || defined(__sun) +// solaris: +# define BOOST_PLATFORM_CONFIG "boost/config/platform/solaris.hpp" + +#elif defined(__sgi) +// SGI Irix: +# define BOOST_PLATFORM_CONFIG "boost/config/platform/irix.hpp" + +#elif defined(__hpux) +// hp unix: +# define BOOST_PLATFORM_CONFIG "boost/config/platform/hpux.hpp" + +#elif defined(__CYGWIN__) +// cygwin is not win32: +# define BOOST_PLATFORM_CONFIG "boost/config/platform/cygwin.hpp" + +#elif defined(_WIN32) || defined(__WIN32__) || defined(WIN32) +// win32: +# define BOOST_PLATFORM_CONFIG "boost/config/platform/win32.hpp" + +#elif defined(__HAIKU__) +// Haiku +# define BOOST_PLATFORM_CONFIG "boost/config/platform/haiku.hpp" + +#elif defined(__BEOS__) +// BeOS +# define BOOST_PLATFORM_CONFIG "boost/config/platform/beos.hpp" + +#elif defined(macintosh) || defined(__APPLE__) || defined(__APPLE_CC__) +// MacOS +# define BOOST_PLATFORM_CONFIG "boost/config/platform/macos.hpp" + +#elif defined(__IBMCPP__) || defined(_AIX) +// IBM +# define BOOST_PLATFORM_CONFIG "boost/config/platform/aix.hpp" + +#elif defined(__amigaos__) +// AmigaOS +# define BOOST_PLATFORM_CONFIG "boost/config/platform/amigaos.hpp" + +#elif defined(__QNXNTO__) +// QNX: +# define BOOST_PLATFORM_CONFIG "boost/config/platform/qnxnto.hpp" + +#elif defined(__VXWORKS__) +// vxWorks: +# define BOOST_PLATFORM_CONFIG "boost/config/platform/vxworks.hpp" + +#elif defined(__SYMBIAN32__) +// Symbian: +# define BOOST_PLATFORM_CONFIG "boost/config/platform/symbian.hpp" + +#elif defined(_CRAYC) +// Cray: +# define BOOST_PLATFORM_CONFIG "boost/config/platform/cray.hpp" + +#elif defined(__VMS) +// VMS: +# define BOOST_PLATFORM_CONFIG "boost/config/platform/vms.hpp" +#else + +# if defined(unix) \ + || defined(__unix) \ + || defined(_XOPEN_SOURCE) \ + || defined(_POSIX_SOURCE) + + // generic unix platform: + +# ifndef BOOST_HAS_UNISTD_H +# define BOOST_HAS_UNISTD_H +# endif + +# include + +# endif + +# if defined (BOOST_ASSERT_CONFIG) + // this must come last - generate an error if we don't + // recognise the platform: +# error "Unknown platform - please configure and report the results to boost.org" +# endif + +#endif + +#if 0 +// +// This section allows dependency scanners to find all the files we *might* include: +// +# include "boost/config/platform/linux.hpp" +# include "boost/config/platform/bsd.hpp" +# include "boost/config/platform/solaris.hpp" +# include "boost/config/platform/irix.hpp" +# include "boost/config/platform/hpux.hpp" +# include "boost/config/platform/cygwin.hpp" +# include "boost/config/platform/win32.hpp" +# include "boost/config/platform/beos.hpp" +# include "boost/config/platform/macos.hpp" +# include "boost/config/platform/aix.hpp" +# include "boost/config/platform/amigaos.hpp" +# include "boost/config/platform/qnxnto.hpp" +# include "boost/config/platform/vxworks.hpp" +# include "boost/config/platform/symbian.hpp" +# include "boost/config/platform/cray.hpp" +# include "boost/config/platform/vms.hpp" +# include + + + +#endif + diff --git a/realsense-file/3rd_party/boost/boost/config/select_stdlib_config.hpp b/realsense-file/3rd_party/boost/boost/config/select_stdlib_config.hpp new file mode 100644 index 0000000000..26b0b666b9 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/config/select_stdlib_config.hpp @@ -0,0 +1,105 @@ +// Boost compiler configuration selection header file + +// (C) Copyright John Maddock 2001 - 2003. +// (C) Copyright Jens Maurer 2001 - 2002. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + + +// See http://www.boost.org for most recent version. + +// locate which std lib we are using and define BOOST_STDLIB_CONFIG as needed: + +// First include to determine if some version of STLport is in use as the std lib +// (do not rely on this header being included since users can short-circuit this header +// if they know whose std lib they are using.) +#ifdef __cplusplus +# include +#else +# include +#endif + +#if defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION) +// STLPort library; this _must_ come first, otherwise since +// STLport typically sits on top of some other library, we +// can end up detecting that first rather than STLport: +# define BOOST_STDLIB_CONFIG "boost/config/stdlib/stlport.hpp" + +#else + +// If our std lib was not some version of STLport, and has not otherwise +// been detected, then include as it is about +// the smallest of the std lib headers that includes real C++ stuff. +// Some std libs do not include their C++-related macros in +// so this additional include makes sure we get those definitions. +// Note: do not rely on this header being included since users can short-circuit this +// #include if they know whose std lib they are using. +#if !defined(__LIBCOMO__) && !defined(__STD_RWCOMPILER_H__) && !defined(_RWSTD_VER)\ + && !defined(_LIBCPP_VERSION) && !defined(__GLIBCPP__) && !defined(__GLIBCXX__)\ + && !defined(__STL_CONFIG_H) && !defined(__MSL_CPP__) && !defined(__IBMCPP__)\ + && !defined(MSIPL_COMPILE_H) && !defined(_YVALS) && !defined(_CPPLIB_VER) +#include +#endif + +#if defined(__LIBCOMO__) +// Comeau STL: +#define BOOST_STDLIB_CONFIG "boost/config/stdlib/libcomo.hpp" + +#elif defined(__STD_RWCOMPILER_H__) || defined(_RWSTD_VER) +// Rogue Wave library: +# define BOOST_STDLIB_CONFIG "boost/config/stdlib/roguewave.hpp" + +#elif defined(_LIBCPP_VERSION) +// libc++ +# define BOOST_STDLIB_CONFIG "boost/config/stdlib/libcpp.hpp" + +#elif defined(__GLIBCPP__) || defined(__GLIBCXX__) +// GNU libstdc++ 3 +# define BOOST_STDLIB_CONFIG "boost/config/stdlib/libstdcpp3.hpp" + +#elif defined(__STL_CONFIG_H) +// generic SGI STL +# define BOOST_STDLIB_CONFIG "boost/config/stdlib/sgi.hpp" + +#elif defined(__MSL_CPP__) +// MSL standard lib: +# define BOOST_STDLIB_CONFIG "boost/config/stdlib/msl.hpp" + +#elif defined(__IBMCPP__) +// take the default VACPP std lib +# define BOOST_STDLIB_CONFIG "boost/config/stdlib/vacpp.hpp" + +#elif defined(MSIPL_COMPILE_H) +// Modena C++ standard library +# define BOOST_STDLIB_CONFIG "boost/config/stdlib/modena.hpp" + +#elif (defined(_YVALS) && !defined(__IBMCPP__)) || defined(_CPPLIB_VER) +// Dinkumware Library (this has to appear after any possible replacement libraries): +# define BOOST_STDLIB_CONFIG "boost/config/stdlib/dinkumware.hpp" + +#elif defined (BOOST_ASSERT_CONFIG) +// this must come last - generate an error if we don't +// recognise the library: +# error "Unknown standard library - please configure and report the results to boost.org" + +#endif + +#endif + +#if 0 +// +// This section allows dependency scanners to find all the files we *might* include: +// +# include "boost/config/stdlib/stlport.hpp" +# include "boost/config/stdlib/libcomo.hpp" +# include "boost/config/stdlib/roguewave.hpp" +# include "boost/config/stdlib/libcpp.hpp" +# include "boost/config/stdlib/libstdcpp3.hpp" +# include "boost/config/stdlib/sgi.hpp" +# include "boost/config/stdlib/msl.hpp" +# include "boost/config/stdlib/vacpp.hpp" +# include "boost/config/stdlib/modena.hpp" +# include "boost/config/stdlib/dinkumware.hpp" +#endif + diff --git a/realsense-file/3rd_party/boost/boost/config/stdlib/dinkumware.hpp b/realsense-file/3rd_party/boost/boost/config/stdlib/dinkumware.hpp new file mode 100644 index 0000000000..4df3bc8a14 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/config/stdlib/dinkumware.hpp @@ -0,0 +1,170 @@ +// (C) Copyright John Maddock 2001 - 2003. +// (C) Copyright Jens Maurer 2001. +// (C) Copyright Peter Dimov 2001. +// (C) Copyright David Abrahams 2002. +// (C) Copyright Guillaume Melquiond 2003. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org for most recent version. + +// Dinkumware standard library config: + +#if !defined(_YVALS) && !defined(_CPPLIB_VER) +#include +#if !defined(_YVALS) && !defined(_CPPLIB_VER) +#error This is not the Dinkumware lib! +#endif +#endif + + +#if defined(_CPPLIB_VER) && (_CPPLIB_VER >= 306) + // full dinkumware 3.06 and above + // fully conforming provided the compiler supports it: +# if !(defined(_GLOBAL_USING) && (_GLOBAL_USING+0 > 0)) && !defined(__BORLANDC__) && !defined(_STD) && !(defined(__ICC) && (__ICC >= 700)) // can be defined in yvals.h +# define BOOST_NO_STDC_NAMESPACE +# endif +# if !(defined(_HAS_MEMBER_TEMPLATES_REBIND) && (_HAS_MEMBER_TEMPLATES_REBIND+0 > 0)) && !(defined(_MSC_VER) && (_MSC_VER > 1300)) && defined(BOOST_MSVC) +# define BOOST_NO_STD_ALLOCATOR +# endif +# define BOOST_HAS_PARTIAL_STD_ALLOCATOR +# if defined(BOOST_MSVC) && (BOOST_MSVC < 1300) + // if this lib version is set up for vc6 then there is no std::use_facet: +# define BOOST_NO_STD_USE_FACET +# define BOOST_HAS_TWO_ARG_USE_FACET + // C lib functions aren't in namespace std either: +# define BOOST_NO_STDC_NAMESPACE + // and nor is +# define BOOST_NO_EXCEPTION_STD_NAMESPACE +# endif +// There's no numeric_limits support unless _LONGLONG is defined: +# if !defined(_LONGLONG) && (_CPPLIB_VER <= 310) +# define BOOST_NO_MS_INT64_NUMERIC_LIMITS +# endif +// 3.06 appears to have (non-sgi versions of) & , +// and no at all +#else +# define BOOST_MSVC_STD_ITERATOR 1 +# define BOOST_NO_STD_ITERATOR +# define BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS +# define BOOST_NO_STD_ALLOCATOR +# define BOOST_NO_STDC_NAMESPACE +# define BOOST_NO_STD_USE_FACET +# define BOOST_NO_STD_OUTPUT_ITERATOR_ASSIGN +# define BOOST_HAS_MACRO_USE_FACET +# ifndef _CPPLIB_VER + // Updated Dinkum library defines this, and provides + // its own min and max definitions, as does MTA version. +# ifndef __MTA__ +# define BOOST_NO_STD_MIN_MAX +# endif +# define BOOST_NO_MS_INT64_NUMERIC_LIMITS +# endif +#endif + +// +// std extension namespace is stdext for vc7.1 and later, +// the same applies to other compilers that sit on top +// of vc7.1 (Intel and Comeau): +// +#if defined(_MSC_VER) && (_MSC_VER >= 1310) && !defined(__BORLANDC__) +# define BOOST_STD_EXTENSION_NAMESPACE stdext +#endif + + +#if (defined(_MSC_VER) && (_MSC_VER <= 1300) && !defined(__BORLANDC__)) || !defined(_CPPLIB_VER) || (_CPPLIB_VER < 306) + // if we're using a dinkum lib that's + // been configured for VC6/7 then there is + // no iterator traits (true even for icl) +# define BOOST_NO_STD_ITERATOR_TRAITS +#endif + +#if defined(__ICL) && (__ICL < 800) && defined(_CPPLIB_VER) && (_CPPLIB_VER <= 310) +// Intel C++ chokes over any non-trivial use of +// this may be an overly restrictive define, but regex fails without it: +# define BOOST_NO_STD_LOCALE +#endif + +// Fix for VC++ 8.0 on up ( I do not have a previous version to test ) +// or clang-cl. If exceptions are off you must manually include the +// header before including the header. Admittedly +// trying to use Boost libraries or the standard C++ libraries without +// exception support is not suggested but currently clang-cl ( v 3.4 ) +// does not support exceptions and must be compiled with exceptions off. +#if !_HAS_EXCEPTIONS && ((defined(BOOST_MSVC) && BOOST_MSVC >= 1400) || (defined(__clang__) && defined(_MSC_VER))) +#include +#endif +#include +#if ( (!_HAS_EXCEPTIONS && !defined(__ghs__)) || (!_HAS_NAMESPACE && defined(__ghs__)) ) && !defined(__TI_COMPILER_VERSION__) && !defined(__VISUALDSPVERSION__) +# define BOOST_NO_STD_TYPEINFO +#endif + +// C++0x headers implemented in 520 (as shipped by Microsoft) +// +#if !defined(_CPPLIB_VER) || _CPPLIB_VER < 520 +# define BOOST_NO_CXX11_HDR_ARRAY +# define BOOST_NO_CXX11_HDR_CODECVT +# define BOOST_NO_CXX11_HDR_FORWARD_LIST +# define BOOST_NO_CXX11_HDR_INITIALIZER_LIST +# define BOOST_NO_CXX11_HDR_RANDOM +# define BOOST_NO_CXX11_HDR_REGEX +# define BOOST_NO_CXX11_HDR_SYSTEM_ERROR +# define BOOST_NO_CXX11_HDR_UNORDERED_MAP +# define BOOST_NO_CXX11_HDR_UNORDERED_SET +# define BOOST_NO_CXX11_HDR_TUPLE +# define BOOST_NO_CXX11_HDR_TYPEINDEX +# define BOOST_NO_CXX11_HDR_FUNCTIONAL +# define BOOST_NO_CXX11_NUMERIC_LIMITS +# define BOOST_NO_CXX11_SMART_PTR +#endif + +#if ((!defined(_HAS_TR1_IMPORTS) || (_HAS_TR1_IMPORTS+0 == 0)) && !defined(BOOST_NO_CXX11_HDR_TUPLE)) \ + && (!defined(_CPPLIB_VER) || _CPPLIB_VER < 610) +# define BOOST_NO_CXX11_HDR_TUPLE +#endif + +// C++0x headers implemented in 540 (as shipped by Microsoft) +// +#if !defined(_CPPLIB_VER) || _CPPLIB_VER < 540 +# define BOOST_NO_CXX11_HDR_TYPE_TRAITS +# define BOOST_NO_CXX11_HDR_CHRONO +# define BOOST_NO_CXX11_HDR_CONDITION_VARIABLE +# define BOOST_NO_CXX11_HDR_FUTURE +# define BOOST_NO_CXX11_HDR_MUTEX +# define BOOST_NO_CXX11_HDR_RATIO +# define BOOST_NO_CXX11_HDR_THREAD +# define BOOST_NO_CXX11_ATOMIC_SMART_PTR +#endif + +// C++0x headers implemented in 610 (as shipped by Microsoft) +// +#if !defined(_CPPLIB_VER) || _CPPLIB_VER < 610 +# define BOOST_NO_CXX11_HDR_INITIALIZER_LIST +# define BOOST_NO_CXX11_HDR_ATOMIC +# define BOOST_NO_CXX11_ALLOCATOR +// 540 has std::align but it is not a conforming implementation +# define BOOST_NO_CXX11_STD_ALIGN +#endif + +#if defined(BOOST_INTEL) && (BOOST_INTEL <= 1400) +// Intel's compiler can't handle this header yet: +# define BOOST_NO_CXX11_HDR_ATOMIC +#endif + + +// 520..610 have std::addressof, but it doesn't support functions +// +# define BOOST_NO_CXX11_ADDRESSOF + +#ifdef _CPPLIB_VER +# define BOOST_DINKUMWARE_STDLIB _CPPLIB_VER +#else +# define BOOST_DINKUMWARE_STDLIB 1 +#endif + +#ifdef _CPPLIB_VER +# define BOOST_STDLIB "Dinkumware standard library version " BOOST_STRINGIZE(_CPPLIB_VER) +#else +# define BOOST_STDLIB "Dinkumware standard library version 1.x" +#endif diff --git a/realsense-file/3rd_party/boost/boost/config/suffix.hpp b/realsense-file/3rd_party/boost/boost/config/suffix.hpp new file mode 100644 index 0000000000..404c0b6095 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/config/suffix.hpp @@ -0,0 +1,995 @@ +// Boost config.hpp configuration header file ------------------------------// +// boostinspect:ndprecated_macros -- tell the inspect tool to ignore this file + +// Copyright (c) 2001-2003 John Maddock +// Copyright (c) 2001 Darin Adler +// Copyright (c) 2001 Peter Dimov +// Copyright (c) 2002 Bill Kempf +// Copyright (c) 2002 Jens Maurer +// Copyright (c) 2002-2003 David Abrahams +// Copyright (c) 2003 Gennaro Prota +// Copyright (c) 2003 Eric Friedman +// Copyright (c) 2010 Eric Jourdanneau, Joel Falcou +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org/ for most recent version. + +// Boost config.hpp policy and rationale documentation has been moved to +// http://www.boost.org/libs/config/ +// +// This file is intended to be stable, and relatively unchanging. +// It should contain boilerplate code only - no compiler specific +// code unless it is unavoidable - no changes unless unavoidable. + +#ifndef BOOST_CONFIG_SUFFIX_HPP +#define BOOST_CONFIG_SUFFIX_HPP + +#if defined(__GNUC__) && (__GNUC__ >= 4) +// +// Some GCC-4.x versions issue warnings even when __extension__ is used, +// so use this as a workaround: +// +#pragma GCC system_header +#endif + +// +// ensure that visibility macros are always defined, thus symplifying use +// +#ifndef BOOST_SYMBOL_EXPORT +# define BOOST_SYMBOL_EXPORT +#endif +#ifndef BOOST_SYMBOL_IMPORT +# define BOOST_SYMBOL_IMPORT +#endif +#ifndef BOOST_SYMBOL_VISIBLE +# define BOOST_SYMBOL_VISIBLE +#endif + +// +// look for long long by looking for the appropriate macros in . +// Note that we use limits.h rather than climits for maximal portability, +// remember that since these just declare a bunch of macros, there should be +// no namespace issues from this. +// +#if !defined(BOOST_HAS_LONG_LONG) && !defined(BOOST_NO_LONG_LONG) \ + && !defined(BOOST_MSVC) && !defined(__BORLANDC__) +# include +# if (defined(ULLONG_MAX) || defined(ULONG_LONG_MAX) || defined(ULONGLONG_MAX)) +# define BOOST_HAS_LONG_LONG +# else +# define BOOST_NO_LONG_LONG +# endif +#endif + +// GCC 3.x will clean up all of those nasty macro definitions that +// BOOST_NO_CTYPE_FUNCTIONS is intended to help work around, so undefine +// it under GCC 3.x. +#if defined(__GNUC__) && (__GNUC__ >= 3) && defined(BOOST_NO_CTYPE_FUNCTIONS) +# undef BOOST_NO_CTYPE_FUNCTIONS +#endif + +// +// Assume any extensions are in namespace std:: unless stated otherwise: +// +# ifndef BOOST_STD_EXTENSION_NAMESPACE +# define BOOST_STD_EXTENSION_NAMESPACE std +# endif + +// +// If cv-qualified specializations are not allowed, then neither are cv-void ones: +// +# if defined(BOOST_NO_CV_SPECIALIZATIONS) \ + && !defined(BOOST_NO_CV_VOID_SPECIALIZATIONS) +# define BOOST_NO_CV_VOID_SPECIALIZATIONS +# endif + +// +// If there is no numeric_limits template, then it can't have any compile time +// constants either! +// +# if defined(BOOST_NO_LIMITS) \ + && !defined(BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS) +# define BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS +# define BOOST_NO_MS_INT64_NUMERIC_LIMITS +# define BOOST_NO_LONG_LONG_NUMERIC_LIMITS +# endif + +// +// if there is no long long then there is no specialisation +// for numeric_limits either: +// +#if !defined(BOOST_HAS_LONG_LONG) && !defined(BOOST_NO_LONG_LONG_NUMERIC_LIMITS) +# define BOOST_NO_LONG_LONG_NUMERIC_LIMITS +#endif + +// +// if there is no __int64 then there is no specialisation +// for numeric_limits<__int64> either: +// +#if !defined(BOOST_HAS_MS_INT64) && !defined(BOOST_NO_MS_INT64_NUMERIC_LIMITS) +# define BOOST_NO_MS_INT64_NUMERIC_LIMITS +#endif + +// +// if member templates are supported then so is the +// VC6 subset of member templates: +// +# if !defined(BOOST_NO_MEMBER_TEMPLATES) \ + && !defined(BOOST_MSVC6_MEMBER_TEMPLATES) +# define BOOST_MSVC6_MEMBER_TEMPLATES +# endif + +// +// Without partial specialization, can't test for partial specialisation bugs: +// +# if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \ + && !defined(BOOST_BCB_PARTIAL_SPECIALIZATION_BUG) +# define BOOST_BCB_PARTIAL_SPECIALIZATION_BUG +# endif + +// +// Without partial specialization, we can't have array-type partial specialisations: +// +# if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \ + && !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS) +# define BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS +# endif + +// +// Without partial specialization, std::iterator_traits can't work: +// +# if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \ + && !defined(BOOST_NO_STD_ITERATOR_TRAITS) +# define BOOST_NO_STD_ITERATOR_TRAITS +# endif + +// +// Without partial specialization, partial +// specialization with default args won't work either: +// +# if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \ + && !defined(BOOST_NO_PARTIAL_SPECIALIZATION_IMPLICIT_DEFAULT_ARGS) +# define BOOST_NO_PARTIAL_SPECIALIZATION_IMPLICIT_DEFAULT_ARGS +# endif + +// +// Without member template support, we can't have template constructors +// in the standard library either: +// +# if defined(BOOST_NO_MEMBER_TEMPLATES) \ + && !defined(BOOST_MSVC6_MEMBER_TEMPLATES) \ + && !defined(BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS) +# define BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS +# endif + +// +// Without member template support, we can't have a conforming +// std::allocator template either: +// +# if defined(BOOST_NO_MEMBER_TEMPLATES) \ + && !defined(BOOST_MSVC6_MEMBER_TEMPLATES) \ + && !defined(BOOST_NO_STD_ALLOCATOR) +# define BOOST_NO_STD_ALLOCATOR +# endif + +// +// without ADL support then using declarations will break ADL as well: +// +#if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP) && !defined(BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL) +# define BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL +#endif + +// +// Without typeid support we have no dynamic RTTI either: +// +#if defined(BOOST_NO_TYPEID) && !defined(BOOST_NO_RTTI) +# define BOOST_NO_RTTI +#endif + +// +// If we have a standard allocator, then we have a partial one as well: +// +#if !defined(BOOST_NO_STD_ALLOCATOR) +# define BOOST_HAS_PARTIAL_STD_ALLOCATOR +#endif + +// +// We can't have a working std::use_facet if there is no std::locale: +// +# if defined(BOOST_NO_STD_LOCALE) && !defined(BOOST_NO_STD_USE_FACET) +# define BOOST_NO_STD_USE_FACET +# endif + +// +// We can't have a std::messages facet if there is no std::locale: +// +# if defined(BOOST_NO_STD_LOCALE) && !defined(BOOST_NO_STD_MESSAGES) +# define BOOST_NO_STD_MESSAGES +# endif + +// +// We can't have a working std::wstreambuf if there is no std::locale: +// +# if defined(BOOST_NO_STD_LOCALE) && !defined(BOOST_NO_STD_WSTREAMBUF) +# define BOOST_NO_STD_WSTREAMBUF +# endif + +// +// We can't have a if there is no : +// +# if defined(BOOST_NO_CWCHAR) && !defined(BOOST_NO_CWCTYPE) +# define BOOST_NO_CWCTYPE +# endif + +// +// We can't have a swprintf if there is no : +// +# if defined(BOOST_NO_CWCHAR) && !defined(BOOST_NO_SWPRINTF) +# define BOOST_NO_SWPRINTF +# endif + +// +// If Win32 support is turned off, then we must turn off +// threading support also, unless there is some other +// thread API enabled: +// +#if defined(BOOST_DISABLE_WIN32) && defined(_WIN32) \ + && !defined(BOOST_DISABLE_THREADS) && !defined(BOOST_HAS_PTHREADS) +# define BOOST_DISABLE_THREADS +#endif + +// +// Turn on threading support if the compiler thinks that it's in +// multithreaded mode. We put this here because there are only a +// limited number of macros that identify this (if there's any missing +// from here then add to the appropriate compiler section): +// +#if (defined(__MT__) || defined(_MT) || defined(_REENTRANT) \ + || defined(_PTHREADS) || defined(__APPLE__) || defined(__DragonFly__)) \ + && !defined(BOOST_HAS_THREADS) +# define BOOST_HAS_THREADS +#endif + +// +// Turn threading support off if BOOST_DISABLE_THREADS is defined: +// +#if defined(BOOST_DISABLE_THREADS) && defined(BOOST_HAS_THREADS) +# undef BOOST_HAS_THREADS +#endif + +// +// Turn threading support off if we don't recognise the threading API: +// +#if defined(BOOST_HAS_THREADS) && !defined(BOOST_HAS_PTHREADS)\ + && !defined(BOOST_HAS_WINTHREADS) && !defined(BOOST_HAS_BETHREADS)\ + && !defined(BOOST_HAS_MPTASKS) +# undef BOOST_HAS_THREADS +#endif + +// +// Turn threading detail macros off if we don't (want to) use threading +// +#ifndef BOOST_HAS_THREADS +# undef BOOST_HAS_PTHREADS +# undef BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE +# undef BOOST_HAS_PTHREAD_YIELD +# undef BOOST_HAS_PTHREAD_DELAY_NP +# undef BOOST_HAS_WINTHREADS +# undef BOOST_HAS_BETHREADS +# undef BOOST_HAS_MPTASKS +#endif + +// +// If the compiler claims to be C99 conformant, then it had better +// have a : +// +# if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901) +# define BOOST_HAS_STDINT_H +# ifndef BOOST_HAS_LOG1P +# define BOOST_HAS_LOG1P +# endif +# ifndef BOOST_HAS_EXPM1 +# define BOOST_HAS_EXPM1 +# endif +# endif + +// +// Define BOOST_NO_SLIST and BOOST_NO_HASH if required. +// Note that this is for backwards compatibility only. +// +# if !defined(BOOST_HAS_SLIST) && !defined(BOOST_NO_SLIST) +# define BOOST_NO_SLIST +# endif + +# if !defined(BOOST_HAS_HASH) && !defined(BOOST_NO_HASH) +# define BOOST_NO_HASH +# endif + +// +// Set BOOST_SLIST_HEADER if not set already: +// +#if defined(BOOST_HAS_SLIST) && !defined(BOOST_SLIST_HEADER) +# define BOOST_SLIST_HEADER +#endif + +// +// Set BOOST_HASH_SET_HEADER if not set already: +// +#if defined(BOOST_HAS_HASH) && !defined(BOOST_HASH_SET_HEADER) +# define BOOST_HASH_SET_HEADER +#endif + +// +// Set BOOST_HASH_MAP_HEADER if not set already: +// +#if defined(BOOST_HAS_HASH) && !defined(BOOST_HASH_MAP_HEADER) +# define BOOST_HASH_MAP_HEADER +#endif + +// BOOST_HAS_ABI_HEADERS +// This macro gets set if we have headers that fix the ABI, +// and prevent ODR violations when linking to external libraries: +#if defined(BOOST_ABI_PREFIX) && defined(BOOST_ABI_SUFFIX) && !defined(BOOST_HAS_ABI_HEADERS) +# define BOOST_HAS_ABI_HEADERS +#endif + +#if defined(BOOST_HAS_ABI_HEADERS) && defined(BOOST_DISABLE_ABI_HEADERS) +# undef BOOST_HAS_ABI_HEADERS +#endif + +// BOOST_NO_STDC_NAMESPACE workaround --------------------------------------// +// Because std::size_t usage is so common, even in boost headers which do not +// otherwise use the C library, the workaround is included here so +// that ugly workaround code need not appear in many other boost headers. +// NOTE WELL: This is a workaround for non-conforming compilers; +// must still be #included in the usual places so that inclusion +// works as expected with standard conforming compilers. The resulting +// double inclusion of is harmless. + +# if defined(BOOST_NO_STDC_NAMESPACE) && defined(__cplusplus) +# include + namespace std { using ::ptrdiff_t; using ::size_t; } +# endif + +// Workaround for the unfortunate min/max macros defined by some platform headers + +#define BOOST_PREVENT_MACRO_SUBSTITUTION + +#ifndef BOOST_USING_STD_MIN +# define BOOST_USING_STD_MIN() using std::min +#endif + +#ifndef BOOST_USING_STD_MAX +# define BOOST_USING_STD_MAX() using std::max +#endif + +// BOOST_NO_STD_MIN_MAX workaround -----------------------------------------// + +# if defined(BOOST_NO_STD_MIN_MAX) && defined(__cplusplus) + +namespace std { + template + inline const _Tp& min BOOST_PREVENT_MACRO_SUBSTITUTION (const _Tp& __a, const _Tp& __b) { + return __b < __a ? __b : __a; + } + template + inline const _Tp& max BOOST_PREVENT_MACRO_SUBSTITUTION (const _Tp& __a, const _Tp& __b) { + return __a < __b ? __b : __a; + } +} + +# endif + +// BOOST_STATIC_CONSTANT workaround --------------------------------------- // +// On compilers which don't allow in-class initialization of static integral +// constant members, we must use enums as a workaround if we want the constants +// to be available at compile-time. This macro gives us a convenient way to +// declare such constants. + +# ifdef BOOST_NO_INCLASS_MEMBER_INITIALIZATION +# define BOOST_STATIC_CONSTANT(type, assignment) enum { assignment } +# else +# define BOOST_STATIC_CONSTANT(type, assignment) static const type assignment +# endif + +// BOOST_USE_FACET / HAS_FACET workaround ----------------------------------// +// When the standard library does not have a conforming std::use_facet there +// are various workarounds available, but they differ from library to library. +// The same problem occurs with has_facet. +// These macros provide a consistent way to access a locale's facets. +// Usage: +// replace +// std::use_facet(loc); +// with +// BOOST_USE_FACET(Type, loc); +// Note do not add a std:: prefix to the front of BOOST_USE_FACET! +// Use for BOOST_HAS_FACET is analogous. + +#if defined(BOOST_NO_STD_USE_FACET) +# ifdef BOOST_HAS_TWO_ARG_USE_FACET +# define BOOST_USE_FACET(Type, loc) std::use_facet(loc, static_cast(0)) +# define BOOST_HAS_FACET(Type, loc) std::has_facet(loc, static_cast(0)) +# elif defined(BOOST_HAS_MACRO_USE_FACET) +# define BOOST_USE_FACET(Type, loc) std::_USE(loc, Type) +# define BOOST_HAS_FACET(Type, loc) std::_HAS(loc, Type) +# elif defined(BOOST_HAS_STLP_USE_FACET) +# define BOOST_USE_FACET(Type, loc) (*std::_Use_facet(loc)) +# define BOOST_HAS_FACET(Type, loc) std::has_facet< Type >(loc) +# endif +#else +# define BOOST_USE_FACET(Type, loc) std::use_facet< Type >(loc) +# define BOOST_HAS_FACET(Type, loc) std::has_facet< Type >(loc) +#endif + +// BOOST_NESTED_TEMPLATE workaround ------------------------------------------// +// Member templates are supported by some compilers even though they can't use +// the A::template member syntax, as a workaround replace: +// +// typedef typename A::template rebind binder; +// +// with: +// +// typedef typename A::BOOST_NESTED_TEMPLATE rebind binder; + +#ifndef BOOST_NO_MEMBER_TEMPLATE_KEYWORD +# define BOOST_NESTED_TEMPLATE template +#else +# define BOOST_NESTED_TEMPLATE +#endif + +// BOOST_UNREACHABLE_RETURN(x) workaround -------------------------------------// +// Normally evaluates to nothing, unless BOOST_NO_UNREACHABLE_RETURN_DETECTION +// is defined, in which case it evaluates to return x; Use when you have a return +// statement that can never be reached. + +#ifdef BOOST_NO_UNREACHABLE_RETURN_DETECTION +# define BOOST_UNREACHABLE_RETURN(x) return x; +#else +# define BOOST_UNREACHABLE_RETURN(x) +#endif + +// BOOST_DEDUCED_TYPENAME workaround ------------------------------------------// +// +// Some compilers don't support the use of `typename' for dependent +// types in deduced contexts, e.g. +// +// template void f(T, typename T::type); +// ^^^^^^^^ +// Replace these declarations with: +// +// template void f(T, BOOST_DEDUCED_TYPENAME T::type); + +#ifndef BOOST_NO_DEDUCED_TYPENAME +# define BOOST_DEDUCED_TYPENAME typename +#else +# define BOOST_DEDUCED_TYPENAME +#endif + +#ifndef BOOST_NO_TYPENAME_WITH_CTOR +# define BOOST_CTOR_TYPENAME typename +#else +# define BOOST_CTOR_TYPENAME +#endif + +// long long workaround ------------------------------------------// +// On gcc (and maybe other compilers?) long long is alway supported +// but it's use may generate either warnings (with -ansi), or errors +// (with -pedantic -ansi) unless it's use is prefixed by __extension__ +// +#if defined(BOOST_HAS_LONG_LONG) && defined(__cplusplus) +namespace boost{ +# ifdef __GNUC__ + __extension__ typedef long long long_long_type; + __extension__ typedef unsigned long long ulong_long_type; +# else + typedef long long long_long_type; + typedef unsigned long long ulong_long_type; +# endif +} +#endif +// same again for __int128: +#if defined(BOOST_HAS_INT128) && defined(__cplusplus) +namespace boost{ +# ifdef __GNUC__ + __extension__ typedef __int128 int128_type; + __extension__ typedef unsigned __int128 uint128_type; +# else + typedef __int128 int128_type; + typedef unsigned __int128 uint128_type; +# endif +} +#endif + +// BOOST_[APPEND_]EXPLICIT_TEMPLATE_[NON_]TYPE macros --------------------------// + +// These macros are obsolete. Port away and remove. + +# define BOOST_EXPLICIT_TEMPLATE_TYPE(t) +# define BOOST_EXPLICIT_TEMPLATE_TYPE_SPEC(t) +# define BOOST_EXPLICIT_TEMPLATE_NON_TYPE(t, v) +# define BOOST_EXPLICIT_TEMPLATE_NON_TYPE_SPEC(t, v) + +# define BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(t) +# define BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE_SPEC(t) +# define BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(t, v) +# define BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE_SPEC(t, v) + +// When BOOST_NO_STD_TYPEINFO is defined, we can just import +// the global definition into std namespace: +#if defined(BOOST_NO_STD_TYPEINFO) && defined(__cplusplus) +#include +namespace std{ using ::type_info; } +#endif + +// ---------------------------------------------------------------------------// + +// +// Helper macro BOOST_STRINGIZE: +// Converts the parameter X to a string after macro replacement +// on X has been performed. +// +#define BOOST_STRINGIZE(X) BOOST_DO_STRINGIZE(X) +#define BOOST_DO_STRINGIZE(X) #X + +// +// Helper macro BOOST_JOIN: +// The following piece of macro magic joins the two +// arguments together, even when one of the arguments is +// itself a macro (see 16.3.1 in C++ standard). The key +// is that macro expansion of macro arguments does not +// occur in BOOST_DO_JOIN2 but does in BOOST_DO_JOIN. +// +#define BOOST_JOIN( X, Y ) BOOST_DO_JOIN( X, Y ) +#define BOOST_DO_JOIN( X, Y ) BOOST_DO_JOIN2(X,Y) +#define BOOST_DO_JOIN2( X, Y ) X##Y + +// +// Set some default values for compiler/library/platform names. +// These are for debugging config setup only: +// +# ifndef BOOST_COMPILER +# define BOOST_COMPILER "Unknown ISO C++ Compiler" +# endif +# ifndef BOOST_STDLIB +# define BOOST_STDLIB "Unknown ISO standard library" +# endif +# ifndef BOOST_PLATFORM +# if defined(unix) || defined(__unix) || defined(_XOPEN_SOURCE) \ + || defined(_POSIX_SOURCE) +# define BOOST_PLATFORM "Generic Unix" +# else +# define BOOST_PLATFORM "Unknown" +# endif +# endif + +// +// Set some default values GPU support +// +# ifndef BOOST_GPU_ENABLED +# define BOOST_GPU_ENABLED +# endif + +// BOOST_FORCEINLINE ---------------------------------------------// +// Macro to use in place of 'inline' to force a function to be inline +#if !defined(BOOST_FORCEINLINE) +# if defined(_MSC_VER) +# define BOOST_FORCEINLINE __forceinline +# elif defined(__GNUC__) && __GNUC__ > 3 + // Clang also defines __GNUC__ (as 4) +# define BOOST_FORCEINLINE inline __attribute__ ((__always_inline__)) +# else +# define BOOST_FORCEINLINE inline +# endif +#endif + +// BOOST_NOINLINE ---------------------------------------------// +// Macro to use in place of 'inline' to prevent a function to be inlined +#if !defined(BOOST_NOINLINE) +# if defined(_MSC_VER) +# define BOOST_NOINLINE __declspec(noinline) +# elif defined(__GNUC__) && __GNUC__ > 3 + // Clang also defines __GNUC__ (as 4) +# if defined(__CUDACC__) + // nvcc doesn't always parse __noinline__, + // see: https://svn.boost.org/trac/boost/ticket/9392 +# define BOOST_NOINLINE __attribute__ ((noinline)) +# else +# define BOOST_NOINLINE __attribute__ ((__noinline__)) +# endif +# else +# define BOOST_NOINLINE +# endif +#endif + +// BOOST_NORETURN ---------------------------------------------// +// Macro to use before a function declaration/definition to designate +// the function as not returning normally (i.e. with a return statement +// or by leaving the function scope, if the function return type is void). +#if !defined(BOOST_NORETURN) +# if defined(_MSC_VER) +# define BOOST_NORETURN __declspec(noreturn) +# elif defined(__GNUC__) +# define BOOST_NORETURN __attribute__ ((__noreturn__)) +# else +# define BOOST_NO_NORETURN +# define BOOST_NORETURN +# endif +#endif + +// Branch prediction hints +// These macros are intended to wrap conditional expressions that yield true or false +// +// if (BOOST_LIKELY(var == 10)) +// { +// // the most probable code here +// } +// +#if !defined(BOOST_LIKELY) +# define BOOST_LIKELY(x) x +#endif +#if !defined(BOOST_UNLIKELY) +# define BOOST_UNLIKELY(x) x +#endif + +// Type and data alignment specification +// +#if !defined(BOOST_NO_CXX11_ALIGNAS) +# define BOOST_ALIGNMENT(x) alignas(x) +#elif defined(_MSC_VER) +# define BOOST_ALIGNMENT(x) __declspec(align(x)) +#elif defined(__GNUC__) +# define BOOST_ALIGNMENT(x) __attribute__ ((__aligned__(x))) +#else +# define BOOST_NO_ALIGNMENT +# define BOOST_ALIGNMENT(x) +#endif + +// Lack of non-public defaulted functions is implied by the lack of any defaulted functions +#if !defined(BOOST_NO_CXX11_NON_PUBLIC_DEFAULTED_FUNCTIONS) && defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS) +# define BOOST_NO_CXX11_NON_PUBLIC_DEFAULTED_FUNCTIONS +#endif + +// Defaulted and deleted function declaration helpers +// These macros are intended to be inside a class definition. +// BOOST_DEFAULTED_FUNCTION accepts the function declaration and its +// body, which will be used if the compiler doesn't support defaulted functions. +// BOOST_DELETED_FUNCTION only accepts the function declaration. It +// will expand to a private function declaration, if the compiler doesn't support +// deleted functions. Because of this it is recommended to use BOOST_DELETED_FUNCTION +// in the end of the class definition. +// +// class my_class +// { +// public: +// // Default-constructible +// BOOST_DEFAULTED_FUNCTION(my_class(), {}) +// // Copying prohibited +// BOOST_DELETED_FUNCTION(my_class(my_class const&)) +// BOOST_DELETED_FUNCTION(my_class& operator= (my_class const&)) +// }; +// +#if !(defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS) || defined(BOOST_NO_CXX11_NON_PUBLIC_DEFAULTED_FUNCTIONS)) +# define BOOST_DEFAULTED_FUNCTION(fun, body) fun = default; +#else +# define BOOST_DEFAULTED_FUNCTION(fun, body) fun body +#endif + +#if !defined(BOOST_NO_CXX11_DELETED_FUNCTIONS) +# define BOOST_DELETED_FUNCTION(fun) fun = delete; +#else +# define BOOST_DELETED_FUNCTION(fun) private: fun; +#endif + +// +// Set BOOST_NO_DECLTYPE_N3276 when BOOST_NO_DECLTYPE is defined +// +#if defined(BOOST_NO_CXX11_DECLTYPE) && !defined(BOOST_NO_CXX11_DECLTYPE_N3276) +#define BOOST_NO_CXX11_DECLTYPE_N3276 BOOST_NO_CXX11_DECLTYPE +#endif + +// -------------------- Deprecated macros for 1.50 --------------------------- +// These will go away in a future release + +// Use BOOST_NO_CXX11_HDR_UNORDERED_SET or BOOST_NO_CXX11_HDR_UNORDERED_MAP +// instead of BOOST_NO_STD_UNORDERED +#if defined(BOOST_NO_CXX11_HDR_UNORDERED_MAP) || defined (BOOST_NO_CXX11_HDR_UNORDERED_SET) +# ifndef BOOST_NO_CXX11_STD_UNORDERED +# define BOOST_NO_CXX11_STD_UNORDERED +# endif +#endif + +// Use BOOST_NO_CXX11_HDR_INITIALIZER_LIST instead of BOOST_NO_INITIALIZER_LISTS +#if defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST) && !defined(BOOST_NO_INITIALIZER_LISTS) +# define BOOST_NO_INITIALIZER_LISTS +#endif + +// Use BOOST_NO_CXX11_HDR_ARRAY instead of BOOST_NO_0X_HDR_ARRAY +#if defined(BOOST_NO_CXX11_HDR_ARRAY) && !defined(BOOST_NO_0X_HDR_ARRAY) +# define BOOST_NO_0X_HDR_ARRAY +#endif +// Use BOOST_NO_CXX11_HDR_CHRONO instead of BOOST_NO_0X_HDR_CHRONO +#if defined(BOOST_NO_CXX11_HDR_CHRONO) && !defined(BOOST_NO_0X_HDR_CHRONO) +# define BOOST_NO_0X_HDR_CHRONO +#endif +// Use BOOST_NO_CXX11_HDR_CODECVT instead of BOOST_NO_0X_HDR_CODECVT +#if defined(BOOST_NO_CXX11_HDR_CODECVT) && !defined(BOOST_NO_0X_HDR_CODECVT) +# define BOOST_NO_0X_HDR_CODECVT +#endif +// Use BOOST_NO_CXX11_HDR_CONDITION_VARIABLE instead of BOOST_NO_0X_HDR_CONDITION_VARIABLE +#if defined(BOOST_NO_CXX11_HDR_CONDITION_VARIABLE) && !defined(BOOST_NO_0X_HDR_CONDITION_VARIABLE) +# define BOOST_NO_0X_HDR_CONDITION_VARIABLE +#endif +// Use BOOST_NO_CXX11_HDR_FORWARD_LIST instead of BOOST_NO_0X_HDR_FORWARD_LIST +#if defined(BOOST_NO_CXX11_HDR_FORWARD_LIST) && !defined(BOOST_NO_0X_HDR_FORWARD_LIST) +# define BOOST_NO_0X_HDR_FORWARD_LIST +#endif +// Use BOOST_NO_CXX11_HDR_FUTURE instead of BOOST_NO_0X_HDR_FUTURE +#if defined(BOOST_NO_CXX11_HDR_FUTURE) && !defined(BOOST_NO_0X_HDR_FUTURE) +# define BOOST_NO_0X_HDR_FUTURE +#endif + +// Use BOOST_NO_CXX11_HDR_INITIALIZER_LIST +// instead of BOOST_NO_0X_HDR_INITIALIZER_LIST or BOOST_NO_INITIALIZER_LISTS +#ifdef BOOST_NO_CXX11_HDR_INITIALIZER_LIST +# ifndef BOOST_NO_0X_HDR_INITIALIZER_LIST +# define BOOST_NO_0X_HDR_INITIALIZER_LIST +# endif +# ifndef BOOST_NO_INITIALIZER_LISTS +# define BOOST_NO_INITIALIZER_LISTS +# endif +#endif + +// Use BOOST_NO_CXX11_HDR_MUTEX instead of BOOST_NO_0X_HDR_MUTEX +#if defined(BOOST_NO_CXX11_HDR_MUTEX) && !defined(BOOST_NO_0X_HDR_MUTEX) +# define BOOST_NO_0X_HDR_MUTEX +#endif +// Use BOOST_NO_CXX11_HDR_RANDOM instead of BOOST_NO_0X_HDR_RANDOM +#if defined(BOOST_NO_CXX11_HDR_RANDOM) && !defined(BOOST_NO_0X_HDR_RANDOM) +# define BOOST_NO_0X_HDR_RANDOM +#endif +// Use BOOST_NO_CXX11_HDR_RATIO instead of BOOST_NO_0X_HDR_RATIO +#if defined(BOOST_NO_CXX11_HDR_RATIO) && !defined(BOOST_NO_0X_HDR_RATIO) +# define BOOST_NO_0X_HDR_RATIO +#endif +// Use BOOST_NO_CXX11_HDR_REGEX instead of BOOST_NO_0X_HDR_REGEX +#if defined(BOOST_NO_CXX11_HDR_REGEX) && !defined(BOOST_NO_0X_HDR_REGEX) +# define BOOST_NO_0X_HDR_REGEX +#endif +// Use BOOST_NO_CXX11_HDR_SYSTEM_ERROR instead of BOOST_NO_0X_HDR_SYSTEM_ERROR +#if defined(BOOST_NO_CXX11_HDR_SYSTEM_ERROR) && !defined(BOOST_NO_0X_HDR_SYSTEM_ERROR) +# define BOOST_NO_0X_HDR_SYSTEM_ERROR +#endif +// Use BOOST_NO_CXX11_HDR_THREAD instead of BOOST_NO_0X_HDR_THREAD +#if defined(BOOST_NO_CXX11_HDR_THREAD) && !defined(BOOST_NO_0X_HDR_THREAD) +# define BOOST_NO_0X_HDR_THREAD +#endif +// Use BOOST_NO_CXX11_HDR_TUPLE instead of BOOST_NO_0X_HDR_TUPLE +#if defined(BOOST_NO_CXX11_HDR_TUPLE) && !defined(BOOST_NO_0X_HDR_TUPLE) +# define BOOST_NO_0X_HDR_TUPLE +#endif +// Use BOOST_NO_CXX11_HDR_TYPE_TRAITS instead of BOOST_NO_0X_HDR_TYPE_TRAITS +#if defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS) && !defined(BOOST_NO_0X_HDR_TYPE_TRAITS) +# define BOOST_NO_0X_HDR_TYPE_TRAITS +#endif +// Use BOOST_NO_CXX11_HDR_TYPEINDEX instead of BOOST_NO_0X_HDR_TYPEINDEX +#if defined(BOOST_NO_CXX11_HDR_TYPEINDEX) && !defined(BOOST_NO_0X_HDR_TYPEINDEX) +# define BOOST_NO_0X_HDR_TYPEINDEX +#endif +// Use BOOST_NO_CXX11_HDR_UNORDERED_MAP instead of BOOST_NO_0X_HDR_UNORDERED_MAP +#if defined(BOOST_NO_CXX11_HDR_UNORDERED_MAP) && !defined(BOOST_NO_0X_HDR_UNORDERED_MAP) +# define BOOST_NO_0X_HDR_UNORDERED_MAP +#endif +// Use BOOST_NO_CXX11_HDR_UNORDERED_SET instead of BOOST_NO_0X_HDR_UNORDERED_SET +#if defined(BOOST_NO_CXX11_HDR_UNORDERED_SET) && !defined(BOOST_NO_0X_HDR_UNORDERED_SET) +# define BOOST_NO_0X_HDR_UNORDERED_SET +#endif + +// ------------------ End of deprecated macros for 1.50 --------------------------- + +// -------------------- Deprecated macros for 1.51 --------------------------- +// These will go away in a future release + +// Use BOOST_NO_CXX11_AUTO_DECLARATIONS instead of BOOST_NO_AUTO_DECLARATIONS +#if defined(BOOST_NO_CXX11_AUTO_DECLARATIONS) && !defined(BOOST_NO_AUTO_DECLARATIONS) +# define BOOST_NO_AUTO_DECLARATIONS +#endif +// Use BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS instead of BOOST_NO_AUTO_MULTIDECLARATIONS +#if defined(BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS) && !defined(BOOST_NO_AUTO_MULTIDECLARATIONS) +# define BOOST_NO_AUTO_MULTIDECLARATIONS +#endif +// Use BOOST_NO_CXX11_CHAR16_T instead of BOOST_NO_CHAR16_T +#if defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CHAR16_T) +# define BOOST_NO_CHAR16_T +#endif +// Use BOOST_NO_CXX11_CHAR32_T instead of BOOST_NO_CHAR32_T +#if defined(BOOST_NO_CXX11_CHAR32_T) && !defined(BOOST_NO_CHAR32_T) +# define BOOST_NO_CHAR32_T +#endif +// Use BOOST_NO_CXX11_TEMPLATE_ALIASES instead of BOOST_NO_TEMPLATE_ALIASES +#if defined(BOOST_NO_CXX11_TEMPLATE_ALIASES) && !defined(BOOST_NO_TEMPLATE_ALIASES) +# define BOOST_NO_TEMPLATE_ALIASES +#endif +// Use BOOST_NO_CXX11_CONSTEXPR instead of BOOST_NO_CONSTEXPR +#if defined(BOOST_NO_CXX11_CONSTEXPR) && !defined(BOOST_NO_CONSTEXPR) +# define BOOST_NO_CONSTEXPR +#endif +// Use BOOST_NO_CXX11_DECLTYPE_N3276 instead of BOOST_NO_DECLTYPE_N3276 +#if defined(BOOST_NO_CXX11_DECLTYPE_N3276) && !defined(BOOST_NO_DECLTYPE_N3276) +# define BOOST_NO_DECLTYPE_N3276 +#endif +// Use BOOST_NO_CXX11_DECLTYPE instead of BOOST_NO_DECLTYPE +#if defined(BOOST_NO_CXX11_DECLTYPE) && !defined(BOOST_NO_DECLTYPE) +# define BOOST_NO_DECLTYPE +#endif +// Use BOOST_NO_CXX11_DEFAULTED_FUNCTIONS instead of BOOST_NO_DEFAULTED_FUNCTIONS +#if defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS) && !defined(BOOST_NO_DEFAULTED_FUNCTIONS) +# define BOOST_NO_DEFAULTED_FUNCTIONS +#endif +// Use BOOST_NO_CXX11_DELETED_FUNCTIONS instead of BOOST_NO_DELETED_FUNCTIONS +#if defined(BOOST_NO_CXX11_DELETED_FUNCTIONS) && !defined(BOOST_NO_DELETED_FUNCTIONS) +# define BOOST_NO_DELETED_FUNCTIONS +#endif +// Use BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS instead of BOOST_NO_EXPLICIT_CONVERSION_OPERATORS +#if defined(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS) && !defined(BOOST_NO_EXPLICIT_CONVERSION_OPERATORS) +# define BOOST_NO_EXPLICIT_CONVERSION_OPERATORS +#endif +// Use BOOST_NO_CXX11_EXTERN_TEMPLATE instead of BOOST_NO_EXTERN_TEMPLATE +#if defined(BOOST_NO_CXX11_EXTERN_TEMPLATE) && !defined(BOOST_NO_EXTERN_TEMPLATE) +# define BOOST_NO_EXTERN_TEMPLATE +#endif +// Use BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS instead of BOOST_NO_FUNCTION_TEMPLATE_DEFAULT_ARGS +#if defined(BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS) && !defined(BOOST_NO_FUNCTION_TEMPLATE_DEFAULT_ARGS) +# define BOOST_NO_FUNCTION_TEMPLATE_DEFAULT_ARGS +#endif +// Use BOOST_NO_CXX11_LAMBDAS instead of BOOST_NO_LAMBDAS +#if defined(BOOST_NO_CXX11_LAMBDAS) && !defined(BOOST_NO_LAMBDAS) +# define BOOST_NO_LAMBDAS +#endif +// Use BOOST_NO_CXX11_LOCAL_CLASS_TEMPLATE_PARAMETERS instead of BOOST_NO_LOCAL_CLASS_TEMPLATE_PARAMETERS +#if defined(BOOST_NO_CXX11_LOCAL_CLASS_TEMPLATE_PARAMETERS) && !defined(BOOST_NO_LOCAL_CLASS_TEMPLATE_PARAMETERS) +# define BOOST_NO_LOCAL_CLASS_TEMPLATE_PARAMETERS +#endif +// Use BOOST_NO_CXX11_NOEXCEPT instead of BOOST_NO_NOEXCEPT +#if defined(BOOST_NO_CXX11_NOEXCEPT) && !defined(BOOST_NO_NOEXCEPT) +# define BOOST_NO_NOEXCEPT +#endif +// Use BOOST_NO_CXX11_NULLPTR instead of BOOST_NO_NULLPTR +#if defined(BOOST_NO_CXX11_NULLPTR) && !defined(BOOST_NO_NULLPTR) +# define BOOST_NO_NULLPTR +#endif +// Use BOOST_NO_CXX11_RAW_LITERALS instead of BOOST_NO_RAW_LITERALS +#if defined(BOOST_NO_CXX11_RAW_LITERALS) && !defined(BOOST_NO_RAW_LITERALS) +# define BOOST_NO_RAW_LITERALS +#endif +// Use BOOST_NO_CXX11_RVALUE_REFERENCES instead of BOOST_NO_RVALUE_REFERENCES +#if defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && !defined(BOOST_NO_RVALUE_REFERENCES) +# define BOOST_NO_RVALUE_REFERENCES +#endif +// Use BOOST_NO_CXX11_SCOPED_ENUMS instead of BOOST_NO_SCOPED_ENUMS +#if defined(BOOST_NO_CXX11_SCOPED_ENUMS) && !defined(BOOST_NO_SCOPED_ENUMS) +# define BOOST_NO_SCOPED_ENUMS +#endif +// Use BOOST_NO_CXX11_STATIC_ASSERT instead of BOOST_NO_STATIC_ASSERT +#if defined(BOOST_NO_CXX11_STATIC_ASSERT) && !defined(BOOST_NO_STATIC_ASSERT) +# define BOOST_NO_STATIC_ASSERT +#endif +// Use BOOST_NO_CXX11_STD_UNORDERED instead of BOOST_NO_STD_UNORDERED +#if defined(BOOST_NO_CXX11_STD_UNORDERED) && !defined(BOOST_NO_STD_UNORDERED) +# define BOOST_NO_STD_UNORDERED +#endif +// Use BOOST_NO_CXX11_UNICODE_LITERALS instead of BOOST_NO_UNICODE_LITERALS +#if defined(BOOST_NO_CXX11_UNICODE_LITERALS) && !defined(BOOST_NO_UNICODE_LITERALS) +# define BOOST_NO_UNICODE_LITERALS +#endif +// Use BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX instead of BOOST_NO_UNIFIED_INITIALIZATION_SYNTAX +#if defined(BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX) && !defined(BOOST_NO_UNIFIED_INITIALIZATION_SYNTAX) +# define BOOST_NO_UNIFIED_INITIALIZATION_SYNTAX +#endif +// Use BOOST_NO_CXX11_VARIADIC_TEMPLATES instead of BOOST_NO_VARIADIC_TEMPLATES +#if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_NO_VARIADIC_TEMPLATES) +# define BOOST_NO_VARIADIC_TEMPLATES +#endif +// Use BOOST_NO_CXX11_VARIADIC_MACROS instead of BOOST_NO_VARIADIC_MACROS +#if defined(BOOST_NO_CXX11_VARIADIC_MACROS) && !defined(BOOST_NO_VARIADIC_MACROS) +# define BOOST_NO_VARIADIC_MACROS +#endif +// Use BOOST_NO_CXX11_NUMERIC_LIMITS instead of BOOST_NO_NUMERIC_LIMITS_LOWEST +#if defined(BOOST_NO_CXX11_NUMERIC_LIMITS) && !defined(BOOST_NO_NUMERIC_LIMITS_LOWEST) +# define BOOST_NO_NUMERIC_LIMITS_LOWEST +#endif +// ------------------ End of deprecated macros for 1.51 --------------------------- + + + +// +// Helper macros BOOST_NOEXCEPT, BOOST_NOEXCEPT_IF, BOOST_NOEXCEPT_EXPR +// These aid the transition to C++11 while still supporting C++03 compilers +// +#ifdef BOOST_NO_CXX11_NOEXCEPT +# define BOOST_NOEXCEPT +# define BOOST_NOEXCEPT_OR_NOTHROW throw() +# define BOOST_NOEXCEPT_IF(Predicate) +# define BOOST_NOEXCEPT_EXPR(Expression) false +#else +# define BOOST_NOEXCEPT noexcept +# define BOOST_NOEXCEPT_OR_NOTHROW noexcept +# define BOOST_NOEXCEPT_IF(Predicate) noexcept((Predicate)) +# define BOOST_NOEXCEPT_EXPR(Expression) noexcept((Expression)) +#endif +// +// Helper macro BOOST_FALLTHROUGH +// Fallback definition of BOOST_FALLTHROUGH macro used to mark intended +// fall-through between case labels in a switch statement. We use a definition +// that requires a semicolon after it to avoid at least one type of misuse even +// on unsupported compilers. +// +#ifndef BOOST_FALLTHROUGH +# define BOOST_FALLTHROUGH ((void)0) +#endif + +// +// constexpr workarounds +// +#if defined(BOOST_NO_CXX11_CONSTEXPR) +#define BOOST_CONSTEXPR +#define BOOST_CONSTEXPR_OR_CONST const +#else +#define BOOST_CONSTEXPR constexpr +#define BOOST_CONSTEXPR_OR_CONST constexpr +#endif +#if defined(BOOST_NO_CXX14_CONSTEXPR) +#define BOOST_CXX14_CONSTEXPR +#else +#define BOOST_CXX14_CONSTEXPR constexpr +#endif + +// +// Unused variable/typedef workarounds: +// +#ifndef BOOST_ATTRIBUTE_UNUSED +# define BOOST_ATTRIBUTE_UNUSED +#endif + +#define BOOST_STATIC_CONSTEXPR static BOOST_CONSTEXPR_OR_CONST + +// +// Set BOOST_HAS_STATIC_ASSERT when BOOST_NO_CXX11_STATIC_ASSERT is not defined +// +#if !defined(BOOST_NO_CXX11_STATIC_ASSERT) && !defined(BOOST_HAS_STATIC_ASSERT) +# define BOOST_HAS_STATIC_ASSERT +#endif + +// +// Set BOOST_HAS_RVALUE_REFS when BOOST_NO_CXX11_RVALUE_REFERENCES is not defined +// +#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && !defined(BOOST_HAS_RVALUE_REFS) +#define BOOST_HAS_RVALUE_REFS +#endif + +// +// Set BOOST_HAS_VARIADIC_TMPL when BOOST_NO_CXX11_VARIADIC_TEMPLATES is not defined +// +#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_HAS_VARIADIC_TMPL) +#define BOOST_HAS_VARIADIC_TMPL +#endif +// +// Set BOOST_NO_CXX11_FIXED_LENGTH_VARIADIC_TEMPLATE_EXPANSION_PACKS when +// BOOST_NO_CXX11_VARIADIC_TEMPLATES is set: +// +#if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_FIXED_LENGTH_VARIADIC_TEMPLATE_EXPANSION_PACKS) +# define BOOST_NO_CXX11_FIXED_LENGTH_VARIADIC_TEMPLATE_EXPANSION_PACKS +#endif + +// +// Finish off with checks for macros that are depricated / no longer supported, +// if any of these are set then it's very likely that much of Boost will no +// longer work. So stop with a #error for now, but give the user a chance +// to continue at their own risk if they really want to: +// +#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_CONFIG_ALLOW_DEPRECATED) +# error "You are using a compiler which lacks features which are now a minimum requirement in order to use Boost, define BOOST_CONFIG_ALLOW_DEPRECATED if you want to continue at your own risk!!!" +#endif + +#endif diff --git a/realsense-file/3rd_party/boost/boost/config/user.hpp b/realsense-file/3rd_party/boost/boost/config/user.hpp new file mode 100644 index 0000000000..4d323c3704 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/config/user.hpp @@ -0,0 +1,133 @@ +// boost/config/user.hpp ---------------------------------------------------// + +// (C) Copyright John Maddock 2001. +// Use, modification and distribution are subject to 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) + +// Do not check in modified versions of this file, +// This file may be customized by the end user, but not by boost. + +// +// Use this file to define a site and compiler specific +// configuration policy: +// + +// define this to locate a compiler config file: +// #define BOOST_COMPILER_CONFIG + +// define this to locate a stdlib config file: +// #define BOOST_STDLIB_CONFIG + +// define this to locate a platform config file: +// #define BOOST_PLATFORM_CONFIG + +// define this to disable compiler config, +// use if your compiler config has nothing to set: +// #define BOOST_NO_COMPILER_CONFIG + +// define this to disable stdlib config, +// use if your stdlib config has nothing to set: +// #define BOOST_NO_STDLIB_CONFIG + +// define this to disable platform config, +// use if your platform config has nothing to set: +// #define BOOST_NO_PLATFORM_CONFIG + +// define this to disable all config options, +// excluding the user config. Use if your +// setup is fully ISO compliant, and has no +// useful extensions, or for autoconf generated +// setups: +// #define BOOST_NO_CONFIG + +// define this to make the config "optimistic" +// about unknown compiler versions. Normally +// unknown compiler versions are assumed to have +// all the defects of the last known version, however +// setting this flag, causes the config to assume +// that unknown compiler versions are fully conformant +// with the standard: +// #define BOOST_STRICT_CONFIG + +// define this to cause the config to halt compilation +// with an #error if it encounters anything unknown -- +// either an unknown compiler version or an unknown +// compiler/platform/library: +// #define BOOST_ASSERT_CONFIG + + +// define if you want to disable threading support, even +// when available: +// #define BOOST_DISABLE_THREADS + +// define when you want to disable Win32 specific features +// even when available: +// #define BOOST_DISABLE_WIN32 + +// BOOST_DISABLE_ABI_HEADERS: Stops boost headers from including any +// prefix/suffix headers that normally control things like struct +// packing and alignment. +// #define BOOST_DISABLE_ABI_HEADERS + +// BOOST_ABI_PREFIX: A prefix header to include in place of whatever +// boost.config would normally select, any replacement should set up +// struct packing and alignment options as required. +// #define BOOST_ABI_PREFIX my-header-name + +// BOOST_ABI_SUFFIX: A suffix header to include in place of whatever +// boost.config would normally select, any replacement should undo +// the effects of the prefix header. +// #define BOOST_ABI_SUFFIX my-header-name + +// BOOST_ALL_DYN_LINK: Forces all libraries that have separate source, +// to be linked as dll's rather than static libraries on Microsoft Windows +// (this macro is used to turn on __declspec(dllimport) modifiers, so that +// the compiler knows which symbols to look for in a dll rather than in a +// static library). Note that there may be some libraries that can only +// be linked in one way (statically or dynamically), in these cases this +// macro has no effect. +// #define BOOST_ALL_DYN_LINK + +// BOOST_WHATEVER_DYN_LINK: Forces library "whatever" to be linked as a dll +// rather than a static library on Microsoft Windows: replace the WHATEVER +// part of the macro name with the name of the library that you want to +// dynamically link to, for example use BOOST_DATE_TIME_DYN_LINK or +// BOOST_REGEX_DYN_LINK etc (this macro is used to turn on __declspec(dllimport) +// modifiers, so that the compiler knows which symbols to look for in a dll +// rather than in a static library). +// Note that there may be some libraries that can only +// be linked in one way (statically or dynamically), +// in these cases this macro is unsupported. +// #define BOOST_WHATEVER_DYN_LINK + +// BOOST_ALL_NO_LIB: Tells the config system not to automatically select +// which libraries to link against. +// Normally if a compiler supports #pragma lib, then the correct library +// build variant will be automatically selected and linked against, +// simply by the act of including one of that library's headers. +// This macro turns that feature off. +// #define BOOST_ALL_NO_LIB + +// BOOST_WHATEVER_NO_LIB: Tells the config system not to automatically +// select which library to link against for library "whatever", +// replace WHATEVER in the macro name with the name of the library; +// for example BOOST_DATE_TIME_NO_LIB or BOOST_REGEX_NO_LIB. +// Normally if a compiler supports #pragma lib, then the correct library +// build variant will be automatically selected and linked against, simply +// by the act of including one of that library's headers. This macro turns +// that feature off. +// #define BOOST_WHATEVER_NO_LIB + +// BOOST_LIB_BUILDID: Set to the same value as the value passed to Boost.Build's +// --buildid command line option. For example if you built using: +// +// bjam address-model=64 --buildid=amd64 +// +// then compile your code with: +// +// -DBOOST_LIB_BUILDID = amd64 +// +// to ensure the correct libraries are selected at link time. +// #define BOOST_LIB_BUILDID amd64 + diff --git a/realsense-file/3rd_party/boost/boost/core/addressof.hpp b/realsense-file/3rd_party/boost/boost/core/addressof.hpp new file mode 100644 index 0000000000..a199e9934c --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/core/addressof.hpp @@ -0,0 +1,162 @@ +// Copyright (C) 2002 Brad King (brad.king@kitware.com) +// Douglas Gregor (gregod@cs.rpi.edu) +// +// Copyright (C) 2002, 2008, 2013 Peter Dimov +// +// 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) + +// For more information, see http://www.boost.org + +#ifndef BOOST_CORE_ADDRESSOF_HPP +#define BOOST_CORE_ADDRESSOF_HPP + +# include +# include +# include + +namespace boost +{ + +namespace detail +{ + +template struct addr_impl_ref +{ + T & v_; + + BOOST_FORCEINLINE addr_impl_ref( T & v ): v_( v ) {} + BOOST_FORCEINLINE operator T& () const { return v_; } + +private: + addr_impl_ref & operator=(const addr_impl_ref &); +}; + +template struct addressof_impl +{ + static BOOST_FORCEINLINE T * f( T & v, long ) + { + return reinterpret_cast( + &const_cast(reinterpret_cast(v))); + } + + static BOOST_FORCEINLINE T * f( T * v, int ) + { + return v; + } +}; + +#if !defined( BOOST_NO_CXX11_NULLPTR ) + +#if !defined( BOOST_NO_CXX11_DECLTYPE ) && ( ( defined( __clang__ ) && !defined( _LIBCPP_VERSION ) ) || defined( __INTEL_COMPILER ) ) + + typedef decltype(nullptr) addr_nullptr_t; + +#else + + typedef std::nullptr_t addr_nullptr_t; + +#endif + +template<> struct addressof_impl< addr_nullptr_t > +{ + typedef addr_nullptr_t T; + + static BOOST_FORCEINLINE T * f( T & v, int ) + { + return &v; + } +}; + +template<> struct addressof_impl< addr_nullptr_t const > +{ + typedef addr_nullptr_t const T; + + static BOOST_FORCEINLINE T * f( T & v, int ) + { + return &v; + } +}; + +template<> struct addressof_impl< addr_nullptr_t volatile > +{ + typedef addr_nullptr_t volatile T; + + static BOOST_FORCEINLINE T * f( T & v, int ) + { + return &v; + } +}; + +template<> struct addressof_impl< addr_nullptr_t const volatile > +{ + typedef addr_nullptr_t const volatile T; + + static BOOST_FORCEINLINE T * f( T & v, int ) + { + return &v; + } +}; + +#endif + +} // namespace detail + +template +BOOST_FORCEINLINE +T * addressof( T & v ) +{ +#if (defined( __BORLANDC__ ) && BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT( 0x610 ) ) ) || (defined(__SUNPRO_CC) && BOOST_WORKAROUND(__SUNPRO_CC, <= 0x5120)) + + return boost::detail::addressof_impl::f( v, 0 ); + +#else + + return boost::detail::addressof_impl::f( boost::detail::addr_impl_ref( v ), 0 ); + +#endif +} + +#if defined( __SUNPRO_CC ) && BOOST_WORKAROUND( __SUNPRO_CC, BOOST_TESTED_AT( 0x590 ) ) + +namespace detail +{ + +template struct addressof_addp +{ + typedef T * type; +}; + +} // namespace detail + +template< class T, std::size_t N > +BOOST_FORCEINLINE +typename detail::addressof_addp< T[N] >::type addressof( T (&t)[N] ) +{ + return &t; +} + +#endif + +// Borland doesn't like casting an array reference to a char reference +// but these overloads work around the problem. +#if defined( __BORLANDC__ ) && BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) +template +BOOST_FORCEINLINE +T (*addressof(T (&t)[N]))[N] +{ + return reinterpret_cast(&t); +} + +template +BOOST_FORCEINLINE +const T (*addressof(const T (&t)[N]))[N] +{ + return reinterpret_cast(&t); +} +#endif + +} // namespace boost + +#endif // BOOST_CORE_ADDRESSOF_HPP diff --git a/realsense-file/3rd_party/boost/boost/core/demangle.hpp b/realsense-file/3rd_party/boost/boost/core/demangle.hpp new file mode 100644 index 0000000000..dd635b6819 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/core/demangle.hpp @@ -0,0 +1,121 @@ +#ifndef BOOST_CORE_DEMANGLE_HPP_INCLUDED +#define BOOST_CORE_DEMANGLE_HPP_INCLUDED + +// core::demangle +// +// Copyright 2014 Peter Dimov +// Copyright 2014 Andrey Semashev +// +// 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 +#include + +#if defined(BOOST_HAS_PRAGMA_ONCE) +# pragma once +#endif + +#if defined( __clang__ ) && defined( __has_include ) +# if __has_include() +# define BOOST_CORE_HAS_CXXABI_H +# endif +#elif defined( __GLIBCXX__ ) || defined( __GLIBCPP__ ) +# define BOOST_CORE_HAS_CXXABI_H +#endif + +#if defined( BOOST_CORE_HAS_CXXABI_H ) +# include +# include +# include +#endif + +namespace boost +{ + +namespace core +{ + +inline char const * demangle_alloc( char const * name ) BOOST_NOEXCEPT; +inline void demangle_free( char const * name ) BOOST_NOEXCEPT; + +class scoped_demangled_name +{ +private: + char const * m_p; + +public: + explicit scoped_demangled_name( char const * name ) BOOST_NOEXCEPT : + m_p( demangle_alloc( name ) ) + { + } + + ~scoped_demangled_name() BOOST_NOEXCEPT + { + demangle_free( m_p ); + } + + char const * get() const BOOST_NOEXCEPT + { + return m_p; + } + + BOOST_DELETED_FUNCTION(scoped_demangled_name( scoped_demangled_name const& )) + BOOST_DELETED_FUNCTION(scoped_demangled_name& operator= ( scoped_demangled_name const& )) +}; + + +#if defined( BOOST_CORE_HAS_CXXABI_H ) + +inline char const * demangle_alloc( char const * name ) BOOST_NOEXCEPT +{ + int status = 0; + std::size_t size = 0; + return abi::__cxa_demangle( name, NULL, &size, &status ); +} + +inline void demangle_free( char const * name ) BOOST_NOEXCEPT +{ + std::free( const_cast< char* >( name ) ); +} + +inline std::string demangle( char const * name ) +{ + scoped_demangled_name demangled_name( name ); + char const * const p = demangled_name.get(); + if( p ) + { + return p; + } + else + { + return name; + } +} + +#else + +inline char const * demangle_alloc( char const * name ) BOOST_NOEXCEPT +{ + return name; +} + +inline void demangle_free( char const * ) BOOST_NOEXCEPT +{ +} + +inline std::string demangle( char const * name ) +{ + return name; +} + +#endif + +} // namespace core + +} // namespace boost + +#undef BOOST_CORE_HAS_CXXABI_H + +#endif // #ifndef BOOST_CORE_DEMANGLE_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/core/enable_if.hpp b/realsense-file/3rd_party/boost/boost/core/enable_if.hpp new file mode 100644 index 0000000000..76e9e4fe71 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/core/enable_if.hpp @@ -0,0 +1,119 @@ +// Boost enable_if library + +// Copyright 2003 (c) The Trustees of Indiana University. + +// Use, modification, and distribution is subject to 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) + +// Authors: Jaakko Jarvi (jajarvi at osl.iu.edu) +// Jeremiah Willcock (jewillco at osl.iu.edu) +// Andrew Lumsdaine (lums at osl.iu.edu) + + +#ifndef BOOST_CORE_ENABLE_IF_HPP +#define BOOST_CORE_ENABLE_IF_HPP + +#include "boost/config.hpp" + +// Even the definition of enable_if causes problems on some compilers, +// so it's macroed out for all compilers that do not support SFINAE + +#ifndef BOOST_NO_SFINAE + +namespace boost +{ + + template + struct enable_if_c { + typedef T type; + }; + + template + struct enable_if_c {}; + + template + struct enable_if : public enable_if_c {}; + + template + struct lazy_enable_if_c { + typedef typename T::type type; + }; + + template + struct lazy_enable_if_c {}; + + template + struct lazy_enable_if : public lazy_enable_if_c {}; + + + template + struct disable_if_c { + typedef T type; + }; + + template + struct disable_if_c {}; + + template + struct disable_if : public disable_if_c {}; + + template + struct lazy_disable_if_c { + typedef typename T::type type; + }; + + template + struct lazy_disable_if_c {}; + + template + struct lazy_disable_if : public lazy_disable_if_c {}; + +} // namespace boost + +#else + +namespace boost { + + namespace detail { typedef void enable_if_default_T; } + + template + struct enable_if_does_not_work_on_this_compiler; + + template + struct enable_if_c : enable_if_does_not_work_on_this_compiler + { }; + + template + struct disable_if_c : enable_if_does_not_work_on_this_compiler + { }; + + template + struct lazy_enable_if_c : enable_if_does_not_work_on_this_compiler + { }; + + template + struct lazy_disable_if_c : enable_if_does_not_work_on_this_compiler + { }; + + template + struct enable_if : enable_if_does_not_work_on_this_compiler + { }; + + template + struct disable_if : enable_if_does_not_work_on_this_compiler + { }; + + template + struct lazy_enable_if : enable_if_does_not_work_on_this_compiler + { }; + + template + struct lazy_disable_if : enable_if_does_not_work_on_this_compiler + { }; + +} // namespace boost + +#endif // BOOST_NO_SFINAE + +#endif diff --git a/realsense-file/3rd_party/boost/boost/core/explicit_operator_bool.hpp b/realsense-file/3rd_party/boost/boost/core/explicit_operator_bool.hpp new file mode 100644 index 0000000000..9b3fb5169d --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/core/explicit_operator_bool.hpp @@ -0,0 +1,154 @@ +/* + * Copyright Andrey Semashev 2007 - 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) + */ + +/*! + * \file explicit_operator_bool.hpp + * \author Andrey Semashev + * \date 08.03.2009 + * + * This header defines a compatibility macro that implements an unspecified + * \c bool operator idiom, which is superseded with explicit conversion operators in + * C++11. + */ + +#ifndef BOOST_CORE_EXPLICIT_OPERATOR_BOOL_HPP +#define BOOST_CORE_EXPLICIT_OPERATOR_BOOL_HPP + +#include + +#ifdef BOOST_HAS_PRAGMA_ONCE +#pragma once +#endif + +#if !defined(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS) + +/*! + * \brief The macro defines an explicit operator of conversion to \c bool + * + * The macro should be used inside the definition of a class that has to + * support the conversion. The class should also implement operator!, + * in terms of which the conversion operator will be implemented. + */ +#define BOOST_EXPLICIT_OPERATOR_BOOL()\ + BOOST_FORCEINLINE explicit operator bool () const\ + {\ + return !this->operator! ();\ + } + +/*! + * \brief The macro defines a noexcept explicit operator of conversion to \c bool + * + * The macro should be used inside the definition of a class that has to + * support the conversion. The class should also implement operator!, + * in terms of which the conversion operator will be implemented. + */ +#define BOOST_EXPLICIT_OPERATOR_BOOL_NOEXCEPT()\ + BOOST_FORCEINLINE explicit operator bool () const BOOST_NOEXCEPT\ + {\ + return !this->operator! ();\ + } + +/*! + * \brief The macro defines a constexpr explicit operator of conversion to \c bool + * + * The macro should be used inside the definition of a class that has to + * support the conversion. The class should also implement operator!, + * in terms of which the conversion operator will be implemented. + */ +#define BOOST_CONSTEXPR_EXPLICIT_OPERATOR_BOOL()\ + BOOST_FORCEINLINE BOOST_CONSTEXPR explicit operator bool () const BOOST_NOEXCEPT\ + {\ + return !this->operator! ();\ + } + +#else // !defined(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS) + +#if (defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x530)) && !defined(BOOST_NO_COMPILER_CONFIG) +// Sun C++ 5.3 can't handle the safe_bool idiom, so don't use it +#define BOOST_NO_UNSPECIFIED_BOOL +#endif // (defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x530)) && !defined(BOOST_NO_COMPILER_CONFIG) + +#if !defined(BOOST_NO_UNSPECIFIED_BOOL) + +namespace boost { + +namespace detail { + +#if !defined(_MSC_VER) && !defined(__IBMCPP__) + + struct unspecified_bool + { + // NOTE TO THE USER: If you see this in error messages then you tried + // to apply an unsupported operator on the object that supports + // explicit conversion to bool. + struct OPERATORS_NOT_ALLOWED; + static void true_value(OPERATORS_NOT_ALLOWED*) {} + }; + typedef void (*unspecified_bool_type)(unspecified_bool::OPERATORS_NOT_ALLOWED*); + +#else + + // MSVC and VACPP are too eager to convert pointer to function to void* even though they shouldn't + struct unspecified_bool + { + // NOTE TO THE USER: If you see this in error messages then you tried + // to apply an unsupported operator on the object that supports + // explicit conversion to bool. + struct OPERATORS_NOT_ALLOWED; + void true_value(OPERATORS_NOT_ALLOWED*) {} + }; + typedef void (unspecified_bool::*unspecified_bool_type)(unspecified_bool::OPERATORS_NOT_ALLOWED*); + +#endif + +} // namespace detail + +} // namespace boost + +#define BOOST_EXPLICIT_OPERATOR_BOOL()\ + BOOST_FORCEINLINE operator boost::detail::unspecified_bool_type () const\ + {\ + return (!this->operator! () ? &boost::detail::unspecified_bool::true_value : (boost::detail::unspecified_bool_type)0);\ + } + +#define BOOST_EXPLICIT_OPERATOR_BOOL_NOEXCEPT()\ + BOOST_FORCEINLINE operator boost::detail::unspecified_bool_type () const BOOST_NOEXCEPT\ + {\ + return (!this->operator! () ? &boost::detail::unspecified_bool::true_value : (boost::detail::unspecified_bool_type)0);\ + } + +#define BOOST_CONSTEXPR_EXPLICIT_OPERATOR_BOOL()\ + BOOST_FORCEINLINE BOOST_CONSTEXPR operator boost::detail::unspecified_bool_type () const BOOST_NOEXCEPT\ + {\ + return (!this->operator! () ? &boost::detail::unspecified_bool::true_value : (boost::detail::unspecified_bool_type)0);\ + } + +#else // !defined(BOOST_NO_UNSPECIFIED_BOOL) + +#define BOOST_EXPLICIT_OPERATOR_BOOL()\ + BOOST_FORCEINLINE operator bool () const\ + {\ + return !this->operator! ();\ + } + +#define BOOST_EXPLICIT_OPERATOR_BOOL_NOEXCEPT()\ + BOOST_FORCEINLINE operator bool () const BOOST_NOEXCEPT\ + {\ + return !this->operator! ();\ + } + +#define BOOST_CONSTEXPR_EXPLICIT_OPERATOR_BOOL()\ + BOOST_FORCEINLINE BOOST_CONSTEXPR operator bool () const BOOST_NOEXCEPT\ + {\ + return !this->operator! ();\ + } + +#endif // !defined(BOOST_NO_UNSPECIFIED_BOOL) + +#endif // !defined(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS) + +#endif // BOOST_CORE_EXPLICIT_OPERATOR_BOOL_HPP diff --git a/realsense-file/3rd_party/boost/boost/core/no_exceptions_support.hpp b/realsense-file/3rd_party/boost/boost/core/no_exceptions_support.hpp new file mode 100644 index 0000000000..7365d19b40 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/core/no_exceptions_support.hpp @@ -0,0 +1,44 @@ +#ifndef BOOST_CORE_NO_EXCEPTIONS_SUPPORT_HPP +#define BOOST_CORE_NO_EXCEPTIONS_SUPPORT_HPP + +#if defined(_MSC_VER) +# pragma once +#endif + +//---------------------------------------------------------------------- +// (C) Copyright 2004 Pavel Vozenilek. +// Use, modification and distribution is subject to 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) +// +// +// This file contains helper macros used when exception support may be +// disabled (as indicated by macro BOOST_NO_EXCEPTIONS). +// +// Before picking up these macros you may consider using RAII techniques +// to deal with exceptions - their syntax can be always the same with +// or without exception support enabled. +//---------------------------------------------------------------------- + +#include +#include + +#if !(defined BOOST_NO_EXCEPTIONS) +# define BOOST_TRY { try +# define BOOST_CATCH(x) catch(x) +# define BOOST_RETHROW throw; +# define BOOST_CATCH_END } +#else +# if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) +# define BOOST_TRY { if ("") +# define BOOST_CATCH(x) else if (!"") +# else +# define BOOST_TRY { if (true) +# define BOOST_CATCH(x) else if (false) +# endif +# define BOOST_RETHROW +# define BOOST_CATCH_END } +#endif + + +#endif diff --git a/realsense-file/3rd_party/boost/boost/core/noncopyable.hpp b/realsense-file/3rd_party/boost/boost/core/noncopyable.hpp new file mode 100644 index 0000000000..a4c207592f --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/core/noncopyable.hpp @@ -0,0 +1,48 @@ +// Boost noncopyable.hpp header file --------------------------------------// + +// (C) Copyright Beman Dawes 1999-2003. Distributed under the Boost +// Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org/libs/utility for documentation. + +#ifndef BOOST_CORE_NONCOPYABLE_HPP +#define BOOST_CORE_NONCOPYABLE_HPP + +#include + +namespace boost { + +// Private copy constructor and copy assignment ensure classes derived from +// class noncopyable cannot be copied. + +// Contributed by Dave Abrahams + +namespace noncopyable_ // protection from unintended ADL +{ + class noncopyable + { + protected: +#if !defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS) && !defined(BOOST_NO_CXX11_NON_PUBLIC_DEFAULTED_FUNCTIONS) + BOOST_CONSTEXPR noncopyable() = default; + ~noncopyable() = default; +#else + noncopyable() {} + ~noncopyable() {} +#endif +#if !defined(BOOST_NO_CXX11_DELETED_FUNCTIONS) + noncopyable( const noncopyable& ) = delete; + noncopyable& operator=( const noncopyable& ) = delete; +#else + private: // emphasize the following members are private + noncopyable( const noncopyable& ); + noncopyable& operator=( const noncopyable& ); +#endif + }; +} + +typedef noncopyable_::noncopyable noncopyable; + +} // namespace boost + +#endif // BOOST_CORE_NONCOPYABLE_HPP diff --git a/realsense-file/3rd_party/boost/boost/core/ref.hpp b/realsense-file/3rd_party/boost/boost/core/ref.hpp new file mode 100644 index 0000000000..60f01a4bdf --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/core/ref.hpp @@ -0,0 +1,301 @@ +#ifndef BOOST_CORE_REF_HPP +#define BOOST_CORE_REF_HPP + +// MS compatible compilers support #pragma once + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma once +#endif + +#include +#include +#include + +// +// ref.hpp - ref/cref, useful helper functions +// +// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi) +// Copyright (C) 2001, 2002 Peter Dimov +// Copyright (C) 2002 David Abrahams +// +// Copyright (C) 2014 Glen Joseph Fernandes +// glenfe at live dot com +// Copyright (C) 2014 Agustin Berge +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/core/doc/html/core/ref.html for documentation. +// + +/** + @file +*/ + +/** + Boost namespace. +*/ +namespace boost +{ + +#if defined( BOOST_MSVC ) && BOOST_WORKAROUND( BOOST_MSVC, == 1600 ) + + struct ref_workaround_tag {}; + +#endif + +// reference_wrapper + +/** + @brief Contains a reference to an object of type `T`. + + `reference_wrapper` is primarily used to "feed" references to + function templates (algorithms) that take their parameter by + value. It provides an implicit conversion to `T&`, which + usually allows the function templates to work on references + unmodified. +*/ +template class reference_wrapper +{ +public: + /** + Type `T`. + */ + typedef T type; + + /** + Constructs a `reference_wrapper` object that stores a + reference to `t`. + + @remark Does not throw. + */ + BOOST_FORCEINLINE explicit reference_wrapper(T& t): t_(boost::addressof(t)) {} + +#if defined( BOOST_MSVC ) && BOOST_WORKAROUND( BOOST_MSVC, == 1600 ) + + BOOST_FORCEINLINE explicit reference_wrapper( T & t, ref_workaround_tag ): t_( boost::addressof( t ) ) {} + +#endif + +#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) + /** + @remark Construction from a temporary object is disabled. + */ + BOOST_DELETED_FUNCTION(reference_wrapper(T&& t)) +public: +#endif + + /** + @return The stored reference. + @remark Does not throw. + */ + BOOST_FORCEINLINE operator T& () const { return *t_; } + + /** + @return The stored reference. + @remark Does not throw. + */ + BOOST_FORCEINLINE T& get() const { return *t_; } + + /** + @return A pointer to the object referenced by the stored + reference. + @remark Does not throw. + */ + BOOST_FORCEINLINE T* get_pointer() const { return t_; } + +private: + + T* t_; +}; + +// ref + +/** + @cond +*/ +#if defined( __BORLANDC__ ) && BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT(0x581) ) +# define BOOST_REF_CONST +#else +# define BOOST_REF_CONST const +#endif +/** + @endcond +*/ + +/** + @return `reference_wrapper(t)` + @remark Does not throw. +*/ +template BOOST_FORCEINLINE reference_wrapper BOOST_REF_CONST ref( T & t ) +{ +#if defined( BOOST_MSVC ) && BOOST_WORKAROUND( BOOST_MSVC, == 1600 ) + + return reference_wrapper( t, ref_workaround_tag() ); + +#else + + return reference_wrapper( t ); + +#endif +} + +// cref + +/** + @return `reference_wrapper(t)` + @remark Does not throw. +*/ +template BOOST_FORCEINLINE reference_wrapper BOOST_REF_CONST cref( T const & t ) +{ + return reference_wrapper(t); +} + +#undef BOOST_REF_CONST + +#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) + +/** + @cond +*/ +#if defined(BOOST_NO_CXX11_DELETED_FUNCTIONS) +# define BOOST_REF_DELETE +#else +# define BOOST_REF_DELETE = delete +#endif +/** + @endcond +*/ + +/** + @remark Construction from a temporary object is disabled. +*/ +template void ref(T const&&) BOOST_REF_DELETE; + +/** + @remark Construction from a temporary object is disabled. +*/ +template void cref(T const&&) BOOST_REF_DELETE; + +#undef BOOST_REF_DELETE + +#endif + +// is_reference_wrapper + +/** + @brief Determine if a type `T` is an instantiation of + `reference_wrapper`. + + The value static constant will be true if the type `T` is a + specialization of `reference_wrapper`. +*/ +template struct is_reference_wrapper +{ + BOOST_STATIC_CONSTANT( bool, value = false ); +}; + +/** + @cond +*/ +template struct is_reference_wrapper< reference_wrapper > +{ + BOOST_STATIC_CONSTANT( bool, value = true ); +}; + +#if !defined(BOOST_NO_CV_SPECIALIZATIONS) + +template struct is_reference_wrapper< reference_wrapper const > +{ + BOOST_STATIC_CONSTANT( bool, value = true ); +}; + +template struct is_reference_wrapper< reference_wrapper volatile > +{ + BOOST_STATIC_CONSTANT( bool, value = true ); +}; + +template struct is_reference_wrapper< reference_wrapper const volatile > +{ + BOOST_STATIC_CONSTANT( bool, value = true ); +}; + +#endif // !defined(BOOST_NO_CV_SPECIALIZATIONS) + +/** + @endcond +*/ + + +// unwrap_reference + +/** + @brief Find the type in a `reference_wrapper`. + + The `typedef` type is `T::type` if `T` is a + `reference_wrapper`, `T` otherwise. +*/ +template struct unwrap_reference +{ + typedef T type; +}; + +/** + @cond +*/ +template struct unwrap_reference< reference_wrapper > +{ + typedef T type; +}; + +#if !defined(BOOST_NO_CV_SPECIALIZATIONS) + +template struct unwrap_reference< reference_wrapper const > +{ + typedef T type; +}; + +template struct unwrap_reference< reference_wrapper volatile > +{ + typedef T type; +}; + +template struct unwrap_reference< reference_wrapper const volatile > +{ + typedef T type; +}; + +#endif // !defined(BOOST_NO_CV_SPECIALIZATIONS) + +/** + @endcond +*/ + +// unwrap_ref + +/** + @return `unwrap_reference::type&(t)` + @remark Does not throw. +*/ +template BOOST_FORCEINLINE typename unwrap_reference::type& unwrap_ref( T & t ) +{ + return t; +} + +// get_pointer + +/** + @cond +*/ +template BOOST_FORCEINLINE T* get_pointer( reference_wrapper const & r ) +{ + return r.get_pointer(); +} +/** + @endcond +*/ + +} // namespace boost + +#endif // #ifndef BOOST_CORE_REF_HPP diff --git a/realsense-file/3rd_party/boost/boost/core/swap.hpp b/realsense-file/3rd_party/boost/boost/core/swap.hpp new file mode 100644 index 0000000000..e06d268e59 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/core/swap.hpp @@ -0,0 +1,60 @@ +// Copyright (C) 2007, 2008 Steven Watanabe, Joseph Gauterin, Niels Dekker +// +// 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) +// For more information, see http://www.boost.org + + +#ifndef BOOST_CORE_SWAP_HPP +#define BOOST_CORE_SWAP_HPP + +// Note: the implementation of this utility contains various workarounds: +// - swap_impl is put outside the boost namespace, to avoid infinite +// recursion (causing stack overflow) when swapping objects of a primitive +// type. +// - swap_impl has a using-directive, rather than a using-declaration, +// because some compilers (including MSVC 7.1, Borland 5.9.3, and +// Intel 8.1) don't do argument-dependent lookup when it has a +// using-declaration instead. +// - boost::swap has two template arguments, instead of one, to +// avoid ambiguity when swapping objects of a Boost type that does +// not have its own boost::swap overload. + +#include //for std::swap (C++11) +#include //for std::swap (C++98) +#include //for std::size_t +#include + +namespace boost_swap_impl +{ + template + BOOST_GPU_ENABLED + void swap_impl(T& left, T& right) + { + using namespace std;//use std::swap if argument dependent lookup fails + swap(left,right); + } + + template + BOOST_GPU_ENABLED + void swap_impl(T (& left)[N], T (& right)[N]) + { + for (std::size_t i = 0; i < N; ++i) + { + ::boost_swap_impl::swap_impl(left[i], right[i]); + } + } +} + +namespace boost +{ + template + BOOST_GPU_ENABLED + void swap(T1& left, T2& right) + { + ::boost_swap_impl::swap_impl(left, right); + } +} + +#endif diff --git a/realsense-file/3rd_party/boost/boost/core/typeinfo.hpp b/realsense-file/3rd_party/boost/boost/core/typeinfo.hpp new file mode 100644 index 0000000000..abd7b41608 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/core/typeinfo.hpp @@ -0,0 +1,151 @@ +#ifndef BOOST_CORE_TYPEINFO_HPP_INCLUDED +#define BOOST_CORE_TYPEINFO_HPP_INCLUDED + +// MS compatible compilers support #pragma once + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma once +#endif + +// core::typeinfo, BOOST_CORE_TYPEID +// +// Copyright 2007, 2014 Peter Dimov +// +// 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 + +#if defined( BOOST_NO_TYPEID ) + +#include +#include + +namespace boost +{ + +namespace core +{ + +class typeinfo +{ +private: + + typeinfo( typeinfo const& ); + typeinfo& operator=( typeinfo const& ); + + char const * name_; + +public: + + explicit typeinfo( char const * name ): name_( name ) + { + } + + bool operator==( typeinfo const& rhs ) const + { + return this == &rhs; + } + + bool operator!=( typeinfo const& rhs ) const + { + return this != &rhs; + } + + bool before( typeinfo const& rhs ) const + { + return std::less< typeinfo const* >()( this, &rhs ); + } + + char const* name() const + { + return name_; + } +}; + +inline char const * demangled_name( core::typeinfo const & ti ) +{ + return ti.name(); +} + +} // namespace core + +namespace detail +{ + +template struct core_typeid_ +{ + static boost::core::typeinfo ti_; + + static char const * name() + { + return BOOST_CURRENT_FUNCTION; + } +}; + +#if defined(__SUNPRO_CC) +// see #4199, the Sun Studio compiler gets confused about static initialization +// constructor arguments. But an assignment works just fine. +template boost::core::typeinfo core_typeid_< T >::ti_ = core_typeid_< T >::name(); +#else +template boost::core::typeinfo core_typeid_< T >::ti_(core_typeid_< T >::name()); +#endif + +template struct core_typeid_< T & >: core_typeid_< T > +{ +}; + +template struct core_typeid_< T const >: core_typeid_< T > +{ +}; + +template struct core_typeid_< T volatile >: core_typeid_< T > +{ +}; + +template struct core_typeid_< T const volatile >: core_typeid_< T > +{ +}; + +} // namespace detail + +} // namespace boost + +#define BOOST_CORE_TYPEID(T) (boost::detail::core_typeid_::ti_) + +#else + +#include +#include + +namespace boost +{ + +namespace core +{ + +#if defined( BOOST_NO_STD_TYPEINFO ) + +typedef ::type_info typeinfo; + +#else + +typedef std::type_info typeinfo; + +#endif + +inline std::string demangled_name( core::typeinfo const & ti ) +{ + return core::demangle( ti.name() ); +} + +} // namespace core + +} // namespace boost + +#define BOOST_CORE_TYPEID(T) typeid(T) + +#endif + +#endif // #ifndef BOOST_CORE_TYPEINFO_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/cstdint.hpp b/realsense-file/3rd_party/boost/boost/cstdint.hpp new file mode 100644 index 0000000000..d6aae237cf --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/cstdint.hpp @@ -0,0 +1,546 @@ +// boost cstdint.hpp header file ------------------------------------------// + +// (C) Copyright Beman Dawes 1999. +// (C) Copyright Jens Mauer 2001 +// (C) Copyright John Maddock 2001 +// Distributed under the Boost +// Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org/libs/integer for documentation. + +// Revision History +// 31 Oct 01 use BOOST_HAS_LONG_LONG to check for "long long" (Jens M.) +// 16 Apr 01 check LONGLONG_MAX when looking for "long long" (Jens Maurer) +// 23 Jan 01 prefer "long" over "int" for int32_t and intmax_t (Jens Maurer) +// 12 Nov 00 Merged (Jens Maurer) +// 23 Sep 00 Added INTXX_C macro support (John Maddock). +// 22 Sep 00 Better 64-bit support (John Maddock) +// 29 Jun 00 Reimplement to avoid including stdint.h within namespace boost +// 8 Aug 99 Initial version (Beman Dawes) + + +#ifndef BOOST_CSTDINT_HPP +#define BOOST_CSTDINT_HPP + +// +// Since we always define the INT#_C macros as per C++0x, +// define __STDC_CONSTANT_MACROS so that does the right +// thing if possible, and so that the user knows that the macros +// are actually defined as per C99. +// +#ifndef __STDC_CONSTANT_MACROS +# define __STDC_CONSTANT_MACROS +#endif + +#include + +// +// Note that GLIBC is a bit inconsistent about whether int64_t is defined or not +// depending upon what headers happen to have been included first... +// so we disable use of stdint.h when GLIBC does not define __GLIBC_HAVE_LONG_LONG. +// See https://svn.boost.org/trac/boost/ticket/3548 and http://sources.redhat.com/bugzilla/show_bug.cgi?id=10990 +// +#if defined(BOOST_HAS_STDINT_H) \ + && (!defined(__GLIBC__) \ + || defined(__GLIBC_HAVE_LONG_LONG) \ + || (defined(__GLIBC__) && ((__GLIBC__ > 2) || ((__GLIBC__ == 2) && (__GLIBC_MINOR__ >= 17))))) + +// The following #include is an implementation artifact; not part of interface. +# ifdef __hpux +// HP-UX has a vaguely nice in a non-standard location +# include +# ifdef __STDC_32_MODE__ + // this is triggered with GCC, because it defines __cplusplus < 199707L +# define BOOST_NO_INT64_T +# endif +# elif defined(__FreeBSD__) || defined(__IBMCPP__) || defined(_AIX) +# include +# else +# include + +// There is a bug in Cygwin two _C macros +# if defined(__STDC_CONSTANT_MACROS) && defined(__CYGWIN__) +# undef INTMAX_C +# undef UINTMAX_C +# define INTMAX_C(c) c##LL +# define UINTMAX_C(c) c##ULL +# endif + +# endif + +#ifdef __QNX__ + +// QNX (Dinkumware stdlib) defines these as non-standard names. +// Reflect to the standard names. + +typedef ::intleast8_t int_least8_t; +typedef ::intfast8_t int_fast8_t; +typedef ::uintleast8_t uint_least8_t; +typedef ::uintfast8_t uint_fast8_t; + +typedef ::intleast16_t int_least16_t; +typedef ::intfast16_t int_fast16_t; +typedef ::uintleast16_t uint_least16_t; +typedef ::uintfast16_t uint_fast16_t; + +typedef ::intleast32_t int_least32_t; +typedef ::intfast32_t int_fast32_t; +typedef ::uintleast32_t uint_least32_t; +typedef ::uintfast32_t uint_fast32_t; + +# ifndef BOOST_NO_INT64_T + +typedef ::intleast64_t int_least64_t; +typedef ::intfast64_t int_fast64_t; +typedef ::uintleast64_t uint_least64_t; +typedef ::uintfast64_t uint_fast64_t; + +# endif + +#endif + +namespace boost +{ + + using ::int8_t; + using ::int_least8_t; + using ::int_fast8_t; + using ::uint8_t; + using ::uint_least8_t; + using ::uint_fast8_t; + + using ::int16_t; + using ::int_least16_t; + using ::int_fast16_t; + using ::uint16_t; + using ::uint_least16_t; + using ::uint_fast16_t; + + using ::int32_t; + using ::int_least32_t; + using ::int_fast32_t; + using ::uint32_t; + using ::uint_least32_t; + using ::uint_fast32_t; + +# ifndef BOOST_NO_INT64_T + + using ::int64_t; + using ::int_least64_t; + using ::int_fast64_t; + using ::uint64_t; + using ::uint_least64_t; + using ::uint_fast64_t; + +# endif + + using ::intmax_t; + using ::uintmax_t; + +} // namespace boost + +#elif defined(__FreeBSD__) && (__FreeBSD__ <= 4) || defined(__osf__) || defined(__VMS) || defined(__SOLARIS9__) || defined(__NetBSD__) +// FreeBSD and Tru64 have an that contains much of what we need. +# include + +namespace boost { + + using ::int8_t; + typedef int8_t int_least8_t; + typedef int8_t int_fast8_t; + using ::uint8_t; + typedef uint8_t uint_least8_t; + typedef uint8_t uint_fast8_t; + + using ::int16_t; + typedef int16_t int_least16_t; + typedef int16_t int_fast16_t; + using ::uint16_t; + typedef uint16_t uint_least16_t; + typedef uint16_t uint_fast16_t; + + using ::int32_t; + typedef int32_t int_least32_t; + typedef int32_t int_fast32_t; + using ::uint32_t; + typedef uint32_t uint_least32_t; + typedef uint32_t uint_fast32_t; + +# ifndef BOOST_NO_INT64_T + + using ::int64_t; + typedef int64_t int_least64_t; + typedef int64_t int_fast64_t; + using ::uint64_t; + typedef uint64_t uint_least64_t; + typedef uint64_t uint_fast64_t; + + typedef int64_t intmax_t; + typedef uint64_t uintmax_t; + +# else + + typedef int32_t intmax_t; + typedef uint32_t uintmax_t; + +# endif + +} // namespace boost + +#else // BOOST_HAS_STDINT_H + +# include // implementation artifact; not part of interface +# include // needed for limits macros + + +namespace boost +{ + +// These are fairly safe guesses for some 16-bit, and most 32-bit and 64-bit +// platforms. For other systems, they will have to be hand tailored. +// +// Because the fast types are assumed to be the same as the undecorated types, +// it may be possible to hand tailor a more efficient implementation. Such +// an optimization may be illusionary; on the Intel x86-family 386 on, for +// example, byte arithmetic and load/stores are as fast as "int" sized ones. + +// 8-bit types ------------------------------------------------------------// + +# if UCHAR_MAX == 0xff + typedef signed char int8_t; + typedef signed char int_least8_t; + typedef signed char int_fast8_t; + typedef unsigned char uint8_t; + typedef unsigned char uint_least8_t; + typedef unsigned char uint_fast8_t; +# else +# error defaults not correct; you must hand modify boost/cstdint.hpp +# endif + +// 16-bit types -----------------------------------------------------------// + +# if USHRT_MAX == 0xffff +# if defined(__crayx1) + // The Cray X1 has a 16-bit short, however it is not recommend + // for use in performance critical code. + typedef short int16_t; + typedef short int_least16_t; + typedef int int_fast16_t; + typedef unsigned short uint16_t; + typedef unsigned short uint_least16_t; + typedef unsigned int uint_fast16_t; +# else + typedef short int16_t; + typedef short int_least16_t; + typedef short int_fast16_t; + typedef unsigned short uint16_t; + typedef unsigned short uint_least16_t; + typedef unsigned short uint_fast16_t; +# endif +# elif (USHRT_MAX == 0xffffffff) && defined(__MTA__) + // On MTA / XMT short is 32 bits unless the -short16 compiler flag is specified + // MTA / XMT does support the following non-standard integer types + typedef __short16 int16_t; + typedef __short16 int_least16_t; + typedef __short16 int_fast16_t; + typedef unsigned __short16 uint16_t; + typedef unsigned __short16 uint_least16_t; + typedef unsigned __short16 uint_fast16_t; +# elif (USHRT_MAX == 0xffffffff) && defined(CRAY) + // no 16-bit types on Cray: + typedef short int_least16_t; + typedef short int_fast16_t; + typedef unsigned short uint_least16_t; + typedef unsigned short uint_fast16_t; +# else +# error defaults not correct; you must hand modify boost/cstdint.hpp +# endif + +// 32-bit types -----------------------------------------------------------// + +# if UINT_MAX == 0xffffffff + typedef int int32_t; + typedef int int_least32_t; + typedef int int_fast32_t; + typedef unsigned int uint32_t; + typedef unsigned int uint_least32_t; + typedef unsigned int uint_fast32_t; +# elif (USHRT_MAX == 0xffffffff) + typedef short int32_t; + typedef short int_least32_t; + typedef short int_fast32_t; + typedef unsigned short uint32_t; + typedef unsigned short uint_least32_t; + typedef unsigned short uint_fast32_t; +# elif ULONG_MAX == 0xffffffff + typedef long int32_t; + typedef long int_least32_t; + typedef long int_fast32_t; + typedef unsigned long uint32_t; + typedef unsigned long uint_least32_t; + typedef unsigned long uint_fast32_t; +# elif (UINT_MAX == 0xffffffffffffffff) && defined(__MTA__) + // Integers are 64 bits on the MTA / XMT + typedef __int32 int32_t; + typedef __int32 int_least32_t; + typedef __int32 int_fast32_t; + typedef unsigned __int32 uint32_t; + typedef unsigned __int32 uint_least32_t; + typedef unsigned __int32 uint_fast32_t; +# else +# error defaults not correct; you must hand modify boost/cstdint.hpp +# endif + +// 64-bit types + intmax_t and uintmax_t ----------------------------------// + +# if defined(BOOST_HAS_LONG_LONG) && \ + !defined(BOOST_MSVC) && !defined(__BORLANDC__) && \ + (!defined(__GLIBCPP__) || defined(_GLIBCPP_USE_LONG_LONG)) && \ + (defined(ULLONG_MAX) || defined(ULONG_LONG_MAX) || defined(ULONGLONG_MAX)) +# if defined(__hpux) + // HP-UX's value of ULONG_LONG_MAX is unusable in preprocessor expressions +# elif (defined(ULLONG_MAX) && ULLONG_MAX == 18446744073709551615ULL) || (defined(ULONG_LONG_MAX) && ULONG_LONG_MAX == 18446744073709551615ULL) || (defined(ULONGLONG_MAX) && ULONGLONG_MAX == 18446744073709551615ULL) + // 2**64 - 1 +# else +# error defaults not correct; you must hand modify boost/cstdint.hpp +# endif + + typedef ::boost::long_long_type intmax_t; + typedef ::boost::ulong_long_type uintmax_t; + typedef ::boost::long_long_type int64_t; + typedef ::boost::long_long_type int_least64_t; + typedef ::boost::long_long_type int_fast64_t; + typedef ::boost::ulong_long_type uint64_t; + typedef ::boost::ulong_long_type uint_least64_t; + typedef ::boost::ulong_long_type uint_fast64_t; + +# elif ULONG_MAX != 0xffffffff + +# if ULONG_MAX == 18446744073709551615 // 2**64 - 1 + typedef long intmax_t; + typedef unsigned long uintmax_t; + typedef long int64_t; + typedef long int_least64_t; + typedef long int_fast64_t; + typedef unsigned long uint64_t; + typedef unsigned long uint_least64_t; + typedef unsigned long uint_fast64_t; +# else +# error defaults not correct; you must hand modify boost/cstdint.hpp +# endif +# elif defined(__GNUC__) && defined(BOOST_HAS_LONG_LONG) + __extension__ typedef long long intmax_t; + __extension__ typedef unsigned long long uintmax_t; + __extension__ typedef long long int64_t; + __extension__ typedef long long int_least64_t; + __extension__ typedef long long int_fast64_t; + __extension__ typedef unsigned long long uint64_t; + __extension__ typedef unsigned long long uint_least64_t; + __extension__ typedef unsigned long long uint_fast64_t; +# elif defined(BOOST_HAS_MS_INT64) + // + // we have Borland/Intel/Microsoft __int64: + // + typedef __int64 intmax_t; + typedef unsigned __int64 uintmax_t; + typedef __int64 int64_t; + typedef __int64 int_least64_t; + typedef __int64 int_fast64_t; + typedef unsigned __int64 uint64_t; + typedef unsigned __int64 uint_least64_t; + typedef unsigned __int64 uint_fast64_t; +# else // assume no 64-bit integers +# define BOOST_NO_INT64_T + typedef int32_t intmax_t; + typedef uint32_t uintmax_t; +# endif + +} // namespace boost + + +#endif // BOOST_HAS_STDINT_H + +// intptr_t/uintptr_t are defined separately because they are optional and not universally available +#if defined(BOOST_WINDOWS) && !defined(_WIN32_WCE) && !defined(BOOST_HAS_STDINT_H) +// Older MSVC don't have stdint.h and have intptr_t/uintptr_t defined in stddef.h +#include +#endif + +// PGI seems to not support intptr_t/uintptr_t properly. BOOST_HAS_STDINT_H is not defined for this compiler by Boost.Config. +#if !defined(__PGIC__) + +#if (defined(BOOST_WINDOWS) && !defined(_WIN32_WCE)) \ + || (defined(_XOPEN_UNIX) && (_XOPEN_UNIX+0 > 0) && !defined(__UCLIBC__)) \ + || defined(__CYGWIN__) \ + || defined(macintosh) || defined(__APPLE__) || defined(__APPLE_CC__) \ + || defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__DragonFly__) || defined(sun) + +namespace boost { + using ::intptr_t; + using ::uintptr_t; +} +#define BOOST_HAS_INTPTR_T + +// Clang pretends to be GCC, so it'll match this condition +#elif defined(__GNUC__) && defined(__INTPTR_TYPE__) && defined(__UINTPTR_TYPE__) + +namespace boost { + typedef __INTPTR_TYPE__ intptr_t; + typedef __UINTPTR_TYPE__ uintptr_t; +} +#define BOOST_HAS_INTPTR_T + +#endif + +#endif // !defined(__PGIC__) + +#endif // BOOST_CSTDINT_HPP + + +/**************************************************** + +Macro definition section: + +Added 23rd September 2000 (John Maddock). +Modified 11th September 2001 to be excluded when +BOOST_HAS_STDINT_H is defined (John Maddock). +Modified 11th Dec 2009 to always define the +INT#_C macros if they're not already defined (John Maddock). + +******************************************************/ + +#if !defined(BOOST__STDC_CONSTANT_MACROS_DEFINED) && \ + (!defined(INT8_C) || !defined(INT16_C) || !defined(INT32_C) || !defined(INT64_C)) +// +// For the following code we get several warnings along the lines of: +// +// boost/cstdint.hpp:428:35: error: use of C99 long long integer constant +// +// So we declare this a system header to suppress these warnings. +// +#if defined(__GNUC__) && (__GNUC__ >= 4) +#pragma GCC system_header +#endif + +#include +# define BOOST__STDC_CONSTANT_MACROS_DEFINED +# if defined(BOOST_HAS_MS_INT64) +// +// Borland/Intel/Microsoft compilers have width specific suffixes: +// +#ifndef INT8_C +# define INT8_C(value) value##i8 +#endif +#ifndef INT16_C +# define INT16_C(value) value##i16 +#endif +#ifndef INT32_C +# define INT32_C(value) value##i32 +#endif +#ifndef INT64_C +# define INT64_C(value) value##i64 +#endif +# ifdef __BORLANDC__ + // Borland bug: appending ui8 makes the type a signed char +# define UINT8_C(value) static_cast(value##u) +# else +# define UINT8_C(value) value##ui8 +# endif +#ifndef UINT16_C +# define UINT16_C(value) value##ui16 +#endif +#ifndef UINT32_C +# define UINT32_C(value) value##ui32 +#endif +#ifndef UINT64_C +# define UINT64_C(value) value##ui64 +#endif +#ifndef INTMAX_C +# define INTMAX_C(value) value##i64 +# define UINTMAX_C(value) value##ui64 +#endif + +# else +// do it the old fashioned way: + +// 8-bit types ------------------------------------------------------------// + +# if (UCHAR_MAX == 0xff) && !defined(INT8_C) +# define INT8_C(value) static_cast(value) +# define UINT8_C(value) static_cast(value##u) +# endif + +// 16-bit types -----------------------------------------------------------// + +# if (USHRT_MAX == 0xffff) && !defined(INT16_C) +# define INT16_C(value) static_cast(value) +# define UINT16_C(value) static_cast(value##u) +# endif + +// 32-bit types -----------------------------------------------------------// +#ifndef INT32_C +# if (UINT_MAX == 0xffffffff) +# define INT32_C(value) value +# define UINT32_C(value) value##u +# elif ULONG_MAX == 0xffffffff +# define INT32_C(value) value##L +# define UINT32_C(value) value##uL +# endif +#endif + +// 64-bit types + intmax_t and uintmax_t ----------------------------------// +#ifndef INT64_C +# if defined(BOOST_HAS_LONG_LONG) && \ + (defined(ULLONG_MAX) || defined(ULONG_LONG_MAX) || defined(ULONGLONG_MAX) || defined(_ULLONG_MAX) || defined(_LLONG_MAX)) + +# if defined(__hpux) + // HP-UX's value of ULONG_LONG_MAX is unusable in preprocessor expressions +# define INT64_C(value) value##LL +# define UINT64_C(value) value##uLL +# elif (defined(ULLONG_MAX) && ULLONG_MAX == 18446744073709551615ULL) || \ + (defined(ULONG_LONG_MAX) && ULONG_LONG_MAX == 18446744073709551615ULL) || \ + (defined(ULONGLONG_MAX) && ULONGLONG_MAX == 18446744073709551615ULL) || \ + (defined(_ULLONG_MAX) && _ULLONG_MAX == 18446744073709551615ULL) || \ + (defined(_LLONG_MAX) && _LLONG_MAX == 9223372036854775807LL) + +# define INT64_C(value) value##LL +# define UINT64_C(value) value##uLL +# else +# error defaults not correct; you must hand modify boost/cstdint.hpp +# endif +# elif ULONG_MAX != 0xffffffff + +# if ULONG_MAX == 18446744073709551615U // 2**64 - 1 +# define INT64_C(value) value##L +# define UINT64_C(value) value##uL +# else +# error defaults not correct; you must hand modify boost/cstdint.hpp +# endif +# elif defined(BOOST_HAS_LONG_LONG) + // Usual macros not defined, work things out for ourselves: +# if(~0uLL == 18446744073709551615ULL) +# define INT64_C(value) value##LL +# define UINT64_C(value) value##uLL +# else +# error defaults not correct; you must hand modify boost/cstdint.hpp +# endif +# else +# error defaults not correct; you must hand modify boost/cstdint.hpp +# endif + +# ifdef BOOST_NO_INT64_T +# define INTMAX_C(value) INT32_C(value) +# define UINTMAX_C(value) UINT32_C(value) +# else +# define INTMAX_C(value) INT64_C(value) +# define UINTMAX_C(value) UINT64_C(value) +# endif +#endif +# endif // Borland/Microsoft specific width suffixes + +#endif // INT#_C macros. + + + + diff --git a/realsense-file/3rd_party/boost/boost/current_function.hpp b/realsense-file/3rd_party/boost/boost/current_function.hpp new file mode 100644 index 0000000000..249e97afbc --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/current_function.hpp @@ -0,0 +1,71 @@ +#ifndef BOOST_CURRENT_FUNCTION_HPP_INCLUDED +#define BOOST_CURRENT_FUNCTION_HPP_INCLUDED + +// MS compatible compilers support #pragma once + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma once +#endif + +// +// boost/current_function.hpp - BOOST_CURRENT_FUNCTION +// +// Copyright (c) 2002 Peter Dimov and Multi Media Ltd. +// +// 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 +// +// http://www.boost.org/libs/assert/current_function.html +// + +namespace boost +{ + +namespace detail +{ + +inline void current_function_helper() +{ + +#if defined(__GNUC__) || (defined(__MWERKS__) && (__MWERKS__ >= 0x3000)) || (defined(__ICC) && (__ICC >= 600)) || defined(__ghs__) + +# define BOOST_CURRENT_FUNCTION __PRETTY_FUNCTION__ + +#elif defined(__DMC__) && (__DMC__ >= 0x810) + +# define BOOST_CURRENT_FUNCTION __PRETTY_FUNCTION__ + +#elif defined(__FUNCSIG__) + +# define BOOST_CURRENT_FUNCTION __FUNCSIG__ + +#elif (defined(__INTEL_COMPILER) && (__INTEL_COMPILER >= 600)) || (defined(__IBMCPP__) && (__IBMCPP__ >= 500)) + +# define BOOST_CURRENT_FUNCTION __FUNCTION__ + +#elif defined(__BORLANDC__) && (__BORLANDC__ >= 0x550) + +# define BOOST_CURRENT_FUNCTION __FUNC__ + +#elif defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901) + +# define BOOST_CURRENT_FUNCTION __func__ + +#elif defined(__cplusplus) && (__cplusplus >= 201103) + +# define BOOST_CURRENT_FUNCTION __func__ + +#else + +# define BOOST_CURRENT_FUNCTION "(unknown)" + +#endif + +} + +} // namespace detail + +} // namespace boost + +#endif // #ifndef BOOST_CURRENT_FUNCTION_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/detail/call_traits.hpp b/realsense-file/3rd_party/boost/boost/detail/call_traits.hpp new file mode 100644 index 0000000000..8c6cb12152 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/detail/call_traits.hpp @@ -0,0 +1,172 @@ +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// Use, modification and distribution are subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt). +// +// See http://www.boost.org/libs/utility for most recent version including documentation. + +// call_traits: defines typedefs for function usage +// (see libs/utility/call_traits.htm) + +/* Release notes: + 23rd July 2000: + Fixed array specialization. (JM) + Added Borland specific fixes for reference types + (issue raised by Steve Cleary). +*/ + +#ifndef BOOST_DETAIL_CALL_TRAITS_HPP +#define BOOST_DETAIL_CALL_TRAITS_HPP + +#ifndef BOOST_CONFIG_HPP +#include +#endif +#include + +#include +#include +#include +#include + +namespace boost{ + +namespace detail{ + +template +struct ct_imp2 +{ + typedef const T& param_type; +}; + +template +struct ct_imp2 +{ + typedef const T param_type; +}; + +template +struct ct_imp +{ + typedef const T& param_type; +}; + +template +struct ct_imp +{ + typedef typename ct_imp2::param_type param_type; +}; + +template +struct ct_imp +{ + typedef typename ct_imp2::param_type param_type; +}; + +template +struct ct_imp +{ + typedef const T param_type; +}; + +} + +template +struct call_traits +{ +public: + typedef T value_type; + typedef T& reference; + typedef const T& const_reference; + // + // C++ Builder workaround: we should be able to define a compile time + // constant and pass that as a single template parameter to ct_imp, + // however compiler bugs prevent this - instead pass three bool's to + // ct_imp and add an extra partial specialisation + // of ct_imp to handle the logic. (JM) + typedef typename boost::detail::ct_imp< + T, + ::std::is_pointer::value, + ::std::is_arithmetic::value, + ::std::is_enum::value + >::param_type param_type; +}; + +template +struct call_traits +{ + typedef T& value_type; + typedef T& reference; + typedef const T& const_reference; + typedef T& param_type; // hh removed const +}; + +#if BOOST_WORKAROUND( __BORLANDC__, < 0x5A0 ) +// these are illegal specialisations; cv-qualifies applied to +// references have no effect according to [8.3.2p1], +// C++ Builder requires them though as it treats cv-qualified +// references as distinct types... +template +struct call_traits +{ + typedef T& value_type; + typedef T& reference; + typedef const T& const_reference; + typedef T& param_type; // hh removed const +}; +template +struct call_traits +{ + typedef T& value_type; + typedef T& reference; + typedef const T& const_reference; + typedef T& param_type; // hh removed const +}; +template +struct call_traits +{ + typedef T& value_type; + typedef T& reference; + typedef const T& const_reference; + typedef T& param_type; // hh removed const +}; + +template +struct call_traits< T * > +{ + typedef T * value_type; + typedef T * & reference; + typedef T * const & const_reference; + typedef T * const param_type; // hh removed const +}; +#endif +#if !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS) +template +struct call_traits +{ +private: + typedef T array_type[N]; +public: + // degrades array to pointer: + typedef const T* value_type; + typedef array_type& reference; + typedef const array_type& const_reference; + typedef const T* const param_type; +}; + +template +struct call_traits +{ +private: + typedef const T array_type[N]; +public: + // degrades array to pointer: + typedef const T* value_type; + typedef array_type& reference; + typedef const array_type& const_reference; + typedef const T* const param_type; +}; +#endif + +} + +#endif // BOOST_DETAIL_CALL_TRAITS_HPP diff --git a/realsense-file/3rd_party/boost/boost/detail/indirect_traits.hpp b/realsense-file/3rd_party/boost/boost/detail/indirect_traits.hpp new file mode 100644 index 0000000000..7d0020bb35 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/detail/indirect_traits.hpp @@ -0,0 +1,204 @@ +// Copyright David Abrahams 2002. +// 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 INDIRECT_TRAITS_DWA2002131_HPP +# define INDIRECT_TRAITS_DWA2002131_HPP +# include +# include +# include +# include +# include +# include +# include +# include +# include +# include +# include + +# include + +# include +# include +# include +# include +# include +# include + + +namespace boost { namespace detail { + +namespace indirect_traits { + +template +struct is_reference_to_const : mpl::false_ +{ +}; + +template +struct is_reference_to_const : mpl::true_ +{ +}; + +# if defined(BOOST_MSVC) && _MSC_FULL_VER <= 13102140 // vc7.01 alpha workaround +template +struct is_reference_to_const : mpl::true_ +{ +}; +# endif + +template +struct is_reference_to_function : mpl::false_ +{ +}; + +template +struct is_reference_to_function : is_function +{ +}; + +template +struct is_pointer_to_function : mpl::false_ +{ +}; + +// There's no such thing as a pointer-to-cv-function, so we don't need +// specializations for those +template +struct is_pointer_to_function : is_function +{ +}; + +template +struct is_reference_to_member_function_pointer_impl : mpl::false_ +{ +}; + +template +struct is_reference_to_member_function_pointer_impl + : is_member_function_pointer::type> +{ +}; + + +template +struct is_reference_to_member_function_pointer + : is_reference_to_member_function_pointer_impl +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_reference_to_member_function_pointer,(T)) +}; + +template +struct is_reference_to_function_pointer_aux + : mpl::and_< + is_reference + , is_pointer_to_function< + typename remove_cv< + typename remove_reference::type + >::type + > + > +{ + // There's no such thing as a pointer-to-cv-function, so we don't need specializations for those +}; + +template +struct is_reference_to_function_pointer + : mpl::if_< + is_reference_to_function + , mpl::false_ + , is_reference_to_function_pointer_aux + >::type +{ +}; + +template +struct is_reference_to_non_const + : mpl::and_< + is_reference + , mpl::not_< + is_reference_to_const + > + > +{ +}; + +template +struct is_reference_to_volatile : mpl::false_ +{ +}; + +template +struct is_reference_to_volatile : mpl::true_ +{ +}; + +# if defined(BOOST_MSVC) && _MSC_FULL_VER <= 13102140 // vc7.01 alpha workaround +template +struct is_reference_to_volatile : mpl::true_ +{ +}; +# endif + + +template +struct is_reference_to_pointer : mpl::false_ +{ +}; + +template +struct is_reference_to_pointer : mpl::true_ +{ +}; + +template +struct is_reference_to_pointer : mpl::true_ +{ +}; + +template +struct is_reference_to_pointer : mpl::true_ +{ +}; + +template +struct is_reference_to_pointer : mpl::true_ +{ +}; + +template +struct is_reference_to_class + : mpl::and_< + is_reference + , is_class< + typename remove_cv< + typename remove_reference::type + >::type + > + > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_reference_to_class,(T)) +}; + +template +struct is_pointer_to_class + : mpl::and_< + is_pointer + , is_class< + typename remove_cv< + typename remove_pointer::type + >::type + > + > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_pointer_to_class,(T)) +}; + + +} + +using namespace indirect_traits; + +}} // namespace boost::python::detail + +#endif // INDIRECT_TRAITS_DWA2002131_HPP diff --git a/realsense-file/3rd_party/boost/boost/detail/iterator.hpp b/realsense-file/3rd_party/boost/boost/detail/iterator.hpp new file mode 100644 index 0000000000..cb7b5e8ea5 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/detail/iterator.hpp @@ -0,0 +1,26 @@ +// (C) Copyright David Abrahams 2002. +// 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 ITERATOR_DWA122600_HPP_ +#define ITERATOR_DWA122600_HPP_ + +// This header is obsolete and will be deprecated. + +#include + +namespace boost +{ + +namespace detail +{ + +using std::iterator_traits; +using std::distance; + +} // namespace detail + +} // namespace boost + +#endif // ITERATOR_DWA122600_HPP_ diff --git a/realsense-file/3rd_party/boost/boost/detail/no_exceptions_support.hpp b/realsense-file/3rd_party/boost/boost/detail/no_exceptions_support.hpp new file mode 100644 index 0000000000..7fc400e03e --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/detail/no_exceptions_support.hpp @@ -0,0 +1,17 @@ +/* + * Copyright (c) 2014 Glen Fernandes + * + * 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_DETAIL_NO_EXCEPTIONS_SUPPORT_HPP +#define BOOST_DETAIL_NO_EXCEPTIONS_SUPPORT_HPP + +// The header file at this path is deprecated; +// use boost/core/no_exceptions_support.hpp instead. + +#include + +#endif diff --git a/realsense-file/3rd_party/boost/boost/detail/reference_content.hpp b/realsense-file/3rd_party/boost/boost/detail/reference_content.hpp new file mode 100644 index 0000000000..171e6b3e9e --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/detail/reference_content.hpp @@ -0,0 +1,120 @@ +//----------------------------------------------------------------------------- +// boost detail/reference_content.hpp header file +// See http://www.boost.org for updates, documentation, and revision history. +//----------------------------------------------------------------------------- +// +// Copyright (c) 2003 +// Eric Friedman +// +// 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_DETAIL_REFERENCE_CONTENT_HPP +#define BOOST_DETAIL_REFERENCE_CONTENT_HPP + +#include "boost/config.hpp" + +# include "boost/mpl/bool.hpp" +# include "boost/type_traits/has_nothrow_copy.hpp" + +#include "boost/mpl/void.hpp" + +namespace boost { + +namespace detail { + +/////////////////////////////////////////////////////////////////////////////// +// (detail) class template reference_content +// +// Non-Assignable wrapper for references. +// +template +class reference_content +{ +private: // representation + + RefT content_; + +public: // structors + + ~reference_content() + { + } + + reference_content(RefT r) + : content_( r ) + { + } + + reference_content(const reference_content& operand) + : content_( operand.content_ ) + { + } + +private: // non-Assignable + + reference_content& operator=(const reference_content&); + +public: // queries + + RefT get() const + { + return content_; + } + +}; + +/////////////////////////////////////////////////////////////////////////////// +// (detail) metafunction make_reference_content +// +// Wraps with reference_content if specified type is reference. +// + +template struct make_reference_content; + + +template +struct make_reference_content +{ + typedef T type; +}; + +template +struct make_reference_content< T& > +{ + typedef reference_content type; +}; + + +template <> +struct make_reference_content< mpl::void_ > +{ + template + struct apply + : make_reference_content + { + }; + + typedef mpl::void_ type; +}; + +} // namespace detail + +/////////////////////////////////////////////////////////////////////////////// +// reference_content type traits specializations +// + + +template +struct has_nothrow_copy< + ::boost::detail::reference_content< T& > + > + : mpl::true_ +{ +}; + + +} // namespace boost + +#endif // BOOST_DETAIL_REFERENCE_CONTENT_HPP diff --git a/realsense-file/3rd_party/boost/boost/detail/sp_typeinfo.hpp b/realsense-file/3rd_party/boost/boost/detail/sp_typeinfo.hpp new file mode 100644 index 0000000000..09fec4ae12 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/detail/sp_typeinfo.hpp @@ -0,0 +1,36 @@ +#ifndef BOOST_DETAIL_SP_TYPEINFO_HPP_INCLUDED +#define BOOST_DETAIL_SP_TYPEINFO_HPP_INCLUDED + +// MS compatible compilers support #pragma once + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma once +#endif + +// detail/sp_typeinfo.hpp +// +// Deprecated, please use boost/core/typeinfo.hpp +// +// Copyright 2007 Peter Dimov +// +// 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 + +namespace boost +{ + +namespace detail +{ + +typedef boost::core::typeinfo sp_typeinfo; + +} // namespace detail + +} // namespace boost + +#define BOOST_SP_TYPEID(T) BOOST_CORE_TYPEID(T) + +#endif // #ifndef BOOST_DETAIL_SP_TYPEINFO_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/detail/utf8_codecvt_facet.ipp b/realsense-file/3rd_party/boost/boost/detail/utf8_codecvt_facet.ipp new file mode 100644 index 0000000000..8bd6f12573 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/detail/utf8_codecvt_facet.ipp @@ -0,0 +1,283 @@ +/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 +// utf8_codecvt_facet.ipp + +// Copyright (c) 2001 Ronald Garcia, Indiana University (garcia@osl.iu.edu) +// Andrew Lumsdaine, Indiana University (lums@osl.iu.edu). +// Use, modification and distribution is subject to 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) + +// Please see the comments in to +// learn how this file should be used. + +#include + +#include // for multi-byte converson routines +#include + +#include +#include + +// If we don't have wstring, then Unicode support +// is not available anyway, so we don't need to even +// compiler this file. This also fixes the problem +// with mingw, which can compile this file, but will +// generate link error when building DLL. +#ifndef BOOST_NO_STD_WSTRING + +BOOST_UTF8_BEGIN_NAMESPACE + +/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 +// implementation for wchar_t + +// Translate incoming UTF-8 into UCS-4 +std::codecvt_base::result utf8_codecvt_facet::do_in( + std::mbstate_t& /*state*/, + const char * from, + const char * from_end, + const char * & from_next, + wchar_t * to, + wchar_t * to_end, + wchar_t * & to_next +) const { + // Basic algorithm: The first octet determines how many + // octets total make up the UCS-4 character. The remaining + // "continuing octets" all begin with "10". To convert, subtract + // the amount that specifies the number of octets from the first + // octet. Subtract 0x80 (1000 0000) from each continuing octet, + // then mash the whole lot together. Note that each continuing + // octet only uses 6 bits as unique values, so only shift by + // multiples of 6 to combine. + while (from != from_end && to != to_end) { + + // Error checking on the first octet + if (invalid_leading_octet(*from)){ + from_next = from; + to_next = to; + return std::codecvt_base::error; + } + + // The first octet is adjusted by a value dependent upon + // the number of "continuing octets" encoding the character + const int cont_octet_count = get_cont_octet_count(*from); + const wchar_t octet1_modifier_table[] = { + 0x00, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc + }; + + // The unsigned char conversion is necessary in case char is + // signed (I learned this the hard way) + wchar_t ucs_result = + (unsigned char)(*from++) - octet1_modifier_table[cont_octet_count]; + + // Invariants : + // 1) At the start of the loop, 'i' continuing characters have been + // processed + // 2) *from points to the next continuing character to be processed. + int i = 0; + while(i != cont_octet_count && from != from_end) { + + // Error checking on continuing characters + if (invalid_continuing_octet(*from)) { + from_next = from; + to_next = to; + return std::codecvt_base::error; + } + + ucs_result *= (1 << 6); + + // each continuing character has an extra (10xxxxxx)b attached to + // it that must be removed. + ucs_result += (unsigned char)(*from++) - 0x80; + ++i; + } + + // If the buffer ends with an incomplete unicode character... + if (from == from_end && i != cont_octet_count) { + // rewind "from" to before the current character translation + from_next = from - (i+1); + to_next = to; + return std::codecvt_base::partial; + } + *to++ = ucs_result; + } + from_next = from; + to_next = to; + + // Were we done converting or did we run out of destination space? + if(from == from_end) return std::codecvt_base::ok; + else return std::codecvt_base::partial; +} + +std::codecvt_base::result utf8_codecvt_facet::do_out( + std::mbstate_t& /*state*/, + const wchar_t * from, + const wchar_t * from_end, + const wchar_t * & from_next, + char * to, + char * to_end, + char * & to_next +) const +{ + // RG - consider merging this table with the other one + const wchar_t octet1_modifier_table[] = { + 0x00, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc + }; + + wchar_t max_wchar = (std::numeric_limits::max)(); + while (from != from_end && to != to_end) { + + // Check for invalid UCS-4 character + if (*from > max_wchar) { + from_next = from; + to_next = to; + return std::codecvt_base::error; + } + + int cont_octet_count = get_cont_octet_out_count(*from); + + // RG - comment this formula better + int shift_exponent = (cont_octet_count) * 6; + + // Process the first character + *to++ = static_cast(octet1_modifier_table[cont_octet_count] + + (unsigned char)(*from / (1 << shift_exponent))); + + // Process the continuation characters + // Invariants: At the start of the loop: + // 1) 'i' continuing octets have been generated + // 2) '*to' points to the next location to place an octet + // 3) shift_exponent is 6 more than needed for the next octet + int i = 0; + while (i != cont_octet_count && to != to_end) { + shift_exponent -= 6; + *to++ = static_cast(0x80 + ((*from / (1 << shift_exponent)) % (1 << 6))); + ++i; + } + // If we filled up the out buffer before encoding the character + if(to == to_end && i != cont_octet_count) { + from_next = from; + to_next = to - (i+1); + return std::codecvt_base::partial; + } + ++from; + } + from_next = from; + to_next = to; + // Were we done or did we run out of destination space + if(from == from_end) return std::codecvt_base::ok; + else return std::codecvt_base::partial; +} + +// How many char objects can I process to get <= max_limit +// wchar_t objects? +int utf8_codecvt_facet::do_length( + const std::mbstate_t &, + const char * from, + const char * from_end, + std::size_t max_limit +) const +#if BOOST_WORKAROUND(__IBMCPP__, BOOST_TESTED_AT(600)) + throw() +#endif +{ + // RG - this code is confusing! I need a better way to express it. + // and test cases. + + // Invariants: + // 1) last_octet_count has the size of the last measured character + // 2) char_count holds the number of characters shown to fit + // within the bounds so far (no greater than max_limit) + // 3) from_next points to the octet 'last_octet_count' before the + // last measured character. + int last_octet_count=0; + std::size_t char_count = 0; + const char* from_next = from; + // Use "<" because the buffer may represent incomplete characters + while (from_next+last_octet_count <= from_end && char_count <= max_limit) { + from_next += last_octet_count; + last_octet_count = (get_octet_count(*from_next)); + ++char_count; + } + return static_cast(from_next-from_end); +} + +unsigned int utf8_codecvt_facet::get_octet_count( + unsigned char lead_octet +){ + // if the 0-bit (MSB) is 0, then 1 character + if (lead_octet <= 0x7f) return 1; + + // Otherwise the count number of consecutive 1 bits starting at MSB +// assert(0xc0 <= lead_octet && lead_octet <= 0xfd); + + if (0xc0 <= lead_octet && lead_octet <= 0xdf) return 2; + else if (0xe0 <= lead_octet && lead_octet <= 0xef) return 3; + else if (0xf0 <= lead_octet && lead_octet <= 0xf7) return 4; + else if (0xf8 <= lead_octet && lead_octet <= 0xfb) return 5; + else return 6; +} + +namespace detail { + +template +int get_cont_octet_out_count_impl(wchar_t word){ + if (word < 0x80) { + return 0; + } + if (word < 0x800) { + return 1; + } + return 2; +} + +template<> +int get_cont_octet_out_count_impl<4>(wchar_t word){ + if (word < 0x80) { + return 0; + } + if (word < 0x800) { + return 1; + } + + // Note that the following code will generate warnings on some platforms + // where wchar_t is defined as UCS2. The warnings are superfluous as the + // specialization is never instantitiated with such compilers, but this + // can cause problems if warnings are being treated as errors, so we guard + // against that. Including as we do + // should be enough to get WCHAR_MAX defined. +#if !defined(WCHAR_MAX) +# error WCHAR_MAX not defined! +#endif + // cope with VC++ 7.1 or earlier having invalid WCHAR_MAX +#if defined(_MSC_VER) && _MSC_VER <= 1310 // 7.1 or earlier + return 2; +#elif WCHAR_MAX > 0x10000 + + if (word < 0x10000) { + return 2; + } + if (word < 0x200000) { + return 3; + } + if (word < 0x4000000) { + return 4; + } + return 5; + +#else + return 2; +#endif +} + +} // namespace detail + +// How many "continuing octets" will be needed for this word +// == total octets - 1. +int utf8_codecvt_facet::get_cont_octet_out_count( + wchar_t word +) const { + return detail::get_cont_octet_out_count_impl(word); +} +BOOST_UTF8_END_NAMESPACE + +#endif diff --git a/realsense-file/3rd_party/boost/boost/detail/workaround.hpp b/realsense-file/3rd_party/boost/boost/detail/workaround.hpp new file mode 100644 index 0000000000..b48deb99d3 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/detail/workaround.hpp @@ -0,0 +1,267 @@ +// Copyright David Abrahams 2002. +// 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 WORKAROUND_DWA2002126_HPP +# define WORKAROUND_DWA2002126_HPP + +// Compiler/library version workaround macro +// +// Usage: +// +// #if BOOST_WORKAROUND(BOOST_MSVC, < 1300) +// // workaround for eVC4 and VC6 +// ... // workaround code here +// #endif +// +// When BOOST_STRICT_CONFIG is defined, expands to 0. Otherwise, the +// first argument must be undefined or expand to a numeric +// value. The above expands to: +// +// (BOOST_MSVC) != 0 && (BOOST_MSVC) < 1300 +// +// When used for workarounds that apply to the latest known version +// and all earlier versions of a compiler, the following convention +// should be observed: +// +// #if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1301)) +// +// The version number in this case corresponds to the last version in +// which the workaround was known to have been required. When +// BOOST_DETECT_OUTDATED_WORKAROUNDS is not the defined, the macro +// BOOST_TESTED_AT(x) expands to "!= 0", which effectively activates +// the workaround for any version of the compiler. When +// BOOST_DETECT_OUTDATED_WORKAROUNDS is defined, a compiler warning or +// error will be issued if the compiler version exceeds the argument +// to BOOST_TESTED_AT(). This can be used to locate workarounds which +// may be obsoleted by newer versions. + +# ifndef BOOST_STRICT_CONFIG + +#include "../config.hpp" + +#ifndef __BORLANDC__ +#define __BORLANDC___WORKAROUND_GUARD 1 +#else +#define __BORLANDC___WORKAROUND_GUARD 0 +#endif +#ifndef __CODEGEARC__ +#define __CODEGEARC___WORKAROUND_GUARD 1 +#else +#define __CODEGEARC___WORKAROUND_GUARD 0 +#endif +#ifndef _MSC_VER +#define _MSC_VER_WORKAROUND_GUARD 1 +#else +#define _MSC_VER_WORKAROUND_GUARD 0 +#endif +#ifndef _MSC_FULL_VER +#define _MSC_FULL_VER_WORKAROUND_GUARD 1 +#else +#define _MSC_FULL_VER_WORKAROUND_GUARD 0 +#endif +#ifndef BOOST_MSVC +#define BOOST_MSVC_WORKAROUND_GUARD 1 +#else +#define BOOST_MSVC_WORKAROUND_GUARD 0 +#endif +#ifndef BOOST_MSVC_FULL_VER +#define BOOST_MSVC_FULL_VER_WORKAROUND_GUARD 1 +#else +#define BOOST_MSVC_FULL_VER_WORKAROUND_GUARD 0 +#endif +#ifndef __GNUC__ +#define __GNUC___WORKAROUND_GUARD 1 +#else +#define __GNUC___WORKAROUND_GUARD 0 +#endif +#ifndef __GNUC_MINOR__ +#define __GNUC_MINOR___WORKAROUND_GUARD 1 +#else +#define __GNUC_MINOR___WORKAROUND_GUARD 0 +#endif +#ifndef __GNUC_PATCHLEVEL__ +#define __GNUC_PATCHLEVEL___WORKAROUND_GUARD 1 +#else +#define __GNUC_PATCHLEVEL___WORKAROUND_GUARD 0 +#endif +#ifndef __IBMCPP__ +#define __IBMCPP___WORKAROUND_GUARD 1 +#else +#define __IBMCPP___WORKAROUND_GUARD 0 +#endif +#ifndef __SUNPRO_CC +#define __SUNPRO_CC_WORKAROUND_GUARD 1 +#else +#define __SUNPRO_CC_WORKAROUND_GUARD 0 +#endif +#ifndef __DECCXX_VER +#define __DECCXX_VER_WORKAROUND_GUARD 1 +#else +#define __DECCXX_VER_WORKAROUND_GUARD 0 +#endif +#ifndef __MWERKS__ +#define __MWERKS___WORKAROUND_GUARD 1 +#else +#define __MWERKS___WORKAROUND_GUARD 0 +#endif +#ifndef __EDG__ +#define __EDG___WORKAROUND_GUARD 1 +#else +#define __EDG___WORKAROUND_GUARD 0 +#endif +#ifndef __EDG_VERSION__ +#define __EDG_VERSION___WORKAROUND_GUARD 1 +#else +#define __EDG_VERSION___WORKAROUND_GUARD 0 +#endif +#ifndef __HP_aCC +#define __HP_aCC_WORKAROUND_GUARD 1 +#else +#define __HP_aCC_WORKAROUND_GUARD 0 +#endif +#ifndef __hpxstd98 +#define __hpxstd98_WORKAROUND_GUARD 1 +#else +#define __hpxstd98_WORKAROUND_GUARD 0 +#endif +#ifndef _CRAYC +#define _CRAYC_WORKAROUND_GUARD 1 +#else +#define _CRAYC_WORKAROUND_GUARD 0 +#endif +#ifndef __DMC__ +#define __DMC___WORKAROUND_GUARD 1 +#else +#define __DMC___WORKAROUND_GUARD 0 +#endif +#ifndef MPW_CPLUS +#define MPW_CPLUS_WORKAROUND_GUARD 1 +#else +#define MPW_CPLUS_WORKAROUND_GUARD 0 +#endif +#ifndef __COMO__ +#define __COMO___WORKAROUND_GUARD 1 +#else +#define __COMO___WORKAROUND_GUARD 0 +#endif +#ifndef __COMO_VERSION__ +#define __COMO_VERSION___WORKAROUND_GUARD 1 +#else +#define __COMO_VERSION___WORKAROUND_GUARD 0 +#endif +#ifndef __INTEL_COMPILER +#define __INTEL_COMPILER_WORKAROUND_GUARD 1 +#else +#define __INTEL_COMPILER_WORKAROUND_GUARD 0 +#endif +#ifndef __ICL +#define __ICL_WORKAROUND_GUARD 1 +#else +#define __ICL_WORKAROUND_GUARD 0 +#endif +#ifndef _COMPILER_VERSION +#define _COMPILER_VERSION_WORKAROUND_GUARD 1 +#else +#define _COMPILER_VERSION_WORKAROUND_GUARD 0 +#endif + +#ifndef _RWSTD_VER +#define _RWSTD_VER_WORKAROUND_GUARD 1 +#else +#define _RWSTD_VER_WORKAROUND_GUARD 0 +#endif +#ifndef BOOST_RWSTD_VER +#define BOOST_RWSTD_VER_WORKAROUND_GUARD 1 +#else +#define BOOST_RWSTD_VER_WORKAROUND_GUARD 0 +#endif +#ifndef __GLIBCPP__ +#define __GLIBCPP___WORKAROUND_GUARD 1 +#else +#define __GLIBCPP___WORKAROUND_GUARD 0 +#endif +#ifndef _GLIBCXX_USE_C99_FP_MACROS_DYNAMIC +#define _GLIBCXX_USE_C99_FP_MACROS_DYNAMIC_WORKAROUND_GUARD 1 +#else +#define _GLIBCXX_USE_C99_FP_MACROS_DYNAMIC_WORKAROUND_GUARD 0 +#endif +#ifndef __SGI_STL_PORT +#define __SGI_STL_PORT_WORKAROUND_GUARD 1 +#else +#define __SGI_STL_PORT_WORKAROUND_GUARD 0 +#endif +#ifndef _STLPORT_VERSION +#define _STLPORT_VERSION_WORKAROUND_GUARD 1 +#else +#define _STLPORT_VERSION_WORKAROUND_GUARD 0 +#endif +#ifndef __LIBCOMO_VERSION__ +#define __LIBCOMO_VERSION___WORKAROUND_GUARD 1 +#else +#define __LIBCOMO_VERSION___WORKAROUND_GUARD 0 +#endif +#ifndef _CPPLIB_VER +#define _CPPLIB_VER_WORKAROUND_GUARD 1 +#else +#define _CPPLIB_VER_WORKAROUND_GUARD 0 +#endif + +#ifndef BOOST_INTEL_CXX_VERSION +#define BOOST_INTEL_CXX_VERSION_WORKAROUND_GUARD 1 +#else +#define BOOST_INTEL_CXX_VERSION_WORKAROUND_GUARD 0 +#endif +#ifndef BOOST_INTEL_WIN +#define BOOST_INTEL_WIN_WORKAROUND_GUARD 1 +#else +#define BOOST_INTEL_WIN_WORKAROUND_GUARD 0 +#endif +#ifndef BOOST_DINKUMWARE_STDLIB +#define BOOST_DINKUMWARE_STDLIB_WORKAROUND_GUARD 1 +#else +#define BOOST_DINKUMWARE_STDLIB_WORKAROUND_GUARD 0 +#endif +#ifndef BOOST_INTEL +#define BOOST_INTEL_WORKAROUND_GUARD 1 +#else +#define BOOST_INTEL_WORKAROUND_GUARD 0 +#endif +// Always define to zero, if it's used it'll be defined my MPL: +#define BOOST_MPL_CFG_GCC_WORKAROUND_GUARD 0 + +# define BOOST_WORKAROUND(symbol, test) \ + ((symbol ## _WORKAROUND_GUARD + 0 == 0) && \ + (symbol != 0) && (1 % (( (symbol test) ) + 1))) +// ^ ^ ^ ^ +// The extra level of parenthesis nesting above, along with the +// BOOST_OPEN_PAREN indirection below, is required to satisfy the +// broken preprocessor in MWCW 8.3 and earlier. +// +// The basic mechanism works as follows: +// (symbol test) + 1 => if (symbol test) then 2 else 1 +// 1 % ((symbol test) + 1) => if (symbol test) then 1 else 0 +// +// The complication with % is for cooperation with BOOST_TESTED_AT(). +// When "test" is BOOST_TESTED_AT(x) and +// BOOST_DETECT_OUTDATED_WORKAROUNDS is #defined, +// +// symbol test => if (symbol <= x) then 1 else -1 +// (symbol test) + 1 => if (symbol <= x) then 2 else 0 +// 1 % ((symbol test) + 1) => if (symbol <= x) then 1 else divide-by-zero +// + +# ifdef BOOST_DETECT_OUTDATED_WORKAROUNDS +# define BOOST_OPEN_PAREN ( +# define BOOST_TESTED_AT(value) > value) ?(-1): BOOST_OPEN_PAREN 1 +# else +# define BOOST_TESTED_AT(value) != ((value)-(value)) +# endif + +# else + +# define BOOST_WORKAROUND(symbol, test) 0 + +# endif + +#endif // WORKAROUND_DWA2002126_HPP diff --git a/realsense-file/3rd_party/boost/boost/enable_if.hpp b/realsense-file/3rd_party/boost/boost/enable_if.hpp new file mode 100644 index 0000000000..5fd5d6f6f2 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/enable_if.hpp @@ -0,0 +1,119 @@ +// Boost enable_if library + +// Copyright 2003 (c) The Trustees of Indiana University. + +// Use, modification, and distribution is subject to 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) + +// Authors: Jaakko Jarvi (jajarvi at osl.iu.edu) +// Jeremiah Willcock (jewillco at osl.iu.edu) +// Andrew Lumsdaine (lums at osl.iu.edu) + + +#ifndef BOOST_CORE_ENABLE_IF_HPP +#define BOOST_CORE_ENABLE_IF_HPP + +#include "config.hpp" +#include +// Even the definition of enable_if causes problems on some compilers, +// so it's macroed out for all compilers that do not support SFINAE + +#ifndef BOOST_NO_SFINAE + +namespace boost +{ + + template + struct enable_if_c { + typedef T type; + }; + + template + struct enable_if_c {}; + + template + struct enable_if : public enable_if_c {}; + + template + struct lazy_enable_if_c { + typedef typename T::type type; + }; + + template + struct lazy_enable_if_c {}; + + template + struct lazy_enable_if : public lazy_enable_if_c {}; + + + template + struct disable_if_c { + typedef T type; + }; + + template + struct disable_if_c {}; + + template + struct disable_if : public disable_if_c {}; + + template + struct lazy_disable_if_c { + typedef typename T::type type; + }; + + template + struct lazy_disable_if_c {}; + + template + struct lazy_disable_if : public lazy_disable_if_c {}; + +} // namespace boost + +#else + +namespace boost { + + namespace detail { typedef void enable_if_default_T; } + + template + struct enable_if_does_not_work_on_this_compiler; + + template + struct enable_if_c : enable_if_does_not_work_on_this_compiler + { }; + + template + struct disable_if_c : enable_if_does_not_work_on_this_compiler + { }; + + template + struct lazy_enable_if_c : enable_if_does_not_work_on_this_compiler + { }; + + template + struct lazy_disable_if_c : enable_if_does_not_work_on_this_compiler + { }; + + template + struct enable_if : enable_if_does_not_work_on_this_compiler + { }; + + template + struct disable_if : enable_if_does_not_work_on_this_compiler + { }; + + template + struct lazy_enable_if : enable_if_does_not_work_on_this_compiler + { }; + + template + struct lazy_disable_if : enable_if_does_not_work_on_this_compiler + { }; + +} // namespace boost + +#endif // BOOST_NO_SFINAE + +#endif diff --git a/realsense-file/3rd_party/boost/boost/exception/exception.hpp b/realsense-file/3rd_party/boost/boost/exception/exception.hpp new file mode 100644 index 0000000000..bdbc5569f0 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/exception/exception.hpp @@ -0,0 +1,489 @@ +//Copyright (c) 2006-2009 Emil Dotchevski and Reverge Studios, Inc. + +//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 UUID_274DA366004E11DCB1DDFE2E56D89593 +#define UUID_274DA366004E11DCB1DDFE2E56D89593 +#if (__GNUC__*100+__GNUC_MINOR__>301) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS) +#pragma GCC system_header +#endif +#if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS) +#pragma warning(push,1) +#endif + +namespace +boost + { + namespace + exception_detail + { + template + class + refcount_ptr + { + public: + + refcount_ptr(): + px_(0) + { + } + + ~refcount_ptr() + { + release(); + } + + refcount_ptr( refcount_ptr const & x ): + px_(x.px_) + { + add_ref(); + } + + refcount_ptr & + operator=( refcount_ptr const & x ) + { + adopt(x.px_); + return *this; + } + + void + adopt( T * px ) + { + release(); + px_=px; + add_ref(); + } + + T * + get() const + { + return px_; + } + + private: + + T * px_; + + void + add_ref() + { + if( px_ ) + px_->add_ref(); + } + + void + release() + { + if( px_ && px_->release() ) + px_=0; + } + }; + } + + //////////////////////////////////////////////////////////////////////// + + template + class error_info; + + typedef error_info throw_function; + typedef error_info throw_file; + typedef error_info throw_line; + + template <> + class + error_info + { + public: + typedef char const * value_type; + value_type v_; + explicit + error_info( value_type v ): + v_(v) + { + } + }; + + template <> + class + error_info + { + public: + typedef char const * value_type; + value_type v_; + explicit + error_info( value_type v ): + v_(v) + { + } + }; + + template <> + class + error_info + { + public: + typedef int value_type; + value_type v_; + explicit + error_info( value_type v ): + v_(v) + { + } + }; + +#if defined(__GNUC__) +# if (__GNUC__ == 4 && __GNUC_MINOR__ >= 1) || (__GNUC__ > 4) +# pragma GCC visibility push (default) +# endif +#endif + class exception; +#if defined(__GNUC__) +# if (__GNUC__ == 4 && __GNUC_MINOR__ >= 1) || (__GNUC__ > 4) +# pragma GCC visibility pop +# endif +#endif + + template + class shared_ptr; + + namespace + exception_detail + { + class error_info_base; + struct type_info_; + + struct + error_info_container + { + virtual char const * diagnostic_information( char const * ) const = 0; + virtual shared_ptr get( type_info_ const & ) const = 0; + virtual void set( shared_ptr const &, type_info_ const & ) = 0; + virtual void add_ref() const = 0; + virtual bool release() const = 0; + virtual refcount_ptr clone() const = 0; + + protected: + + ~error_info_container() throw() + { + } + }; + + template + struct get_info; + + template <> + struct get_info; + + template <> + struct get_info; + + template <> + struct get_info; + + char const * get_diagnostic_information( exception const &, char const * ); + + void copy_boost_exception( exception *, exception const * ); + + template + E const & set_info( E const &, error_info const & ); + + template + E const & set_info( E const &, throw_function const & ); + + template + E const & set_info( E const &, throw_file const & ); + + template + E const & set_info( E const &, throw_line const & ); + } + +#if defined(__GNUC__) +# if (__GNUC__ == 4 && __GNUC_MINOR__ >= 1) || (__GNUC__ > 4) +# pragma GCC visibility push (default) +# endif +#endif + class + exception + { + // + public: + template void set( typename Tag::type const & ); + template typename Tag::type const * get() const; + // + + protected: + + exception(): + throw_function_(0), + throw_file_(0), + throw_line_(-1) + { + } + +#ifdef __HP_aCC + //On HP aCC, this protected copy constructor prevents throwing boost::exception. + //On all other platforms, the same effect is achieved by the pure virtual destructor. + exception( exception const & x ) throw(): + data_(x.data_), + throw_function_(x.throw_function_), + throw_file_(x.throw_file_), + throw_line_(x.throw_line_) + { + } +#endif + + virtual ~exception() throw() +#ifndef __HP_aCC + = 0 //Workaround for HP aCC, =0 incorrectly leads to link errors. +#endif + ; + +#if (defined(__MWERKS__) && __MWERKS__<=0x3207) || (defined(_MSC_VER) && _MSC_VER<=1310) + public: +#else + private: + + template + friend E const & exception_detail::set_info( E const &, throw_function const & ); + + template + friend E const & exception_detail::set_info( E const &, throw_file const & ); + + template + friend E const & exception_detail::set_info( E const &, throw_line const & ); + + template + friend E const & exception_detail::set_info( E const &, error_info const & ); + + friend char const * exception_detail::get_diagnostic_information( exception const &, char const * ); + + template + friend struct exception_detail::get_info; + friend struct exception_detail::get_info; + friend struct exception_detail::get_info; + friend struct exception_detail::get_info; + friend void exception_detail::copy_boost_exception( exception *, exception const * ); +#endif + mutable exception_detail::refcount_ptr data_; + mutable char const * throw_function_; + mutable char const * throw_file_; + mutable int throw_line_; + }; +#if defined(__GNUC__) +# if (__GNUC__ == 4 && __GNUC_MINOR__ >= 1) || (__GNUC__ > 4) +# pragma GCC visibility pop +# endif +#endif + + inline + exception:: + ~exception() throw() + { + } + + namespace + exception_detail + { + template + E const & + set_info( E const & x, throw_function const & y ) + { + x.throw_function_=y.v_; + return x; + } + + template + E const & + set_info( E const & x, throw_file const & y ) + { + x.throw_file_=y.v_; + return x; + } + + template + E const & + set_info( E const & x, throw_line const & y ) + { + x.throw_line_=y.v_; + return x; + } + } + + //////////////////////////////////////////////////////////////////////// + + namespace + exception_detail + { +#if defined(__GNUC__) +# if (__GNUC__ == 4 && __GNUC_MINOR__ >= 1) || (__GNUC__ > 4) +# pragma GCC visibility push (default) +# endif +#endif + template + struct + error_info_injector: + public T, + public exception + { + explicit + error_info_injector( T const & x ): + T(x) + { + } + + ~error_info_injector() throw() + { + } + }; +#if defined(__GNUC__) +# if (__GNUC__ == 4 && __GNUC_MINOR__ >= 1) || (__GNUC__ > 4) +# pragma GCC visibility pop +# endif +#endif + + struct large_size { char c[256]; }; + large_size dispatch_boost_exception( exception const * ); + + struct small_size { }; + small_size dispatch_boost_exception( void const * ); + + template + struct enable_error_info_helper; + + template + struct + enable_error_info_helper + { + typedef T type; + }; + + template + struct + enable_error_info_helper + { + typedef error_info_injector type; + }; + + template + struct + enable_error_info_return_type + { + typedef typename enable_error_info_helper(0)))>::type type; + }; + } + + template + inline + typename + exception_detail::enable_error_info_return_type::type + enable_error_info( T const & x ) + { + typedef typename exception_detail::enable_error_info_return_type::type rt; + return rt(x); + } + + //////////////////////////////////////////////////////////////////////// + + namespace + exception_detail + { +#if defined(__GNUC__) +# if (__GNUC__ == 4 && __GNUC_MINOR__ >= 1) || (__GNUC__ > 4) +# pragma GCC visibility push (default) +# endif +#endif + class + clone_base + { + public: + + virtual clone_base const * clone() const = 0; + virtual void rethrow() const = 0; + + virtual + ~clone_base() throw() + { + } + }; +#if defined(__GNUC__) +# if (__GNUC__ == 4 && __GNUC_MINOR__ >= 1) || (__GNUC__ > 4) +# pragma GCC visibility pop +# endif +#endif + + inline + void + copy_boost_exception( exception * a, exception const * b ) + { + refcount_ptr data; + if( error_info_container * d=b->data_.get() ) + data = d->clone(); + a->throw_file_ = b->throw_file_; + a->throw_line_ = b->throw_line_; + a->throw_function_ = b->throw_function_; + a->data_ = data; + } + + inline + void + copy_boost_exception( void *, void const * ) + { + } + + template + class + clone_impl: + public T, + public virtual clone_base + { + struct clone_tag { }; + clone_impl( clone_impl const & x, clone_tag ): + T(x) + { + copy_boost_exception(this,&x); + } + + public: + + explicit + clone_impl( T const & x ): + T(x) + { + copy_boost_exception(this,&x); + } + + ~clone_impl() throw() + { + } + + private: + + clone_base const * + clone() const + { + return new clone_impl(*this,clone_tag()); + } + + void + rethrow() const + { + throw*this; + } + }; + } + + template + inline + exception_detail::clone_impl + enable_current_exception( T const & x ) + { + return exception_detail::clone_impl(x); + } + } + +#if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS) +#pragma warning(pop) +#endif +#endif diff --git a/realsense-file/3rd_party/boost/boost/foreach.hpp b/realsense-file/3rd_party/boost/boost/foreach.hpp new file mode 100644 index 0000000000..8795de8495 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/foreach.hpp @@ -0,0 +1,1127 @@ +/////////////////////////////////////////////////////////////////////////////// +// foreach.hpp header file +// +// Copyright 2004 Eric Niebler. +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// See http://www.boost.org/libs/foreach for documentation +// +// Credits: +// Anson Tsao - for the initial inspiration and several good suggestions. +// Thorsten Ottosen - for Boost.Range, and for suggesting a way to detect +// const-qualified rvalues at compile time on VC7.1+ +// Russell Hind - For help porting to Borland +// Alisdair Meredith - For help porting to Borland +// Stefan Slapeta - For help porting to Intel +// David Jenkins - For help finding a Microsoft Code Analysis bug +// mimomorin@... - For a patch to use rvalue refs on supporting compilers + +#ifndef BOOST_FOREACH + +// MS compatible compilers support #pragma once +#if defined(_MSC_VER) +# pragma once +#endif + +#include +#include // for std::pair + +#include +#include + +// Some compilers let us detect even const-qualified rvalues at compile-time +#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) \ + || defined(BOOST_MSVC) && !defined(_PREFAST_) \ + || (BOOST_WORKAROUND(__GNUC__, == 4) && (__GNUC_MINOR__ <= 5) && !defined(BOOST_INTEL) && \ + !defined(BOOST_CLANG)) \ + || (BOOST_WORKAROUND(__GNUC__, == 3) && (__GNUC_MINOR__ >= 4) && !defined(BOOST_INTEL) && \ + !defined(BOOST_CLANG)) +# define BOOST_FOREACH_COMPILE_TIME_CONST_RVALUE_DETECTION +#else +// Some compilers allow temporaries to be bound to non-const references. +// These compilers make it impossible to for BOOST_FOREACH to detect +// temporaries and avoid reevaluation of the collection expression. +# if BOOST_WORKAROUND(__BORLANDC__, < 0x593) \ + || (BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION, <= 700) && defined(_MSC_VER)) \ + || BOOST_WORKAROUND(__SUNPRO_CC, < 0x5100) \ + || BOOST_WORKAROUND(__DECCXX_VER, <= 60590042) +# define BOOST_FOREACH_NO_RVALUE_DETECTION +# endif +// Some compilers do not correctly implement the lvalue/rvalue conversion +// rules of the ternary conditional operator. +# if defined(BOOST_FOREACH_NO_RVALUE_DETECTION) \ + || defined(BOOST_NO_SFINAE) \ + || BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1400)) \ + || BOOST_WORKAROUND(BOOST_INTEL_WIN, BOOST_TESTED_AT(1400)) \ + || (BOOST_WORKAROUND(__GNUC__, == 3) && (__GNUC_MINOR__ <= 3) && defined(__APPLE_CC__)) \ + || BOOST_WORKAROUND(__IBMCPP__, BOOST_TESTED_AT(600)) \ + || BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3206)) \ + || BOOST_WORKAROUND(__SUNPRO_CC, >= 0x5100) \ + || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x590)) +# define BOOST_FOREACH_NO_CONST_RVALUE_DETECTION +# else +# define BOOST_FOREACH_RUN_TIME_CONST_RVALUE_DETECTION +# endif +#endif + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef BOOST_FOREACH_RUN_TIME_CONST_RVALUE_DETECTION +# include +# include +# include +# include +#endif + +namespace boost +{ + +// forward declarations for iterator_range +template +class iterator_range; + +// forward declarations for sub_range +template +class sub_range; + +namespace foreach +{ + /////////////////////////////////////////////////////////////////////////////// + // in_range + // + template + inline std::pair in_range(T begin, T end) + { + return std::make_pair(begin, end); + } + + /////////////////////////////////////////////////////////////////////////////// + // boost::foreach::is_lightweight_proxy + // Specialize this for user-defined collection types if they are inexpensive to copy. + // This tells BOOST_FOREACH it can avoid the rvalue/lvalue detection stuff. + template + struct is_lightweight_proxy + : boost::mpl::false_ + { + }; + + /////////////////////////////////////////////////////////////////////////////// + // boost::foreach::is_noncopyable + // Specialize this for user-defined collection types if they cannot be copied. + // This also tells BOOST_FOREACH to avoid the rvalue/lvalue detection stuff. + template + struct is_noncopyable + #if !defined(BOOST_BROKEN_IS_BASE_AND_DERIVED) && !defined(BOOST_NO_IS_ABSTRACT) + : boost::mpl::or_< + boost::is_abstract + , boost::is_base_and_derived + > + #elif !defined(BOOST_BROKEN_IS_BASE_AND_DERIVED) + : boost::is_base_and_derived + #elif !defined(BOOST_NO_IS_ABSTRACT) + : boost::is_abstract + #else + : boost::mpl::false_ + #endif + { + }; + +} // namespace foreach + +} // namespace boost + +// vc6/7 needs help ordering the following overloads +#ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING +# define BOOST_FOREACH_TAG_DEFAULT ... +#else +# define BOOST_FOREACH_TAG_DEFAULT boost::foreach::tag +#endif + +/////////////////////////////////////////////////////////////////////////////// +// boost_foreach_is_lightweight_proxy +// Another customization point for the is_lightweight_proxy optimization, +// this one works on legacy compilers. Overload boost_foreach_is_lightweight_proxy +// at the global namespace for your type. +template +inline boost::foreach::is_lightweight_proxy * +boost_foreach_is_lightweight_proxy(T *&, BOOST_FOREACH_TAG_DEFAULT) { return 0; } + +template +inline boost::mpl::true_ * +boost_foreach_is_lightweight_proxy(std::pair *&, boost::foreach::tag) { return 0; } + +template +inline boost::mpl::true_ * +boost_foreach_is_lightweight_proxy(boost::iterator_range *&, boost::foreach::tag) { return 0; } + +template +inline boost::mpl::true_ * +boost_foreach_is_lightweight_proxy(boost::sub_range *&, boost::foreach::tag) { return 0; } + +template +inline boost::mpl::true_ * +boost_foreach_is_lightweight_proxy(T **&, boost::foreach::tag) { return 0; } + +/////////////////////////////////////////////////////////////////////////////// +// boost_foreach_is_noncopyable +// Another customization point for the is_noncopyable trait, +// this one works on legacy compilers. Overload boost_foreach_is_noncopyable +// at the global namespace for your type. +template +inline boost::foreach::is_noncopyable * +boost_foreach_is_noncopyable(T *&, BOOST_FOREACH_TAG_DEFAULT) { return 0; } + +namespace boost +{ + +namespace foreach_detail_ +{ + +/////////////////////////////////////////////////////////////////////////////// +// Define some utilities for assessing the properties of expressions +// +template +inline boost::mpl::and_ *and_(Bool1 *, Bool2 *) { return 0; } + +template +inline boost::mpl::and_ *and_(Bool1 *, Bool2 *, Bool3 *) { return 0; } + +template +inline boost::mpl::or_ *or_(Bool1 *, Bool2 *) { return 0; } + +template +inline boost::mpl::or_ *or_(Bool1 *, Bool2 *, Bool3 *) { return 0; } + +template +inline boost::mpl::not_ *not_(Bool1 *) { return 0; } + +template +inline boost::is_array *is_array_(T const &) { return 0; } + +template +inline boost::is_const *is_const_(T &) { return 0; } + +#ifndef BOOST_FOREACH_NO_RVALUE_DETECTION +template +inline boost::mpl::true_ *is_const_(T const &) { return 0; } +#endif + +#ifdef BOOST_NO_CXX11_RVALUE_REFERENCES +template +inline boost::mpl::false_ *is_rvalue_(T &, int) { return 0; } + +template +inline boost::mpl::true_ *is_rvalue_(T const &, ...) { return 0; } +#else +template +inline boost::is_rvalue_reference *is_rvalue_(T &&, int) { return 0; } +#endif + +/////////////////////////////////////////////////////////////////////////////// +// auto_any_t/auto_any +// General utility for putting an object of any type into automatic storage +struct auto_any_base +{ + // auto_any_base must evaluate to false in boolean context so that + // they can be declared in if() statements. + operator bool() const + { + return false; + } +}; + +template +struct auto_any : auto_any_base +{ + explicit auto_any(T const &t) + : item(t) + { + } + + // temporaries of type auto_any will be bound to const auto_any_base + // references, but we still want to be able to mutate the stored + // data, so declare it as mutable. + mutable T item; +}; + +typedef auto_any_base const &auto_any_t; + +template +inline BOOST_DEDUCED_TYPENAME boost::mpl::if_::type &auto_any_cast(auto_any_t a) +{ + return static_cast const &>(a).item; +} + +typedef boost::mpl::true_ const_; + +/////////////////////////////////////////////////////////////////////////////// +// type2type +// +template +struct type2type + : boost::mpl::if_ +{ +}; + +template +struct wrap_cstr +{ + typedef T type; +}; + +template<> +struct wrap_cstr +{ + typedef wrap_cstr type; + typedef char *iterator; + typedef char *const_iterator; +}; + +template<> +struct wrap_cstr +{ + typedef wrap_cstr type; + typedef char const *iterator; + typedef char const *const_iterator; +}; + +template<> +struct wrap_cstr +{ + typedef wrap_cstr type; + typedef wchar_t *iterator; + typedef wchar_t *const_iterator; +}; + +template<> +struct wrap_cstr +{ + typedef wrap_cstr type; + typedef wchar_t const *iterator; + typedef wchar_t const *const_iterator; +}; + +template +struct is_char_array + : mpl::and_< + is_array + , mpl::or_< + is_convertible + , is_convertible + > + > +{}; + +template +struct foreach_iterator +{ + // **** READ THIS IF YOUR COMPILE BREAKS HERE **** + // + // There is an ambiguity about how to iterate over arrays of char and wchar_t. + // Should the last array element be treated as a null terminator to be skipped, or + // is it just like any other element in the array? To fix the problem, you must + // say which behavior you want. + // + // To treat the container as a null-terminated string, merely cast it to a + // char const *, as in BOOST_FOREACH( char ch, (char const *)"hello" ) ... + // + // To treat the container as an array, use boost::as_array() in , + // as in BOOST_FOREACH( char ch, boost::as_array("hello") ) ... + BOOST_MPL_ASSERT_MSG( (!is_char_array::value), IS_THIS_AN_ARRAY_OR_A_NULL_TERMINATED_STRING, (T&) ); + + // If the type is a pointer to a null terminated string (as opposed + // to an array type), there is no ambiguity. + typedef BOOST_DEDUCED_TYPENAME wrap_cstr::type container; + + typedef BOOST_DEDUCED_TYPENAME boost::mpl::eval_if< + C + , range_const_iterator + , range_mutable_iterator + >::type type; +}; + + +template +struct foreach_reverse_iterator +{ + // **** READ THIS IF YOUR COMPILE BREAKS HERE **** + // + // There is an ambiguity about how to iterate over arrays of char and wchar_t. + // Should the last array element be treated as a null terminator to be skipped, or + // is it just like any other element in the array? To fix the problem, you must + // say which behavior you want. + // + // To treat the container as a null-terminated string, merely cast it to a + // char const *, as in BOOST_FOREACH( char ch, (char const *)"hello" ) ... + // + // To treat the container as an array, use boost::as_array() in , + // as in BOOST_FOREACH( char ch, boost::as_array("hello") ) ... + BOOST_MPL_ASSERT_MSG( (!is_char_array::value), IS_THIS_AN_ARRAY_OR_A_NULL_TERMINATED_STRING, (T&) ); + + // If the type is a pointer to a null terminated string (as opposed + // to an array type), there is no ambiguity. + typedef BOOST_DEDUCED_TYPENAME wrap_cstr::type container; + + typedef BOOST_DEDUCED_TYPENAME boost::mpl::eval_if< + C + , range_reverse_iterator + , range_reverse_iterator + >::type type; +}; + +template +struct foreach_reference + : iterator_reference::type> +{ +}; + +/////////////////////////////////////////////////////////////////////////////// +// encode_type +// +template +inline type2type *encode_type(T &, boost::false_type*) { return 0; } + +template +inline type2type *encode_type(T const &, boost::true_type*) { return 0; } + +template +inline type2type *encode_type(T &, boost::mpl::false_*) { return 0; } + +template +inline type2type *encode_type(T const &, boost::mpl::true_*) { return 0; } + +/////////////////////////////////////////////////////////////////////////////// +// set_false +// +inline bool set_false(bool &b) +{ + b = false; + return false; +} + +/////////////////////////////////////////////////////////////////////////////// +// to_ptr +// +template +inline T *&to_ptr(T const &) +{ + static T *t = 0; + return t; +} + +// Borland needs a little extra help with arrays +#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) +template +inline T (*&to_ptr(T (&)[N]))[N] +{ + static T (*t)[N] = 0; + return t; +} + +/////////////////////////////////////////////////////////////////////////////// +// derefof +// +template +inline T &derefof(T *t) +{ + // This is a work-around for a compiler bug in Borland. If T* is a pointer to array type U(*)[N], + // then dereferencing it results in a U* instead of U(&)[N]. The cast forces the issue. + return reinterpret_cast( + *const_cast( + reinterpret_cast(t) + ) + ); +} + +# define BOOST_FOREACH_DEREFOF(T) boost::foreach_detail_::derefof(*T) +#else +# define BOOST_FOREACH_DEREFOF(T) (*T) +#endif + +#if defined(BOOST_FOREACH_COMPILE_TIME_CONST_RVALUE_DETECTION) \ + && !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) +/////////////////////////////////////////////////////////////////////////////// +// Rvalue references makes it drop-dead simple to detect at compile time +// whether an expression is an rvalue. +/////////////////////////////////////////////////////////////////////////////// + +# define BOOST_FOREACH_IS_RVALUE(COL) \ + boost::foreach_detail_::is_rvalue_((COL), 0) + +#elif defined(BOOST_FOREACH_COMPILE_TIME_CONST_RVALUE_DETECTION) \ + && defined(BOOST_NO_CXX11_RVALUE_REFERENCES) +/////////////////////////////////////////////////////////////////////////////// +// Detect at compile-time whether an expression yields an rvalue or +// an lvalue. This is rather non-standard, but some popular compilers +// accept it. +/////////////////////////////////////////////////////////////////////////////// + +/////////////////////////////////////////////////////////////////////////////// +// rvalue_probe +// +template +struct rvalue_probe +{ + struct private_type_ {}; + // can't ever return an array by value + typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_< + boost::mpl::or_, boost::is_array >, private_type_, T + >::type value_type; + operator value_type() { return *reinterpret_cast(this); } // never called + operator T &() const { return *reinterpret_cast(const_cast(this)); } // never called +}; + +template +rvalue_probe const make_probe(T const &) +{ + return rvalue_probe(); +} + +# define BOOST_FOREACH_IS_RVALUE(COL) \ + boost::foreach_detail_::and_( \ + boost::foreach_detail_::not_(boost::foreach_detail_::is_array_(COL)) \ + , (true ? 0 : boost::foreach_detail_::is_rvalue_( \ + (true ? boost::foreach_detail_::make_probe(COL) : (COL)), 0))) + +#elif defined(BOOST_FOREACH_RUN_TIME_CONST_RVALUE_DETECTION) +/////////////////////////////////////////////////////////////////////////////// +// Detect at run-time whether an expression yields an rvalue +// or an lvalue. This is 100% standard C++, but not all compilers +// accept it. Also, it causes FOREACH to break when used with non- +// copyable collection types. +/////////////////////////////////////////////////////////////////////////////// + +/////////////////////////////////////////////////////////////////////////////// +// rvalue_probe +// +template +struct rvalue_probe +{ + rvalue_probe(T &t, bool &b) + : value(t) + , is_rvalue(b) + { + } + + struct private_type_ {}; + // can't ever return an array or an abstract type by value + #ifdef BOOST_NO_IS_ABSTRACT + typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_< + boost::is_array, private_type_, T + >::type value_type; + #else + typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_< + boost::mpl::or_, boost::is_array >, private_type_, T + >::type value_type; + #endif + + operator value_type() + { + this->is_rvalue = true; + return this->value; + } + + operator T &() const + { + return this->value; + } + +private: + T &value; + bool &is_rvalue; +}; + +template +rvalue_probe make_probe(T &t, bool &b) { return rvalue_probe(t, b); } + +template +rvalue_probe make_probe(T const &t, bool &b) { return rvalue_probe(t, b); } + +/////////////////////////////////////////////////////////////////////////////// +// simple_variant +// holds either a T or a T const* +template +struct simple_variant +{ + simple_variant(T const *t) + : is_rvalue(false) + { + *static_cast(this->data.address()) = t; + } + + simple_variant(T const &t) + : is_rvalue(true) + { + ::new(this->data.address()) T(t); + } + + simple_variant(simple_variant const &that) + : is_rvalue(that.is_rvalue) + { + if(this->is_rvalue) + ::new(this->data.address()) T(*that.get()); + else + *static_cast(this->data.address()) = that.get(); + } + + ~simple_variant() + { + if(this->is_rvalue) + this->get()->~T(); + } + + T const *get() const + { + if(this->is_rvalue) + return static_cast(this->data.address()); + else + return *static_cast(this->data.address()); + } + +private: + enum size_type { size = sizeof(T) > sizeof(T*) ? sizeof(T) : sizeof(T*) }; + simple_variant &operator =(simple_variant const &); + bool const is_rvalue; + aligned_storage data; +}; + +// If the collection is an array or is noncopyable, it must be an lvalue. +// If the collection is a lightweight proxy, treat it as an rvalue +// BUGBUG what about a noncopyable proxy? +template +inline BOOST_DEDUCED_TYPENAME boost::enable_if, IsProxy>::type * +should_copy_impl(LValue *, IsProxy *, bool *) +{ + return 0; +} + +// Otherwise, we must determine at runtime whether it's an lvalue or rvalue +inline bool * +should_copy_impl(boost::mpl::false_ *, boost::mpl::false_ *, bool *is_rvalue) +{ + return is_rvalue; +} + +#endif + +/////////////////////////////////////////////////////////////////////////////// +// contain +// +template +inline auto_any contain(T const &t, boost::mpl::true_ *) // rvalue +{ + return auto_any(t); +} + +template +inline auto_any contain(T &t, boost::mpl::false_ *) // lvalue +{ + // Cannot seem to get sunpro to handle addressof() with array types. + #if BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x570)) + return auto_any(&t); + #else + return auto_any(boost::addressof(t)); + #endif +} + +#ifdef BOOST_FOREACH_RUN_TIME_CONST_RVALUE_DETECTION +template +inline auto_any > +contain(T const &t, bool *rvalue) +{ + return auto_any >(*rvalue ? simple_variant(t) : simple_variant(&t)); +} +#endif + +///////////////////////////////////////////////////////////////////////////// +// begin +// +template +inline auto_any::type> +begin(auto_any_t col, type2type *, boost::mpl::true_ *) // rvalue +{ + return auto_any::type>( + boost::begin(auto_any_cast(col))); +} + +template +inline auto_any::type> +begin(auto_any_t col, type2type *, boost::mpl::false_ *) // lvalue +{ + typedef BOOST_DEDUCED_TYPENAME type2type::type type; + typedef BOOST_DEDUCED_TYPENAME foreach_iterator::type iterator; + return auto_any::type>( + iterator(boost::begin(BOOST_FOREACH_DEREFOF((auto_any_cast(col)))))); +} + +#ifdef BOOST_FOREACH_RUN_TIME_CONST_RVALUE_DETECTION +template +inline auto_any::type> +begin(auto_any_t col, type2type *, bool *) +{ + return auto_any::type>( + boost::begin(*auto_any_cast, boost::mpl::false_>(col).get())); +} +#endif + +#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING +template +inline auto_any +begin(auto_any_t col, type2type *, boost::mpl::true_ *) // null-terminated C-style strings +{ + return auto_any(auto_any_cast(col)); +} +#endif + +/////////////////////////////////////////////////////////////////////////////// +// end +// +template +inline auto_any::type> +end(auto_any_t col, type2type *, boost::mpl::true_ *) // rvalue +{ + return auto_any::type>( + boost::end(auto_any_cast(col))); +} + +template +inline auto_any::type> +end(auto_any_t col, type2type *, boost::mpl::false_ *) // lvalue +{ + typedef BOOST_DEDUCED_TYPENAME type2type::type type; + typedef BOOST_DEDUCED_TYPENAME foreach_iterator::type iterator; + return auto_any::type>( + iterator(boost::end(BOOST_FOREACH_DEREFOF((auto_any_cast(col)))))); +} + +#ifdef BOOST_FOREACH_RUN_TIME_CONST_RVALUE_DETECTION +template +inline auto_any::type> +end(auto_any_t col, type2type *, bool *) +{ + return auto_any::type>( + boost::end(*auto_any_cast, boost::mpl::false_>(col).get())); +} +#endif + +#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING +template +inline auto_any +end(auto_any_t, type2type *, boost::mpl::true_ *) // null-terminated C-style strings +{ + return auto_any(0); // not used +} +#endif + +/////////////////////////////////////////////////////////////////////////////// +// done +// +template +inline bool done(auto_any_t cur, auto_any_t end, type2type *) +{ + typedef BOOST_DEDUCED_TYPENAME foreach_iterator::type iter_t; + return auto_any_cast(cur) == auto_any_cast(end); +} + +#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING +template +inline bool done(auto_any_t cur, auto_any_t, type2type *) // null-terminated C-style strings +{ + return ! *auto_any_cast(cur); +} +#endif + +/////////////////////////////////////////////////////////////////////////////// +// next +// +template +inline void next(auto_any_t cur, type2type *) +{ + typedef BOOST_DEDUCED_TYPENAME foreach_iterator::type iter_t; + ++auto_any_cast(cur); +} + +/////////////////////////////////////////////////////////////////////////////// +// deref +// +template +inline BOOST_DEDUCED_TYPENAME foreach_reference::type +deref(auto_any_t cur, type2type *) +{ + typedef BOOST_DEDUCED_TYPENAME foreach_iterator::type iter_t; + return *auto_any_cast(cur); +} + +///////////////////////////////////////////////////////////////////////////// +// rbegin +// +template +inline auto_any::type> +rbegin(auto_any_t col, type2type *, boost::mpl::true_ *) // rvalue +{ + return auto_any::type>( + boost::rbegin(auto_any_cast(col))); +} + +template +inline auto_any::type> +rbegin(auto_any_t col, type2type *, boost::mpl::false_ *) // lvalue +{ + typedef BOOST_DEDUCED_TYPENAME type2type::type type; + typedef BOOST_DEDUCED_TYPENAME foreach_reverse_iterator::type iterator; + return auto_any::type>( + iterator(boost::rbegin(BOOST_FOREACH_DEREFOF((auto_any_cast(col)))))); +} + +#ifdef BOOST_FOREACH_RUN_TIME_CONST_RVALUE_DETECTION +template +inline auto_any::type> +rbegin(auto_any_t col, type2type *, bool *) +{ + return auto_any::type>( + boost::rbegin(*auto_any_cast, boost::mpl::false_>(col).get())); +} +#endif + +#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING +template +inline auto_any > +rbegin(auto_any_t col, type2type *, boost::mpl::true_ *) // null-terminated C-style strings +{ + T *p = auto_any_cast(col); + while(0 != *p) + ++p; + return auto_any >(reverse_iterator(p)); +} +#endif + +/////////////////////////////////////////////////////////////////////////////// +// rend +// +template +inline auto_any::type> +rend(auto_any_t col, type2type *, boost::mpl::true_ *) // rvalue +{ + return auto_any::type>( + boost::rend(auto_any_cast(col))); +} + +template +inline auto_any::type> +rend(auto_any_t col, type2type *, boost::mpl::false_ *) // lvalue +{ + typedef BOOST_DEDUCED_TYPENAME type2type::type type; + typedef BOOST_DEDUCED_TYPENAME foreach_reverse_iterator::type iterator; + return auto_any::type>( + iterator(boost::rend(BOOST_FOREACH_DEREFOF((auto_any_cast(col)))))); +} + +#ifdef BOOST_FOREACH_RUN_TIME_CONST_RVALUE_DETECTION +template +inline auto_any::type> +rend(auto_any_t col, type2type *, bool *) +{ + return auto_any::type>( + boost::rend(*auto_any_cast, boost::mpl::false_>(col).get())); +} +#endif + +#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING +template +inline auto_any > +rend(auto_any_t col, type2type *, boost::mpl::true_ *) // null-terminated C-style strings +{ + return auto_any >( + reverse_iterator(auto_any_cast(col))); +} +#endif + +/////////////////////////////////////////////////////////////////////////////// +// rdone +// +template +inline bool rdone(auto_any_t cur, auto_any_t end, type2type *) +{ + typedef BOOST_DEDUCED_TYPENAME foreach_reverse_iterator::type iter_t; + return auto_any_cast(cur) == auto_any_cast(end); +} + +/////////////////////////////////////////////////////////////////////////////// +// rnext +// +template +inline void rnext(auto_any_t cur, type2type *) +{ + typedef BOOST_DEDUCED_TYPENAME foreach_reverse_iterator::type iter_t; + ++auto_any_cast(cur); +} + +/////////////////////////////////////////////////////////////////////////////// +// rderef +// +template +inline BOOST_DEDUCED_TYPENAME foreach_reference::type +rderef(auto_any_t cur, type2type *) +{ + typedef BOOST_DEDUCED_TYPENAME foreach_reverse_iterator::type iter_t; + return *auto_any_cast(cur); +} + +} // namespace foreach_detail_ +} // namespace boost + +// Suppress a bogus code analysis warning on vc8+ +#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) +# define BOOST_FOREACH_SUPPRESS_WARNINGS() __pragma(warning(suppress:6001)) +#else +# define BOOST_FOREACH_SUPPRESS_WARNINGS() +#endif + +/////////////////////////////////////////////////////////////////////////////// +// Define a macro for giving hidden variables a unique name. Not strictly +// needed, but eliminates some warnings on some compilers. +#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1500)) +// With some versions of MSVC, use of __LINE__ to create unique identifiers +// can fail when the Edit-and-Continue debug flag is used. +# define BOOST_FOREACH_ID(x) x +#else +# define BOOST_FOREACH_ID(x) BOOST_PP_CAT(x, __LINE__) +#endif + +// A sneaky way to get the type of the collection without evaluating the expression +#define BOOST_FOREACH_TYPEOF(COL) \ + (true ? 0 : boost::foreach_detail_::encode_type(COL, boost::foreach_detail_::is_const_(COL))) + +// returns true_* if the type is noncopyable +#define BOOST_FOREACH_IS_NONCOPYABLE(COL) \ + boost_foreach_is_noncopyable( \ + boost::foreach_detail_::to_ptr(COL) \ + , boost_foreach_argument_dependent_lookup_hack_value) + +// returns true_* if the type is a lightweight proxy (and is not noncopyable) +#define BOOST_FOREACH_IS_LIGHTWEIGHT_PROXY(COL) \ + boost::foreach_detail_::and_( \ + boost::foreach_detail_::not_(BOOST_FOREACH_IS_NONCOPYABLE(COL)) \ + , boost_foreach_is_lightweight_proxy( \ + boost::foreach_detail_::to_ptr(COL) \ + , boost_foreach_argument_dependent_lookup_hack_value)) + +#if defined(BOOST_FOREACH_COMPILE_TIME_CONST_RVALUE_DETECTION) +/////////////////////////////////////////////////////////////////////////////// +// R-values and const R-values supported here with zero runtime overhead +/////////////////////////////////////////////////////////////////////////////// + +// No variable is needed to track the rvalue-ness of the collection expression +# define BOOST_FOREACH_PREAMBLE() \ + BOOST_FOREACH_SUPPRESS_WARNINGS() + +// Evaluate the collection expression +# define BOOST_FOREACH_EVALUATE(COL) \ + (COL) + +# define BOOST_FOREACH_SHOULD_COPY(COL) \ + (true ? 0 : boost::foreach_detail_::or_( \ + BOOST_FOREACH_IS_RVALUE(COL) \ + , BOOST_FOREACH_IS_LIGHTWEIGHT_PROXY(COL))) + +#elif defined(BOOST_FOREACH_RUN_TIME_CONST_RVALUE_DETECTION) +/////////////////////////////////////////////////////////////////////////////// +// R-values and const R-values supported here +/////////////////////////////////////////////////////////////////////////////// + +// Declare a variable to track the rvalue-ness of the collection expression +# define BOOST_FOREACH_PREAMBLE() \ + BOOST_FOREACH_SUPPRESS_WARNINGS() \ + if (bool BOOST_FOREACH_ID(_foreach_is_rvalue) = false) {} else + +// Evaluate the collection expression, and detect if it is an lvalue or and rvalue +# define BOOST_FOREACH_EVALUATE(COL) \ + (true ? boost::foreach_detail_::make_probe((COL), BOOST_FOREACH_ID(_foreach_is_rvalue)) : (COL)) + +// The rvalue/lvalue-ness of the collection expression is determined dynamically, unless +// the type is an array or is noncopyable or is non-const, in which case we know it's an lvalue. +// If the type happens to be a lightweight proxy, always make a copy. +# define BOOST_FOREACH_SHOULD_COPY(COL) \ + (boost::foreach_detail_::should_copy_impl( \ + true ? 0 : boost::foreach_detail_::or_( \ + boost::foreach_detail_::is_array_(COL) \ + , BOOST_FOREACH_IS_NONCOPYABLE(COL) \ + , boost::foreach_detail_::not_(boost::foreach_detail_::is_const_(COL))) \ + , true ? 0 : BOOST_FOREACH_IS_LIGHTWEIGHT_PROXY(COL) \ + , &BOOST_FOREACH_ID(_foreach_is_rvalue))) + +#elif !defined(BOOST_FOREACH_NO_RVALUE_DETECTION) +/////////////////////////////////////////////////////////////////////////////// +// R-values supported here, const R-values NOT supported here +/////////////////////////////////////////////////////////////////////////////// + +// No variable is needed to track the rvalue-ness of the collection expression +# define BOOST_FOREACH_PREAMBLE() \ + BOOST_FOREACH_SUPPRESS_WARNINGS() + +// Evaluate the collection expression +# define BOOST_FOREACH_EVALUATE(COL) \ + (COL) + +// Determine whether the collection expression is an lvalue or an rvalue. +// NOTE: this gets the answer wrong for const rvalues. +# define BOOST_FOREACH_SHOULD_COPY(COL) \ + (true ? 0 : boost::foreach_detail_::or_( \ + boost::foreach_detail_::is_rvalue_((COL), 0) \ + , BOOST_FOREACH_IS_LIGHTWEIGHT_PROXY(COL))) + +#else +/////////////////////////////////////////////////////////////////////////////// +// R-values NOT supported here +/////////////////////////////////////////////////////////////////////////////// + +// No variable is needed to track the rvalue-ness of the collection expression +# define BOOST_FOREACH_PREAMBLE() \ + BOOST_FOREACH_SUPPRESS_WARNINGS() + +// Evaluate the collection expression +# define BOOST_FOREACH_EVALUATE(COL) \ + (COL) + +// Can't use rvalues with BOOST_FOREACH (unless they are lightweight proxies) +# define BOOST_FOREACH_SHOULD_COPY(COL) \ + (true ? 0 : BOOST_FOREACH_IS_LIGHTWEIGHT_PROXY(COL)) + +#endif + +#define BOOST_FOREACH_CONTAIN(COL) \ + boost::foreach_detail_::contain( \ + BOOST_FOREACH_EVALUATE(COL) \ + , BOOST_FOREACH_SHOULD_COPY(COL)) + +#define BOOST_FOREACH_BEGIN(COL) \ + boost::foreach_detail_::begin( \ + BOOST_FOREACH_ID(_foreach_col) \ + , BOOST_FOREACH_TYPEOF(COL) \ + , BOOST_FOREACH_SHOULD_COPY(COL)) + +#define BOOST_FOREACH_END(COL) \ + boost::foreach_detail_::end( \ + BOOST_FOREACH_ID(_foreach_col) \ + , BOOST_FOREACH_TYPEOF(COL) \ + , BOOST_FOREACH_SHOULD_COPY(COL)) + +#define BOOST_FOREACH_DONE(COL) \ + boost::foreach_detail_::done( \ + BOOST_FOREACH_ID(_foreach_cur) \ + , BOOST_FOREACH_ID(_foreach_end) \ + , BOOST_FOREACH_TYPEOF(COL)) + +#define BOOST_FOREACH_NEXT(COL) \ + boost::foreach_detail_::next( \ + BOOST_FOREACH_ID(_foreach_cur) \ + , BOOST_FOREACH_TYPEOF(COL)) + +#define BOOST_FOREACH_DEREF(COL) \ + boost::foreach_detail_::deref( \ + BOOST_FOREACH_ID(_foreach_cur) \ + , BOOST_FOREACH_TYPEOF(COL)) + +#define BOOST_FOREACH_RBEGIN(COL) \ + boost::foreach_detail_::rbegin( \ + BOOST_FOREACH_ID(_foreach_col) \ + , BOOST_FOREACH_TYPEOF(COL) \ + , BOOST_FOREACH_SHOULD_COPY(COL)) + +#define BOOST_FOREACH_REND(COL) \ + boost::foreach_detail_::rend( \ + BOOST_FOREACH_ID(_foreach_col) \ + , BOOST_FOREACH_TYPEOF(COL) \ + , BOOST_FOREACH_SHOULD_COPY(COL)) + +#define BOOST_FOREACH_RDONE(COL) \ + boost::foreach_detail_::rdone( \ + BOOST_FOREACH_ID(_foreach_cur) \ + , BOOST_FOREACH_ID(_foreach_end) \ + , BOOST_FOREACH_TYPEOF(COL)) + +#define BOOST_FOREACH_RNEXT(COL) \ + boost::foreach_detail_::rnext( \ + BOOST_FOREACH_ID(_foreach_cur) \ + , BOOST_FOREACH_TYPEOF(COL)) + +#define BOOST_FOREACH_RDEREF(COL) \ + boost::foreach_detail_::rderef( \ + BOOST_FOREACH_ID(_foreach_cur) \ + , BOOST_FOREACH_TYPEOF(COL)) + +/////////////////////////////////////////////////////////////////////////////// +// BOOST_FOREACH +// +// For iterating over collections. Collections can be +// arrays, null-terminated strings, or STL containers. +// The loop variable can be a value or reference. For +// example: +// +// std::list int_list(/*stuff*/); +// BOOST_FOREACH(int &i, int_list) +// { +// /* +// * loop body goes here. +// * i is a reference to the int in int_list. +// */ +// } +// +// Alternately, you can declare the loop variable first, +// so you can access it after the loop finishes. Obviously, +// if you do it this way, then the loop variable cannot be +// a reference. +// +// int i; +// BOOST_FOREACH(i, int_list) +// { ... } +// +#define BOOST_FOREACH(VAR, COL) \ + BOOST_FOREACH_PREAMBLE() \ + if (boost::foreach_detail_::auto_any_t BOOST_FOREACH_ID(_foreach_col) = BOOST_FOREACH_CONTAIN(COL)) {} else \ + if (boost::foreach_detail_::auto_any_t BOOST_FOREACH_ID(_foreach_cur) = BOOST_FOREACH_BEGIN(COL)) {} else \ + if (boost::foreach_detail_::auto_any_t BOOST_FOREACH_ID(_foreach_end) = BOOST_FOREACH_END(COL)) {} else \ + for (bool BOOST_FOREACH_ID(_foreach_continue) = true; \ + BOOST_FOREACH_ID(_foreach_continue) && !BOOST_FOREACH_DONE(COL); \ + BOOST_FOREACH_ID(_foreach_continue) ? BOOST_FOREACH_NEXT(COL) : (void)0) \ + if (boost::foreach_detail_::set_false(BOOST_FOREACH_ID(_foreach_continue))) {} else \ + for (VAR = BOOST_FOREACH_DEREF(COL); !BOOST_FOREACH_ID(_foreach_continue); BOOST_FOREACH_ID(_foreach_continue) = true) + +/////////////////////////////////////////////////////////////////////////////// +// BOOST_REVERSE_FOREACH +// +// For iterating over collections in reverse order. In +// all other respects, BOOST_REVERSE_FOREACH is like +// BOOST_FOREACH. +// +#define BOOST_REVERSE_FOREACH(VAR, COL) \ + BOOST_FOREACH_PREAMBLE() \ + if (boost::foreach_detail_::auto_any_t BOOST_FOREACH_ID(_foreach_col) = BOOST_FOREACH_CONTAIN(COL)) {} else \ + if (boost::foreach_detail_::auto_any_t BOOST_FOREACH_ID(_foreach_cur) = BOOST_FOREACH_RBEGIN(COL)) {} else \ + if (boost::foreach_detail_::auto_any_t BOOST_FOREACH_ID(_foreach_end) = BOOST_FOREACH_REND(COL)) {} else \ + for (bool BOOST_FOREACH_ID(_foreach_continue) = true; \ + BOOST_FOREACH_ID(_foreach_continue) && !BOOST_FOREACH_RDONE(COL); \ + BOOST_FOREACH_ID(_foreach_continue) ? BOOST_FOREACH_RNEXT(COL) : (void)0) \ + if (boost::foreach_detail_::set_false(BOOST_FOREACH_ID(_foreach_continue))) {} else \ + for (VAR = BOOST_FOREACH_RDEREF(COL); !BOOST_FOREACH_ID(_foreach_continue); BOOST_FOREACH_ID(_foreach_continue) = true) + +#endif diff --git a/realsense-file/3rd_party/boost/boost/foreach_fwd.hpp b/realsense-file/3rd_party/boost/boost/foreach_fwd.hpp new file mode 100644 index 0000000000..5b7bee4a90 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/foreach_fwd.hpp @@ -0,0 +1,51 @@ +/////////////////////////////////////////////////////////////////////////////// +// foreach.hpp header file +// +// Copyright 2010 Eric Niebler. +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// See http://www.boost.org/libs/foreach for documentation +// +// Credits: +// Kazutoshi Satoda: for suggesting the need for a _fwd header for foreach's +// customization points. + +#ifndef BOOST_FOREACH_FWD_HPP +#define BOOST_FOREACH_FWD_HPP + +// This must be at global scope, hence the uglified name +enum boost_foreach_argument_dependent_lookup_hack +{ + boost_foreach_argument_dependent_lookup_hack_value +}; + +namespace boost +{ + +namespace foreach +{ + /////////////////////////////////////////////////////////////////////////////// + // boost::foreach::tag + // + typedef boost_foreach_argument_dependent_lookup_hack tag; + + /////////////////////////////////////////////////////////////////////////////// + // boost::foreach::is_lightweight_proxy + // Specialize this for user-defined collection types if they are inexpensive to copy. + // This tells BOOST_FOREACH it can avoid the rvalue/lvalue detection stuff. + template + struct is_lightweight_proxy; + + /////////////////////////////////////////////////////////////////////////////// + // boost::foreach::is_noncopyable + // Specialize this for user-defined collection types if they cannot be copied. + // This also tells BOOST_FOREACH to avoid the rvalue/lvalue detection stuff. + template + struct is_noncopyable; + +} // namespace foreach + +} // namespace boost + +#endif diff --git a/realsense-file/3rd_party/boost/boost/format.hpp b/realsense-file/3rd_party/boost/boost/format.hpp new file mode 100644 index 0000000000..13516b4062 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/format.hpp @@ -0,0 +1,59 @@ +// ---------------------------------------------------------------------------- +// format.hpp : primary header +// ---------------------------------------------------------------------------- + +// Copyright Samuel Krempp 2003. Use, modification, and distribution are +// subject to the Boost Software License, Version 1.0. (See accompanying +// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org/libs/format for library home page + + +// ---------------------------------------------------------------------------- + +#ifndef BOOST_FORMAT_HPP +#define BOOST_FORMAT_HPP + +#include +#include +#include +#include + +#ifndef BOOST_NO_STD_LOCALE +#include +#endif + +// *** Compatibility framework +#include + +#ifdef BOOST_NO_LOCALE_ISIDIGIT +#include // we'll use the non-locale 's std::isdigit(int) +#endif + +// **** Forward declarations ---------------------------------- +#include // basic_format, and other frontends +#include // misc forward declarations for internal use + +// **** Auxiliary structs (stream_format_state , and format_item ) +#include + +// **** Format class interface -------------------------------- +#include + +// **** Exceptions ----------------------------------------------- +#include + +// **** Implementation ------------------------------------------- +#include // member functions +#include // class for grouping arguments +#include // argument-feeding functions +#include // format-string parsing (member-)functions + +// **** Implementation of the free functions ---------------------- +#include + + +// *** Undefine 'local' macros : +#include + +#endif // BOOST_FORMAT_HPP diff --git a/realsense-file/3rd_party/boost/boost/format/alt_sstream.hpp b/realsense-file/3rd_party/boost/boost/format/alt_sstream.hpp new file mode 100644 index 0000000000..833a383af8 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/format/alt_sstream.hpp @@ -0,0 +1,177 @@ +// ---------------------------------------------------------------------------- +// alt_sstream.hpp : alternative stringstream +// ---------------------------------------------------------------------------- + +// Copyright Samuel Krempp 2003. Use, modification, and distribution are +// subject to the Boost Software License, Version 1.0. (See accompanying +// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org/libs/format for library home page + +// ---------------------------------------------------------------------------- + + + +#ifndef BOOST_SK_ALT_SSTREAM_HPP +#define BOOST_SK_ALT_SSTREAM_HPP + +#include +#include +#include +//#include +#include +#include + +namespace boost { + namespace io { + + template, + class Alloc=::std::allocator > + class basic_altstringbuf; + + template, + class Alloc=::std::allocator > + class basic_oaltstringstream; + + + template + class basic_altstringbuf + : public ::std::basic_streambuf + { + typedef ::std::basic_streambuf streambuf_t; + typedef typename CompatAlloc::compatible_type compat_allocator_type; + typedef typename CompatTraits::compatible_type compat_traits_type; + public: + typedef Ch char_type; + typedef Tr traits_type; + typedef typename compat_traits_type::int_type int_type; + typedef typename compat_traits_type::pos_type pos_type; + typedef typename compat_traits_type::off_type off_type; + typedef Alloc allocator_type; + typedef ::std::basic_string string_type; + typedef typename string_type::size_type size_type; + + typedef ::std::streamsize streamsize; + + + explicit basic_altstringbuf(std::ios_base::openmode mode + = std::ios_base::in | std::ios_base::out) + : putend_(NULL), is_allocated_(false), mode_(mode) + {} + explicit basic_altstringbuf(const string_type& s, + ::std::ios_base::openmode mode + = ::std::ios_base::in | ::std::ios_base::out) + : putend_(NULL), is_allocated_(false), mode_(mode) + { dealloc(); str(s); } + virtual ~basic_altstringbuf() + { dealloc(); } + using streambuf_t::pbase; + using streambuf_t::pptr; + using streambuf_t::epptr; + using streambuf_t::eback; + using streambuf_t::gptr; + using streambuf_t::egptr; + + void clear_buffer(); + void str(const string_type& s); + + // 0-copy access : + Ch * begin() const; + size_type size() const; + size_type cur_size() const; // stop at current pointer + Ch * pend() const // the highest position reached by pptr() since creation + { return ((putend_ < pptr()) ? pptr() : putend_); } + size_type pcount() const + { return static_cast( pptr() - pbase()) ;} + + // copy buffer to string : + string_type str() const + { return string_type(begin(), size()); } + string_type cur_str() const + { return string_type(begin(), cur_size()); } + protected: + explicit basic_altstringbuf (basic_altstringbuf * s, + ::std::ios_base::openmode mode + = ::std::ios_base::in | ::std::ios_base::out) + : putend_(NULL), is_allocated_(false), mode_(mode) + { dealloc(); str(s); } + + virtual pos_type seekoff(off_type off, ::std::ios_base::seekdir way, + ::std::ios_base::openmode which + = ::std::ios_base::in | ::std::ios_base::out); + virtual pos_type seekpos (pos_type pos, + ::std::ios_base::openmode which + = ::std::ios_base::in | ::std::ios_base::out); + virtual int_type underflow(); + virtual int_type pbackfail(int_type meta = compat_traits_type::eof()); + virtual int_type overflow(int_type meta = compat_traits_type::eof()); + void dealloc(); + private: + enum { alloc_min = 256}; // minimum size of allocations + + Ch *putend_; // remembers (over seeks) the highest value of pptr() + bool is_allocated_; + ::std::ios_base::openmode mode_; + compat_allocator_type alloc_; // the allocator object + }; + + +// --- class basic_oaltstringstream ---------------------------------------- + template + class basic_oaltstringstream + : private base_from_member< std::shared_ptr< basic_altstringbuf< Ch, Tr, Alloc> > >, + public ::std::basic_ostream + { + class No_Op { + // used as no-op deleter for (not-owner) shared_pointers + public: + template + const T & operator()(const T & arg) { return arg; } + }; + typedef ::std::basic_ostream stream_t; + typedef boost::base_from_member > > + pbase_type; + typedef ::std::basic_string string_type; + typedef typename string_type::size_type size_type; + typedef basic_altstringbuf stringbuf_t; + public: + typedef Alloc allocator_type; + basic_oaltstringstream() + : pbase_type(new stringbuf_t), stream_t(rdbuf()) + { } + basic_oaltstringstream(::std::shared_ptr buf) + : pbase_type(buf), stream_t(rdbuf()) + { } + basic_oaltstringstream(stringbuf_t * buf) + : pbase_type(buf, No_Op() ), stream_t(rdbuf()) + { } + stringbuf_t * rdbuf() const + { return pbase_type::member.get(); } + void clear_buffer() + { rdbuf()->clear_buffer(); } + + // 0-copy access : + Ch * begin() const + { return rdbuf()->begin(); } + size_type size() const + { return rdbuf()->size(); } + size_type cur_size() const // stops at current position + { return rdbuf()->cur_size(); } + + // copy buffer to string : + string_type str() const // [pbase, epptr[ + { return rdbuf()->str(); } + string_type cur_str() const // [pbase, pptr[ + { return rdbuf()->cur_str(); } + void str(const string_type& s) + { rdbuf()->str(s); } + }; + + } // N.S. io +} // N.S. boost + +#include + +#endif // include guard + diff --git a/realsense-file/3rd_party/boost/boost/format/alt_sstream_impl.hpp b/realsense-file/3rd_party/boost/boost/format/alt_sstream_impl.hpp new file mode 100644 index 0000000000..97439907ca --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/format/alt_sstream_impl.hpp @@ -0,0 +1,313 @@ +// ---------------------------------------------------------------------------- +// alt_sstream_impl.hpp : alternative stringstream, templates implementation +// ---------------------------------------------------------------------------- + +// Copyright Samuel Krempp 2003. Use, modification, and distribution are +// subject to the Boost Software License, Version 1.0. (See accompanying +// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org/libs/format for library home page + +// ---------------------------------------------------------------------------- + +#ifndef BOOST_SK_ALT_SSTREAM_IMPL_HPP +#define BOOST_SK_ALT_SSTREAM_IMPL_HPP + +namespace boost { + namespace io { +// --- Implementation ------------------------------------------------------// + + template + void basic_altstringbuf:: + clear_buffer () { + const Ch * p = pptr(); + const Ch * b = pbase(); + if(p != NULL && p != b) { + seekpos(0, ::std::ios_base::out); + } + p = gptr(); + b = eback(); + if(p != NULL && p != b) { + seekpos(0, ::std::ios_base::in); + } + } + + template + void basic_altstringbuf:: + str (const string_type& s) { + size_type sz=s.size(); + if(sz != 0 && mode_ & (::std::ios_base::in | ::std::ios_base::out) ) { +#ifdef _RWSTD_NO_CLASS_PARTIAL_SPEC + void *vd_ptr = alloc_.allocate(sz, is_allocated_? eback() : 0); + Ch *new_ptr = static_cast(vd_ptr); +#else + Ch *new_ptr = alloc_.allocate(sz, is_allocated_? eback() : 0); +#endif + // if this didnt throw, we're safe, update the buffer + dealloc(); + sz = s.copy(new_ptr, sz); + putend_ = new_ptr + sz; + if(mode_ & ::std::ios_base::in) + streambuf_t::setg(new_ptr, new_ptr, new_ptr + sz); + if(mode_ & ::std::ios_base::out) { + streambuf_t::setp(new_ptr, new_ptr + sz); + if(mode_ & (::std::ios_base::app | ::std::ios_base::ate)) + streambuf_t::pbump(static_cast(sz)); + if(gptr() == NULL) + streambuf_t::setg(new_ptr, NULL, new_ptr); + } + is_allocated_ = true; + } + else + dealloc(); + } + template + Ch* basic_altstringbuf:: + begin () const { + if(mode_ & ::std::ios_base::out && pptr() != NULL) + return pbase(); + else if(mode_ & ::std::ios_base::in && gptr() != NULL) + return eback(); + return NULL; + } + + template + typename std::basic_string::size_type + basic_altstringbuf:: + size () const { + if(mode_ & ::std::ios_base::out && pptr()) + return static_cast(pend() - pbase()); + else if(mode_ & ::std::ios_base::in && gptr()) + return static_cast(egptr() - eback()); + else + return 0; + } + + template + typename std::basic_string::size_type + basic_altstringbuf:: + cur_size () const { + if(mode_ & ::std::ios_base::out && pptr()) + return static_cast( pptr() - pbase()); + else if(mode_ & ::std::ios_base::in && gptr()) + return static_cast( gptr() - eback()); + else + return 0; + } + + template + typename basic_altstringbuf::pos_type + basic_altstringbuf:: + seekoff (off_type off, ::std::ios_base::seekdir way, ::std::ios_base::openmode which) { + if(pptr() != NULL && putend_ < pptr()) + putend_ = pptr(); + if(which & ::std::ios_base::in && gptr() != NULL) { + // get area + if(way == ::std::ios_base::end) + off += static_cast(putend_ - gptr()); + else if(way == ::std::ios_base::beg) + off += static_cast(eback() - gptr()); + else if(way != ::std::ios_base::cur || (which & ::std::ios_base::out) ) + // (altering in&out is only supported if way is beg or end, not cur) + return pos_type(off_type(-1)); + if(eback() <= off+gptr() && off+gptr() <= putend_ ) { + // set gptr + streambuf_t::gbump(static_cast(off)); + if(which & ::std::ios_base::out && pptr() != NULL) + // update pptr to match gptr + streambuf_t::pbump(static_cast(gptr()-pptr())); + } + else + off = off_type(-1); + } + else if(which & ::std::ios_base::out && pptr() != NULL) { + // put area + if(way == ::std::ios_base::end) + off += static_cast(putend_ - pptr()); + else if(way == ::std::ios_base::beg) + off += static_cast(pbase() - pptr()); + else if(way != ::std::ios_base::beg) + return pos_type(off_type(-1)); + if(pbase() <= off+pptr() && off+pptr() <= putend_) + // set pptr + streambuf_t::pbump(static_cast(off)); + else + off = off_type(-1); + } + else // neither in nor out + off = off_type(-1); + return (pos_type(off)); + } + //- end seekoff(..) + + + template + typename basic_altstringbuf::pos_type + basic_altstringbuf:: + seekpos (pos_type pos, ::std::ios_base::openmode which) { + off_type off = off_type(pos); // operation guaranteed by 27.4.3.2 table 88 + if(pptr() != NULL && putend_ < pptr()) + putend_ = pptr(); + if(off != off_type(-1)) { + if(which & ::std::ios_base::in && gptr() != NULL) { + // get area + if(0 <= off && off <= putend_ - eback()) { + streambuf_t::gbump(static_cast(eback() - gptr() + off)); + if(which & ::std::ios_base::out && pptr() != NULL) { + // update pptr to match gptr + streambuf_t::pbump(static_cast(gptr()-pptr())); + } + } + else + off = off_type(-1); + } + else if(which & ::std::ios_base::out && pptr() != NULL) { + // put area + if(0 <= off && off <= putend_ - eback()) + streambuf_t::pbump(static_cast(eback() - pptr() + off)); + else + off = off_type(-1); + } + else // neither in nor out + off = off_type(-1); + return (pos_type(off)); + } + else { + BOOST_ASSERT(0); // §27.4.3.2 allows undefined-behaviour here + return pos_type(off_type(-1)); + } + } + // -end seekpos(..) + + + template + typename basic_altstringbuf::int_type + basic_altstringbuf:: + underflow () { + if(gptr() == NULL) // no get area -> nothing to get. + return (compat_traits_type::eof()); + else if(gptr() < egptr()) // ok, in buffer + return (compat_traits_type::to_int_type(*gptr())); + else if(mode_ & ::std::ios_base::in && pptr() != NULL + && (gptr() < pptr() || gptr() < putend_) ) + { // expand get area + if(putend_ < pptr()) + putend_ = pptr(); // remember pptr reached this far + streambuf_t::setg(eback(), gptr(), putend_); + return (compat_traits_type::to_int_type(*gptr())); + } + else // couldnt get anything. EOF. + return (compat_traits_type::eof()); + } + // -end underflow(..) + + + template + typename basic_altstringbuf::int_type + basic_altstringbuf:: + pbackfail (int_type meta) { + if(gptr() != NULL && (eback() < gptr()) + && (mode_ & (::std::ios_base::out) + || compat_traits_type::eq_int_type(compat_traits_type::eof(), meta) + || compat_traits_type::eq(compat_traits_type::to_char_type(meta), gptr()[-1]) ) ) { + streambuf_t::gbump(-1); // back one character + if(!compat_traits_type::eq_int_type(compat_traits_type::eof(), meta)) + // put-back meta into get area + *gptr() = compat_traits_type::to_char_type(meta); + return (compat_traits_type::not_eof(meta)); + } + else + return (compat_traits_type::eof()); // failed putback + } + // -end pbackfail(..) + + + template + typename basic_altstringbuf::int_type + basic_altstringbuf:: + overflow (int_type meta) { +#ifdef BOOST_MSVC +#pragma warning(push) +#pragma warning(disable:4996) +#endif + if(compat_traits_type::eq_int_type(compat_traits_type::eof(), meta)) + return compat_traits_type::not_eof(meta); // nothing to do + else if(pptr() != NULL && pptr() < epptr()) { + streambuf_t::sputc(compat_traits_type::to_char_type(meta)); + return meta; + } + else if(! (mode_ & ::std::ios_base::out)) + // no write position, and cant make one + return compat_traits_type::eof(); + else { // make a write position available + std::size_t prev_size = pptr() == NULL ? 0 : epptr() - eback(); + std::size_t new_size = prev_size; + // exponential growth : size *= 1.5 + std::size_t add_size = new_size / 2; + if(add_size < alloc_min) + add_size = alloc_min; + Ch * newptr = NULL, *oldptr = eback(); + + // make sure adding add_size wont overflow size_t + while (0 < add_size && ((std::numeric_limits::max)() + - add_size < new_size) ) + add_size /= 2; + if(0 < add_size) { + new_size += add_size; +#ifdef _RWSTD_NO_CLASS_PARTIAL_SPEC + void *vdptr = alloc_.allocate(new_size, is_allocated_? oldptr : 0); + newptr = static_cast(vdptr); +#else + newptr = alloc_.allocate(new_size, is_allocated_? oldptr : 0); +#endif + } + + if(0 < prev_size) + compat_traits_type::copy(newptr, oldptr, prev_size); + if(is_allocated_) + alloc_.deallocate(oldptr, prev_size); + is_allocated_=true; + + if(prev_size == 0) { // first allocation + putend_ = newptr; + streambuf_t::setp(newptr, newptr + new_size); + if(mode_ & ::std::ios_base::in) + streambuf_t::setg(newptr, newptr, newptr + 1); + else + streambuf_t::setg(newptr, 0, newptr); + } + else { // update pointers + putend_ = putend_ - oldptr + newptr; + int pptr_count = static_cast(pptr()-pbase()); + int gptr_count = static_cast(gptr()-eback()); + streambuf_t::setp(pbase() - oldptr + newptr, newptr + new_size); + streambuf_t::pbump(pptr_count); + if(mode_ & ::std::ios_base::in) + streambuf_t::setg(newptr, newptr + gptr_count, pptr() + 1); + else + streambuf_t::setg(newptr, 0, newptr); + } + streambuf_t::sputc(compat_traits_type::to_char_type(meta)); + return meta; + } +#ifdef BOOST_MSVC +#pragma warning(pop) +#endif + } + // -end overflow(..) + + template + void basic_altstringbuf:: dealloc() { + if(is_allocated_) + alloc_.deallocate(eback(), (pptr() != NULL ? epptr() : egptr()) - eback()); + is_allocated_ = false; + streambuf_t::setg(0, 0, 0); + streambuf_t::setp(0, 0); + putend_ = NULL; + } + + }// N.S. io +} // N.S. boost + +#endif // include guard + diff --git a/realsense-file/3rd_party/boost/boost/format/detail/compat_workarounds.hpp b/realsense-file/3rd_party/boost/boost/format/detail/compat_workarounds.hpp new file mode 100644 index 0000000000..898ef30769 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/format/detail/compat_workarounds.hpp @@ -0,0 +1,86 @@ +// ---------------------------------------------------------------------------- +// compat_workarounds : general framework for non-conformance workarounds +// ---------------------------------------------------------------------------- + +// Copyright Samuel Krempp 2003. Use, modification, and distribution are +// subject to the Boost Software License, Version 1.0. (See accompanying +// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// see http://www.boost.org/libs/format for library home page + +// ---------------------------------------------------------------------------- + + +// this file defines wrapper classes to hide non-conforming +// std::char_traits<> and std::allocator<> traits +// and Includes : config_macros.hpp (defines config macros +// and compiler-specific switches) + +// Non-conformant Std-libs fail to supply conformant traits (std::char_traits, +// std::allocator) and/or the std::string doesnt support them. +// We don't want to have hundreds of #ifdef workarounds, so we define +// replacement traits. +// But both char_traits and allocator traits are visible in the interface, +// (inside the final string type), thus we need to keep both +// the replacement type (typedefed to 'compatible_type') for real use, +// and the original stdlib type (typedef to 'type_for_string') for interface +// visibility. This is what Compat* classes do (as well as be transparent +// when good allocator and char traits are present) + +#ifndef BOOST_FORMAT_COMPAT_WORKAROUNDS_HPP +#define BOOST_FORMAT_COMPAT_WORKAROUNDS_HPP + +namespace boost { + namespace io { + + // gcc-2.95 char traits (non-conformantly named string_char_traits) + // lack several functions so we extend them in a replacement class. + template + class CompatTraits; + + // std::allocator in gcc-2.95 is ok, but basic_string only works + // with plain 'std::alloc' still, alt_stringbuf requires a functionnal + // alloc template argument, so we need a replacement allocator + template + class CompatAlloc; + } // N.S. io +}// N.S. boost + + +#include + // sets-up macros and load compiler-specific workarounds headers. + +#if !defined(BOOST_FORMAT_STREAMBUF_DEFINED) +// workarounds-gcc-2.95 might have defined own streambuf +#include +#endif + +#if !defined(BOOST_FORMAT_OSTREAM_DEFINED) +// workarounds-gcc-2.95 might already have included +#include +#endif + + + +namespace boost { + namespace io { + + // **** CompatTraits general definitions : ---------------------------- + template + class CompatTraits + { // general case : be transparent + public: + typedef Tr compatible_type; + }; + + // **** CompatAlloc general definitions : ----------------------------- + template + class CompatAlloc + { // general case : be transparent + public: + typedef Alloc compatible_type; + }; + + } //N.S. io +} // N.S. boost +#endif // include guard diff --git a/realsense-file/3rd_party/boost/boost/format/detail/config_macros.hpp b/realsense-file/3rd_party/boost/boost/format/detail/config_macros.hpp new file mode 100644 index 0000000000..389c00c42f --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/format/detail/config_macros.hpp @@ -0,0 +1,95 @@ +// -*- C++ -*- +// ---------------------------------------------------------------------------- +// config_macros.hpp : configuration macros for the format library +// only BOOST_IO_STD is absolutely needed (it should be 'std::' in general) +// others are compiler-specific workaround macros used in #ifdef switches +// ---------------------------------------------------------------------------- + +// Copyright Samuel Krempp 2003. Use, modification, and distribution are +// subject to the Boost Software License, Version 1.0. (See accompanying +// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// see http://www.boost.org/libs/format for library home page + + +// ---------------------------------------------------------------------------- + +#ifndef BOOST_FORMAT_CONFIG_MACROS_HPP +#define BOOST_FORMAT_CONFIG_MACROS_HPP + +#include +#include + +// make sure our local macros wont override something : +#if defined(BOOST_NO_LOCALE_ISDIGIT) || defined(BOOST_OVERLOAD_FOR_NON_CONST) \ + || defined(BOOST_IO_STD) || defined( BOOST_IO_NEEDS_USING_DECLARATION ) \ + || defined(BOOST_NO_TEMPLATE_STD_STREAM) \ + || defined(BOOST_FORMAT_STREAMBUF_DEFINED) || defined(BOOST_FORMAT_OSTREAM_DEFINED) +#error "boost::format uses a local macro that is already defined." +#endif + +// specific workarounds. each header can define BOOS_IO_STD if it +// needs. (e.g. because of IO_NEEDS_USING_DECLARATION) +#include +#include + +#ifndef BOOST_IO_STD +# define BOOST_IO_STD ::std:: +#endif + +#if defined(BOOST_NO_STD_LOCALE) || \ + ( BOOST_WORKAROUND(__BORLANDC__, <= 0x564) \ + || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT( 0x570 ) ) ) +// some future __BORLANDC__ >0x564 versions might not need this +// 0x570 is Borland's kylix branch +#define BOOST_NO_LOCALE_ISDIGIT +#endif + +#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x570) ) || BOOST_WORKAROUND( BOOST_MSVC, BOOST_TESTED_AT(1300)) +#define BOOST_NO_OVERLOAD_FOR_NON_CONST +#endif + +// **** Workaround for io streams, stlport and msvc. +#ifdef BOOST_IO_NEEDS_USING_DECLARATION +namespace boost { + using std::char_traits; + using std::basic_ostream; + namespace io { + using std::basic_ostream; + namespace detail { + using std::basic_ios; + using std::basic_ostream; + } + } +#if ! defined(BOOST_NO_STD_LOCALE) + using std::locale; + namespace io { + using std::locale; + namespace detail { + using std::locale; + } + } +#endif // locale +} + // -end N.S. boost +#endif // needs_using_declaration + +#if ! defined(BOOST_NO_STD_LOCALE) +#include +#endif + + +// *** hide std::locale if it doesnt exist. +// this typedef is either std::locale or int, avoids placing ifdefs everywhere +namespace boost { namespace io { namespace detail { +#if ! defined(BOOST_NO_STD_LOCALE) + typedef BOOST_IO_STD locale locale_t; +#else + typedef int locale_t; +#endif +} } } + + +// ---------------------------------------------------------------------------- + +#endif // BOOST_FORMAT_MACROS_DEFAULT_HPP diff --git a/realsense-file/3rd_party/boost/boost/format/detail/msvc_disambiguater.hpp b/realsense-file/3rd_party/boost/boost/format/detail/msvc_disambiguater.hpp new file mode 100644 index 0000000000..860a011715 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/format/detail/msvc_disambiguater.hpp @@ -0,0 +1,54 @@ +// ---------------------------------------------------------------------------- +// msvc_disambiguater.hpp : msvc workarounds. (for put_{head|last} overloads) +// the trick was described in boost's list by Aleksey Gurtovoy +// ---------------------------------------------------------------------------- + +// Copyright Samuel Krempp 2003. Use, modification, and distribution are +// subject to the Boost Software License, Version 1.0. (See accompanying +// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// see http://www.boost.org/libs/format for library home page + +// ---------------------------------------------------------------------------- + +#ifndef BOOST_MSVC_DISAMBIGUATER_HPP +#define BOOST_MSVC_DISAMBIGUATER_HPP + +#if BOOST_WORKAROUND(__DECCXX_VER, BOOST_TESTED_AT(60590042)) + +#include +#include + +namespace boost { +namespace io { +namespace detail { + +template< class Ch, class Tr, class T > +struct disambiguater +{ + template< typename U > + static void put_head(BOOST_IO_STD basic_ostream& os, group1 const& x, long) + { + os << group_head(x.a1_); + } + static void put_head(BOOST_IO_STD basic_ostream& os, T const& x, int) + { + } + template< typename U > + static void put_last(BOOST_IO_STD basic_ostream& os, group1 const& x, long) + { + os << group_last(x.a1_); + } + static void put_last(BOOST_IO_STD basic_ostream& os, T const& x, int) + { + os << x; + } +}; + +} // namespace detail +} // namespace io +} // namespace boost + +#endif // -__DECCXX_VER + +#endif // -BOOST_MSVC_DISAMBIGUATER_HPP diff --git a/realsense-file/3rd_party/boost/boost/format/detail/unset_macros.hpp b/realsense-file/3rd_party/boost/boost/format/detail/unset_macros.hpp new file mode 100644 index 0000000000..20226f0ec4 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/format/detail/unset_macros.hpp @@ -0,0 +1,34 @@ +// ---------------------------------------------------------------------------- +// unset_macros.hpp +// ---------------------------------------------------------------------------- + +// Copyright Samuel Krempp 2003. Use, modification, and distribution are +// subject to the Boost Software License, Version 1.0. (See accompanying +// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org/libs/format for library home page + +// ---------------------------------------------------------------------------- + +// *** Undefine 'local' macros : +#ifdef BOOST_NO_OVERLOAD_FOR_NON_CONST +#undef BOOST_NO_OVERLOAD_FOR_NON_CONST +#endif +#ifdef BOOST_NO_LOCALE_ISDIGIT +#undef BOOST_NO_LOCALE_ISDIGIT +#endif +#ifdef BOOST_IO_STD +#undef BOOST_IO_STD +#endif +#ifdef BOOST_IO_NEEDS_USING_DECLARATION +#undef BOOST_IO_NEEDS_USING_DECLARATION +#endif +#ifdef BOOST_NO_TEMPLATE_STD_STREAM +#undef BOOST_NO_TEMPLATE_STD_STREAM +#endif +#ifdef BOOST_FORMAT_STREAMBUF_DEFINED +#undef BOOST_FORMAT_STREAMBUF_DEFINED +#endif +#ifdef BOOST_FORMAT_OSTREAM_DEFINED +#undef BOOST_FORMAT_OSTREAM_DEFINED +#endif diff --git a/realsense-file/3rd_party/boost/boost/format/detail/workarounds_gcc-2_95.hpp b/realsense-file/3rd_party/boost/boost/format/detail/workarounds_gcc-2_95.hpp new file mode 100644 index 0000000000..86608c96c7 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/format/detail/workarounds_gcc-2_95.hpp @@ -0,0 +1,162 @@ +// ---------------------------------------------------------------------------- +// workarounds for gcc < 3.0. +// ---------------------------------------------------------------------------- + +// Copyright Samuel Krempp 2003. Use, modification, and distribution are +// subject to the Boost Software License, Version 1.0. (See accompanying +// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org/libs/format for library home page + + +// ---------------------------------------------------------------------------- + +// There's a lot to do, the stdlib shipped with gcc prior to 3.x +// was terribly non-conforming. +// . defines macros switches +// . supplies template classes basic_foo where gcc only supplies foo. +// i.e : +// - basic_ios from ios +// - basic_ostream from ostream +// - basic_srteambuf from streambuf +// these can be used transparently. (it obviously does not work for wchar_t) +// . specialise CompatAlloc and CompatTraits to wrap gcc-2.95's +// string_char_traits and std::alloc + +#if BOOST_WORKAROUND(__GNUC__, < 3) && !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION) + // only for gcc-2.95's native stdlib + +#ifndef BOOST_FORMAT_WORKAROUNDS_GCC295_H +#define BOOST_FORMAT_WORKAROUNDS_GCC295_H + +// SGI STL doesnt have and others, so we need iostream. +#include +#define BOOST_FORMAT_OSTREAM_DEFINED + +#include +#define BOOST_FORMAT_STREAMBUF_DEFINED + +#define BOOST_NO_TEMPLATE_STD_STREAM + +#ifndef BOOST_IO_STD +# define BOOST_IO_STD std:: +#endif + + + +// *** +// gcc's simple classes turned into standard-like template classes : + +namespace std { + + + // gcc has string_char_traits, it's incomplete. + // we declare a std::char_traits, and specialize CompatTraits<..> on it + // to do what is required + template + class char_traits; // no definition here, we will just use it as a tag. + + template + class basic_streambuf; + + template + class basic_streambuf : public streambuf { + }; + + template > + class basic_ios; + + template + class basic_ios : public ostream { + public: + basic_ios(streambuf * p) : ostream(p) {}; + char fill() const { return ios::fill(); } // gcc returns wchar.. + char fill(char c) { return ios::fill(c); } // gcc takes wchar.. + char widen(char c) { return c; } + char narrow(char c, char def) { return c; } + basic_ios& copyfmt(const ios& right) { + fill(right.fill()); + flags(right.flags() ); + exceptions(right.exceptions()); + width(right.width()); + precision(right.precision()); + return *this; + } + }; + + + typedef ios ios_base; + + template + class basic_ostream; + + template + class basic_ostream : public basic_ios + { + public: + basic_ostream(streambuf * p) : basic_ios (p) {} + }; + +} // namespace std + + +namespace boost { + namespace io { + + + // ** CompatTraits gcc2.95 specialisations ---------------------------- + template + class CompatTraits< ::std::string_char_traits > + : public ::std::string_char_traits + { + public: + typedef CompatTraits compatible_type; + + typedef Ch char_type; + typedef int int_type; + typedef ::std::streampos pos_type; + typedef ::std::streamoff off_type; + + static char_type + to_char_type(const int_type& meta) { + return static_cast(meta); } + static int_type + to_int_type(const char_type& ch) { + return static_cast(static_cast(ch) );} + static bool + eq_int_type(const int_type& left, const int_type& right) { + return left == right; } + static int_type + eof() { + return static_cast(EOF); + } + static int_type + not_eof(const int_type& meta) { + return (meta == eof()) ? 0 : meta; + } + }; + + template + class CompatTraits< ::std::char_traits > { + public: + typedef CompatTraits< ::std::string_char_traits > compatible_type; + }; + + // ** CompatAlloc gcc-2.95 specialisations --------------------------- + template<> + class CompatAlloc< ::std::alloc> + { + public: + typedef ::std::allocator compatible_type; + }; + + } // N.S. io +} // N.S. boost + + + + + +#endif // include guard + +#endif // if workaround diff --git a/realsense-file/3rd_party/boost/boost/format/detail/workarounds_stlport.hpp b/realsense-file/3rd_party/boost/boost/format/detail/workarounds_stlport.hpp new file mode 100644 index 0000000000..5c23e1fe69 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/format/detail/workarounds_stlport.hpp @@ -0,0 +1,36 @@ +// ---------------------------------------------------------------------------- +// workarounds_stlport.hpp : workaround STLport issues +// ---------------------------------------------------------------------------- + +// Copyright Samuel Krempp 2003. Use, modification, and distribution are +// subject to the Boost Software License, Version 1.0. (See accompanying +// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// see http://www.boost.org/libs/format for library home page + +// ---------------------------------------------------------------------------- + +#ifndef BOOST_MACROS_STLPORT_HPP +#define BOOST_MACROS_STLPORT_HPP + +// *** This should go to "boost/config/stdlib/stlport.hpp". + +// If the streams are not native and there are problems with using templates +// accross namespaces, we define some macros to enable a workaround for this. + +// STLport 4.5 +#if !defined(_STLP_OWN_IOSTREAMS) && defined(_STLP_USE_NAMESPACES) && defined(BOOST_NO_USING_TEMPLATE) +# define BOOST_IO_STD +# define BOOST_IO_NEEDS_USING_DECLARATION +#endif + +// STLport 4.0 +#if !defined(__SGI_STL_OWN_IOSTREAMS) && defined(__STL_USE_OWN_NAMESPACE) && defined(BOOST_NO_USING_TEMPLATE) +# define BOOST_IO_STD +# define BOOST_IO_NEEDS_USING_DECLARATION +#endif + + +// ---------------------------------------------------------------------------- + +#endif // BOOST_MACROS_STLPORT_HPP diff --git a/realsense-file/3rd_party/boost/boost/format/exceptions.hpp b/realsense-file/3rd_party/boost/boost/format/exceptions.hpp new file mode 100644 index 0000000000..54b409800c --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/format/exceptions.hpp @@ -0,0 +1,103 @@ +// ---------------------------------------------------------------------------- +// boost/format/exceptions.hpp +// ---------------------------------------------------------------------------- + +// Copyright Samuel Krempp 2003. +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// +// See http://www.boost.org/libs/format/ for library home page + +// ---------------------------------------------------------------------------- + +#ifndef BOOST_FORMAT_EXCEPTIONS_HPP +#define BOOST_FORMAT_EXCEPTIONS_HPP + + +#include + + +namespace boost { + + namespace io { + +// **** exceptions ----------------------------------------------- + + class format_error : public std::exception + { + public: + format_error() {} + virtual const char *what() const throw() { + return "boost::format_error: " + "format generic failure"; + } + }; + + class bad_format_string : public format_error + { + std::size_t pos_, next_; + public: + bad_format_string(std::size_t pos, std::size_t size) + : pos_(pos), next_(size) {} + std::size_t get_pos() const { return pos_; } + std::size_t get_next() const { return next_; } + virtual const char *what() const throw() { + return "boost::bad_format_string: format-string is ill-formed"; + } + }; + + class too_few_args : public format_error + { + std::size_t cur_, expected_; + public: + too_few_args(std::size_t cur, std::size_t expected) + : cur_(cur), expected_(expected) {} + std::size_t get_cur() const { return cur_; } + std::size_t get_expected() const { return expected_; } + virtual const char *what() const throw() { + return "boost::too_few_args: " + "format-string referred to more arguments than were passed"; + } + }; + + class too_many_args : public format_error + { + std::size_t cur_, expected_; + public: + too_many_args(std::size_t cur, std::size_t expected) + : cur_(cur), expected_(expected) {} + std::size_t get_cur() const { return cur_; } + std::size_t get_expected() const { return expected_; } + virtual const char *what() const throw() { + return "boost::too_many_args: " + "format-string referred to less arguments than were passed"; + } + }; + + + class out_of_range : public format_error + { + int index_, beg_, end_; // range is [ beg, end [ + public: + out_of_range(int index, int beg, int end) + : index_(index), beg_(beg), end_(end) {} + int get_index() const { return index_; } + int get_beg() const { return beg_; } + int get_end() const { return end_; } + virtual const char *what() const throw() { + return "boost::out_of_range: " + "tried to refer to an argument (or item) number which" + " is out of range, according to the format string"; + } + }; + + + } // namespace io + +} // namespace boost + + +#endif // BOOST_FORMAT_EXCEPTIONS_HPP diff --git a/realsense-file/3rd_party/boost/boost/format/feed_args.hpp b/realsense-file/3rd_party/boost/boost/format/feed_args.hpp new file mode 100644 index 0000000000..bdb72ea82c --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/format/feed_args.hpp @@ -0,0 +1,315 @@ +// ---------------------------------------------------------------------------- +// feed_args.hpp : functions for processing each argument +// (feed, feed_manip, and distribute) +// ---------------------------------------------------------------------------- + +// Copyright Samuel Krempp 2003. Use, modification, and distribution are +// subject to the Boost Software License, Version 1.0. (See accompanying +// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org/libs/format for library home page + +// ---------------------------------------------------------------------------- + +#ifndef BOOST_FORMAT_FEED_ARGS_HPP +#define BOOST_FORMAT_FEED_ARGS_HPP + +#include +#include +#include + +#include +#include +#include + +namespace boost { +namespace io { +namespace detail { + + template + void mk_str( std::basic_string & res, + const Ch * beg, + typename std::basic_string::size_type size, + std::streamsize w, + const Ch fill_char, + std::ios_base::fmtflags f, + const Ch prefix_space, // 0 if no space-padding + bool center) + // applies centered/left/right padding to the string [beg, beg+size[ + // Effects : the result is placed in res. + { + typedef typename std::basic_string::size_type size_type; + res.resize(0); + if(w<=0 || static_cast(w) <=size) { + // no need to pad. + res.reserve(size + !!prefix_space); + if(prefix_space) + res.append(1, prefix_space); + if (size) + res.append(beg, size); + } + else { + std::streamsize n=static_cast(w-size-!!prefix_space); + std::streamsize n_after = 0, n_before = 0; + res.reserve(static_cast(w)); // allocate once for the 2 inserts + if(center) + n_after = n/2, n_before = n - n_after; + else + if(f & std::ios_base::left) + n_after = n; + else + n_before = n; + // now make the res string : + if(n_before) res.append(static_cast(n_before), fill_char); + if(prefix_space) + res.append(1, prefix_space); + if (size) + res.append(beg, size); + if(n_after) res.append(static_cast(n_after), fill_char); + } + } // -mk_str(..) + + +#if BOOST_WORKAROUND(__DECCXX_VER, BOOST_TESTED_AT(60590042)) +// __DECCXX needs to be tricked to disambiguate this simple overload.. +// the trick is in "boost/format/msvc_disambiguater.hpp" + + template< class Ch, class Tr, class T> inline + void put_head (BOOST_IO_STD basic_ostream & os, const T& x ) { + disambiguater::put_head(os, x, 1L); + } + template< class Ch, class Tr, class T> inline + void put_last (BOOST_IO_STD basic_ostream & os, const T& x ) { + disambiguater::put_last(os, x, 1L); + } + +#else + + template< class Ch, class Tr, class T> inline + void put_head (BOOST_IO_STD basic_ostream &, const T& ) { + } + + template< class Ch, class Tr, class T> inline + void put_head( BOOST_IO_STD basic_ostream & os, const group1& x ) { + os << group_head(x.a1_); // send the first N-1 items, not the last + } + + template< class Ch, class Tr, class T> inline + void put_last( BOOST_IO_STD basic_ostream & os, const T& x ) { + os << x ; + } + + template< class Ch, class Tr, class T> inline + void put_last( BOOST_IO_STD basic_ostream & os, const group1& x ) { + os << group_last(x.a1_); // this selects the last element + } + +#ifndef BOOST_NO_OVERLOAD_FOR_NON_CONST + template< class Ch, class Tr, class T> inline + void put_head( BOOST_IO_STD basic_ostream &, T& ) { + } + + template< class Ch, class Tr, class T> inline + void put_last( BOOST_IO_STD basic_ostream & os, T& x) { + os << x ; + } +#endif +#endif // -__DECCXX workaround + + template< class Ch, class Tr, class T> + void call_put_head(BOOST_IO_STD basic_ostream & os, const void* x) { + put_head(os, *(typename ::boost::remove_reference::type*)x); + } + + template< class Ch, class Tr, class T> + void call_put_last(BOOST_IO_STD basic_ostream & os, const void* x) { + put_last(os, *(T*)x); + } + + template< class Ch, class Tr> + struct put_holder { + template + put_holder(T& t) + : arg(&t), + put_head(&call_put_head), + put_last(&call_put_last) + {} + const void* arg; + void (*put_head)(BOOST_IO_STD basic_ostream & os, const void* x); + void (*put_last)(BOOST_IO_STD basic_ostream & os, const void* x); + }; + + template< class Ch, class Tr> inline + void put_head( BOOST_IO_STD basic_ostream & os, const put_holder& t) { + t.put_head(os, t.arg); + } + + template< class Ch, class Tr> inline + void put_last( BOOST_IO_STD basic_ostream & os, const put_holder& t) { + t.put_last(os, t.arg); + } + + + template< class Ch, class Tr, class Alloc, class T> + void put( T x, + const format_item& specs, + typename basic_format::string_type& res, + typename basic_format::internal_streambuf_t & buf, + io::detail::locale_t *loc_p = NULL) + { +#ifdef BOOST_MSVC + // If std::min or std::max are already instantiated + // at this point then we get a blizzard of warning messages when we call + // those templates with std::size_t as arguments. Weird and very annoyning... +#pragma warning(push) +#pragma warning(disable:4267) +#endif + // does the actual conversion of x, with given params, into a string + // using the supplied stringbuf. + + typedef typename basic_format::string_type string_type; + typedef typename basic_format::format_item_t format_item_t; + typedef typename string_type::size_type size_type; + + basic_oaltstringstream oss( &buf); + specs.fmtstate_.apply_on(oss, loc_p); + + // the stream format state can be modified by manipulators in the argument : + put_head( oss, x ); + // in case x is a group, apply the manip part of it, + // in order to find width + + const std::ios_base::fmtflags fl=oss.flags(); + const bool internal = (fl & std::ios_base::internal) != 0; + const std::streamsize w = oss.width(); + const bool two_stepped_padding= internal && (w!=0); + + res.resize(0); + if(! two_stepped_padding) { + if(w>0) // handle padding via mk_str, not natively in stream + oss.width(0); + put_last( oss, x); + const Ch * res_beg = buf.pbase(); + Ch prefix_space = 0; + if(specs.pad_scheme_ & format_item_t::spacepad) + if(buf.pcount()== 0 || + (res_beg[0] !=oss.widen('+') && res_beg[0] !=oss.widen('-') )) + prefix_space = oss.widen(' '); + size_type res_size = (std::min)( + static_cast(specs.truncate_ - !!prefix_space), + buf.pcount() ); + mk_str(res, res_beg, res_size, w, oss.fill(), fl, + prefix_space, (specs.pad_scheme_ & format_item_t::centered) !=0 ); + } + else { // 2-stepped padding + // internal can be implied by zeropad, or user-set. + // left, right, and centered alignment overrule internal, + // but spacepad or truncate might be mixed with internal (using manipulator) + put_last( oss, x); // may pad + const Ch * res_beg = buf.pbase(); + size_type res_size = buf.pcount(); + bool prefix_space=false; + if(specs.pad_scheme_ & format_item_t::spacepad) + if(buf.pcount()== 0 || + (res_beg[0] !=oss.widen('+') && res_beg[0] !=oss.widen('-') )) + prefix_space = true; + if(res_size == static_cast(w) && w<=specs.truncate_ && !prefix_space) { + // okay, only one thing was printed and padded, so res is fine + res.assign(res_beg, res_size); + } + else { // length w exceeded + // either it was multi-output with first output padding up all width.. + // either it was one big arg and we are fine. + // Note that res_size oss2( &buf); + specs.fmtstate_.apply_on(oss2, loc_p); + put_head( oss2, x ); + + oss2.width(0); + if(prefix_space) + oss2 << ' '; + put_last(oss2, x ); + if(buf.pcount()==0 && specs.pad_scheme_ & format_item_t::spacepad) { + prefix_space =true; + oss2 << ' '; + } + // we now have the minimal-length output + const Ch * tmp_beg = buf.pbase(); + size_type tmp_size = (std::min)(static_cast(specs.truncate_), + buf.pcount() ); + + + if(static_cast(w) <= tmp_size) { + // minimal length is already >= w, so no padding (cool!) + res.assign(tmp_beg, tmp_size); + } + else { // hum.. we need to pad (multi_output, or spacepad present) + //find where we should pad + size_type sz = (std::min)(res_size + (prefix_space ? 1 : 0), tmp_size); + size_type i = prefix_space; + for(; i=tmp_size) i=prefix_space; + res.assign(tmp_beg, i); + std::streamsize d = w - static_cast(tmp_size); + BOOST_ASSERT(d>0); + res.append(static_cast( d ), oss2.fill()); + res.append(tmp_beg+i, tmp_size-i); + BOOST_ASSERT(i+(tmp_size-i)+(std::max)(d,(std::streamsize)0) + == static_cast(w)); + BOOST_ASSERT(res.size() == static_cast(w)); + } + } + } + buf.clear_buffer(); +#ifdef BOOST_MSVC +#pragma warning(pop) +#endif + } // end- put(..) + + + template< class Ch, class Tr, class Alloc, class T> + void distribute (basic_format& self, T x) { + // call put(x, ..) on every occurence of the current argument : + if(self.cur_arg_ >= self.num_args_) { + if( self.exceptions() & too_many_args_bit ) + boost::throw_exception(too_many_args(self.cur_arg_, self.num_args_)); + else return; + } + for(unsigned long i=0; i < self.items_.size(); ++i) { + if(self.items_[i].argN_ == self.cur_arg_) { + put (x, self.items_[i], self.items_[i].res_, + self.buf_, boost::get_pointer(self.loc_) ); + } + } + } + + template + basic_format& + feed_impl (basic_format& self, T x) { + if(self.dumped_) self.clear(); + distribute (self, x); + ++self.cur_arg_; + if(self.bound_.size() != 0) { + while( self.cur_arg_ < self.num_args_ && self.bound_[self.cur_arg_] ) + ++self.cur_arg_; + } + return self; + } + + template inline + basic_format& + feed (basic_format& self, T x) { + return feed_impl&>(self, put_holder(x)); + } + +} // namespace detail +} // namespace io +} // namespace boost + + +#endif // BOOST_FORMAT_FEED_ARGS_HPP diff --git a/realsense-file/3rd_party/boost/boost/format/format_class.hpp b/realsense-file/3rd_party/boost/boost/format/format_class.hpp new file mode 100644 index 0000000000..de7460f6e2 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/format/format_class.hpp @@ -0,0 +1,168 @@ +// ---------------------------------------------------------------------------- +// format_class.hpp : class interface +// ---------------------------------------------------------------------------- + +// Copyright Samuel Krempp 2003. Use, modification, and distribution are +// subject to the Boost Software License, Version 1.0. (See accompanying +// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org/libs/format for library home page + +// ---------------------------------------------------------------------------- + +#ifndef BOOST_FORMAT_CLASS_HPP +#define BOOST_FORMAT_CLASS_HPP + + +#include +#include + +#include // to store locale when needed + +#include +#include +#include +#include + +namespace boost { + + template + class basic_format + { + typedef typename io::CompatTraits::compatible_type compat_traits; + public: + typedef Ch CharT; // borland fails in operator% if we use Ch and Tr directly + typedef std::basic_string string_type; + typedef typename string_type::size_type size_type; + typedef io::detail::format_item format_item_t; + typedef io::basic_altstringbuf internal_streambuf_t; + + + explicit basic_format(const Ch* str=NULL); + explicit basic_format(const string_type& s); + basic_format(const basic_format& x); + basic_format& operator= (const basic_format& x); + void swap(basic_format& x); + +#if !defined(BOOST_NO_STD_LOCALE) + explicit basic_format(const Ch* str, const std::locale & loc); + explicit basic_format(const string_type& s, const std::locale & loc); +#endif + io::detail::locale_t getloc() const; + + basic_format& clear(); // empty all converted string buffers (except bound items) + basic_format& clear_binds(); // unbind all bound items, and call clear() + basic_format& parse(const string_type&); // resets buffers and parse a new format string + + // ** formatted result ** // + size_type size() const; // sum of the current string pieces sizes + string_type str() const; // final string + + // ** arguments passing ** // + template + basic_format& operator%(const T& x) + { return io::detail::feed(*this,x); } + +#ifndef BOOST_NO_OVERLOAD_FOR_NON_CONST + template basic_format& operator%(T& x) + { return io::detail::feed(*this,x); } +#endif + +#if defined(__GNUC__) + // GCC can't handle anonymous enums without some help + // ** arguments passing ** // + basic_format& operator%(const int& x) + { return io::detail::feed(*this,x); } + +#ifndef BOOST_NO_OVERLOAD_FOR_NON_CONST + basic_format& operator%(int& x) + { return io::detail::feed(*this,x); } +#endif +#endif + + // The total number of arguments expected to be passed to the format objectt + int expected_args() const + { return num_args_; } + // The number of arguments currently bound (see bind_arg(..) ) + int bound_args() const; + // The number of arguments currently fed to the format object + int fed_args() const; + // The index (1-based) of the current argument (i.e. next to be formatted) + int cur_arg() const; + // The number of arguments still required to be fed + int remaining_args() const; // same as expected_args() - bound_args() - fed_args() + + + // ** object modifying **// + template + basic_format& bind_arg(int argN, const T& val) + { return io::detail::bind_arg_body(*this, argN, val); } + basic_format& clear_bind(int argN); + template + basic_format& modify_item(int itemN, T manipulator) + { return io::detail::modify_item_body (*this, itemN, manipulator);} + + // Choosing which errors will throw exceptions : + unsigned char exceptions() const; + unsigned char exceptions(unsigned char newexcept); + +#if !defined( BOOST_NO_MEMBER_TEMPLATE_FRIENDS ) \ + && !BOOST_WORKAROUND(__BORLANDC__, <= 0x570) \ + && !BOOST_WORKAROUND( _CRAYC, != 0) \ + && !BOOST_WORKAROUND(__DECCXX_VER, BOOST_TESTED_AT(60590042)) + // use friend templates and private members only if supported + +#ifndef BOOST_NO_TEMPLATE_STD_STREAM + template + friend std::basic_ostream & + operator<<( std::basic_ostream & , + const basic_format& ); +#else + template + friend std::ostream & + operator<<( std::ostream & , + const basic_format& ); +#endif + + template + friend basic_format& + io::detail::feed_impl (basic_format&, T); + + template friend + void io::detail::distribute (basic_format&, T); + + template friend + basic_format& + io::detail::modify_item_body (basic_format&, int, T); + + template friend + basic_format& + io::detail::bind_arg_body (basic_format&, int, const T&); + + private: +#endif + typedef io::detail::stream_format_state stream_format_state; + // flag bits, used for style_ + enum style_values { ordered = 1, // set only if all directives are positional + special_needs = 4 }; + + void make_or_reuse_data(std::size_t nbitems);// used for (re-)initialisation + + // member data --------------------------------------------// + std::vector items_; // each '%..' directive leads to a format_item + std::vector bound_; // stores which arguments were bound. size() == 0 || num_args + + int style_; // style of format-string : positional or not, etc + int cur_arg_; // keep track of wich argument is current + int num_args_; // number of expected arguments + mutable bool dumped_; // true only after call to str() or << + string_type prefix_; // piece of string to insert before first item + unsigned char exceptions_; + internal_streambuf_t buf_; // the internal stream buffer. + boost::optional loc_; + }; // class basic_format + +} // namespace boost + + +#endif // BOOST_FORMAT_CLASS_HPP diff --git a/realsense-file/3rd_party/boost/boost/format/format_fwd.hpp b/realsense-file/3rd_party/boost/boost/format/format_fwd.hpp new file mode 100644 index 0000000000..2dd1138538 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/format/format_fwd.hpp @@ -0,0 +1,43 @@ +// ---------------------------------------------------------------------------- +// format_fwd.hpp : forward declarations +// ---------------------------------------------------------------------------- + +// Copyright Samuel Krempp 2003. Use, modification, and distribution are +// subject to the Boost Software License, Version 1.0. (See accompanying +// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org/libs/format for library home page + +// ---------------------------------------------------------------------------- + +#ifndef BOOST_FORMAT_FWD_HPP +#define BOOST_FORMAT_FWD_HPP + +#include +#include + +#include + +namespace boost { + + template , class Alloc = std::allocator > + class basic_format; + + typedef basic_format format; + +#if !defined(BOOST_NO_STD_WSTRING) && !defined(BOOST_NO_STD_WSTREAMBUF) + typedef basic_format wformat; +#endif + + namespace io { + enum format_error_bits { bad_format_string_bit = 1, + too_few_args_bit = 2, too_many_args_bit = 4, + out_of_range_bit = 8, + all_error_bits = 255, no_error_bits=0 }; + + } // namespace io + +} // namespace boost + +#endif // BOOST_FORMAT_FWD_HPP diff --git a/realsense-file/3rd_party/boost/boost/format/format_implementation.hpp b/realsense-file/3rd_party/boost/boost/format/format_implementation.hpp new file mode 100644 index 0000000000..7f8b15cdf9 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/format/format_implementation.hpp @@ -0,0 +1,329 @@ +// ---------------------------------------------------------------------------- +// format_implementation.hpp Implementation of the basic_format class +// ---------------------------------------------------------------------------- + +// Copyright Samuel Krempp 2003. Use, modification, and distribution are +// subject to the Boost Software License, Version 1.0. (See accompanying +// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org/libs/format for library home page + + +// ---------------------------------------------------------------------------- + +#ifndef BOOST_FORMAT_IMPLEMENTATION_HPP +#define BOOST_FORMAT_IMPLEMENTATION_HPP + +#include +#include +#include +#include +#include // std::swap + +namespace boost { + +// --- basic_format implementation -----------------------------------------// + + template< class Ch, class Tr, class Alloc> + basic_format:: basic_format(const Ch* s) + : style_(0), cur_arg_(0), num_args_(0), dumped_(false), + exceptions_(io::all_error_bits) + { + if( s) + parse( s ); + } + +#if !defined(BOOST_NO_STD_LOCALE) + template< class Ch, class Tr, class Alloc> + basic_format:: basic_format(const Ch* s, const std::locale & loc) + : style_(0), cur_arg_(0), num_args_(0), dumped_(false), + exceptions_(io::all_error_bits), loc_(loc) + { + if(s) parse( s ); + } + + template< class Ch, class Tr, class Alloc> + basic_format:: basic_format(const string_type& s, const std::locale & loc) + : style_(0), cur_arg_(0), num_args_(0), dumped_(false), + exceptions_(io::all_error_bits), loc_(loc) + { + parse(s); + } +#endif // ! BOOST_NO_STD_LOCALE + template< class Ch, class Tr, class Alloc> + io::detail::locale_t basic_format:: + getloc() const { + return loc_ ? loc_.get() : io::detail::locale_t(); + } + + template< class Ch, class Tr, class Alloc> + basic_format:: basic_format(const string_type& s) + : style_(0), cur_arg_(0), num_args_(0), dumped_(false), + exceptions_(io::all_error_bits) + { + parse(s); + } + + template< class Ch, class Tr, class Alloc> // just don't copy the buf_ member + basic_format:: basic_format(const basic_format& x) + : items_(x.items_), bound_(x.bound_), style_(x.style_), + cur_arg_(x.cur_arg_), num_args_(x.num_args_), dumped_(x.dumped_), + prefix_(x.prefix_), exceptions_(x.exceptions_), loc_(x.loc_) + { + } + + template< class Ch, class Tr, class Alloc> // just don't copy the buf_ member + basic_format& basic_format:: + operator= (const basic_format& x) { + if(this == &x) + return *this; + (basic_format(x)).swap(*this); + return *this; + } + template< class Ch, class Tr, class Alloc> + void basic_format:: + swap (basic_format & x) { + std::swap(exceptions_, x.exceptions_); + std::swap(style_, x.style_); + std::swap(cur_arg_, x.cur_arg_); + std::swap(num_args_, x.num_args_); + std::swap(dumped_, x.dumped_); + + items_.swap(x.items_); + prefix_.swap(x.prefix_); + bound_.swap(x.bound_); + } + + template< class Ch, class Tr, class Alloc> + unsigned char basic_format:: exceptions() const { + return exceptions_; + } + + template< class Ch, class Tr, class Alloc> + unsigned char basic_format:: exceptions(unsigned char newexcept) { + unsigned char swp = exceptions_; + exceptions_ = newexcept; + return swp; + } + + template + void basic_format:: + make_or_reuse_data (std::size_t nbitems) { +#if !defined(BOOST_NO_STD_LOCALE) + Ch fill = ( BOOST_USE_FACET(std::ctype, getloc()) ). widen(' '); +#else + Ch fill = ' '; +#endif + if(items_.size() == 0) + items_.assign( nbitems, format_item_t(fill) ); + else { + if(nbitems>items_.size()) + items_.resize(nbitems, format_item_t(fill)); + bound_.resize(0); + for(std::size_t i=0; i < nbitems; ++i) + items_[i].reset(fill); // strings are resized, instead of reallocated + } + prefix_.resize(0); + } + + template< class Ch, class Tr, class Alloc> + basic_format& basic_format:: + clear () { + // empty the string buffers (except bound arguments) + // and make the format object ready for formatting a new set of arguments + + BOOST_ASSERT( bound_.size()==0 || num_args_ == static_cast(bound_.size()) ); + + for(unsigned long i=0; i + basic_format& basic_format:: + clear_binds () { + // remove all binds, then clear() + bound_.resize(0); + clear(); + return *this; + } + + template< class Ch, class Tr, class Alloc> + basic_format& basic_format:: + clear_bind (int argN) { + // remove the bind of ONE argument then clear() + if(argN<1 || argN > num_args_ || bound_.size()==0 || !bound_[argN-1] ) { + if( exceptions() & io::out_of_range_bit) + boost::throw_exception(io::out_of_range(argN, 1, num_args_+1 ) ); + else return *this; + } + bound_[argN-1]=false; + clear(); + return *this; + } + + template< class Ch, class Tr, class Alloc> + int basic_format:: + bound_args() const { + if(bound_.size()==0) + return 0; + int n=0; + for(int i=0; i + int basic_format:: + fed_args() const { + if(bound_.size()==0) + return cur_arg_; + int n=0; + for(int i=0; i + int basic_format:: + cur_arg() const { + return cur_arg_+1; } + + template< class Ch, class Tr, class Alloc> + int basic_format:: + remaining_args() const { + if(bound_.size()==0) + return num_args_-cur_arg_; + int n=0; + for(int i=cur_arg_; i + typename basic_format::string_type + basic_format:: + str () const { + if(items_.size()==0) + return prefix_; + if( cur_arg_ < num_args_) + if( exceptions() & io::too_few_args_bit ) + // not enough variables supplied + boost::throw_exception(io::too_few_args(cur_arg_, num_args_)); + + unsigned long i; + string_type res; + res.reserve(size()); + res += prefix_; + for(i=0; i < items_.size(); ++i) { + const format_item_t& item = items_[i]; + res += item.res_; + if( item.argN_ == format_item_t::argN_tabulation) { + BOOST_ASSERT( item.pad_scheme_ & format_item_t::tabulation); + if( static_cast(item.fmtstate_.width_) > res.size() ) + res.append( static_cast(item.fmtstate_.width_) - res.size(), + item.fmtstate_.fill_ ); + } + res += item.appendix_; + } + dumped_=true; + return res; + } + template< class Ch, class Tr, class Alloc> + typename std::basic_string::size_type basic_format:: + size () const { +#ifdef BOOST_MSVC + // If std::min or std::max are already instantiated + // at this point then we get a blizzard of warning messages when we call + // those templates with std::size_t as arguments. Weird and very annoyning... +#pragma warning(push) +#pragma warning(disable:4267) +#endif + BOOST_USING_STD_MAX(); + size_type sz = prefix_.size(); + unsigned long i; + for(i=0; i < items_.size(); ++i) { + const format_item_t& item = items_[i]; + sz += item.res_.size(); + if( item.argN_ == format_item_t::argN_tabulation) + sz = max BOOST_PREVENT_MACRO_SUBSTITUTION (sz, + static_cast(item.fmtstate_.width_) ); + sz += item.appendix_.size(); + } + return sz; +#ifdef BOOST_MSVC +#pragma warning(pop) +#endif + } + +namespace io { +namespace detail { + + template + basic_format& + bind_arg_body (basic_format& self, int argN, const T& val) { + // bind one argument to a fixed value + // this is persistent over clear() calls, thus also over str() and << + if(self.dumped_) + self.clear(); // needed because we will modify cur_arg_ + if(argN<1 || argN > self.num_args_) { + if( self.exceptions() & io::out_of_range_bit ) + boost::throw_exception(io::out_of_range(argN, 1, self.num_args_+1 ) ); + else return self; + } + if(self.bound_.size()==0) + self.bound_.assign(self.num_args_,false); + else + BOOST_ASSERT( self.num_args_ == static_cast(self.bound_.size()) ); + int o_cur_arg = self.cur_arg_; + self.cur_arg_ = argN-1; // arrays begin at 0 + + self.bound_[self.cur_arg_]=false; // if already set, we unset and re-sets.. + self.operator%(val); // put val at the right place, because cur_arg is set + + + // Now re-position cur_arg before leaving : + self.cur_arg_ = o_cur_arg; + self.bound_[argN-1]=true; + if(self.cur_arg_ == argN-1 ) { + // hum, now this arg is bound, so move to next free arg + while(self.cur_arg_ < self.num_args_ && self.bound_[self.cur_arg_]) + ++self.cur_arg_; + } + // In any case, we either have all args, or are on an unbound arg : + BOOST_ASSERT( self.cur_arg_ >= self.num_args_ || ! self.bound_[self.cur_arg_]); + return self; + } + + template basic_format& + modify_item_body (basic_format& self, int itemN, T manipulator) { + // applies a manipulator to the format_item describing a given directive. + // this is a permanent change, clear or reset won't cancel that. + if(itemN<1 || itemN > static_cast(self.items_.size() )) { + if( self.exceptions() & io::out_of_range_bit ) + boost::throw_exception(io::out_of_range(itemN, 1, static_cast(self.items_.size()) )); + else return self; + } + self.items_[itemN-1].fmtstate_. template apply_manip ( manipulator ); + return self; + } + +} // namespace detail +} // namespace io +} // namespace boost + + + +#endif // BOOST_FORMAT_IMPLEMENTATION_HPP diff --git a/realsense-file/3rd_party/boost/boost/format/free_funcs.hpp b/realsense-file/3rd_party/boost/boost/format/free_funcs.hpp new file mode 100644 index 0000000000..76b592a844 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/format/free_funcs.hpp @@ -0,0 +1,70 @@ +// ---------------------------------------------------------------------------- +// free_funcs.hpp : implementation of the free functions of boost::format +// ---------------------------------------------------------------------------- + +// Copyright Samuel Krempp 2003. Use, modification, and distribution are +// subject to the Boost Software License, Version 1.0. (See accompanying +// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org/libs/format for library home page + +// ---------------------------------------------------------------------------- + +#ifndef BOOST_FORMAT_FUNCS_HPP +#define BOOST_FORMAT_FUNCS_HPP + +#include +#include + +namespace boost { + + template inline + std::basic_string str(const basic_format& f) { + // adds up all pieces of strings and converted items, and return the formatted string + return f.str(); + } + namespace io { + using ::boost::str; // keep compatibility with when it was defined in this N.S. + } // - namespace io + +#ifndef BOOST_NO_TEMPLATE_STD_STREAM + template + std::basic_ostream & + operator<<( std::basic_ostream & os, + const basic_format& f) +#else + template + std::ostream & + operator<<( std::ostream & os, + const basic_format& f) +#endif + // effect: "return os << str(f);" but we can do it faster + { + typedef boost::basic_format format_t; + if(f.items_.size()==0) + os << f.prefix_; + else { + if(f.cur_arg_ < f.num_args_) + if( f.exceptions() & io::too_few_args_bit ) + // not enough variables supplied + boost::throw_exception(io::too_few_args(f.cur_arg_, f.num_args_)); + if(f.style_ & format_t::special_needs) + os << f.str(); + else { + // else we dont have to count chars output, so we dump directly to os : + os << f.prefix_; + for(unsigned long i=0; i + + +namespace boost { +namespace io { + + +namespace detail { + + +// empty group, but useful even though. +struct group0 +{ + group0() {} +}; + +template +inline +BOOST_IO_STD basic_ostream& +operator << ( BOOST_IO_STD basic_ostream& os, + const group0& ) +{ + return os; +} + +template +struct group1 +{ + T1 a1_; + group1(T1 a1) + : a1_(a1) + {} +private: + group1& operator=(const group1&); +}; + +template +inline +BOOST_IO_STD basic_ostream& +operator << (BOOST_IO_STD basic_ostream& os, + const group1& x) +{ + os << x.a1_; + return os; +} + + + + +template +struct group2 +{ + T1 a1_; + T2 a2_; + group2(T1 a1,T2 a2) + : a1_(a1),a2_(a2) + {} +private: + group2& operator=(const group2&); +}; + +template +inline +BOOST_IO_STD basic_ostream& +operator << (BOOST_IO_STD basic_ostream& os, + const group2& x) +{ + os << x.a1_<< x.a2_; + return os; +} + +template +struct group3 +{ + T1 a1_; + T2 a2_; + T3 a3_; + group3(T1 a1,T2 a2,T3 a3) + : a1_(a1),a2_(a2),a3_(a3) + {} +private: + group3& operator=(const group3&); +}; + +template +inline +BOOST_IO_STD basic_ostream& +operator << (BOOST_IO_STD basic_ostream& os, + const group3& x) +{ + os << x.a1_<< x.a2_<< x.a3_; + return os; +} + +template +struct group4 +{ + T1 a1_; + T2 a2_; + T3 a3_; + T4 a4_; + group4(T1 a1,T2 a2,T3 a3,T4 a4) + : a1_(a1),a2_(a2),a3_(a3),a4_(a4) + {} +private: + group4& operator=(const group4&); +}; + +template +inline +BOOST_IO_STD basic_ostream& +operator << (BOOST_IO_STD basic_ostream& os, + const group4& x) +{ + os << x.a1_<< x.a2_<< x.a3_<< x.a4_; + return os; +} + +template +struct group5 +{ + T1 a1_; + T2 a2_; + T3 a3_; + T4 a4_; + T5 a5_; + group5(T1 a1,T2 a2,T3 a3,T4 a4,T5 a5) + : a1_(a1),a2_(a2),a3_(a3),a4_(a4),a5_(a5) + {} +}; + +template +inline +BOOST_IO_STD basic_ostream& +operator << (BOOST_IO_STD basic_ostream& os, + const group5& x) +{ + os << x.a1_<< x.a2_<< x.a3_<< x.a4_<< x.a5_; + return os; +} + +template +struct group6 +{ + T1 a1_; + T2 a2_; + T3 a3_; + T4 a4_; + T5 a5_; + T6 a6_; + group6(T1 a1,T2 a2,T3 a3,T4 a4,T5 a5,T6 a6) + : a1_(a1),a2_(a2),a3_(a3),a4_(a4),a5_(a5),a6_(a6) + {} +}; + +template +inline +BOOST_IO_STD basic_ostream& +operator << (BOOST_IO_STD basic_ostream& os, + const group6& x) +{ + os << x.a1_<< x.a2_<< x.a3_<< x.a4_<< x.a5_<< x.a6_; + return os; +} + +template +struct group7 +{ + T1 a1_; + T2 a2_; + T3 a3_; + T4 a4_; + T5 a5_; + T6 a6_; + T7 a7_; + group7(T1 a1,T2 a2,T3 a3,T4 a4,T5 a5,T6 a6,T7 a7) + : a1_(a1),a2_(a2),a3_(a3),a4_(a4),a5_(a5),a6_(a6),a7_(a7) + {} +}; + +template +inline +BOOST_IO_STD basic_ostream& +operator << (BOOST_IO_STD basic_ostream& os, + const group7& x) +{ + os << x.a1_<< x.a2_<< x.a3_<< x.a4_<< x.a5_<< x.a6_<< x.a7_; + return os; +} + +template +struct group8 +{ + T1 a1_; + T2 a2_; + T3 a3_; + T4 a4_; + T5 a5_; + T6 a6_; + T7 a7_; + T8 a8_; + group8(T1 a1,T2 a2,T3 a3,T4 a4,T5 a5,T6 a6,T7 a7,T8 a8) + : a1_(a1),a2_(a2),a3_(a3),a4_(a4),a5_(a5),a6_(a6),a7_(a7),a8_(a8) + {} +}; + +template +inline +BOOST_IO_STD basic_ostream& +operator << (BOOST_IO_STD basic_ostream& os, + const group8& x) +{ + os << x.a1_<< x.a2_<< x.a3_<< x.a4_<< x.a5_<< x.a6_<< x.a7_<< x.a8_; + return os; +} + +template +struct group9 +{ + T1 a1_; + T2 a2_; + T3 a3_; + T4 a4_; + T5 a5_; + T6 a6_; + T7 a7_; + T8 a8_; + T9 a9_; + group9(T1 a1,T2 a2,T3 a3,T4 a4,T5 a5,T6 a6,T7 a7,T8 a8,T9 a9) + : a1_(a1),a2_(a2),a3_(a3),a4_(a4),a5_(a5),a6_(a6),a7_(a7),a8_(a8),a9_(a9) + {} +}; + +template +inline +BOOST_IO_STD basic_ostream& +operator << (BOOST_IO_STD basic_ostream& os, + const group9& x) +{ + os << x.a1_<< x.a2_<< x.a3_<< x.a4_<< x.a5_<< x.a6_<< x.a7_<< x.a8_<< x.a9_; + return os; +} + +template +struct group10 +{ + T1 a1_; + T2 a2_; + T3 a3_; + T4 a4_; + T5 a5_; + T6 a6_; + T7 a7_; + T8 a8_; + T9 a9_; + T10 a10_; + group10(T1 a1,T2 a2,T3 a3,T4 a4,T5 a5,T6 a6,T7 a7,T8 a8,T9 a9,T10 a10) + : a1_(a1),a2_(a2),a3_(a3),a4_(a4),a5_(a5),a6_(a6),a7_(a7),a8_(a8),a9_(a9),a10_(a10) + {} +}; + +template +inline +BOOST_IO_STD basic_ostream& +operator << (BOOST_IO_STD basic_ostream& os, + const group10& x) +{ + os << x.a1_<< x.a2_<< x.a3_<< x.a4_<< x.a5_<< x.a6_<< x.a7_<< x.a8_<< x.a9_<< x.a10_; + return os; +} + + + + +template +inline +group1 +group_head( group2 const& x) +{ + return group1 (x.a1_); +} + +template +inline +group1 +group_last( group2 const& x) +{ + return group1 (x.a2_); +} + + + +template +inline +group2 +group_head( group3 const& x) +{ + return group2 (x.a1_,x.a2_); +} + +template +inline +group1 +group_last( group3 const& x) +{ + return group1 (x.a3_); +} + + + +template +inline +group3 +group_head( group4 const& x) +{ + return group3 (x.a1_,x.a2_,x.a3_); +} + +template +inline +group1 +group_last( group4 const& x) +{ + return group1 (x.a4_); +} + + + +template +inline +group4 +group_head( group5 const& x) +{ + return group4 (x.a1_,x.a2_,x.a3_,x.a4_); +} + +template +inline +group1 +group_last( group5 const& x) +{ + return group1 (x.a5_); +} + + + +template +inline +group5 +group_head( group6 const& x) +{ + return group5 (x.a1_,x.a2_,x.a3_,x.a4_,x.a5_); +} + +template +inline +group1 +group_last( group6 const& x) +{ + return group1 (x.a6_); +} + + + +template +inline +group6 +group_head( group7 const& x) +{ + return group6 (x.a1_,x.a2_,x.a3_,x.a4_,x.a5_,x.a6_); +} + +template +inline +group1 +group_last( group7 const& x) +{ + return group1 (x.a7_); +} + + + +template +inline +group7 +group_head( group8 const& x) +{ + return group7 (x.a1_,x.a2_,x.a3_,x.a4_,x.a5_,x.a6_,x.a7_); +} + +template +inline +group1 +group_last( group8 const& x) +{ + return group1 (x.a8_); +} + + + +template +inline +group8 +group_head( group9 const& x) +{ + return group8 (x.a1_,x.a2_,x.a3_,x.a4_,x.a5_,x.a6_,x.a7_,x.a8_); +} + +template +inline +group1 +group_last( group9 const& x) +{ + return group1 (x.a9_); +} + + + +template +inline +group9 +group_head( group10 const& x) +{ + return group9 (x.a1_,x.a2_,x.a3_,x.a4_,x.a5_,x.a6_,x.a7_,x.a8_,x.a9_); +} + +template +inline +group1 +group_last( group10 const& x) +{ + return group1 (x.a10_); +} + + + + + +} // namespace detail + + + +// helper functions + + +inline detail::group1< detail::group0 > +group() { return detail::group1< detail::group0 > ( detail::group0() ); } + +template +inline +detail::group1< detail::group2 > + group(T1 a1, Var const& var) +{ + return detail::group1< detail::group2 > + ( detail::group2 + (a1, var) + ); +} + +template +inline +detail::group1< detail::group3 > + group(T1 a1,T2 a2, Var const& var) +{ + return detail::group1< detail::group3 > + ( detail::group3 + (a1,a2, var) + ); +} + +template +inline +detail::group1< detail::group4 > + group(T1 a1,T2 a2,T3 a3, Var const& var) +{ + return detail::group1< detail::group4 > + ( detail::group4 + (a1,a2,a3, var) + ); +} + +template +inline +detail::group1< detail::group5 > + group(T1 a1,T2 a2,T3 a3,T4 a4, Var const& var) +{ + return detail::group1< detail::group5 > + ( detail::group5 + (a1,a2,a3,a4, var) + ); +} + +template +inline +detail::group1< detail::group6 > + group(T1 a1,T2 a2,T3 a3,T4 a4,T5 a5, Var const& var) +{ + return detail::group1< detail::group6 > + ( detail::group6 + (a1,a2,a3,a4,a5, var) + ); +} + +template +inline +detail::group1< detail::group7 > + group(T1 a1,T2 a2,T3 a3,T4 a4,T5 a5,T6 a6, Var const& var) +{ + return detail::group1< detail::group7 > + ( detail::group7 + (a1,a2,a3,a4,a5,a6, var) + ); +} + +template +inline +detail::group1< detail::group8 > + group(T1 a1,T2 a2,T3 a3,T4 a4,T5 a5,T6 a6,T7 a7, Var const& var) +{ + return detail::group1< detail::group8 > + ( detail::group8 + (a1,a2,a3,a4,a5,a6,a7, var) + ); +} + +template +inline +detail::group1< detail::group9 > + group(T1 a1,T2 a2,T3 a3,T4 a4,T5 a5,T6 a6,T7 a7,T8 a8, Var const& var) +{ + return detail::group1< detail::group9 > + ( detail::group9 + (a1,a2,a3,a4,a5,a6,a7,a8, var) + ); +} + +template +inline +detail::group1< detail::group10 > + group(T1 a1,T2 a2,T3 a3,T4 a4,T5 a5,T6 a6,T7 a7,T8 a8,T9 a9, Var const& var) +{ + return detail::group1< detail::group10 > + ( detail::group10 + (a1,a2,a3,a4,a5,a6,a7,a8,a9, var) + ); +} + + +#ifndef BOOST_NO_OVERLOAD_FOR_NON_CONST + +template +inline +detail::group1< detail::group2 > + group(T1 a1, Var& var) +{ + return detail::group1< detail::group2 > + ( detail::group2 + (a1, var) + ); +} + +template +inline +detail::group1< detail::group3 > + group(T1 a1,T2 a2, Var& var) +{ + return detail::group1< detail::group3 > + ( detail::group3 + (a1,a2, var) + ); +} + +template +inline +detail::group1< detail::group4 > + group(T1 a1,T2 a2,T3 a3, Var& var) +{ + return detail::group1< detail::group4 > + ( detail::group4 + (a1,a2,a3, var) + ); +} + +template +inline +detail::group1< detail::group5 > + group(T1 a1,T2 a2,T3 a3,T4 a4, Var& var) +{ + return detail::group1< detail::group5 > + ( detail::group5 + (a1,a2,a3,a4, var) + ); +} + +template +inline +detail::group1< detail::group6 > + group(T1 a1,T2 a2,T3 a3,T4 a4,T5 a5, Var& var) +{ + return detail::group1< detail::group6 > + ( detail::group6 + (a1,a2,a3,a4,a5, var) + ); +} + +template +inline +detail::group1< detail::group7 > + group(T1 a1,T2 a2,T3 a3,T4 a4,T5 a5,T6 a6, Var& var) +{ + return detail::group1< detail::group7 > + ( detail::group7 + (a1,a2,a3,a4,a5,a6, var) + ); +} + +template +inline +detail::group1< detail::group8 > + group(T1 a1,T2 a2,T3 a3,T4 a4,T5 a5,T6 a6,T7 a7, Var& var) +{ + return detail::group1< detail::group8 > + ( detail::group8 + (a1,a2,a3,a4,a5,a6,a7, var) + ); +} + +template +inline +detail::group1< detail::group9 > + group(T1 a1,T2 a2,T3 a3,T4 a4,T5 a5,T6 a6,T7 a7,T8 a8, Var& var) +{ + return detail::group1< detail::group9 > + ( detail::group9 + (a1,a2,a3,a4,a5,a6,a7,a8, var) + ); +} + +template +inline +detail::group1< detail::group10 > + group(T1 a1,T2 a2,T3 a3,T4 a4,T5 a5,T6 a6,T7 a7,T8 a8,T9 a9, Var& var) +{ + return detail::group1< detail::group10 > + ( detail::group10 + (a1,a2,a3,a4,a5,a6,a7,a8,a9, var) + ); +} + + +#endif // - BOOST_NO_OVERLOAD_FOR_NON_CONST + + +} // namespace io + +} // namespace boost + + +#endif // BOOST_FORMAT_GROUP_HPP diff --git a/realsense-file/3rd_party/boost/boost/format/internals.hpp b/realsense-file/3rd_party/boost/boost/format/internals.hpp new file mode 100644 index 0000000000..71aba02ecb --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/format/internals.hpp @@ -0,0 +1,202 @@ +// ---------------------------------------------------------------------------- +// internals.hpp : internal structs : stream_format_state, format_item. +// included by format.hpp +// ---------------------------------------------------------------------------- + +// Copyright Samuel Krempp 2003. Use, modification, and distribution are +// subject to the Boost Software License, Version 1.0. (See accompanying +// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org/libs/format for library home page + +// ---------------------------------------------------------------------------- + +#ifndef BOOST_FORMAT_INTERNALS_HPP +#define BOOST_FORMAT_INTERNALS_HPP + + +#include +#include +#include +#include +#include +#include // used as a dummy stream + +namespace boost { +namespace io { +namespace detail { + + +//---- stream_format_state --------------------------------------------------// + +// set of params that define the format state of a stream + template + struct stream_format_state + { + typedef BOOST_IO_STD basic_ios basic_ios; + + stream_format_state(Ch fill) { reset(fill); } +// stream_format_state(const basic_ios& os) { set_by_stream(os); } + + void reset(Ch fill); //- sets to default state. + void set_by_stream(const basic_ios& os); //- sets to os's state. + void apply_on(basic_ios & os, //- applies format_state to the stream + boost::io::detail::locale_t * loc_default = 0) const; + template + void apply_manip(T manipulator) //- modifies state by applying manipulator + { apply_manip_body( *this, manipulator) ; } + + // --- data --- + std::streamsize width_; + std::streamsize precision_; + Ch fill_; + std::ios_base::fmtflags flags_; + std::ios_base::iostate rdstate_; + std::ios_base::iostate exceptions_; + boost::optional loc_; + }; + + +//---- format_item ---------------------------------------------------------// + +// stores all parameters that can be specified in format strings + template + struct format_item + { + enum pad_values { zeropad = 1, spacepad =2, centered=4, tabulation = 8 }; + // 1. if zeropad is set, all other bits are not, + // 2. if tabulation is set, all others are not. + // centered and spacepad can be mixed freely. + enum arg_values { argN_no_posit = -1, // non-positional directive. will set argN later + argN_tabulation = -2, // tabulation directive. (no argument read) + argN_ignored = -3 // ignored directive. (no argument read) + }; + typedef BOOST_IO_STD basic_ios basic_ios; + typedef detail::stream_format_state stream_format_state; + typedef ::std::basic_string string_type; + + format_item(Ch fill) :argN_(argN_no_posit), fmtstate_(fill), + truncate_(max_streamsize()), pad_scheme_(0) {} + void reset(Ch fill); + void compute_states(); // sets states according to truncate and pad_scheme. + + static std::streamsize max_streamsize() { + return (std::numeric_limits::max)(); + } + + // --- data --- + int argN_; //- argument number (starts at 0, eg : %1 => argN=0) + // negative values for items that don't process an argument + string_type res_; //- result of the formatting of this item + string_type appendix_; //- piece of string between this item and the next + + stream_format_state fmtstate_;// set by parsing, is only affected by modify_item + + std::streamsize truncate_;//- is set for directives like %.5s that ask truncation + unsigned int pad_scheme_;//- several possible padding schemes can mix. see pad_values + }; + + + +//--- Definitions ------------------------------------------------------------ + +// - stream_format_state:: ------------------------------------------------- + template + void stream_format_state:: apply_on (basic_ios & os, + boost::io::detail::locale_t * loc_default) const { + // If a locale is available, set it first. "os.fill(fill_);" may chrash otherwise. +#if !defined(BOOST_NO_STD_LOCALE) + if(loc_) + os.imbue(loc_.get()); + else if(loc_default) + os.imbue(*loc_default); +#else + (void) loc_default; // keep compiler quiet if we don't support locales +#endif + // set the state of this stream according to our params + if(width_ != -1) + os.width(width_); + if(precision_ != -1) + os.precision(precision_); + if(fill_ != 0) + os.fill(fill_); + os.flags(flags_); + os.clear(rdstate_); + os.exceptions(exceptions_); + } + + template + void stream_format_state:: set_by_stream(const basic_ios& os) { + // set our params according to the state of this stream + flags_ = os.flags(); + width_ = os.width(); + precision_ = os.precision(); + fill_ = os.fill(); + rdstate_ = os.rdstate(); + exceptions_ = os.exceptions(); + } + + + template + void apply_manip_body( stream_format_state& self, + T manipulator) { + // modify our params according to the manipulator + basic_oaltstringstream ss; + self.apply_on( ss ); + ss << manipulator; + self.set_by_stream( ss ); + } + + template inline + void stream_format_state:: reset(Ch fill) { + // set our params to standard's default state. cf 27.4.4.1 of the C++ norm + width_=0; precision_=6; + fill_=fill; // default is widen(' '), but we cant compute it without the locale + flags_ = std::ios_base::dec | std::ios_base::skipws; + // the adjust_field part is left equal to 0, which means right. + exceptions_ = std::ios_base::goodbit; + rdstate_ = std::ios_base::goodbit; + } + + +// --- format_item:: -------------------------------------------------------- + + template + void format_item:: + reset (Ch fill) { + argN_=argN_no_posit; truncate_ = max_streamsize(); pad_scheme_ =0; + res_.resize(0); appendix_.resize(0); + fmtstate_.reset(fill); + } + + template + void format_item:: + compute_states() { + // reflect pad_scheme_ on fmt_state_ + // because some pad_schemes has complex consequences on several state params. + if(pad_scheme_ & zeropad) { + // ignore zeropad in left alignment : + if(fmtstate_.flags_ & std::ios_base::left) { + BOOST_ASSERT(!(fmtstate_.flags_ &(std::ios_base::adjustfield ^std::ios_base::left))); + // only left bit might be set. (not right, nor internal) + pad_scheme_ = pad_scheme_ & (~zeropad); + } + else { + pad_scheme_ &= ~spacepad; // printf ignores spacepad when zeropadding + fmtstate_.fill_='0'; + fmtstate_.flags_ = (fmtstate_.flags_ & ~std::ios_base::adjustfield) + | std::ios_base::internal; + // removes all adjustfield bits, and adds internal. + } + } + if(pad_scheme_ & spacepad) { + if(fmtstate_.flags_ & std::ios_base::showpos) + pad_scheme_ &= ~spacepad; + } + } + + +} } } // namespaces boost :: io :: detail + + +#endif // BOOST_FORMAT_INTERNALS_HPP diff --git a/realsense-file/3rd_party/boost/boost/format/internals_fwd.hpp b/realsense-file/3rd_party/boost/boost/format/internals_fwd.hpp new file mode 100644 index 0000000000..9a65f92d77 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/format/internals_fwd.hpp @@ -0,0 +1,64 @@ +// ---------------------------------------------------------------------------- +// internals_fwd.hpp : forward declarations, for internal headers +// ---------------------------------------------------------------------------- + +// Copyright Samuel Krempp 2003. Use, modification, and distribution are +// subject to the Boost Software License, Version 1.0. (See accompanying +// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org/libs/format for library home page + +// ---------------------------------------------------------------------------- + +#ifndef BOOST_FORMAT_INTERNAL_FWD_HPP +#define BOOST_FORMAT_INTERNAL_FWD_HPP + +#include +#include + + +namespace boost { +namespace io { + +namespace detail { + template struct stream_format_state; + template struct format_item; + + + // these functions were intended as methods, + // but MSVC have problems with template member functions : + // defined in format_implementation.hpp : + template + basic_format& + modify_item_body (basic_format& self, + int itemN, T manipulator); + + template + basic_format& + bind_arg_body (basic_format& self, + int argN, const T& val); + + // in internals.hpp : + template + void apply_manip_body (stream_format_state& self, + T manipulator); + + // argument feeding (defined in feed_args.hpp ) : + template + void distribute (basic_format& self, T x); + + template + basic_format& + feed (basic_format& self, T x); + + template + basic_format& + feed_impl (basic_format& self, T x); + +} // namespace detail + +} // namespace io +} // namespace boost + + +#endif // BOOST_FORMAT_INTERNAL_FWD_HPP diff --git a/realsense-file/3rd_party/boost/boost/format/parsing.hpp b/realsense-file/3rd_party/boost/boost/format/parsing.hpp new file mode 100644 index 0000000000..b7854d3669 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/format/parsing.hpp @@ -0,0 +1,501 @@ +// ---------------------------------------------------------------------------- +// parsing.hpp : implementation of the parsing member functions +// ( parse, parse_printf_directive) +// ---------------------------------------------------------------------------- + +// Copyright Samuel Krempp 2003. Use, modification, and distribution are +// subject to the Boost Software License, Version 1.0. (See accompanying +// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// see http://www.boost.org/libs/format for library home page + +// ---------------------------------------------------------------------------- + +#ifndef BOOST_FORMAT_PARSING_HPP +#define BOOST_FORMAT_PARSING_HPP + + +#include +#include +#include +#include + + +namespace boost { +namespace io { +namespace detail { + +#if defined(BOOST_NO_STD_LOCALE) + // streams will be used for narrow / widen. but these methods are not const + template + T& const_or_not(const T& x) { + return const_cast (x); + } +#else + template + const T& const_or_not(const T& x) { + return x; + } +#endif + + template inline + char wrap_narrow(const Facet& fac, Ch c, char deflt) { + return const_or_not(fac).narrow(c, deflt); + } + + template inline + bool wrap_isdigit(const Facet& fac, Ch c) { +#if ! defined( BOOST_NO_LOCALE_ISDIGIT ) + return fac.is(std::ctype::digit, c); +# else + (void) fac; // remove "unused parameter" warning + using namespace std; + return isdigit(c); +#endif + } + + template + Iter wrap_scan_notdigit(const Facet & fac, Iter beg, Iter end) { + using namespace std; + for( ; beg!=end && wrap_isdigit(fac, *beg); ++beg) ; + return beg; + } + + + // Input : [start, last) iterators range and a + // a Facet to use its widen/narrow member function + // Effects : read sequence and convert digits into integral n, of type Res + // Returns : n + template + Iter str2int (const Iter & start, const Iter & last, Res & res, + const Facet& fac) + { + using namespace std; + Iter it; + res=0; + for(it=start; it != last && wrap_isdigit(fac, *it); ++it ) { + char cur_ch = wrap_narrow(fac, *it, 0); // cant fail. + res *= 10; + res += cur_ch - '0'; // 22.2.1.1.2.13 of the C++ standard + } + return it; + } + + // skip printf's "asterisk-fields" directives in the format-string buf + // Input : char string, with starting index *pos_p + // a Facet merely to use its widen/narrow member function + // Effects : advance *pos_p by skipping printf's asterisk fields. + // Returns : nothing + template + Iter skip_asterisk(Iter start, Iter last, const Facet& fac) + { + using namespace std; + ++ start; + start = wrap_scan_notdigit(fac, start, last); + if(start!=last && *start== const_or_not(fac).widen( '$') ) + ++start; + return start; + } + + + // auxiliary func called by parse_printf_directive + // for centralising error handling + // it either throws if user sets the corresponding flag, or does nothing. + inline void maybe_throw_exception(unsigned char exceptions, + std::size_t pos, std::size_t size) + { + if(exceptions & io::bad_format_string_bit) + boost::throw_exception(io::bad_format_string(pos, size) ); + } + + + // Input: the position of a printf-directive in the format-string + // a basic_ios& merely to use its widen/narrow member function + // a bitset'exceptions' telling whether to throw exceptions on errors. + // Returns: + // true if parse succeeded (ignore some errors if exceptions disabled) + // false if it failed so bad that the directive should be printed verbatim + // Effects: + // start is incremented so that *start is the first char after + // this directive + // *fpar is set with the parameters read in the directive + template + bool parse_printf_directive(Iter & start, const Iter& last, + detail::format_item * fpar, + const Facet& fac, + std::size_t offset, unsigned char exceptions) + { + typedef typename basic_format::format_item_t format_item_t; + + fpar->argN_ = format_item_t::argN_no_posit; // if no positional-directive + bool precision_set = false; + bool in_brackets=false; + Iter start0 = start; + std::size_t fstring_size = last-start0+offset; + + if(start>= last) { // empty directive : this is a trailing % + maybe_throw_exception(exceptions, start-start0 + offset, fstring_size); + return false; + } + + if(*start== const_or_not(fac).widen( '|')) { + in_brackets=true; + if( ++start >= last ) { + maybe_throw_exception(exceptions, start-start0 + offset, fstring_size); + return false; + } + } + + // the flag '0' would be picked as a digit for argument order, but here it's a flag : + if(*start== const_or_not(fac).widen( '0')) + goto parse_flags; + + // handle argument order (%2$d) or possibly width specification: %2d + if(wrap_isdigit(fac, *start)) { + int n; + start = str2int(start, last, n, fac); + if( start >= last ) { + maybe_throw_exception(exceptions, start-start0+offset, fstring_size); + return false; + } + + // %N% case : this is already the end of the directive + if( *start == const_or_not(fac).widen( '%') ) { + fpar->argN_ = n-1; + ++start; + if( in_brackets) + maybe_throw_exception(exceptions, start-start0+offset, fstring_size); + // but don't return. maybe "%" was used in lieu of '$', so we go on. + else + return true; + } + + if ( *start== const_or_not(fac).widen( '$') ) { + fpar->argN_ = n-1; + ++start; + } + else { + // non-positionnal directive + fpar->fmtstate_.width_ = n; + fpar->argN_ = format_item_t::argN_no_posit; + goto parse_precision; + } + } + + parse_flags: + // handle flags + while ( start != last) { // as long as char is one of + - = _ # 0 l h or ' ' + // misc switches + switch ( wrap_narrow(fac, *start, 0)) { + case '\'' : break; // no effect yet. (painful to implement) + case 'l': + case 'h': // short/long modifier : for printf-comaptibility (no action needed) + break; + case '-': + fpar->fmtstate_.flags_ |= std::ios_base::left; + break; + case '=': + fpar->pad_scheme_ |= format_item_t::centered; + break; + case '_': + fpar->fmtstate_.flags_ |= std::ios_base::internal; + break; + case ' ': + fpar->pad_scheme_ |= format_item_t::spacepad; + break; + case '+': + fpar->fmtstate_.flags_ |= std::ios_base::showpos; + break; + case '0': + fpar->pad_scheme_ |= format_item_t::zeropad; + // need to know alignment before really setting flags, + // so just add 'zeropad' flag for now, it will be processed later. + break; + case '#': + fpar->fmtstate_.flags_ |= std::ios_base::showpoint | std::ios_base::showbase; + break; + default: + goto parse_width; + } + ++start; + } // loop on flag. + + if( start>=last) { + maybe_throw_exception(exceptions, start-start0+offset, fstring_size); + return true; + } + parse_width: + // handle width spec + // first skip 'asterisk fields' : *, or *N$ + if(*start == const_or_not(fac).widen( '*') ) + start = skip_asterisk(start, last, fac); + if(start!=last && wrap_isdigit(fac, *start)) + start = str2int(start, last, fpar->fmtstate_.width_, fac); + + parse_precision: + if( start>= last) { + maybe_throw_exception(exceptions, start-start0+offset, fstring_size); + return true; + } + // handle precision spec + if (*start== const_or_not(fac).widen( '.')) { + ++start; + if(start != last && *start == const_or_not(fac).widen( '*') ) + start = skip_asterisk(start, last, fac); + if(start != last && wrap_isdigit(fac, *start)) { + start = str2int(start, last, fpar->fmtstate_.precision_, fac); + precision_set = true; + } + else + fpar->fmtstate_.precision_ =0; + } + + // handle formatting-type flags : + while( start != last && ( *start== const_or_not(fac).widen( 'l') + || *start== const_or_not(fac).widen( 'L') + || *start== const_or_not(fac).widen( 'h')) ) + ++start; + if( start>=last) { + maybe_throw_exception(exceptions, start-start0+offset, fstring_size); + return true; + } + + if( in_brackets && *start== const_or_not(fac).widen( '|') ) { + ++start; + return true; + } + switch ( wrap_narrow(fac, *start, 0) ) { + case 'X': + fpar->fmtstate_.flags_ |= std::ios_base::uppercase; + case 'p': // pointer => set hex. + case 'x': + fpar->fmtstate_.flags_ &= ~std::ios_base::basefield; + fpar->fmtstate_.flags_ |= std::ios_base::hex; + break; + + case 'o': + fpar->fmtstate_.flags_ &= ~std::ios_base::basefield; + fpar->fmtstate_.flags_ |= std::ios_base::oct; + break; + + case 'E': + fpar->fmtstate_.flags_ |= std::ios_base::uppercase; + case 'e': + fpar->fmtstate_.flags_ &= ~std::ios_base::floatfield; + fpar->fmtstate_.flags_ |= std::ios_base::scientific; + + fpar->fmtstate_.flags_ &= ~std::ios_base::basefield; + fpar->fmtstate_.flags_ |= std::ios_base::dec; + break; + + case 'f': + fpar->fmtstate_.flags_ &= ~std::ios_base::floatfield; + fpar->fmtstate_.flags_ |= std::ios_base::fixed; + case 'u': + case 'd': + case 'i': + fpar->fmtstate_.flags_ &= ~std::ios_base::basefield; + fpar->fmtstate_.flags_ |= std::ios_base::dec; + break; + + case 'T': + ++start; + if( start >= last) + maybe_throw_exception(exceptions, start-start0+offset, fstring_size); + else + fpar->fmtstate_.fill_ = *start; + fpar->pad_scheme_ |= format_item_t::tabulation; + fpar->argN_ = format_item_t::argN_tabulation; + break; + case 't': + fpar->fmtstate_.fill_ = const_or_not(fac).widen( ' '); + fpar->pad_scheme_ |= format_item_t::tabulation; + fpar->argN_ = format_item_t::argN_tabulation; + break; + + case 'G': + fpar->fmtstate_.flags_ |= std::ios_base::uppercase; + break; + case 'g': // 'g' conversion is default for floats. + fpar->fmtstate_.flags_ &= ~std::ios_base::basefield; + fpar->fmtstate_.flags_ |= std::ios_base::dec; + + // CLEAR all floatield flags, so stream will CHOOSE + fpar->fmtstate_.flags_ &= ~std::ios_base::floatfield; + break; + + case 'C': + case 'c': + fpar->truncate_ = 1; + break; + case 'S': + case 's': + if(precision_set) // handle truncation manually, with own parameter. + fpar->truncate_ = fpar->fmtstate_.precision_; + fpar->fmtstate_.precision_ = 6; // default stream precision. + break; + case 'n' : + fpar->argN_ = format_item_t::argN_ignored; + break; + default: + maybe_throw_exception(exceptions, start-start0+offset, fstring_size); + } + ++start; + + if( in_brackets ) { + if( start != last && *start== const_or_not(fac).widen( '|') ) { + ++start; + return true; + } + else maybe_throw_exception(exceptions, start-start0+offset, fstring_size); + } + return true; + } + // -end parse_printf_directive() + + template + int upper_bound_from_fstring(const String& buf, + const typename String::value_type arg_mark, + const Facet& fac, + unsigned char exceptions) + { + // quick-parsing of the format-string to count arguments mark (arg_mark, '%') + // returns : upper bound on the number of format items in the format strings + using namespace boost::io; + typename String::size_type i1=0; + int num_items=0; + while( (i1=buf.find(arg_mark,i1)) != String::npos ) { + if( i1+1 >= buf.size() ) { + if(exceptions & bad_format_string_bit) + boost::throw_exception(bad_format_string(i1, buf.size() )); // must not end in ".. %" + else { + ++num_items; + break; + } + } + if(buf[i1+1] == buf[i1] ) {// escaped "%%" + i1+=2; continue; + } + + ++i1; + // in case of %N% directives, dont count it double (wastes allocations..) : + i1 = detail::wrap_scan_notdigit(fac, buf.begin()+i1, buf.end()) - buf.begin(); + if( i1 < buf.size() && buf[i1] == arg_mark ) + ++i1; + ++num_items; + } + return num_items; + } + template inline + void append_string(String& dst, const String& src, + const typename String::size_type beg, + const typename String::size_type end) { + dst.append(src.begin()+beg, src.begin()+end); + } + +} // detail namespace +} // io namespace + + + +// ----------------------------------------------- +// format :: parse(..) + + template + basic_format& basic_format:: + parse (const string_type& buf) { + // parse the format-string + using namespace std; +#if !defined(BOOST_NO_STD_LOCALE) + const std::ctype & fac = BOOST_USE_FACET( std::ctype, getloc()); +#else + io::basic_oaltstringstream fac; + //has widen and narrow even on compilers without locale +#endif + + const Ch arg_mark = io::detail::const_or_not(fac).widen( '%'); + bool ordered_args=true; + int max_argN=-1; + + // A: find upper_bound on num_items and allocates arrays + int num_items = io::detail::upper_bound_from_fstring(buf, arg_mark, fac, exceptions()); + make_or_reuse_data(num_items); + + // B: Now the real parsing of the format string : + num_items=0; + typename string_type::size_type i0=0, i1=0; + typename string_type::const_iterator it; + bool special_things=false; + int cur_item=0; + while( (i1=buf.find(arg_mark,i1)) != string_type::npos ) { + string_type & piece = (cur_item==0) ? prefix_ : items_[cur_item-1].appendix_; + if( buf[i1+1] == buf[i1] ) { // escaped mark, '%%' + io::detail::append_string(piece, buf, i0, i1+1); + i1+=2; i0=i1; + continue; + } + BOOST_ASSERT( static_cast(cur_item) < items_.size() || cur_item==0); + + if(i1!=i0) { + io::detail::append_string(piece, buf, i0, i1); + i0=i1; + } + ++i1; + it = buf.begin()+i1; + bool parse_ok = io::detail::parse_printf_directive( + it, buf.end(), &items_[cur_item], fac, i1, exceptions()); + i1 = it - buf.begin(); + if( ! parse_ok ) // the directive will be printed verbatim + continue; + i0=i1; + items_[cur_item].compute_states(); // process complex options, like zeropad, into params + + int argN=items_[cur_item].argN_; + if(argN == format_item_t::argN_ignored) + continue; + if(argN ==format_item_t::argN_no_posit) + ordered_args=false; + else if(argN == format_item_t::argN_tabulation) special_things=true; + else if(argN > max_argN) max_argN = argN; + ++num_items; + ++cur_item; + } // loop on %'s + BOOST_ASSERT(cur_item == num_items); + + // store the final piece of string + { + string_type & piece = (cur_item==0) ? prefix_ : items_[cur_item-1].appendix_; + io::detail::append_string(piece, buf, i0, buf.size()); + } + + if( !ordered_args) { + if(max_argN >= 0 ) { // dont mix positional with non-positionnal directives + if(exceptions() & io::bad_format_string_bit) + boost::throw_exception( + io::bad_format_string(static_cast(max_argN), 0)); + // else do nothing. => positionnal arguments are processed as non-positionnal + } + // set things like it would have been with positional directives : + int non_ordered_items = 0; + for(int i=0; i< num_items; ++i) + if(items_[i].argN_ == format_item_t::argN_no_posit) { + items_[i].argN_ = non_ordered_items; + ++non_ordered_items; + } + max_argN = non_ordered_items-1; + } + + // C: set some member data : + items_.resize(num_items, format_item_t(io::detail::const_or_not(fac).widen( ' ')) ); + + if(special_things) style_ |= special_needs; + num_args_ = max_argN + 1; + if(ordered_args) style_ |= ordered; + else style_ &= ~ordered; + return *this; + } + +} // namespace boost + + +#endif // BOOST_FORMAT_PARSING_HPP diff --git a/realsense-file/3rd_party/boost/boost/function.hpp b/realsense-file/3rd_party/boost/boost/function.hpp new file mode 100644 index 0000000000..50bb11d98b --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/function.hpp @@ -0,0 +1,66 @@ +// Boost.Function library + +// Copyright Douglas Gregor 2001-2003. Use, modification and +// distribution is subject to 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) + +// For more information, see http://www.boost.org/libs/function + +// William Kempf, Jesse Jones and Karl Nelson were all very helpful in the +// design of this library. + +#include // unary_function, binary_function + +#include +#include + +#ifndef BOOST_FUNCTION_MAX_ARGS +# define BOOST_FUNCTION_MAX_ARGS 10 +#endif // BOOST_FUNCTION_MAX_ARGS + +// Include the prologue here so that the use of file-level iteration +// in anything that may be included by function_template.hpp doesn't break +#include "function/detail/prologue.hpp" + +// Older Visual Age C++ version do not handle the file iteration well +#if BOOST_WORKAROUND(__IBMCPP__, >= 500) && BOOST_WORKAROUND(__IBMCPP__, < 800) +# if BOOST_FUNCTION_MAX_ARGS >= 0 +# include +# endif +# if BOOST_FUNCTION_MAX_ARGS >= 1 +# include +# endif +# if BOOST_FUNCTION_MAX_ARGS >= 2 +# include +# endif +# if BOOST_FUNCTION_MAX_ARGS >= 3 +# include +# endif +# if BOOST_FUNCTION_MAX_ARGS >= 4 +# include +# endif +# if BOOST_FUNCTION_MAX_ARGS >= 5 +# include +# endif +# if BOOST_FUNCTION_MAX_ARGS >= 6 +# include +# endif +# if BOOST_FUNCTION_MAX_ARGS >= 7 +# include +# endif +# if BOOST_FUNCTION_MAX_ARGS >= 8 +# include +# endif +# if BOOST_FUNCTION_MAX_ARGS >= 9 +# include +# endif +# if BOOST_FUNCTION_MAX_ARGS >= 10 +# include +# endif +#else +// What is the '3' for? +# define BOOST_PP_ITERATION_PARAMS_1 (3,(0,BOOST_FUNCTION_MAX_ARGS,)) +# include BOOST_PP_ITERATE() +# undef BOOST_PP_ITERATION_PARAMS_1 +#endif diff --git a/realsense-file/3rd_party/boost/boost/function/detail/function_iterate.hpp b/realsense-file/3rd_party/boost/boost/function/detail/function_iterate.hpp new file mode 100644 index 0000000000..d068cb7ed5 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/function/detail/function_iterate.hpp @@ -0,0 +1,16 @@ +// Boost.Function library + +// Copyright Douglas Gregor 2003. Use, modification and +// distribution is subject to 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) + +// For more information, see http://www.boost.org +#if !defined(BOOST_PP_IS_ITERATING) +# error Boost.Function - do not include this file! +#endif + +#define BOOST_FUNCTION_NUM_ARGS BOOST_PP_ITERATION() +#include +#undef BOOST_FUNCTION_NUM_ARGS + diff --git a/realsense-file/3rd_party/boost/boost/function/detail/gen_maybe_include.pl b/realsense-file/3rd_party/boost/boost/function/detail/gen_maybe_include.pl new file mode 100644 index 0000000000..1bfaab780f --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/function/detail/gen_maybe_include.pl @@ -0,0 +1,37 @@ +#!/usr/bin/perl -w +# +# Boost.Function library +# +# Copyright (C) 2001-2003 Douglas Gregor (gregod@cs.rpi.edu) +# +# Permission to copy, use, sell and distribute this software is granted +# provided this copyright notice appears in all copies. +# Permission to modify the code and to distribute modified code is granted +# provided this copyright notice appears in all copies, and a notice +# that the code was modified is included with the copyright notice. +# +# This software is provided "as is" without express or implied warranty, +# and with no claim as to its suitability for any purpose. +# +# For more information, see http://www.boost.org +use English; + +$max_args = $ARGV[0]; + +open (OUT, ">maybe_include.hpp") or die("Cannot write to maybe_include.hpp"); +for($on_arg = 0; $on_arg <= $max_args; ++$on_arg) { + if ($on_arg == 0) { + print OUT "#if"; + } + else { + print OUT "#elif"; + } + print OUT " BOOST_FUNCTION_NUM_ARGS == $on_arg\n"; + print OUT "# ifndef BOOST_FUNCTION_$on_arg\n"; + print OUT "# define BOOST_FUNCTION_$on_arg\n"; + print OUT "# include \n"; + print OUT "# endif\n"; +} +print OUT "#else\n"; +print OUT "# error Cannot handle Boost.Function objects that accept more than $max_args arguments!\n"; +print OUT "#endif\n"; diff --git a/realsense-file/3rd_party/boost/boost/function/detail/maybe_include.hpp b/realsense-file/3rd_party/boost/boost/function/detail/maybe_include.hpp new file mode 100644 index 0000000000..10beac8df1 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/function/detail/maybe_include.hpp @@ -0,0 +1,267 @@ +// Boost.Function library + +// Copyright Douglas Gregor 2003. Use, modification and +// distribution is subject to 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) + +// For more information, see http://www.boost.org + +#if BOOST_FUNCTION_NUM_ARGS == 0 +# ifndef BOOST_FUNCTION_0 +# define BOOST_FUNCTION_0 +# include +# endif +#elif BOOST_FUNCTION_NUM_ARGS == 1 +# ifndef BOOST_FUNCTION_1 +# define BOOST_FUNCTION_1 +# include +# endif +#elif BOOST_FUNCTION_NUM_ARGS == 2 +# ifndef BOOST_FUNCTION_2 +# define BOOST_FUNCTION_2 +# include +# endif +#elif BOOST_FUNCTION_NUM_ARGS == 3 +# ifndef BOOST_FUNCTION_3 +# define BOOST_FUNCTION_3 +# include +# endif +#elif BOOST_FUNCTION_NUM_ARGS == 4 +# ifndef BOOST_FUNCTION_4 +# define BOOST_FUNCTION_4 +# include +# endif +#elif BOOST_FUNCTION_NUM_ARGS == 5 +# ifndef BOOST_FUNCTION_5 +# define BOOST_FUNCTION_5 +# include +# endif +#elif BOOST_FUNCTION_NUM_ARGS == 6 +# ifndef BOOST_FUNCTION_6 +# define BOOST_FUNCTION_6 +# include +# endif +#elif BOOST_FUNCTION_NUM_ARGS == 7 +# ifndef BOOST_FUNCTION_7 +# define BOOST_FUNCTION_7 +# include +# endif +#elif BOOST_FUNCTION_NUM_ARGS == 8 +# ifndef BOOST_FUNCTION_8 +# define BOOST_FUNCTION_8 +# include +# endif +#elif BOOST_FUNCTION_NUM_ARGS == 9 +# ifndef BOOST_FUNCTION_9 +# define BOOST_FUNCTION_9 +# include +# endif +#elif BOOST_FUNCTION_NUM_ARGS == 10 +# ifndef BOOST_FUNCTION_10 +# define BOOST_FUNCTION_10 +# include +# endif +#elif BOOST_FUNCTION_NUM_ARGS == 11 +# ifndef BOOST_FUNCTION_11 +# define BOOST_FUNCTION_11 +# include +# endif +#elif BOOST_FUNCTION_NUM_ARGS == 12 +# ifndef BOOST_FUNCTION_12 +# define BOOST_FUNCTION_12 +# include +# endif +#elif BOOST_FUNCTION_NUM_ARGS == 13 +# ifndef BOOST_FUNCTION_13 +# define BOOST_FUNCTION_13 +# include +# endif +#elif BOOST_FUNCTION_NUM_ARGS == 14 +# ifndef BOOST_FUNCTION_14 +# define BOOST_FUNCTION_14 +# include +# endif +#elif BOOST_FUNCTION_NUM_ARGS == 15 +# ifndef BOOST_FUNCTION_15 +# define BOOST_FUNCTION_15 +# include +# endif +#elif BOOST_FUNCTION_NUM_ARGS == 16 +# ifndef BOOST_FUNCTION_16 +# define BOOST_FUNCTION_16 +# include +# endif +#elif BOOST_FUNCTION_NUM_ARGS == 17 +# ifndef BOOST_FUNCTION_17 +# define BOOST_FUNCTION_17 +# include +# endif +#elif BOOST_FUNCTION_NUM_ARGS == 18 +# ifndef BOOST_FUNCTION_18 +# define BOOST_FUNCTION_18 +# include +# endif +#elif BOOST_FUNCTION_NUM_ARGS == 19 +# ifndef BOOST_FUNCTION_19 +# define BOOST_FUNCTION_19 +# include +# endif +#elif BOOST_FUNCTION_NUM_ARGS == 20 +# ifndef BOOST_FUNCTION_20 +# define BOOST_FUNCTION_20 +# include +# endif +#elif BOOST_FUNCTION_NUM_ARGS == 21 +# ifndef BOOST_FUNCTION_21 +# define BOOST_FUNCTION_21 +# include +# endif +#elif BOOST_FUNCTION_NUM_ARGS == 22 +# ifndef BOOST_FUNCTION_22 +# define BOOST_FUNCTION_22 +# include +# endif +#elif BOOST_FUNCTION_NUM_ARGS == 23 +# ifndef BOOST_FUNCTION_23 +# define BOOST_FUNCTION_23 +# include +# endif +#elif BOOST_FUNCTION_NUM_ARGS == 24 +# ifndef BOOST_FUNCTION_24 +# define BOOST_FUNCTION_24 +# include +# endif +#elif BOOST_FUNCTION_NUM_ARGS == 25 +# ifndef BOOST_FUNCTION_25 +# define BOOST_FUNCTION_25 +# include +# endif +#elif BOOST_FUNCTION_NUM_ARGS == 26 +# ifndef BOOST_FUNCTION_26 +# define BOOST_FUNCTION_26 +# include +# endif +#elif BOOST_FUNCTION_NUM_ARGS == 27 +# ifndef BOOST_FUNCTION_27 +# define BOOST_FUNCTION_27 +# include +# endif +#elif BOOST_FUNCTION_NUM_ARGS == 28 +# ifndef BOOST_FUNCTION_28 +# define BOOST_FUNCTION_28 +# include +# endif +#elif BOOST_FUNCTION_NUM_ARGS == 29 +# ifndef BOOST_FUNCTION_29 +# define BOOST_FUNCTION_29 +# include +# endif +#elif BOOST_FUNCTION_NUM_ARGS == 30 +# ifndef BOOST_FUNCTION_30 +# define BOOST_FUNCTION_30 +# include +# endif +#elif BOOST_FUNCTION_NUM_ARGS == 31 +# ifndef BOOST_FUNCTION_31 +# define BOOST_FUNCTION_31 +# include +# endif +#elif BOOST_FUNCTION_NUM_ARGS == 32 +# ifndef BOOST_FUNCTION_32 +# define BOOST_FUNCTION_32 +# include +# endif +#elif BOOST_FUNCTION_NUM_ARGS == 33 +# ifndef BOOST_FUNCTION_33 +# define BOOST_FUNCTION_33 +# include +# endif +#elif BOOST_FUNCTION_NUM_ARGS == 34 +# ifndef BOOST_FUNCTION_34 +# define BOOST_FUNCTION_34 +# include +# endif +#elif BOOST_FUNCTION_NUM_ARGS == 35 +# ifndef BOOST_FUNCTION_35 +# define BOOST_FUNCTION_35 +# include +# endif +#elif BOOST_FUNCTION_NUM_ARGS == 36 +# ifndef BOOST_FUNCTION_36 +# define BOOST_FUNCTION_36 +# include +# endif +#elif BOOST_FUNCTION_NUM_ARGS == 37 +# ifndef BOOST_FUNCTION_37 +# define BOOST_FUNCTION_37 +# include +# endif +#elif BOOST_FUNCTION_NUM_ARGS == 38 +# ifndef BOOST_FUNCTION_38 +# define BOOST_FUNCTION_38 +# include +# endif +#elif BOOST_FUNCTION_NUM_ARGS == 39 +# ifndef BOOST_FUNCTION_39 +# define BOOST_FUNCTION_39 +# include +# endif +#elif BOOST_FUNCTION_NUM_ARGS == 40 +# ifndef BOOST_FUNCTION_40 +# define BOOST_FUNCTION_40 +# include +# endif +#elif BOOST_FUNCTION_NUM_ARGS == 41 +# ifndef BOOST_FUNCTION_41 +# define BOOST_FUNCTION_41 +# include +# endif +#elif BOOST_FUNCTION_NUM_ARGS == 42 +# ifndef BOOST_FUNCTION_42 +# define BOOST_FUNCTION_42 +# include +# endif +#elif BOOST_FUNCTION_NUM_ARGS == 43 +# ifndef BOOST_FUNCTION_43 +# define BOOST_FUNCTION_43 +# include +# endif +#elif BOOST_FUNCTION_NUM_ARGS == 44 +# ifndef BOOST_FUNCTION_44 +# define BOOST_FUNCTION_44 +# include +# endif +#elif BOOST_FUNCTION_NUM_ARGS == 45 +# ifndef BOOST_FUNCTION_45 +# define BOOST_FUNCTION_45 +# include +# endif +#elif BOOST_FUNCTION_NUM_ARGS == 46 +# ifndef BOOST_FUNCTION_46 +# define BOOST_FUNCTION_46 +# include +# endif +#elif BOOST_FUNCTION_NUM_ARGS == 47 +# ifndef BOOST_FUNCTION_47 +# define BOOST_FUNCTION_47 +# include +# endif +#elif BOOST_FUNCTION_NUM_ARGS == 48 +# ifndef BOOST_FUNCTION_48 +# define BOOST_FUNCTION_48 +# include +# endif +#elif BOOST_FUNCTION_NUM_ARGS == 49 +# ifndef BOOST_FUNCTION_49 +# define BOOST_FUNCTION_49 +# include +# endif +#elif BOOST_FUNCTION_NUM_ARGS == 50 +# ifndef BOOST_FUNCTION_50 +# define BOOST_FUNCTION_50 +# include +# endif +#else +# error Cannot handle Boost.Function objects that accept more than 50 arguments! +#endif diff --git a/realsense-file/3rd_party/boost/boost/function/detail/prologue.hpp b/realsense-file/3rd_party/boost/boost/function/detail/prologue.hpp new file mode 100644 index 0000000000..612a96837a --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/function/detail/prologue.hpp @@ -0,0 +1,26 @@ +// Boost.Function library + +// Copyright Douglas Gregor 2002-2003. Use, modification and +// distribution is subject to 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) + +// For more information, see http://www.boost.org + +#ifndef BOOST_FUNCTION_PROLOGUE_HPP +#define BOOST_FUNCTION_PROLOGUE_HPP +# include +# include +# include // unary_function, binary_function +# include +# include +# include +//# include +# include +# include +# include +# include +# include +# include +# include +#endif // BOOST_FUNCTION_PROLOGUE_HPP diff --git a/realsense-file/3rd_party/boost/boost/function/function_base.hpp b/realsense-file/3rd_party/boost/boost/function/function_base.hpp new file mode 100644 index 0000000000..d5d9ef54cc --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/function/function_base.hpp @@ -0,0 +1,902 @@ +// Boost.Function library + +// Copyright Douglas Gregor 2001-2006 +// Copyright Emil Dotchevski 2007 +// Use, modification and distribution is subject to 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) + +// For more information, see http://www.boost.org + +#ifndef BOOST_FUNCTION_BASE_HEADER +#define BOOST_FUNCTION_BASE_HEADER + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#ifndef BOOST_NO_SFINAE +# include "boost/utility/enable_if.hpp" +#else +# include "boost/mpl/bool.hpp" +#endif +#include +#include + +#if defined(BOOST_MSVC) +# pragma warning( push ) +# pragma warning( disable : 4793 ) // complaint about native code generation +# pragma warning( disable : 4127 ) // "conditional expression is constant" +#endif + +// Define BOOST_FUNCTION_STD_NS to the namespace that contains type_info. +#ifdef BOOST_NO_STD_TYPEINFO +// Embedded VC++ does not have type_info in namespace std +# define BOOST_FUNCTION_STD_NS +#else +# define BOOST_FUNCTION_STD_NS std +#endif + +// Borrowed from Boost.Python library: determines the cases where we +// need to use std::type_info::name to compare instead of operator==. +#if defined( BOOST_NO_TYPEID ) +# define BOOST_FUNCTION_COMPARE_TYPE_ID(X,Y) ((X)==(Y)) +#elif defined(__GNUC__) \ + || defined(_AIX) \ + || ( defined(__sgi) && defined(__host_mips)) +# include +# define BOOST_FUNCTION_COMPARE_TYPE_ID(X,Y) \ + (std::strcmp((X).name(),(Y).name()) == 0) +# else +# define BOOST_FUNCTION_COMPARE_TYPE_ID(X,Y) ((X)==(Y)) +#endif + +#if defined(__ICL) && __ICL <= 600 || defined(__MWERKS__) && __MWERKS__ < 0x2406 && !defined(BOOST_STRICT_CONFIG) +# define BOOST_FUNCTION_TARGET_FIX(x) x +#else +# define BOOST_FUNCTION_TARGET_FIX(x) +#endif // __ICL etc + +#if !BOOST_WORKAROUND(__BORLANDC__, < 0x5A0) +# define BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor,Type) \ + typename ::boost::enable_if_c<(::boost::type_traits::ice_not< \ + (::boost::is_integral::value)>::value), \ + Type>::type +#else +// BCC doesn't recognize this depends on a template argument and complains +// about the use of 'typename' +# define BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor,Type) \ + ::boost::enable_if_c<(::boost::type_traits::ice_not< \ + (::boost::is_integral::value)>::value), \ + Type>::type +#endif + +namespace boost { + namespace detail { + namespace function { + class X; + + /** + * A buffer used to store small function objects in + * boost::function. It is a union containing function pointers, + * object pointers, and a structure that resembles a bound + * member function pointer. + */ + union function_buffer + { + // For pointers to function objects + mutable void* obj_ptr; + + // For pointers to std::type_info objects + struct type_t { + // (get_functor_type_tag, check_functor_type_tag). + const detail::sp_typeinfo* type; + + // Whether the type is const-qualified. + bool const_qualified; + // Whether the type is volatile-qualified. + bool volatile_qualified; + } type; + + // For function pointers of all kinds + mutable void (*func_ptr)(); + + // For bound member pointers + struct bound_memfunc_ptr_t { + void (X::*memfunc_ptr)(int); + void* obj_ptr; + } bound_memfunc_ptr; + + // For references to function objects. We explicitly keep + // track of the cv-qualifiers on the object referenced. + struct obj_ref_t { + mutable void* obj_ptr; + bool is_const_qualified; + bool is_volatile_qualified; + } obj_ref; + + // To relax aliasing constraints + mutable char data; + }; + + /** + * The unusable class is a placeholder for unused function arguments + * It is also completely unusable except that it constructable from + * anything. This helps compilers without partial specialization to + * handle Boost.Function objects returning void. + */ + struct unusable + { + unusable() {} + template unusable(const T&) {} + }; + + /* Determine the return type. This supports compilers that do not support + * void returns or partial specialization by silently changing the return + * type to "unusable". + */ + template struct function_return_type { typedef T type; }; + + template<> + struct function_return_type + { + typedef unusable type; + }; + + // The operation type to perform on the given functor/function pointer + enum functor_manager_operation_type { + clone_functor_tag, + move_functor_tag, + destroy_functor_tag, + check_functor_type_tag, + get_functor_type_tag + }; + + // Tags used to decide between different types of functions + struct function_ptr_tag {}; + struct function_obj_tag {}; + struct member_ptr_tag {}; + struct function_obj_ref_tag {}; + + template + class get_function_tag + { + typedef typename mpl::if_c<(is_pointer::value), + function_ptr_tag, + function_obj_tag>::type ptr_or_obj_tag; + + typedef typename mpl::if_c<(is_member_pointer::value), + member_ptr_tag, + ptr_or_obj_tag>::type ptr_or_obj_or_mem_tag; + + typedef typename mpl::if_c<(is_reference_wrapper::value), + function_obj_ref_tag, + ptr_or_obj_or_mem_tag>::type or_ref_tag; + + public: + typedef or_ref_tag type; + }; + + // The trivial manager does nothing but return the same pointer (if we + // are cloning) or return the null pointer (if we are deleting). + template + struct reference_manager + { + static inline void + manage(const function_buffer& in_buffer, function_buffer& out_buffer, + functor_manager_operation_type op) + { + switch (op) { + case clone_functor_tag: + out_buffer.obj_ref = in_buffer.obj_ref; + return; + + case move_functor_tag: + out_buffer.obj_ref = in_buffer.obj_ref; + in_buffer.obj_ref.obj_ptr = 0; + return; + + case destroy_functor_tag: + out_buffer.obj_ref.obj_ptr = 0; + return; + + case check_functor_type_tag: + { + const detail::sp_typeinfo& check_type + = *out_buffer.type.type; + + // Check whether we have the same type. We can add + // cv-qualifiers, but we can't take them away. + if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, BOOST_SP_TYPEID(F)) + && (!in_buffer.obj_ref.is_const_qualified + || out_buffer.type.const_qualified) + && (!in_buffer.obj_ref.is_volatile_qualified + || out_buffer.type.volatile_qualified)) + out_buffer.obj_ptr = in_buffer.obj_ref.obj_ptr; + else + out_buffer.obj_ptr = 0; + } + return; + + case get_functor_type_tag: + out_buffer.type.type = &BOOST_SP_TYPEID(F); + out_buffer.type.const_qualified = in_buffer.obj_ref.is_const_qualified; + out_buffer.type.volatile_qualified = in_buffer.obj_ref.is_volatile_qualified; + return; + } + } + }; + + /** + * Determine if boost::function can use the small-object + * optimization with the function object type F. + */ + template + struct function_allows_small_object_optimization + { + BOOST_STATIC_CONSTANT + (bool, + value = ((sizeof(F) <= sizeof(function_buffer) && + (alignment_of::value + % alignment_of::value == 0)))); + }; + + template + struct functor_wrapper: public F, public A + { + functor_wrapper( F f, A a ): + F(f), + A(a) + { + } + + functor_wrapper(const functor_wrapper& f) : + F(static_cast(f)), + A(static_cast(f)) + { + } + }; + + /** + * The functor_manager class contains a static function "manage" which + * can clone or destroy the given function/function object pointer. + */ + template + struct functor_manager_common + { + typedef Functor functor_type; + + // Function pointers + static inline void + manage_ptr(const function_buffer& in_buffer, function_buffer& out_buffer, + functor_manager_operation_type op) + { + if (op == clone_functor_tag) + out_buffer.func_ptr = in_buffer.func_ptr; + else if (op == move_functor_tag) { + out_buffer.func_ptr = in_buffer.func_ptr; + in_buffer.func_ptr = 0; + } else if (op == destroy_functor_tag) + out_buffer.func_ptr = 0; + else if (op == check_functor_type_tag) { + const boost::detail::sp_typeinfo& check_type + = *out_buffer.type.type; + if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, BOOST_SP_TYPEID(Functor))) + out_buffer.obj_ptr = &in_buffer.func_ptr; + else + out_buffer.obj_ptr = 0; + } else /* op == get_functor_type_tag */ { + out_buffer.type.type = &BOOST_SP_TYPEID(Functor); + out_buffer.type.const_qualified = false; + out_buffer.type.volatile_qualified = false; + } + } + + // Function objects that fit in the small-object buffer. + static inline void + manage_small(const function_buffer& in_buffer, function_buffer& out_buffer, + functor_manager_operation_type op) + { + if (op == clone_functor_tag || op == move_functor_tag) { + const functor_type* in_functor = + reinterpret_cast(&in_buffer.data); + new (reinterpret_cast(&out_buffer.data)) functor_type(*in_functor); + + if (op == move_functor_tag) { + functor_type* f = reinterpret_cast(&in_buffer.data); + (void)f; // suppress warning about the value of f not being used (MSVC) + f->~Functor(); + } + } else if (op == destroy_functor_tag) { + // Some compilers (Borland, vc6, ...) are unhappy with ~functor_type. + functor_type* f = reinterpret_cast(&out_buffer.data); + (void)f; // suppress warning about the value of f not being used (MSVC) + f->~Functor(); + } else if (op == check_functor_type_tag) { + const detail::sp_typeinfo& check_type + = *out_buffer.type.type; + if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, BOOST_SP_TYPEID(Functor))) + out_buffer.obj_ptr = &in_buffer.data; + else + out_buffer.obj_ptr = 0; + } else /* op == get_functor_type_tag */ { + out_buffer.type.type = &BOOST_SP_TYPEID(Functor); + out_buffer.type.const_qualified = false; + out_buffer.type.volatile_qualified = false; + } + } + }; + + template + struct functor_manager + { + private: + typedef Functor functor_type; + + // Function pointers + static inline void + manager(const function_buffer& in_buffer, function_buffer& out_buffer, + functor_manager_operation_type op, function_ptr_tag) + { + functor_manager_common::manage_ptr(in_buffer,out_buffer,op); + } + + // Function objects that fit in the small-object buffer. + static inline void + manager(const function_buffer& in_buffer, function_buffer& out_buffer, + functor_manager_operation_type op, mpl::true_) + { + functor_manager_common::manage_small(in_buffer,out_buffer,op); + } + + // Function objects that require heap allocation + static inline void + manager(const function_buffer& in_buffer, function_buffer& out_buffer, + functor_manager_operation_type op, mpl::false_) + { + if (op == clone_functor_tag) { + // Clone the functor + // GCC 2.95.3 gets the CV qualifiers wrong here, so we + // can't do the static_cast that we should do. + // jewillco: Changing this to static_cast because GCC 2.95.3 is + // obsolete. + const functor_type* f = + static_cast(in_buffer.obj_ptr); + functor_type* new_f = new functor_type(*f); + out_buffer.obj_ptr = new_f; + } else if (op == move_functor_tag) { + out_buffer.obj_ptr = in_buffer.obj_ptr; + in_buffer.obj_ptr = 0; + } else if (op == destroy_functor_tag) { + /* Cast from the void pointer to the functor pointer type */ + functor_type* f = + static_cast(out_buffer.obj_ptr); + delete f; + out_buffer.obj_ptr = 0; + } else if (op == check_functor_type_tag) { + const detail::sp_typeinfo& check_type + = *out_buffer.type.type; + if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, BOOST_SP_TYPEID(Functor))) + out_buffer.obj_ptr = in_buffer.obj_ptr; + else + out_buffer.obj_ptr = 0; + } else /* op == get_functor_type_tag */ { + out_buffer.type.type = &BOOST_SP_TYPEID(Functor); + out_buffer.type.const_qualified = false; + out_buffer.type.volatile_qualified = false; + } + } + + // For function objects, we determine whether the function + // object can use the small-object optimization buffer or + // whether we need to allocate it on the heap. + static inline void + manager(const function_buffer& in_buffer, function_buffer& out_buffer, + functor_manager_operation_type op, function_obj_tag) + { + manager(in_buffer, out_buffer, op, + mpl::bool_<(function_allows_small_object_optimization::value)>()); + } + + // For member pointers, we use the small-object optimization buffer. + static inline void + manager(const function_buffer& in_buffer, function_buffer& out_buffer, + functor_manager_operation_type op, member_ptr_tag) + { + manager(in_buffer, out_buffer, op, mpl::true_()); + } + + public: + /* Dispatch to an appropriate manager based on whether we have a + function pointer or a function object pointer. */ + static inline void + manage(const function_buffer& in_buffer, function_buffer& out_buffer, + functor_manager_operation_type op) + { + typedef typename get_function_tag::type tag_type; + switch (op) { + case get_functor_type_tag: + out_buffer.type.type = &BOOST_SP_TYPEID(functor_type); + out_buffer.type.const_qualified = false; + out_buffer.type.volatile_qualified = false; + return; + + default: + manager(in_buffer, out_buffer, op, tag_type()); + return; + } + } + }; + + template + struct functor_manager_a + { + private: + typedef Functor functor_type; + + // Function pointers + static inline void + manager(const function_buffer& in_buffer, function_buffer& out_buffer, + functor_manager_operation_type op, function_ptr_tag) + { + functor_manager_common::manage_ptr(in_buffer,out_buffer,op); + } + + // Function objects that fit in the small-object buffer. + static inline void + manager(const function_buffer& in_buffer, function_buffer& out_buffer, + functor_manager_operation_type op, mpl::true_) + { + functor_manager_common::manage_small(in_buffer,out_buffer,op); + } + + // Function objects that require heap allocation + static inline void + manager(const function_buffer& in_buffer, function_buffer& out_buffer, + functor_manager_operation_type op, mpl::false_) + { + typedef functor_wrapper functor_wrapper_type; + typedef typename Allocator::template rebind::other + wrapper_allocator_type; + typedef typename wrapper_allocator_type::pointer wrapper_allocator_pointer_type; + + if (op == clone_functor_tag) { + // Clone the functor + // GCC 2.95.3 gets the CV qualifiers wrong here, so we + // can't do the static_cast that we should do. + const functor_wrapper_type* f = + static_cast(in_buffer.obj_ptr); + wrapper_allocator_type wrapper_allocator(static_cast(*f)); + wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1); + wrapper_allocator.construct(copy, *f); + + // Get back to the original pointer type + functor_wrapper_type* new_f = static_cast(copy); + out_buffer.obj_ptr = new_f; + } else if (op == move_functor_tag) { + out_buffer.obj_ptr = in_buffer.obj_ptr; + in_buffer.obj_ptr = 0; + } else if (op == destroy_functor_tag) { + /* Cast from the void pointer to the functor_wrapper_type */ + functor_wrapper_type* victim = + static_cast(in_buffer.obj_ptr); + wrapper_allocator_type wrapper_allocator(static_cast(*victim)); + wrapper_allocator.destroy(victim); + wrapper_allocator.deallocate(victim,1); + out_buffer.obj_ptr = 0; + } else if (op == check_functor_type_tag) { + const detail::sp_typeinfo& check_type + = *out_buffer.type.type; + if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, BOOST_SP_TYPEID(Functor))) + out_buffer.obj_ptr = in_buffer.obj_ptr; + else + out_buffer.obj_ptr = 0; + } else /* op == get_functor_type_tag */ { + out_buffer.type.type = &BOOST_SP_TYPEID(Functor); + out_buffer.type.const_qualified = false; + out_buffer.type.volatile_qualified = false; + } + } + + // For function objects, we determine whether the function + // object can use the small-object optimization buffer or + // whether we need to allocate it on the heap. + static inline void + manager(const function_buffer& in_buffer, function_buffer& out_buffer, + functor_manager_operation_type op, function_obj_tag) + { + manager(in_buffer, out_buffer, op, + mpl::bool_<(function_allows_small_object_optimization::value)>()); + } + + public: + /* Dispatch to an appropriate manager based on whether we have a + function pointer or a function object pointer. */ + static inline void + manage(const function_buffer& in_buffer, function_buffer& out_buffer, + functor_manager_operation_type op) + { + typedef typename get_function_tag::type tag_type; + switch (op) { + case get_functor_type_tag: + out_buffer.type.type = &BOOST_SP_TYPEID(functor_type); + out_buffer.type.const_qualified = false; + out_buffer.type.volatile_qualified = false; + return; + + default: + manager(in_buffer, out_buffer, op, tag_type()); + return; + } + } + }; + + // A type that is only used for comparisons against zero + struct useless_clear_type {}; + +#ifdef BOOST_NO_SFINAE + // These routines perform comparisons between a Boost.Function + // object and an arbitrary function object (when the last + // parameter is mpl::bool_) or against zero (when the + // last parameter is mpl::bool_). They are only necessary + // for compilers that don't support SFINAE. + template + bool + compare_equal(const Function& f, const Functor&, int, mpl::bool_) + { return f.empty(); } + + template + bool + compare_not_equal(const Function& f, const Functor&, int, + mpl::bool_) + { return !f.empty(); } + + template + bool + compare_equal(const Function& f, const Functor& g, long, + mpl::bool_) + { + if (const Functor* fp = f.template target()) + return function_equal(*fp, g); + else return false; + } + + template + bool + compare_equal(const Function& f, const reference_wrapper& g, + int, mpl::bool_) + { + if (const Functor* fp = f.template target()) + return fp == g.get_pointer(); + else return false; + } + + template + bool + compare_not_equal(const Function& f, const Functor& g, long, + mpl::bool_) + { + if (const Functor* fp = f.template target()) + return !function_equal(*fp, g); + else return true; + } + + template + bool + compare_not_equal(const Function& f, + const reference_wrapper& g, int, + mpl::bool_) + { + if (const Functor* fp = f.template target()) + return fp != g.get_pointer(); + else return true; + } +#endif // BOOST_NO_SFINAE + + /** + * Stores the "manager" portion of the vtable for a + * boost::function object. + */ + struct vtable_base + { + void (*manager)(const function_buffer& in_buffer, + function_buffer& out_buffer, + functor_manager_operation_type op); + }; + } // end namespace function + } // end namespace detail + +/** + * The function_base class contains the basic elements needed for the + * function1, function2, function3, etc. classes. It is common to all + * functions (and as such can be used to tell if we have one of the + * functionN objects). + */ +class function_base +{ +public: + function_base() : vtable(0) { } + + /** Determine if the function is empty (i.e., has no target). */ + bool empty() const { return !vtable; } + + /** Retrieve the type of the stored function object, or BOOST_SP_TYPEID(void) + if this is empty. */ + const detail::sp_typeinfo& target_type() const + { + if (!vtable) return BOOST_SP_TYPEID(void); + + detail::function::function_buffer type; + get_vtable()->manager(functor, type, detail::function::get_functor_type_tag); + return *type.type.type; + } + + template + Functor* target() + { + if (!vtable) return 0; + + detail::function::function_buffer type_result; + type_result.type.type = &BOOST_SP_TYPEID(Functor); + type_result.type.const_qualified = is_const::value; + type_result.type.volatile_qualified = is_volatile::value; + get_vtable()->manager(functor, type_result, + detail::function::check_functor_type_tag); + return static_cast(type_result.obj_ptr); + } + + template + const Functor* target() const + { + if (!vtable) return 0; + + detail::function::function_buffer type_result; + type_result.type.type = &BOOST_SP_TYPEID(Functor); + type_result.type.const_qualified = true; + type_result.type.volatile_qualified = is_volatile::value; + get_vtable()->manager(functor, type_result, + detail::function::check_functor_type_tag); + // GCC 2.95.3 gets the CV qualifiers wrong here, so we + // can't do the static_cast that we should do. + return static_cast(type_result.obj_ptr); + } + + template + bool contains(const F& f) const + { + if (const F* fp = this->template target()) + { + return function_equal(*fp, f); + } else { + return false; + } + } + +#if defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3 + // GCC 3.3 and newer cannot copy with the global operator==, due to + // problems with instantiation of function return types before it + // has been verified that the argument types match up. + template + BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool) + operator==(Functor g) const + { + if (const Functor* fp = target()) + return function_equal(*fp, g); + else return false; + } + + template + BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool) + operator!=(Functor g) const + { + if (const Functor* fp = target()) + return !function_equal(*fp, g); + else return true; + } +#endif + +public: // should be protected, but GCC 2.95.3 will fail to allow access + detail::function::vtable_base* get_vtable() const { + return reinterpret_cast( + reinterpret_cast(vtable) & ~static_cast(0x01)); + } + + bool has_trivial_copy_and_destroy() const { + return reinterpret_cast(vtable) & 0x01; + } + + detail::function::vtable_base* vtable; + mutable detail::function::function_buffer functor; +}; + +/** + * The bad_function_call exception class is thrown when a boost::function + * object is invoked + */ +class bad_function_call : public std::runtime_error +{ +public: + bad_function_call() : std::runtime_error("call to empty boost::function") {} +}; + +#ifndef BOOST_NO_SFINAE +inline bool operator==(const function_base& f, + detail::function::useless_clear_type*) +{ + return f.empty(); +} + +inline bool operator!=(const function_base& f, + detail::function::useless_clear_type*) +{ + return !f.empty(); +} + +inline bool operator==(detail::function::useless_clear_type*, + const function_base& f) +{ + return f.empty(); +} + +inline bool operator!=(detail::function::useless_clear_type*, + const function_base& f) +{ + return !f.empty(); +} +#endif + +#ifdef BOOST_NO_SFINAE +// Comparisons between boost::function objects and arbitrary function objects +template + inline bool operator==(const function_base& f, Functor g) + { + typedef mpl::bool_<(is_integral::value)> integral; + return detail::function::compare_equal(f, g, 0, integral()); + } + +template + inline bool operator==(Functor g, const function_base& f) + { + typedef mpl::bool_<(is_integral::value)> integral; + return detail::function::compare_equal(f, g, 0, integral()); + } + +template + inline bool operator!=(const function_base& f, Functor g) + { + typedef mpl::bool_<(is_integral::value)> integral; + return detail::function::compare_not_equal(f, g, 0, integral()); + } + +template + inline bool operator!=(Functor g, const function_base& f) + { + typedef mpl::bool_<(is_integral::value)> integral; + return detail::function::compare_not_equal(f, g, 0, integral()); + } +#else + +# if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3) +// Comparisons between boost::function objects and arbitrary function +// objects. GCC 3.3 and before has an obnoxious bug that prevents this +// from working. +template + BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool) + operator==(const function_base& f, Functor g) + { + if (const Functor* fp = f.template target()) + return function_equal(*fp, g); + else return false; + } + +template + BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool) + operator==(Functor g, const function_base& f) + { + if (const Functor* fp = f.template target()) + return function_equal(g, *fp); + else return false; + } + +template + BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool) + operator!=(const function_base& f, Functor g) + { + if (const Functor* fp = f.template target()) + return !function_equal(*fp, g); + else return true; + } + +template + BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool) + operator!=(Functor g, const function_base& f) + { + if (const Functor* fp = f.template target()) + return !function_equal(g, *fp); + else return true; + } +# endif + +template + BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool) + operator==(const function_base& f, reference_wrapper g) + { + if (const Functor* fp = f.template target()) + return fp == g.get_pointer(); + else return false; + } + +template + BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool) + operator==(reference_wrapper g, const function_base& f) + { + if (const Functor* fp = f.template target()) + return g.get_pointer() == fp; + else return false; + } + +template + BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool) + operator!=(const function_base& f, reference_wrapper g) + { + if (const Functor* fp = f.template target()) + return fp != g.get_pointer(); + else return true; + } + +template + BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool) + operator!=(reference_wrapper g, const function_base& f) + { + if (const Functor* fp = f.template target()) + return g.get_pointer() != fp; + else return true; + } + +#endif // Compiler supporting SFINAE + +namespace detail { + namespace function { + inline bool has_empty_target(const function_base* f) + { + return f->empty(); + } + +#if BOOST_WORKAROUND(BOOST_MSVC, <= 1310) + inline bool has_empty_target(const void*) + { + return false; + } +#else + inline bool has_empty_target(...) + { + return false; + } +#endif + } // end namespace function +} // end namespace detail +} // end namespace boost + +#undef BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL +#undef BOOST_FUNCTION_COMPARE_TYPE_ID + +#if defined(BOOST_MSVC) +# pragma warning( pop ) +#endif + +#endif // BOOST_FUNCTION_BASE_HEADER diff --git a/realsense-file/3rd_party/boost/boost/function/function_fwd.hpp b/realsense-file/3rd_party/boost/boost/function/function_fwd.hpp new file mode 100644 index 0000000000..ca5409e177 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/function/function_fwd.hpp @@ -0,0 +1,69 @@ +// Boost.Function library +// Copyright (C) Douglas Gregor 2008 +// +// Use, modification and distribution is subject to 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) +// +// For more information, see http://www.boost.org +#ifndef BOOST_FUNCTION_FWD_HPP +#define BOOST_FUNCTION_FWD_HPP +#include + +#if defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730 && !defined(BOOST_STRICT_CONFIG) +// Work around a compiler bug. +// boost::python::objects::function has to be seen by the compiler before the +// boost::function class template. +namespace boost { namespace python { namespace objects { + class function; +}}} +#endif + +#if defined(BOOST_BCB_PARTIAL_SPECIALIZATION_BUG) \ + || !(defined(BOOST_STRICT_CONFIG) || !defined(__SUNPRO_CC) || __SUNPRO_CC > 0x540) +# define BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX +#endif + +namespace boost { + class bad_function_call; + +#if !defined(BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX) + // Preferred syntax + template class function; + + template + inline void swap(function& f1, function& f2) + { + f1.swap(f2); + } +#endif // have partial specialization + + // Portable syntax + template class function0; + template class function1; + template class function2; + template class function3; + template + class function4; + template + class function5; + template + class function6; + template + class function7; + template + class function8; + template + class function9; + template + class function10; +} + +#endif diff --git a/realsense-file/3rd_party/boost/boost/function/function_template.hpp b/realsense-file/3rd_party/boost/boost/function/function_template.hpp new file mode 100644 index 0000000000..bfa0761ca4 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/function/function_template.hpp @@ -0,0 +1,1196 @@ +// Boost.Function library + +// Copyright Douglas Gregor 2001-2006 +// Copyright Emil Dotchevski 2007 +// Use, modification and distribution is subject to 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) + +// For more information, see http://www.boost.org + +// Note: this header is a header template and must NOT have multiple-inclusion +// protection. +#include +#include + +#if defined(BOOST_MSVC) +# pragma warning( push ) +# pragma warning( disable : 4127 ) // "conditional expression is constant" +#endif + +#define BOOST_FUNCTION_TEMPLATE_PARMS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, typename T) + +#define BOOST_FUNCTION_TEMPLATE_ARGS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, T) + +#define BOOST_FUNCTION_PARM(J,I,D) BOOST_PP_CAT(T,I) BOOST_PP_CAT(a,I) + +#define BOOST_FUNCTION_PARMS BOOST_PP_ENUM(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_PARM,BOOST_PP_EMPTY) + +#ifdef BOOST_NO_CXX11_RVALUE_REFERENCES +# define BOOST_FUNCTION_ARGS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, a) +#else +# include +# define BOOST_FUNCTION_ARG(J,I,D) ::boost::forward< BOOST_PP_CAT(T,I) >(BOOST_PP_CAT(a,I)) +# define BOOST_FUNCTION_ARGS BOOST_PP_ENUM(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_ARG,BOOST_PP_EMPTY) +#endif + +#define BOOST_FUNCTION_ARG_TYPE(J,I,D) \ + typedef BOOST_PP_CAT(T,I) BOOST_PP_CAT(BOOST_PP_CAT(arg, BOOST_PP_INC(I)),_type); + +#define BOOST_FUNCTION_ARG_TYPES BOOST_PP_REPEAT(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_ARG_TYPE,BOOST_PP_EMPTY) + +// Comma if nonzero number of arguments +#if BOOST_FUNCTION_NUM_ARGS == 0 +# define BOOST_FUNCTION_COMMA +#else +# define BOOST_FUNCTION_COMMA , +#endif // BOOST_FUNCTION_NUM_ARGS > 0 + +// Class names used in this version of the code +#define BOOST_FUNCTION_FUNCTION BOOST_JOIN(function,BOOST_FUNCTION_NUM_ARGS) +#define BOOST_FUNCTION_FUNCTION_INVOKER \ + BOOST_JOIN(function_invoker,BOOST_FUNCTION_NUM_ARGS) +#define BOOST_FUNCTION_VOID_FUNCTION_INVOKER \ + BOOST_JOIN(void_function_invoker,BOOST_FUNCTION_NUM_ARGS) +#define BOOST_FUNCTION_FUNCTION_OBJ_INVOKER \ + BOOST_JOIN(function_obj_invoker,BOOST_FUNCTION_NUM_ARGS) +#define BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER \ + BOOST_JOIN(void_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS) +#define BOOST_FUNCTION_FUNCTION_REF_INVOKER \ + BOOST_JOIN(function_ref_invoker,BOOST_FUNCTION_NUM_ARGS) +#define BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER \ + BOOST_JOIN(void_function_ref_invoker,BOOST_FUNCTION_NUM_ARGS) +#define BOOST_FUNCTION_MEMBER_INVOKER \ + BOOST_JOIN(function_mem_invoker,BOOST_FUNCTION_NUM_ARGS) +#define BOOST_FUNCTION_VOID_MEMBER_INVOKER \ + BOOST_JOIN(function_void_mem_invoker,BOOST_FUNCTION_NUM_ARGS) +#define BOOST_FUNCTION_GET_FUNCTION_INVOKER \ + BOOST_JOIN(get_function_invoker,BOOST_FUNCTION_NUM_ARGS) +#define BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER \ + BOOST_JOIN(get_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS) +#define BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER \ + BOOST_JOIN(get_function_ref_invoker,BOOST_FUNCTION_NUM_ARGS) +#define BOOST_FUNCTION_GET_MEMBER_INVOKER \ + BOOST_JOIN(get_member_invoker,BOOST_FUNCTION_NUM_ARGS) +#define BOOST_FUNCTION_GET_INVOKER \ + BOOST_JOIN(get_invoker,BOOST_FUNCTION_NUM_ARGS) +#define BOOST_FUNCTION_VTABLE BOOST_JOIN(basic_vtable,BOOST_FUNCTION_NUM_ARGS) + +#ifndef BOOST_NO_VOID_RETURNS +# define BOOST_FUNCTION_VOID_RETURN_TYPE void +# define BOOST_FUNCTION_RETURN(X) X +#else +# define BOOST_FUNCTION_VOID_RETURN_TYPE boost::detail::function::unusable +# define BOOST_FUNCTION_RETURN(X) X; return BOOST_FUNCTION_VOID_RETURN_TYPE () +#endif + +namespace boost { + namespace detail { + namespace function { + template< + typename FunctionPtr, + typename R BOOST_FUNCTION_COMMA + BOOST_FUNCTION_TEMPLATE_PARMS + > + struct BOOST_FUNCTION_FUNCTION_INVOKER + { + static R invoke(function_buffer& function_ptr BOOST_FUNCTION_COMMA + BOOST_FUNCTION_PARMS) + { + FunctionPtr f = reinterpret_cast(function_ptr.func_ptr); + return f(BOOST_FUNCTION_ARGS); + } + }; + + template< + typename FunctionPtr, + typename R BOOST_FUNCTION_COMMA + BOOST_FUNCTION_TEMPLATE_PARMS + > + struct BOOST_FUNCTION_VOID_FUNCTION_INVOKER + { + static BOOST_FUNCTION_VOID_RETURN_TYPE + invoke(function_buffer& function_ptr BOOST_FUNCTION_COMMA + BOOST_FUNCTION_PARMS) + + { + FunctionPtr f = reinterpret_cast(function_ptr.func_ptr); + BOOST_FUNCTION_RETURN(f(BOOST_FUNCTION_ARGS)); + } + }; + + template< + typename FunctionObj, + typename R BOOST_FUNCTION_COMMA + BOOST_FUNCTION_TEMPLATE_PARMS + > + struct BOOST_FUNCTION_FUNCTION_OBJ_INVOKER + { + static R invoke(function_buffer& function_obj_ptr BOOST_FUNCTION_COMMA + BOOST_FUNCTION_PARMS) + + { + FunctionObj* f; + if (function_allows_small_object_optimization::value) + f = reinterpret_cast(&function_obj_ptr.data); + else + f = reinterpret_cast(function_obj_ptr.obj_ptr); + return (*f)(BOOST_FUNCTION_ARGS); + } + }; + + template< + typename FunctionObj, + typename R BOOST_FUNCTION_COMMA + BOOST_FUNCTION_TEMPLATE_PARMS + > + struct BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER + { + static BOOST_FUNCTION_VOID_RETURN_TYPE + invoke(function_buffer& function_obj_ptr BOOST_FUNCTION_COMMA + BOOST_FUNCTION_PARMS) + + { + FunctionObj* f; + if (function_allows_small_object_optimization::value) + f = reinterpret_cast(&function_obj_ptr.data); + else + f = reinterpret_cast(function_obj_ptr.obj_ptr); + BOOST_FUNCTION_RETURN((*f)(BOOST_FUNCTION_ARGS)); + } + }; + + template< + typename FunctionObj, + typename R BOOST_FUNCTION_COMMA + BOOST_FUNCTION_TEMPLATE_PARMS + > + struct BOOST_FUNCTION_FUNCTION_REF_INVOKER + { + static R invoke(function_buffer& function_obj_ptr BOOST_FUNCTION_COMMA + BOOST_FUNCTION_PARMS) + + { + FunctionObj* f = + reinterpret_cast(function_obj_ptr.obj_ptr); + return (*f)(BOOST_FUNCTION_ARGS); + } + }; + + template< + typename FunctionObj, + typename R BOOST_FUNCTION_COMMA + BOOST_FUNCTION_TEMPLATE_PARMS + > + struct BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER + { + static BOOST_FUNCTION_VOID_RETURN_TYPE + invoke(function_buffer& function_obj_ptr BOOST_FUNCTION_COMMA + BOOST_FUNCTION_PARMS) + + { + FunctionObj* f = + reinterpret_cast(function_obj_ptr.obj_ptr); + BOOST_FUNCTION_RETURN((*f)(BOOST_FUNCTION_ARGS)); + } + }; + +#if BOOST_FUNCTION_NUM_ARGS > 0 + /* Handle invocation of member pointers. */ + template< + typename MemberPtr, + typename R BOOST_FUNCTION_COMMA + BOOST_FUNCTION_TEMPLATE_PARMS + > + struct BOOST_FUNCTION_MEMBER_INVOKER + { + static R invoke(function_buffer& function_obj_ptr BOOST_FUNCTION_COMMA + BOOST_FUNCTION_PARMS) + + { + MemberPtr* f = + reinterpret_cast(&function_obj_ptr.data); + return std::mem_fn(*f)(BOOST_FUNCTION_ARGS); + } + }; + + template< + typename MemberPtr, + typename R BOOST_FUNCTION_COMMA + BOOST_FUNCTION_TEMPLATE_PARMS + > + struct BOOST_FUNCTION_VOID_MEMBER_INVOKER + { + static BOOST_FUNCTION_VOID_RETURN_TYPE + invoke(function_buffer& function_obj_ptr BOOST_FUNCTION_COMMA + BOOST_FUNCTION_PARMS) + + { + MemberPtr* f = + reinterpret_cast(&function_obj_ptr.data); + BOOST_FUNCTION_RETURN(std::mem_fn(*f)(BOOST_FUNCTION_ARGS)); + } + }; +#endif + + template< + typename FunctionPtr, + typename R BOOST_FUNCTION_COMMA + BOOST_FUNCTION_TEMPLATE_PARMS + > + struct BOOST_FUNCTION_GET_FUNCTION_INVOKER + { + typedef typename mpl::if_c<(is_void::value), + BOOST_FUNCTION_VOID_FUNCTION_INVOKER< + FunctionPtr, + R BOOST_FUNCTION_COMMA + BOOST_FUNCTION_TEMPLATE_ARGS + >, + BOOST_FUNCTION_FUNCTION_INVOKER< + FunctionPtr, + R BOOST_FUNCTION_COMMA + BOOST_FUNCTION_TEMPLATE_ARGS + > + >::type type; + }; + + template< + typename FunctionObj, + typename R BOOST_FUNCTION_COMMA + BOOST_FUNCTION_TEMPLATE_PARMS + > + struct BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER + { + typedef typename mpl::if_c<(is_void::value), + BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER< + FunctionObj, + R BOOST_FUNCTION_COMMA + BOOST_FUNCTION_TEMPLATE_ARGS + >, + BOOST_FUNCTION_FUNCTION_OBJ_INVOKER< + FunctionObj, + R BOOST_FUNCTION_COMMA + BOOST_FUNCTION_TEMPLATE_ARGS + > + >::type type; + }; + + template< + typename FunctionObj, + typename R BOOST_FUNCTION_COMMA + BOOST_FUNCTION_TEMPLATE_PARMS + > + struct BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER + { + typedef typename mpl::if_c<(is_void::value), + BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER< + FunctionObj, + R BOOST_FUNCTION_COMMA + BOOST_FUNCTION_TEMPLATE_ARGS + >, + BOOST_FUNCTION_FUNCTION_REF_INVOKER< + FunctionObj, + R BOOST_FUNCTION_COMMA + BOOST_FUNCTION_TEMPLATE_ARGS + > + >::type type; + }; + +#if BOOST_FUNCTION_NUM_ARGS > 0 + /* Retrieve the appropriate invoker for a member pointer. */ + template< + typename MemberPtr, + typename R BOOST_FUNCTION_COMMA + BOOST_FUNCTION_TEMPLATE_PARMS + > + struct BOOST_FUNCTION_GET_MEMBER_INVOKER + { + typedef typename mpl::if_c<(is_void::value), + BOOST_FUNCTION_VOID_MEMBER_INVOKER< + MemberPtr, + R BOOST_FUNCTION_COMMA + BOOST_FUNCTION_TEMPLATE_ARGS + >, + BOOST_FUNCTION_MEMBER_INVOKER< + MemberPtr, + R BOOST_FUNCTION_COMMA + BOOST_FUNCTION_TEMPLATE_ARGS + > + >::type type; + }; +#endif + + /* Given the tag returned by get_function_tag, retrieve the + actual invoker that will be used for the given function + object. + + Each specialization contains an "apply" nested class template + that accepts the function object, return type, function + argument types, and allocator. The resulting "apply" class + contains two typedefs, "invoker_type" and "manager_type", + which correspond to the invoker and manager types. */ + template + struct BOOST_FUNCTION_GET_INVOKER { }; + + /* Retrieve the invoker for a function pointer. */ + template<> + struct BOOST_FUNCTION_GET_INVOKER + { + template + struct apply + { + typedef typename BOOST_FUNCTION_GET_FUNCTION_INVOKER< + FunctionPtr, + R BOOST_FUNCTION_COMMA + BOOST_FUNCTION_TEMPLATE_ARGS + >::type + invoker_type; + + typedef functor_manager manager_type; + }; + + template + struct apply_a + { + typedef typename BOOST_FUNCTION_GET_FUNCTION_INVOKER< + FunctionPtr, + R BOOST_FUNCTION_COMMA + BOOST_FUNCTION_TEMPLATE_ARGS + >::type + invoker_type; + + typedef functor_manager manager_type; + }; + }; + +#if BOOST_FUNCTION_NUM_ARGS > 0 + /* Retrieve the invoker for a member pointer. */ + template<> + struct BOOST_FUNCTION_GET_INVOKER + { + template + struct apply + { + typedef typename BOOST_FUNCTION_GET_MEMBER_INVOKER< + MemberPtr, + R BOOST_FUNCTION_COMMA + BOOST_FUNCTION_TEMPLATE_ARGS + >::type + invoker_type; + + typedef functor_manager manager_type; + }; + + template + struct apply_a + { + typedef typename BOOST_FUNCTION_GET_MEMBER_INVOKER< + MemberPtr, + R BOOST_FUNCTION_COMMA + BOOST_FUNCTION_TEMPLATE_ARGS + >::type + invoker_type; + + typedef functor_manager manager_type; + }; + }; +#endif + + /* Retrieve the invoker for a function object. */ + template<> + struct BOOST_FUNCTION_GET_INVOKER + { + template + struct apply + { + typedef typename BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER< + FunctionObj, + R BOOST_FUNCTION_COMMA + BOOST_FUNCTION_TEMPLATE_ARGS + >::type + invoker_type; + + typedef functor_manager manager_type; + }; + + template + struct apply_a + { + typedef typename BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER< + FunctionObj, + R BOOST_FUNCTION_COMMA + BOOST_FUNCTION_TEMPLATE_ARGS + >::type + invoker_type; + + typedef functor_manager_a manager_type; + }; + }; + + /* Retrieve the invoker for a reference to a function object. */ + template<> + struct BOOST_FUNCTION_GET_INVOKER + { + template + struct apply + { + typedef typename BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER< + typename RefWrapper::type, + R BOOST_FUNCTION_COMMA + BOOST_FUNCTION_TEMPLATE_ARGS + >::type + invoker_type; + + typedef reference_manager manager_type; + }; + + template + struct apply_a + { + typedef typename BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER< + typename RefWrapper::type, + R BOOST_FUNCTION_COMMA + BOOST_FUNCTION_TEMPLATE_ARGS + >::type + invoker_type; + + typedef reference_manager manager_type; + }; + }; + + + /** + * vtable for a specific boost::function instance. This + * structure must be an aggregate so that we can use static + * initialization in boost::function's assign_to and assign_to_a + * members. It therefore cannot have any constructors, + * destructors, base classes, etc. + */ + template + struct BOOST_FUNCTION_VTABLE + { +#ifndef BOOST_NO_VOID_RETURNS + typedef R result_type; +#else + typedef typename function_return_type::type result_type; +#endif // BOOST_NO_VOID_RETURNS + + typedef result_type (*invoker_type)(function_buffer& + BOOST_FUNCTION_COMMA + BOOST_FUNCTION_TEMPLATE_ARGS); + + template + bool assign_to(F f, function_buffer& functor) const + { + typedef typename get_function_tag::type tag; + return assign_to(f, functor, tag()); + } + template + bool assign_to_a(F f, function_buffer& functor, Allocator a) const + { + typedef typename get_function_tag::type tag; + return assign_to_a(f, functor, a, tag()); + } + + void clear(function_buffer& functor) const + { + if (base.manager) + base.manager(functor, functor, destroy_functor_tag); + } + + private: + // Function pointers + template + bool + assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag) const + { + this->clear(functor); + if (f) { + // should be a reinterpret cast, but some compilers insist + // on giving cv-qualifiers to free functions + functor.func_ptr = reinterpret_cast(f); + return true; + } else { + return false; + } + } + template + bool + assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag) const + { + return assign_to(f,functor,function_ptr_tag()); + } + + // Member pointers +#if BOOST_FUNCTION_NUM_ARGS > 0 + template + bool assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag) const + { + // DPG TBD: Add explicit support for member function + // objects, so we invoke through mem_fn() but we retain the + // right target_type() values. + if (f) { + this->assign_to(std::mem_fn(f), functor); + return true; + } else { + return false; + } + } + template + bool assign_to_a(MemberPtr f, function_buffer& functor, Allocator a, member_ptr_tag) const + { + // DPG TBD: Add explicit support for member function + // objects, so we invoke through mem_fn() but we retain the + // right target_type() values. + if (f) { + this->assign_to_a(std::mem_fn(f), functor, a); + return true; + } else { + return false; + } + } +#endif // BOOST_FUNCTION_NUM_ARGS > 0 + + // Function objects + // Assign to a function object using the small object optimization + template + void + assign_functor(FunctionObj f, function_buffer& functor, mpl::true_) const + { + new (reinterpret_cast(&functor.data)) FunctionObj(f); + } + template + void + assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, mpl::true_) const + { + assign_functor(f,functor,mpl::true_()); + } + + // Assign to a function object allocated on the heap. + template + void + assign_functor(FunctionObj f, function_buffer& functor, mpl::false_) const + { + functor.obj_ptr = new FunctionObj(f); + } + template + void + assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, mpl::false_) const + { + typedef functor_wrapper functor_wrapper_type; + typedef typename Allocator::template rebind::other + wrapper_allocator_type; + typedef typename wrapper_allocator_type::pointer wrapper_allocator_pointer_type; + wrapper_allocator_type wrapper_allocator(a); + wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1); + wrapper_allocator.construct(copy, functor_wrapper_type(f,a)); + functor_wrapper_type* new_f = static_cast(copy); + functor.obj_ptr = new_f; + } + + template + bool + assign_to(FunctionObj f, function_buffer& functor, function_obj_tag) const + { + if (!boost::detail::function::has_empty_target(boost::addressof(f))) { + assign_functor(f, functor, + mpl::bool_<(function_allows_small_object_optimization::value)>()); + return true; + } else { + return false; + } + } + template + bool + assign_to_a(FunctionObj f, function_buffer& functor, Allocator a, function_obj_tag) const + { + if (!boost::detail::function::has_empty_target(boost::addressof(f))) { + assign_functor_a(f, functor, a, + mpl::bool_<(function_allows_small_object_optimization::value)>()); + return true; + } else { + return false; + } + } + + // Reference to a function object + template + bool + assign_to(const reference_wrapper& f, + function_buffer& functor, function_obj_ref_tag) const + { + functor.obj_ref.obj_ptr = (void *)(f.get_pointer()); + functor.obj_ref.is_const_qualified = is_const::value; + functor.obj_ref.is_volatile_qualified = is_volatile::value; + return true; + } + template + bool + assign_to_a(const reference_wrapper& f, + function_buffer& functor, Allocator, function_obj_ref_tag) const + { + return assign_to(f,functor,function_obj_ref_tag()); + } + + public: + vtable_base base; + invoker_type invoker; + }; + } // end namespace function + } // end namespace detail + + template< + typename R BOOST_FUNCTION_COMMA + BOOST_FUNCTION_TEMPLATE_PARMS + > + class BOOST_FUNCTION_FUNCTION : public function_base + +#if BOOST_FUNCTION_NUM_ARGS == 1 + + , public std::unary_function + +#elif BOOST_FUNCTION_NUM_ARGS == 2 + + , public std::binary_function + +#endif + + { + public: +#ifndef BOOST_NO_VOID_RETURNS + typedef R result_type; +#else + typedef typename boost::detail::function::function_return_type::type + result_type; +#endif // BOOST_NO_VOID_RETURNS + + private: + typedef boost::detail::function::BOOST_FUNCTION_VTABLE< + R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_ARGS> + vtable_type; + + vtable_type* get_vtable() const { + return reinterpret_cast( + reinterpret_cast(vtable) & ~static_cast(0x01)); + } + + struct clear_type {}; + + public: + BOOST_STATIC_CONSTANT(int, args = BOOST_FUNCTION_NUM_ARGS); + + // add signature for boost::lambda + template + struct sig + { + typedef result_type type; + }; + +#if BOOST_FUNCTION_NUM_ARGS == 1 + typedef T0 argument_type; +#elif BOOST_FUNCTION_NUM_ARGS == 2 + typedef T0 first_argument_type; + typedef T1 second_argument_type; +#endif + + BOOST_STATIC_CONSTANT(int, arity = BOOST_FUNCTION_NUM_ARGS); + BOOST_FUNCTION_ARG_TYPES + + typedef BOOST_FUNCTION_FUNCTION self_type; + + BOOST_FUNCTION_FUNCTION() : function_base() { } + + // MSVC chokes if the following two constructors are collapsed into + // one with a default parameter. + template + BOOST_FUNCTION_FUNCTION(Functor BOOST_FUNCTION_TARGET_FIX(const &) f +#ifndef BOOST_NO_SFINAE + ,typename enable_if_c< + (boost::type_traits::ice_not< + (is_integral::value)>::value), + int>::type = 0 +#endif // BOOST_NO_SFINAE + ) : + function_base() + { + this->assign_to(f); + } + template + BOOST_FUNCTION_FUNCTION(Functor BOOST_FUNCTION_TARGET_FIX(const &) f, Allocator a +#ifndef BOOST_NO_SFINAE + ,typename enable_if_c< + (boost::type_traits::ice_not< + (is_integral::value)>::value), + int>::type = 0 +#endif // BOOST_NO_SFINAE + ) : + function_base() + { + this->assign_to_a(f,a); + } + +#ifndef BOOST_NO_SFINAE + BOOST_FUNCTION_FUNCTION(clear_type*) : function_base() { } +#else + BOOST_FUNCTION_FUNCTION(int zero) : function_base() + { + BOOST_ASSERT(zero == 0); + } +#endif + + BOOST_FUNCTION_FUNCTION(const BOOST_FUNCTION_FUNCTION& f) : function_base() + { + this->assign_to_own(f); + } + +#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES + BOOST_FUNCTION_FUNCTION(BOOST_FUNCTION_FUNCTION&& f) : function_base() + { + this->move_assign(f); + } +#endif + + ~BOOST_FUNCTION_FUNCTION() { clear(); } + + result_type operator()(BOOST_FUNCTION_PARMS) const + { + if (this->empty()) + boost::throw_exception(bad_function_call()); + + return get_vtable()->invoker + (this->functor BOOST_FUNCTION_COMMA BOOST_FUNCTION_ARGS); + } + + // The distinction between when to use BOOST_FUNCTION_FUNCTION and + // when to use self_type is obnoxious. MSVC cannot handle self_type as + // the return type of these assignment operators, but Borland C++ cannot + // handle BOOST_FUNCTION_FUNCTION as the type of the temporary to + // construct. + template +#ifndef BOOST_NO_SFINAE + typename enable_if_c< + (boost::type_traits::ice_not< + (is_integral::value)>::value), + BOOST_FUNCTION_FUNCTION&>::type +#else + BOOST_FUNCTION_FUNCTION& +#endif + operator=(Functor BOOST_FUNCTION_TARGET_FIX(const &) f) + { + this->clear(); + BOOST_TRY { + this->assign_to(f); + } BOOST_CATCH (...) { + vtable = 0; + BOOST_RETHROW; + } + BOOST_CATCH_END + return *this; + } + template + void assign(Functor BOOST_FUNCTION_TARGET_FIX(const &) f, Allocator a) + { + this->clear(); + BOOST_TRY{ + this->assign_to_a(f,a); + } BOOST_CATCH (...) { + vtable = 0; + BOOST_RETHROW; + } + BOOST_CATCH_END + } + +#ifndef BOOST_NO_SFINAE + BOOST_FUNCTION_FUNCTION& operator=(clear_type*) + { + this->clear(); + return *this; + } +#else + BOOST_FUNCTION_FUNCTION& operator=(int zero) + { + BOOST_ASSERT(zero == 0); + this->clear(); + return *this; + } +#endif + + // Assignment from another BOOST_FUNCTION_FUNCTION + BOOST_FUNCTION_FUNCTION& operator=(const BOOST_FUNCTION_FUNCTION& f) + { + if (&f == this) + return *this; + + this->clear(); + BOOST_TRY { + this->assign_to_own(f); + } BOOST_CATCH (...) { + vtable = 0; + BOOST_RETHROW; + } + BOOST_CATCH_END + return *this; + } + +#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES + // Move assignment from another BOOST_FUNCTION_FUNCTION + BOOST_FUNCTION_FUNCTION& operator=(BOOST_FUNCTION_FUNCTION&& f) + { + + if (&f == this) + return *this; + + this->clear(); + BOOST_TRY { + this->move_assign(f); + } BOOST_CATCH (...) { + vtable = 0; + BOOST_RETHROW; + } + BOOST_CATCH_END + return *this; + } +#endif + + void swap(BOOST_FUNCTION_FUNCTION& other) + { + if (&other == this) + return; + + BOOST_FUNCTION_FUNCTION tmp; + tmp.move_assign(*this); + this->move_assign(other); + other.move_assign(tmp); + } + + // Clear out a target, if there is one + void clear() + { + if (vtable) { + if (!this->has_trivial_copy_and_destroy()) + get_vtable()->clear(this->functor); + vtable = 0; + } + } + +#if (defined __SUNPRO_CC) && (__SUNPRO_CC <= 0x530) && !(defined BOOST_NO_COMPILER_CONFIG) + // Sun C++ 5.3 can't handle the safe_bool idiom, so don't use it + operator bool () const { return !this->empty(); } +#else + private: + struct dummy { + void nonnull() {} + }; + + typedef void (dummy::*safe_bool)(); + + public: + operator safe_bool () const + { return (this->empty())? 0 : &dummy::nonnull; } + + bool operator!() const + { return this->empty(); } +#endif + + private: + void assign_to_own(const BOOST_FUNCTION_FUNCTION& f) + { + if (!f.empty()) { + this->vtable = f.vtable; + if (this->has_trivial_copy_and_destroy()) + this->functor = f.functor; + else + get_vtable()->base.manager(f.functor, this->functor, + boost::detail::function::clone_functor_tag); + } + } + + template + void assign_to(Functor f) + { + using boost::detail::function::vtable_base; + + typedef typename boost::detail::function::get_function_tag::type tag; + typedef boost::detail::function::BOOST_FUNCTION_GET_INVOKER get_invoker; + typedef typename get_invoker:: + template apply + handler_type; + + typedef typename handler_type::invoker_type invoker_type; + typedef typename handler_type::manager_type manager_type; + + // Note: it is extremely important that this initialization use + // static initialization. Otherwise, we will have a race + // condition here in multi-threaded code. See + // http://thread.gmane.org/gmane.comp.lib.boost.devel/164902/. + static const vtable_type stored_vtable = + { { &manager_type::manage }, &invoker_type::invoke }; + + if (stored_vtable.assign_to(f, functor)) { + std::size_t value = reinterpret_cast(&stored_vtable.base); + // coverity[pointless_expression]: suppress coverity warnings on apparant if(const). + if (boost::has_trivial_copy_constructor::value && + boost::has_trivial_destructor::value && + boost::detail::function::function_allows_small_object_optimization::value) + value |= static_cast(0x01); + vtable = reinterpret_cast(value); + } else + vtable = 0; + } + + template + void assign_to_a(Functor f,Allocator a) + { + using boost::detail::function::vtable_base; + + typedef typename boost::detail::function::get_function_tag::type tag; + typedef boost::detail::function::BOOST_FUNCTION_GET_INVOKER get_invoker; + typedef typename get_invoker:: + template apply_a + handler_type; + + typedef typename handler_type::invoker_type invoker_type; + typedef typename handler_type::manager_type manager_type; + + // Note: it is extremely important that this initialization use + // static initialization. Otherwise, we will have a race + // condition here in multi-threaded code. See + // http://thread.gmane.org/gmane.comp.lib.boost.devel/164902/. + static const vtable_type stored_vtable = + { { &manager_type::manage }, &invoker_type::invoke }; + + if (stored_vtable.assign_to_a(f, functor, a)) { + std::size_t value = reinterpret_cast(&stored_vtable.base); + // coverity[pointless_expression]: suppress coverity warnings on apparant if(const). + if (boost::has_trivial_copy_constructor::value && + boost::has_trivial_destructor::value && + boost::detail::function::function_allows_small_object_optimization::value) + value |= static_cast(0x01); + vtable = reinterpret_cast(value); + } else + vtable = 0; + } + + // Moves the value from the specified argument to *this. If the argument + // has its function object allocated on the heap, move_assign will pass + // its buffer to *this, and set the argument's buffer pointer to NULL. + void move_assign(BOOST_FUNCTION_FUNCTION& f) + { + if (&f == this) + return; + + BOOST_TRY { + if (!f.empty()) { + this->vtable = f.vtable; + if (this->has_trivial_copy_and_destroy()) + this->functor = f.functor; + else + get_vtable()->base.manager(f.functor, this->functor, + boost::detail::function::move_functor_tag); + f.vtable = 0; + } else { + clear(); + } + } BOOST_CATCH (...) { + vtable = 0; + BOOST_RETHROW; + } + BOOST_CATCH_END + } + }; + + template + inline void swap(BOOST_FUNCTION_FUNCTION< + R BOOST_FUNCTION_COMMA + BOOST_FUNCTION_TEMPLATE_ARGS + >& f1, + BOOST_FUNCTION_FUNCTION< + R BOOST_FUNCTION_COMMA + BOOST_FUNCTION_TEMPLATE_ARGS + >& f2) + { + f1.swap(f2); + } + +// Poison comparisons between boost::function objects of the same type. +template + void operator==(const BOOST_FUNCTION_FUNCTION< + R BOOST_FUNCTION_COMMA + BOOST_FUNCTION_TEMPLATE_ARGS>&, + const BOOST_FUNCTION_FUNCTION< + R BOOST_FUNCTION_COMMA + BOOST_FUNCTION_TEMPLATE_ARGS>&); +template + void operator!=(const BOOST_FUNCTION_FUNCTION< + R BOOST_FUNCTION_COMMA + BOOST_FUNCTION_TEMPLATE_ARGS>&, + const BOOST_FUNCTION_FUNCTION< + R BOOST_FUNCTION_COMMA + BOOST_FUNCTION_TEMPLATE_ARGS>& ); + +#if !defined(BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX) + +#if BOOST_FUNCTION_NUM_ARGS == 0 +#define BOOST_FUNCTION_PARTIAL_SPEC R (void) +#else +#define BOOST_FUNCTION_PARTIAL_SPEC R (BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS,T)) +#endif + +template +class function + : public BOOST_FUNCTION_FUNCTION +{ + typedef BOOST_FUNCTION_FUNCTION base_type; + typedef function self_type; + + struct clear_type {}; + +public: + + function() : base_type() {} + + template + function(Functor f +#ifndef BOOST_NO_SFINAE + ,typename enable_if_c< + (boost::type_traits::ice_not< + (is_integral::value)>::value), + int>::type = 0 +#endif + ) : + base_type(f) + { + } + template + function(Functor f, Allocator a +#ifndef BOOST_NO_SFINAE + ,typename enable_if_c< + (boost::type_traits::ice_not< + (is_integral::value)>::value), + int>::type = 0 +#endif + ) : + base_type(f,a) + { + } + +#ifndef BOOST_NO_SFINAE + function(clear_type*) : base_type() {} +#endif + + function(const self_type& f) : base_type(static_cast(f)){} + + function(const base_type& f) : base_type(static_cast(f)){} + +#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES + // Move constructors + function(self_type&& f): base_type(static_cast(f)){} + function(base_type&& f): base_type(static_cast(f)){} +#endif + + self_type& operator=(const self_type& f) + { + self_type(f).swap(*this); + return *this; + } + +#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES + self_type& operator=(self_type&& f) + { + self_type(static_cast(f)).swap(*this); + return *this; + } +#endif + + template +#ifndef BOOST_NO_SFINAE + typename enable_if_c< + (boost::type_traits::ice_not< + (is_integral::value)>::value), + self_type&>::type +#else + self_type& +#endif + operator=(Functor f) + { + self_type(f).swap(*this); + return *this; + } + +#ifndef BOOST_NO_SFINAE + self_type& operator=(clear_type*) + { + this->clear(); + return *this; + } +#endif + + self_type& operator=(const base_type& f) + { + self_type(f).swap(*this); + return *this; + } + +#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES + self_type& operator=(base_type&& f) + { + self_type(static_cast(f)).swap(*this); + return *this; + } +#endif +}; + +#undef BOOST_FUNCTION_PARTIAL_SPEC +#endif // have partial specialization + +} // end namespace boost + +// Cleanup after ourselves... +#undef BOOST_FUNCTION_VTABLE +#undef BOOST_FUNCTION_COMMA +#undef BOOST_FUNCTION_FUNCTION +#undef BOOST_FUNCTION_FUNCTION_INVOKER +#undef BOOST_FUNCTION_VOID_FUNCTION_INVOKER +#undef BOOST_FUNCTION_FUNCTION_OBJ_INVOKER +#undef BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER +#undef BOOST_FUNCTION_FUNCTION_REF_INVOKER +#undef BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER +#undef BOOST_FUNCTION_MEMBER_INVOKER +#undef BOOST_FUNCTION_VOID_MEMBER_INVOKER +#undef BOOST_FUNCTION_GET_FUNCTION_INVOKER +#undef BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER +#undef BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER +#undef BOOST_FUNCTION_GET_MEM_FUNCTION_INVOKER +#undef BOOST_FUNCTION_GET_INVOKER +#undef BOOST_FUNCTION_TEMPLATE_PARMS +#undef BOOST_FUNCTION_TEMPLATE_ARGS +#undef BOOST_FUNCTION_PARMS +#undef BOOST_FUNCTION_PARM +#ifdef BOOST_FUNCTION_ARG +# undef BOOST_FUNCTION_ARG +#endif +#undef BOOST_FUNCTION_ARGS +#undef BOOST_FUNCTION_ARG_TYPE +#undef BOOST_FUNCTION_ARG_TYPES +#undef BOOST_FUNCTION_VOID_RETURN_TYPE +#undef BOOST_FUNCTION_RETURN + +#if defined(BOOST_MSVC) +# pragma warning( pop ) +#endif diff --git a/realsense-file/3rd_party/boost/boost/function/gen_function_N.pl b/realsense-file/3rd_party/boost/boost/function/gen_function_N.pl new file mode 100644 index 0000000000..6d1ca2f923 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/function/gen_function_N.pl @@ -0,0 +1,26 @@ +#!/usr/bin/perl -w +# +# Boost.Function library +# +# Copyright Douglas Gregor 2001-2003. Use, modification and +# distribution is subject to 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) +# +# For more information, see http://www.boost.org +use English; + +if ($#ARGV < 0) { + print "Usage: perl gen_function_N \n"; + exit; +} + + +$totalNumArgs = $ARGV[0]; +for ($numArgs = 0; $numArgs <= $totalNumArgs; ++$numArgs) { + open OUT, ">function$numArgs.hpp"; + print OUT "#define BOOST_FUNCTION_NUM_ARGS $numArgs\n"; + print OUT "#include \n"; + print OUT "#undef BOOST_FUNCTION_NUM_ARGS\n"; + close OUT; +} diff --git a/realsense-file/3rd_party/boost/boost/function_equal.hpp b/realsense-file/3rd_party/boost/boost/function_equal.hpp new file mode 100644 index 0000000000..35e66421a4 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/function_equal.hpp @@ -0,0 +1,28 @@ +// Copyright Douglas Gregor 2004. +// Copyright 2005 Peter Dimov + +// Use, modification and distribution is subject to +// 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) + +// For more information, see http://www.boost.org +#ifndef BOOST_FUNCTION_EQUAL_HPP +#define BOOST_FUNCTION_EQUAL_HPP + +namespace boost { + +template + bool function_equal_impl(const F& f, const G& g, long) + { return f == g; } + +// function_equal_impl needs to be unqualified to pick +// user overloads on two-phase compilers + +template + bool function_equal(const F& f, const G& g) + { return function_equal_impl(f, g, 0); } + +} // end namespace boost + +#endif // BOOST_FUNCTION_EQUAL_HPP diff --git a/realsense-file/3rd_party/boost/boost/integer.hpp b/realsense-file/3rd_party/boost/boost/integer.hpp new file mode 100644 index 0000000000..522a863441 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/integer.hpp @@ -0,0 +1,262 @@ +// boost integer.hpp header file -------------------------------------------// + +// Copyright Beman Dawes and Daryle Walker 1999. Distributed under the Boost +// Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org/libs/integer for documentation. + +// Revision History +// 22 Sep 01 Added value-based integer templates. (Daryle Walker) +// 01 Apr 01 Modified to use new header. (John Maddock) +// 30 Jul 00 Add typename syntax fix (Jens Maurer) +// 28 Aug 99 Initial version + +#ifndef BOOST_INTEGER_HPP +#define BOOST_INTEGER_HPP + +#include // self include + +#include // for boost::::boost::integer_traits +#include // for ::std::numeric_limits +#include // for boost::int64_t and BOOST_NO_INTEGRAL_INT64_T +#include + +// +// We simply cannot include this header on gcc without getting copious warnings of the kind: +// +// boost/integer.hpp:77:30: warning: use of C99 long long integer constant +// +// And yet there is no other reasonable implementation, so we declare this a system header +// to suppress these warnings. +// +#if defined(__GNUC__) && (__GNUC__ >= 4) +#pragma GCC system_header +#endif + +namespace boost +{ + + // Helper templates ------------------------------------------------------// + + // fast integers from least integers + // int_fast_t<> works correctly for unsigned too, in spite of the name. + template< typename LeastInt > + struct int_fast_t + { + typedef LeastInt fast; + typedef fast type; + }; // imps may specialize + + namespace detail{ + + // convert category to type + template< int Category > struct int_least_helper {}; // default is empty + template< int Category > struct uint_least_helper {}; // default is empty + + // specializatons: 1=long, 2=int, 3=short, 4=signed char, + // 6=unsigned long, 7=unsigned int, 8=unsigned short, 9=unsigned char + // no specializations for 0 and 5: requests for a type > long are in error +#ifdef BOOST_HAS_LONG_LONG + template<> struct int_least_helper<1> { typedef boost::long_long_type least; }; +#elif defined(BOOST_HAS_MS_INT64) + template<> struct int_least_helper<1> { typedef __int64 least; }; +#endif + template<> struct int_least_helper<2> { typedef long least; }; + template<> struct int_least_helper<3> { typedef int least; }; + template<> struct int_least_helper<4> { typedef short least; }; + template<> struct int_least_helper<5> { typedef signed char least; }; +#ifdef BOOST_HAS_LONG_LONG + template<> struct uint_least_helper<1> { typedef boost::ulong_long_type least; }; +#elif defined(BOOST_HAS_MS_INT64) + template<> struct uint_least_helper<1> { typedef unsigned __int64 least; }; +#endif + template<> struct uint_least_helper<2> { typedef unsigned long least; }; + template<> struct uint_least_helper<3> { typedef unsigned int least; }; + template<> struct uint_least_helper<4> { typedef unsigned short least; }; + template<> struct uint_least_helper<5> { typedef unsigned char least; }; + + template + struct exact_signed_base_helper{}; + template + struct exact_unsigned_base_helper{}; + + template <> struct exact_signed_base_helper { typedef signed char exact; }; + template <> struct exact_unsigned_base_helper { typedef unsigned char exact; }; +#if USHRT_MAX != UCHAR_MAX + template <> struct exact_signed_base_helper { typedef short exact; }; + template <> struct exact_unsigned_base_helper { typedef unsigned short exact; }; +#endif +#if UINT_MAX != USHRT_MAX + template <> struct exact_signed_base_helper { typedef int exact; }; + template <> struct exact_unsigned_base_helper { typedef unsigned int exact; }; +#endif +#if ULONG_MAX != UINT_MAX && ( !defined __TI_COMPILER_VERSION__ || \ + ( __TI_COMPILER_VERSION__ >= 7000000 && !defined __TI_40BIT_LONG__ ) ) + template <> struct exact_signed_base_helper { typedef long exact; }; + template <> struct exact_unsigned_base_helper { typedef unsigned long exact; }; +#endif +#if defined(BOOST_HAS_LONG_LONG) &&\ + ((defined(ULLONG_MAX) && (ULLONG_MAX != ULONG_MAX)) ||\ + (defined(ULONG_LONG_MAX) && (ULONG_LONG_MAX != ULONG_MAX)) ||\ + (defined(ULONGLONG_MAX) && (ULONGLONG_MAX != ULONG_MAX)) ||\ + (defined(_ULLONG_MAX) && (_ULLONG_MAX != ULONG_MAX))) + template <> struct exact_signed_base_helper { typedef boost::long_long_type exact; }; + template <> struct exact_unsigned_base_helper { typedef boost::ulong_long_type exact; }; +#endif + + + } // namespace detail + + // integer templates specifying number of bits ---------------------------// + + // signed + template< int Bits > // bits (including sign) required + struct int_t : public boost::detail::exact_signed_base_helper + { + BOOST_STATIC_ASSERT_MSG(Bits <= (int)(sizeof(boost::intmax_t) * CHAR_BIT), + "No suitable signed integer type with the requested number of bits is available."); + typedef typename boost::detail::int_least_helper + < +#ifdef BOOST_HAS_LONG_LONG + (Bits <= (int)(sizeof(boost::long_long_type) * CHAR_BIT)) + +#else + 1 + +#endif + (Bits-1 <= ::std::numeric_limits::digits) + + (Bits-1 <= ::std::numeric_limits::digits) + + (Bits-1 <= ::std::numeric_limits::digits) + + (Bits-1 <= ::std::numeric_limits::digits) + >::least least; + typedef typename int_fast_t::type fast; + }; + + // unsigned + template< int Bits > // bits required + struct uint_t : public boost::detail::exact_unsigned_base_helper + { + BOOST_STATIC_ASSERT_MSG(Bits <= (int)(sizeof(boost::uintmax_t) * CHAR_BIT), + "No suitable unsigned integer type with the requested number of bits is available."); +#if (defined(__BORLANDC__) || defined(__CODEGEAR__)) && defined(BOOST_NO_INTEGRAL_INT64_T) + // It's really not clear why this workaround should be needed... shrug I guess! JM + BOOST_STATIC_CONSTANT(int, s = + 6 + + (Bits <= ::std::numeric_limits::digits) + + (Bits <= ::std::numeric_limits::digits) + + (Bits <= ::std::numeric_limits::digits) + + (Bits <= ::std::numeric_limits::digits)); + typedef typename detail::int_least_helper< ::boost::uint_t::s>::least least; +#else + typedef typename boost::detail::uint_least_helper + < +#ifdef BOOST_HAS_LONG_LONG + (Bits <= (int)(sizeof(boost::long_long_type) * CHAR_BIT)) + +#else + 1 + +#endif + (Bits <= ::std::numeric_limits::digits) + + (Bits <= ::std::numeric_limits::digits) + + (Bits <= ::std::numeric_limits::digits) + + (Bits <= ::std::numeric_limits::digits) + >::least least; +#endif + typedef typename int_fast_t::type fast; + // int_fast_t<> works correctly for unsigned too, in spite of the name. + }; + + // integer templates specifying extreme value ----------------------------// + + // signed +#if !defined(BOOST_NO_INTEGRAL_INT64_T) && !defined(BOOST_NO_INT64_T) && defined(BOOST_HAS_LONG_LONG) + template< boost::long_long_type MaxValue > // maximum value to require support +#else + template< long MaxValue > // maximum value to require support +#endif + struct int_max_value_t + { + typedef typename boost::detail::int_least_helper + < +#if !defined(BOOST_NO_INTEGRAL_INT64_T) && !defined(BOOST_NO_INT64_T) && defined(BOOST_HAS_LONG_LONG) + (MaxValue <= ::boost::integer_traits::const_max) + +#else + 1 + +#endif + (MaxValue <= ::boost::integer_traits::const_max) + + (MaxValue <= ::boost::integer_traits::const_max) + + (MaxValue <= ::boost::integer_traits::const_max) + + (MaxValue <= ::boost::integer_traits::const_max) + >::least least; + typedef typename int_fast_t::type fast; + }; + +#if !defined(BOOST_NO_INTEGRAL_INT64_T) && !defined(BOOST_NO_INT64_T) && defined(BOOST_HAS_LONG_LONG) + template< boost::long_long_type MinValue > // minimum value to require support +#else + template< long MinValue > // minimum value to require support +#endif + struct int_min_value_t + { + typedef typename boost::detail::int_least_helper + < +#if !defined(BOOST_NO_INTEGRAL_INT64_T) && !defined(BOOST_NO_INT64_T) && defined(BOOST_HAS_LONG_LONG) + (MinValue >= ::boost::integer_traits::const_min) + +#else + 1 + +#endif + (MinValue >= ::boost::integer_traits::const_min) + + (MinValue >= ::boost::integer_traits::const_min) + + (MinValue >= ::boost::integer_traits::const_min) + + (MinValue >= ::boost::integer_traits::const_min) + >::least least; + typedef typename int_fast_t::type fast; + }; + + // unsigned +#if !defined(BOOST_NO_INTEGRAL_INT64_T) && defined(BOOST_HAS_LONG_LONG) + template< boost::ulong_long_type MaxValue > // minimum value to require support +#else + template< unsigned long MaxValue > // minimum value to require support +#endif + struct uint_value_t + { +#if (defined(__BORLANDC__) || defined(__CODEGEAR__)) + // It's really not clear why this workaround should be needed... shrug I guess! JM +#if defined(BOOST_NO_INTEGRAL_INT64_T) + BOOST_STATIC_CONSTANT(unsigned, which = + 1 + + (MaxValue <= ::boost::integer_traits::const_max) + + (MaxValue <= ::boost::integer_traits::const_max) + + (MaxValue <= ::boost::integer_traits::const_max) + + (MaxValue <= ::boost::integer_traits::const_max)); + typedef typename detail::int_least_helper< ::boost::uint_value_t::which>::least least; +#else // BOOST_NO_INTEGRAL_INT64_T + BOOST_STATIC_CONSTANT(unsigned, which = + 1 + + (MaxValue <= ::boost::integer_traits::const_max) + + (MaxValue <= ::boost::integer_traits::const_max) + + (MaxValue <= ::boost::integer_traits::const_max) + + (MaxValue <= ::boost::integer_traits::const_max) + + (MaxValue <= ::boost::integer_traits::const_max)); + typedef typename detail::uint_least_helper< ::boost::uint_value_t::which>::least least; +#endif // BOOST_NO_INTEGRAL_INT64_T +#else + typedef typename boost::detail::uint_least_helper + < +#if !defined(BOOST_NO_INTEGRAL_INT64_T) && defined(BOOST_HAS_LONG_LONG) + (MaxValue <= ::boost::integer_traits::const_max) + +#else + 1 + +#endif + (MaxValue <= ::boost::integer_traits::const_max) + + (MaxValue <= ::boost::integer_traits::const_max) + + (MaxValue <= ::boost::integer_traits::const_max) + + (MaxValue <= ::boost::integer_traits::const_max) + >::least least; +#endif + typedef typename int_fast_t::type fast; + }; + + +} // namespace boost + +#endif // BOOST_INTEGER_HPP diff --git a/realsense-file/3rd_party/boost/boost/integer_fwd.hpp b/realsense-file/3rd_party/boost/boost/integer_fwd.hpp new file mode 100644 index 0000000000..b1b0e70acd --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/integer_fwd.hpp @@ -0,0 +1,187 @@ +// Boost integer_fwd.hpp header file ---------------------------------------// + +// (C) Copyright Dave Abrahams and Daryle Walker 2001. Distributed under the Boost +// Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org/libs/integer for documentation. + +#ifndef BOOST_INTEGER_FWD_HPP +#define BOOST_INTEGER_FWD_HPP + +#include // for UCHAR_MAX, etc. +#include // for std::size_t + +#include // for BOOST_NO_INTRINSIC_WCHAR_T +#include // for std::numeric_limits +#include // For intmax_t + + +namespace boost +{ + +#ifdef BOOST_NO_INTEGRAL_INT64_T + typedef unsigned long static_log2_argument_type; + typedef int static_log2_result_type; + typedef long static_min_max_signed_type; + typedef unsigned long static_min_max_unsigned_type; +#else + typedef boost::uintmax_t static_min_max_unsigned_type; + typedef boost::intmax_t static_min_max_signed_type; + typedef boost::uintmax_t static_log2_argument_type; + typedef int static_log2_result_type; +#endif + +// From ------------------------------------------------// + +// Only has typedefs or using statements, with #conditionals + + +// From -----------------------------------------// + +template < class T > + class integer_traits; + +template < > + class integer_traits< bool >; + +template < > + class integer_traits< char >; + +template < > + class integer_traits< signed char >; + +template < > + class integer_traits< unsigned char >; + +#ifndef BOOST_NO_INTRINSIC_WCHAR_T +template < > + class integer_traits< wchar_t >; +#endif + +template < > + class integer_traits< short >; + +template < > + class integer_traits< unsigned short >; + +template < > + class integer_traits< int >; + +template < > + class integer_traits< unsigned int >; + +template < > + class integer_traits< long >; + +template < > + class integer_traits< unsigned long >; + +#if !defined(BOOST_NO_INTEGRAL_INT64_T) && !defined(BOOST_NO_INT64_T) && defined(BOOST_HAS_LONG_LONG) +template < > +class integer_traits< ::boost::long_long_type>; + +template < > +class integer_traits< ::boost::ulong_long_type >; +#elif !defined(BOOST_NO_INTEGRAL_INT64_T) && !defined(BOOST_NO_INT64_T) && defined(BOOST_HAS_MS_INT64) +template < > +class integer_traits<__int64>; + +template < > +class integer_traits; +#endif + + +// From ------------------------------------------------// + +template < typename LeastInt > + struct int_fast_t; + +template< int Bits > + struct int_t; + +template< int Bits > + struct uint_t; + +#if !defined(BOOST_NO_INTEGRAL_INT64_T) && defined(BOOST_HAS_LONG_LONG) + template< boost::long_long_type MaxValue > // maximum value to require support +#else + template< long MaxValue > // maximum value to require support +#endif + struct int_max_value_t; + +#if !defined(BOOST_NO_INTEGRAL_INT64_T) && defined(BOOST_HAS_LONG_LONG) + template< boost::long_long_type MinValue > // minimum value to require support +#else + template< long MinValue > // minimum value to require support +#endif + struct int_min_value_t; + +#if !defined(BOOST_NO_INTEGRAL_INT64_T) && defined(BOOST_HAS_LONG_LONG) + template< boost::ulong_long_type MaxValue > // maximum value to require support +#else + template< unsigned long MaxValue > // maximum value to require support +#endif + struct uint_value_t; + + +// From -----------------------------------// + +template < std::size_t Bit > + struct high_bit_mask_t; + +template < std::size_t Bits > + struct low_bits_mask_t; + +template < > + struct low_bits_mask_t< ::std::numeric_limits::digits >; + +// From ------------------------------------// + +template + struct static_log2; + +template <> struct static_log2<0u>; + + +// From ---------------------------------// + +template + struct static_signed_min; + +template + struct static_signed_max; + +template + struct static_unsigned_min; + +template + struct static_unsigned_max; + + +// From + +#ifdef BOOST_NO_INTEGRAL_INT64_T + typedef unsigned long static_gcd_type; +#else + typedef boost::uintmax_t static_gcd_type; +#endif + +template < static_gcd_type Value1, static_gcd_type Value2 > + struct static_gcd; +template < static_gcd_type Value1, static_gcd_type Value2 > + struct static_lcm; + + +// From + +template < typename IntegerType > + class gcd_evaluator; +template < typename IntegerType > + class lcm_evaluator; + + +} // namespace boost + + +#endif // BOOST_INTEGER_FWD_HPP diff --git a/realsense-file/3rd_party/boost/boost/integer_traits.hpp b/realsense-file/3rd_party/boost/boost/integer_traits.hpp new file mode 100644 index 0000000000..6947d01022 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/integer_traits.hpp @@ -0,0 +1,256 @@ +/* boost integer_traits.hpp header file + * + * Copyright Jens Maurer 2000 + * 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) + * + * $Id$ + * + * Idea by Beman Dawes, Ed Brey, Steve Cleary, and Nathan Myers + */ + +// See http://www.boost.org/libs/integer for documentation. + + +#ifndef BOOST_INTEGER_TRAITS_HPP +#define BOOST_INTEGER_TRAITS_HPP + +#include +#include + +// These are an implementation detail and not part of the interface +#include +// we need wchar.h for WCHAR_MAX/MIN but not all platforms provide it, +// and some may have but not ... +#if !defined(BOOST_NO_INTRINSIC_WCHAR_T) && (!defined(BOOST_NO_CWCHAR) || defined(sun) || defined(__sun) || defined(__QNX__)) +#include +#endif + +// +// We simply cannot include this header on gcc without getting copious warnings of the kind: +// +// ../../../boost/integer_traits.hpp:164:66: warning: use of C99 long long integer constant +// +// And yet there is no other reasonable implementation, so we declare this a system header +// to suppress these warnings. +// +#if defined(__GNUC__) && (__GNUC__ >= 4) +#pragma GCC system_header +#endif + +namespace boost { +template +class integer_traits : public std::numeric_limits +{ +public: + BOOST_STATIC_CONSTANT(bool, is_integral = false); +}; + +namespace detail { +template +class integer_traits_base +{ +public: + BOOST_STATIC_CONSTANT(bool, is_integral = true); + BOOST_STATIC_CONSTANT(T, const_min = min_val); + BOOST_STATIC_CONSTANT(T, const_max = max_val); +}; + +#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION +// A definition is required even for integral static constants +template +const bool integer_traits_base::is_integral; + +template +const T integer_traits_base::const_min; + +template +const T integer_traits_base::const_max; +#endif + +} // namespace detail + +template<> +class integer_traits + : public std::numeric_limits, + public detail::integer_traits_base +{ }; + +template<> +class integer_traits + : public std::numeric_limits, + public detail::integer_traits_base +{ }; + +template<> +class integer_traits + : public std::numeric_limits, + public detail::integer_traits_base +{ }; + +template<> +class integer_traits + : public std::numeric_limits, + public detail::integer_traits_base +{ }; + +#ifndef BOOST_NO_INTRINSIC_WCHAR_T +template<> +class integer_traits + : public std::numeric_limits, + // Don't trust WCHAR_MIN and WCHAR_MAX with Mac OS X's native + // library: they are wrong! +#if defined(WCHAR_MIN) && defined(WCHAR_MAX) && !defined(__APPLE__) + public detail::integer_traits_base +#elif defined(__BORLANDC__) || defined(__CYGWIN__) || defined(__MINGW32__) || (defined(__BEOS__) && defined(__GNUC__)) + // No WCHAR_MIN and WCHAR_MAX, whar_t is short and unsigned: + public detail::integer_traits_base +#elif (defined(__sgi) && (!defined(__SGI_STL_PORT) || __SGI_STL_PORT < 0x400))\ + || (defined __APPLE__)\ + || (defined(__OpenBSD__) && defined(__GNUC__))\ + || (defined(__NetBSD__) && defined(__GNUC__))\ + || (defined(__FreeBSD__) && defined(__GNUC__))\ + || (defined(__DragonFly__) && defined(__GNUC__))\ + || (defined(__hpux) && defined(__GNUC__) && (__GNUC__ == 3) && !defined(__SGI_STL_PORT)) + // No WCHAR_MIN and WCHAR_MAX, wchar_t has the same range as int. + // - SGI MIPSpro with native library + // - gcc 3.x on HP-UX + // - Mac OS X with native library + // - gcc on FreeBSD, OpenBSD and NetBSD + public detail::integer_traits_base +#else +#error No WCHAR_MIN and WCHAR_MAX present, please adjust integer_traits<> for your compiler. +#endif +{ }; +#endif // BOOST_NO_INTRINSIC_WCHAR_T + +template<> +class integer_traits + : public std::numeric_limits, + public detail::integer_traits_base +{ }; + +template<> +class integer_traits + : public std::numeric_limits, + public detail::integer_traits_base +{ }; + +template<> +class integer_traits + : public std::numeric_limits, + public detail::integer_traits_base +{ }; + +template<> +class integer_traits + : public std::numeric_limits, + public detail::integer_traits_base +{ }; + +template<> +class integer_traits + : public std::numeric_limits, + public detail::integer_traits_base +{ }; + +template<> +class integer_traits + : public std::numeric_limits, + public detail::integer_traits_base +{ }; + +#if !defined(BOOST_NO_INTEGRAL_INT64_T) && !defined(BOOST_NO_INT64_T) +#if defined(ULLONG_MAX) && defined(BOOST_HAS_LONG_LONG) + +template<> +class integer_traits< ::boost::long_long_type> + : public std::numeric_limits< ::boost::long_long_type>, + public detail::integer_traits_base< ::boost::long_long_type, LLONG_MIN, LLONG_MAX> +{ }; + +template<> +class integer_traits< ::boost::ulong_long_type> + : public std::numeric_limits< ::boost::ulong_long_type>, + public detail::integer_traits_base< ::boost::ulong_long_type, 0, ULLONG_MAX> +{ }; + +#elif defined(ULONG_LONG_MAX) && defined(BOOST_HAS_LONG_LONG) + +template<> +class integer_traits< ::boost::long_long_type> : public std::numeric_limits< ::boost::long_long_type>, public detail::integer_traits_base< ::boost::long_long_type, LONG_LONG_MIN, LONG_LONG_MAX>{ }; +template<> +class integer_traits< ::boost::ulong_long_type> + : public std::numeric_limits< ::boost::ulong_long_type>, + public detail::integer_traits_base< ::boost::ulong_long_type, 0, ULONG_LONG_MAX> +{ }; + +#elif defined(ULONGLONG_MAX) && defined(BOOST_HAS_LONG_LONG) + +template<> +class integer_traits< ::boost::long_long_type> + : public std::numeric_limits< ::boost::long_long_type>, + public detail::integer_traits_base< ::boost::long_long_type, LONGLONG_MIN, LONGLONG_MAX> +{ }; + +template<> +class integer_traits< ::boost::ulong_long_type> + : public std::numeric_limits< ::boost::ulong_long_type>, + public detail::integer_traits_base< ::boost::ulong_long_type, 0, ULONGLONG_MAX> +{ }; + +#elif defined(_LLONG_MAX) && defined(_C2) && defined(BOOST_HAS_LONG_LONG) + +template<> +class integer_traits< ::boost::long_long_type> + : public std::numeric_limits< ::boost::long_long_type>, + public detail::integer_traits_base< ::boost::long_long_type, -_LLONG_MAX - _C2, _LLONG_MAX> +{ }; + +template<> +class integer_traits< ::boost::ulong_long_type> + : public std::numeric_limits< ::boost::ulong_long_type>, + public detail::integer_traits_base< ::boost::ulong_long_type, 0, _ULLONG_MAX> +{ }; + +#elif defined(BOOST_HAS_LONG_LONG) +// +// we have long long but no constants, this happens for example with gcc in -ansi mode, +// we'll just have to work out the values for ourselves (assumes 2's compliment representation): +// +template<> +class integer_traits< ::boost::long_long_type> + : public std::numeric_limits< ::boost::long_long_type>, + public detail::integer_traits_base< ::boost::long_long_type, (1LL << (sizeof(::boost::long_long_type) * CHAR_BIT - 1)), ~(1LL << (sizeof(::boost::long_long_type) * CHAR_BIT - 1))> +{ }; + +template<> +class integer_traits< ::boost::ulong_long_type> + : public std::numeric_limits< ::boost::ulong_long_type>, + public detail::integer_traits_base< ::boost::ulong_long_type, 0, ~0uLL> +{ }; + +#elif defined(BOOST_HAS_MS_INT64) + +template<> +class integer_traits< __int64> + : public std::numeric_limits< __int64>, + public detail::integer_traits_base< __int64, _I64_MIN, _I64_MAX> +{ }; + +template<> +class integer_traits< unsigned __int64> + : public std::numeric_limits< unsigned __int64>, + public detail::integer_traits_base< unsigned __int64, 0, _UI64_MAX> +{ }; + +#endif +#endif + +} // namespace boost + +#endif /* BOOST_INTEGER_TRAITS_HPP */ + + + diff --git a/realsense-file/3rd_party/boost/boost/io/ios_state.hpp b/realsense-file/3rd_party/boost/boost/io/ios_state.hpp new file mode 100644 index 0000000000..fcbb0bb68d --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/io/ios_state.hpp @@ -0,0 +1,439 @@ +// Boost io/ios_state.hpp header file --------------------------------------// + +// Copyright 2002, 2005 Daryle Walker. Use, modification, and distribution +// are subject to the Boost Software License, Version 1.0. (See accompanying +// file LICENSE_1_0.txt or a copy at .) + +// See for the library's home page. + +#ifndef BOOST_IO_IOS_STATE_HPP +#define BOOST_IO_IOS_STATE_HPP + +#include // self include +#include + +#include // for std::ios_base, std::basic_ios, etc. +#ifndef BOOST_NO_STD_LOCALE +#include // for std::locale +#endif +#include // for std::basic_ostream +#include // for std::basic_streambuf +#include // for std::char_traits + + +namespace boost +{ +namespace io +{ + + +// Basic stream state saver class declarations -----------------------------// + +class ios_flags_saver +{ +public: + typedef ::std::ios_base state_type; + typedef ::std::ios_base::fmtflags aspect_type; + + explicit ios_flags_saver( state_type &s ) + : s_save_( s ), a_save_( s.flags() ) + {} + ios_flags_saver( state_type &s, aspect_type const &a ) + : s_save_( s ), a_save_( s.flags(a) ) + {} + ~ios_flags_saver() + { this->restore(); } + + void restore() + { s_save_.flags( a_save_ ); } + +private: + state_type & s_save_; + aspect_type const a_save_; + + ios_flags_saver& operator=(const ios_flags_saver&); +}; + +class ios_precision_saver +{ +public: + typedef ::std::ios_base state_type; + typedef ::std::streamsize aspect_type; + + explicit ios_precision_saver( state_type &s ) + : s_save_( s ), a_save_( s.precision() ) + {} + ios_precision_saver( state_type &s, aspect_type const &a ) + : s_save_( s ), a_save_( s.precision(a) ) + {} + ~ios_precision_saver() + { this->restore(); } + + void restore() + { s_save_.precision( a_save_ ); } + +private: + state_type & s_save_; + aspect_type const a_save_; + + ios_precision_saver& operator=(const ios_precision_saver&); +}; + +class ios_width_saver +{ +public: + typedef ::std::ios_base state_type; + typedef ::std::streamsize aspect_type; + + explicit ios_width_saver( state_type &s ) + : s_save_( s ), a_save_( s.width() ) + {} + ios_width_saver( state_type &s, aspect_type const &a ) + : s_save_( s ), a_save_( s.width(a) ) + {} + ~ios_width_saver() + { this->restore(); } + + void restore() + { s_save_.width( a_save_ ); } + +private: + state_type & s_save_; + aspect_type const a_save_; + ios_width_saver& operator=(const ios_width_saver&); +}; + + +// Advanced stream state saver class template declarations -----------------// + +template < typename Ch, class Tr > +class basic_ios_iostate_saver +{ +public: + typedef ::std::basic_ios state_type; + typedef ::std::ios_base::iostate aspect_type; + + explicit basic_ios_iostate_saver( state_type &s ) + : s_save_( s ), a_save_( s.rdstate() ) + {} + basic_ios_iostate_saver( state_type &s, aspect_type const &a ) + : s_save_( s ), a_save_( s.rdstate() ) + { s.clear(a); } + ~basic_ios_iostate_saver() + { this->restore(); } + + void restore() + { s_save_.clear( a_save_ ); } + +private: + state_type & s_save_; + aspect_type const a_save_; + basic_ios_iostate_saver& operator=(const basic_ios_iostate_saver&); +}; + +template < typename Ch, class Tr > +class basic_ios_exception_saver +{ +public: + typedef ::std::basic_ios state_type; + typedef ::std::ios_base::iostate aspect_type; + + explicit basic_ios_exception_saver( state_type &s ) + : s_save_( s ), a_save_( s.exceptions() ) + {} +#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x582)) + basic_ios_exception_saver( state_type &s, aspect_type a ) +#else + basic_ios_exception_saver( state_type &s, aspect_type const &a ) +#endif + : s_save_( s ), a_save_( s.exceptions() ) + { s.exceptions(a); } + ~basic_ios_exception_saver() + { this->restore(); } + + void restore() + { s_save_.exceptions( a_save_ ); } + +private: + state_type & s_save_; + aspect_type const a_save_; + basic_ios_exception_saver& operator=(const basic_ios_exception_saver&); +}; + +template < typename Ch, class Tr > +class basic_ios_tie_saver +{ +public: + typedef ::std::basic_ios state_type; + typedef ::std::basic_ostream * aspect_type; + + explicit basic_ios_tie_saver( state_type &s ) + : s_save_( s ), a_save_( s.tie() ) + {} + basic_ios_tie_saver( state_type &s, aspect_type const &a ) + : s_save_( s ), a_save_( s.tie(a) ) + {} + ~basic_ios_tie_saver() + { this->restore(); } + + void restore() + { s_save_.tie( a_save_ ); } + +private: + state_type & s_save_; + aspect_type const a_save_; + basic_ios_tie_saver& operator=(const basic_ios_tie_saver&); +}; + +template < typename Ch, class Tr > +class basic_ios_rdbuf_saver +{ +public: + typedef ::std::basic_ios state_type; + typedef ::std::basic_streambuf * aspect_type; + + explicit basic_ios_rdbuf_saver( state_type &s ) + : s_save_( s ), a_save_( s.rdbuf() ) + {} + basic_ios_rdbuf_saver( state_type &s, aspect_type const &a ) + : s_save_( s ), a_save_( s.rdbuf(a) ) + {} + ~basic_ios_rdbuf_saver() + { this->restore(); } + + void restore() + { s_save_.rdbuf( a_save_ ); } + +private: + state_type & s_save_; + aspect_type const a_save_; + basic_ios_rdbuf_saver& operator=(const basic_ios_rdbuf_saver&); +}; + +template < typename Ch, class Tr > +class basic_ios_fill_saver +{ +public: + typedef ::std::basic_ios state_type; + typedef typename state_type::char_type aspect_type; + + explicit basic_ios_fill_saver( state_type &s ) + : s_save_( s ), a_save_( s.fill() ) + {} + basic_ios_fill_saver( state_type &s, aspect_type const &a ) + : s_save_( s ), a_save_( s.fill(a) ) + {} + ~basic_ios_fill_saver() + { this->restore(); } + + void restore() + { s_save_.fill( a_save_ ); } + +private: + state_type & s_save_; + aspect_type const a_save_; + basic_ios_fill_saver& operator=(const basic_ios_fill_saver&); +}; + +#ifndef BOOST_NO_STD_LOCALE +template < typename Ch, class Tr > +class basic_ios_locale_saver +{ +public: + typedef ::std::basic_ios state_type; + typedef ::std::locale aspect_type; + + explicit basic_ios_locale_saver( state_type &s ) + : s_save_( s ), a_save_( s.getloc() ) + {} + basic_ios_locale_saver( state_type &s, aspect_type const &a ) + : s_save_( s ), a_save_( s.imbue(a) ) + {} + ~basic_ios_locale_saver() + { this->restore(); } + + void restore() + { s_save_.imbue( a_save_ ); } + +private: + state_type & s_save_; + aspect_type const a_save_; + basic_ios_locale_saver& operator=(const basic_ios_locale_saver&); +}; +#endif + + +// User-defined stream state saver class declarations ----------------------// + +class ios_iword_saver +{ +public: + typedef ::std::ios_base state_type; + typedef int index_type; + typedef long aspect_type; + + explicit ios_iword_saver( state_type &s, index_type i ) + : s_save_( s ), a_save_( s.iword(i) ), i_save_( i ) + {} + ios_iword_saver( state_type &s, index_type i, aspect_type const &a ) + : s_save_( s ), a_save_( s.iword(i) ), i_save_( i ) + { s.iword(i) = a; } + ~ios_iword_saver() + { this->restore(); } + + void restore() + { s_save_.iword( i_save_ ) = a_save_; } + +private: + state_type & s_save_; + aspect_type const a_save_; + index_type const i_save_; + + ios_iword_saver& operator=(const ios_iword_saver&); +}; + +class ios_pword_saver +{ +public: + typedef ::std::ios_base state_type; + typedef int index_type; + typedef void * aspect_type; + + explicit ios_pword_saver( state_type &s, index_type i ) + : s_save_( s ), a_save_( s.pword(i) ), i_save_( i ) + {} + ios_pword_saver( state_type &s, index_type i, aspect_type const &a ) + : s_save_( s ), a_save_( s.pword(i) ), i_save_( i ) + { s.pword(i) = a; } + ~ios_pword_saver() + { this->restore(); } + + void restore() + { s_save_.pword( i_save_ ) = a_save_; } + +private: + state_type & s_save_; + aspect_type const a_save_; + index_type const i_save_; + + ios_pword_saver operator=(const ios_pword_saver&); +}; + + +// Combined stream state saver class (template) declarations ---------------// + +class ios_base_all_saver +{ +public: + typedef ::std::ios_base state_type; + + explicit ios_base_all_saver( state_type &s ) + : s_save_( s ), a1_save_( s.flags() ), a2_save_( s.precision() ) + , a3_save_( s.width() ) + {} + + ~ios_base_all_saver() + { this->restore(); } + + void restore() + { + s_save_.width( a3_save_ ); + s_save_.precision( a2_save_ ); + s_save_.flags( a1_save_ ); + } + +private: + state_type & s_save_; + state_type::fmtflags const a1_save_; + ::std::streamsize const a2_save_; + ::std::streamsize const a3_save_; + + ios_base_all_saver& operator=(const ios_base_all_saver&); +}; + +template < typename Ch, class Tr > +class basic_ios_all_saver +{ +public: + typedef ::std::basic_ios state_type; + + explicit basic_ios_all_saver( state_type &s ) + : s_save_( s ), a1_save_( s.flags() ), a2_save_( s.precision() ) + , a3_save_( s.width() ), a4_save_( s.rdstate() ) + , a5_save_( s.exceptions() ), a6_save_( s.tie() ) + , a7_save_( s.rdbuf() ), a8_save_( s.fill() ) + #ifndef BOOST_NO_STD_LOCALE + , a9_save_( s.getloc() ) + #endif + {} + + ~basic_ios_all_saver() + { this->restore(); } + + void restore() + { + #ifndef BOOST_NO_STD_LOCALE + s_save_.imbue( a9_save_ ); + #endif + s_save_.fill( a8_save_ ); + s_save_.rdbuf( a7_save_ ); + s_save_.tie( a6_save_ ); + s_save_.exceptions( a5_save_ ); + s_save_.clear( a4_save_ ); + s_save_.width( a3_save_ ); + s_save_.precision( a2_save_ ); + s_save_.flags( a1_save_ ); + } + +private: + state_type & s_save_; + typename state_type::fmtflags const a1_save_; + ::std::streamsize const a2_save_; + ::std::streamsize const a3_save_; + typename state_type::iostate const a4_save_; + typename state_type::iostate const a5_save_; + ::std::basic_ostream * const a6_save_; + ::std::basic_streambuf * const a7_save_; + typename state_type::char_type const a8_save_; + #ifndef BOOST_NO_STD_LOCALE + ::std::locale const a9_save_; + #endif + + basic_ios_all_saver& operator=(const basic_ios_all_saver&); +}; + +class ios_all_word_saver +{ +public: + typedef ::std::ios_base state_type; + typedef int index_type; + + ios_all_word_saver( state_type &s, index_type i ) + : s_save_( s ), i_save_( i ), a1_save_( s.iword(i) ) + , a2_save_( s.pword(i) ) + {} + + ~ios_all_word_saver() + { this->restore(); } + + void restore() + { + s_save_.pword( i_save_ ) = a2_save_; + s_save_.iword( i_save_ ) = a1_save_; + } + +private: + state_type & s_save_; + index_type const i_save_; + long const a1_save_; + void * const a2_save_; + + ios_all_word_saver& operator=(const ios_all_word_saver&); +}; + + +} // namespace io +} // namespace boost + + +#endif // BOOST_IO_IOS_STATE_HPP diff --git a/realsense-file/3rd_party/boost/boost/io_fwd.hpp b/realsense-file/3rd_party/boost/boost/io_fwd.hpp new file mode 100644 index 0000000000..0ed46ea104 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/io_fwd.hpp @@ -0,0 +1,67 @@ +// Boost io_fwd.hpp header file --------------------------------------------// + +// Copyright 2002 Daryle Walker. Use, modification, and distribution are subject +// to the Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or a copy at .) + +// See for the library's home page. + +#ifndef BOOST_IO_FWD_HPP +#define BOOST_IO_FWD_HPP + +#include // for std::char_traits (declaration) + + +namespace boost +{ +namespace io +{ + + +// From -------------------------------------------// + +class ios_flags_saver; +class ios_precision_saver; +class ios_width_saver; +class ios_base_all_saver; + +template < typename Ch, class Tr = ::std::char_traits > + class basic_ios_iostate_saver; +template < typename Ch, class Tr = ::std::char_traits > + class basic_ios_exception_saver; +template < typename Ch, class Tr = ::std::char_traits > + class basic_ios_tie_saver; +template < typename Ch, class Tr = ::std::char_traits > + class basic_ios_rdbuf_saver; +template < typename Ch, class Tr = ::std::char_traits > + class basic_ios_fill_saver; +template < typename Ch, class Tr = ::std::char_traits > + class basic_ios_locale_saver; +template < typename Ch, class Tr = ::std::char_traits > + class basic_ios_all_saver; + +typedef basic_ios_iostate_saver ios_iostate_saver; +typedef basic_ios_iostate_saver wios_iostate_saver; +typedef basic_ios_exception_saver ios_exception_saver; +typedef basic_ios_exception_saver wios_exception_saver; +typedef basic_ios_tie_saver ios_tie_saver; +typedef basic_ios_tie_saver wios_tie_saver; +typedef basic_ios_rdbuf_saver ios_rdbuf_saver; +typedef basic_ios_rdbuf_saver wios_rdbuf_saver; +typedef basic_ios_fill_saver ios_fill_saver; +typedef basic_ios_fill_saver wios_fill_saver; +typedef basic_ios_locale_saver ios_locale_saver; +typedef basic_ios_locale_saver wios_locale_saver; +typedef basic_ios_all_saver ios_all_saver; +typedef basic_ios_all_saver wios_all_saver; + +class ios_iword_saver; +class ios_pword_saver; +class ios_all_word_saver; + + +} // namespace io +} // namespace boost + + +#endif // BOOST_IO_FWD_HPP diff --git a/realsense-file/3rd_party/boost/boost/iterator.hpp b/realsense-file/3rd_party/boost/boost/iterator.hpp new file mode 100644 index 0000000000..8d7bcccd8a --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/iterator.hpp @@ -0,0 +1,20 @@ +// (C) Copyright Beman Dawes 2000. 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_ITERATOR_HPP +#define BOOST_ITERATOR_HPP + +// This header is obsolete and will be deprecated. + +#include +#include // std::ptrdiff_t + +namespace boost +{ + +using std::iterator; + +} // namespace boost + +#endif // BOOST_ITERATOR_HPP diff --git a/realsense-file/3rd_party/boost/boost/iterator/detail/config_def.hpp b/realsense-file/3rd_party/boost/boost/iterator/detail/config_def.hpp new file mode 100644 index 0000000000..4ec35c7df2 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/iterator/detail/config_def.hpp @@ -0,0 +1,128 @@ +// (C) Copyright David Abrahams 2002. +// (C) Copyright Jeremy Siek 2002. +// (C) Copyright Thomas Witt 2002. +// 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) + +// no include guard multiple inclusion intended + +// +// This is a temporary workaround until the bulk of this is +// available in boost config. +// 23/02/03 thw +// + +#include // for prior +#include + +#ifdef BOOST_ITERATOR_CONFIG_DEF +# error you have nested config_def #inclusion. +#else +# define BOOST_ITERATOR_CONFIG_DEF +#endif + +// We enable this always now. Otherwise, the simple case in +// libs/iterator/test/constant_iterator_arrow.cpp fails to compile +// because the operator-> return is improperly deduced as a non-const +// pointer. +#if 1 || defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \ + || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x531)) + +// Recall that in general, compilers without partial specialization +// can't strip constness. Consider counting_iterator, which normally +// passes a const Value to iterator_facade. As a result, any code +// which makes a std::vector of the iterator's value_type will fail +// when its allocator declares functions overloaded on reference and +// const_reference (the same type). +// +// Furthermore, Borland 5.5.1 drops constness in enough ways that we +// end up using a proxy for operator[] when we otherwise shouldn't. +// Using reference constness gives it an extra hint that it can +// return the value_type from operator[] directly, but is not +// strictly necessary. Not sure how best to resolve this one. + +# define BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY 1 + +#endif + +#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x5A0)) \ + || (BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION, <= 700) && defined(_MSC_VER)) \ + || BOOST_WORKAROUND(__DECCXX_VER, BOOST_TESTED_AT(60590042)) \ + || BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x590)) + +# define BOOST_NO_LVALUE_RETURN_DETECTION + +# if 0 // test code + struct v {}; + + typedef char (&no)[3]; + + template + no foo(T const&, ...); + + template + char foo(T&, int); + + + struct value_iterator + { + v operator*() const; + }; + + template + struct lvalue_deref_helper + { + static T& x; + enum { value = (sizeof(foo(*x,0)) == 1) }; + }; + + int z2[(lvalue_deref_helper::value == 1) ? 1 : -1]; + int z[(lvalue_deref_helper::value) == 1 ? -1 : 1 ]; +# endif + +#endif + +#if BOOST_WORKAROUND(__MWERKS__, <=0x2407) +# define BOOST_NO_IS_CONVERTIBLE // "is_convertible doesn't work for simple types" +#endif + +#if BOOST_WORKAROUND(__GNUC__, == 3) && BOOST_WORKAROUND(__GNUC_MINOR__, < 4) && !defined(__EDG_VERSION__) \ + || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551)) +# define BOOST_NO_IS_CONVERTIBLE_TEMPLATE // The following program fails to compile: + +# if 0 // test code + #include + template + struct foo + { + foo(T); + + template + foo(foo const& other) : p(other.p) { } + + T p; + }; + + bool x = boost::is_convertible, foo >::value; +# endif + +#endif + + +#if !defined(BOOST_MSVC) && (defined(BOOST_NO_SFINAE) || defined(BOOST_NO_IS_CONVERTIBLE) || defined(BOOST_NO_IS_CONVERTIBLE_TEMPLATE)) +# define BOOST_NO_STRICT_ITERATOR_INTEROPERABILITY +#endif + +# if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) + +// GCC-2.95 (obsolete) eagerly instantiates templated constructors and conversion +// operators in convertibility checks, causing premature errors. +// +// Borland's problems are harder to diagnose due to lack of an +// instantiation stack backtrace. They may be due in part to the fact +// that it drops cv-qualification willy-nilly in templates. +# define BOOST_NO_ONE_WAY_ITERATOR_INTEROP +# endif + +// no include guard; multiple inclusion intended diff --git a/realsense-file/3rd_party/boost/boost/iterator/detail/config_undef.hpp b/realsense-file/3rd_party/boost/boost/iterator/detail/config_undef.hpp new file mode 100644 index 0000000000..070efbbcd7 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/iterator/detail/config_undef.hpp @@ -0,0 +1,24 @@ +// (C) Copyright Thomas Witt 2002. +// 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) + +// no include guard multiple inclusion intended + +// +// This is a temporary workaround until the bulk of this is +// available in boost config. +// 23/02/03 thw +// + +#undef BOOST_NO_IS_CONVERTIBLE +#undef BOOST_NO_IS_CONVERTIBLE_TEMPLATE +#undef BOOST_NO_STRICT_ITERATOR_INTEROPERABILITY +#undef BOOST_NO_LVALUE_RETURN_DETECTION +#undef BOOST_NO_ONE_WAY_ITERATOR_INTEROP + +#ifdef BOOST_ITERATOR_CONFIG_DEF +# undef BOOST_ITERATOR_CONFIG_DEF +#else +# error missing or nested #include config_def +#endif diff --git a/realsense-file/3rd_party/boost/boost/iterator/detail/enable_if.hpp b/realsense-file/3rd_party/boost/boost/iterator/detail/enable_if.hpp new file mode 100644 index 0000000000..c0da4b4839 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/iterator/detail/enable_if.hpp @@ -0,0 +1,83 @@ +// (C) Copyright David Abrahams 2002. +// (C) Copyright Jeremy Siek 2002. +// (C) Copyright Thomas Witt 2002. +// 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_ENABLE_IF_23022003THW_HPP +#define BOOST_ENABLE_IF_23022003THW_HPP + +#include +#include + +#include + +// +// Boost iterators uses its own enable_if cause we need +// special semantics for deficient compilers. +// 23/02/03 thw +// + +namespace boost +{ + + namespace iterators + { + // + // Base machinery for all kinds of enable if + // + template + struct enabled + { + template + struct base + { + typedef T type; + }; + }; + + // + // For compilers that don't support "Substitution Failure Is Not An Error" + // enable_if falls back to always enabled. See comments + // on operator implementation for consequences. + // + template<> + struct enabled + { + template + struct base + { +#ifdef BOOST_NO_SFINAE + + typedef T type; + + // This way to do it would give a nice error message containing + // invalid overload, but has the big disadvantage that + // there is no reference to user code in the error message. + // + // struct invalid_overload; + // typedef invalid_overload type; + // +#endif + }; + }; + + + template + struct enable_if +# if !defined(BOOST_NO_SFINAE) && !defined(BOOST_NO_IS_CONVERTIBLE) + : enabled<(Cond::value)>::template base +# else + : mpl::identity +# endif + { + }; + + } // namespace iterators + +} // namespace boost + +#include + +#endif // BOOST_ENABLE_IF_23022003THW_HPP diff --git a/realsense-file/3rd_party/boost/boost/iterator/detail/facade_iterator_category.hpp b/realsense-file/3rd_party/boost/boost/iterator/detail/facade_iterator_category.hpp new file mode 100644 index 0000000000..73f5ff9f7c --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/iterator/detail/facade_iterator_category.hpp @@ -0,0 +1,193 @@ +// Copyright David Abrahams 2003. Use, modification and distribution is +// subject to 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 FACADE_ITERATOR_CATEGORY_DWA20031118_HPP +# define FACADE_ITERATOR_CATEGORY_DWA20031118_HPP + +# include + +# include // used in iterator_tag inheritance logic +# include +# include +# include +# include +# include + +# include +# include +# include +# include + +# include + +# include // try to keep this last + +# ifdef BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY +# include +# endif + +// +// iterator_category deduction for iterator_facade +// + +namespace boost { +namespace iterators { + +// forward declaration +struct use_default; + +namespace detail { + +struct input_output_iterator_tag + : std::input_iterator_tag +{ + // Using inheritance for only input_iterator_tag helps to avoid + // ambiguities when a stdlib implementation dispatches on a + // function which is overloaded on both input_iterator_tag and + // output_iterator_tag, as STLPort does, in its __valid_range + // function. I claim it's better to avoid the ambiguity in these + // cases. + operator std::output_iterator_tag() const + { + return std::output_iterator_tag(); + } +}; + +// +// True iff the user has explicitly disabled writability of this +// iterator. Pass the iterator_facade's Value parameter and its +// nested ::reference type. +// +template +struct iterator_writability_disabled +# ifdef BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY // Adding Thomas' logic? + : mpl::or_< + is_const + , boost::detail::indirect_traits::is_reference_to_const + , is_const + > +# else + : is_const +# endif +{}; + + +// +// Convert an iterator_facade's traversal category, Value parameter, +// and ::reference type to an appropriate old-style category. +// +// Due to changeset 21683, this now never results in a category convertible +// to output_iterator_tag. +// +// Change at: https://svn.boost.org/trac/boost/changeset/21683 +template +struct iterator_facade_default_category + : mpl::eval_if< + mpl::and_< + is_reference + , is_convertible + > + , mpl::eval_if< + is_convertible + , mpl::identity + , mpl::if_< + is_convertible + , std::bidirectional_iterator_tag + , std::forward_iterator_tag + > + > + , typename mpl::eval_if< + mpl::and_< + is_convertible + + // check for readability + , is_convertible + > + , mpl::identity + , mpl::identity + > + > +{ +}; + +// True iff T is convertible to an old-style iterator category. +template +struct is_iterator_category + : mpl::or_< + is_convertible + , is_convertible + > +{ +}; + +template +struct is_iterator_traversal + : is_convertible +{}; + +// +// A composite iterator_category tag convertible to Category (a pure +// old-style category) and Traversal (a pure traversal tag). +// Traversal must be a strict increase of the traversal power given by +// Category. +// +template +struct iterator_category_with_traversal + : Category, Traversal +{ + // Make sure this isn't used to build any categories where + // convertibility to Traversal is redundant. Should just use the + // Category element in that case. + BOOST_MPL_ASSERT_NOT(( + is_convertible< + typename iterator_category_to_traversal::type + , Traversal + >)); + + BOOST_MPL_ASSERT((is_iterator_category)); + BOOST_MPL_ASSERT_NOT((is_iterator_category)); + BOOST_MPL_ASSERT_NOT((is_iterator_traversal)); +# if !BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1310)) + BOOST_MPL_ASSERT((is_iterator_traversal)); +# endif +}; + +// Computes an iterator_category tag whose traversal is Traversal and +// which is appropriate for an iterator +template +struct facade_iterator_category_impl +{ + BOOST_MPL_ASSERT_NOT((is_iterator_category)); + + typedef typename iterator_facade_default_category< + Traversal,ValueParam,Reference + >::type category; + + typedef typename mpl::if_< + is_same< + Traversal + , typename iterator_category_to_traversal::type + > + , category + , iterator_category_with_traversal + >::type type; +}; + +// +// Compute an iterator_category for iterator_facade +// +template +struct facade_iterator_category + : mpl::eval_if< + is_iterator_category + , mpl::identity // old-style categories are fine as-is + , facade_iterator_category_impl + > +{ +}; + +}}} // namespace boost::iterators::detail + +# include + +#endif // FACADE_ITERATOR_CATEGORY_DWA20031118_HPP diff --git a/realsense-file/3rd_party/boost/boost/iterator/interoperable.hpp b/realsense-file/3rd_party/boost/boost/iterator/interoperable.hpp new file mode 100644 index 0000000000..00cfb250f6 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/iterator/interoperable.hpp @@ -0,0 +1,54 @@ +// (C) Copyright David Abrahams 2002. +// (C) Copyright Jeremy Siek 2002. +// (C) Copyright Thomas Witt 2002. +// 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_INTEROPERABLE_23022003THW_HPP +# define BOOST_INTEROPERABLE_23022003THW_HPP + +# include +# include + +# include + +# include // must appear last + +namespace boost { +namespace iterators { + + // + // Meta function that determines whether two + // iterator types are considered interoperable. + // + // Two iterator types A,B are considered interoperable if either + // A is convertible to B or vice versa. + // This interoperability definition is in sync with the + // standards requirements on constant/mutable container + // iterators (23.1 [lib.container.requirements]). + // + // For compilers that don't support is_convertible + // is_interoperable gives false positives. See comments + // on operator implementation for consequences. + // + template + struct is_interoperable +# ifdef BOOST_NO_STRICT_ITERATOR_INTEROPERABILITY + : mpl::true_ +# else + : mpl::or_< + is_convertible< A, B > + , is_convertible< B, A > > +# endif + { + }; + +} // namespace iterators + +using iterators::is_interoperable; + +} // namespace boost + +# include + +#endif // BOOST_INTEROPERABLE_23022003THW_HPP diff --git a/realsense-file/3rd_party/boost/boost/iterator/iterator_adaptor.hpp b/realsense-file/3rd_party/boost/boost/iterator/iterator_adaptor.hpp new file mode 100644 index 0000000000..e0ed8b6cc6 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/iterator/iterator_adaptor.hpp @@ -0,0 +1,360 @@ +// (C) Copyright David Abrahams 2002. +// (C) Copyright Jeremy Siek 2002. +// (C) Copyright Thomas Witt 2002. +// 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_ITERATOR_ADAPTOR_23022003THW_HPP +#define BOOST_ITERATOR_ADAPTOR_23022003THW_HPP + +#include +#include +#include + +#include +#include +#include + +#include +#include +#include + +#include +#include + +#ifdef BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY +# include +#endif + +#include +#include + +#include + +namespace boost { +namespace iterators { + + // Used as a default template argument internally, merely to + // indicate "use the default", this can also be passed by users + // explicitly in order to specify that the default should be used. + struct use_default; + +} // namespace iterators + +using iterators::use_default; + +// the incompleteness of use_default causes massive problems for +// is_convertible (naturally). This workaround is fortunately not +// needed for vc6/vc7. +template +struct is_convertible + : mpl::false_ {}; + +namespace iterators { + + namespace detail + { + + // + // Result type used in enable_if_convertible meta function. + // This can be an incomplete type, as only pointers to + // enable_if_convertible< ... >::type are used. + // We could have used void for this, but conversion to + // void* is just to easy. + // + struct enable_type; + } + + + // + // enable_if for use in adapted iterators constructors. + // + // In order to provide interoperability between adapted constant and + // mutable iterators, adapted iterators will usually provide templated + // conversion constructors of the following form + // + // template + // class adapted_iterator : + // public iterator_adaptor< adapted_iterator, Iterator > + // { + // public: + // + // ... + // + // template + // adapted_iterator( + // OtherIterator const& it + // , typename enable_if_convertible::type* = 0); + // + // ... + // }; + // + // enable_if_convertible is used to remove those overloads from the overload + // set that cannot be instantiated. For all practical purposes only overloads + // for constant/mutable interaction will remain. This has the advantage that + // meta functions like boost::is_convertible do not return false positives, + // as they can only look at the signature of the conversion constructor + // and not at the actual instantiation. + // + // enable_if_interoperable can be safely used in user code. It falls back to + // always enabled for compilers that don't support enable_if or is_convertible. + // There is no need for compiler specific workarounds in user code. + // + // The operators implementation relies on boost::is_convertible not returning + // false positives for user/library defined iterator types. See comments + // on operator implementation for consequences. + // +# if defined(BOOST_NO_IS_CONVERTIBLE) || defined(BOOST_NO_SFINAE) + + template + struct enable_if_convertible + { + typedef boost::iterators::detail::enable_type type; + }; + +# elif BOOST_WORKAROUND(_MSC_FULL_VER, BOOST_TESTED_AT(13102292)) + + // For some reason vc7.1 needs us to "cut off" instantiation + // of is_convertible in a few cases. + template + struct enable_if_convertible + : iterators::enable_if< + mpl::or_< + is_same + , is_convertible + > + , boost::iterators::detail::enable_type + > + {}; + +# else + + template + struct enable_if_convertible + : iterators::enable_if< + is_convertible + , boost::iterators::detail::enable_type + > + {}; + +# endif + + // + // Default template argument handling for iterator_adaptor + // + namespace detail + { + // If T is use_default, return the result of invoking + // DefaultNullaryFn, otherwise return T. + template + struct ia_dflt_help + : mpl::eval_if< + is_same + , DefaultNullaryFn + , mpl::identity + > + { + }; + + // A metafunction which computes an iterator_adaptor's base class, + // a specialization of iterator_facade. + template < + class Derived + , class Base + , class Value + , class Traversal + , class Reference + , class Difference + > + struct iterator_adaptor_base + { + typedef iterator_facade< + Derived + +# ifdef BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY + , typename boost::iterators::detail::ia_dflt_help< + Value + , mpl::eval_if< + is_same + , iterator_value + , remove_reference + > + >::type +# else + , typename boost::iterators::detail::ia_dflt_help< + Value, iterator_value + >::type +# endif + + , typename boost::iterators::detail::ia_dflt_help< + Traversal + , iterator_traversal + >::type + + , typename boost::iterators::detail::ia_dflt_help< + Reference + , mpl::eval_if< + is_same + , iterator_reference + , add_reference + > + >::type + + , typename boost::iterators::detail::ia_dflt_help< + Difference, iterator_difference + >::type + > + type; + }; + + // workaround for aC++ CR JAGaf33512 + template + inline void iterator_adaptor_assert_traversal () + { + BOOST_STATIC_ASSERT((is_convertible::value)); + } + } + + // + // Iterator Adaptor + // + // The parameter ordering changed slightly with respect to former + // versions of iterator_adaptor The idea is that when the user needs + // to fiddle with the reference type it is highly likely that the + // iterator category has to be adjusted as well. Any of the + // following four template arguments may be ommitted or explicitly + // replaced by use_default. + // + // Value - if supplied, the value_type of the resulting iterator, unless + // const. If const, a conforming compiler strips constness for the + // value_type. If not supplied, iterator_traits::value_type is used + // + // Category - the traversal category of the resulting iterator. If not + // supplied, iterator_traversal::type is used. + // + // Reference - the reference type of the resulting iterator, and in + // particular, the result type of operator*(). If not supplied but + // Value is supplied, Value& is used. Otherwise + // iterator_traits::reference is used. + // + // Difference - the difference_type of the resulting iterator. If not + // supplied, iterator_traits::difference_type is used. + // + template < + class Derived + , class Base + , class Value = use_default + , class Traversal = use_default + , class Reference = use_default + , class Difference = use_default + > + class iterator_adaptor + : public boost::iterators::detail::iterator_adaptor_base< + Derived, Base, Value, Traversal, Reference, Difference + >::type + { + friend class iterator_core_access; + + protected: + typedef typename boost::iterators::detail::iterator_adaptor_base< + Derived, Base, Value, Traversal, Reference, Difference + >::type super_t; + public: + iterator_adaptor() {} + + explicit iterator_adaptor(Base const &iter) + : m_iterator(iter) + { + } + + typedef Base base_type; + + Base const& base() const + { return m_iterator; } + + protected: + // for convenience in derived classes + typedef iterator_adaptor iterator_adaptor_; + + // + // lvalue access to the Base object for Derived + // + Base const& base_reference() const + { return m_iterator; } + + Base& base_reference() + { return m_iterator; } + + private: + // + // Core iterator interface for iterator_facade. This is private + // to prevent temptation for Derived classes to use it, which + // will often result in an error. Derived classes should use + // base_reference(), above, to get direct access to m_iterator. + // + typename super_t::reference dereference() const + { return *m_iterator; } + + template < + class OtherDerived, class OtherIterator, class V, class C, class R, class D + > + bool equal(iterator_adaptor const& x) const + { + // Maybe readd with same_distance + // BOOST_STATIC_ASSERT( + // (detail::same_category_and_difference::value) + // ); + return m_iterator == x.base(); + } + + typedef typename iterator_category_to_traversal< + typename super_t::iterator_category + >::type my_traversal; + +# define BOOST_ITERATOR_ADAPTOR_ASSERT_TRAVERSAL(cat) \ + boost::iterators::detail::iterator_adaptor_assert_traversal(); + + void advance(typename super_t::difference_type n) + { + BOOST_ITERATOR_ADAPTOR_ASSERT_TRAVERSAL(random_access_traversal_tag) + m_iterator += n; + } + + void increment() { ++m_iterator; } + + void decrement() + { + BOOST_ITERATOR_ADAPTOR_ASSERT_TRAVERSAL(bidirectional_traversal_tag) + --m_iterator; + } + + template < + class OtherDerived, class OtherIterator, class V, class C, class R, class D + > + typename super_t::difference_type distance_to( + iterator_adaptor const& y) const + { + BOOST_ITERATOR_ADAPTOR_ASSERT_TRAVERSAL(random_access_traversal_tag) + // Maybe readd with same_distance + // BOOST_STATIC_ASSERT( + // (detail::same_category_and_difference::value) + // ); + return y.base() - m_iterator; + } + +# undef BOOST_ITERATOR_ADAPTOR_ASSERT_TRAVERSAL + + private: // data members + Base m_iterator; + }; + +} // namespace iterators + +using iterators::iterator_adaptor; +using iterators::enable_if_convertible; + +} // namespace boost + +#include + +#endif // BOOST_ITERATOR_ADAPTOR_23022003THW_HPP diff --git a/realsense-file/3rd_party/boost/boost/iterator/iterator_categories.hpp b/realsense-file/3rd_party/boost/boost/iterator/iterator_categories.hpp new file mode 100644 index 0000000000..b479facbd4 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/iterator/iterator_categories.hpp @@ -0,0 +1,222 @@ +// (C) Copyright Jeremy Siek 2002. +// 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_ITERATOR_CATEGORIES_HPP +# define BOOST_ITERATOR_CATEGORIES_HPP + +# include +# include +# include + +# include + +# include +# include +# include +# include + +# include + +# include + +namespace boost { +namespace iterators { + +// +// Traversal Categories +// + +struct no_traversal_tag {}; + +struct incrementable_traversal_tag + : no_traversal_tag +{ +// incrementable_traversal_tag() {} +// incrementable_traversal_tag(std::output_iterator_tag const&) {}; +}; + +struct single_pass_traversal_tag + : incrementable_traversal_tag +{ +// single_pass_traversal_tag() {} +// single_pass_traversal_tag(std::input_iterator_tag const&) {}; +}; + +struct forward_traversal_tag + : single_pass_traversal_tag +{ +// forward_traversal_tag() {} +// forward_traversal_tag(std::forward_iterator_tag const&) {}; +}; + +struct bidirectional_traversal_tag + : forward_traversal_tag +{ +// bidirectional_traversal_tag() {}; +// bidirectional_traversal_tag(std::bidirectional_iterator_tag const&) {}; +}; + +struct random_access_traversal_tag + : bidirectional_traversal_tag +{ +// random_access_traversal_tag() {}; +// random_access_traversal_tag(std::random_access_iterator_tag const&) {}; +}; + +namespace detail +{ + // + // Convert a "strictly old-style" iterator category to a traversal + // tag. This is broken out into a separate metafunction to reduce + // the cost of instantiating iterator_category_to_traversal, below, + // for new-style types. + // + template + struct old_category_to_traversal + : mpl::eval_if< + is_convertible + , mpl::identity + , mpl::eval_if< + is_convertible + , mpl::identity + , mpl::eval_if< + is_convertible + , mpl::identity + , mpl::eval_if< + is_convertible + , mpl::identity + , mpl::eval_if< + is_convertible + , mpl::identity + , void + > + > + > + > + > + {}; + +} // namespace detail + +// +// Convert an iterator category into a traversal tag +// +template +struct iterator_category_to_traversal + : mpl::eval_if< // if already convertible to a traversal tag, we're done. + is_convertible + , mpl::identity + , boost::iterators::detail::old_category_to_traversal + > +{}; + +// Trait to get an iterator's traversal category +template +struct iterator_traversal + : iterator_category_to_traversal< + typename boost::detail::iterator_traits::iterator_category + > +{}; + +# ifdef BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT +// Hack because BOOST_MPL_AUX_LAMBDA_SUPPORT doesn't seem to work +// out well. Instantiating the nested apply template also +// requires instantiating iterator_traits on the +// placeholder. Instead we just specialize it as a metafunction +// class. +template <> +struct iterator_traversal +{ + template + struct apply : iterator_traversal + {}; +}; +template <> +struct iterator_traversal + : iterator_traversal +{}; +# endif + +// +// Convert an iterator traversal to one of the traversal tags. +// +template +struct pure_traversal_tag + : mpl::eval_if< + is_convertible + , mpl::identity + , mpl::eval_if< + is_convertible + , mpl::identity + , mpl::eval_if< + is_convertible + , mpl::identity + , mpl::eval_if< + is_convertible + , mpl::identity + , mpl::eval_if< + is_convertible + , mpl::identity + , void + > + > + > + > + > +{ +}; + +// This import is needed for backward compatibility with Boost.Range: +// boost/range/detail/demote_iterator_traversal_tag.hpp +// It should be removed when that header is fixed. +namespace detail { +using iterators::pure_traversal_tag; +} // namespace detail + +// +// Trait to retrieve one of the iterator traversal tags from the iterator category or traversal. +// +template +struct pure_iterator_traversal + : pure_traversal_tag::type> +{}; + +# ifdef BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT +template <> +struct pure_iterator_traversal +{ + template + struct apply : pure_iterator_traversal + {}; +}; +template <> +struct pure_iterator_traversal + : pure_iterator_traversal +{}; +# endif + +} // namespace iterators + +using iterators::no_traversal_tag; +using iterators::incrementable_traversal_tag; +using iterators::single_pass_traversal_tag; +using iterators::forward_traversal_tag; +using iterators::bidirectional_traversal_tag; +using iterators::random_access_traversal_tag; +using iterators::iterator_category_to_traversal; +using iterators::iterator_traversal; + +// This import is needed for backward compatibility with Boost.Range: +// boost/range/detail/demote_iterator_traversal_tag.hpp +// It should be removed when that header is fixed. +namespace detail { +using iterators::pure_traversal_tag; +} // namespace detail + +} // namespace boost + +#include + +#endif // BOOST_ITERATOR_CATEGORIES_HPP diff --git a/realsense-file/3rd_party/boost/boost/iterator/iterator_facade.hpp b/realsense-file/3rd_party/boost/boost/iterator/iterator_facade.hpp new file mode 100644 index 0000000000..2bbf1ebf65 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/iterator/iterator_facade.hpp @@ -0,0 +1,971 @@ +// (C) Copyright David Abrahams 2002. +// (C) Copyright Jeremy Siek 2002. +// (C) Copyright Thomas Witt 2002. +// 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_ITERATOR_FACADE_23022003THW_HPP +#define BOOST_ITERATOR_FACADE_23022003THW_HPP + +#include +#include "boost/iterator.hpp" +#include +#include +#include + +#include +#include + +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +#include // this goes last + +namespace boost { +namespace iterators { + + // This forward declaration is required for the friend declaration + // in iterator_core_access + template class iterator_facade; + + namespace detail + { + // A binary metafunction class that always returns bool. VC6 + // ICEs on mpl::always, probably because of the default + // parameters. + struct always_bool2 + { + template + struct apply + { + typedef bool type; + }; + }; + + // The type trait checks if the category or traversal is at least as advanced as the specified required traversal + template< typename CategoryOrTraversal, typename Required > + struct is_traversal_at_least : + public boost::is_convertible< typename iterator_category_to_traversal< CategoryOrTraversal >::type, Required > + {}; + + // + // enable if for use in operator implementation. + // + template < + class Facade1 + , class Facade2 + , class Return + > + struct enable_if_interoperable : + public boost::iterators::enable_if< + is_interoperable< Facade1, Facade2 > + , Return + > + {}; + + // + // enable if for use in implementation of operators specific for random access traversal. + // + template < + class Facade1 + , class Facade2 + , class Return + > + struct enable_if_interoperable_and_random_access_traversal : + public boost::iterators::enable_if< + mpl::and_< + is_interoperable< Facade1, Facade2 > + , is_traversal_at_least< typename iterator_category< Facade1 >::type, random_access_traversal_tag > + , is_traversal_at_least< typename iterator_category< Facade2 >::type, random_access_traversal_tag > + > + , Return + > + {}; + + // + // Generates associated types for an iterator_facade with the + // given parameters. + // + template < + class ValueParam + , class CategoryOrTraversal + , class Reference + , class Difference + > + struct iterator_facade_types + { + typedef typename facade_iterator_category< + CategoryOrTraversal, ValueParam, Reference + >::type iterator_category; + + typedef typename remove_const::type value_type; + + // Not the real associated pointer type + typedef typename mpl::eval_if< + boost::iterators::detail::iterator_writability_disabled + , add_pointer + , add_pointer + >::type pointer; + +# if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \ + && (BOOST_WORKAROUND(_STLPORT_VERSION, BOOST_TESTED_AT(0x452)) \ + || BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, BOOST_TESTED_AT(310))) \ + || BOOST_WORKAROUND(BOOST_RWSTD_VER, BOOST_TESTED_AT(0x20101)) \ + || BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, <= 310) + + // To interoperate with some broken library/compiler + // combinations, user-defined iterators must be derived from + // std::iterator. It is possible to implement a standard + // library for broken compilers without this limitation. +# define BOOST_ITERATOR_FACADE_NEEDS_ITERATOR_BASE 1 + + typedef + iterator + base; +# endif + }; + + // iterators whose dereference operators reference the same value + // for all iterators into the same sequence (like many input + // iterators) need help with their postfix ++: the referenced + // value must be read and stored away before the increment occurs + // so that *a++ yields the originally referenced element and not + // the next one. + template + class postfix_increment_proxy + { + typedef typename iterator_value::type value_type; + public: + explicit postfix_increment_proxy(Iterator const& x) + : stored_value(*x) + {} + + // Returning a mutable reference allows nonsense like + // (*r++).mutate(), but it imposes fewer assumptions about the + // behavior of the value_type. In particular, recall that + // (*r).mutate() is legal if operator* returns by value. + value_type& + operator*() const + { + return this->stored_value; + } + private: + mutable value_type stored_value; + }; + + // + // In general, we can't determine that such an iterator isn't + // writable -- we also need to store a copy of the old iterator so + // that it can be written into. + template + class writable_postfix_increment_proxy + { + typedef typename iterator_value::type value_type; + public: + explicit writable_postfix_increment_proxy(Iterator const& x) + : stored_value(*x) + , stored_iterator(x) + {} + + // Dereferencing must return a proxy so that both *r++ = o and + // value_type(*r++) can work. In this case, *r is the same as + // *r++, and the conversion operator below is used to ensure + // readability. + writable_postfix_increment_proxy const& + operator*() const + { + return *this; + } + + // Provides readability of *r++ + operator value_type&() const + { + return stored_value; + } + + // Provides writability of *r++ + template + T const& operator=(T const& x) const + { + *this->stored_iterator = x; + return x; + } + + // This overload just in case only non-const objects are writable + template + T& operator=(T& x) const + { + *this->stored_iterator = x; + return x; + } + + // Provides X(r++) + operator Iterator const&() const + { + return stored_iterator; + } + + private: + mutable value_type stored_value; + Iterator stored_iterator; + }; + +# ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + + template + struct is_non_proxy_reference_impl + { + static Reference r; + + template + static typename mpl::if_< + is_convertible< + R const volatile* + , Value const volatile* + > + , char[1] + , char[2] + >::type& helper(R const&); + + BOOST_STATIC_CONSTANT(bool, value = sizeof(helper(r)) == 1); + }; + + template + struct is_non_proxy_reference + : mpl::bool_< + is_non_proxy_reference_impl::value + > + {}; +# else + template + struct is_non_proxy_reference + : is_convertible< + typename remove_reference::type + const volatile* + , Value const volatile* + > + {}; +# endif + + // A metafunction to choose the result type of postfix ++ + // + // Because the C++98 input iterator requirements say that *r++ has + // type T (value_type), implementations of some standard + // algorithms like lexicographical_compare may use constructions + // like: + // + // *r++ < *s++ + // + // If *r++ returns a proxy (as required if r is writable but not + // multipass), this sort of expression will fail unless the proxy + // supports the operator<. Since there are any number of such + // operations, we're not going to try to support them. Therefore, + // even if r++ returns a proxy, *r++ will only return a proxy if + // *r also returns a proxy. + template + struct postfix_increment_result + : mpl::eval_if< + mpl::and_< + // A proxy is only needed for readable iterators + is_convertible + + // No multipass iterator can have values that disappear + // before positions can be re-visited + , mpl::not_< + is_convertible< + typename iterator_category_to_traversal::type + , forward_traversal_tag + > + > + > + , mpl::if_< + is_non_proxy_reference + , postfix_increment_proxy + , writable_postfix_increment_proxy + > + , mpl::identity + > + {}; + + // operator->() needs special support for input iterators to strictly meet the + // standard's requirements. If *i is not a reference type, we must still + // produce an lvalue to which a pointer can be formed. We do that by + // returning a proxy object containing an instance of the reference object. + template + struct operator_arrow_dispatch // proxy references + { + struct proxy + { + explicit proxy(Reference const & x) : m_ref(x) {} + Reference* operator->() { return boost::addressof(m_ref); } + // This function is needed for MWCW and BCC, which won't call + // operator-> again automatically per 13.3.1.2 para 8 + operator Reference*() { return boost::addressof(m_ref); } + Reference m_ref; + }; + typedef proxy result_type; + static result_type apply(Reference const & x) + { + return result_type(x); + } + }; + + template + struct operator_arrow_dispatch // "real" references + { + typedef Pointer result_type; + static result_type apply(T& x) + { + return boost::addressof(x); + } + }; + + // A proxy return type for operator[], needed to deal with + // iterators that may invalidate referents upon destruction. + // Consider the temporary iterator in *(a + n) + template + class operator_brackets_proxy + { + // Iterator is actually an iterator_facade, so we do not have to + // go through iterator_traits to access the traits. + typedef typename Iterator::reference reference; + typedef typename Iterator::value_type value_type; + + public: + operator_brackets_proxy(Iterator const& iter) + : m_iter(iter) + {} + + operator reference() const + { + return *m_iter; + } + + operator_brackets_proxy& operator=(value_type const& val) + { + *m_iter = val; + return *this; + } + + private: + Iterator m_iter; + }; + + // A metafunction that determines whether operator[] must return a + // proxy, or whether it can simply return a copy of the value_type. + template + struct use_operator_brackets_proxy + : mpl::not_< + mpl::and_< + // Really we want an is_copy_constructible trait here, + // but is_POD will have to suffice in the meantime. + boost::is_POD + , iterator_writability_disabled + > + > + {}; + + template + struct operator_brackets_result + { + typedef typename mpl::if_< + use_operator_brackets_proxy + , operator_brackets_proxy + , Value + >::type type; + }; + + template + operator_brackets_proxy make_operator_brackets_result(Iterator const& iter, mpl::true_) + { + return operator_brackets_proxy(iter); + } + + template + typename Iterator::value_type make_operator_brackets_result(Iterator const& iter, mpl::false_) + { + return *iter; + } + + struct choose_difference_type + { + template + struct apply + : +# ifdef BOOST_NO_ONE_WAY_ITERATOR_INTEROP + iterator_difference +# else + mpl::eval_if< + is_convertible + , iterator_difference + , iterator_difference + > +# endif + {}; + + }; + + template < + class Derived + , class Value + , class CategoryOrTraversal + , class Reference + , class Difference + , bool IsBidirectionalTraversal + , bool IsRandomAccessTraversal + > + class iterator_facade_base; + + } // namespace detail + + + // Macros which describe the declarations of binary operators +# ifdef BOOST_NO_STRICT_ITERATOR_INTEROPERABILITY +# define BOOST_ITERATOR_FACADE_INTEROP_HEAD_IMPL(prefix, op, result_type, enabler) \ + template < \ + class Derived1, class V1, class TC1, class Reference1, class Difference1 \ + , class Derived2, class V2, class TC2, class Reference2, class Difference2 \ + > \ + prefix typename mpl::apply2::type \ + operator op( \ + iterator_facade const& lhs \ + , iterator_facade const& rhs) +# else +# define BOOST_ITERATOR_FACADE_INTEROP_HEAD_IMPL(prefix, op, result_type, enabler) \ + template < \ + class Derived1, class V1, class TC1, class Reference1, class Difference1 \ + , class Derived2, class V2, class TC2, class Reference2, class Difference2 \ + > \ + prefix typename enabler< \ + Derived1, Derived2 \ + , typename mpl::apply2::type \ + >::type \ + operator op( \ + iterator_facade const& lhs \ + , iterator_facade const& rhs) +# endif + +# define BOOST_ITERATOR_FACADE_INTEROP_HEAD(prefix, op, result_type) \ + BOOST_ITERATOR_FACADE_INTEROP_HEAD_IMPL(prefix, op, result_type, boost::iterators::detail::enable_if_interoperable) + +# define BOOST_ITERATOR_FACADE_INTEROP_RANDOM_ACCESS_HEAD(prefix, op, result_type) \ + BOOST_ITERATOR_FACADE_INTEROP_HEAD_IMPL(prefix, op, result_type, boost::iterators::detail::enable_if_interoperable_and_random_access_traversal) + +# define BOOST_ITERATOR_FACADE_PLUS_HEAD(prefix,args) \ + template \ + prefix typename boost::iterators::enable_if< \ + boost::iterators::detail::is_traversal_at_least< TC, boost::iterators::random_access_traversal_tag >, \ + Derived \ + >::type operator+ args + + // + // Helper class for granting access to the iterator core interface. + // + // The simple core interface is used by iterator_facade. The core + // interface of a user/library defined iterator type should not be made public + // so that it does not clutter the public interface. Instead iterator_core_access + // should be made friend so that iterator_facade can access the core + // interface through iterator_core_access. + // + class iterator_core_access + { +# if defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS) + // Tasteless as this may seem, making all members public allows member templates + // to work in the absence of member template friends. + public: +# else + + template friend class iterator_facade; + template + friend class detail::iterator_facade_base; + +# define BOOST_ITERATOR_FACADE_RELATION(op) \ + BOOST_ITERATOR_FACADE_INTEROP_HEAD(friend,op, boost::iterators::detail::always_bool2); + + BOOST_ITERATOR_FACADE_RELATION(==) + BOOST_ITERATOR_FACADE_RELATION(!=) + +# undef BOOST_ITERATOR_FACADE_RELATION + +# define BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION(op) \ + BOOST_ITERATOR_FACADE_INTEROP_RANDOM_ACCESS_HEAD(friend,op, boost::iterators::detail::always_bool2); + + BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION(<) + BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION(>) + BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION(<=) + BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION(>=) + +# undef BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION + + BOOST_ITERATOR_FACADE_INTEROP_RANDOM_ACCESS_HEAD( + friend, -, boost::iterators::detail::choose_difference_type) + ; + + BOOST_ITERATOR_FACADE_PLUS_HEAD( + friend inline + , (iterator_facade const& + , typename Derived::difference_type) + ) + ; + + BOOST_ITERATOR_FACADE_PLUS_HEAD( + friend inline + , (typename Derived::difference_type + , iterator_facade const&) + ) + ; + +# endif + + template + static typename Facade::reference dereference(Facade const& f) + { + return f.dereference(); + } + + template + static void increment(Facade& f) + { + f.increment(); + } + + template + static void decrement(Facade& f) + { + f.decrement(); + } + + template + static bool equal(Facade1 const& f1, Facade2 const& f2, mpl::true_) + { + return f1.equal(f2); + } + + template + static bool equal(Facade1 const& f1, Facade2 const& f2, mpl::false_) + { + return f2.equal(f1); + } + + template + static void advance(Facade& f, typename Facade::difference_type n) + { + f.advance(n); + } + + template + static typename Facade1::difference_type distance_from( + Facade1 const& f1, Facade2 const& f2, mpl::true_) + { + return -f1.distance_to(f2); + } + + template + static typename Facade2::difference_type distance_from( + Facade1 const& f1, Facade2 const& f2, mpl::false_) + { + return f2.distance_to(f1); + } + + // + // Curiously Recurring Template interface. + // + template + static I& derived(iterator_facade& facade) + { + return *static_cast(&facade); + } + + template + static I const& derived(iterator_facade const& facade) + { + return *static_cast(&facade); + } + + // objects of this class are useless + BOOST_DELETED_FUNCTION(iterator_core_access()) + }; + + namespace detail { + + // Implementation for forward traversal iterators + template < + class Derived + , class Value + , class CategoryOrTraversal + , class Reference + , class Difference + > + class iterator_facade_base< Derived, Value, CategoryOrTraversal, Reference, Difference, false, false > +# ifdef BOOST_ITERATOR_FACADE_NEEDS_ITERATOR_BASE + : public boost::iterators::detail::iterator_facade_types< + Value, CategoryOrTraversal, Reference, Difference + >::base +# undef BOOST_ITERATOR_FACADE_NEEDS_ITERATOR_BASE +# endif + { + private: + typedef boost::iterators::detail::iterator_facade_types< + Value, CategoryOrTraversal, Reference, Difference + > associated_types; + + typedef boost::iterators::detail::operator_arrow_dispatch< + Reference + , typename associated_types::pointer + > operator_arrow_dispatch_; + + public: + typedef typename associated_types::value_type value_type; + typedef Reference reference; + typedef Difference difference_type; + + typedef typename operator_arrow_dispatch_::result_type pointer; + + typedef typename associated_types::iterator_category iterator_category; + + public: + reference operator*() const + { + return iterator_core_access::dereference(this->derived()); + } + + pointer operator->() const + { + return operator_arrow_dispatch_::apply(*this->derived()); + } + + Derived& operator++() + { + iterator_core_access::increment(this->derived()); + return this->derived(); + } + + protected: + // + // Curiously Recurring Template interface. + // + Derived& derived() + { + return *static_cast(this); + } + + Derived const& derived() const + { + return *static_cast(this); + } + }; + + // Implementation for bidirectional traversal iterators + template < + class Derived + , class Value + , class CategoryOrTraversal + , class Reference + , class Difference + > + class iterator_facade_base< Derived, Value, CategoryOrTraversal, Reference, Difference, true, false > : + public iterator_facade_base< Derived, Value, CategoryOrTraversal, Reference, Difference, false, false > + { + public: + Derived& operator--() + { + iterator_core_access::decrement(this->derived()); + return this->derived(); + } + + Derived operator--(int) + { + Derived tmp(this->derived()); + --*this; + return tmp; + } + }; + + // Implementation for random access traversal iterators + template < + class Derived + , class Value + , class CategoryOrTraversal + , class Reference + , class Difference + > + class iterator_facade_base< Derived, Value, CategoryOrTraversal, Reference, Difference, true, true > : + public iterator_facade_base< Derived, Value, CategoryOrTraversal, Reference, Difference, true, false > + { + private: + typedef iterator_facade_base< Derived, Value, CategoryOrTraversal, Reference, Difference, true, false > base_type; + + public: + typedef typename base_type::reference reference; + typedef typename base_type::difference_type difference_type; + + public: + typename boost::iterators::detail::operator_brackets_result::type + operator[](difference_type n) const + { + typedef boost::iterators::detail::use_operator_brackets_proxy use_proxy; + + return boost::iterators::detail::make_operator_brackets_result( + this->derived() + n + , use_proxy() + ); + } + + Derived& operator+=(difference_type n) + { + iterator_core_access::advance(this->derived(), n); + return this->derived(); + } + + Derived& operator-=(difference_type n) + { + iterator_core_access::advance(this->derived(), -n); + return this->derived(); + } + + Derived operator-(difference_type x) const + { + Derived result(this->derived()); + return result -= x; + } + }; + + } // namespace detail + + // + // iterator_facade - use as a public base class for defining new + // standard-conforming iterators. + // + template < + class Derived // The derived iterator type being constructed + , class Value + , class CategoryOrTraversal + , class Reference = Value& + , class Difference = std::ptrdiff_t + > + class iterator_facade : + public detail::iterator_facade_base< + Derived, + Value, + CategoryOrTraversal, + Reference, + Difference, + detail::is_traversal_at_least< CategoryOrTraversal, bidirectional_traversal_tag >::value, + detail::is_traversal_at_least< CategoryOrTraversal, random_access_traversal_tag >::value + > + { + protected: + // For use by derived classes + typedef iterator_facade iterator_facade_; + }; + + template + inline typename boost::iterators::detail::postfix_increment_result::type + operator++( + iterator_facade& i + , int + ) + { + typename boost::iterators::detail::postfix_increment_result::type + tmp(*static_cast(&i)); + + ++i; + + return tmp; + } + + + // + // Comparison operator implementation. The library supplied operators + // enables the user to provide fully interoperable constant/mutable + // iterator types. I.e. the library provides all operators + // for all mutable/constant iterator combinations. + // + // Note though that this kind of interoperability for constant/mutable + // iterators is not required by the standard for container iterators. + // All the standard asks for is a conversion mutable -> constant. + // Most standard library implementations nowadays provide fully interoperable + // iterator implementations, but there are still heavily used implementations + // that do not provide them. (Actually it's even worse, they do not provide + // them for only a few iterators.) + // + // ?? Maybe a BOOST_ITERATOR_NO_FULL_INTEROPERABILITY macro should + // enable the user to turn off mixed type operators + // + // The library takes care to provide only the right operator overloads. + // I.e. + // + // bool operator==(Iterator, Iterator); + // bool operator==(ConstIterator, Iterator); + // bool operator==(Iterator, ConstIterator); + // bool operator==(ConstIterator, ConstIterator); + // + // ... + // + // In order to do so it uses c++ idioms that are not yet widely supported + // by current compiler releases. The library is designed to degrade gracefully + // in the face of compiler deficiencies. In general compiler + // deficiencies result in less strict error checking and more obscure + // error messages, functionality is not affected. + // + // For full operation compiler support for "Substitution Failure Is Not An Error" + // (aka. enable_if) and boost::is_convertible is required. + // + // The following problems occur if support is lacking. + // + // Pseudo code + // + // --------------- + // AdaptorA a1; + // AdaptorA a2; + // + // // This will result in a no such overload error in full operation + // // If enable_if or is_convertible is not supported + // // The instantiation will fail with an error hopefully indicating that + // // there is no operator== for Iterator1, Iterator2 + // // The same will happen if no enable_if is used to remove + // // false overloads from the templated conversion constructor + // // of AdaptorA. + // + // a1 == a2; + // ---------------- + // + // AdaptorA a; + // AdaptorB b; + // + // // This will result in a no such overload error in full operation + // // If enable_if is not supported the static assert used + // // in the operator implementation will fail. + // // This will accidently work if is_convertible is not supported. + // + // a == b; + // ---------------- + // + +# ifdef BOOST_NO_ONE_WAY_ITERATOR_INTEROP +# define BOOST_ITERATOR_CONVERTIBLE(a,b) mpl::true_() +# else +# define BOOST_ITERATOR_CONVERTIBLE(a,b) is_convertible() +# endif + +# define BOOST_ITERATOR_FACADE_INTEROP(op, result_type, return_prefix, base_op) \ + BOOST_ITERATOR_FACADE_INTEROP_HEAD(inline, op, result_type) \ + { \ + /* For those compilers that do not support enable_if */ \ + BOOST_STATIC_ASSERT(( \ + is_interoperable< Derived1, Derived2 >::value \ + )); \ + return_prefix iterator_core_access::base_op( \ + *static_cast(&lhs) \ + , *static_cast(&rhs) \ + , BOOST_ITERATOR_CONVERTIBLE(Derived2,Derived1) \ + ); \ + } + +# define BOOST_ITERATOR_FACADE_RELATION(op, return_prefix, base_op) \ + BOOST_ITERATOR_FACADE_INTEROP( \ + op \ + , boost::iterators::detail::always_bool2 \ + , return_prefix \ + , base_op \ + ) + + BOOST_ITERATOR_FACADE_RELATION(==, return, equal) + BOOST_ITERATOR_FACADE_RELATION(!=, return !, equal) + +# undef BOOST_ITERATOR_FACADE_RELATION + + +# define BOOST_ITERATOR_FACADE_INTEROP_RANDOM_ACCESS(op, result_type, return_prefix, base_op) \ + BOOST_ITERATOR_FACADE_INTEROP_RANDOM_ACCESS_HEAD(inline, op, result_type) \ + { \ + /* For those compilers that do not support enable_if */ \ + BOOST_STATIC_ASSERT(( \ + is_interoperable< Derived1, Derived2 >::value && \ + boost::iterators::detail::is_traversal_at_least< typename iterator_category< Derived1 >::type, random_access_traversal_tag >::value && \ + boost::iterators::detail::is_traversal_at_least< typename iterator_category< Derived2 >::type, random_access_traversal_tag >::value \ + )); \ + return_prefix iterator_core_access::base_op( \ + *static_cast(&lhs) \ + , *static_cast(&rhs) \ + , BOOST_ITERATOR_CONVERTIBLE(Derived2,Derived1) \ + ); \ + } + +# define BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION(op, return_prefix, base_op) \ + BOOST_ITERATOR_FACADE_INTEROP_RANDOM_ACCESS( \ + op \ + , boost::iterators::detail::always_bool2 \ + , return_prefix \ + , base_op \ + ) + + BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION(<, return 0 >, distance_from) + BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION(>, return 0 <, distance_from) + BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION(<=, return 0 >=, distance_from) + BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION(>=, return 0 <=, distance_from) + +# undef BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION + + // operator- requires an additional part in the static assertion + BOOST_ITERATOR_FACADE_INTEROP_RANDOM_ACCESS( + - + , boost::iterators::detail::choose_difference_type + , return + , distance_from + ) + +# undef BOOST_ITERATOR_FACADE_INTEROP +# undef BOOST_ITERATOR_FACADE_INTEROP_RANDOM_ACCESS + +# define BOOST_ITERATOR_FACADE_PLUS(args) \ + BOOST_ITERATOR_FACADE_PLUS_HEAD(inline, args) \ + { \ + Derived tmp(static_cast(i)); \ + return tmp += n; \ + } + + BOOST_ITERATOR_FACADE_PLUS(( + iterator_facade const& i + , typename Derived::difference_type n + )) + + BOOST_ITERATOR_FACADE_PLUS(( + typename Derived::difference_type n + , iterator_facade const& i + )) + +# undef BOOST_ITERATOR_FACADE_PLUS +# undef BOOST_ITERATOR_FACADE_PLUS_HEAD + +# undef BOOST_ITERATOR_FACADE_INTEROP_HEAD +# undef BOOST_ITERATOR_FACADE_INTEROP_RANDOM_ACCESS_HEAD +# undef BOOST_ITERATOR_FACADE_INTEROP_HEAD_IMPL + +} // namespace iterators + +using iterators::iterator_core_access; +using iterators::iterator_facade; + +} // namespace boost + +#include + +#endif // BOOST_ITERATOR_FACADE_23022003THW_HPP diff --git a/realsense-file/3rd_party/boost/boost/iterator/iterator_traits.hpp b/realsense-file/3rd_party/boost/boost/iterator/iterator_traits.hpp new file mode 100644 index 0000000000..9721a02093 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/iterator/iterator_traits.hpp @@ -0,0 +1,60 @@ +// Copyright David Abrahams 2003. +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +#ifndef ITERATOR_TRAITS_DWA200347_HPP +# define ITERATOR_TRAITS_DWA200347_HPP + +# include +# include + +namespace boost { +namespace iterators { + +// Macro for supporting old compilers, no longer needed but kept +// for backwards compatibility (it was documented). +#define BOOST_ITERATOR_CATEGORY iterator_category + + +template +struct iterator_value +{ + typedef typename boost::detail::iterator_traits::value_type type; +}; + +template +struct iterator_reference +{ + typedef typename boost::detail::iterator_traits::reference type; +}; + + +template +struct iterator_pointer +{ + typedef typename boost::detail::iterator_traits::pointer type; +}; + +template +struct iterator_difference +{ + typedef typename boost::detail::iterator_traits::difference_type type; +}; + +template +struct iterator_category +{ + typedef typename boost::detail::iterator_traits::iterator_category type; +}; + +} // namespace iterators + +using iterators::iterator_value; +using iterators::iterator_reference; +using iterators::iterator_pointer; +using iterators::iterator_difference; +using iterators::iterator_category; + +} // namespace boost + +#endif // ITERATOR_TRAITS_DWA200347_HPP diff --git a/realsense-file/3rd_party/boost/boost/iterator/reverse_iterator.hpp b/realsense-file/3rd_party/boost/boost/iterator/reverse_iterator.hpp new file mode 100644 index 0000000000..f9aab8fc72 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/iterator/reverse_iterator.hpp @@ -0,0 +1,74 @@ +// (C) Copyright David Abrahams 2002. +// (C) Copyright Jeremy Siek 2002. +// (C) Copyright Thomas Witt 2002. +// 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_REVERSE_ITERATOR_23022003THW_HPP +#define BOOST_REVERSE_ITERATOR_23022003THW_HPP + +#include +#include +#include + +namespace boost { +namespace iterators { + + // + // + // + template + class reverse_iterator + : public iterator_adaptor< reverse_iterator, Iterator > + { + typedef iterator_adaptor< reverse_iterator, Iterator > super_t; + + friend class iterator_core_access; + + public: + reverse_iterator() {} + + explicit reverse_iterator(Iterator x) + : super_t(x) {} + + template + reverse_iterator( + reverse_iterator const& r + , typename enable_if_convertible::type* = 0 + ) + : super_t(r.base()) + {} + + private: + typename super_t::reference dereference() const { return *boost::prior(this->base()); } + + void increment() { --this->base_reference(); } + void decrement() { ++this->base_reference(); } + + void advance(typename super_t::difference_type n) + { + this->base_reference() += -n; + } + + template + typename super_t::difference_type + distance_to(reverse_iterator const& y) const + { + return this->base_reference() - y.base(); + } + }; + + template + inline reverse_iterator make_reverse_iterator(BidirectionalIterator x) + { + return reverse_iterator(x); + } + +} // namespace iterators + +using iterators::reverse_iterator; +using iterators::make_reverse_iterator; + +} // namespace boost + +#endif // BOOST_REVERSE_ITERATOR_23022003THW_HPP diff --git a/realsense-file/3rd_party/boost/boost/limits.hpp b/realsense-file/3rd_party/boost/boost/limits.hpp new file mode 100644 index 0000000000..0baf5d2bd2 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/limits.hpp @@ -0,0 +1,146 @@ + +// (C) Copyright John maddock 1999. +// (C) David Abrahams 2002. 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) +// +// use this header as a workaround for missing + +// See http://www.boost.org/libs/compatibility/index.html for documentation. + +#ifndef BOOST_LIMITS +#define BOOST_LIMITS + +#include + +#ifdef BOOST_NO_LIMITS +# error "There is no std::numeric_limits suppport available." +#else +# include +#endif + +#if (defined(BOOST_HAS_LONG_LONG) && defined(BOOST_NO_LONG_LONG_NUMERIC_LIMITS)) \ + || (defined(BOOST_HAS_MS_INT64) && defined(BOOST_NO_MS_INT64_NUMERIC_LIMITS)) +// Add missing specializations for numeric_limits: +#ifdef BOOST_HAS_MS_INT64 +# define BOOST_LLT __int64 +# define BOOST_ULLT unsigned __int64 +#else +# define BOOST_LLT ::boost::long_long_type +# define BOOST_ULLT ::boost::ulong_long_type +#endif + +#include // for CHAR_BIT + +namespace std +{ + template<> + class numeric_limits + { + public: + + BOOST_STATIC_CONSTANT(bool, is_specialized = true); +#ifdef BOOST_HAS_MS_INT64 + static BOOST_LLT min BOOST_PREVENT_MACRO_SUBSTITUTION (){ return 0x8000000000000000i64; } + static BOOST_LLT max BOOST_PREVENT_MACRO_SUBSTITUTION (){ return 0x7FFFFFFFFFFFFFFFi64; } +#elif defined(LLONG_MAX) + static BOOST_LLT min BOOST_PREVENT_MACRO_SUBSTITUTION (){ return LLONG_MIN; } + static BOOST_LLT max BOOST_PREVENT_MACRO_SUBSTITUTION (){ return LLONG_MAX; } +#elif defined(LONGLONG_MAX) + static BOOST_LLT min BOOST_PREVENT_MACRO_SUBSTITUTION (){ return LONGLONG_MIN; } + static BOOST_LLT max BOOST_PREVENT_MACRO_SUBSTITUTION (){ return LONGLONG_MAX; } +#else + static BOOST_LLT min BOOST_PREVENT_MACRO_SUBSTITUTION (){ return 1LL << (sizeof(BOOST_LLT) * CHAR_BIT - 1); } + static BOOST_LLT max BOOST_PREVENT_MACRO_SUBSTITUTION (){ return ~(min)(); } +#endif + BOOST_STATIC_CONSTANT(int, digits = sizeof(BOOST_LLT) * CHAR_BIT -1); + BOOST_STATIC_CONSTANT(int, digits10 = (CHAR_BIT * sizeof (BOOST_LLT) - 1) * 301L / 1000); + BOOST_STATIC_CONSTANT(bool, is_signed = true); + BOOST_STATIC_CONSTANT(bool, is_integer = true); + BOOST_STATIC_CONSTANT(bool, is_exact = true); + BOOST_STATIC_CONSTANT(int, radix = 2); + static BOOST_LLT epsilon() throw() { return 0; }; + static BOOST_LLT round_error() throw() { return 0; }; + + BOOST_STATIC_CONSTANT(int, min_exponent = 0); + BOOST_STATIC_CONSTANT(int, min_exponent10 = 0); + BOOST_STATIC_CONSTANT(int, max_exponent = 0); + BOOST_STATIC_CONSTANT(int, max_exponent10 = 0); + + BOOST_STATIC_CONSTANT(bool, has_infinity = false); + BOOST_STATIC_CONSTANT(bool, has_quiet_NaN = false); + BOOST_STATIC_CONSTANT(bool, has_signaling_NaN = false); + BOOST_STATIC_CONSTANT(bool, has_denorm = false); + BOOST_STATIC_CONSTANT(bool, has_denorm_loss = false); + static BOOST_LLT infinity() throw() { return 0; }; + static BOOST_LLT quiet_NaN() throw() { return 0; }; + static BOOST_LLT signaling_NaN() throw() { return 0; }; + static BOOST_LLT denorm_min() throw() { return 0; }; + + BOOST_STATIC_CONSTANT(bool, is_iec559 = false); + BOOST_STATIC_CONSTANT(bool, is_bounded = true); + BOOST_STATIC_CONSTANT(bool, is_modulo = true); + + BOOST_STATIC_CONSTANT(bool, traps = false); + BOOST_STATIC_CONSTANT(bool, tinyness_before = false); + BOOST_STATIC_CONSTANT(float_round_style, round_style = round_toward_zero); + + }; + + template<> + class numeric_limits + { + public: + + BOOST_STATIC_CONSTANT(bool, is_specialized = true); +#ifdef BOOST_HAS_MS_INT64 + static BOOST_ULLT min BOOST_PREVENT_MACRO_SUBSTITUTION (){ return 0ui64; } + static BOOST_ULLT max BOOST_PREVENT_MACRO_SUBSTITUTION (){ return 0xFFFFFFFFFFFFFFFFui64; } +#elif defined(ULLONG_MAX) && defined(ULLONG_MIN) + static BOOST_ULLT min BOOST_PREVENT_MACRO_SUBSTITUTION (){ return ULLONG_MIN; } + static BOOST_ULLT max BOOST_PREVENT_MACRO_SUBSTITUTION (){ return ULLONG_MAX; } +#elif defined(ULONGLONG_MAX) && defined(ULONGLONG_MIN) + static BOOST_ULLT min BOOST_PREVENT_MACRO_SUBSTITUTION (){ return ULONGLONG_MIN; } + static BOOST_ULLT max BOOST_PREVENT_MACRO_SUBSTITUTION (){ return ULONGLONG_MAX; } +#else + static BOOST_ULLT min BOOST_PREVENT_MACRO_SUBSTITUTION (){ return 0uLL; } + static BOOST_ULLT max BOOST_PREVENT_MACRO_SUBSTITUTION (){ return ~0uLL; } +#endif + BOOST_STATIC_CONSTANT(int, digits = sizeof(BOOST_LLT) * CHAR_BIT); + BOOST_STATIC_CONSTANT(int, digits10 = (CHAR_BIT * sizeof (BOOST_LLT)) * 301L / 1000); + BOOST_STATIC_CONSTANT(bool, is_signed = false); + BOOST_STATIC_CONSTANT(bool, is_integer = true); + BOOST_STATIC_CONSTANT(bool, is_exact = true); + BOOST_STATIC_CONSTANT(int, radix = 2); + static BOOST_ULLT epsilon() throw() { return 0; }; + static BOOST_ULLT round_error() throw() { return 0; }; + + BOOST_STATIC_CONSTANT(int, min_exponent = 0); + BOOST_STATIC_CONSTANT(int, min_exponent10 = 0); + BOOST_STATIC_CONSTANT(int, max_exponent = 0); + BOOST_STATIC_CONSTANT(int, max_exponent10 = 0); + + BOOST_STATIC_CONSTANT(bool, has_infinity = false); + BOOST_STATIC_CONSTANT(bool, has_quiet_NaN = false); + BOOST_STATIC_CONSTANT(bool, has_signaling_NaN = false); + BOOST_STATIC_CONSTANT(bool, has_denorm = false); + BOOST_STATIC_CONSTANT(bool, has_denorm_loss = false); + static BOOST_ULLT infinity() throw() { return 0; }; + static BOOST_ULLT quiet_NaN() throw() { return 0; }; + static BOOST_ULLT signaling_NaN() throw() { return 0; }; + static BOOST_ULLT denorm_min() throw() { return 0; }; + + BOOST_STATIC_CONSTANT(bool, is_iec559 = false); + BOOST_STATIC_CONSTANT(bool, is_bounded = true); + BOOST_STATIC_CONSTANT(bool, is_modulo = true); + + BOOST_STATIC_CONSTANT(bool, traps = false); + BOOST_STATIC_CONSTANT(bool, tinyness_before = false); + BOOST_STATIC_CONSTANT(float_round_style, round_style = round_toward_zero); + + }; +} +#endif + +#endif + diff --git a/realsense-file/3rd_party/boost/boost/move/core.hpp b/realsense-file/3rd_party/boost/boost/move/core.hpp new file mode 100644 index 0000000000..81d33089c2 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/move/core.hpp @@ -0,0 +1,452 @@ +////////////////////////////////////////////////////////////////////////////// +// +// (C) Copyright Ion Gaztanaga 2012-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) +// +// See http://www.boost.org/libs/move for documentation. +// +////////////////////////////////////////////////////////////////////////////// + +//! \file +//! This header implements macros to define movable classes and +//! move-aware functions + +#ifndef BOOST_MOVE_CORE_HPP +#define BOOST_MOVE_CORE_HPP + +#ifndef BOOST_CONFIG_HPP +# include +#endif +# +#if defined(BOOST_HAS_PRAGMA_ONCE) +# pragma once +#endif + +#include +#include + +//boost_move_no_copy_constructor_or_assign typedef +//used to detect noncopyable types for other Boost libraries. +#if defined(BOOST_NO_CXX11_DELETED_FUNCTIONS) || defined(BOOST_NO_CXX11_RVALUE_REFERENCES) + #define BOOST_MOVE_IMPL_NO_COPY_CTOR_OR_ASSIGN(TYPE) \ + private:\ + TYPE(TYPE &);\ + TYPE& operator=(TYPE &);\ + public:\ + typedef int boost_move_no_copy_constructor_or_assign; \ + private:\ + // +#else + #define BOOST_MOVE_IMPL_NO_COPY_CTOR_OR_ASSIGN(TYPE) \ + public:\ + TYPE(TYPE const &) = delete;\ + TYPE& operator=(TYPE const &) = delete;\ + public:\ + typedef int boost_move_no_copy_constructor_or_assign; \ + private:\ + // +#endif //BOOST_NO_CXX11_DELETED_FUNCTIONS + +#if defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && !defined(BOOST_MOVE_DOXYGEN_INVOKED) + + #include + + //Move emulation rv breaks standard aliasing rules so add workarounds for some compilers + #if defined(__GNUC__) && (__GNUC__ >= 4) && \ + (\ + defined(BOOST_GCC) || \ + (defined(BOOST_INTEL) && (BOOST_INTEL_CXX_VERSION >= 1300)) \ + ) + #define BOOST_MOVE_ATTRIBUTE_MAY_ALIAS __attribute__((__may_alias__)) + #else + #define BOOST_MOVE_ATTRIBUTE_MAY_ALIAS + #endif + + namespace boost { + + ////////////////////////////////////////////////////////////////////////////// + // + // struct rv + // + ////////////////////////////////////////////////////////////////////////////// + template + class rv + : public ::boost::move_detail::if_c + < ::boost::move_detail::is_class::value + , T + , ::boost::move_detail::nat + >::type + { + rv(); + ~rv() throw(); + rv(rv const&); + void operator=(rv const&); + } BOOST_MOVE_ATTRIBUTE_MAY_ALIAS; + + + ////////////////////////////////////////////////////////////////////////////// + // + // is_rv + // + ////////////////////////////////////////////////////////////////////////////// + + namespace move_detail { + + template + struct is_rv + //Derive from integral constant because some Boost code assummes it has + //a "type" internal typedef + : integral_constant::value > + {}; + + } //namespace move_detail { + + ////////////////////////////////////////////////////////////////////////////// + // + // has_move_emulation_enabled + // + ////////////////////////////////////////////////////////////////////////////// + template + struct has_move_emulation_enabled + : ::boost::move_detail::has_move_emulation_enabled_impl + {}; + + } //namespace boost { + + #define BOOST_RV_REF(TYPE)\ + ::boost::rv< TYPE >& \ + // + + #define BOOST_RV_REF_2_TEMPL_ARGS(TYPE, ARG1, ARG2)\ + ::boost::rv< TYPE >& \ + // + + #define BOOST_RV_REF_3_TEMPL_ARGS(TYPE, ARG1, ARG2, ARG3)\ + ::boost::rv< TYPE >& \ + // + + #define BOOST_RV_REF_BEG\ + ::boost::rv< \ + // + + #define BOOST_RV_REF_END\ + >& \ + // + + #define BOOST_FWD_REF(TYPE)\ + const TYPE & \ + // + + #define BOOST_COPY_ASSIGN_REF(TYPE)\ + const ::boost::rv< TYPE >& \ + // + + #define BOOST_COPY_ASSIGN_REF_BEG \ + const ::boost::rv< \ + // + + #define BOOST_COPY_ASSIGN_REF_END \ + >& \ + // + + #define BOOST_COPY_ASSIGN_REF_2_TEMPL_ARGS(TYPE, ARG1, ARG2)\ + const ::boost::rv< TYPE >& \ + // + + #define BOOST_COPY_ASSIGN_REF_3_TEMPL_ARGS(TYPE, ARG1, ARG2, ARG3)\ + const ::boost::rv< TYPE >& \ + // + + #define BOOST_CATCH_CONST_RLVALUE(TYPE)\ + const ::boost::rv< TYPE >& \ + // + + namespace boost { + namespace move_detail { + + template + inline typename ::boost::move_detail::enable_if_c + < ::boost::move_detail::is_lvalue_reference::value || + !::boost::has_move_emulation_enabled::value + , T&>::type + move_return(T& x) BOOST_NOEXCEPT + { + return x; + } + + template + inline typename ::boost::move_detail::enable_if_c + < !::boost::move_detail::is_lvalue_reference::value && + ::boost::has_move_emulation_enabled::value + , ::boost::rv&>::type + move_return(T& x) BOOST_NOEXCEPT + { + return *static_cast< ::boost::rv* >(::boost::move_detail::addressof(x)); + } + + template + inline typename ::boost::move_detail::enable_if_c + < !::boost::move_detail::is_lvalue_reference::value && + ::boost::has_move_emulation_enabled::value + , ::boost::rv&>::type + move_return(::boost::rv& x) BOOST_NOEXCEPT + { + return x; + } + + } //namespace move_detail { + } //namespace boost { + + #define BOOST_MOVE_RET(RET_TYPE, REF)\ + boost::move_detail::move_return< RET_TYPE >(REF) + // + + #define BOOST_MOVE_BASE(BASE_TYPE, ARG) \ + ::boost::move((BASE_TYPE&)(ARG)) + // + + ////////////////////////////////////////////////////////////////////////////// + // + // BOOST_MOVABLE_BUT_NOT_COPYABLE + // + ////////////////////////////////////////////////////////////////////////////// + #define BOOST_MOVABLE_BUT_NOT_COPYABLE(TYPE)\ + BOOST_MOVE_IMPL_NO_COPY_CTOR_OR_ASSIGN(TYPE)\ + public:\ + operator ::boost::rv&() \ + { return *static_cast< ::boost::rv* >(this); }\ + operator const ::boost::rv&() const \ + { return *static_cast* >(this); }\ + private:\ + // + + ////////////////////////////////////////////////////////////////////////////// + // + // BOOST_COPYABLE_AND_MOVABLE + // + ////////////////////////////////////////////////////////////////////////////// + + #define BOOST_COPYABLE_AND_MOVABLE(TYPE)\ + public:\ + TYPE& operator=(TYPE &t)\ + { this->operator=(static_cast &>(const_cast(t))); return *this;}\ + public:\ + operator ::boost::rv&() \ + { return *static_cast< ::boost::rv* >(this); }\ + operator const ::boost::rv&() const \ + { return *static_cast* >(this); }\ + private:\ + // + + #define BOOST_COPYABLE_AND_MOVABLE_ALT(TYPE)\ + public:\ + operator ::boost::rv&() \ + { return *static_cast< ::boost::rv* >(this); }\ + operator const ::boost::rv&() const \ + { return *static_cast* >(this); }\ + private:\ + // + + namespace boost{ + namespace move_detail{ + + template< class T> + struct forward_type + { typedef const T &type; }; + + template< class T> + struct forward_type< boost::rv > + { typedef T type; }; + + }} + +#else //BOOST_NO_CXX11_RVALUE_REFERENCES + + //! This macro marks a type as movable but not copyable, disabling copy construction + //! and assignment. The user will need to write a move constructor/assignment as explained + //! in the documentation to fully write a movable but not copyable class. + #define BOOST_MOVABLE_BUT_NOT_COPYABLE(TYPE)\ + BOOST_MOVE_IMPL_NO_COPY_CTOR_OR_ASSIGN(TYPE)\ + public:\ + typedef int boost_move_emulation_t;\ + // + + //! This macro marks a type as copyable and movable. + //! The user will need to write a move constructor/assignment and a copy assignment + //! as explained in the documentation to fully write a copyable and movable class. + #define BOOST_COPYABLE_AND_MOVABLE(TYPE)\ + // + + #if !defined(BOOST_MOVE_DOXYGEN_INVOKED) + #define BOOST_COPYABLE_AND_MOVABLE_ALT(TYPE)\ + // + #endif //#if !defined(BOOST_MOVE_DOXYGEN_INVOKED) + + namespace boost { + + //!This trait yields to a compile-time true boolean if T was marked as + //!BOOST_MOVABLE_BUT_NOT_COPYABLE or BOOST_COPYABLE_AND_MOVABLE and + //!rvalue references are not available on the platform. False otherwise. + template + struct has_move_emulation_enabled + { + static const bool value = false; + }; + + } //namespace boost{ + + //!This macro is used to achieve portable syntax in move + //!constructors and assignments for classes marked as + //!BOOST_COPYABLE_AND_MOVABLE or BOOST_MOVABLE_BUT_NOT_COPYABLE + #define BOOST_RV_REF(TYPE)\ + TYPE && \ + // + + //!This macro is used to achieve portable syntax in move + //!constructors and assignments for template classes marked as + //!BOOST_COPYABLE_AND_MOVABLE or BOOST_MOVABLE_BUT_NOT_COPYABLE. + //!As macros have problems with comma-separated template arguments, + //!the template argument must be preceded with BOOST_RV_REF_BEG + //!and ended with BOOST_RV_REF_END + #define BOOST_RV_REF_BEG\ + \ + // + + //!This macro is used to achieve portable syntax in move + //!constructors and assignments for template classes marked as + //!BOOST_COPYABLE_AND_MOVABLE or BOOST_MOVABLE_BUT_NOT_COPYABLE. + //!As macros have problems with comma-separated template arguments, + //!the template argument must be preceded with BOOST_RV_REF_BEG + //!and ended with BOOST_RV_REF_END + #define BOOST_RV_REF_END\ + && \ + + //!This macro is used to achieve portable syntax in copy + //!assignment for classes marked as BOOST_COPYABLE_AND_MOVABLE. + #define BOOST_COPY_ASSIGN_REF(TYPE)\ + const TYPE & \ + // + + //! This macro is used to implement portable perfect forwarding + //! as explained in the documentation. + #define BOOST_FWD_REF(TYPE)\ + TYPE && \ + // + + #if !defined(BOOST_MOVE_DOXYGEN_INVOKED) + + #define BOOST_RV_REF_2_TEMPL_ARGS(TYPE, ARG1, ARG2)\ + TYPE && \ + // + + #define BOOST_RV_REF_3_TEMPL_ARGS(TYPE, ARG1, ARG2, ARG3)\ + TYPE && \ + // + + #define BOOST_COPY_ASSIGN_REF_BEG \ + const \ + // + + #define BOOST_COPY_ASSIGN_REF_END \ + & \ + // + + #define BOOST_COPY_ASSIGN_REF_2_TEMPL_ARGS(TYPE, ARG1, ARG2)\ + const TYPE & \ + // + + #define BOOST_COPY_ASSIGN_REF_3_TEMPL_ARGS(TYPE, ARG1, ARG2, ARG3)\ + const TYPE& \ + // + + #define BOOST_CATCH_CONST_RLVALUE(TYPE)\ + const TYPE & \ + // + + #endif //#if !defined(BOOST_MOVE_DOXYGEN_INVOKED) + + #if !defined(BOOST_MOVE_MSVC_AUTO_MOVE_RETURN_BUG) || defined(BOOST_MOVE_DOXYGEN_INVOKED) + + //!This macro is used to achieve portable move return semantics. + //!The C++11 Standard allows implicit move returns when the object to be returned + //!is designated by a lvalue and: + //! - The criteria for elision of a copy operation are met OR + //! - The criteria would be met save for the fact that the source object is a function parameter + //! + //!For C++11 conforming compilers this macros only yields to REF: + //! return BOOST_MOVE_RET(RET_TYPE, REF); -> return REF; + //! + //!For compilers without rvalue references + //!this macro does an explicit move if the move emulation is activated + //!and the return type (RET_TYPE) is not a reference. + //! + //!For non-conforming compilers with rvalue references like Visual 2010 & 2012, + //!an explicit move is performed if RET_TYPE is not a reference. + //! + //! Caution: When using this macro in non-conforming or C++03 + //!compilers, a move will be performed even if the C++11 standard does not allow it + //!(e.g. returning a static variable). The user is responsible for using this macro + //!only to return local objects that met C++11 criteria. + #define BOOST_MOVE_RET(RET_TYPE, REF)\ + REF + // + + #else //!defined(BOOST_MOVE_MSVC_AUTO_MOVE_RETURN_BUG) || defined(BOOST_MOVE_DOXYGEN_INVOKED) + + #include + + namespace boost { + namespace move_detail { + + template + inline typename ::boost::move_detail::enable_if_c + < ::boost::move_detail::is_lvalue_reference::value + , T&>::type + move_return(T& x) BOOST_NOEXCEPT + { + return x; + } + + template + inline typename ::boost::move_detail::enable_if_c + < !::boost::move_detail::is_lvalue_reference::value + , Ret && >::type + move_return(T&& t) BOOST_NOEXCEPT + { + return static_cast< Ret&& >(t); + } + + } //namespace move_detail { + } //namespace boost { + + #define BOOST_MOVE_RET(RET_TYPE, REF)\ + boost::move_detail::move_return< RET_TYPE >(REF) + // + + #endif //!defined(BOOST_MOVE_MSVC_AUTO_MOVE_RETURN_BUG) || defined(BOOST_MOVE_DOXYGEN_INVOKED) + + //!This macro is used to achieve portable optimal move constructors. + //! + //!When implementing the move constructor, in C++03 compilers the moved-from argument must be + //!cast to the base type before calling `::boost::move()` due to rvalue reference limitations. + //! + //!In C++11 compilers the cast from a rvalue reference of a derived type to a rvalue reference of + //!a base type is implicit. + #define BOOST_MOVE_BASE(BASE_TYPE, ARG) \ + ::boost::move((BASE_TYPE&)(ARG)) + // + + namespace boost { + namespace move_detail { + + template< class T> struct forward_type { typedef T type; }; + + }} + +#endif //BOOST_NO_CXX11_RVALUE_REFERENCES + +#include + +#endif //#ifndef BOOST_MOVE_CORE_HPP diff --git a/realsense-file/3rd_party/boost/boost/move/detail/config_begin.hpp b/realsense-file/3rd_party/boost/boost/move/detail/config_begin.hpp new file mode 100644 index 0000000000..1d49b0ae12 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/move/detail/config_begin.hpp @@ -0,0 +1,19 @@ +////////////////////////////////////////////////////////////////////////////// +// +// (C) Copyright Ion Gaztanaga 2012-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) +// +// See http://www.boost.org/libs/move for documentation. +// +////////////////////////////////////////////////////////////////////////////// +#ifndef BOOST_CONFIG_HPP +#include +#endif + +#ifdef BOOST_MSVC +# pragma warning (push) +# pragma warning (disable : 4324) // structure was padded due to __declspec(align()) +# pragma warning (disable : 4675) // "function": resolved overload was found by argument-dependent lookup +# pragma warning (disable : 4996) // "function": was declared deprecated (_CRT_SECURE_NO_DEPRECATE/_SCL_SECURE_NO_WARNINGS) +#endif diff --git a/realsense-file/3rd_party/boost/boost/move/detail/config_end.hpp b/realsense-file/3rd_party/boost/boost/move/detail/config_end.hpp new file mode 100644 index 0000000000..f5f561f429 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/move/detail/config_end.hpp @@ -0,0 +1,12 @@ +////////////////////////////////////////////////////////////////////////////// +// +// (C) Copyright Ion Gaztanaga 2012-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) +// +// See http://www.boost.org/libs/move for documentation. +// +////////////////////////////////////////////////////////////////////////////// +#if defined BOOST_MSVC +# pragma warning (pop) +#endif diff --git a/realsense-file/3rd_party/boost/boost/move/detail/meta_utils.hpp b/realsense-file/3rd_party/boost/boost/move/detail/meta_utils.hpp new file mode 100644 index 0000000000..14a9de74d9 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/move/detail/meta_utils.hpp @@ -0,0 +1,367 @@ +////////////////////////////////////////////////////////////////////////////// +// +// (C) Copyright Ion Gaztanaga 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) +// +// See http://www.boost.org/libs/move for documentation. +// +////////////////////////////////////////////////////////////////////////////// + +//! \file + +#ifndef BOOST_MOVE_DETAIL_META_UTILS_HPP +#define BOOST_MOVE_DETAIL_META_UTILS_HPP + +#ifndef BOOST_CONFIG_HPP +# include +#endif +# +#if defined(BOOST_HAS_PRAGMA_ONCE) +# pragma once +#endif +#include +#include //for std::size_t + +//Small meta-typetraits to support move + +namespace boost { + +//Forward declare boost::rv +template class rv; + +namespace move_detail { + +////////////////////////////////////// +// nat +////////////////////////////////////// +struct nat{}; + +////////////////////////////////////// +// natify +////////////////////////////////////// +template struct natify{}; + +////////////////////////////////////// +// remove_reference +////////////////////////////////////// +template +struct remove_reference +{ + typedef T type; +}; + +template +struct remove_reference +{ + typedef T type; +}; + +#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES + +template +struct remove_reference +{ + typedef T type; +}; + +#else + +template +struct remove_reference< rv > +{ + typedef T type; +}; + +template +struct remove_reference< rv &> +{ + typedef T type; +}; + +template +struct remove_reference< const rv &> +{ + typedef T type; +}; + + +#endif + +////////////////////////////////////// +// add_const +////////////////////////////////////// +template +struct add_const +{ + typedef const T type; +}; + +template +struct add_const +{ + typedef const T& type; +}; + +#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES + +template +struct add_const +{ + typedef T&& type; +}; + +#endif + +////////////////////////////////////// +// add_lvalue_reference +////////////////////////////////////// +template +struct add_lvalue_reference +{ typedef T& type; }; + +template struct add_lvalue_reference { typedef T& type; }; +template<> struct add_lvalue_reference { typedef void type; }; +template<> struct add_lvalue_reference { typedef const void type; }; +template<> struct add_lvalue_reference { typedef volatile void type; }; +template<> struct add_lvalue_reference{ typedef const volatile void type; }; + +template +struct add_const_lvalue_reference +{ + typedef typename remove_reference::type t_unreferenced; + typedef typename add_const::type t_unreferenced_const; + typedef typename add_lvalue_reference + ::type type; +}; + +////////////////////////////////////// +// is_lvalue_reference +////////////////////////////////////// +template +struct is_lvalue_reference +{ + static const bool value = false; +}; + +template +struct is_lvalue_reference +{ + static const bool value = true; +}; + +////////////////////////////////////// +// is_class_or_union +////////////////////////////////////// +template +struct is_class_or_union +{ + struct twochar { char dummy[2]; }; + template + static char is_class_or_union_tester(void(U::*)(void)); + template + static twochar is_class_or_union_tester(...); + static const bool value = sizeof(is_class_or_union_tester(0)) == sizeof(char); +}; + +////////////////////////////////////// +// addressof +////////////////////////////////////// +template +struct addr_impl_ref +{ + T & v_; + inline addr_impl_ref( T & v ): v_( v ) {} + inline operator T& () const { return v_; } + + private: + addr_impl_ref & operator=(const addr_impl_ref &); +}; + +template +struct addressof_impl +{ + static inline T * f( T & v, long ) + { + return reinterpret_cast( + &const_cast(reinterpret_cast(v))); + } + + static inline T * f( T * v, int ) + { return v; } +}; + +template +inline T * addressof( T & v ) +{ + return ::boost::move_detail::addressof_impl::f + ( ::boost::move_detail::addr_impl_ref( v ), 0 ); +} + +////////////////////////////////////// +// has_pointer_type +////////////////////////////////////// +template +struct has_pointer_type +{ + struct two { char c[2]; }; + template static two test(...); + template static char test(typename U::pointer* = 0); + static const bool value = sizeof(test(0)) == 1; +}; + +////////////////////////////////////// +// is_convertible +////////////////////////////////////// +#if defined(_MSC_VER) && (_MSC_VER >= 1400) + +//use intrinsic since in MSVC +//overaligned types can't go through ellipsis +template +struct is_convertible +{ + static const bool value = __is_convertible_to(T, U); +}; + +#else + +template +class is_convertible +{ + typedef typename add_lvalue_reference::type t_reference; + typedef char true_t; + class false_t { char dummy[2]; }; + static false_t dispatch(...); + static true_t dispatch(U); + static t_reference trigger(); + public: + static const bool value = sizeof(dispatch(trigger())) == sizeof(true_t); +}; + +#endif + +////////////////////////////////////////////////////////////////////////////// +// +// has_move_emulation_enabled_impl +// +////////////////////////////////////////////////////////////////////////////// +template +struct has_move_emulation_enabled_impl + : is_convertible< T, ::boost::rv& > +{}; + +template +struct has_move_emulation_enabled_impl +{ static const bool value = false; }; + +template +struct has_move_emulation_enabled_impl< ::boost::rv > +{ static const bool value = false; }; + +////////////////////////////////////////////////////////////////////////////// +// +// is_rv_impl +// +////////////////////////////////////////////////////////////////////////////// + +template +struct is_rv_impl +{ static const bool value = false; }; + +template +struct is_rv_impl< rv > +{ static const bool value = true; }; + +template +struct is_rv_impl< const rv > +{ static const bool value = true; }; + +// Code from Jeffrey Lee Hellrung, many thanks + +template< class T > +struct is_rvalue_reference +{ static const bool value = false; }; + +#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES + +template< class T > +struct is_rvalue_reference< T&& > +{ static const bool value = true; }; + +#else // #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES + +template< class T > +struct is_rvalue_reference< boost::rv& > +{ static const bool value = true; }; + +template< class T > +struct is_rvalue_reference< const boost::rv& > +{ static const bool value = true; }; + +#endif // #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES + +#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES + +template< class T > +struct add_rvalue_reference +{ typedef T&& type; }; + +#else // #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES + +namespace detail_add_rvalue_reference +{ + template< class T + , bool emulation = has_move_emulation_enabled_impl::value + , bool rv = is_rv_impl::value > + struct add_rvalue_reference_impl { typedef T type; }; + + template< class T, bool emulation> + struct add_rvalue_reference_impl< T, emulation, true > { typedef T & type; }; + + template< class T, bool rv > + struct add_rvalue_reference_impl< T, true, rv > { typedef ::boost::rv& type; }; +} // namespace detail_add_rvalue_reference + +template< class T > +struct add_rvalue_reference + : detail_add_rvalue_reference::add_rvalue_reference_impl +{ }; + +template< class T > +struct add_rvalue_reference +{ typedef T & type; }; + +#endif // #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES + +template< class T > struct remove_rvalue_reference { typedef T type; }; + +#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES + template< class T > struct remove_rvalue_reference< T&& > { typedef T type; }; +#else // #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES + template< class T > struct remove_rvalue_reference< rv > { typedef T type; }; + template< class T > struct remove_rvalue_reference< const rv > { typedef T type; }; + template< class T > struct remove_rvalue_reference< volatile rv > { typedef T type; }; + template< class T > struct remove_rvalue_reference< const volatile rv > { typedef T type; }; + template< class T > struct remove_rvalue_reference< rv& > { typedef T type; }; + template< class T > struct remove_rvalue_reference< const rv& > { typedef T type; }; + template< class T > struct remove_rvalue_reference< volatile rv& > { typedef T type; }; + template< class T > struct remove_rvalue_reference< const volatile rv& >{ typedef T type; }; +#endif // #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES + +// Ideas from Boost.Move review, Jeffrey Lee Hellrung: +// +//- TypeTraits metafunctions is_lvalue_reference, add_lvalue_reference, and remove_lvalue_reference ? +// Perhaps add_reference and remove_reference can be modified so that they behave wrt emulated rvalue +// references the same as wrt real rvalue references, i.e., add_reference< rv& > -> T& rather than +// rv& (since T&& & -> T&). +// +//- Add'l TypeTraits has_[trivial_]move_{constructor,assign}...? +// +//- An as_lvalue(T& x) function, which amounts to an identity operation in C++0x, but strips emulated +// rvalue references in C++03. This may be necessary to prevent "accidental moves". + +} //namespace move_detail { +} //namespace boost { + +#endif //#ifndef BOOST_MOVE_DETAIL_META_UTILS_HPP diff --git a/realsense-file/3rd_party/boost/boost/move/detail/meta_utils_core.hpp b/realsense-file/3rd_party/boost/boost/move/detail/meta_utils_core.hpp new file mode 100644 index 0000000000..e4ac2bd00a --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/move/detail/meta_utils_core.hpp @@ -0,0 +1,118 @@ +////////////////////////////////////////////////////////////////////////////// +// +// (C) Copyright Ion Gaztanaga 2015-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) +// +// See http://www.boost.org/libs/move for documentation. +// +////////////////////////////////////////////////////////////////////////////// + +//! \file + +#ifndef BOOST_MOVE_DETAIL_META_UTILS_CORE_HPP +#define BOOST_MOVE_DETAIL_META_UTILS_CORE_HPP + +#ifndef BOOST_CONFIG_HPP +# include +#endif +# +#if defined(BOOST_HAS_PRAGMA_ONCE) +# pragma once +#endif + +//Small meta-typetraits to support move + +namespace boost { +namespace move_detail { + +////////////////////////////////////// +// if_c +////////////////////////////////////// +template +struct if_c +{ + typedef T1 type; +}; + +template +struct if_c +{ + typedef T2 type; +}; + +////////////////////////////////////// +// if_ +////////////////////////////////////// +template +struct if_ : if_c<0 != T1::value, T2, T3> +{}; + +//enable_if_ +template +struct enable_if_c +{ + typedef T type; +}; + +////////////////////////////////////// +// enable_if_c +////////////////////////////////////// +template +struct enable_if_c {}; + +////////////////////////////////////// +// enable_if +////////////////////////////////////// +template +struct enable_if : enable_if_c {}; + +////////////////////////////////////// +// disable_if +////////////////////////////////////// +template +struct disable_if : enable_if_c {}; + +////////////////////////////////////// +// integral_constant +////////////////////////////////////// +template +struct integral_constant +{ + static const T value = v; + typedef T value_type; + typedef integral_constant type; +}; + +typedef integral_constant true_type; +typedef integral_constant false_type; + +////////////////////////////////////// +// identity +////////////////////////////////////// +template +struct identity +{ + typedef T type; +}; + +////////////////////////////////////// +// is_same +////////////////////////////////////// +template +struct is_same +{ + static const bool value = false; +}; + +template +struct is_same +{ + static const bool value = true; +}; + +} //namespace move_detail { +} //namespace boost { + +#endif //#ifndef BOOST_MOVE_DETAIL_META_UTILS_CORE_HPP diff --git a/realsense-file/3rd_party/boost/boost/move/detail/type_traits.hpp b/realsense-file/3rd_party/boost/boost/move/detail/type_traits.hpp new file mode 100644 index 0000000000..91481eb883 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/move/detail/type_traits.hpp @@ -0,0 +1,1003 @@ +////////////////////////////////////////////////////////////////////////////// +// (C) Copyright John Maddock 2000. +// (C) Copyright Ion Gaztanaga 2005-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) +// +// See http://www.boost.org/libs/move for documentation. +// +// The alignment and Type traits implementation comes from +// John Maddock's TypeTraits library. +// +// Some other tricks come from Howard Hinnant's papers and StackOverflow replies +////////////////////////////////////////////////////////////////////////////// +#ifndef BOOST_MOVE_DETAIL_TYPE_TRAITS_HPP +#define BOOST_MOVE_DETAIL_TYPE_TRAITS_HPP + +#ifndef BOOST_CONFIG_HPP +# include +#endif +# +#if defined(BOOST_HAS_PRAGMA_ONCE) +# pragma once +#endif + +#include +#include + +// move/detail +#include +// other +#include +#include +// std +#include + +//Use of Boost.TypeTraits leads to long preprocessed source code due to +//MPL dependencies. We'll use intrinsics directly and make or own +//simplified version of TypeTraits. +//If someday Boost.TypeTraits dependencies are minimized, we should +//revisit this file redirecting code to Boost.TypeTraits traits. + +//These traits don't care about volatile, reference or other checks +//made by Boost.TypeTraits because no volatile or reference types +//can be hold in Boost.Containers. This helps to avoid any Boost.TypeTraits +//dependency. + +// Helper macros for builtin compiler support. +// If your compiler has builtin support for any of the following +// traits concepts, then redefine the appropriate macros to pick +// up on the compiler support: +// +// (these should largely ignore cv-qualifiers) +// BOOST_MOVE_IS_POD(T) should evaluate to true if T is a POD type +// BOOST_MOVE_HAS_TRIVIAL_CONSTRUCTOR(T) should evaluate to true if "T x;" has no effect +// BOOST_MOVE_HAS_TRIVIAL_COPY(T) should evaluate to true if T(t) <==> memcpy +// BOOST_MOVE_HAS_TRIVIAL_MOVE_CONSTRUCTOR(T) should evaluate to true if T(boost::move(t)) <==> memcpy +// BOOST_MOVE_HAS_TRIVIAL_ASSIGN(T) should evaluate to true if t = u <==> memcpy +// BOOST_MOVE_HAS_TRIVIAL_MOVE_ASSIGN(T) should evaluate to true if t = boost::move(u) <==> memcpy +// BOOST_MOVE_HAS_TRIVIAL_DESTRUCTOR(T) should evaluate to true if ~T() has no effect +// BOOST_MOVE_HAS_NOTHROW_CONSTRUCTOR(T) should evaluate to true if "T x;" can not throw +// BOOST_MOVE_HAS_NOTHROW_COPY(T) should evaluate to true if T(t) can not throw +// BOOST_MOVE_HAS_NOTHROW_ASSIGN(T) should evaluate to true if t = u can not throw +// BOOST_MOVE_IS_ENUM(T) should evaluate to true it t is a union type. +// +// The following can also be defined: when detected our implementation is greatly simplified. +// +// BOOST_ALIGNMENT_OF(T) should evaluate to the alignment requirements of type T. + +#if defined(__MSL_CPP__) && (__MSL_CPP__ >= 0x8000) + // Metrowerks compiler is acquiring intrinsic type traits support + // post version 8. We hook into the published interface to pick up + // user defined specializations as well as compiler intrinsics as + // and when they become available: +# include +# define BOOST_MOVE_IS_UNION(T) BOOST_STD_EXTENSION_NAMESPACE::is_union::value +# define BOOST_MOVE_IS_POD(T) BOOST_STD_EXTENSION_NAMESPACE::is_POD::value +# define BOOST_MOVE_HAS_TRIVIAL_CONSTRUCTOR(T) BOOST_STD_EXTENSION_NAMESPACE::has_trivial_default_ctor::value +# define BOOST_MOVE_HAS_TRIVIAL_COPY(T) BOOST_STD_EXTENSION_NAMESPACE::has_trivial_copy_ctor::value +# define BOOST_MOVE_HAS_TRIVIAL_ASSIGN(T) BOOST_STD_EXTENSION_NAMESPACE::has_trivial_assignment::value +# define BOOST_MOVE_HAS_TRIVIAL_DESTRUCTOR(T) BOOST_STD_EXTENSION_NAMESPACE::has_trivial_dtor::value +#endif + +#if (defined(BOOST_MSVC) && defined(BOOST_MSVC_FULL_VER) && (BOOST_MSVC_FULL_VER >=140050215))\ + || (defined(BOOST_INTEL) && defined(_MSC_VER) && (_MSC_VER >= 1500)) +# define BOOST_MOVE_IS_UNION(T) __is_union(T) +# define BOOST_MOVE_IS_POD(T) (__is_pod(T) && __has_trivial_constructor(T)) +# define BOOST_MOVE_IS_EMPTY(T) __is_empty(T) +# define BOOST_MOVE_HAS_TRIVIAL_CONSTRUCTOR(T) __has_trivial_constructor(T) +# define BOOST_MOVE_HAS_TRIVIAL_COPY(T) (__has_trivial_copy(T)|| ::boost::move_detail::is_pod::value) +# define BOOST_MOVE_HAS_TRIVIAL_ASSIGN(T) (__has_trivial_assign(T) || ::boost::move_detail::is_pod::value) +# define BOOST_MOVE_HAS_TRIVIAL_DESTRUCTOR(T) (__has_trivial_destructor(T) || ::boost::move_detail::is_pod::value) +# define BOOST_MOVE_HAS_NOTHROW_CONSTRUCTOR(T) (__has_nothrow_constructor(T) || ::boost::move_detail::is_trivially_default_constructible::value) +# define BOOST_MOVE_HAS_NOTHROW_COPY(T) (__has_nothrow_copy(T) || ::boost::move_detail::is_trivially_copy_constructible::value) +# define BOOST_MOVE_HAS_NOTHROW_ASSIGN(T) (__has_nothrow_assign(T) || ::boost::move_detail::is_trivially_copy_assignable::value) + +# define BOOST_MOVE_IS_ENUM(T) __is_enum(T) +# if defined(_MSC_VER) && (_MSC_VER >= 1700) +# define BOOST_MOVE_HAS_TRIVIAL_MOVE_CONSTRUCTOR(T) (__has_trivial_move_constructor(T) || ::boost::move_detail::is_pod::value) +# define BOOST_MOVE_HAS_TRIVIAL_MOVE_ASSIGN(T) (__has_trivial_move_assign(T) || ::boost::move_detail::is_pod::value) +# endif +#endif + +#if defined(BOOST_CLANG) && defined(__has_feature) + +# if __has_feature(is_union) +# define BOOST_MOVE_IS_UNION(T) __is_union(T) +# endif +# if (!defined(__GLIBCXX__) || (__GLIBCXX__ >= 20080306 && __GLIBCXX__ != 20080519)) && __has_feature(is_pod) +# define BOOST_MOVE_IS_POD(T) __is_pod(T) +# endif +# if (!defined(__GLIBCXX__) || (__GLIBCXX__ >= 20080306 && __GLIBCXX__ != 20080519)) && __has_feature(is_empty) +# define BOOST_MOVE_IS_EMPTY(T) __is_empty(T) +# endif +# if __has_feature(has_trivial_constructor) +# define BOOST_MOVE_HAS_TRIVIAL_CONSTRUCTOR(T) __has_trivial_constructor(T) +# endif +# if __has_feature(has_trivial_copy) +# //There are problems with deleted copy constructors detected as trivially copyable. +# //http://stackoverflow.com/questions/12754886/has-trivial-copy-behaves-differently-in-clang-and-gcc-whos-right +# define BOOST_MOVE_HAS_TRIVIAL_COPY(T) (__has_trivial_copy(T) && ::boost::move_detail::is_copy_constructible::value) +# endif +# if __has_feature(has_trivial_assign) +# define BOOST_MOVE_HAS_TRIVIAL_ASSIGN(T) (__has_trivial_assign(T) ) +# endif +# if __has_feature(has_trivial_destructor) +# define BOOST_MOVE_HAS_TRIVIAL_DESTRUCTOR(T) __has_trivial_destructor(T) +# endif +# if __has_feature(has_nothrow_constructor) +# define BOOST_MOVE_HAS_NOTHROW_CONSTRUCTOR(T) __has_nothrow_constructor(T) +# endif +# if __has_feature(has_nothrow_copy) +# define BOOST_MOVE_HAS_NOTHROW_COPY(T) (__has_nothrow_copy(T)) +# endif +# if __has_feature(is_nothrow_copy_assignable) +# define BOOST_MOVE_HAS_NOTHROW_ASSIGN(T) (__has_nothrow_assign(T)) +# endif +# if __has_feature(is_enum) +# define BOOST_MOVE_IS_ENUM(T) __is_enum(T) +# endif +# if __has_feature(has_trivial_move_constructor) +# define BOOST_MOVE_HAS_TRIVIAL_MOVE_CONSTRUCTOR(T) __has_trivial_move_constructor(T) +# endif +# if __has_feature(has_trivial_move_assign) +# define BOOST_MOVE_HAS_TRIVIAL_MOVE_ASSIGN(T) __has_trivial_move_assign(T) +# endif +# define BOOST_MOVE_ALIGNMENT_OF(T) __alignof(T) +#endif + +#if defined(__GNUC__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 3) && !defined(__GCCXML__))) && !defined(BOOST_CLANG) + +#ifdef BOOST_INTEL +# define BOOST_MOVE_INTEL_TT_OPTS || ::boost::move_detail::is_pod::value +#else +# define BOOST_MOVE_INTEL_TT_OPTS +#endif + +# define BOOST_MOVE_IS_UNION(T) __is_union(T) +# define BOOST_MOVE_IS_POD(T) __is_pod(T) +# define BOOST_MOVE_IS_EMPTY(T) __is_empty(T) +# define BOOST_MOVE_HAS_TRIVIAL_CONSTRUCTOR(T) ((__has_trivial_constructor(T) BOOST_MOVE_INTEL_TT_OPTS)) +# define BOOST_MOVE_HAS_TRIVIAL_COPY(T) ((__has_trivial_copy(T) BOOST_MOVE_INTEL_TT_OPTS)) +# define BOOST_MOVE_HAS_TRIVIAL_ASSIGN(T) ((__has_trivial_assign(T) BOOST_MOVE_INTEL_TT_OPTS) ) +# define BOOST_MOVE_HAS_TRIVIAL_DESTRUCTOR(T) (__has_trivial_destructor(T) BOOST_MOVE_INTEL_TT_OPTS) +# define BOOST_MOVE_HAS_NOTHROW_CONSTRUCTOR(T) (__has_nothrow_constructor(T) BOOST_MOVE_INTEL_TT_OPTS) +# define BOOST_MOVE_HAS_NOTHROW_COPY(T) ((__has_nothrow_copy(T) BOOST_MOVE_INTEL_TT_OPTS)) +# define BOOST_MOVE_HAS_NOTHROW_ASSIGN(T) ((__has_nothrow_assign(T) BOOST_MOVE_INTEL_TT_OPTS)) + +# define BOOST_MOVE_IS_ENUM(T) __is_enum(T) +# if (!defined(unix) && !defined(__unix__)) || defined(__LP64__) + // GCC sometimes lies about alignment requirements + // of type double on 32-bit unix platforms, use the + // old implementation instead in that case: +# define BOOST_MOVE_ALIGNMENT_OF(T) __alignof__(T) +# endif +#endif + +#if defined(__ghs__) && (__GHS_VERSION_NUMBER >= 600) + +# define BOOST_MOVE_IS_UNION(T) __is_union(T) +# define BOOST_MOVE_IS_POD(T) __is_pod(T) +# define BOOST_MOVE_IS_EMPTY(T) __is_empty(T) +# define BOOST_MOVE_HAS_TRIVIAL_CONSTRUCTOR(T) __has_trivial_constructor(T) +# define BOOST_MOVE_HAS_TRIVIAL_COPY(T) (__has_trivial_copy(T)) +# define BOOST_MOVE_HAS_TRIVIAL_ASSIGN(T) (__has_trivial_assign(T)) +# define BOOST_MOVE_HAS_TRIVIAL_DESTRUCTOR(T) __has_trivial_destructor(T) +# define BOOST_MOVE_HAS_NOTHROW_CONSTRUCTOR(T) __has_nothrow_constructor(T) +# define BOOST_MOVE_HAS_NOTHROW_COPY(T) (__has_nothrow_copy(T)) +# define BOOST_MOVE_HAS_NOTHROW_ASSIGN(T) (__has_nothrow_assign(T)) + +# define BOOST_MOVE_IS_ENUM(T) __is_enum(T) +# define BOOST_MOVE_ALIGNMENT_OF(T) __alignof__(T) +#endif + +# if defined(__CODEGEARC__) +# define BOOST_MOVE_IS_UNION(T) __is_union(T) +# define BOOST_MOVE_IS_POD(T) __is_pod(T) +# define BOOST_MOVE_IS_EMPTY(T) __is_empty(T) +# define BOOST_MOVE_HAS_TRIVIAL_CONSTRUCTOR(T) (__has_trivial_default_constructor(T)) +# define BOOST_MOVE_HAS_TRIVIAL_COPY(T) (__has_trivial_copy_constructor(T)) +# define BOOST_MOVE_HAS_TRIVIAL_ASSIGN(T) (__has_trivial_assign(T)) +# define BOOST_MOVE_HAS_TRIVIAL_DESTRUCTOR(T) (__has_trivial_destructor(T)) +# define BOOST_MOVE_HAS_NOTHROW_CONSTRUCTOR(T) (__has_nothrow_default_constructor(T)) +# define BOOST_MOVE_HAS_NOTHROW_COPY(T) (__has_nothrow_copy_constructor(T)) +# define BOOST_MOVE_HAS_NOTHROW_ASSIGN(T) (__has_nothrow_assign(T)) + +# define BOOST_MOVE_IS_ENUM(T) __is_enum(T) +# define BOOST_MOVE_ALIGNMENT_OF(T) alignof(T) + +#endif + +//Fallback definitions + +#ifdef BOOST_MOVE_IS_UNION + #define BOOST_MOVE_IS_UNION_IMPL(T) BOOST_MOVE_IS_UNION(T) +#else + #define BOOST_MOVE_IS_UNION_IMPL(T) false +#endif + +#ifdef BOOST_MOVE_IS_POD + #define BOOST_MOVE_IS_POD_IMPL(T) BOOST_MOVE_IS_POD(T) +#else + #define BOOST_MOVE_IS_POD_IMPL(T) \ + (::boost::move_detail::is_scalar::value || ::boost::move_detail::is_void::value) +#endif + +#ifdef BOOST_MOVE_IS_EMPTY + #define BOOST_MOVE_IS_EMPTY_IMPL(T) BOOST_MOVE_IS_EMPTY(T) +#else + #define BOOST_MOVE_IS_EMPTY_IMPL(T) ::boost::move_detail::is_empty_nonintrinsic::value +#endif + +#ifdef BOOST_MOVE_HAS_TRIVIAL_COPY + #define BOOST_MOVE_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T) BOOST_MOVE_HAS_TRIVIAL_COPY(T) +#else + #define BOOST_MOVE_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T) ::boost::move_detail::is_pod::value +#endif + +#ifdef BOOST_MOVE_HAS_TRIVIAL_CONSTRUCTOR + #define BOOST_MOVE_IS_TRIVIALLY_DEFAULT_CONSTRUCTIBLE(T) BOOST_MOVE_HAS_TRIVIAL_CONSTRUCTOR(T) +#else + #define BOOST_MOVE_IS_TRIVIALLY_DEFAULT_CONSTRUCTIBLE(T) ::boost::move_detail::is_pod::value +#endif + +#ifdef BOOST_MOVE_HAS_TRIVIAL_COPY + #define BOOST_MOVE_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T) BOOST_MOVE_HAS_TRIVIAL_COPY(T) +#else + #define BOOST_MOVE_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T) ::boost::move_detail::is_pod::value +#endif + +#ifdef BOOST_MOVE_HAS_TRIVIAL_MOVE_CONSTRUCTOR + #define BOOST_MOVE_IS_TRIVIALLY_MOVE_CONSTRUCTIBLE(T) BOOST_MOVE_HAS_TRIVIAL_MOVE_CONSTRUCTOR(T) +#else + #define BOOST_MOVE_IS_TRIVIALLY_MOVE_CONSTRUCTIBLE(T) ::boost::move_detail::is_pod::value +#endif + +#ifdef BOOST_MOVE_HAS_TRIVIAL_ASSIGN + #define BOOST_MOVE_IS_TRIVIALLY_COPY_ASSIGNABLE(T) BOOST_MOVE_HAS_TRIVIAL_ASSIGN(T) +#else + #define BOOST_MOVE_IS_TRIVIALLY_COPY_ASSIGNABLE(T) ::boost::move_detail::is_pod::value +#endif + +#ifdef BOOST_MOVE_HAS_TRIVIAL_MOVE_ASSIGN + #define BOOST_MOVE_IS_TRIVIALLY_MOVE_ASSIGNABLE(T) BOOST_MOVE_HAS_TRIVIAL_MOVE_ASSIGN(T) +#else + #define BOOST_MOVE_IS_TRIVIALLY_MOVE_ASSIGNABLE(T) ::boost::move_detail::is_pod::value +#endif + +#ifdef BOOST_MOVE_HAS_TRIVIAL_DESTRUCTOR + #define BOOST_MOVE_IS_TRIVIALLY_DESTRUCTIBLE(T) BOOST_MOVE_HAS_TRIVIAL_DESTRUCTOR(T) +#else + #define BOOST_MOVE_IS_TRIVIALLY_DESTRUCTIBLE(T) ::boost::move_detail::is_pod::value +#endif + +#ifdef BOOST_MOVE_HAS_NOTHROW_CONSTRUCTOR + #define BOOST_MOVE_IS_NOTHROW_DEFAULT_CONSTRUCTIBLE(T) BOOST_MOVE_HAS_NOTHROW_CONSTRUCTOR(T) +#else + #define BOOST_MOVE_IS_NOTHROW_DEFAULT_CONSTRUCTIBLE(T) ::boost::move_detail::is_pod::value +#endif + +#ifdef BOOST_MOVE_HAS_NOTHROW_COPY + #define BOOST_MOVE_IS_NOTHROW_COPY_CONSTRUCTIBLE(T) BOOST_MOVE_HAS_NOTHROW_COPY(T) +#else + #define BOOST_MOVE_IS_NOTHROW_COPY_CONSTRUCTIBLE(T) ::boost::move_detail::is_pod::value +#endif + +#ifdef BOOST_MOVE_HAS_NOTHROW_MOVE + #define BOOST_MOVE_IS_NOTHROW_MOVE_CONSTRUCTIBLE(T) BOOST_MOVE_HAS_NOTHROW_MOVE(T) +#else + #define BOOST_MOVE_IS_NOTHROW_MOVE_CONSTRUCTIBLE(T) ::boost::move_detail::is_pod::value +#endif + +#ifdef BOOST_MOVE_HAS_NOTHROW_ASSIGN + #define BOOST_MOVE_IS_NOTHROW_COPY_ASSIGNABLE(T) BOOST_MOVE_HAS_NOTHROW_ASSIGN(T) +#else + #define BOOST_MOVE_IS_NOTHROW_COPY_ASSIGNABLE(T) ::boost::move_detail::is_pod::value +#endif + +#ifdef BOOST_MOVE_HAS_NOTHROW_MOVE_ASSIGN + #define BOOST_MOVE_IS_NOTHROW_MOVE_ASSIGNABLE(T) BOOST_MOVE_HAS_NOTHROW_MOVE_ASSIGN(T) +#else + #define BOOST_MOVE_IS_NOTHROW_MOVE_ASSIGNABLE(T) ::boost::move_detail::is_pod::value +#endif + +#ifdef BOOST_MOVE_IS_ENUM + #define BOOST_MOVE_IS_ENUM_IMPL(T) BOOST_MOVE_IS_ENUM(T) +#else + #define BOOST_MOVE_IS_ENUM_IMPL(T) ::boost::move_detail::is_enum_nonintrinsic::value +#endif + +namespace boost { +namespace move_detail { + +////////////////////////// +// is_reference +////////////////////////// +template +struct is_reference +{ static const bool value = false; }; + +template +struct is_reference +{ static const bool value = true; }; + +#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) +template +struct is_reference +{ static const bool value = true; }; +#endif + +////////////////////////// +// is_pointer +////////////////////////// +template +struct is_pointer +{ static const bool value = false; }; + +template +struct is_pointer +{ static const bool value = true; }; + +////////////////////////// +// add_reference +////////////////////////// +template +struct add_reference +{ typedef T& type; }; + +template +struct add_reference +{ typedef T& type; }; + +template<> +struct add_reference +{ typedef nat &type; }; + +template<> +struct add_reference +{ typedef const nat &type; }; + +////////////////////////// +// add_const_reference +////////////////////////// +template +struct add_const_reference +{ typedef const T &type; }; + +template +struct add_const_reference +{ typedef T& type; }; + +////////////////////////// +// remove_const +////////////////////////// +template +struct remove_const +{ typedef T type; }; + +template +struct remove_const< const T> +{ typedef T type; }; + +////////////////////////// +// remove_cv +////////////////////////// +template struct remove_cv { typedef T type; }; +template struct remove_cv { typedef T type; }; +template struct remove_cv { typedef T type; }; +template struct remove_cv { typedef T type; }; + +////////////////////////// +// make_unsigned +////////////////////////// +template +struct make_unsigned_impl { typedef T type; }; +template <> struct make_unsigned_impl { typedef unsigned char type; }; +template <> struct make_unsigned_impl { typedef unsigned short type; }; +template <> struct make_unsigned_impl { typedef unsigned int type; }; +template <> struct make_unsigned_impl { typedef unsigned long type; }; +#ifdef BOOST_HAS_LONG_LONG +template <> struct make_unsigned_impl< ::boost::long_long_type > { typedef ::boost::ulong_long_type type; }; +#endif + +template +struct make_unsigned + : make_unsigned_impl::type> +{}; + +////////////////////////// +// is_floating_point +////////////////////////// +template struct is_floating_point_cv { static const bool value = false; }; +template<> struct is_floating_point_cv { static const bool value = true; }; +template<> struct is_floating_point_cv { static const bool value = true; }; +template<> struct is_floating_point_cv { static const bool value = true; }; + +template +struct is_floating_point + : is_floating_point_cv::type> +{}; + +////////////////////////// +// is_integral +////////////////////////// +template struct is_integral_cv { static const bool value = false; }; +template<> struct is_integral_cv< bool>{ static const bool value = true; }; +template<> struct is_integral_cv< char>{ static const bool value = true; }; +template<> struct is_integral_cv< unsigned char>{ static const bool value = true; }; +template<> struct is_integral_cv< signed char>{ static const bool value = true; }; +#ifndef BOOST_NO_CXX11_CHAR16_T +template<> struct is_integral_cv< char16_t>{ static const bool value = true; }; +#endif +#ifndef BOOST_NO_CXX11_CHAR32_T +template<> struct is_integral_cv< char32_t>{ static const bool value = true; }; +#endif +#ifndef BOOST_NO_INTRINSIC_WCHAR_T +template<> struct is_integral_cv< wchar_t>{ static const bool value = true; }; +#endif +template<> struct is_integral_cv< short>{ static const bool value = true; }; +template<> struct is_integral_cv< unsigned short>{ static const bool value = true; }; +template<> struct is_integral_cv< int>{ static const bool value = true; }; +template<> struct is_integral_cv< unsigned int>{ static const bool value = true; }; +template<> struct is_integral_cv< long>{ static const bool value = true; }; +template<> struct is_integral_cv< unsigned long>{ static const bool value = true; }; +#ifdef BOOST_HAS_LONG_LONG +template<> struct is_integral_cv< ::boost:: long_long_type>{ static const bool value = true; }; +template<> struct is_integral_cv< ::boost::ulong_long_type>{ static const bool value = true; }; +#endif + +template +struct is_integral + : public is_integral_cv::type> +{}; + +////////////////////////////////////// +// remove_all_extents +////////////////////////////////////// +template +struct remove_all_extents +{ typedef T type;}; + +template +struct remove_all_extents +{ typedef typename remove_all_extents::type type; }; + +template +struct remove_all_extents +{ typedef typename remove_all_extents::type type;}; + +////////////////////////// +// is_scalar +////////////////////////// +template +struct is_scalar +{ static const bool value = is_integral::value || is_floating_point::value; }; + +////////////////////////// +// is_void +////////////////////////// +template +struct is_void_cv +{ static const bool value = false; }; + +template<> +struct is_void_cv +{ static const bool value = true; }; + +template +struct is_void + : is_void_cv::type> +{}; + +////////////////////////////////////// +// is_array +////////////////////////////////////// +template +struct is_array +{ static const bool value = false; }; + +template +struct is_array +{ static const bool value = true; }; + +template +struct is_array +{ static const bool value = true; }; + +////////////////////////////////////// +// is_member_pointer +////////////////////////////////////// +template struct is_member_pointer_cv { static const bool value = false; }; +template struct is_member_pointer_cv { static const bool value = true; }; + +template +struct is_member_pointer + : is_member_pointer_cv::type> +{}; + +////////////////////////////////////// +// is_nullptr_t +////////////////////////////////////// +template +struct is_nullptr_t_cv +{ static const bool value = false; }; + +#if !defined(BOOST_NO_CXX11_NULLPTR) +template <> +struct is_nullptr_t_cv + #if !defined(BOOST_NO_CXX11_DECLTYPE) + + #else + + #endif +{ static const bool value = true; }; +#endif + +template +struct is_nullptr_t + : is_nullptr_t_cv::type> +{}; + +////////////////////////////////////// +// is_function +////////////////////////////////////// +//Inspired by libc++, thanks to Howard Hinnant +//For a function to pointer an lvalue of function type T can be implicitly converted to a prvalue +//pointer to that function. This does not apply to non-static member functions because lvalues +//that refer to non-static member functions do not exist. +template +struct is_reference_convertible_to_pointer +{ + struct twochar { char dummy[2]; }; + template static char test(U*); + template static twochar test(...); + static T& source(); + static const bool value = sizeof(char) == sizeof(test(source())); +}; +//Filter out: +// - class types that might have implicit conversions +// - void (to avoid forming a reference to void later) +// - references (e.g.: filtering reference to functions) +// - nullptr_t (convertible to pointer) +template < class T + , bool Filter = is_class_or_union::value || + is_void::value || + is_reference::value || + is_nullptr_t::value > +struct is_function_impl +{ static const bool value = is_reference_convertible_to_pointer::value; }; + +template +struct is_function_impl +{ static const bool value = false; }; + +template +struct is_function + : is_function_impl +{}; + +////////////////////////////////////// +// is_union +////////////////////////////////////// +template +struct is_union_noextents_cv +{ static const bool value = BOOST_MOVE_IS_UNION_IMPL(T); }; + +template +struct is_union + : is_union_noextents_cv::type>::type> +{}; + +////////////////////////////////////// +// is_class +////////////////////////////////////// +template +struct is_class +{ + static const bool value = is_class_or_union::value && ! is_union::value; +}; + + +////////////////////////////////////// +// is_arithmetic +////////////////////////////////////// +template +struct is_arithmetic +{ + static const bool value = is_floating_point::value || + is_integral::value; +}; + +////////////////////////////////////// +// is_member_function_pointer +////////////////////////////////////// +template +struct is_member_function_pointer_cv +{ + static const bool value = false; +}; + +template +struct is_member_function_pointer_cv + : is_function +{}; + +template +struct is_member_function_pointer + : is_member_function_pointer_cv::type> +{}; + +////////////////////////////////////// +// is_enum +////////////////////////////////////// +#if !defined(BOOST_MOVE_IS_ENUM) +//Based on (http://howardhinnant.github.io/TypeHiearchy.pdf) +template +struct is_enum_nonintrinsic +{ + static const bool value = !is_arithmetic::value && + !is_reference::value && + !is_class_or_union::value && + !is_array::value && + !is_void::value && + !is_nullptr_t::value && + !is_member_pointer::value && + !is_pointer::value && + !is_function::value; +}; +#endif + +template +struct is_enum +{ static const bool value = BOOST_MOVE_IS_ENUM_IMPL(T); }; + +////////////////////////////////////// +// is_pod +////////////////////////////////////// +template +struct is_pod_noextents_cv //for non-c++11 compilers, a safe fallback +{ static const bool value = BOOST_MOVE_IS_POD_IMPL(T); }; + +template +struct is_pod + : is_pod_noextents_cv::type>::type> +{}; + +////////////////////////////////////// +// is_empty +////////////////////////////////////// +#if !defined(BOOST_MOVE_IS_EMPTY) + +template +struct empty_helper_t1 : public T +{ + empty_helper_t1(); // hh compiler bug workaround + int i[256]; + private: + + empty_helper_t1(const empty_helper_t1&); + empty_helper_t1& operator=(const empty_helper_t1&); +}; + +struct empty_helper_t2 { int i[256]; }; + +template ::value > +struct is_empty_nonintrinsic +{ + static const bool value = false; +}; + +template +struct is_empty_nonintrinsic +{ + static const bool value = sizeof(empty_helper_t1) == sizeof(empty_helper_t2); +}; +#endif + +template +struct is_empty +{ static const bool value = BOOST_MOVE_IS_EMPTY_IMPL(T); }; + +////////////////////////////////////// +// is_copy_constructible +////////////////////////////////////// +template +struct is_copy_constructible +{ + typedef char yes_type; + struct no_type { char dummy[2]; }; + template static typename add_reference::type source(); + + // Intel compiler has problems with SFINAE for copy constructors and deleted functions: + // + // error: function *function_name* cannot be referenced -- it is a deleted function + // static yes_type test(U&, decltype(U(boost::declval()))* = 0); + // ^ + // MSVC 12.0 (Visual 2013) has problems when the copy constructor has been deleted. See: + // https://connect.microsoft.com/VisualStudio/feedback/details/800328/std-is-copy-constructible-is-broken + #if !defined(BOOST_NO_CXX11_DELETED_FUNCTIONS) && !defined(BOOST_INTEL_CXX_VERSION) &&\ + !(defined(BOOST_MSVC) && _MSC_VER == 1800) + static no_type test(...); + #ifdef BOOST_NO_CXX11_DECLTYPE + template + static yes_type test(U&, bool_()))>* = 0); + #else + template + static yes_type test(U&, decltype(U(source()))* = 0); + #endif + #else + template + static no_type test(U&, typename U::boost_move_no_copy_constructor_or_assign* = 0); + static yes_type test(...); + #endif + + static const bool value = sizeof(test(source())) == sizeof(yes_type); +}; + +////////////////////////////////////// +// is_trivially_destructible +////////////////////////////////////// +template +struct is_trivially_destructible +{ static const bool value = BOOST_MOVE_IS_TRIVIALLY_DESTRUCTIBLE(T); }; + +////////////////////////////////////// +// is_trivially_default_constructible +////////////////////////////////////// +template +struct is_trivially_default_constructible +{ static const bool value = BOOST_MOVE_IS_TRIVIALLY_DEFAULT_CONSTRUCTIBLE(T); }; + +////////////////////////////////////// +// is_trivially_copy_constructible +////////////////////////////////////// +template +struct is_trivially_copy_constructible +{ static const bool value = BOOST_MOVE_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T); }; + +////////////////////////////////////// +// is_trivially_move_constructible +////////////////////////////////////// +template +struct is_trivially_move_constructible +{ static const bool value = BOOST_MOVE_IS_TRIVIALLY_MOVE_CONSTRUCTIBLE(T); }; + +////////////////////////////////////// +// is_trivially_copy_assignable +////////////////////////////////////// +template +struct is_trivially_copy_assignable +{ static const bool value = BOOST_MOVE_IS_TRIVIALLY_COPY_ASSIGNABLE(T); }; + +////////////////////////////////////// +// is_trivially_move_assignable +////////////////////////////////////// +template +struct is_trivially_move_assignable +{ static const bool value = BOOST_MOVE_IS_TRIVIALLY_MOVE_ASSIGNABLE(T); }; + +////////////////////////////////////// +// is_nothrow_default_constructible +////////////////////////////////////// +template +struct is_nothrow_default_constructible + : is_pod +{ static const bool value = BOOST_MOVE_IS_NOTHROW_DEFAULT_CONSTRUCTIBLE(T); }; + +////////////////////////////////////// +// is_nothrow_copy_constructible +////////////////////////////////////// +template +struct is_nothrow_copy_constructible +{ static const bool value = BOOST_MOVE_IS_NOTHROW_COPY_CONSTRUCTIBLE(T); }; + +////////////////////////////////////// +// is_nothrow_move_constructible +////////////////////////////////////// +template +struct is_nothrow_move_constructible +{ static const bool value = BOOST_MOVE_IS_NOTHROW_MOVE_CONSTRUCTIBLE(T); }; + +////////////////////////////////////// +// is_nothrow_copy_assignable +////////////////////////////////////// +template +struct is_nothrow_copy_assignable +{ static const bool value = BOOST_MOVE_IS_NOTHROW_COPY_ASSIGNABLE(T); }; + +////////////////////////////////////// +// is_nothrow_move_assignable +////////////////////////////////////// +template +struct is_nothrow_move_assignable +{ static const bool value = BOOST_MOVE_IS_NOTHROW_MOVE_ASSIGNABLE(T); }; + +////////////////////////////////////// +// is_nothrow_swappable +////////////////////////////////////// +template +struct is_nothrow_swappable +{ + static const bool value = is_empty::value || is_pod::value; +}; + +////////////////////////////////////// +// alignment_of +////////////////////////////////////// +template +struct alignment_of_hack +{ + T t1; + char c; + T t2; + alignment_of_hack(); +}; + +template +struct alignment_logic +{ static const std::size_t value = A < S ? A : S; }; + +template< typename T > +struct alignment_of_impl +#if defined(BOOST_MSVC) && (BOOST_MSVC >= 1400) + // With MSVC both the native __alignof operator + // and our own logic gets things wrong from time to time :-( + // Using a combination of the two seems to make the most of a bad job: + : alignment_logic< sizeof(alignment_of_hack) - 2*sizeof(T), __alignof(T)> +{}; +#elif !defined(BOOST_MOVE_ALIGNMENT_OF) + : alignment_logic< sizeof(alignment_of_hack) - 2*sizeof(T), sizeof(T)> +{}; +#else +{ static const std::size_t value = BOOST_MOVE_ALIGNMENT_OF(T); }; +#endif + +template< typename T > +struct alignment_of + : alignment_of_impl +{}; + +class alignment_dummy; +typedef void (*function_ptr)(); +typedef int (alignment_dummy::*member_ptr); +typedef int (alignment_dummy::*member_function_ptr)(); +struct alignment_struct +{ long double dummy[4]; }; + +///////////////////////////// +// max_align_t +///////////////////////////// +//This is not standard, but should work with all compilers +union max_align +{ + char char_; + short short_; + int int_; + long long_; + #ifdef BOOST_HAS_LONG_LONG + ::boost::long_long_type long_long_; + #endif + float float_; + double double_; + void * void_ptr_; + long double long_double_[4]; + alignment_dummy *unknown_class_ptr_; + function_ptr function_ptr_; + member_function_ptr member_function_ptr_; + alignment_struct alignment_struct_; +}; + +typedef union max_align max_align_t; + +///////////////////////////// +// aligned_storage +///////////////////////////// + +#if !defined(BOOST_NO_ALIGNMENT) + +template +struct aligned_storage_impl; + +#define BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(A)\ +template\ +struct BOOST_ALIGNMENT(A) aligned_storage_impl\ +{\ + char dummy[Len];\ + typedef aligned_storage_impl type;\ +};\ +// + +//Up to 4K alignment (typical page size) +BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(0x1) +BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(0x2) +BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(0x4) +BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(0x8) +BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(0x10) +BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(0x20) +BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(0x40) +BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(0x80) +BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(0x100) +BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(0x200) +BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(0x400) +BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(0x800) +BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(0x1000) + +#undef BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT + +#else //BOOST_NO_ALIGNMENT + +template +union aligned_union +{ + T aligner; + char dummy[Len]; +}; + +template +struct aligned_next; + +template +struct aligned_next +{ + BOOST_STATIC_ASSERT((alignment_of::value == Align)); + typedef aligned_union type; +}; + +//End of search defaults to max_align_t +template +struct aligned_next +{ typedef aligned_union type; }; + +//Now define a search list through types +#define BOOST_MOVE_ALIGNED_NEXT_STEP(TYPE, NEXT_TYPE)\ + template\ + struct aligned_next\ + : aligned_next::value>\ + {};\ + // + BOOST_MOVE_ALIGNED_NEXT_STEP(long double, max_align_t) + BOOST_MOVE_ALIGNED_NEXT_STEP(double, long double) + #ifdef BOOST_HAS_LONG_LONG + BOOST_MOVE_ALIGNED_NEXT_STEP(::boost::long_long_type, double) + BOOST_MOVE_ALIGNED_NEXT_STEP(long, ::boost::long_long_type) + #else + BOOST_MOVE_ALIGNED_NEXT_STEP(long, double) + #endif + BOOST_MOVE_ALIGNED_NEXT_STEP(int, long) + BOOST_MOVE_ALIGNED_NEXT_STEP(short, int) + BOOST_MOVE_ALIGNED_NEXT_STEP(char, short) +#undef BOOST_MOVE_ALIGNED_NEXT_STEP + +template +struct aligned_storage_impl + : aligned_next::value> +{}; + +#endif + +template::value> +struct aligned_storage +{ + //Sanity checks for input parameters + BOOST_STATIC_ASSERT(Align > 0); + + //Sanity checks for output type + typedef typename aligned_storage_impl::type type; + static const std::size_t value = alignment_of::value; + BOOST_STATIC_ASSERT(value >= Align); + BOOST_STATIC_ASSERT((value % Align) == 0); + + //Just in case someone instantiates aligned_storage + //instead of aligned_storage::type (typical error). + private: + aligned_storage(); +}; + +} //namespace move_detail { +} //namespace boost { + +#include + +#endif //#ifndef BOOST_MOVE_DETAIL_TYPE_TRAITS_HPP diff --git a/realsense-file/3rd_party/boost/boost/move/detail/workaround.hpp b/realsense-file/3rd_party/boost/boost/move/detail/workaround.hpp new file mode 100644 index 0000000000..4dedd97487 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/move/detail/workaround.hpp @@ -0,0 +1,45 @@ +////////////////////////////////////////////////////////////////////////////// +// +// (C) Copyright Ion Gaztanaga 2014-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) +// +// See http://www.boost.org/libs/interprocess for documentation. +// +////////////////////////////////////////////////////////////////////////////// + +#ifndef BOOST_MOVE_DETAIL_WORKAROUND_HPP +#define BOOST_MOVE_DETAIL_WORKAROUND_HPP + +#ifndef BOOST_CONFIG_HPP +# include +#endif +# +#if defined(BOOST_HAS_PRAGMA_ONCE) +# pragma once +#endif + +#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) + #define BOOST_MOVE_PERFECT_FORWARDING +#endif + +//Macros for documentation purposes. For code, expands to the argument +#define BOOST_MOVE_IMPDEF(TYPE) TYPE +#define BOOST_MOVE_SEEDOC(TYPE) TYPE +#define BOOST_MOVE_DOC0PTR(TYPE) TYPE +#define BOOST_MOVE_DOC1ST(TYPE1, TYPE2) TYPE2 +#define BOOST_MOVE_I , +#define BOOST_MOVE_DOCIGN(T1) T1 + +#if defined(__GNUC__) && (__GNUC__ == 4) && (__GNUC_MINOR__ < 5) && !defined(__clang__) + //Pre-standard rvalue binding rules + #define BOOST_MOVE_OLD_RVALUE_REF_BINDING_RULES +#elif defined(_MSC_VER) && (_MSC_VER == 1600) + //Standard rvalue binding rules but with some bugs + #define BOOST_MOVE_MSVC_10_MEMBER_RVALUE_REF_BUG + #define BOOST_MOVE_MSVC_AUTO_MOVE_RETURN_BUG +#elif defined(_MSC_VER) && (_MSC_VER == 1700) + #define BOOST_MOVE_MSVC_AUTO_MOVE_RETURN_BUG +#endif + +#endif //#ifndef BOOST_MOVE_DETAIL_WORKAROUND_HPP diff --git a/realsense-file/3rd_party/boost/boost/move/traits.hpp b/realsense-file/3rd_party/boost/boost/move/traits.hpp new file mode 100644 index 0000000000..c16fdcc300 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/move/traits.hpp @@ -0,0 +1,77 @@ +////////////////////////////////////////////////////////////////////////////// +// +// (C) Copyright Ion Gaztanaga 2009-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) +// +// See http://www.boost.org/libs/move for documentation. +// +////////////////////////////////////////////////////////////////////////////// + +//! \file + +#ifndef BOOST_MOVE_TRAITS_HPP +#define BOOST_MOVE_TRAITS_HPP + +#ifndef BOOST_CONFIG_HPP +# include +#endif +# +#if defined(BOOST_HAS_PRAGMA_ONCE) +# pragma once +#endif + +#include + +#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES +#include +#endif +#include +#include + +namespace boost { + +//! If this trait yields to true +//! (has_trivial_destructor_after_move <T>::value == true) +//! means that if T is used as argument of a move construction/assignment, +//! there is no need to call T's destructor. +//! This optimization tipically is used to improve containers' performance. +//! +//! By default this trait is true if the type has trivial destructor, +//! every class should specialize this trait if it wants to improve performance +//! when inserted in containers. +template +struct has_trivial_destructor_after_move + : ::boost::move_detail::is_trivially_destructible +{}; + +//! By default this traits returns +//! 
boost::is_nothrow_move_constructible::value && boost::is_nothrow_move_assignable::value
. +//! Classes with non-throwing move constructor +//! and assignment can specialize this trait to obtain some performance improvements. +template +struct has_nothrow_move +{ + static const bool value = boost::move_detail::is_nothrow_move_constructible::value && + boost::move_detail::is_nothrow_move_assignable::value; +}; + +namespace move_detail { + +template +struct is_nothrow_move_constructible_or_uncopyable +{ + //The standard requires is_nothrow_move_constructible for move_if_noexcept + //but a user (usually in C++03) might specialize has_nothrow_move which includes it + static const bool value = is_nothrow_move_constructible::value || + has_nothrow_move::value || + !is_copy_constructible::value; +}; + +} //move_detail { +} //namespace boost { + +#include + +#endif //#ifndef BOOST_MOVE_TRAITS_HPP diff --git a/realsense-file/3rd_party/boost/boost/move/utility.hpp b/realsense-file/3rd_party/boost/boost/move/utility.hpp new file mode 100644 index 0000000000..0293374575 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/move/utility.hpp @@ -0,0 +1,149 @@ +////////////////////////////////////////////////////////////////////////////// +// +// (C) Copyright Ion Gaztanaga 2012-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) +// +// See http://www.boost.org/libs/move for documentation. +// +////////////////////////////////////////////////////////////////////////////// + +//! \file +//! This header includes core utilities from and defines +//! some more advanced utilities such as: + +#ifndef BOOST_MOVE_MOVE_UTILITY_HPP +#define BOOST_MOVE_MOVE_UTILITY_HPP + +#ifndef BOOST_CONFIG_HPP +# include +#endif +# +#if defined(BOOST_HAS_PRAGMA_ONCE) +# pragma once +#endif + +#include +#include +#include + +#if defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && !defined(BOOST_MOVE_DOXYGEN_INVOKED) + + namespace boost { + + ////////////////////////////////////////////////////////////////////////////// + // + // move_if_noexcept() + // + ////////////////////////////////////////////////////////////////////////////// + + template + inline typename ::boost::move_detail::enable_if_c + < enable_move_utility_emulation::value && !has_move_emulation_enabled::value + , typename ::boost::move_detail::add_const::type & + >::type + move_if_noexcept(T& x) BOOST_NOEXCEPT + { + return x; + } + + template + inline typename ::boost::move_detail::enable_if_c + < enable_move_utility_emulation::value && has_move_emulation_enabled::value + && ::boost::move_detail::is_nothrow_move_constructible_or_uncopyable::value, rv&>::type + move_if_noexcept(T& x) BOOST_NOEXCEPT + { + return *static_cast* >(::boost::move_detail::addressof(x)); + } + + template + inline typename ::boost::move_detail::enable_if_c + < enable_move_utility_emulation::value && has_move_emulation_enabled::value + && ::boost::move_detail::is_nothrow_move_constructible_or_uncopyable::value + , rv& + >::type + move_if_noexcept(rv& x) BOOST_NOEXCEPT + { + return x; + } + + template + inline typename ::boost::move_detail::enable_if_c + < enable_move_utility_emulation::value && has_move_emulation_enabled::value + && !::boost::move_detail::is_nothrow_move_constructible_or_uncopyable::value + , typename ::boost::move_detail::add_const::type & + >::type + move_if_noexcept(T& x) BOOST_NOEXCEPT + { + return x; + } + + template + inline typename ::boost::move_detail::enable_if_c + < enable_move_utility_emulation::value && has_move_emulation_enabled::value + && !::boost::move_detail::is_nothrow_move_constructible_or_uncopyable::value + , typename ::boost::move_detail::add_const::type & + >::type + move_if_noexcept(rv& x) BOOST_NOEXCEPT + { + return x; + } + + } //namespace boost + +#else //#if defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && !defined(BOOST_MOVE_DOXYGEN_INVOKED) + + #if defined(BOOST_MOVE_USE_STANDARD_LIBRARY_MOVE) + #include + + namespace boost{ + + using ::std::move_if_noexcept; + + } //namespace boost + + #else //!BOOST_MOVE_USE_STANDARD_LIBRARY_MOVE + + namespace boost { + + ////////////////////////////////////////////////////////////////////////////// + // + // move_if_noexcept() + // + ////////////////////////////////////////////////////////////////////////////// + #if defined(BOOST_MOVE_DOXYGEN_INVOKED) + //! This function provides a way to convert a reference into a rvalue reference + //! in compilers with rvalue references. For other compilers converts T & into + //! ::boost::rv & so that move emulation is activated. Reference + //! would be converted to rvalue reference only if input type is nothrow move + //! constructible or if it has no copy constructor. In all other cases const + //! reference would be returned + template + rvalue_reference_or_const_lvalue_reference move_if_noexcept(input_reference) noexcept; + + #else //BOOST_MOVE_DOXYGEN_INVOKED + + template + typename ::boost::move_detail::enable_if_c + < ::boost::move_detail::is_nothrow_move_constructible_or_uncopyable::value, T&&>::type + move_if_noexcept(T& x) BOOST_NOEXCEPT + { return ::boost::move(x); } + + template + typename ::boost::move_detail::enable_if_c + < !::boost::move_detail::is_nothrow_move_constructible_or_uncopyable::value, const T&>::type + move_if_noexcept(T& x) BOOST_NOEXCEPT + { return x; } + + #endif //BOOST_MOVE_DOXYGEN_INVOKED + + } //namespace boost { + + #endif //#if defined(BOOST_MOVE_USE_STANDARD_LIBRARY_MOVE) + +#endif //BOOST_NO_CXX11_RVALUE_REFERENCES + +#include + +#endif //#ifndef BOOST_MOVE_MOVE_UTILITY_HPP diff --git a/realsense-file/3rd_party/boost/boost/move/utility_core.hpp b/realsense-file/3rd_party/boost/boost/move/utility_core.hpp new file mode 100644 index 0000000000..829c4dc4fb --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/move/utility_core.hpp @@ -0,0 +1,295 @@ +////////////////////////////////////////////////////////////////////////////// +// +// (C) Copyright Ion Gaztanaga 2012-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) +// +// See http://www.boost.org/libs/move for documentation. +// +////////////////////////////////////////////////////////////////////////////// + +//! \file +//! This header defines core utilities to ease the development +//! of move-aware functions. This header minimizes dependencies +//! from other libraries. + +#ifndef BOOST_MOVE_MOVE_UTILITY_CORE_HPP +#define BOOST_MOVE_MOVE_UTILITY_CORE_HPP + +#ifndef BOOST_CONFIG_HPP +# include +#endif +# +#if defined(BOOST_HAS_PRAGMA_ONCE) +# pragma once +#endif + +#include +#include +#include +#include + +#if defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && !defined(BOOST_MOVE_DOXYGEN_INVOKED) + + namespace boost { + + template + struct enable_move_utility_emulation + { + static const bool value = true; + }; + + ////////////////////////////////////////////////////////////////////////////// + // + // move() + // + ////////////////////////////////////////////////////////////////////////////// + + template + inline typename ::boost::move_detail::enable_if_c + < enable_move_utility_emulation::value && !has_move_emulation_enabled::value, T&>::type + move(T& x) BOOST_NOEXCEPT + { + return x; + } + + template + inline typename ::boost::move_detail::enable_if_c + < enable_move_utility_emulation::value && has_move_emulation_enabled::value, rv&>::type + move(T& x) BOOST_NOEXCEPT + { + return *static_cast* >(::boost::move_detail::addressof(x)); + } + + template + inline typename ::boost::move_detail::enable_if_c + < enable_move_utility_emulation::value && has_move_emulation_enabled::value, rv&>::type + move(rv& x) BOOST_NOEXCEPT + { + return x; + } + + ////////////////////////////////////////////////////////////////////////////// + // + // forward() + // + ////////////////////////////////////////////////////////////////////////////// + + template + inline typename ::boost::move_detail::enable_if_c + < enable_move_utility_emulation::value && ::boost::move_detail::is_rv::value, T &>::type + forward(const typename ::boost::move_detail::identity::type &x) BOOST_NOEXCEPT + { + return const_cast(x); + } + + template + inline typename ::boost::move_detail::enable_if_c + < enable_move_utility_emulation::value && !::boost::move_detail::is_rv::value, const T &>::type + forward(const typename ::boost::move_detail::identity::type &x) BOOST_NOEXCEPT + { + return x; + } + + ////////////////////////////////////////////////////////////////////////////// + // + // move_if_not_lvalue_reference() + // + ////////////////////////////////////////////////////////////////////////////// + + template + inline typename ::boost::move_detail::enable_if_c + < enable_move_utility_emulation::value && + ::boost::move_detail::is_rv::value + , T &>::type + move_if_not_lvalue_reference(const typename ::boost::move_detail::identity::type &x) BOOST_NOEXCEPT + { + return const_cast(x); + } + + template + inline typename ::boost::move_detail::enable_if_c + < enable_move_utility_emulation::value && + !::boost::move_detail::is_rv::value && + (::boost::move_detail::is_lvalue_reference::value || + !has_move_emulation_enabled::value) + , typename ::boost::move_detail::add_lvalue_reference::type + >::type + move_if_not_lvalue_reference(typename ::boost::move_detail::remove_reference::type &x) BOOST_NOEXCEPT + { + return x; + } + + template + inline typename ::boost::move_detail::enable_if_c + < enable_move_utility_emulation::value && + !::boost::move_detail::is_rv::value && + (!::boost::move_detail::is_lvalue_reference::value && + has_move_emulation_enabled::value) + , rv& + >::type + move_if_not_lvalue_reference(typename ::boost::move_detail::remove_reference::type &x) BOOST_NOEXCEPT + { + return move(x); + } + + } //namespace boost + +#else //#if defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && !defined(BOOST_MOVE_DOXYGEN_INVOKED) + + #if defined(BOOST_MOVE_USE_STANDARD_LIBRARY_MOVE) + #include + + namespace boost{ + + using ::std::move; + using ::std::forward; + + } //namespace boost + + #else //!BOOST_MOVE_USE_STANDARD_LIBRARY_MOVE + + namespace boost { + + //! This trait's internal boolean `value` is false in compilers with rvalue references + //! and true in compilers without rvalue references. + //! + //! A user can specialize this trait for a type T to false to SFINAE out `move` and `forward` + //! so that the user can define a different move emulation for that type in namespace boost + //! (e.g. another Boost library for its types) and avoid any overload ambiguity. + template + struct enable_move_utility_emulation + { + static const bool value = false; + }; + + ////////////////////////////////////////////////////////////////////////////// + // + // move + // + ////////////////////////////////////////////////////////////////////////////// + + #if defined(BOOST_MOVE_DOXYGEN_INVOKED) + //! This function provides a way to convert a reference into a rvalue reference + //! in compilers with rvalue references. For other compilers if `T` is Boost.Move + //! enabled type then it converts `T&` into ::boost::rv & so that + //! move emulation is activated, else it returns `T &`. + template + rvalue_reference move(input_reference) noexcept; + + #elif defined(BOOST_MOVE_OLD_RVALUE_REF_BINDING_RULES) + + //Old move approach, lvalues could bind to rvalue references + template + inline typename ::boost::move_detail::remove_reference::type && move(T&& t) BOOST_NOEXCEPT + { return t; } + + #else //BOOST_MOVE_OLD_RVALUE_REF_BINDING_RULES + + template + inline typename ::boost::move_detail::remove_reference::type && move(T&& t) BOOST_NOEXCEPT + { return static_cast::type &&>(t); } + + #endif //BOOST_MOVE_OLD_RVALUE_REF_BINDING_RULES + + ////////////////////////////////////////////////////////////////////////////// + // + // forward + // + ////////////////////////////////////////////////////////////////////////////// + + + #if defined(BOOST_MOVE_DOXYGEN_INVOKED) + //! This function provides limited form of forwarding that is usually enough for + //! in-place construction and avoids the exponential overloading for + //! achieve the limited forwarding in C++03. + //! + //! For compilers with rvalue references this function provides perfect forwarding. + //! + //! Otherwise: + //! * If input_reference binds to const ::boost::rv & then it output_reference is + //! ::boost::rv & + //! + //! * Else, output_reference is equal to input_reference. + template output_reference forward(input_reference) noexcept; + #elif defined(BOOST_MOVE_OLD_RVALUE_REF_BINDING_RULES) + + //Old move approach, lvalues could bind to rvalue references + + template + inline T&& forward(typename ::boost::move_detail::identity::type&& t) BOOST_NOEXCEPT + { return t; } + + #else //Old move + + template + inline T&& forward(typename ::boost::move_detail::remove_reference::type& t) BOOST_NOEXCEPT + { return static_cast(t); } + + template + inline T&& forward(typename ::boost::move_detail::remove_reference::type&& t) BOOST_NOEXCEPT + { + //"boost::forward error: 'T' is a lvalue reference, can't forward as rvalue."; + BOOST_STATIC_ASSERT(!boost::move_detail::is_lvalue_reference::value); + return static_cast(t); + } + + #endif //BOOST_MOVE_DOXYGEN_INVOKED + + ////////////////////////////////////////////////////////////////////////////// + // + // move_if_not_lvalue_reference + // + ////////////////////////////////////////////////////////////////////////////// + + + #if defined(BOOST_MOVE_DOXYGEN_INVOKED) + template output_reference move_if_not_lvalue_reference(input_reference) noexcept; + #elif defined(BOOST_MOVE_OLD_RVALUE_REF_BINDING_RULES) + + //Old move approach, lvalues could bind to rvalue references + + template + inline T&& move_if_not_lvalue_reference(typename ::boost::move_detail::identity::type&& t) BOOST_NOEXCEPT + { return t; } + + #else //Old move + + template + inline T&& move_if_not_lvalue_reference(typename ::boost::move_detail::remove_reference::type& t) BOOST_NOEXCEPT + { return static_cast(t); } + + template + inline T&& move_if_not_lvalue_reference(typename ::boost::move_detail::remove_reference::type&& t) BOOST_NOEXCEPT + { + //"boost::forward error: 'T' is a lvalue reference, can't forward as rvalue."; + BOOST_STATIC_ASSERT(!boost::move_detail::is_lvalue_reference::value); + return static_cast(t); + } + + #endif //BOOST_MOVE_DOXYGEN_INVOKED + + } //namespace boost { + + #endif //#if defined(BOOST_MOVE_USE_STANDARD_LIBRARY_MOVE) + +#endif //BOOST_NO_CXX11_RVALUE_REFERENCES + +#if !defined(BOOST_MOVE_DOXYGEN_INVOKED) + +namespace boost{ +namespace move_detail{ + +template +typename boost::move_detail::add_rvalue_reference::type declval(); + +} //namespace move_detail{ +} //namespace boost{ + +#endif //#if !defined(BOOST_MOVE_DOXYGEN_INVOKED) + + +#include + +#endif //#ifndef BOOST_MOVE_MOVE_UTILITY_CORE_HPP diff --git a/realsense-file/3rd_party/boost/boost/mpl/always.hpp b/realsense-file/3rd_party/boost/boost/mpl/always.hpp new file mode 100644 index 0000000000..cf507536b6 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/always.hpp @@ -0,0 +1,38 @@ + +#ifndef BOOST_MPL_ALWAYS_HPP_INCLUDED +#define BOOST_MPL_ALWAYS_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Id$ +// $Date$ +// $Revision$ + +#include +#include +#include + +namespace boost { namespace mpl { + +template< typename Value > struct always +{ + template< + BOOST_MPL_PP_DEFAULT_PARAMS(BOOST_MPL_LIMIT_METAFUNCTION_ARITY, typename T, na) + > + struct apply + { + typedef Value type; + }; +}; + +BOOST_MPL_AUX_ARITY_SPEC(0, always) + +}} + +#endif // BOOST_MPL_ALWAYS_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/mpl/and.hpp b/realsense-file/3rd_party/boost/boost/mpl/and.hpp new file mode 100644 index 0000000000..a92c2785d5 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/and.hpp @@ -0,0 +1,60 @@ + +#ifndef BOOST_MPL_AND_HPP_INCLUDED +#define BOOST_MPL_AND_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Id$ +// $Date$ +// $Revision$ + +#include + +#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) + +# include +# include +# include +# include + +// agurt, 19/may/04: workaround a conflict with header's +// 'or' and 'and' macros, see http://tinyurl.com/3et69; 'defined(and)' +// has to be checked in a separate condition, otherwise GCC complains +// about 'and' being an alternative token +#if defined(_MSC_VER) && !defined(__clang__) +#ifndef __GCCXML__ +#if defined(and) +# pragma push_macro("and") +# undef and +# define and(x) +#endif +#endif +#endif + +# define BOOST_MPL_PREPROCESSED_HEADER and.hpp +# include + +#if defined(_MSC_VER) && !defined(__clang__) +#ifndef __GCCXML__ +#if defined(and) +# pragma pop_macro("and") +#endif +#endif +#endif + +#else + +# define AUX778076_OP_NAME and_ +# define AUX778076_OP_VALUE1 false +# define AUX778076_OP_VALUE2 true +# include + +#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS +#endif // BOOST_MPL_AND_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/mpl/apply.hpp b/realsense-file/3rd_party/boost/boost/mpl/apply.hpp new file mode 100644 index 0000000000..b70cd2a4b6 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/apply.hpp @@ -0,0 +1,229 @@ + +#if !defined(BOOST_PP_IS_ITERATING) + +///// header body + +#ifndef BOOST_MPL_APPLY_HPP_INCLUDED +#define BOOST_MPL_APPLY_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Id$ +// $Date$ +// $Revision$ + +#if !defined(BOOST_MPL_PREPROCESSING_MODE) +# include +# include +# include +# include +# include +# include +#endif + +#include + +#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) + +# define BOOST_MPL_PREPROCESSED_HEADER apply.hpp +# include + +#else + +# include +# include +# include +# include +# include +# include +# include +# include +# include +# include +# include + +# include +# include +# include +# include + +namespace boost { namespace mpl { + +// local macros, #undef-ined at the end of the header +# define AUX778076_APPLY_PARAMS(param) \ + BOOST_MPL_PP_PARAMS( \ + BOOST_MPL_LIMIT_METAFUNCTION_ARITY \ + , param \ + ) \ + /**/ + +# define AUX778076_APPLY_DEF_PARAMS(param, value) \ + BOOST_MPL_PP_DEFAULT_PARAMS( \ + BOOST_MPL_LIMIT_METAFUNCTION_ARITY \ + , param \ + , value \ + ) \ + /**/ + +# define AUX778076_APPLY_N_PARAMS(n, param) \ + BOOST_MPL_PP_PARAMS(n, param) \ + /**/ + +# define AUX778076_APPLY_N_COMMA_PARAMS(n, param) \ + BOOST_PP_COMMA_IF(n) \ + BOOST_MPL_PP_PARAMS(n, param) \ + /**/ + +# define AUX778076_APPLY_N_PARTIAL_SPEC_PARAMS(n, param, def) \ + BOOST_PP_COMMA_IF(n) \ + BOOST_MPL_PP_PARTIAL_SPEC_PARAMS(n, param, def) \ + /**/ + +# define AUX778076_APPLY_N_SPEC_PARAMS(n, param) \ + BOOST_MPL_PP_ENUM(BOOST_PP_INC(n), param) \ + /**/ + + +#define BOOST_PP_ITERATION_PARAMS_1 \ + (3,(0, BOOST_MPL_LIMIT_METAFUNCTION_ARITY, )) +#include BOOST_PP_ITERATE() + +# if !defined(BOOST_MPL_CFG_NO_APPLY_TEMPLATE) +// real C++ version is already taken care of +# if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) + +namespace aux { +// apply_count_args +#define AUX778076_COUNT_ARGS_PREFIX apply +#define AUX778076_COUNT_ARGS_DEFAULT na +#define AUX778076_COUNT_ARGS_ARITY BOOST_MPL_LIMIT_METAFUNCTION_ARITY +#include +} + + +template< + typename F, AUX778076_APPLY_DEF_PARAMS(typename T, na) + > +struct apply + : aux::apply_chooser< + aux::apply_count_args< AUX778076_APPLY_PARAMS(T) >::value + >::template result_< F, AUX778076_APPLY_PARAMS(T) >::type +{ +}; + +# endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION +# endif // BOOST_MPL_CFG_NO_APPLY_TEMPLATE + +# undef AUX778076_APPLY_N_SPEC_PARAMS +# undef AUX778076_APPLY_N_PARTIAL_SPEC_PARAMS +# undef AUX778076_APPLY_N_COMMA_PARAMS +# undef AUX778076_APPLY_N_PARAMS +# undef AUX778076_APPLY_DEF_PARAMS +# undef AUX778076_APPLY_PARAMS + +}} + +#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS +#endif // BOOST_MPL_APPLY_HPP_INCLUDED + +///// iteration, depth == 1 + +// For gcc 4.4 compatability, we must include the +// BOOST_PP_ITERATION_DEPTH test inside an #else clause. +#else // BOOST_PP_IS_ITERATING +#if BOOST_PP_ITERATION_DEPTH() == 1 + +# define i_ BOOST_PP_FRAME_ITERATION(1) + +template< + typename F AUX778076_APPLY_N_COMMA_PARAMS(i_, typename T) + > +struct BOOST_PP_CAT(apply,i_) +#if !BOOST_WORKAROUND(BOOST_MSVC, < 1300) + : BOOST_PP_CAT(apply_wrap,i_)< + typename lambda::type + AUX778076_APPLY_N_COMMA_PARAMS(i_, T) + > +{ +#else +{ + typedef typename BOOST_PP_CAT(apply_wrap,i_)< + typename lambda::type + AUX778076_APPLY_N_COMMA_PARAMS(i_, T) + >::type type; +#endif + BOOST_MPL_AUX_LAMBDA_SUPPORT( + BOOST_PP_INC(i_) + , BOOST_PP_CAT(apply,i_) + , (F AUX778076_APPLY_N_COMMA_PARAMS(i_,T)) + ) +}; + + +#if defined(BOOST_MPL_CFG_MSVC_ETI_BUG) +/// workaround for ETI bug +template<> +struct BOOST_PP_CAT(apply,i_) +{ + typedef int type; +}; +#endif + +# if !defined(BOOST_MPL_CFG_NO_APPLY_TEMPLATE) +# if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) + +#if i_ == BOOST_MPL_LIMIT_METAFUNCTION_ARITY +/// primary template (not a specialization!) +template< + typename F AUX778076_APPLY_N_COMMA_PARAMS(i_, typename T) + > +struct apply + : BOOST_PP_CAT(apply,i_)< F AUX778076_APPLY_N_COMMA_PARAMS(i_, T) > +{ +}; +#else +template< + typename F AUX778076_APPLY_N_COMMA_PARAMS(i_, typename T) + > +struct apply< F AUX778076_APPLY_N_PARTIAL_SPEC_PARAMS(i_, T, na) > + : BOOST_PP_CAT(apply,i_)< F AUX778076_APPLY_N_COMMA_PARAMS(i_, T) > +{ +}; +#endif + +# else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +#if !defined(BOOST_MPL_CFG_NO_APPLY_TEMPLATE) +namespace aux { + +template<> +struct apply_chooser +{ + template< + typename F, AUX778076_APPLY_PARAMS(typename T) + > + struct result_ + { + typedef BOOST_PP_CAT(apply,i_)< + F AUX778076_APPLY_N_COMMA_PARAMS(i_, T) + > type; + }; +}; + +} // namespace aux +#endif + +# endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION +# endif // BOOST_MPL_CFG_NO_APPLY_TEMPLATE + +# undef i_ + +#endif // BOOST_PP_ITERATION_DEPTH() +#endif // BOOST_PP_IS_ITERATING diff --git a/realsense-file/3rd_party/boost/boost/mpl/apply_fwd.hpp b/realsense-file/3rd_party/boost/boost/mpl/apply_fwd.hpp new file mode 100644 index 0000000000..ddbd4b72fa --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/apply_fwd.hpp @@ -0,0 +1,107 @@ + +#if !defined(BOOST_PP_IS_ITERATING) + +///// header body + +#ifndef BOOST_MPL_APPLY_FWD_HPP_INCLUDED +#define BOOST_MPL_APPLY_FWD_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Id$ +// $Date$ +// $Revision$ + +#if !defined(BOOST_MPL_PREPROCESSING_MODE) +# include +#endif + +#include + +#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) + +# define BOOST_MPL_PREPROCESSED_HEADER apply_fwd.hpp +# include + +#else + +# include +# include +# include +# include +# include + +# include +# include +# include + +// agurt, 15/jan/02: top-level 'apply' template gives an ICE on MSVC +// (for known reasons) +#if BOOST_WORKAROUND(BOOST_MSVC, < 1300) +# define BOOST_MPL_CFG_NO_APPLY_TEMPLATE +#endif + +namespace boost { namespace mpl { + +// local macro, #undef-ined at the end of the header +# define AUX778076_APPLY_DEF_PARAMS(param, value) \ + BOOST_MPL_PP_DEFAULT_PARAMS( \ + BOOST_MPL_LIMIT_METAFUNCTION_ARITY \ + , param \ + , value \ + ) \ + /**/ + +# define AUX778076_APPLY_N_COMMA_PARAMS(n, param) \ + BOOST_PP_COMMA_IF(n) \ + BOOST_MPL_PP_PARAMS(n, param) \ + /**/ + +# if !defined(BOOST_MPL_CFG_NO_APPLY_TEMPLATE) + +#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) +// forward declaration +template< + typename F, AUX778076_APPLY_DEF_PARAMS(typename T, na) + > +struct apply; +#else +namespace aux { +template< BOOST_AUX_NTTP_DECL(int, arity_) > struct apply_chooser; +} +#endif + +# endif // BOOST_MPL_CFG_NO_APPLY_TEMPLATE + +#define BOOST_PP_ITERATION_PARAMS_1 \ + (3,(0, BOOST_MPL_LIMIT_METAFUNCTION_ARITY, )) +#include BOOST_PP_ITERATE() + + +# undef AUX778076_APPLY_N_COMMA_PARAMS +# undef AUX778076_APPLY_DEF_PARAMS + +}} + +#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS +#endif // BOOST_MPL_APPLY_FWD_HPP_INCLUDED + +///// iteration + +#else +#define i_ BOOST_PP_FRAME_ITERATION(1) + +template< + typename F AUX778076_APPLY_N_COMMA_PARAMS(i_, typename T) + > +struct BOOST_PP_CAT(apply,i_); + +#undef i_ +#endif // BOOST_PP_IS_ITERATING diff --git a/realsense-file/3rd_party/boost/boost/mpl/apply_wrap.hpp b/realsense-file/3rd_party/boost/boost/mpl/apply_wrap.hpp new file mode 100644 index 0000000000..6b485c7efe --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/apply_wrap.hpp @@ -0,0 +1,234 @@ + +#if !defined(BOOST_PP_IS_ITERATING) + +///// header body + +#ifndef BOOST_MPL_APPLY_WRAP_HPP_INCLUDED +#define BOOST_MPL_APPLY_WRAP_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2008 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Id$ +// $Date$ +// $Revision$ + +#if !defined(BOOST_MPL_PREPROCESSING_MODE) +# include +# include +# include +# include +#endif + +#include + +#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) + +# define BOOST_MPL_PREPROCESSED_HEADER apply_wrap.hpp +# include + +#else + +# include +# include +# include +# include +# include +# include +# include +# include +# include +# include + +# include +# include +# include +# include + + +namespace boost { namespace mpl { + +// local macros, #undef-ined at the end of the header +# define AUX778076_APPLY_WRAP_PARAMS(n, param) \ + BOOST_MPL_PP_PARAMS(n, param) \ + /**/ + +# define AUX778076_APPLY_WRAP_SPEC_PARAMS(n, param) \ + BOOST_MPL_PP_ENUM(BOOST_PP_INC(n), param) \ + /**/ + + +#define BOOST_PP_ITERATION_PARAMS_1 \ + (3,(0, BOOST_MPL_LIMIT_METAFUNCTION_ARITY, )) +#include BOOST_PP_ITERATE() + + +# undef AUX778076_APPLY_WRAP_SPEC_PARAMS +# undef AUX778076_APPLY_WRAP_PARAMS + +}} + +#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS +#endif // BOOST_MPL_APPLY_WRAP_HPP_INCLUDED + +///// iteration, depth == 1 + +// For gcc 4.4 compatability, we must include the +// BOOST_PP_ITERATION_DEPTH test inside an #else clause. +#else // BOOST_PP_IS_ITERATING +#if BOOST_PP_ITERATION_DEPTH() == 1 + +# define i_ BOOST_PP_FRAME_ITERATION(1) + +# if BOOST_WORKAROUND(BOOST_MSVC, < 1300) +// MSVC version + +#define AUX778076_MSVC_DTW_NAME BOOST_PP_CAT(msvc_apply,i_) +#define AUX778076_MSVC_DTW_ORIGINAL_NAME apply +#define AUX778076_MSVC_DTW_ARITY i_ +#include + +template< + typename F BOOST_PP_COMMA_IF(i_) AUX778076_APPLY_WRAP_PARAMS(i_, typename T) + > +struct BOOST_PP_CAT(apply_wrap,i_) +{ + // Metafunction forwarding confuses vc6 + typedef typename BOOST_PP_CAT(msvc_apply,i_)::template result_< + AUX778076_APPLY_WRAP_PARAMS(i_, T) + >::type type; +}; + +# elif defined(BOOST_MPL_CFG_BROKEN_DEFAULT_PARAMETERS_IN_NESTED_TEMPLATES) +// MWCW/Borland version + +template< + int N, typename F BOOST_PP_COMMA_IF(i_) AUX778076_APPLY_WRAP_PARAMS(i_, typename T) + > +struct BOOST_PP_CAT(apply_wrap_impl,i_); + +#define BOOST_PP_ITERATION_PARAMS_2 \ + (3,(0, BOOST_MPL_LIMIT_METAFUNCTION_ARITY - i_, )) +#include BOOST_PP_ITERATE() + +template< + typename F BOOST_PP_COMMA_IF(i_) AUX778076_APPLY_WRAP_PARAMS(i_, typename T) + > +struct BOOST_PP_CAT(apply_wrap,i_) + : BOOST_PP_CAT(apply_wrap_impl,i_)< + ::boost::mpl::aux::arity::value + , F + BOOST_PP_COMMA_IF(i_) AUX778076_APPLY_WRAP_PARAMS(i_, T) + >::type +{ +}; + +# else +// ISO98 C++, with minor concession to vc7 + +template< + typename F BOOST_PP_COMMA_IF(i_) AUX778076_APPLY_WRAP_PARAMS(i_, typename T) +#if i_ == 0 + , typename has_apply_ = typename aux::has_apply::type +#endif + > +struct BOOST_PP_CAT(apply_wrap,i_) +// metafunction forwarding confuses MSVC 7.0 +#if !BOOST_WORKAROUND(BOOST_MSVC, == 1300) + : F::template apply< AUX778076_APPLY_WRAP_PARAMS(i_, T) > +{ +#else +{ + typedef typename F::template apply< + AUX778076_APPLY_WRAP_PARAMS(i_, T) + >::type type; +#endif +}; + +#if i_ == 0 && !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) +template< typename F > +struct BOOST_PP_CAT(apply_wrap,i_) + : F::apply +{ +}; +#endif + +# endif // workarounds + +#if defined(BOOST_MPL_CFG_MSVC_ETI_BUG) +/// workaround for ETI bug +template<> +struct BOOST_PP_CAT(apply_wrap,i_) +{ + typedef int type; +}; +#endif + +# undef i_ + +///// iteration, depth == 2 + +#elif BOOST_PP_ITERATION_DEPTH() == 2 + +# define j_ BOOST_PP_FRAME_ITERATION(2) + +#if i_ == 0 && j_ == 0 \ + && defined(BOOST_MPL_CFG_BCC590_WORKAROUNDS) \ + && !defined(BOOST_MPL_CFG_NO_HAS_APPLY) + +template< typename F, bool F_has_apply > +struct apply_wrap_impl0_bcb { + typedef typename F::template apply< na > type; +}; + +template< typename F > +struct apply_wrap_impl0_bcb< F, true > { + typedef typename F::apply type; +}; + +template< + typename F BOOST_PP_COMMA_IF(i_) AUX778076_APPLY_WRAP_PARAMS(i_, typename T) + > +struct BOOST_PP_CAT(apply_wrap_impl,i_)< + BOOST_MPL_PP_ADD(i_, j_) + , F + BOOST_PP_COMMA_IF(i_) AUX778076_APPLY_WRAP_PARAMS(i_, T) + > +{ + typedef apply_wrap_impl0_bcb< F, aux::has_apply< F >::value >::type type; +}; +#else + +template< + typename F BOOST_PP_COMMA_IF(i_) AUX778076_APPLY_WRAP_PARAMS(i_, typename T) + > +struct BOOST_PP_CAT(apply_wrap_impl,i_)< + BOOST_MPL_PP_ADD(i_, j_) + , F + BOOST_PP_COMMA_IF(i_) AUX778076_APPLY_WRAP_PARAMS(i_, T) + > +{ + typedef typename F::template apply< + AUX778076_APPLY_WRAP_PARAMS(i_, T) +#if i_ == 0 && j_ == 0 +/// since the defaults are "lost", we have to pass *something* even for nullary +/// metafunction classes + na +#else + BOOST_PP_COMMA_IF(BOOST_PP_AND(i_, j_)) BOOST_MPL_PP_ENUM(j_, na) +#endif + > type; +}; + +#endif + +# undef j_ + +#endif // BOOST_PP_ITERATION_DEPTH() +#endif // BOOST_PP_IS_ITERATING diff --git a/realsense-file/3rd_party/boost/boost/mpl/arg.hpp b/realsense-file/3rd_party/boost/boost/mpl/arg.hpp new file mode 100644 index 0000000000..5d1db7450a --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/arg.hpp @@ -0,0 +1,131 @@ + +#if !defined(BOOST_PP_IS_ITERATING) + +///// header body + +#ifndef BOOST_MPL_ARG_HPP_INCLUDED +#define BOOST_MPL_ARG_HPP_INCLUDED + +// Copyright Peter Dimov 2001-2002 +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Id$ +// $Date$ +// $Revision$ + +#if !defined(BOOST_MPL_PREPROCESSING_MODE) +# include +# include +# include +# include +# include +#endif + +#include +#include + +#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) + +# define BOOST_MPL_PREPROCESSED_HEADER arg.hpp +# include + +#else + +# include +# include +# include +# include +# include +# include + +# include +# include +# include + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN + +// local macro, #undef-ined at the end of the header +#if !defined(BOOST_MPL_CFG_NO_DEFAULT_PARAMETERS_IN_NESTED_TEMPLATES) +# define AUX778076_ARG_N_DEFAULT_PARAMS(param,value) \ + BOOST_MPL_PP_DEFAULT_PARAMS( \ + BOOST_MPL_LIMIT_METAFUNCTION_ARITY \ + , param \ + , value \ + ) \ + /**/ +#else +# define AUX778076_ARG_N_DEFAULT_PARAMS(param,value) \ + BOOST_MPL_PP_PARAMS( \ + BOOST_MPL_LIMIT_METAFUNCTION_ARITY \ + , param \ + ) \ + /**/ +#endif + +#define BOOST_PP_ITERATION_PARAMS_1 \ + (3,(0, BOOST_MPL_LIMIT_METAFUNCTION_ARITY, )) +#include BOOST_PP_ITERATE() + + +# undef AUX778076_ARG_N_DEFAULT_PARAMS + +BOOST_MPL_AUX_NONTYPE_ARITY_SPEC(1,int,arg) + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE + +#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS +#endif // BOOST_MPL_ARG_HPP_INCLUDED + +///// iteration + +#else +#define i_ BOOST_PP_FRAME_ITERATION(1) + +#if i_ > 0 + +template<> struct arg +{ + BOOST_STATIC_CONSTANT(int, value = i_); + typedef arg next; + BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) + BOOST_MPL_AUX_ARG_TYPEDEF(na, type) + + template< + AUX778076_ARG_N_DEFAULT_PARAMS(typename U, na) + > + struct apply + { + typedef BOOST_PP_CAT(U,i_) type; + BOOST_MPL_AUX_ASSERT_NOT_NA(type); + }; +}; + +#else + +template<> struct arg<-1> +{ + BOOST_STATIC_CONSTANT(int, value = -1); + BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) + BOOST_MPL_AUX_ARG_TYPEDEF(na, type) + + template< + AUX778076_ARG_N_DEFAULT_PARAMS(typename U, na) + > + struct apply + { + typedef U1 type; + BOOST_MPL_AUX_ASSERT_NOT_NA(type); + }; +}; + +#endif // i_ > 0 + +#undef i_ +#endif // BOOST_PP_IS_ITERATING diff --git a/realsense-file/3rd_party/boost/boost/mpl/arg_fwd.hpp b/realsense-file/3rd_party/boost/boost/mpl/arg_fwd.hpp new file mode 100644 index 0000000000..40fdf4abd1 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/arg_fwd.hpp @@ -0,0 +1,28 @@ + +#ifndef BOOST_MPL_ARG_FWD_HPP_INCLUDED +#define BOOST_MPL_ARG_FWD_HPP_INCLUDED + +// Copyright Peter Dimov 2001-2002 +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Id$ +// $Date$ +// $Revision$ + +#include +#include + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN + +template< BOOST_MPL_AUX_NTTP_DECL(int, N) > struct arg; + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE +BOOST_MPL_AUX_ADL_BARRIER_DECL(arg) + +#endif // BOOST_MPL_ARG_FWD_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/mpl/assert.hpp b/realsense-file/3rd_party/boost/boost/mpl/assert.hpp new file mode 100644 index 0000000000..a970a19d80 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/assert.hpp @@ -0,0 +1,439 @@ + +#ifndef BOOST_MPL_ASSERT_HPP_INCLUDED +#define BOOST_MPL_ASSERT_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2006 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Id$ +// $Date$ +// $Revision$ + +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#include // make sure 'size_t' is placed into 'std' +#include + +#if BOOST_WORKAROUND(BOOST_MSVC, == 1700) +#include +#endif + +#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x610)) \ + || (BOOST_MPL_CFG_GCC != 0) \ + || BOOST_WORKAROUND(__IBMCPP__, <= 600) +# define BOOST_MPL_CFG_ASSERT_USE_RELATION_NAMES +#endif + +#if BOOST_WORKAROUND(__MWERKS__, < 0x3202) \ + || BOOST_WORKAROUND(__EDG_VERSION__, <= 238) \ + || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x610)) \ + || BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840)) +# define BOOST_MPL_CFG_ASSERT_BROKEN_POINTER_TO_POINTER_TO_MEMBER +#endif + +// agurt, 10/nov/06: use enums for Borland (which cannot cope with static constants) +// and GCC (which issues "unused variable" warnings when static constants are used +// at a function scope) +#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x610)) \ + || (BOOST_MPL_CFG_GCC != 0) || (BOOST_MPL_CFG_GPU != 0) +# define BOOST_MPL_AUX_ASSERT_CONSTANT(T, expr) enum { expr } +#else +# define BOOST_MPL_AUX_ASSERT_CONSTANT(T, expr) BOOST_STATIC_CONSTANT(T, expr) +#endif + + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN + +struct failed {}; + +// agurt, 24/aug/04: MSVC 7.1 workaround here and below: return/accept +// 'assert' by reference; can't apply it unconditionally -- apparently it +// degrades the quality of GCC diagnostics +#if BOOST_WORKAROUND(BOOST_MSVC, == 1310) +# define AUX778076_ASSERT_ARG(x) x& +#else +# define AUX778076_ASSERT_ARG(x) x +#endif + +template< bool C > struct assert { typedef void* type; }; +template<> struct assert { typedef AUX778076_ASSERT_ARG(assert) type; }; + +template< bool C > +int assertion_failed( typename assert::type ); + +template< bool C > +struct assertion +{ + static int failed( assert ); +}; + +template<> +struct assertion +{ + static int failed( void* ); +}; + +struct assert_ +{ +#if !defined(BOOST_MPL_CFG_NO_DEFAULT_PARAMETERS_IN_NESTED_TEMPLATES) + template< typename T1, typename T2 = na, typename T3 = na, typename T4 = na > struct types {}; +#endif + static assert_ const arg; + enum relations { equal = 1, not_equal, greater, greater_equal, less, less_equal }; +}; + + +#if !defined(BOOST_MPL_CFG_ASSERT_USE_RELATION_NAMES) + +bool operator==( failed, failed ); +bool operator!=( failed, failed ); +bool operator>( failed, failed ); +bool operator>=( failed, failed ); +bool operator<( failed, failed ); +bool operator<=( failed, failed ); + +#if defined(__EDG_VERSION__) +template< bool (*)(failed, failed), long x, long y > struct assert_relation {}; +# define BOOST_MPL_AUX_ASSERT_RELATION(x, y, r) assert_relation +#else +template< BOOST_MPL_AUX_NTTP_DECL(long, x), BOOST_MPL_AUX_NTTP_DECL(long, y), bool (*)(failed, failed) > +struct assert_relation {}; +# define BOOST_MPL_AUX_ASSERT_RELATION(x, y, r) assert_relation +#endif + +#else // BOOST_MPL_CFG_ASSERT_USE_RELATION_NAMES + +boost::mpl::aux::weighted_tag<1>::type operator==( assert_, assert_ ); +boost::mpl::aux::weighted_tag<2>::type operator!=( assert_, assert_ ); +boost::mpl::aux::weighted_tag<3>::type operator>( assert_, assert_ ); +boost::mpl::aux::weighted_tag<4>::type operator>=( assert_, assert_ ); +boost::mpl::aux::weighted_tag<5>::type operator<( assert_, assert_ ); +boost::mpl::aux::weighted_tag<6>::type operator<=( assert_, assert_ ); + +template< assert_::relations r, long x, long y > struct assert_relation {}; + +#endif + +#if BOOST_WORKAROUND(BOOST_MSVC, == 1700) + +template +struct extract_assert_pred; + +template +struct extract_assert_pred { typedef Pred type; }; + +template +struct eval_assert { + typedef typename extract_assert_pred::type P; + typedef typename P::type p_type; + typedef typename ::boost::mpl::if_c), + failed ************ P::************ + >::type type; +}; + +template +struct eval_assert_not { + typedef typename extract_assert_pred::type P; + typedef typename P::type p_type; + typedef typename ::boost::mpl::if_c), + failed ************ ::boost::mpl::not_

::************ + >::type type; +}; + +template< typename T > +T make_assert_arg(); + +#elif !defined(BOOST_MPL_CFG_ASSERT_BROKEN_POINTER_TO_POINTER_TO_MEMBER) + +template< bool > struct assert_arg_pred_impl { typedef int type; }; +template<> struct assert_arg_pred_impl { typedef void* type; }; + +template< typename P > struct assert_arg_pred +{ + typedef typename P::type p_type; + typedef typename assert_arg_pred_impl< p_type::value >::type type; +}; + +template< typename P > struct assert_arg_pred_not +{ + typedef typename P::type p_type; + BOOST_MPL_AUX_ASSERT_CONSTANT( bool, p = !p_type::value ); + typedef typename assert_arg_pred_impl

::type type; +}; + +template< typename Pred > +failed ************ (Pred::************ + assert_arg( void (*)(Pred), typename assert_arg_pred::type ) + ); + +template< typename Pred > +failed ************ (boost::mpl::not_::************ + assert_not_arg( void (*)(Pred), typename assert_arg_pred_not::type ) + ); + +template< typename Pred > +AUX778076_ASSERT_ARG(assert) +assert_arg( void (*)(Pred), typename assert_arg_pred_not::type ); + +template< typename Pred > +AUX778076_ASSERT_ARG(assert) +assert_not_arg( void (*)(Pred), typename assert_arg_pred::type ); + + +#else // BOOST_MPL_CFG_ASSERT_BROKEN_POINTER_TO_POINTER_TO_MEMBER + +template< bool c, typename Pred > struct assert_arg_type_impl +{ + typedef failed ************ Pred::* mwcw83_wknd; + typedef mwcw83_wknd ************* type; +}; + +template< typename Pred > struct assert_arg_type_impl +{ + typedef AUX778076_ASSERT_ARG(assert) type; +}; + +template< typename Pred > struct assert_arg_type + : assert_arg_type_impl< BOOST_MPL_AUX_VALUE_WKND(BOOST_MPL_AUX_NESTED_TYPE_WKND(Pred))::value, Pred > +{ +}; + +template< typename Pred > +typename assert_arg_type::type +assert_arg(void (*)(Pred), int); + +template< typename Pred > +typename assert_arg_type< boost::mpl::not_ >::type +assert_not_arg(void (*)(Pred), int); + +# if !defined(BOOST_MPL_CFG_ASSERT_USE_RELATION_NAMES) +template< long x, long y, bool (*r)(failed, failed) > +typename assert_arg_type_impl< false,BOOST_MPL_AUX_ASSERT_RELATION(x,y,r) >::type +assert_rel_arg( BOOST_MPL_AUX_ASSERT_RELATION(x,y,r) ); +# else +template< assert_::relations r, long x, long y > +typename assert_arg_type_impl< false,assert_relation >::type +assert_rel_arg( assert_relation ); +# endif + +#endif // BOOST_MPL_CFG_ASSERT_BROKEN_POINTER_TO_POINTER_TO_MEMBER + +#undef AUX778076_ASSERT_ARG + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE + +#if BOOST_WORKAROUND(BOOST_MSVC, == 1700) + +// BOOST_MPL_ASSERT((pred)) + +#define BOOST_MPL_ASSERT(pred) \ +BOOST_MPL_AUX_ASSERT_CONSTANT( \ + std::size_t \ + , BOOST_PP_CAT(mpl_assertion_in_line_,BOOST_MPL_AUX_PP_COUNTER()) = sizeof( \ + boost::mpl::assertion_failed( \ + boost::mpl::make_assert_arg< \ + typename boost::mpl::eval_assert::type \ + >() \ + ) \ + ) \ + ) \ +/**/ + +// BOOST_MPL_ASSERT_NOT((pred)) + +#define BOOST_MPL_ASSERT_NOT(pred) \ +BOOST_MPL_AUX_ASSERT_CONSTANT( \ + std::size_t \ + , BOOST_PP_CAT(mpl_assertion_in_line_,BOOST_MPL_AUX_PP_COUNTER()) = sizeof( \ + boost::mpl::assertion_failed( \ + boost::mpl::make_assert_arg< \ + typename boost::mpl::eval_assert_not::type \ + >() \ + ) \ + ) \ + ) \ +/**/ + +#else + +// BOOST_MPL_ASSERT((pred)) + +#define BOOST_MPL_ASSERT(pred) \ +BOOST_MPL_AUX_ASSERT_CONSTANT( \ + std::size_t \ + , BOOST_PP_CAT(mpl_assertion_in_line_,BOOST_MPL_AUX_PP_COUNTER()) = sizeof( \ + boost::mpl::assertion_failed( \ + boost::mpl::assert_arg( (void (*) pred)0, 1 ) \ + ) \ + ) \ + ) \ +/**/ + +// BOOST_MPL_ASSERT_NOT((pred)) + +#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) +# define BOOST_MPL_ASSERT_NOT(pred) \ +enum { \ + BOOST_PP_CAT(mpl_assertion_in_line_,BOOST_MPL_AUX_PP_COUNTER()) = sizeof( \ + boost::mpl::assertion::failed( \ + boost::mpl::assert_not_arg( (void (*) pred)0, 1 ) \ + ) \ + ) \ +}\ +/**/ +#else +# define BOOST_MPL_ASSERT_NOT(pred) \ +BOOST_MPL_AUX_ASSERT_CONSTANT( \ + std::size_t \ + , BOOST_PP_CAT(mpl_assertion_in_line_,BOOST_MPL_AUX_PP_COUNTER()) = sizeof( \ + boost::mpl::assertion_failed( \ + boost::mpl::assert_not_arg( (void (*) pred)0, 1 ) \ + ) \ + ) \ + ) \ +/**/ +#endif + +#endif + +// BOOST_MPL_ASSERT_RELATION(x, ==|!=|<=|<|>=|>, y) + +#if defined(BOOST_MPL_CFG_ASSERT_USE_RELATION_NAMES) + +# if !defined(BOOST_MPL_CFG_ASSERT_BROKEN_POINTER_TO_POINTER_TO_MEMBER) +// agurt, 9/nov/06: 'enum' below is a workaround for gcc 4.0.4/4.1.1 bugs #29522 and #29518 +# define BOOST_MPL_ASSERT_RELATION_IMPL(counter, x, rel, y) \ +enum { BOOST_PP_CAT(mpl_assert_rel_value,counter) = (x rel y) }; \ +BOOST_MPL_AUX_ASSERT_CONSTANT( \ + std::size_t \ + , BOOST_PP_CAT(mpl_assertion_in_line_,counter) = sizeof( \ + boost::mpl::assertion_failed( \ + (boost::mpl::failed ************ ( boost::mpl::assert_relation< \ + boost::mpl::assert_::relations( sizeof( \ + boost::mpl::assert_::arg rel boost::mpl::assert_::arg \ + ) ) \ + , x \ + , y \ + >::************)) 0 ) \ + ) \ + ) \ +/**/ +# else +# define BOOST_MPL_ASSERT_RELATION_IMPL(counter, x, rel, y) \ +BOOST_MPL_AUX_ASSERT_CONSTANT( \ + std::size_t \ + , BOOST_PP_CAT(mpl_assert_rel,counter) = sizeof( \ + boost::mpl::assert_::arg rel boost::mpl::assert_::arg \ + ) \ + ); \ +BOOST_MPL_AUX_ASSERT_CONSTANT( bool, BOOST_PP_CAT(mpl_assert_rel_value,counter) = (x rel y) ); \ +BOOST_MPL_AUX_ASSERT_CONSTANT( \ + std::size_t \ + , BOOST_PP_CAT(mpl_assertion_in_line_,counter) = sizeof( \ + boost::mpl::assertion_failed( \ + boost::mpl::assert_rel_arg( boost::mpl::assert_relation< \ + boost::mpl::assert_::relations(BOOST_PP_CAT(mpl_assert_rel,counter)) \ + , x \ + , y \ + >() ) \ + ) \ + ) \ + ) \ +/**/ +# endif + +# define BOOST_MPL_ASSERT_RELATION(x, rel, y) \ +BOOST_MPL_ASSERT_RELATION_IMPL(BOOST_MPL_AUX_PP_COUNTER(), x, rel, y) \ +/**/ + +#else // !BOOST_MPL_CFG_ASSERT_USE_RELATION_NAMES + +# if defined(BOOST_MPL_CFG_ASSERT_BROKEN_POINTER_TO_POINTER_TO_MEMBER) +# define BOOST_MPL_ASSERT_RELATION(x, rel, y) \ +BOOST_MPL_AUX_ASSERT_CONSTANT( \ + std::size_t \ + , BOOST_PP_CAT(mpl_assertion_in_line_,BOOST_MPL_AUX_PP_COUNTER()) = sizeof( \ + boost::mpl::assertion_failed<(x rel y)>( boost::mpl::assert_rel_arg( \ + boost::mpl::BOOST_MPL_AUX_ASSERT_RELATION(x,y,(&boost::mpl::operator rel))() \ + ) ) \ + ) \ + ) \ +/**/ +# else +# define BOOST_MPL_ASSERT_RELATION(x, rel, y) \ +BOOST_MPL_AUX_ASSERT_CONSTANT( \ + std::size_t \ + , BOOST_PP_CAT(mpl_assertion_in_line_,BOOST_MPL_AUX_PP_COUNTER()) = sizeof( \ + boost::mpl::assertion_failed<(x rel y)>( (boost::mpl::failed ************ ( \ + boost::mpl::BOOST_MPL_AUX_ASSERT_RELATION(x,y,(&boost::mpl::operator rel))::************))0 ) \ + ) \ + ) \ +/**/ +# endif + +#endif + + +// BOOST_MPL_ASSERT_MSG( (pred::value), USER_PROVIDED_MESSAGE, (types) ) + +#if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3202)) +# define BOOST_MPL_ASSERT_MSG_IMPL( counter, c, msg, types_ ) \ +struct msg; \ +typedef struct BOOST_PP_CAT(msg,counter) : boost::mpl::assert_ \ +{ \ + using boost::mpl::assert_::types; \ + static boost::mpl::failed ************ (msg::************ assert_arg()) types_ \ + { return 0; } \ +} BOOST_PP_CAT(mpl_assert_arg,counter); \ +BOOST_MPL_AUX_ASSERT_CONSTANT( \ + std::size_t \ + , BOOST_PP_CAT(mpl_assertion_in_line_,counter) = sizeof( \ + boost::mpl::assertion<(c)>::failed( BOOST_PP_CAT(mpl_assert_arg,counter)::assert_arg() ) \ + ) \ + ) \ +/**/ +#else +# define BOOST_MPL_ASSERT_MSG_IMPL( counter, c, msg, types_ ) \ +struct msg; \ +typedef struct BOOST_PP_CAT(msg,counter) : boost::mpl::assert_ \ +{ \ + static boost::mpl::failed ************ (msg::************ assert_arg()) types_ \ + { return 0; } \ +} BOOST_PP_CAT(mpl_assert_arg,counter); \ +BOOST_MPL_AUX_ASSERT_CONSTANT( \ + std::size_t \ + , BOOST_PP_CAT(mpl_assertion_in_line_,counter) = sizeof( \ + boost::mpl::assertion_failed<(c)>( BOOST_PP_CAT(mpl_assert_arg,counter)::assert_arg() ) \ + ) \ + ) \ +/**/ +#endif + +#define BOOST_MPL_ASSERT_MSG( c, msg, types_ ) \ +BOOST_MPL_ASSERT_MSG_IMPL( BOOST_MPL_AUX_PP_COUNTER(), c, msg, types_ ) \ +/**/ + +#endif // BOOST_MPL_ASSERT_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/mpl/aux_/adl_barrier.hpp b/realsense-file/3rd_party/boost/boost/mpl/aux_/adl_barrier.hpp new file mode 100644 index 0000000000..89acd3826a --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/aux_/adl_barrier.hpp @@ -0,0 +1,48 @@ + +#ifndef BOOST_MPL_AUX_ADL_BARRIER_HPP_INCLUDED +#define BOOST_MPL_AUX_ADL_BARRIER_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2002-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Id$ +// $Date$ +// $Revision$ + +#include "config/adl.hpp" +#include "config/gcc.hpp" +#include "config/workaround.hpp" + +#if !defined(BOOST_MPL_CFG_NO_ADL_BARRIER_NAMESPACE) + +# define BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE mpl_ +# define BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN namespace mpl_ { +# define BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE } +# define BOOST_MPL_AUX_ADL_BARRIER_DECL(type) \ + namespace boost { namespace mpl { \ + using ::BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::type; \ + } } \ +/**/ + +#if !defined(BOOST_MPL_PREPROCESSING_MODE) +namespace BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE { namespace aux {} } +namespace boost { namespace mpl { using namespace BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE; +namespace aux { using namespace BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::aux; } +}} +#endif + +#else // BOOST_MPL_CFG_NO_ADL_BARRIER_NAMESPACE + +# define BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE boost::mpl +# define BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN namespace boost { namespace mpl { +# define BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE }} +# define BOOST_MPL_AUX_ADL_BARRIER_DECL(type) /**/ + +#endif + +#endif // BOOST_MPL_AUX_ADL_BARRIER_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/mpl/aux_/arg_typedef.hpp b/realsense-file/3rd_party/boost/boost/mpl/aux_/arg_typedef.hpp new file mode 100644 index 0000000000..6b8584c2e5 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/aux_/arg_typedef.hpp @@ -0,0 +1,31 @@ + +#ifndef BOOST_MPL_AUX_ARG_TYPEDEF_HPP_INCLUDED +#define BOOST_MPL_AUX_ARG_TYPEDEF_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Id$ +// $Date$ +// $Revision$ + +#include +#include + +#if defined(BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT) \ + || BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840)) + +# define BOOST_MPL_AUX_ARG_TYPEDEF(T, name) typedef T name; + +#else + +# define BOOST_MPL_AUX_ARG_TYPEDEF(T, name) /**/ + +#endif + +#endif // BOOST_MPL_AUX_ARG_TYPEDEF_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/mpl/aux_/arity.hpp b/realsense-file/3rd_party/boost/boost/mpl/aux_/arity.hpp new file mode 100644 index 0000000000..944c4dafdf --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/aux_/arity.hpp @@ -0,0 +1,39 @@ + +#ifndef BOOST_MPL_AUX_ARITY_HPP_INCLUDED +#define BOOST_MPL_AUX_ARITY_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Id$ +// $Date$ +// $Revision$ + +#include + +#if defined(BOOST_MPL_CFG_BROKEN_DEFAULT_PARAMETERS_IN_NESTED_TEMPLATES) + +# include +# include + +namespace boost { namespace mpl { namespace aux { + +// agurt, 15/mar/02: it's possible to implement the template so that it will +// "just work" and do not require any specialization, but not on the compilers +// that require the arity workaround in the first place +template< typename F, BOOST_MPL_AUX_NTTP_DECL(int, N) > +struct arity +{ + BOOST_STATIC_CONSTANT(int, value = N); +}; + +}}} + +#endif // BOOST_MPL_CFG_BROKEN_DEFAULT_PARAMETERS_IN_NESTED_TEMPLATES + +#endif // BOOST_MPL_AUX_ARITY_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/mpl/aux_/arity_spec.hpp b/realsense-file/3rd_party/boost/boost/mpl/aux_/arity_spec.hpp new file mode 100644 index 0000000000..c77713b90f --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/aux_/arity_spec.hpp @@ -0,0 +1,67 @@ + +#ifndef BOOST_MPL_AUX_ARITY_SPEC_HPP_INCLUDED +#define BOOST_MPL_AUX_ARITY_SPEC_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Id$ +// $Date$ +// $Revision$ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#if defined(BOOST_MPL_CFG_BROKEN_DEFAULT_PARAMETERS_IN_NESTED_TEMPLATES) +# define BOOST_MPL_AUX_NONTYPE_ARITY_SPEC(i,type,name) \ +namespace aux { \ +template< BOOST_MPL_AUX_NTTP_DECL(int, N), BOOST_MPL_PP_PARAMS(i,type T) > \ +struct arity< \ + name< BOOST_MPL_PP_PARAMS(i,T) > \ + , N \ + > \ +{ \ + BOOST_STATIC_CONSTANT(int \ + , value = BOOST_MPL_LIMIT_METAFUNCTION_ARITY \ + ); \ +}; \ +} \ +/**/ +#else +# define BOOST_MPL_AUX_NONTYPE_ARITY_SPEC(i,type,name) /**/ +#endif + +# define BOOST_MPL_AUX_ARITY_SPEC(i,name) \ + BOOST_MPL_AUX_NONTYPE_ARITY_SPEC(i,typename,name) \ +/**/ + + +#if defined(BOOST_MPL_CFG_EXTENDED_TEMPLATE_PARAMETERS_MATCHING) \ + && !defined(BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT) +# define BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(i, name) \ +namespace aux { \ +template< BOOST_MPL_PP_PARAMS(i,typename T) > \ +struct template_arity< name > \ + : int_ \ +{ \ +}; \ +} \ +/**/ +#else +# define BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(i, name) /**/ +#endif + + +#endif // BOOST_MPL_AUX_ARITY_SPEC_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/mpl/aux_/config/adl.hpp b/realsense-file/3rd_party/boost/boost/mpl/aux_/config/adl.hpp new file mode 100644 index 0000000000..8f6215069b --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/aux_/config/adl.hpp @@ -0,0 +1,40 @@ + +#ifndef BOOST_MPL_AUX_CONFIG_ADL_HPP_INCLUDED +#define BOOST_MPL_AUX_CONFIG_ADL_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2002-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Id$ +// $Date$ +// $Revision$ + +#include "msvc.hpp" +#include "intel.hpp" +#include "gcc.hpp" +#include "workaround.hpp" + +// agurt, 25/apr/04: technically, the ADL workaround is only needed for GCC, +// but putting everything expect public, user-specializable metafunctions into +// a separate global namespace has a nice side effect of reducing the length +// of template instantiation symbols, so we apply the workaround on all +// platforms that can handle it + +#if !defined(BOOST_MPL_CFG_NO_ADL_BARRIER_NAMESPACE) \ + && ( BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1400)) \ + || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x610)) \ + || BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840)) \ + || BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3202)) \ + || BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION, BOOST_TESTED_AT(810)) \ + ) + +# define BOOST_MPL_CFG_NO_ADL_BARRIER_NAMESPACE + +#endif + +#endif // BOOST_MPL_AUX_CONFIG_ADL_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/mpl/aux_/config/arrays.hpp b/realsense-file/3rd_party/boost/boost/mpl/aux_/config/arrays.hpp new file mode 100644 index 0000000000..e30d803335 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/aux_/config/arrays.hpp @@ -0,0 +1,30 @@ + +#ifndef BOOST_MPL_AUX_CONFIG_ARRAYS_HPP_INCLUDED +#define BOOST_MPL_AUX_CONFIG_ARRAYS_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2003-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Id$ +// $Date$ +// $Revision$ + +#include +#include + +#if !defined(BOOST_MPL_CFG_NO_DEPENDENT_ARRAY_TYPES) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) \ + && ( BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x610)) \ + || BOOST_WORKAROUND(BOOST_MSVC, <= 1300) \ + ) + +# define BOOST_MPL_CFG_NO_DEPENDENT_ARRAY_TYPES + +#endif + +#endif // BOOST_MPL_AUX_CONFIG_ARRAYS_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/mpl/aux_/config/bcc.hpp b/realsense-file/3rd_party/boost/boost/mpl/aux_/config/bcc.hpp new file mode 100644 index 0000000000..ee7816e769 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/aux_/config/bcc.hpp @@ -0,0 +1,28 @@ + +#ifndef BOOST_MPL_AUX_CONFIG_BCC_HPP_INCLUDED +#define BOOST_MPL_AUX_CONFIG_BCC_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2008 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Id$ +// $Date: 2004-09-02 10:41:37 -0500 (Thu, 02 Sep 2004) $ +// $Revision: 24874 $ + +#include + +#if !defined(BOOST_MPL_CFG_BCC590_WORKAROUNDS) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) \ + && BOOST_WORKAROUND(__BORLANDC__, >= 0x590) \ + && BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x610)) + +# define BOOST_MPL_CFG_BCC590_WORKAROUNDS + +#endif + +#endif // BOOST_MPL_AUX_CONFIG_BCC_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/mpl/aux_/config/bind.hpp b/realsense-file/3rd_party/boost/boost/mpl/aux_/config/bind.hpp new file mode 100644 index 0000000000..ea644b5384 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/aux_/config/bind.hpp @@ -0,0 +1,33 @@ + +#ifndef BOOST_MPL_AUX_CONFIG_BIND_HPP_INCLUDED +#define BOOST_MPL_AUX_CONFIG_BIND_HPP_INCLUDED + +// Copyright David Abrahams 2002 +// Copyright Aleksey Gurtovoy 2002-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Id$ +// $Date$ +// $Revision$ + +#include +#include + +#if !defined(BOOST_MPL_CFG_NO_BIND_TEMPLATE) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) \ + && ( BOOST_WORKAROUND(BOOST_MSVC, <= 1300) \ + || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x610)) \ + ) + +# define BOOST_MPL_CFG_NO_BIND_TEMPLATE + +#endif + +//#define BOOST_MPL_CFG_NO_UNNAMED_PLACEHOLDER_SUPPORT + +#endif // BOOST_MPL_AUX_CONFIG_BIND_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/mpl/aux_/config/compiler.hpp b/realsense-file/3rd_party/boost/boost/mpl/aux_/config/compiler.hpp new file mode 100644 index 0000000000..d680e79e18 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/aux_/config/compiler.hpp @@ -0,0 +1,66 @@ + +#ifndef BOOST_MPL_AUX_CONFIG_COMPILER_HPP_INCLUDED +#define BOOST_MPL_AUX_CONFIG_COMPILER_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2001-2008 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Id$ +// $Date$ +// $Revision$ + +#if !defined(BOOST_MPL_CFG_COMPILER_DIR) + +# include +# include +# include +# include +# include +# include + +# if BOOST_WORKAROUND(BOOST_MSVC, < 1300) +# define BOOST_MPL_CFG_COMPILER_DIR msvc60 + +# elif BOOST_WORKAROUND(BOOST_MSVC, == 1300) +# define BOOST_MPL_CFG_COMPILER_DIR msvc70 + +# elif BOOST_WORKAROUND(BOOST_MPL_CFG_GCC, BOOST_TESTED_AT(0x0304)) +# define BOOST_MPL_CFG_COMPILER_DIR gcc + +# elif BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x610)) +# if !defined(BOOST_MPL_CFG_NO_DEFAULT_PARAMETERS_IN_NESTED_TEMPLATES) +# define BOOST_MPL_CFG_COMPILER_DIR bcc551 +# elif BOOST_WORKAROUND(__BORLANDC__, >= 0x590) +# define BOOST_MPL_CFG_COMPILER_DIR bcc +# else +# define BOOST_MPL_CFG_COMPILER_DIR bcc_pre590 +# endif + +# elif BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840)) +# define BOOST_MPL_CFG_COMPILER_DIR dmc + +# elif defined(__MWERKS__) +# if defined(BOOST_MPL_CFG_BROKEN_DEFAULT_PARAMETERS_IN_NESTED_TEMPLATES) +# define BOOST_MPL_CFG_COMPILER_DIR mwcw +# else +# define BOOST_MPL_CFG_COMPILER_DIR plain +# endif + +# elif defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) +# define BOOST_MPL_CFG_COMPILER_DIR no_ctps + +# elif defined(BOOST_MPL_CFG_NO_TEMPLATE_TEMPLATE_PARAMETERS) +# define BOOST_MPL_CFG_COMPILER_DIR no_ttp + +# else +# define BOOST_MPL_CFG_COMPILER_DIR plain +# endif + +#endif // BOOST_MPL_CFG_COMPILER_DIR + +#endif // BOOST_MPL_AUX_CONFIG_COMPILER_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/mpl/aux_/config/ctps.hpp b/realsense-file/3rd_party/boost/boost/mpl/aux_/config/ctps.hpp new file mode 100644 index 0000000000..e6b41dd75e --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/aux_/config/ctps.hpp @@ -0,0 +1,30 @@ + +#ifndef BOOST_MPL_AUX_CONFIG_CTPS_HPP_INCLUDED +#define BOOST_MPL_AUX_CONFIG_CTPS_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Id$ +// $Date$ +// $Revision$ + +#include "boost/mpl/aux_/config/workaround.hpp" +#include "boost/config.hpp" + +#if !defined(BOOST_MPL_CFG_NO_NONTYPE_TEMPLATE_PARTIAL_SPEC) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) \ + && BOOST_WORKAROUND(__BORLANDC__, < 0x582) + +# define BOOST_MPL_CFG_NO_NONTYPE_TEMPLATE_PARTIAL_SPEC + +#endif + +// BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION is defined in + +#endif // BOOST_MPL_AUX_CONFIG_CTPS_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/mpl/aux_/config/dtp.hpp b/realsense-file/3rd_party/boost/boost/mpl/aux_/config/dtp.hpp new file mode 100644 index 0000000000..dd3d2ac6f4 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/aux_/config/dtp.hpp @@ -0,0 +1,46 @@ + +#ifndef BOOST_MPL_AUX_CONFIG_DTP_HPP_INCLUDED +#define BOOST_MPL_AUX_CONFIG_DTP_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Id$ +// $Date$ +// $Revision$ + +#include + +// MWCW 7.x-8.0 "losts" default template parameters of nested class +// templates when their owner classes are passed as arguments to other +// templates; Borland 5.5.1 "forgets" them from the very beginning (if +// the owner class is a class template), and Borland 5.6 isn't even +// able to compile a definition of nested class template with DTP + +#if !defined(BOOST_MPL_CFG_NO_DEFAULT_PARAMETERS_IN_NESTED_TEMPLATES) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) \ + && BOOST_WORKAROUND(__BORLANDC__, >= 0x560) \ + && BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x610)) + +# define BOOST_MPL_CFG_NO_DEFAULT_PARAMETERS_IN_NESTED_TEMPLATES + +#endif + + +#if !defined(BOOST_MPL_CFG_BROKEN_DEFAULT_PARAMETERS_IN_NESTED_TEMPLATES) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) \ + && ( BOOST_WORKAROUND(__MWERKS__, <= 0x3001) \ + || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x610)) \ + || defined(BOOST_MPL_CFG_NO_DEFAULT_PARAMETERS_IN_NESTED_TEMPLATES) \ + ) + +# define BOOST_MPL_CFG_BROKEN_DEFAULT_PARAMETERS_IN_NESTED_TEMPLATES + +#endif + +#endif // BOOST_MPL_AUX_CONFIG_DTP_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/mpl/aux_/config/eti.hpp b/realsense-file/3rd_party/boost/boost/mpl/aux_/config/eti.hpp new file mode 100644 index 0000000000..4de6aa64d6 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/aux_/config/eti.hpp @@ -0,0 +1,47 @@ + +#ifndef BOOST_MPL_AUX_CONFIG_ETI_HPP_INCLUDED +#define BOOST_MPL_AUX_CONFIG_ETI_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Id$ +// $Date$ +// $Revision$ + +#include +#include + +// flags for MSVC 6.5's so-called "early template instantiation bug" +#if !defined(BOOST_MPL_CFG_MSVC_60_ETI_BUG) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) \ + && BOOST_WORKAROUND(BOOST_MSVC, < 1300) + +# define BOOST_MPL_CFG_MSVC_60_ETI_BUG + +#endif + +#if !defined(BOOST_MPL_CFG_MSVC_70_ETI_BUG) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) \ + && BOOST_WORKAROUND(BOOST_MSVC, == 1300) + +# define BOOST_MPL_CFG_MSVC_70_ETI_BUG + +#endif + +#if !defined(BOOST_MPL_CFG_MSVC_ETI_BUG) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) \ + && ( defined(BOOST_MPL_CFG_MSVC_60_ETI_BUG) \ + || defined(BOOST_MPL_CFG_MSVC_70_ETI_BUG) \ + ) + +# define BOOST_MPL_CFG_MSVC_ETI_BUG + +#endif + +#endif // BOOST_MPL_AUX_CONFIG_ETI_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/mpl/aux_/config/gcc.hpp b/realsense-file/3rd_party/boost/boost/mpl/aux_/config/gcc.hpp new file mode 100644 index 0000000000..eea2438295 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/aux_/config/gcc.hpp @@ -0,0 +1,23 @@ + +#ifndef BOOST_MPL_AUX_CONFIG_GCC_HPP_INCLUDED +#define BOOST_MPL_AUX_CONFIG_GCC_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Id$ +// $Date$ +// $Revision$ + +#if defined(__GNUC__) && !defined(__EDG_VERSION__) +# define BOOST_MPL_CFG_GCC ((__GNUC__ << 8) | __GNUC_MINOR__) +#else +# define BOOST_MPL_CFG_GCC 0 +#endif + +#endif // BOOST_MPL_AUX_CONFIG_GCC_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/mpl/aux_/config/gpu.hpp b/realsense-file/3rd_party/boost/boost/mpl/aux_/config/gpu.hpp new file mode 100644 index 0000000000..61e6408d2f --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/aux_/config/gpu.hpp @@ -0,0 +1,35 @@ + +#ifndef BOOST_MPL_AUX_CONFIG_GPU_HPP_INCLUDED +#define BOOST_MPL_AUX_CONFIG_GPU_HPP_INCLUDED + +// Copyright Eric Niebler 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) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Id$ +// $Date$ +// $Revision$ + +#include + +#if !defined(BOOST_MPL_CFG_GPU_ENABLED) \ + +# define BOOST_MPL_CFG_GPU_ENABLED BOOST_GPU_ENABLED + +#endif + +#if defined __CUDACC__ + +# define BOOST_MPL_CFG_GPU 1 + +#else + +# define BOOST_MPL_CFG_GPU 0 + +#endif + +#endif // BOOST_MPL_AUX_CONFIG_GPU_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/mpl/aux_/config/has_apply.hpp b/realsense-file/3rd_party/boost/boost/mpl/aux_/config/has_apply.hpp new file mode 100644 index 0000000000..4f1dff7285 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/aux_/config/has_apply.hpp @@ -0,0 +1,32 @@ + +#ifndef BOOST_MPL_AUX_CONFIG_HAS_APPLY_HPP_INCLUDED +#define BOOST_MPL_AUX_CONFIG_HAS_APPLY_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Id$ +// $Date$ +// $Revision$ + +#include +#include +#include + +#if !defined(BOOST_MPL_CFG_NO_HAS_APPLY) \ + && ( defined(BOOST_MPL_CFG_NO_HAS_XXX) \ + || BOOST_WORKAROUND(__EDG_VERSION__, < 300) \ + || BOOST_WORKAROUND(BOOST_MSVC, <= 1300) \ + || BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3202)) \ + ) + +# define BOOST_MPL_CFG_NO_HAS_APPLY + +#endif + +#endif // BOOST_MPL_AUX_CONFIG_HAS_APPLY_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/mpl/aux_/config/has_xxx.hpp b/realsense-file/3rd_party/boost/boost/mpl/aux_/config/has_xxx.hpp new file mode 100644 index 0000000000..8100f0fb09 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/aux_/config/has_xxx.hpp @@ -0,0 +1,34 @@ + +#ifndef BOOST_MPL_AUX_CONFIG_HAS_XXX_HPP_INCLUDED +#define BOOST_MPL_AUX_CONFIG_HAS_XXX_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2002-2004 +// Copyright David Abrahams 2002-2003 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Id$ +// $Date$ +// $Revision$ + +#include +#include + +// agurt, 11/jan/03: signals a stub-only 'has_xxx' implementation + +#if !defined(BOOST_MPL_CFG_NO_HAS_XXX) \ + && ( defined(BOOST_MPL_CFG_BROKEN_OVERLOAD_RESOLUTION) \ + || BOOST_WORKAROUND(__GNUC__, <= 2) \ + || BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840)) \ + ) + +# define BOOST_MPL_CFG_NO_HAS_XXX +# define BOOST_MPL_CFG_NO_HAS_XXX_TEMPLATE + +#endif + +#endif // BOOST_MPL_AUX_CONFIG_HAS_XXX_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/mpl/aux_/config/integral.hpp b/realsense-file/3rd_party/boost/boost/mpl/aux_/config/integral.hpp new file mode 100644 index 0000000000..f1531b3f96 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/aux_/config/integral.hpp @@ -0,0 +1,38 @@ + +#ifndef BOOST_MPL_AUX_CONFIG_INTEGRAL_HPP_INCLUDED +#define BOOST_MPL_AUX_CONFIG_INTEGRAL_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Id$ +// $Date$ +// $Revision$ + +#include +#include + +#if !defined(BOOST_MPL_CFG_BCC_INTEGRAL_CONSTANTS) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) \ + && BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x610)) + +# define BOOST_MPL_CFG_BCC_INTEGRAL_CONSTANTS + +#endif + +#if !defined(BOOST_MPL_CFG_NO_NESTED_VALUE_ARITHMETIC) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) \ + && ( BOOST_WORKAROUND(BOOST_MSVC, <= 1300) \ + || BOOST_WORKAROUND(__EDG_VERSION__, <= 238) \ + ) + +# define BOOST_MPL_CFG_NO_NESTED_VALUE_ARITHMETIC + +#endif + +#endif // BOOST_MPL_AUX_CONFIG_INTEGRAL_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/mpl/aux_/config/intel.hpp b/realsense-file/3rd_party/boost/boost/mpl/aux_/config/intel.hpp new file mode 100644 index 0000000000..edea980a41 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/aux_/config/intel.hpp @@ -0,0 +1,21 @@ + +#ifndef BOOST_MPL_AUX_CONFIG_INTEL_HPP_INCLUDED +#define BOOST_MPL_AUX_CONFIG_INTEL_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Id$ +// $Date$ +// $Revision$ + + +// BOOST_INTEL_CXX_VERSION is defined here: +#include "../../../config.hpp" + +#endif // BOOST_MPL_AUX_CONFIG_INTEL_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/mpl/aux_/config/lambda.hpp b/realsense-file/3rd_party/boost/boost/mpl/aux_/config/lambda.hpp new file mode 100644 index 0000000000..36b5af017d --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/aux_/config/lambda.hpp @@ -0,0 +1,32 @@ + +#ifndef BOOST_MPL_AUX_CONFIG_LAMBDA_HPP_INCLUDED +#define BOOST_MPL_AUX_CONFIG_LAMBDA_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2002-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Id$ +// $Date$ +// $Revision$ + +#include "boost/mpl/aux_/config/ttp.hpp" +#include "boost/mpl/aux_/config/ctps.hpp" + +// agurt, 15/jan/02: full-fledged implementation requires both +// template template parameters _and_ partial specialization + +#if !defined(BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT) \ + && ( defined(BOOST_MPL_CFG_NO_TEMPLATE_TEMPLATE_PARAMETERS) \ + || defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \ + ) + +# define BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT + +#endif + +#endif // BOOST_MPL_AUX_CONFIG_LAMBDA_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/mpl/aux_/config/msvc.hpp b/realsense-file/3rd_party/boost/boost/mpl/aux_/config/msvc.hpp new file mode 100644 index 0000000000..a8fc9fd692 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/aux_/config/msvc.hpp @@ -0,0 +1,21 @@ + +#ifndef BOOST_MPL_AUX_CONFIG_MSVC_HPP_INCLUDED +#define BOOST_MPL_AUX_CONFIG_MSVC_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2002-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Id$ +// $Date$ +// $Revision$ + + +// BOOST_MSVC is defined here: +#include "../../../config.hpp" + +#endif // BOOST_MPL_AUX_CONFIG_MSVC_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/mpl/aux_/config/msvc_typename.hpp b/realsense-file/3rd_party/boost/boost/mpl/aux_/config/msvc_typename.hpp new file mode 100644 index 0000000000..27b1bde87e --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/aux_/config/msvc_typename.hpp @@ -0,0 +1,26 @@ + +#ifndef BOOST_MPL_AUX_CONFIG_MSVC_TYPENAME_HPP_INCLUDED +#define BOOST_MPL_AUX_CONFIG_MSVC_TYPENAME_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Id$ +// $Date$ +// $Revision$ + +#include +#include + +#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) +# define BOOST_MSVC_TYPENAME +#else +# define BOOST_MSVC_TYPENAME typename +#endif + +#endif // BOOST_MPL_AUX_CONFIG_MSVC_TYPENAME_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/mpl/aux_/config/nttp.hpp b/realsense-file/3rd_party/boost/boost/mpl/aux_/config/nttp.hpp new file mode 100644 index 0000000000..6819f67634 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/aux_/config/nttp.hpp @@ -0,0 +1,41 @@ + +#ifndef BOOST_MPL_AUX_CONFIG_NTTP_HPP_INCLUDED +#define BOOST_MPL_AUX_CONFIG_NTTP_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Id$ +// $Date$ +// $Revision$ + +#include "msvc.hpp" +#include "workaround.hpp" + +// MSVC 6.5 ICE-s on the code as simple as this (see "aux_/nttp_decl.hpp" +// for a workaround): +// +// namespace std { +// template< typename Char > struct string; +// } +// +// void foo(std::string); +// +// namespace boost { namespace mpl { +// template< int > struct arg; +// }} + +#if !defined(BOOST_MPL_CFG_NTTP_BUG) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) \ + && BOOST_WORKAROUND(BOOST_MSVC, < 1300) + +# define BOOST_MPL_CFG_NTTP_BUG + +#endif + +#endif // BOOST_MPL_AUX_CONFIG_NTTP_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/mpl/aux_/config/overload_resolution.hpp b/realsense-file/3rd_party/boost/boost/mpl/aux_/config/overload_resolution.hpp new file mode 100644 index 0000000000..b92bb85e9d --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/aux_/config/overload_resolution.hpp @@ -0,0 +1,29 @@ + +#ifndef BOOST_MPL_AUX_CONFIG_OVERLOAD_RESOLUTION_HPP_INCLUDED +#define BOOST_MPL_AUX_CONFIG_OVERLOAD_RESOLUTION_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2002-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Id$ +// $Date$ +// $Revision$ + +#include "boost/mpl/aux_/config/workaround.hpp" + +#if !defined(BOOST_MPL_CFG_BROKEN_OVERLOAD_RESOLUTION) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) \ + && ( BOOST_WORKAROUND(__BORLANDC__, < 0x590) \ + || BOOST_WORKAROUND(__MWERKS__, < 0x3001) \ + ) + +# define BOOST_MPL_CFG_BROKEN_OVERLOAD_RESOLUTION + +#endif + +#endif // BOOST_MPL_AUX_CONFIG_OVERLOAD_RESOLUTION_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/mpl/aux_/config/pp_counter.hpp b/realsense-file/3rd_party/boost/boost/mpl/aux_/config/pp_counter.hpp new file mode 100644 index 0000000000..e38a40f2f5 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/aux_/config/pp_counter.hpp @@ -0,0 +1,26 @@ + +#ifndef BOOST_MPL_AUX_CONFIG_PP_COUNTER_HPP_INCLUDED +#define BOOST_MPL_AUX_CONFIG_PP_COUNTER_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2006 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Id$ +// $Date$ +// $Revision$ + +#if !defined(BOOST_MPL_AUX_PP_COUNTER) +# include +# if BOOST_WORKAROUND(BOOST_MSVC, >= 1300) +# define BOOST_MPL_AUX_PP_COUNTER() __COUNTER__ +# else +# define BOOST_MPL_AUX_PP_COUNTER() __LINE__ +# endif +#endif + +#endif // BOOST_MPL_AUX_CONFIG_PP_COUNTER_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/mpl/aux_/config/preprocessor.hpp b/realsense-file/3rd_party/boost/boost/mpl/aux_/config/preprocessor.hpp new file mode 100644 index 0000000000..4b78ef3219 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/aux_/config/preprocessor.hpp @@ -0,0 +1,39 @@ + +#ifndef BOOST_MPL_AUX_CONFIG_PREPROCESSOR_HPP_INCLUDED +#define BOOST_MPL_AUX_CONFIG_PREPROCESSOR_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Id$ +// $Date$ +// $Revision$ + +#include "workaround.hpp" + +#if !defined(BOOST_MPL_CFG_BROKEN_PP_MACRO_EXPANSION) \ + && ( BOOST_WORKAROUND(__MWERKS__, <= 0x3003) \ + || BOOST_WORKAROUND(__BORLANDC__, < 0x582) \ + || BOOST_WORKAROUND(__IBMCPP__, BOOST_TESTED_AT(502)) \ + ) + +# define BOOST_MPL_CFG_BROKEN_PP_MACRO_EXPANSION + +#endif + +#if !defined(BOOST_MPL_CFG_NO_OWN_PP_PRIMITIVES) +# define BOOST_MPL_CFG_NO_OWN_PP_PRIMITIVES +#endif + +#if !defined(BOOST_NEEDS_TOKEN_PASTING_OP_FOR_TOKENS_JUXTAPOSING) \ + && BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840)) +# define BOOST_NEEDS_TOKEN_PASTING_OP_FOR_TOKENS_JUXTAPOSING +#endif + + +#endif // BOOST_MPL_AUX_CONFIG_PREPROCESSOR_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/mpl/aux_/config/static_constant.hpp b/realsense-file/3rd_party/boost/boost/mpl/aux_/config/static_constant.hpp new file mode 100644 index 0000000000..22b63585c4 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/aux_/config/static_constant.hpp @@ -0,0 +1,25 @@ + +#ifndef BOOST_MPL_AUX_CONFIG_STATIC_CONSTANT_HPP_INCLUDED +#define BOOST_MPL_AUX_CONFIG_STATIC_CONSTANT_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Id$ +// $Date$ +// $Revision$ + +#if !defined(BOOST_MPL_PREPROCESSING_MODE) +// BOOST_STATIC_CONSTANT is defined here: +# include "../../../config.hpp" +#else +// undef the macro for the preprocessing mode +# undef BOOST_STATIC_CONSTANT +#endif + +#endif // BOOST_MPL_AUX_CONFIG_STATIC_CONSTANT_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/mpl/aux_/config/ttp.hpp b/realsense-file/3rd_party/boost/boost/mpl/aux_/config/ttp.hpp new file mode 100644 index 0000000000..a19bd26aee --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/aux_/config/ttp.hpp @@ -0,0 +1,41 @@ + +#ifndef BOOST_MPL_AUX_CONFIG_TTP_HPP_INCLUDED +#define BOOST_MPL_AUX_CONFIG_TTP_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Id$ +// $Date$ +// $Revision$ + +#include "boost/mpl/aux_/config/msvc.hpp" +#include "boost/mpl/aux_/config/gcc.hpp" +#include "boost/mpl/aux_/config/workaround.hpp" + +#if !defined(BOOST_MPL_CFG_NO_TEMPLATE_TEMPLATE_PARAMETERS) \ + && ( defined(BOOST_NO_TEMPLATE_TEMPLATES) \ + || BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT( 0x590) ) \ + ) + +# define BOOST_MPL_CFG_NO_TEMPLATE_TEMPLATE_PARAMETERS + +#endif + + +#if !defined(BOOST_MPL_CFG_EXTENDED_TEMPLATE_PARAMETERS_MATCHING) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) \ + && ( BOOST_WORKAROUND(BOOST_MPL_CFG_GCC, BOOST_TESTED_AT(0x0302)) \ + || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x610)) \ + ) + +# define BOOST_MPL_CFG_EXTENDED_TEMPLATE_PARAMETERS_MATCHING + +#endif + +#endif // BOOST_MPL_AUX_CONFIG_TTP_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/mpl/aux_/config/use_preprocessed.hpp b/realsense-file/3rd_party/boost/boost/mpl/aux_/config/use_preprocessed.hpp new file mode 100644 index 0000000000..9eb0dd987a --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/aux_/config/use_preprocessed.hpp @@ -0,0 +1,19 @@ + +#ifndef BOOST_MPL_AUX_CONFIG_USE_PREPROCESSED_HPP_INCLUDED +#define BOOST_MPL_AUX_CONFIG_USE_PREPROCESSED_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Id$ +// $Date$ +// $Revision$ + +// #define BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS + +#endif // BOOST_MPL_AUX_CONFIG_USE_PREPROCESSED_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/mpl/aux_/config/workaround.hpp b/realsense-file/3rd_party/boost/boost/mpl/aux_/config/workaround.hpp new file mode 100644 index 0000000000..4009af0384 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/aux_/config/workaround.hpp @@ -0,0 +1,19 @@ + +#ifndef BOOST_MPL_AUX_CONFIG_WORKAROUND_HPP_INCLUDED +#define BOOST_MPL_AUX_CONFIG_WORKAROUND_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2002-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Id$ +// $Date$ +// $Revision$ + +#include "../../../detail/workaround.hpp" + +#endif // BOOST_MPL_AUX_CONFIG_WORKAROUND_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/mpl/aux_/full_lambda.hpp b/realsense-file/3rd_party/boost/boost/mpl/aux_/full_lambda.hpp new file mode 100644 index 0000000000..451fcf7fac --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/aux_/full_lambda.hpp @@ -0,0 +1,354 @@ + +#if !defined(BOOST_PP_IS_ITERATING) + +///// header body + +#ifndef BOOST_MPL_AUX_FULL_LAMBDA_HPP_INCLUDED +#define BOOST_MPL_AUX_FULL_LAMBDA_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Id$ +// $Date$ +// $Revision$ + +#if !defined(BOOST_MPL_PREPROCESSING_MODE) +# include +# include +# include +# include +# include +# include +# include +# include +# include +# include +# if defined(BOOST_MPL_CFG_EXTENDED_TEMPLATE_PARAMETERS_MATCHING) +# include +# endif +#endif + +#include +#include + +#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) + +# define BOOST_MPL_PREPROCESSED_HEADER full_lambda.hpp +# include + +#else + +# include +# include +# include +# include +# include +# include + +# include +# include +# include +# include + +namespace boost { namespace mpl { + +// local macros, #undef-ined at the end of the header +# define AUX778076_LAMBDA_PARAMS(i_, param) \ + BOOST_MPL_PP_PARAMS(i_, param) \ + /**/ + +# define AUX778076_BIND_PARAMS(param) \ + BOOST_MPL_PP_PARAMS( \ + BOOST_MPL_LIMIT_METAFUNCTION_ARITY \ + , param \ + ) \ + /**/ + +# define AUX778076_BIND_N_PARAMS(i_, param) \ + BOOST_PP_COMMA_IF(i_) \ + BOOST_MPL_PP_PARAMS(i_, param) \ + /**/ + +# define AUX778076_ARITY_PARAM(param) \ + BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(param) \ + /**/ + + +#define n_ BOOST_MPL_LIMIT_METAFUNCTION_ARITY +namespace aux { + +template< + BOOST_MPL_PP_DEFAULT_PARAMS(n_,bool C,false) + > +struct lambda_or + : true_ +{ +}; + +template<> +struct lambda_or< BOOST_MPL_PP_ENUM(n_,false) > + : false_ +{ +}; + +} // namespace aux +#undef n_ + +template< + typename T + , typename Tag + AUX778076_ARITY_PARAM(typename Arity) + > +struct lambda +{ + typedef false_ is_le; + typedef T result_; + typedef T type; +}; + +template< + typename T + > +struct is_lambda_expression + : lambda::is_le +{ +}; + + +template< int N, typename Tag > +struct lambda< arg,Tag AUX778076_ARITY_PARAM(int_<-1>) > +{ + typedef true_ is_le; + typedef mpl::arg result_; // qualified for the sake of MIPSpro 7.41 + typedef mpl::protect type; +}; + + +#define BOOST_PP_ITERATION_PARAMS_1 \ + (3,(0, BOOST_MPL_LIMIT_METAFUNCTION_ARITY, )) +#include BOOST_PP_ITERATE() + +/// special case for 'protect' +template< typename T, typename Tag > +struct lambda< mpl::protect,Tag AUX778076_ARITY_PARAM(int_<1>) > +{ + typedef false_ is_le; + typedef mpl::protect result_; + typedef result_ type; +}; + +/// specializations for the main 'bind' form +template< + typename F, AUX778076_BIND_PARAMS(typename T) + , typename Tag + > +struct lambda< + bind + , Tag + AUX778076_ARITY_PARAM(int_) + > +{ + typedef false_ is_le; + typedef bind result_; + typedef result_ type; +}; + + +#if defined(BOOST_MPL_CFG_EXTENDED_TEMPLATE_PARAMETERS_MATCHING) + +template< + typename F + , typename Tag1 + , typename Tag2 + , typename Arity + > +struct lambda< + lambda + , Tag2 + , int_<3> + > +{ + typedef lambda< F,Tag2 > l1; + typedef lambda< Tag1,Tag2 > l2; + + typedef typename l1::is_le is_le; + typedef bind1< quote1, typename l1::result_ > arity_; + typedef lambda< typename if_::type,Tag2 > l3; + + typedef aux::le_result3 le_result_; + typedef typename le_result_::result_ result_; + typedef typename le_result_::type type; +}; + +#elif !defined(BOOST_MPL_CFG_DMC_AMBIGUOUS_CTPS) + +/// workaround for MWCW 8.3+/EDG < 303, leads to ambiguity on Digital Mars +template< + typename F, typename Tag1, typename Tag2 + > +struct lambda< + lambda< F,Tag1 > + , Tag2 + > +{ + typedef lambda< F,Tag2 > l1; + typedef lambda< Tag1,Tag2 > l2; + + typedef typename l1::is_le is_le; + typedef aux::le_result2 le_result_; + typedef typename le_result_::result_ result_; + typedef typename le_result_::type type; +}; + +#endif + +# undef AUX778076_ARITY_PARAM +# undef AUX778076_BIND_N_PARAMS +# undef AUX778076_BIND_PARAMS +# undef AUX778076_LAMBDA_PARAMS + +#if !defined(BOOST_MPL_CFG_EXTENDED_TEMPLATE_PARAMETERS_MATCHING) +BOOST_MPL_AUX_NA_SPEC(2, lambda) +#else +BOOST_MPL_AUX_NA_SPEC2(2, 3, lambda) +#endif + +}} + +#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS +#endif // BOOST_MPL_AUX_FULL_LAMBDA_HPP_INCLUDED + +///// iteration, depth == 1 + +// For gcc 4.4 compatability, we must include the +// BOOST_PP_ITERATION_DEPTH test inside an #else clause. +#else // BOOST_PP_IS_ITERATING +#if BOOST_PP_ITERATION_DEPTH() == 1 +#define i_ BOOST_PP_FRAME_ITERATION(1) + +#if i_ > 0 + +namespace aux { + +# define AUX778076_RESULT(unused, i_, T) \ + BOOST_PP_COMMA_IF(i_) \ + typename BOOST_PP_CAT(T, BOOST_PP_INC(i_))::result_ \ + /**/ + +# define AUX778076_TYPE(unused, i_, T) \ + BOOST_PP_COMMA_IF(i_) \ + typename BOOST_PP_CAT(T, BOOST_PP_INC(i_))::type \ + /**/ + +template< + typename IsLE, typename Tag + , template< AUX778076_LAMBDA_PARAMS(i_, typename P) > class F + , AUX778076_LAMBDA_PARAMS(i_, typename L) + > +struct BOOST_PP_CAT(le_result,i_) +{ + typedef F< + BOOST_MPL_PP_REPEAT(i_, AUX778076_TYPE, L) + > result_; + + typedef result_ type; +}; + +template< + typename Tag + , template< AUX778076_LAMBDA_PARAMS(i_, typename P) > class F + , AUX778076_LAMBDA_PARAMS(i_, typename L) + > +struct BOOST_PP_CAT(le_result,i_)< true_,Tag,F,AUX778076_LAMBDA_PARAMS(i_, L) > +{ + typedef BOOST_PP_CAT(bind,i_)< + BOOST_PP_CAT(quote,i_) + , BOOST_MPL_PP_REPEAT(i_, AUX778076_RESULT, L) + > result_; + + typedef mpl::protect type; +}; + +# undef AUX778076_TYPE +# undef AUX778076_RESULT + +} // namespace aux + + +# define AUX778076_LAMBDA_TYPEDEF(unused, i_, T) \ + typedef lambda< BOOST_PP_CAT(T, BOOST_PP_INC(i_)), Tag > \ + BOOST_PP_CAT(l,BOOST_PP_INC(i_)); \ +/**/ + +# define AUX778076_IS_LE_TYPEDEF(unused, i_, unused2) \ + typedef typename BOOST_PP_CAT(l,BOOST_PP_INC(i_))::is_le \ + BOOST_PP_CAT(is_le,BOOST_PP_INC(i_)); \ +/**/ + +# define AUX778076_IS_LAMBDA_EXPR(unused, i_, unused2) \ + BOOST_PP_COMMA_IF(i_) \ + BOOST_PP_CAT(is_le,BOOST_PP_INC(i_))::value \ +/**/ + +template< + template< AUX778076_LAMBDA_PARAMS(i_, typename P) > class F + , AUX778076_LAMBDA_PARAMS(i_, typename T) + , typename Tag + > +struct lambda< + F + , Tag + AUX778076_ARITY_PARAM(int_) + > +{ + BOOST_MPL_PP_REPEAT(i_, AUX778076_LAMBDA_TYPEDEF, T) + BOOST_MPL_PP_REPEAT(i_, AUX778076_IS_LE_TYPEDEF, unused) + + typedef typename aux::lambda_or< + BOOST_MPL_PP_REPEAT(i_, AUX778076_IS_LAMBDA_EXPR, unused) + >::type is_le; + + typedef aux::BOOST_PP_CAT(le_result,i_)< + is_le, Tag, F, AUX778076_LAMBDA_PARAMS(i_, l) + > le_result_; + + typedef typename le_result_::result_ result_; + typedef typename le_result_::type type; +}; + + +# undef AUX778076_IS_LAMBDA_EXPR +# undef AUX778076_IS_LE_TYPEDEF +# undef AUX778076_LAMBDA_TYPEDEF + +#endif // i_ > 0 + +template< + typename F AUX778076_BIND_N_PARAMS(i_, typename T) + , typename Tag + > +struct lambda< + BOOST_PP_CAT(bind,i_) + , Tag + AUX778076_ARITY_PARAM(int_) + > +{ + typedef false_ is_le; + typedef BOOST_PP_CAT(bind,i_)< + F + AUX778076_BIND_N_PARAMS(i_, T) + > result_; + + typedef result_ type; +}; + +#undef i_ +#endif // BOOST_PP_ITERATION_DEPTH() +#endif // BOOST_PP_IS_ITERATING diff --git a/realsense-file/3rd_party/boost/boost/mpl/aux_/has_apply.hpp b/realsense-file/3rd_party/boost/boost/mpl/aux_/has_apply.hpp new file mode 100644 index 0000000000..fe224bd004 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/aux_/has_apply.hpp @@ -0,0 +1,32 @@ + +#ifndef BOOST_MPL_AUX_HAS_APPLY_HPP_INCLUDED +#define BOOST_MPL_AUX_HAS_APPLY_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Id$ +// $Date$ +// $Revision$ + +#include +#include + +namespace boost { namespace mpl { namespace aux { +#if !defined(BOOST_MPL_CFG_NO_HAS_APPLY) +BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(has_apply, apply, false) +#else +template< typename T, typename fallback_ = false_ > +struct has_apply + : fallback_ +{ +}; +#endif +}}} + +#endif // BOOST_MPL_AUX_HAS_APPLY_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/mpl/aux_/has_type.hpp b/realsense-file/3rd_party/boost/boost/mpl/aux_/has_type.hpp new file mode 100644 index 0000000000..bf3b77d413 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/aux_/has_type.hpp @@ -0,0 +1,23 @@ + +#ifndef BOOST_MPL_AUX_HAS_TYPE_HPP_INCLUDED +#define BOOST_MPL_AUX_HAS_TYPE_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2002-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Id$ +// $Date$ +// $Revision$ + +#include + +namespace boost { namespace mpl { namespace aux { +BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(has_type, type, true) +}}} + +#endif // BOOST_MPL_AUX_HAS_TYPE_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/mpl/aux_/include_preprocessed.hpp b/realsense-file/3rd_party/boost/boost/mpl/aux_/include_preprocessed.hpp new file mode 100644 index 0000000000..661537d37a --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/aux_/include_preprocessed.hpp @@ -0,0 +1,42 @@ + +// NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION + +// Copyright Aleksey Gurtovoy 2000-2006 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Id$ +// $Date$ +// $Revision$ + +#include +#include +#include +#include +#include + +#if !defined(BOOST_NEEDS_TOKEN_PASTING_OP_FOR_TOKENS_JUXTAPOSING) +# define AUX778076_PREPROCESSED_HEADER \ + BOOST_MPL_CFG_COMPILER_DIR/BOOST_MPL_PREPROCESSED_HEADER \ +/**/ +#else +# define AUX778076_PREPROCESSED_HEADER \ + BOOST_PP_CAT(BOOST_MPL_CFG_COMPILER_DIR,/)##BOOST_MPL_PREPROCESSED_HEADER \ +/**/ +#endif + +#if BOOST_WORKAROUND(__IBMCPP__, BOOST_TESTED_AT(700)) +# define AUX778076_INCLUDE_STRING BOOST_PP_STRINGIZE(boost/mpl/aux_/preprocessed/AUX778076_PREPROCESSED_HEADER) +# include AUX778076_INCLUDE_STRING +# undef AUX778076_INCLUDE_STRING +#else +# include BOOST_PP_STRINGIZE(boost/mpl/aux_/preprocessed/AUX778076_PREPROCESSED_HEADER) +#endif + +# undef AUX778076_PREPROCESSED_HEADER + +#undef BOOST_MPL_PREPROCESSED_HEADER diff --git a/realsense-file/3rd_party/boost/boost/mpl/aux_/integral_wrapper.hpp b/realsense-file/3rd_party/boost/boost/mpl/aux_/integral_wrapper.hpp new file mode 100644 index 0000000000..d00beee52e --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/aux_/integral_wrapper.hpp @@ -0,0 +1,93 @@ + +// Copyright Aleksey Gurtovoy 2000-2006 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Id$ +// $Date$ +// $Revision$ + +// NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION! + +#include "../integral_c_tag.hpp" +#include "static_cast.hpp" +#include "nttp_decl.hpp" +#include "config/static_constant.hpp" +#include "config/workaround.hpp" + +#include "boost/preprocessor/cat.hpp" + +#if !defined(AUX_WRAPPER_NAME) +# define AUX_WRAPPER_NAME BOOST_PP_CAT(AUX_WRAPPER_VALUE_TYPE,_) +#endif + +#if !defined(AUX_WRAPPER_PARAMS) +# define AUX_WRAPPER_PARAMS(N) BOOST_MPL_AUX_NTTP_DECL(AUX_WRAPPER_VALUE_TYPE, N) +#endif + +#if !defined(AUX_WRAPPER_INST) +# if BOOST_WORKAROUND(__MWERKS__, <= 0x2407) +# define AUX_WRAPPER_INST(value) AUX_WRAPPER_NAME< value > +# else +# define AUX_WRAPPER_INST(value) BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::AUX_WRAPPER_NAME< value > +# endif +#endif + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN + +template< AUX_WRAPPER_PARAMS(N) > +struct AUX_WRAPPER_NAME +{ + BOOST_STATIC_CONSTANT(AUX_WRAPPER_VALUE_TYPE, value = N); +// agurt, 08/mar/03: SGI MIPSpro C++ workaround, have to #ifdef because some +// other compilers (e.g. MSVC) are not particulary happy about it +#if BOOST_WORKAROUND(__EDG_VERSION__, <= 238) + typedef struct AUX_WRAPPER_NAME type; +#else + typedef AUX_WRAPPER_NAME type; +#endif + typedef AUX_WRAPPER_VALUE_TYPE value_type; + typedef integral_c_tag tag; + +// have to #ifdef here: some compilers don't like the 'N + 1' form (MSVC), +// while some other don't like 'value + 1' (Borland), and some don't like +// either +#if BOOST_WORKAROUND(__EDG_VERSION__, <= 243) + private: + BOOST_STATIC_CONSTANT(AUX_WRAPPER_VALUE_TYPE, next_value = BOOST_MPL_AUX_STATIC_CAST(AUX_WRAPPER_VALUE_TYPE, (N + 1))); + BOOST_STATIC_CONSTANT(AUX_WRAPPER_VALUE_TYPE, prior_value = BOOST_MPL_AUX_STATIC_CAST(AUX_WRAPPER_VALUE_TYPE, (N - 1))); + public: + typedef AUX_WRAPPER_INST(next_value) next; + typedef AUX_WRAPPER_INST(prior_value) prior; +#elif BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x561)) \ + || BOOST_WORKAROUND(__IBMCPP__, BOOST_TESTED_AT(502)) \ + || (BOOST_WORKAROUND(__HP_aCC, <= 53800) && (BOOST_WORKAROUND(__hpxstd98, != 1))) + typedef AUX_WRAPPER_INST( BOOST_MPL_AUX_STATIC_CAST(AUX_WRAPPER_VALUE_TYPE, (N + 1)) ) next; + typedef AUX_WRAPPER_INST( BOOST_MPL_AUX_STATIC_CAST(AUX_WRAPPER_VALUE_TYPE, (N - 1)) ) prior; +#else + typedef AUX_WRAPPER_INST( BOOST_MPL_AUX_STATIC_CAST(AUX_WRAPPER_VALUE_TYPE, (value + 1)) ) next; + typedef AUX_WRAPPER_INST( BOOST_MPL_AUX_STATIC_CAST(AUX_WRAPPER_VALUE_TYPE, (value - 1)) ) prior; +#endif + + // enables uniform function call syntax for families of overloaded + // functions that return objects of both arithmetic ('int', 'long', + // 'double', etc.) and wrapped integral types (for an example, see + // "mpl/example/power.cpp") + BOOST_CONSTEXPR operator AUX_WRAPPER_VALUE_TYPE() const { return static_cast(this->value); } +}; + +#if !defined(BOOST_NO_INCLASS_MEMBER_INITIALIZATION) +template< AUX_WRAPPER_PARAMS(N) > +AUX_WRAPPER_VALUE_TYPE const AUX_WRAPPER_INST(N)::value; +#endif + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE + +#undef AUX_WRAPPER_NAME +#undef AUX_WRAPPER_PARAMS +#undef AUX_WRAPPER_INST +#undef AUX_WRAPPER_VALUE_TYPE diff --git a/realsense-file/3rd_party/boost/boost/mpl/aux_/lambda_arity_param.hpp b/realsense-file/3rd_party/boost/boost/mpl/aux_/lambda_arity_param.hpp new file mode 100644 index 0000000000..3c308bbf8f --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/aux_/lambda_arity_param.hpp @@ -0,0 +1,25 @@ + +#ifndef BOOST_MPL_AUX_LAMBDA_ARITY_PARAM_HPP_INCLUDED +#define BOOST_MPL_AUX_LAMBDA_ARITY_PARAM_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Id$ +// $Date$ +// $Revision$ + +#include + +#if !defined(BOOST_MPL_CFG_EXTENDED_TEMPLATE_PARAMETERS_MATCHING) +# define BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(param) +#else +# define BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(param) , param +#endif + +#endif // BOOST_MPL_AUX_LAMBDA_ARITY_PARAM_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/mpl/aux_/lambda_support.hpp b/realsense-file/3rd_party/boost/boost/mpl/aux_/lambda_support.hpp new file mode 100644 index 0000000000..8b7610f2a2 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/aux_/lambda_support.hpp @@ -0,0 +1,169 @@ + +#ifndef BOOST_MPL_AUX_LAMBDA_SUPPORT_HPP_INCLUDED +#define BOOST_MPL_AUX_LAMBDA_SUPPORT_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Id$ +// $Date$ +// $Revision$ + +#include + +#if !defined(BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT) + +# define BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(i, name, params) /**/ +# define BOOST_MPL_AUX_LAMBDA_SUPPORT(i,name,params) /**/ + +#else + +# include +# include +# include +# include +# include +# include +# include + +# include +# include +# include +# include + +# define BOOST_MPL_AUX_LAMBDA_SUPPORT_ARG_TYPEDEF_FUNC(R,typedef_,i,param) \ + typedef_ param BOOST_PP_CAT(arg,BOOST_PP_INC(i)); \ + /**/ + +// agurt, 07/mar/03: restore an old revision for the sake of SGI MIPSpro C++ +#if BOOST_WORKAROUND(__EDG_VERSION__, <= 238) + +# define BOOST_MPL_AUX_LAMBDA_SUPPORT(i, name, params) \ + typedef BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::int_ arity; \ + BOOST_PP_LIST_FOR_EACH_I_R( \ + 1 \ + , BOOST_MPL_AUX_LAMBDA_SUPPORT_ARG_TYPEDEF_FUNC \ + , typedef \ + , BOOST_PP_TUPLE_TO_LIST(i,params) \ + ) \ + struct rebind \ + { \ + template< BOOST_MPL_PP_PARAMS(i,typename U) > struct apply \ + : name< BOOST_MPL_PP_PARAMS(i,U) > \ + { \ + }; \ + }; \ + /**/ + +# define BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(i, name, params) \ + BOOST_MPL_AUX_LAMBDA_SUPPORT(i, name, params) \ + /**/ + +#elif BOOST_WORKAROUND(__EDG_VERSION__, <= 244) && !defined(BOOST_INTEL_CXX_VERSION) +// agurt, 18/jan/03: old EDG-based compilers actually enforce 11.4 para 9 +// (in strict mode), so we have to provide an alternative to the +// MSVC-optimized implementation + +# define BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(i, name, params) \ + typedef BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::int_ arity; \ + BOOST_PP_LIST_FOR_EACH_I_R( \ + 1 \ + , BOOST_MPL_AUX_LAMBDA_SUPPORT_ARG_TYPEDEF_FUNC \ + , typedef \ + , BOOST_PP_TUPLE_TO_LIST(i,params) \ + ) \ + struct rebind; \ +/**/ + +# define BOOST_MPL_AUX_LAMBDA_SUPPORT(i, name, params) \ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(i, name, params) \ +}; \ +template< BOOST_MPL_PP_PARAMS(i,typename T) > \ +struct name::rebind \ +{ \ + template< BOOST_MPL_PP_PARAMS(i,typename U) > struct apply \ + : name< BOOST_MPL_PP_PARAMS(i,U) > \ + { \ + }; \ +/**/ + +#else // __EDG_VERSION__ + +namespace boost { namespace mpl { namespace aux { +template< typename T > struct has_rebind_tag; +}}} + +# define BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(i, name, params) \ + typedef BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::int_ arity; \ + BOOST_PP_LIST_FOR_EACH_I_R( \ + 1 \ + , BOOST_MPL_AUX_LAMBDA_SUPPORT_ARG_TYPEDEF_FUNC \ + , typedef \ + , BOOST_PP_TUPLE_TO_LIST(i,params) \ + ) \ + friend class BOOST_PP_CAT(name,_rebind); \ + typedef BOOST_PP_CAT(name,_rebind) rebind; \ +/**/ + +#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x610)) +# define BOOST_MPL_AUX_LAMBDA_SUPPORT_HAS_REBIND(i, name, params) \ +template< BOOST_MPL_PP_PARAMS(i,typename T) > \ +::boost::mpl::aux::yes_tag operator|( \ + ::boost::mpl::aux::has_rebind_tag \ + , name* \ + ); \ +::boost::mpl::aux::no_tag operator|( \ + ::boost::mpl::aux::has_rebind_tag \ + , name< BOOST_MPL_PP_ENUM(i,::boost::mpl::na) >* \ + ); \ +/**/ +#elif !BOOST_WORKAROUND(BOOST_MSVC, < 1300) +# define BOOST_MPL_AUX_LAMBDA_SUPPORT_HAS_REBIND(i, name, params) \ +template< BOOST_MPL_PP_PARAMS(i,typename T) > \ +::boost::mpl::aux::yes_tag operator|( \ + ::boost::mpl::aux::has_rebind_tag \ + , ::boost::mpl::aux::has_rebind_tag< name >* \ + ); \ +/**/ +#else +# define BOOST_MPL_AUX_LAMBDA_SUPPORT_HAS_REBIND(i, name, params) /**/ +#endif + +# if !defined(__BORLANDC__) +# define BOOST_MPL_AUX_LAMBDA_SUPPORT(i, name, params) \ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(i, name, params) \ +}; \ +BOOST_MPL_AUX_LAMBDA_SUPPORT_HAS_REBIND(i, name, params) \ +class BOOST_PP_CAT(name,_rebind) \ +{ \ + public: \ + template< BOOST_MPL_PP_PARAMS(i,typename U) > struct apply \ + : name< BOOST_MPL_PP_PARAMS(i,U) > \ + { \ + }; \ +/**/ +# else +# define BOOST_MPL_AUX_LAMBDA_SUPPORT(i, name, params) \ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(i, name, params) \ +}; \ +BOOST_MPL_AUX_LAMBDA_SUPPORT_HAS_REBIND(i, name, params) \ +class BOOST_PP_CAT(name,_rebind) \ +{ \ + public: \ + template< BOOST_MPL_PP_PARAMS(i,typename U) > struct apply \ + { \ + typedef typename name< BOOST_MPL_PP_PARAMS(i,U) >::type type; \ + }; \ +/**/ +# endif // __BORLANDC__ + +#endif // __EDG_VERSION__ + +#endif // BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT + +#endif // BOOST_MPL_AUX_LAMBDA_SUPPORT_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/mpl/aux_/msvc_never_true.hpp b/realsense-file/3rd_party/boost/boost/mpl/aux_/msvc_never_true.hpp new file mode 100644 index 0000000000..bd39843089 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/aux_/msvc_never_true.hpp @@ -0,0 +1,34 @@ + +#ifndef BOOST_MPL_AUX_MSVC_NEVER_TRUE_HPP_INCLUDED +#define BOOST_MPL_AUX_MSVC_NEVER_TRUE_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Id$ +// $Date$ +// $Revision$ + +#include +#include + +#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) + +namespace boost { namespace mpl { namespace aux { + +template< typename T > +struct msvc_never_true +{ + enum { value = false }; +}; + +}}} + +#endif // BOOST_MSVC + +#endif // BOOST_MPL_AUX_MSVC_NEVER_TRUE_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/mpl/aux_/na.hpp b/realsense-file/3rd_party/boost/boost/mpl/aux_/na.hpp new file mode 100644 index 0000000000..0722ff491f --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/aux_/na.hpp @@ -0,0 +1,95 @@ + +#ifndef BOOST_MPL_AUX_NA_HPP_INCLUDED +#define BOOST_MPL_AUX_NA_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Id$ +// $Date$ +// $Revision$ + +#include +#include +#include +#include + +namespace boost { namespace mpl { + +template< typename T > +struct is_na + : false_ +{ +#if BOOST_WORKAROUND(BOOST_MSVC, < 1300) + using false_::value; +#endif +}; + +template<> +struct is_na + : true_ +{ +#if BOOST_WORKAROUND(BOOST_MSVC, < 1300) + using true_::value; +#endif +}; + +template< typename T > +struct is_not_na + : true_ +{ +#if BOOST_WORKAROUND(BOOST_MSVC, < 1300) + using true_::value; +#endif +}; + +template<> +struct is_not_na + : false_ +{ +#if BOOST_WORKAROUND(BOOST_MSVC, < 1300) + using false_::value; +#endif +}; + +#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) +template< typename T, typename U > struct if_na +{ + typedef T type; +}; + +template< typename U > struct if_na +{ + typedef U type; +}; +#else +template< typename T > struct if_na_impl +{ + template< typename U > struct apply + { + typedef T type; + }; +}; + +template<> struct if_na_impl +{ + template< typename U > struct apply + { + typedef U type; + }; +}; + +template< typename T, typename U > struct if_na + : if_na_impl::template apply +{ +}; +#endif + +}} + +#endif // BOOST_MPL_AUX_NA_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/mpl/aux_/na_assert.hpp b/realsense-file/3rd_party/boost/boost/mpl/aux_/na_assert.hpp new file mode 100644 index 0000000000..8217368934 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/aux_/na_assert.hpp @@ -0,0 +1,34 @@ + +#ifndef BOOST_MPL_AUX_NA_ASSERT_HPP_INCLUDED +#define BOOST_MPL_AUX_NA_ASSERT_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Id$ +// $Date$ +// $Revision$ + +#include +#include +#include + +#if !BOOST_WORKAROUND(_MSC_FULL_VER, <= 140050601) \ + && !BOOST_WORKAROUND(__EDG_VERSION__, <= 243) +# include +# define BOOST_MPL_AUX_ASSERT_NOT_NA(x) \ + BOOST_MPL_ASSERT_NOT((boost::mpl::is_na)) \ +/**/ +#else +# include +# define BOOST_MPL_AUX_ASSERT_NOT_NA(x) \ + BOOST_STATIC_ASSERT(!boost::mpl::is_na::value) \ +/**/ +#endif + +#endif // BOOST_MPL_AUX_NA_ASSERT_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/mpl/aux_/na_fwd.hpp b/realsense-file/3rd_party/boost/boost/mpl/aux_/na_fwd.hpp new file mode 100644 index 0000000000..efc11144f9 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/aux_/na_fwd.hpp @@ -0,0 +1,31 @@ + +#ifndef BOOST_MPL_AUX_NA_FWD_HPP_INCLUDED +#define BOOST_MPL_AUX_NA_FWD_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Id$ +// $Date$ +// $Revision$ + +#include + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN + +// n.a. == not available +struct na +{ + typedef na type; + enum { value = 0 }; +}; + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE +BOOST_MPL_AUX_ADL_BARRIER_DECL(na) + +#endif // BOOST_MPL_AUX_NA_FWD_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/mpl/aux_/na_spec.hpp b/realsense-file/3rd_party/boost/boost/mpl/aux_/na_spec.hpp new file mode 100644 index 0000000000..8a77654cc5 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/aux_/na_spec.hpp @@ -0,0 +1,175 @@ + +#ifndef BOOST_MPL_AUX_NA_SPEC_HPP_INCLUDED +#define BOOST_MPL_AUX_NA_SPEC_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Id$ +// $Date$ +// $Revision$ + +#if !defined(BOOST_MPL_PREPROCESSING_MODE) +# include +# include +# include +# include +# include +# include +#endif + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +#define BOOST_MPL_AUX_NA_PARAMS(i) \ + BOOST_MPL_PP_ENUM(i, na) \ +/**/ + +#if defined(BOOST_MPL_CFG_BROKEN_DEFAULT_PARAMETERS_IN_NESTED_TEMPLATES) +# define BOOST_MPL_AUX_NA_SPEC_ARITY(i, name) \ +namespace aux { \ +template< BOOST_MPL_AUX_NTTP_DECL(int, N) > \ +struct arity< \ + name< BOOST_MPL_AUX_NA_PARAMS(i) > \ + , N \ + > \ + : int_< BOOST_MPL_LIMIT_METAFUNCTION_ARITY > \ +{ \ +}; \ +} \ +/**/ +#else +# define BOOST_MPL_AUX_NA_SPEC_ARITY(i, name) /**/ +#endif + +#define BOOST_MPL_AUX_NA_SPEC_MAIN(i, name) \ +template<> \ +struct name< BOOST_MPL_AUX_NA_PARAMS(i) > \ +{ \ + template< \ + BOOST_MPL_PP_PARAMS(i, typename T) \ + BOOST_MPL_PP_NESTED_DEF_PARAMS_TAIL(i, typename T, na) \ + > \ + struct apply \ + : name< BOOST_MPL_PP_PARAMS(i, T) > \ + { \ + }; \ +}; \ +/**/ + +#if defined(BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT) +# define BOOST_MPL_AUX_NA_SPEC_LAMBDA(i, name) \ +template<> \ +struct lambda< \ + name< BOOST_MPL_AUX_NA_PARAMS(i) > \ + , void_ \ + , true_ \ + > \ +{ \ + typedef false_ is_le; \ + typedef name< BOOST_MPL_AUX_NA_PARAMS(i) > type; \ +}; \ +template<> \ +struct lambda< \ + name< BOOST_MPL_AUX_NA_PARAMS(i) > \ + , void_ \ + , false_ \ + > \ +{ \ + typedef false_ is_le; \ + typedef name< BOOST_MPL_AUX_NA_PARAMS(i) > type; \ +}; \ +/**/ +#else +# define BOOST_MPL_AUX_NA_SPEC_LAMBDA(i, name) \ +template< typename Tag > \ +struct lambda< \ + name< BOOST_MPL_AUX_NA_PARAMS(i) > \ + , Tag \ + BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(int_<-1>) \ + > \ +{ \ + typedef false_ is_le; \ + typedef name< BOOST_MPL_AUX_NA_PARAMS(i) > result_; \ + typedef name< BOOST_MPL_AUX_NA_PARAMS(i) > type; \ +}; \ +/**/ +#endif + +#if defined(BOOST_MPL_CFG_EXTENDED_TEMPLATE_PARAMETERS_MATCHING) \ + || defined(BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT) \ + && defined(BOOST_MPL_CFG_BROKEN_OVERLOAD_RESOLUTION) +# define BOOST_MPL_AUX_NA_SPEC_TEMPLATE_ARITY(i, j, name) \ +namespace aux { \ +template< BOOST_MPL_PP_PARAMS(j, typename T) > \ +struct template_arity< \ + name< BOOST_MPL_PP_PARAMS(j, T) > \ + > \ + : int_ \ +{ \ +}; \ +\ +template<> \ +struct template_arity< \ + name< BOOST_MPL_PP_ENUM(i, na) > \ + > \ + : int_<-1> \ +{ \ +}; \ +} \ +/**/ +#else +# define BOOST_MPL_AUX_NA_SPEC_TEMPLATE_ARITY(i, j, name) /**/ +#endif + +#if defined(BOOST_MPL_CFG_MSVC_ETI_BUG) +# define BOOST_MPL_AUX_NA_SPEC_ETI(i, name) \ +template<> \ +struct name< BOOST_MPL_PP_ENUM(i, int) > \ +{ \ + typedef int type; \ + enum { value = 0 }; \ +}; \ +/**/ +#else +# define BOOST_MPL_AUX_NA_SPEC_ETI(i, name) /**/ +#endif + +#define BOOST_MPL_AUX_NA_PARAM(param) param = na + +#define BOOST_MPL_AUX_NA_SPEC_NO_ETI(i, name) \ +BOOST_MPL_AUX_NA_SPEC_MAIN(i, name) \ +BOOST_MPL_AUX_NA_SPEC_LAMBDA(i, name) \ +BOOST_MPL_AUX_NA_SPEC_ARITY(i, name) \ +BOOST_MPL_AUX_NA_SPEC_TEMPLATE_ARITY(i, i, name) \ +/**/ + +#define BOOST_MPL_AUX_NA_SPEC(i, name) \ +BOOST_MPL_AUX_NA_SPEC_NO_ETI(i, name) \ +BOOST_MPL_AUX_NA_SPEC_ETI(i, name) \ +/**/ + +#define BOOST_MPL_AUX_NA_SPEC2(i, j, name) \ +BOOST_MPL_AUX_NA_SPEC_MAIN(i, name) \ +BOOST_MPL_AUX_NA_SPEC_ETI(i, name) \ +BOOST_MPL_AUX_NA_SPEC_LAMBDA(i, name) \ +BOOST_MPL_AUX_NA_SPEC_ARITY(i, name) \ +BOOST_MPL_AUX_NA_SPEC_TEMPLATE_ARITY(i, j, name) \ +/**/ + + +#endif // BOOST_MPL_AUX_NA_SPEC_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/mpl/aux_/nested_type_wknd.hpp b/realsense-file/3rd_party/boost/boost/mpl/aux_/nested_type_wknd.hpp new file mode 100644 index 0000000000..00a99a80f0 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/aux_/nested_type_wknd.hpp @@ -0,0 +1,48 @@ + +#ifndef BOOST_MPL_AUX_NESTED_TYPE_WKND_HPP_INCLUDED +#define BOOST_MPL_AUX_NESTED_TYPE_WKND_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Id$ +// $Date$ +// $Revision$ + +#include +#include + +#if BOOST_WORKAROUND(BOOST_MPL_CFG_GCC, BOOST_TESTED_AT(0x0302)) \ + || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x561)) \ + || BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x530)) \ + || BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840)) + +namespace boost { namespace mpl { namespace aux { +template< typename T > struct nested_type_wknd + : T::type +{ +}; +}}} + +#if BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840)) +# define BOOST_MPL_AUX_NESTED_TYPE_WKND(T) \ + aux::nested_type_wknd \ +/**/ +#else +# define BOOST_MPL_AUX_NESTED_TYPE_WKND(T) \ + ::boost::mpl::aux::nested_type_wknd \ +/**/ +#endif + +#else // !BOOST_MPL_CFG_GCC et al. + +# define BOOST_MPL_AUX_NESTED_TYPE_WKND(T) T::type + +#endif + +#endif // BOOST_MPL_AUX_NESTED_TYPE_WKND_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/mpl/aux_/nttp_decl.hpp b/realsense-file/3rd_party/boost/boost/mpl/aux_/nttp_decl.hpp new file mode 100644 index 0000000000..8b61a569c2 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/aux_/nttp_decl.hpp @@ -0,0 +1,35 @@ + +#ifndef BOOST_MPL_AUX_NTTP_DECL_HPP_INCLUDED +#define BOOST_MPL_AUX_NTTP_DECL_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Id$ +// $Date$ +// $Revision$ + +#include "config/nttp.hpp" + +#if defined(BOOST_MPL_CFG_NTTP_BUG) + +typedef bool _mpl_nttp_bool; +typedef int _mpl_nttp_int; +typedef unsigned _mpl_nttp_unsigned; +typedef long _mpl_nttp_long; + +# include +# define BOOST_MPL_AUX_NTTP_DECL(T, x) BOOST_PP_CAT(_mpl_nttp_,T) x /**/ + +#else + +# define BOOST_MPL_AUX_NTTP_DECL(T, x) T x /**/ + +#endif + +#endif // BOOST_MPL_AUX_NTTP_DECL_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/mpl/aux_/preprocessed/plain/and.hpp b/realsense-file/3rd_party/boost/boost/mpl/aux_/preprocessed/plain/and.hpp new file mode 100644 index 0000000000..aae95c54f4 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/aux_/preprocessed/plain/and.hpp @@ -0,0 +1,64 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/and.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { + +template< bool C_, typename T1, typename T2, typename T3, typename T4 > +struct and_impl + : false_ +{ +}; + +template< typename T1, typename T2, typename T3, typename T4 > +struct and_impl< true,T1,T2,T3,T4 > + : and_impl< + BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value + , T2, T3, T4 + , true_ + > +{ +}; + +template<> +struct and_impl< + true + , true_, true_, true_, true_ + > + : true_ +{ +}; + +} // namespace aux + +template< + typename BOOST_MPL_AUX_NA_PARAM(T1) + , typename BOOST_MPL_AUX_NA_PARAM(T2) + , typename T3 = true_, typename T4 = true_, typename T5 = true_ + > +struct and_ + + : aux::and_impl< + BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value + , T2, T3, T4, T5 + > + +{ +}; + +BOOST_MPL_AUX_NA_SPEC2( + 2 + , 5 + , and_ + ) + +}} diff --git a/realsense-file/3rd_party/boost/boost/mpl/aux_/preprocessed/plain/apply.hpp b/realsense-file/3rd_party/boost/boost/mpl/aux_/preprocessed/plain/apply.hpp new file mode 100644 index 0000000000..d18329c1df --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/aux_/preprocessed/plain/apply.hpp @@ -0,0 +1,139 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/apply.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename F + > +struct apply0 + + : apply_wrap0< + typename lambda::type + + > +{ +}; + +template< + typename F + > +struct apply< F,na,na,na,na,na > + : apply0 +{ +}; + +template< + typename F, typename T1 + > +struct apply1 + + : apply_wrap1< + typename lambda::type + , T1 + > +{ +}; + +template< + typename F, typename T1 + > +struct apply< F,T1,na,na,na,na > + : apply1< F,T1 > +{ +}; + +template< + typename F, typename T1, typename T2 + > +struct apply2 + + : apply_wrap2< + typename lambda::type + , T1, T2 + > +{ +}; + +template< + typename F, typename T1, typename T2 + > +struct apply< F,T1,T2,na,na,na > + : apply2< F,T1,T2 > +{ +}; + +template< + typename F, typename T1, typename T2, typename T3 + > +struct apply3 + + : apply_wrap3< + typename lambda::type + , T1, T2, T3 + > +{ +}; + +template< + typename F, typename T1, typename T2, typename T3 + > +struct apply< F,T1,T2,T3,na,na > + : apply3< F,T1,T2,T3 > +{ +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + > +struct apply4 + + : apply_wrap4< + typename lambda::type + , T1, T2, T3, T4 + > +{ +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + > +struct apply< F,T1,T2,T3,T4,na > + : apply4< F,T1,T2,T3,T4 > +{ +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct apply5 + + : apply_wrap5< + typename lambda::type + , T1, T2, T3, T4, T5 + > +{ +}; + +/// primary template (not a specialization!) + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct apply + : apply5< F,T1,T2,T3,T4,T5 > +{ +}; + +}} + diff --git a/realsense-file/3rd_party/boost/boost/mpl/aux_/preprocessed/plain/apply_fwd.hpp b/realsense-file/3rd_party/boost/boost/mpl/aux_/preprocessed/plain/apply_fwd.hpp new file mode 100644 index 0000000000..b1c5573624 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/aux_/preprocessed/plain/apply_fwd.hpp @@ -0,0 +1,52 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/apply_fwd.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename F, typename T1 = na, typename T2 = na, typename T3 = na + , typename T4 = na, typename T5 = na + > +struct apply; + +template< + typename F + > +struct apply0; + +template< + typename F, typename T1 + > +struct apply1; + +template< + typename F, typename T1, typename T2 + > +struct apply2; + +template< + typename F, typename T1, typename T2, typename T3 + > +struct apply3; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + > +struct apply4; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct apply5; + +}} + diff --git a/realsense-file/3rd_party/boost/boost/mpl/aux_/preprocessed/plain/apply_wrap.hpp b/realsense-file/3rd_party/boost/boost/mpl/aux_/preprocessed/plain/apply_wrap.hpp new file mode 100644 index 0000000000..e6de04768c --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/aux_/preprocessed/plain/apply_wrap.hpp @@ -0,0 +1,84 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/apply_wrap.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename F + + , typename has_apply_ = typename aux::has_apply::type + + > +struct apply_wrap0 + + : F::template apply< > +{ +}; + +template< typename F > +struct apply_wrap0< F,true_ > + : F::apply +{ +}; + +template< + typename F, typename T1 + + > +struct apply_wrap1 + + : F::template apply +{ +}; + +template< + typename F, typename T1, typename T2 + + > +struct apply_wrap2 + + : F::template apply< T1,T2 > +{ +}; + +template< + typename F, typename T1, typename T2, typename T3 + + > +struct apply_wrap3 + + : F::template apply< T1,T2,T3 > +{ +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + + > +struct apply_wrap4 + + : F::template apply< T1,T2,T3,T4 > +{ +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + + > +struct apply_wrap5 + + : F::template apply< T1,T2,T3,T4,T5 > +{ +}; + +}} + diff --git a/realsense-file/3rd_party/boost/boost/mpl/aux_/preprocessed/plain/arg.hpp b/realsense-file/3rd_party/boost/boost/mpl/aux_/preprocessed/plain/arg.hpp new file mode 100644 index 0000000000..a77b8a2e66 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/aux_/preprocessed/plain/arg.hpp @@ -0,0 +1,123 @@ + +// Copyright Peter Dimov 2001-2002 +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/arg.hpp" header +// -- DO NOT modify by hand! + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +template<> struct arg< -1 > +{ + BOOST_STATIC_CONSTANT(int, value = -1); + BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) + BOOST_MPL_AUX_ARG_TYPEDEF(na, type) + + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + typedef U1 type; + BOOST_MPL_AUX_ASSERT_NOT_NA(type); + }; +}; + +template<> struct arg<1> +{ + BOOST_STATIC_CONSTANT(int, value = 1); + typedef arg<2> next; + BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) + BOOST_MPL_AUX_ARG_TYPEDEF(na, type) + + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + typedef U1 type; + BOOST_MPL_AUX_ASSERT_NOT_NA(type); + }; +}; + +template<> struct arg<2> +{ + BOOST_STATIC_CONSTANT(int, value = 2); + typedef arg<3> next; + BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) + BOOST_MPL_AUX_ARG_TYPEDEF(na, type) + + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + typedef U2 type; + BOOST_MPL_AUX_ASSERT_NOT_NA(type); + }; +}; + +template<> struct arg<3> +{ + BOOST_STATIC_CONSTANT(int, value = 3); + typedef arg<4> next; + BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) + BOOST_MPL_AUX_ARG_TYPEDEF(na, type) + + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + typedef U3 type; + BOOST_MPL_AUX_ASSERT_NOT_NA(type); + }; +}; + +template<> struct arg<4> +{ + BOOST_STATIC_CONSTANT(int, value = 4); + typedef arg<5> next; + BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) + BOOST_MPL_AUX_ARG_TYPEDEF(na, type) + + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + typedef U4 type; + BOOST_MPL_AUX_ASSERT_NOT_NA(type); + }; +}; + +template<> struct arg<5> +{ + BOOST_STATIC_CONSTANT(int, value = 5); + typedef arg<6> next; + BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) + BOOST_MPL_AUX_ARG_TYPEDEF(na, type) + + template< + typename U1 = na, typename U2 = na, typename U3 = na + , typename U4 = na, typename U5 = na + > + struct apply + { + typedef U5 type; + BOOST_MPL_AUX_ASSERT_NOT_NA(type); + }; +}; + +BOOST_MPL_AUX_NONTYPE_ARITY_SPEC(1,int, arg) + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE diff --git a/realsense-file/3rd_party/boost/boost/mpl/aux_/preprocessed/plain/bind_fwd.hpp b/realsense-file/3rd_party/boost/boost/mpl/aux_/preprocessed/plain/bind_fwd.hpp new file mode 100644 index 0000000000..e47dd924c9 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/aux_/preprocessed/plain/bind_fwd.hpp @@ -0,0 +1,52 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/bind_fwd.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< + typename F, typename T1 = na, typename T2 = na, typename T3 = na + , typename T4 = na, typename T5 = na + > +struct bind; + +template< + typename F + > +struct bind0; + +template< + typename F, typename T1 + > +struct bind1; + +template< + typename F, typename T1, typename T2 + > +struct bind2; + +template< + typename F, typename T1, typename T2, typename T3 + > +struct bind3; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + > +struct bind4; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + > +struct bind5; + +}} + diff --git a/realsense-file/3rd_party/boost/boost/mpl/aux_/preprocessed/plain/full_lambda.hpp b/realsense-file/3rd_party/boost/boost/mpl/aux_/preprocessed/plain/full_lambda.hpp new file mode 100644 index 0000000000..78cb47c5fb --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/aux_/preprocessed/plain/full_lambda.hpp @@ -0,0 +1,554 @@ + +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/full_lambda.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { + +template< + bool C1 = false, bool C2 = false, bool C3 = false, bool C4 = false + , bool C5 = false + > +struct lambda_or + : true_ +{ +}; + +template<> +struct lambda_or< false,false,false,false,false > + : false_ +{ +}; + +} // namespace aux + +template< + typename T + , typename Tag + + > +struct lambda +{ + typedef false_ is_le; + typedef T result_; + typedef T type; +}; + +template< + typename T + > +struct is_lambda_expression + : lambda::is_le +{ +}; + +template< int N, typename Tag > +struct lambda< arg, Tag > +{ + typedef true_ is_le; + typedef mpl::arg result_; // qualified for the sake of MIPSpro 7.41 + typedef mpl::protect type; +}; + +template< + typename F + , typename Tag + > +struct lambda< + bind0 + , Tag + + > +{ + typedef false_ is_le; + typedef bind0< + F + > result_; + + typedef result_ type; +}; + +namespace aux { + +template< + typename IsLE, typename Tag + , template< typename P1 > class F + , typename L1 + > +struct le_result1 +{ + typedef F< + typename L1::type + > result_; + + typedef result_ type; +}; + +template< + typename Tag + , template< typename P1 > class F + , typename L1 + > +struct le_result1< true_,Tag,F,L1 > +{ + typedef bind1< + quote1< F,Tag > + , typename L1::result_ + > result_; + + typedef mpl::protect type; +}; + +} // namespace aux + +template< + template< typename P1 > class F + , typename T1 + , typename Tag + > +struct lambda< + F + , Tag + + > +{ + typedef lambda< T1,Tag > l1; + typedef typename l1::is_le is_le1; + typedef typename aux::lambda_or< + is_le1::value + >::type is_le; + + typedef aux::le_result1< + is_le, Tag, F, l1 + > le_result_; + + typedef typename le_result_::result_ result_; + typedef typename le_result_::type type; +}; + +template< + typename F, typename T1 + , typename Tag + > +struct lambda< + bind1< F,T1 > + , Tag + + > +{ + typedef false_ is_le; + typedef bind1< + F + , T1 + > result_; + + typedef result_ type; +}; + +namespace aux { + +template< + typename IsLE, typename Tag + , template< typename P1, typename P2 > class F + , typename L1, typename L2 + > +struct le_result2 +{ + typedef F< + typename L1::type, typename L2::type + > result_; + + typedef result_ type; +}; + +template< + typename Tag + , template< typename P1, typename P2 > class F + , typename L1, typename L2 + > +struct le_result2< true_,Tag,F,L1,L2 > +{ + typedef bind2< + quote2< F,Tag > + , typename L1::result_, typename L2::result_ + > result_; + + typedef mpl::protect type; +}; + +} // namespace aux + +template< + template< typename P1, typename P2 > class F + , typename T1, typename T2 + , typename Tag + > +struct lambda< + F< T1,T2 > + , Tag + + > +{ + typedef lambda< T1,Tag > l1; + typedef lambda< T2,Tag > l2; + + typedef typename l1::is_le is_le1; + typedef typename l2::is_le is_le2; + + + typedef typename aux::lambda_or< + is_le1::value, is_le2::value + >::type is_le; + + typedef aux::le_result2< + is_le, Tag, F, l1, l2 + > le_result_; + + typedef typename le_result_::result_ result_; + typedef typename le_result_::type type; +}; + +template< + typename F, typename T1, typename T2 + , typename Tag + > +struct lambda< + bind2< F,T1,T2 > + , Tag + + > +{ + typedef false_ is_le; + typedef bind2< + F + , T1, T2 + > result_; + + typedef result_ type; +}; + +namespace aux { + +template< + typename IsLE, typename Tag + , template< typename P1, typename P2, typename P3 > class F + , typename L1, typename L2, typename L3 + > +struct le_result3 +{ + typedef F< + typename L1::type, typename L2::type, typename L3::type + > result_; + + typedef result_ type; +}; + +template< + typename Tag + , template< typename P1, typename P2, typename P3 > class F + , typename L1, typename L2, typename L3 + > +struct le_result3< true_,Tag,F,L1,L2,L3 > +{ + typedef bind3< + quote3< F,Tag > + , typename L1::result_, typename L2::result_, typename L3::result_ + > result_; + + typedef mpl::protect type; +}; + +} // namespace aux + +template< + template< typename P1, typename P2, typename P3 > class F + , typename T1, typename T2, typename T3 + , typename Tag + > +struct lambda< + F< T1,T2,T3 > + , Tag + + > +{ + typedef lambda< T1,Tag > l1; + typedef lambda< T2,Tag > l2; + typedef lambda< T3,Tag > l3; + + typedef typename l1::is_le is_le1; + typedef typename l2::is_le is_le2; + typedef typename l3::is_le is_le3; + + + typedef typename aux::lambda_or< + is_le1::value, is_le2::value, is_le3::value + >::type is_le; + + typedef aux::le_result3< + is_le, Tag, F, l1, l2, l3 + > le_result_; + + typedef typename le_result_::result_ result_; + typedef typename le_result_::type type; +}; + +template< + typename F, typename T1, typename T2, typename T3 + , typename Tag + > +struct lambda< + bind3< F,T1,T2,T3 > + , Tag + + > +{ + typedef false_ is_le; + typedef bind3< + F + , T1, T2, T3 + > result_; + + typedef result_ type; +}; + +namespace aux { + +template< + typename IsLE, typename Tag + , template< typename P1, typename P2, typename P3, typename P4 > class F + , typename L1, typename L2, typename L3, typename L4 + > +struct le_result4 +{ + typedef F< + typename L1::type, typename L2::type, typename L3::type + , typename L4::type + > result_; + + typedef result_ type; +}; + +template< + typename Tag + , template< typename P1, typename P2, typename P3, typename P4 > class F + , typename L1, typename L2, typename L3, typename L4 + > +struct le_result4< true_,Tag,F,L1,L2,L3,L4 > +{ + typedef bind4< + quote4< F,Tag > + , typename L1::result_, typename L2::result_, typename L3::result_ + , typename L4::result_ + > result_; + + typedef mpl::protect type; +}; + +} // namespace aux + +template< + template< typename P1, typename P2, typename P3, typename P4 > class F + , typename T1, typename T2, typename T3, typename T4 + , typename Tag + > +struct lambda< + F< T1,T2,T3,T4 > + , Tag + + > +{ + typedef lambda< T1,Tag > l1; + typedef lambda< T2,Tag > l2; + typedef lambda< T3,Tag > l3; + typedef lambda< T4,Tag > l4; + + typedef typename l1::is_le is_le1; + typedef typename l2::is_le is_le2; + typedef typename l3::is_le is_le3; + typedef typename l4::is_le is_le4; + + + typedef typename aux::lambda_or< + is_le1::value, is_le2::value, is_le3::value, is_le4::value + >::type is_le; + + typedef aux::le_result4< + is_le, Tag, F, l1, l2, l3, l4 + > le_result_; + + typedef typename le_result_::result_ result_; + typedef typename le_result_::type type; +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename Tag + > +struct lambda< + bind4< F,T1,T2,T3,T4 > + , Tag + + > +{ + typedef false_ is_le; + typedef bind4< + F + , T1, T2, T3, T4 + > result_; + + typedef result_ type; +}; + +namespace aux { + +template< + typename IsLE, typename Tag + , template< typename P1, typename P2, typename P3, typename P4, typename P5 > class F + , typename L1, typename L2, typename L3, typename L4, typename L5 + > +struct le_result5 +{ + typedef F< + typename L1::type, typename L2::type, typename L3::type + , typename L4::type, typename L5::type + > result_; + + typedef result_ type; +}; + +template< + typename Tag + , template< typename P1, typename P2, typename P3, typename P4, typename P5 > class F + , typename L1, typename L2, typename L3, typename L4, typename L5 + > +struct le_result5< true_,Tag,F,L1,L2,L3,L4,L5 > +{ + typedef bind5< + quote5< F,Tag > + , typename L1::result_, typename L2::result_, typename L3::result_ + , typename L4::result_, typename L5::result_ + > result_; + + typedef mpl::protect type; +}; + +} // namespace aux + +template< + template< + typename P1, typename P2, typename P3, typename P4 + , typename P5 + > + class F + , typename T1, typename T2, typename T3, typename T4, typename T5 + , typename Tag + > +struct lambda< + F< T1,T2,T3,T4,T5 > + , Tag + + > +{ + typedef lambda< T1,Tag > l1; + typedef lambda< T2,Tag > l2; + typedef lambda< T3,Tag > l3; + typedef lambda< T4,Tag > l4; + typedef lambda< T5,Tag > l5; + + typedef typename l1::is_le is_le1; + typedef typename l2::is_le is_le2; + typedef typename l3::is_le is_le3; + typedef typename l4::is_le is_le4; + typedef typename l5::is_le is_le5; + + + typedef typename aux::lambda_or< + is_le1::value, is_le2::value, is_le3::value, is_le4::value + , is_le5::value + >::type is_le; + + typedef aux::le_result5< + is_le, Tag, F, l1, l2, l3, l4, l5 + > le_result_; + + typedef typename le_result_::result_ result_; + typedef typename le_result_::type type; +}; + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + , typename Tag + > +struct lambda< + bind5< F,T1,T2,T3,T4,T5 > + , Tag + + > +{ + typedef false_ is_le; + typedef bind5< + F + , T1, T2, T3, T4, T5 + > result_; + + typedef result_ type; +}; + +/// special case for 'protect' +template< typename T, typename Tag > +struct lambda< mpl::protect, Tag > +{ + typedef false_ is_le; + typedef mpl::protect result_; + typedef result_ type; +}; + +/// specializations for the main 'bind' form + +template< + typename F, typename T1, typename T2, typename T3, typename T4 + , typename T5 + , typename Tag + > +struct lambda< + bind< F,T1,T2,T3,T4,T5 > + , Tag + + > +{ + typedef false_ is_le; + typedef bind< F,T1,T2,T3,T4,T5 > result_; + typedef result_ type; +}; + +/// workaround for MWCW 8.3+/EDG < 303, leads to ambiguity on Digital Mars + +template< + typename F, typename Tag1, typename Tag2 + > +struct lambda< + lambda< F,Tag1 > + , Tag2 + > +{ + typedef lambda< F,Tag2 > l1; + typedef lambda< Tag1,Tag2 > l2; + typedef typename l1::is_le is_le; + typedef aux::le_result2 le_result_; + typedef typename le_result_::result_ result_; + typedef typename le_result_::type type; +}; + +BOOST_MPL_AUX_NA_SPEC(2, lambda) + +}} + diff --git a/realsense-file/3rd_party/boost/boost/mpl/aux_/preprocessed/plain/or.hpp b/realsense-file/3rd_party/boost/boost/mpl/aux_/preprocessed/plain/or.hpp new file mode 100644 index 0000000000..35136b0030 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/aux_/preprocessed/plain/or.hpp @@ -0,0 +1,64 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/or.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +namespace aux { + +template< bool C_, typename T1, typename T2, typename T3, typename T4 > +struct or_impl + : true_ +{ +}; + +template< typename T1, typename T2, typename T3, typename T4 > +struct or_impl< false,T1,T2,T3,T4 > + : or_impl< + BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value + , T2, T3, T4 + , false_ + > +{ +}; + +template<> +struct or_impl< + false + , false_, false_, false_, false_ + > + : false_ +{ +}; + +} // namespace aux + +template< + typename BOOST_MPL_AUX_NA_PARAM(T1) + , typename BOOST_MPL_AUX_NA_PARAM(T2) + , typename T3 = false_, typename T4 = false_, typename T5 = false_ + > +struct or_ + + : aux::or_impl< + BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value + , T2, T3, T4, T5 + > + +{ +}; + +BOOST_MPL_AUX_NA_SPEC2( + 2 + , 5 + , or_ + ) + +}} diff --git a/realsense-file/3rd_party/boost/boost/mpl/aux_/preprocessed/plain/placeholders.hpp b/realsense-file/3rd_party/boost/boost/mpl/aux_/preprocessed/plain/placeholders.hpp new file mode 100644 index 0000000000..df5cb1da7f --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/aux_/preprocessed/plain/placeholders.hpp @@ -0,0 +1,105 @@ + +// Copyright Aleksey Gurtovoy 2001-2004 +// Copyright Peter Dimov 2001-2003 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/placeholders.hpp" header +// -- DO NOT modify by hand! + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +typedef arg< -1 > _; +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE +namespace boost { namespace mpl { + +BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_) + +namespace placeholders { +using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_; +} + +}} + +/// agurt, 17/mar/02: one more placeholder for the last 'apply#' +/// specialization +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +typedef arg<1> _1; + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE +namespace boost { namespace mpl { + +BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_1) + +namespace placeholders { +using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_1; +} + +}} +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +typedef arg<2> _2; + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE +namespace boost { namespace mpl { + +BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_2) + +namespace placeholders { +using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_2; +} + +}} +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +typedef arg<3> _3; + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE +namespace boost { namespace mpl { + +BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_3) + +namespace placeholders { +using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_3; +} + +}} +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +typedef arg<4> _4; + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE +namespace boost { namespace mpl { + +BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_4) + +namespace placeholders { +using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_4; +} + +}} +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +typedef arg<5> _5; + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE +namespace boost { namespace mpl { + +BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_5) + +namespace placeholders { +using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_5; +} + +}} +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +typedef arg<6> _6; + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE +namespace boost { namespace mpl { + +BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_6) + +namespace placeholders { +using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_6; +} + +}} diff --git a/realsense-file/3rd_party/boost/boost/mpl/aux_/preprocessed/plain/quote.hpp b/realsense-file/3rd_party/boost/boost/mpl/aux_/preprocessed/plain/quote.hpp new file mode 100644 index 0000000000..4b4e539d18 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/aux_/preprocessed/plain/quote.hpp @@ -0,0 +1,123 @@ + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/quote.hpp" header +// -- DO NOT modify by hand! + +namespace boost { namespace mpl { + +template< typename T, bool has_type_ > +struct quote_impl + : T +{ +}; + +template< typename T > +struct quote_impl< T,false > +{ + typedef T type; +}; + +template< + template< typename P1 > class F + , typename Tag = void_ + > +struct quote1 +{ + template< typename U1 > struct apply + + : quote_impl< + F + , aux::has_type< F >::value + > + + { + }; +}; + +template< + template< typename P1, typename P2 > class F + , typename Tag = void_ + > +struct quote2 +{ + template< typename U1, typename U2 > struct apply + + : quote_impl< + F< U1,U2 > + , aux::has_type< F< U1,U2 > >::value + > + + { + }; +}; + +template< + template< typename P1, typename P2, typename P3 > class F + , typename Tag = void_ + > +struct quote3 +{ + template< typename U1, typename U2, typename U3 > struct apply + + : quote_impl< + F< U1,U2,U3 > + , aux::has_type< F< U1,U2,U3 > >::value + > + + { + }; +}; + +template< + template< typename P1, typename P2, typename P3, typename P4 > class F + , typename Tag = void_ + > +struct quote4 +{ + template< + typename U1, typename U2, typename U3, typename U4 + > + struct apply + + : quote_impl< + F< U1,U2,U3,U4 > + , aux::has_type< F< U1,U2,U3,U4 > >::value + > + + { + }; +}; + +template< + template< + typename P1, typename P2, typename P3, typename P4 + , typename P5 + > + class F + , typename Tag = void_ + > +struct quote5 +{ + template< + typename U1, typename U2, typename U3, typename U4 + , typename U5 + > + struct apply + + : quote_impl< + F< U1,U2,U3,U4,U5 > + , aux::has_type< F< U1,U2,U3,U4,U5 > >::value + > + + { + }; +}; + +}} + diff --git a/realsense-file/3rd_party/boost/boost/mpl/aux_/preprocessed/plain/template_arity.hpp b/realsense-file/3rd_party/boost/boost/mpl/aux_/preprocessed/plain/template_arity.hpp new file mode 100644 index 0000000000..03f2dbd178 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/aux_/preprocessed/plain/template_arity.hpp @@ -0,0 +1,11 @@ + +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +// Preprocessed version of "boost/mpl/aux_/template_arity.hpp" header +// -- DO NOT modify by hand! + diff --git a/realsense-file/3rd_party/boost/boost/mpl/aux_/preprocessor/def_params_tail.hpp b/realsense-file/3rd_party/boost/boost/mpl/aux_/preprocessor/def_params_tail.hpp new file mode 100644 index 0000000000..6b941284ba --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/aux_/preprocessor/def_params_tail.hpp @@ -0,0 +1,105 @@ + +#ifndef BOOST_MPL_AUX_PREPROCESSOR_DEF_PARAMS_TAIL_HPP_INCLUDED +#define BOOST_MPL_AUX_PREPROCESSOR_DEF_PARAMS_TAIL_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Id$ +// $Date$ +// $Revision$ + +#include +#include +#include + +#include +#include +#include +#include + +// BOOST_MPL_PP_DEF_PARAMS_TAIL(1,T,value): , T1 = value, .., Tn = value +// BOOST_MPL_PP_DEF_PARAMS_TAIL(2,T,value): , T2 = value, .., Tn = value +// BOOST_MPL_PP_DEF_PARAMS_TAIL(n,T,value): + +#if !defined(BOOST_MPL_CFG_NO_OWN_PP_PRIMITIVES) + +# include +# include + +# define BOOST_MPL_PP_DEF_PARAMS_TAIL_IMPL(i, param, value_func) \ + BOOST_MPL_PP_DEF_PARAMS_TAIL_DELAY_1( \ + i \ + , BOOST_MPL_PP_SUB(BOOST_MPL_LIMIT_METAFUNCTION_ARITY,i) \ + , param \ + , value_func \ + ) \ + /**/ + +# define BOOST_MPL_PP_DEF_PARAMS_TAIL_DELAY_1(i, n, param, value_func) \ + BOOST_MPL_PP_DEF_PARAMS_TAIL_DELAY_2(i,n,param,value_func) \ + /**/ + +# define BOOST_MPL_PP_DEF_PARAMS_TAIL_DELAY_2(i, n, param, value_func) \ + BOOST_PP_COMMA_IF(BOOST_PP_AND(i,n)) \ + BOOST_MPL_PP_DEF_PARAMS_TAIL_##i(n,param,value_func) \ + /**/ + +# define BOOST_MPL_PP_DEF_PARAMS_TAIL_0(i,p,v) BOOST_MPL_PP_FILTER_PARAMS_##i(p##1 v(),p##2 v(),p##3 v(),p##4 v(),p##5 v(),p##6 v(),p##7 v(),p##8 v(),p##9 v()) +# define BOOST_MPL_PP_DEF_PARAMS_TAIL_1(i,p,v) BOOST_MPL_PP_FILTER_PARAMS_##i(p##2 v(),p##3 v(),p##4 v(),p##5 v(),p##6 v(),p##7 v(),p##8 v(),p##9 v(),p1) +# define BOOST_MPL_PP_DEF_PARAMS_TAIL_2(i,p,v) BOOST_MPL_PP_FILTER_PARAMS_##i(p##3 v(),p##4 v(),p##5 v(),p##6 v(),p##7 v(),p##8 v(),p##9 v(),p1,p2) +# define BOOST_MPL_PP_DEF_PARAMS_TAIL_3(i,p,v) BOOST_MPL_PP_FILTER_PARAMS_##i(p##4 v(),p##5 v(),p##6 v(),p##7 v(),p##8 v(),p##9 v(),p1,p2,p3) +# define BOOST_MPL_PP_DEF_PARAMS_TAIL_4(i,p,v) BOOST_MPL_PP_FILTER_PARAMS_##i(p##5 v(),p##6 v(),p##7 v(),p##8 v(),p##9 v(),p1,p2,p3,p4) +# define BOOST_MPL_PP_DEF_PARAMS_TAIL_5(i,p,v) BOOST_MPL_PP_FILTER_PARAMS_##i(p##6 v(),p##7 v(),p##8 v(),p##9 v(),p1,p2,p3,p4,p5) +# define BOOST_MPL_PP_DEF_PARAMS_TAIL_6(i,p,v) BOOST_MPL_PP_FILTER_PARAMS_##i(p##7 v(),p##8 v(),p##9 v(),p1,p2,p3,p4,p5,p6) +# define BOOST_MPL_PP_DEF_PARAMS_TAIL_7(i,p,v) BOOST_MPL_PP_FILTER_PARAMS_##i(p##8 v(),p##9 v(),p1,p2,p3,p4,p5,p6,p7) +# define BOOST_MPL_PP_DEF_PARAMS_TAIL_8(i,p,v) BOOST_MPL_PP_FILTER_PARAMS_##i(p##9 v(),p1,p2,p3,p4,p5,p6,p7,p8) +# define BOOST_MPL_PP_DEF_PARAMS_TAIL_9(i,p,v) BOOST_MPL_PP_FILTER_PARAMS_##i(p1,p2,p3,p4,p5,p6,p7,p8,p9) + +#else + +# include +# include +# include +# include +# include +# include + +# define BOOST_MPL_PP_AUX_TAIL_PARAM_FUNC(unused, i, op) \ + , BOOST_PP_CAT( \ + BOOST_PP_TUPLE_ELEM(3, 1, op) \ + , BOOST_PP_ADD_D(1, i, BOOST_PP_INC(BOOST_PP_TUPLE_ELEM(3, 0, op))) \ + ) BOOST_PP_TUPLE_ELEM(3, 2, op)() \ + /**/ + +# define BOOST_MPL_PP_DEF_PARAMS_TAIL_IMPL(i, param, value_func) \ + BOOST_PP_REPEAT( \ + BOOST_PP_SUB_D(1, BOOST_MPL_LIMIT_METAFUNCTION_ARITY, i) \ + , BOOST_MPL_PP_AUX_TAIL_PARAM_FUNC \ + , (i, param, value_func) \ + ) \ + /**/ + + +#endif // BOOST_MPL_CFG_NO_OWN_PP_PRIMITIVES + +#define BOOST_MPL_PP_DEF_PARAMS_TAIL(i, param, value) \ + BOOST_MPL_PP_DEF_PARAMS_TAIL_IMPL(i, param, BOOST_PP_IDENTITY(=value)) \ + /**/ + +#if !defined(BOOST_MPL_CFG_NO_DEFAULT_PARAMETERS_IN_NESTED_TEMPLATES) +# define BOOST_MPL_PP_NESTED_DEF_PARAMS_TAIL(i, param, value) \ + BOOST_MPL_PP_DEF_PARAMS_TAIL_IMPL(i, param, BOOST_PP_IDENTITY(=value)) \ + /**/ +#else +# define BOOST_MPL_PP_NESTED_DEF_PARAMS_TAIL(i, param, value) \ + BOOST_MPL_PP_DEF_PARAMS_TAIL_IMPL(i, param, BOOST_PP_EMPTY) \ + /**/ +#endif + +#endif // BOOST_MPL_AUX_PREPROCESSOR_DEF_PARAMS_TAIL_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/mpl/aux_/preprocessor/default_params.hpp b/realsense-file/3rd_party/boost/boost/mpl/aux_/preprocessor/default_params.hpp new file mode 100644 index 0000000000..51f981fff9 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/aux_/preprocessor/default_params.hpp @@ -0,0 +1,67 @@ + +#ifndef BOOST_MPL_AUX_PREPROCESSOR_DEFAULT_PARAMS_HPP_INCLUDED +#define BOOST_MPL_AUX_PREPROCESSOR_DEFAULT_PARAMS_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2002-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Id$ +// $Date$ +// $Revision$ + +#include + +// BOOST_MPL_PP_DEFAULT_PARAMS(0,T,int): +// BOOST_MPL_PP_DEFAULT_PARAMS(1,T,int): T1 = int +// BOOST_MPL_PP_DEFAULT_PARAMS(2,T,int): T1 = int, T2 = int +// BOOST_MPL_PP_DEFAULT_PARAMS(n,T,int): T1 = int, T2 = int, .., Tn = int + +#if !defined(BOOST_MPL_CFG_NO_OWN_PP_PRIMITIVES) + +# include + +# define BOOST_MPL_PP_DEFAULT_PARAMS(n,p,v) \ + BOOST_PP_CAT(BOOST_MPL_PP_DEFAULT_PARAMS_,n)(p,v) \ + /**/ + +# define BOOST_MPL_PP_DEFAULT_PARAMS_0(p,v) +# define BOOST_MPL_PP_DEFAULT_PARAMS_1(p,v) p##1=v +# define BOOST_MPL_PP_DEFAULT_PARAMS_2(p,v) p##1=v,p##2=v +# define BOOST_MPL_PP_DEFAULT_PARAMS_3(p,v) p##1=v,p##2=v,p##3=v +# define BOOST_MPL_PP_DEFAULT_PARAMS_4(p,v) p##1=v,p##2=v,p##3=v,p##4=v +# define BOOST_MPL_PP_DEFAULT_PARAMS_5(p,v) p##1=v,p##2=v,p##3=v,p##4=v,p##5=v +# define BOOST_MPL_PP_DEFAULT_PARAMS_6(p,v) p##1=v,p##2=v,p##3=v,p##4=v,p##5=v,p##6=v +# define BOOST_MPL_PP_DEFAULT_PARAMS_7(p,v) p##1=v,p##2=v,p##3=v,p##4=v,p##5=v,p##6=v,p##7=v +# define BOOST_MPL_PP_DEFAULT_PARAMS_8(p,v) p##1=v,p##2=v,p##3=v,p##4=v,p##5=v,p##6=v,p##7=v,p##8=v +# define BOOST_MPL_PP_DEFAULT_PARAMS_9(p,v) p##1=v,p##2=v,p##3=v,p##4=v,p##5=v,p##6=v,p##7=v,p##8=v,p##9=v + +#else + +# include +# include +# include +# include +# include + +# define BOOST_MPL_PP_AUX_DEFAULT_PARAM_FUNC(unused, i, pv) \ + BOOST_PP_COMMA_IF(i) \ + BOOST_PP_CAT( BOOST_PP_TUPLE_ELEM(2,0,pv), BOOST_PP_INC(i) ) \ + = BOOST_PP_TUPLE_ELEM(2,1,pv) \ + /**/ + +# define BOOST_MPL_PP_DEFAULT_PARAMS(n, param, value) \ + BOOST_PP_REPEAT( \ + n \ + , BOOST_MPL_PP_AUX_DEFAULT_PARAM_FUNC \ + , (param,value) \ + ) \ + /**/ + +#endif + +#endif // BOOST_MPL_AUX_PREPROCESSOR_DEFAULT_PARAMS_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/mpl/aux_/preprocessor/enum.hpp b/realsense-file/3rd_party/boost/boost/mpl/aux_/preprocessor/enum.hpp new file mode 100644 index 0000000000..b43b8c9d11 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/aux_/preprocessor/enum.hpp @@ -0,0 +1,62 @@ + +#ifndef BOOST_MPL_AUX_PREPROCESSOR_ENUM_HPP_INCLUDED +#define BOOST_MPL_AUX_PREPROCESSOR_ENUM_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Id$ +// $Date$ +// $Revision$ + +#include + +// BOOST_MPL_PP_ENUM(0,int): +// BOOST_MPL_PP_ENUM(1,int): int +// BOOST_MPL_PP_ENUM(2,int): int, int +// BOOST_MPL_PP_ENUM(n,int): int, int, .., int + +#if !defined(BOOST_MPL_CFG_NO_OWN_PP_PRIMITIVES) + +# include + +# define BOOST_MPL_PP_ENUM(n, param) \ + BOOST_PP_CAT(BOOST_MPL_PP_ENUM_,n)(param) \ + /**/ + +# define BOOST_MPL_PP_ENUM_0(p) +# define BOOST_MPL_PP_ENUM_1(p) p +# define BOOST_MPL_PP_ENUM_2(p) p,p +# define BOOST_MPL_PP_ENUM_3(p) p,p,p +# define BOOST_MPL_PP_ENUM_4(p) p,p,p,p +# define BOOST_MPL_PP_ENUM_5(p) p,p,p,p,p +# define BOOST_MPL_PP_ENUM_6(p) p,p,p,p,p,p +# define BOOST_MPL_PP_ENUM_7(p) p,p,p,p,p,p,p +# define BOOST_MPL_PP_ENUM_8(p) p,p,p,p,p,p,p,p +# define BOOST_MPL_PP_ENUM_9(p) p,p,p,p,p,p,p,p,p + +#else + +# include +# include + +# define BOOST_MPL_PP_AUX_ENUM_FUNC(unused, i, param) \ + BOOST_PP_COMMA_IF(i) param \ + /**/ + +# define BOOST_MPL_PP_ENUM(n, param) \ + BOOST_PP_REPEAT( \ + n \ + , BOOST_MPL_PP_AUX_ENUM_FUNC \ + , param \ + ) \ + /**/ + +#endif + +#endif // BOOST_MPL_AUX_PREPROCESSOR_ENUM_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/mpl/aux_/preprocessor/params.hpp b/realsense-file/3rd_party/boost/boost/mpl/aux_/preprocessor/params.hpp new file mode 100644 index 0000000000..08b48f68a6 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/aux_/preprocessor/params.hpp @@ -0,0 +1,65 @@ + +#ifndef BOOST_MPL_AUX_PREPROCESSOR_PARAMS_HPP_INCLUDED +#define BOOST_MPL_AUX_PREPROCESSOR_PARAMS_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Id$ +// $Date$ +// $Revision$ + +#include "../config/preprocessor.hpp" + +// BOOST_MPL_PP_PARAMS(0,T): +// BOOST_MPL_PP_PARAMS(1,T): T1 +// BOOST_MPL_PP_PARAMS(2,T): T1, T2 +// BOOST_MPL_PP_PARAMS(n,T): T1, T2, .., Tn + +#if !defined(BOOST_MPL_CFG_NO_OWN_PP_PRIMITIVES) + +# include + +# define BOOST_MPL_PP_PARAMS(n,p) \ + BOOST_PP_CAT(BOOST_MPL_PP_PARAMS_,n)(p) \ + /**/ + +# define BOOST_MPL_PP_PARAMS_0(p) +# define BOOST_MPL_PP_PARAMS_1(p) p##1 +# define BOOST_MPL_PP_PARAMS_2(p) p##1,p##2 +# define BOOST_MPL_PP_PARAMS_3(p) p##1,p##2,p##3 +# define BOOST_MPL_PP_PARAMS_4(p) p##1,p##2,p##3,p##4 +# define BOOST_MPL_PP_PARAMS_5(p) p##1,p##2,p##3,p##4,p##5 +# define BOOST_MPL_PP_PARAMS_6(p) p##1,p##2,p##3,p##4,p##5,p##6 +# define BOOST_MPL_PP_PARAMS_7(p) p##1,p##2,p##3,p##4,p##5,p##6,p##7 +# define BOOST_MPL_PP_PARAMS_8(p) p##1,p##2,p##3,p##4,p##5,p##6,p##7,p##8 +# define BOOST_MPL_PP_PARAMS_9(p) p##1,p##2,p##3,p##4,p##5,p##6,p##7,p##8,p##9 + +#else + +# include "boost/preprocessor/comma_if.hpp" +# include "boost/preprocessor/repeat.hpp" +# include "boost/preprocessor/inc.hpp" +# include "boost/preprocessor/cat.hpp" + +# define BOOST_MPL_PP_AUX_PARAM_FUNC(unused, i, param) \ + BOOST_PP_COMMA_IF(i) \ + BOOST_PP_CAT(param, BOOST_PP_INC(i)) \ + /**/ + +# define BOOST_MPL_PP_PARAMS(n, param) \ + BOOST_PP_REPEAT( \ + n \ + , BOOST_MPL_PP_AUX_PARAM_FUNC \ + , param \ + ) \ + /**/ + +#endif + +#endif // BOOST_MPL_AUX_PREPROCESSOR_PARAMS_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/mpl/aux_/static_cast.hpp b/realsense-file/3rd_party/boost/boost/mpl/aux_/static_cast.hpp new file mode 100644 index 0000000000..52a78d958a --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/aux_/static_cast.hpp @@ -0,0 +1,27 @@ + +#ifndef BOOST_MPL_AUX_STATIC_CAST_HPP_INCLUDED +#define BOOST_MPL_AUX_STATIC_CAST_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Id$ +// $Date$ +// $Revision$ + +#include "config/workaround.hpp" + +#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x561)) \ + || BOOST_WORKAROUND(__GNUC__, < 3) \ + || BOOST_WORKAROUND(__MWERKS__, <= 0x3001) +# define BOOST_MPL_AUX_STATIC_CAST(T, expr) (T)(expr) +#else +# define BOOST_MPL_AUX_STATIC_CAST(T, expr) static_cast(expr) +#endif + +#endif // BOOST_MPL_AUX_STATIC_CAST_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/mpl/aux_/template_arity.hpp b/realsense-file/3rd_party/boost/boost/mpl/aux_/template_arity.hpp new file mode 100644 index 0000000000..d6eda14f01 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/aux_/template_arity.hpp @@ -0,0 +1,189 @@ + +#if !defined(BOOST_PP_IS_ITERATING) + +///// header body + +#ifndef BOOST_MPL_AUX_TEMPLATE_ARITY_HPP_INCLUDED +#define BOOST_MPL_AUX_TEMPLATE_ARITY_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Id$ +// $Date$ +// $Revision$ + +#include +#include + +#if !defined(BOOST_MPL_PREPROCESSING_MODE) +# include +# include +# if !defined(BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT) +# if defined(BOOST_MPL_CFG_EXTENDED_TEMPLATE_PARAMETERS_MATCHING) +# include +# endif +# else +# include +# endif +#endif + +#include +#include + +#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) + +# define BOOST_MPL_PREPROCESSED_HEADER template_arity.hpp +# include + +#else + +# if !defined(BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT) +# if defined(BOOST_MPL_CFG_EXTENDED_TEMPLATE_PARAMETERS_MATCHING) + +# include +# include +# include +# include +# include + +# include +# include +# include +# include +# include + +# define AUX778076_ARITY BOOST_PP_INC(BOOST_MPL_LIMIT_METAFUNCTION_ARITY) + +namespace boost { namespace mpl { namespace aux { + +template< BOOST_MPL_AUX_NTTP_DECL(int, N) > struct arity_tag +{ + typedef char (&type)[N + 1]; +}; + +# define AUX778076_MAX_ARITY_OP(unused, state, i_) \ + ( BOOST_PP_CAT(C,i_) > 0 ? BOOST_PP_CAT(C,i_) : state ) \ +/**/ + +template< + BOOST_MPL_PP_PARAMS(AUX778076_ARITY, BOOST_MPL_AUX_NTTP_DECL(int, C)) + > +struct max_arity +{ + BOOST_STATIC_CONSTANT(int, value = + BOOST_PP_SEQ_FOLD_LEFT( + AUX778076_MAX_ARITY_OP + , -1 + , BOOST_MPL_PP_RANGE(1, AUX778076_ARITY) + ) + ); +}; + +# undef AUX778076_MAX_ARITY_OP + +arity_tag<0>::type arity_helper(...); + +# define BOOST_PP_ITERATION_LIMITS (1, AUX778076_ARITY) +# define BOOST_PP_FILENAME_1 +# include BOOST_PP_ITERATE() + +template< typename F, BOOST_MPL_AUX_NTTP_DECL(int, N) > +struct template_arity_impl +{ + BOOST_STATIC_CONSTANT(int, value = + sizeof(::boost::mpl::aux::arity_helper(type_wrapper(),arity_tag())) - 1 + ); +}; + +# define AUX778076_TEMPLATE_ARITY_IMPL_INVOCATION(unused, i_, F) \ + BOOST_PP_COMMA_IF(i_) template_arity_impl::value \ +/**/ + +template< typename F > +struct template_arity +{ + BOOST_STATIC_CONSTANT(int, value = ( + max_arity< BOOST_MPL_PP_REPEAT( + AUX778076_ARITY + , AUX778076_TEMPLATE_ARITY_IMPL_INVOCATION + , F + ) >::value + )); + + typedef mpl::int_ type; +}; + +# undef AUX778076_TEMPLATE_ARITY_IMPL_INVOCATION + +# undef AUX778076_ARITY + +}}} + +# endif // BOOST_MPL_CFG_EXTENDED_TEMPLATE_PARAMETERS_MATCHING +# else // BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT + +# include + +namespace boost { namespace mpl { namespace aux { + +template< bool > +struct template_arity_impl +{ + template< typename F > struct result_ + : mpl::int_<-1> + { + }; +}; + +template<> +struct template_arity_impl +{ + template< typename F > struct result_ + : F::arity + { + }; +}; + +template< typename F > +struct template_arity + : template_arity_impl< ::boost::mpl::aux::has_rebind::value > + ::template result_ +{ +}; + +#if defined(BOOST_MPL_CFG_MSVC_ETI_BUG) +template<> +struct template_arity + : mpl::int_<-1> +{ +}; +#endif + +}}} + +# endif // BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT + +#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS +#endif // BOOST_MPL_AUX_TEMPLATE_ARITY_HPP_INCLUDED + +///// iteration + +#else +#define i_ BOOST_PP_FRAME_ITERATION(1) + +template< + template< BOOST_MPL_PP_PARAMS(i_, typename P) > class F + , BOOST_MPL_PP_PARAMS(i_, typename T) + > +typename arity_tag::type +arity_helper(type_wrapper< F >, arity_tag); + +#undef i_ +#endif // BOOST_PP_IS_ITERATING diff --git a/realsense-file/3rd_party/boost/boost/mpl/aux_/template_arity_fwd.hpp b/realsense-file/3rd_party/boost/boost/mpl/aux_/template_arity_fwd.hpp new file mode 100644 index 0000000000..e1742c4486 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/aux_/template_arity_fwd.hpp @@ -0,0 +1,23 @@ + +#ifndef BOOST_MPL_AUX_TEMPLATE_ARITY_FWD_HPP_INCLUDED +#define BOOST_MPL_AUX_TEMPLATE_ARITY_FWD_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Id$ +// $Date$ +// $Revision$ + +namespace boost { namespace mpl { namespace aux { + +template< typename F > struct template_arity; + +}}} + +#endif // BOOST_MPL_AUX_TEMPLATE_ARITY_FWD_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/mpl/aux_/type_wrapper.hpp b/realsense-file/3rd_party/boost/boost/mpl/aux_/type_wrapper.hpp new file mode 100644 index 0000000000..1a6f42ce6b --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/aux_/type_wrapper.hpp @@ -0,0 +1,47 @@ + +#ifndef BOOST_MPL_AUX_TYPE_WRAPPER_HPP_INCLUDED +#define BOOST_MPL_AUX_TYPE_WRAPPER_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// Copyright Peter Dimov 2000-2003 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Id$ +// $Date$ +// $Revision$ + +#include + +namespace boost { namespace mpl { namespace aux { + +template< typename T > struct type_wrapper +{ + typedef T type; +}; + +#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) +// agurt 08/may/03: a complicated way to extract the wrapped type; need it +// mostly for the sake of GCC (3.2.x), which ICEs if you try to extract the +// nested 'type' from 'type_wrapper' when the latter was the result of a +// 'typeof' expression +template< typename T > struct wrapped_type; + +template< typename T > struct wrapped_type< type_wrapper > +{ + typedef T type; +}; +#else +template< typename W > struct wrapped_type +{ + typedef typename W::type type; +}; +#endif + +}}} + +#endif // BOOST_MPL_AUX_TYPE_WRAPPER_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/mpl/aux_/value_wknd.hpp b/realsense-file/3rd_party/boost/boost/mpl/aux_/value_wknd.hpp new file mode 100644 index 0000000000..0b2c15192d --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/aux_/value_wknd.hpp @@ -0,0 +1,89 @@ + +#ifndef BOOST_MPL_AUX_VALUE_WKND_HPP_INCLUDED +#define BOOST_MPL_AUX_VALUE_WKND_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Id$ +// $Date$ +// $Revision$ + +#include +#include +#include +#include + +#if defined(BOOST_MPL_CFG_BCC_INTEGRAL_CONSTANTS) \ + || defined(BOOST_MPL_CFG_MSVC_60_ETI_BUG) + +# include + +namespace boost { namespace mpl { namespace aux { +template< typename C_ > struct value_wknd + : C_ +{ +}; + +#if defined(BOOST_MPL_CFG_MSVC_60_ETI_BUG) +template<> struct value_wknd + : int_<1> +{ + using int_<1>::value; +}; +#endif +}}} + + +#if !defined(BOOST_MPL_CFG_MSVC_60_ETI_BUG) +# define BOOST_MPL_AUX_VALUE_WKND(C) \ + ::BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::aux::value_wknd< C > \ +/**/ +# define BOOST_MPL_AUX_MSVC_VALUE_WKND(C) BOOST_MPL_AUX_VALUE_WKND(C) +#else +# define BOOST_MPL_AUX_VALUE_WKND(C) C +# define BOOST_MPL_AUX_MSVC_VALUE_WKND(C) \ + ::boost::mpl::aux::value_wknd< C > \ +/**/ +#endif + +#else // BOOST_MPL_CFG_BCC_INTEGRAL_CONSTANTS + +# define BOOST_MPL_AUX_VALUE_WKND(C) C +# define BOOST_MPL_AUX_MSVC_VALUE_WKND(C) C + +#endif + +#if BOOST_WORKAROUND(__EDG_VERSION__, <= 238) +# define BOOST_MPL_AUX_NESTED_VALUE_WKND(T, C) \ + BOOST_MPL_AUX_STATIC_CAST(T, C::value) \ +/**/ +#else +# define BOOST_MPL_AUX_NESTED_VALUE_WKND(T, C) \ + BOOST_MPL_AUX_VALUE_WKND(C)::value \ +/**/ +#endif + + +namespace boost { namespace mpl { namespace aux { + +template< typename T > struct value_type_wknd +{ + typedef typename T::value_type type; +}; + +#if defined(BOOST_MPL_CFG_MSVC_ETI_BUG) +template<> struct value_type_wknd +{ + typedef int type; +}; +#endif + +}}} + +#endif // BOOST_MPL_AUX_VALUE_WKND_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/mpl/aux_/yes_no.hpp b/realsense-file/3rd_party/boost/boost/mpl/aux_/yes_no.hpp new file mode 100644 index 0000000000..22082b5ec6 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/aux_/yes_no.hpp @@ -0,0 +1,58 @@ + +#ifndef BOOST_MPL_AUX_YES_NO_HPP_INCLUDED +#define BOOST_MPL_AUX_YES_NO_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Id$ +// $Date$ +// $Revision$ + +#include +#include +#include +#include + + +namespace boost { namespace mpl { namespace aux { + +typedef char (&no_tag)[1]; +typedef char (&yes_tag)[2]; + +template< bool C_ > struct yes_no_tag +{ + typedef no_tag type; +}; + +template<> struct yes_no_tag +{ + typedef yes_tag type; +}; + + +template< BOOST_MPL_AUX_NTTP_DECL(long, n) > struct weighted_tag +{ +#if !BOOST_WORKAROUND(BOOST_MSVC, < 1300) + typedef char (&type)[n]; +#else + char buf[n]; + typedef weighted_tag type; +#endif +}; + +#if defined(BOOST_MPL_CFG_NO_DEPENDENT_ARRAY_TYPES) +template<> struct weighted_tag<0> +{ + typedef char (&type)[1]; +}; +#endif + +}}} + +#endif // BOOST_MPL_AUX_YES_NO_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/mpl/bind_fwd.hpp b/realsense-file/3rd_party/boost/boost/mpl/bind_fwd.hpp new file mode 100644 index 0000000000..39c6025a26 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/bind_fwd.hpp @@ -0,0 +1,99 @@ + +#if !defined(BOOST_PP_IS_ITERATING) + +///// header body + +#ifndef BOOST_MPL_BIND_FWD_HPP_INCLUDED +#define BOOST_MPL_BIND_FWD_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Id$ +// $Date$ +// $Revision$ + +#if !defined(BOOST_MPL_PREPROCESSING_MODE) +# include +#endif + +#include +#include + +#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) + +# define BOOST_MPL_PREPROCESSED_HEADER bind_fwd.hpp +# include + +#else + +# include +# include +# include +# include + +# include +# include +# include + +namespace boost { namespace mpl { + +// local macros, #undef-ined at the end of the header + +# if defined(BOOST_MPL_CFG_DMC_AMBIGUOUS_CTPS) +# define AUX778076_DMC_PARAM() , int dummy_ = 0 +# else +# define AUX778076_DMC_PARAM() +# endif + +# define AUX778076_BIND_DEFAULT_PARAMS(param, value) \ + BOOST_MPL_PP_DEFAULT_PARAMS( \ + BOOST_MPL_LIMIT_METAFUNCTION_ARITY \ + , param \ + , value \ + ) \ + AUX778076_DMC_PARAM() \ + /**/ + +# define AUX778076_BIND_N_PARAMS(n, param) \ + BOOST_PP_COMMA_IF(n) BOOST_MPL_PP_PARAMS(n, param) \ + AUX778076_DMC_PARAM() \ + /**/ + +#if !defined(BOOST_MPL_CFG_NO_BIND_TEMPLATE) +template< + typename F, AUX778076_BIND_DEFAULT_PARAMS(typename T, na) + > +struct bind; +#endif + +#define BOOST_PP_ITERATION_PARAMS_1 \ + (3,(0, BOOST_MPL_LIMIT_METAFUNCTION_ARITY, )) +#include BOOST_PP_ITERATE() + +# undef AUX778076_BIND_N_PARAMS +# undef AUX778076_BIND_DEFAULT_PARAMS +# undef AUX778076_DMC_PARAM +}} + +#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS +#endif // BOOST_MPL_BIND_FWD_HPP_INCLUDED + +///// iteration + +#else +#define i_ BOOST_PP_FRAME_ITERATION(1) + +template< + typename F AUX778076_BIND_N_PARAMS(i_, typename T) + > +struct BOOST_PP_CAT(bind,i_); + +#undef i_ +#endif // BOOST_PP_IS_ITERATING diff --git a/realsense-file/3rd_party/boost/boost/mpl/bool.hpp b/realsense-file/3rd_party/boost/boost/mpl/bool.hpp new file mode 100644 index 0000000000..c707c71f92 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/bool.hpp @@ -0,0 +1,39 @@ + +#ifndef BOOST_MPL_BOOL_HPP_INCLUDED +#define BOOST_MPL_BOOL_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Id$ +// $Date$ +// $Revision$ + +#include +#include +#include + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN + +template< bool C_ > struct bool_ +{ + BOOST_STATIC_CONSTANT(bool, value = C_); + typedef integral_c_tag tag; + typedef bool_ type; + typedef bool value_type; + BOOST_CONSTEXPR operator bool() const { return this->value; } +}; + +#if !defined(BOOST_NO_INCLASS_MEMBER_INITIALIZATION) +template< bool C_ > +bool const bool_::value; +#endif + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE + +#endif // BOOST_MPL_BOOL_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/mpl/bool_fwd.hpp b/realsense-file/3rd_party/boost/boost/mpl/bool_fwd.hpp new file mode 100644 index 0000000000..c813332c7b --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/bool_fwd.hpp @@ -0,0 +1,33 @@ + +#ifndef BOOST_MPL_BOOL_FWD_HPP_INCLUDED +#define BOOST_MPL_BOOL_FWD_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Id$ +// $Date$ +// $Revision$ + +#include + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN + +template< bool C_ > struct bool_; + +// shorcuts +typedef bool_ true_; +typedef bool_ false_; + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE + +BOOST_MPL_AUX_ADL_BARRIER_DECL(bool_) +BOOST_MPL_AUX_ADL_BARRIER_DECL(true_) +BOOST_MPL_AUX_ADL_BARRIER_DECL(false_) + +#endif // BOOST_MPL_BOOL_FWD_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/mpl/eval_if.hpp b/realsense-file/3rd_party/boost/boost/mpl/eval_if.hpp new file mode 100644 index 0000000000..7e5c6b3d3e --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/eval_if.hpp @@ -0,0 +1,71 @@ + +#ifndef BOOST_MPL_EVAL_IF_HPP_INCLUDED +#define BOOST_MPL_EVAL_IF_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Id$ +// $Date$ +// $Revision$ + +#include +#include +#include +#include +#include +#include + +namespace boost { namespace mpl { + +template< + typename BOOST_MPL_AUX_NA_PARAM(C) + , typename BOOST_MPL_AUX_NA_PARAM(F1) + , typename BOOST_MPL_AUX_NA_PARAM(F2) + > +struct eval_if +#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) \ + || ( BOOST_WORKAROUND(BOOST_MPL_CFG_GCC, >= 0x0300) \ + && BOOST_WORKAROUND(BOOST_MPL_CFG_GCC, BOOST_TESTED_AT(0x0304)) \ + ) +{ + typedef typename if_::type f_; + typedef typename f_::type type; +#else + : if_::type +{ +#endif + BOOST_MPL_AUX_LAMBDA_SUPPORT(3,eval_if,(C,F1,F2)) +}; + +// (almost) copy & paste in order to save one more +// recursively nested template instantiation to user +template< + bool C + , typename F1 + , typename F2 + > +struct eval_if_c +#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) \ + || ( BOOST_WORKAROUND(BOOST_MPL_CFG_GCC, >= 0x0300) \ + && BOOST_WORKAROUND(BOOST_MPL_CFG_GCC, BOOST_TESTED_AT(0x0304)) \ + ) +{ + typedef typename if_c::type f_; + typedef typename f_::type type; +#else + : if_c::type +{ +#endif +}; + +BOOST_MPL_AUX_NA_SPEC(3, eval_if) + +}} + +#endif // BOOST_MPL_EVAL_IF_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/mpl/has_xxx.hpp b/realsense-file/3rd_party/boost/boost/mpl/has_xxx.hpp new file mode 100644 index 0000000000..1365c72ff8 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/has_xxx.hpp @@ -0,0 +1,647 @@ + +#ifndef BOOST_MPL_HAS_XXX_HPP_INCLUDED +#define BOOST_MPL_HAS_XXX_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2002-2006 +// Copyright David Abrahams 2002-2003 +// Copyright Daniel Walker 2007 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Id$ +// $Date$ +// $Revision$ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include + +#if BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT(0x590) ) +# include +#endif + +#if !defined(BOOST_MPL_CFG_NO_HAS_XXX) + +# if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) + +// agurt, 11/sep/02: MSVC-specific version (< 7.1), based on a USENET +// newsgroup's posting by John Madsen (comp.lang.c++.moderated, +// 1999-11-12 19:17:06 GMT); the code is _not_ standard-conforming, but +// it works way more reliably than the SFINAE-based implementation + +// Modified dwa 8/Oct/02 to handle reference types. + +# include +# include + +namespace boost { namespace mpl { namespace aux { + +struct has_xxx_tag; + +#if BOOST_WORKAROUND(BOOST_MSVC, == 1300) +template< typename U > struct msvc_incomplete_array +{ + typedef char (&type)[sizeof(U) + 1]; +}; +#endif + +template< typename T > +struct msvc_is_incomplete +{ + // MSVC is capable of some kinds of SFINAE. If U is an incomplete + // type, it won't pick the second overload + static char tester(...); + +#if BOOST_WORKAROUND(BOOST_MSVC, == 1300) + template< typename U > + static typename msvc_incomplete_array::type tester(type_wrapper); +#else + template< typename U > + static char (& tester(type_wrapper) )[sizeof(U)+1]; +#endif + + BOOST_STATIC_CONSTANT(bool, value = + sizeof(tester(type_wrapper())) == 1 + ); +}; + +template<> +struct msvc_is_incomplete +{ + BOOST_STATIC_CONSTANT(bool, value = false); +}; + +}}} + +# define BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF_(trait, name, default_) \ +template< typename T, typename name = ::boost::mpl::aux::has_xxx_tag > \ +struct BOOST_PP_CAT(trait,_impl) : T \ +{ \ + static boost::mpl::aux::no_tag \ + test(void(*)(::boost::mpl::aux::has_xxx_tag)); \ + \ + static boost::mpl::aux::yes_tag test(...); \ + \ + BOOST_STATIC_CONSTANT(bool, value = \ + sizeof(test(static_cast(0))) \ + != sizeof(boost::mpl::aux::no_tag) \ + ); \ + typedef boost::mpl::bool_ type; \ +}; \ +\ +template< typename T, typename fallback_ = boost::mpl::bool_ > \ +struct trait \ + : boost::mpl::if_c< \ + boost::mpl::aux::msvc_is_incomplete::value \ + , boost::mpl::bool_ \ + , BOOST_PP_CAT(trait,_impl) \ + >::type \ +{ \ +}; \ +\ +BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, void) \ +BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, bool) \ +BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, char) \ +BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, signed char) \ +BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, unsigned char) \ +BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, signed short) \ +BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, unsigned short) \ +BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, signed int) \ +BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, unsigned int) \ +BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, signed long) \ +BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, unsigned long) \ +BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, float) \ +BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, double) \ +BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, long double) \ +/**/ + +# define BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, T) \ +template<> struct trait \ +{ \ + BOOST_STATIC_CONSTANT(bool, value = false); \ + typedef boost::mpl::bool_ type; \ +}; \ +/**/ + +#if !defined(BOOST_NO_INTRINSIC_WCHAR_T) +# define BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(trait, name, unused) \ + BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF_(trait, name, unused) \ + BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, wchar_t) \ +/**/ +#else +# define BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(trait, name, unused) \ + BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF_(trait, name, unused) \ +/**/ +#endif + + +// SFINAE-based implementations below are derived from a USENET newsgroup's +// posting by Rani Sharoni (comp.lang.c++.moderated, 2002-03-17 07:45:09 PST) + +# elif BOOST_WORKAROUND(BOOST_MSVC, <= 1400) \ + || (BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1800)) && defined(__CUDACC__)) \ + || BOOST_WORKAROUND(__IBMCPP__, <= 700) + +// MSVC 7.1 & MSVC 8.0 & VACPP + +// agurt, 15/jun/05: replace overload-based SFINAE implementation with SFINAE +// applied to partial specialization to fix some apparently random failures +// (thanks to Daniel Wallin for researching this!) + +# define BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(trait, name, default_) \ +template< typename T > \ +struct BOOST_PP_CAT(trait, _msvc_sfinae_helper) \ +{ \ + typedef void type; \ +};\ +\ +template< typename T, typename U = void > \ +struct BOOST_PP_CAT(trait,_impl_) \ +{ \ + BOOST_STATIC_CONSTANT(bool, value = false); \ + typedef boost::mpl::bool_ type; \ +}; \ +\ +template< typename T > \ +struct BOOST_PP_CAT(trait,_impl_)< \ + T \ + , typename BOOST_PP_CAT(trait, _msvc_sfinae_helper)< typename T::name >::type \ + > \ +{ \ + BOOST_STATIC_CONSTANT(bool, value = true); \ + typedef boost::mpl::bool_ type; \ +}; \ +\ +template< typename T, typename fallback_ = boost::mpl::bool_ > \ +struct trait \ + : BOOST_PP_CAT(trait,_impl_) \ +{ \ +}; \ +/**/ + +# elif BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT(0x590) ) + +# define BOOST_MPL_HAS_XXX_TRAIT_NAMED_BCB_DEF(trait, trait_tester, name, default_) \ +template< typename T, bool IS_CLASS > \ +struct trait_tester \ +{ \ + BOOST_STATIC_CONSTANT( bool, value = false ); \ +}; \ +template< typename T > \ +struct trait_tester< T, true > \ +{ \ + struct trait_tester_impl \ + { \ + template < class U > \ + static int resolve( boost::mpl::aux::type_wrapper const volatile * \ + , boost::mpl::aux::type_wrapper* = 0 ); \ + static char resolve( ... ); \ + }; \ + typedef boost::mpl::aux::type_wrapper t_; \ + BOOST_STATIC_CONSTANT( bool, value = ( sizeof( trait_tester_impl::resolve( static_cast< t_ * >(0) ) ) == sizeof(int) ) ); \ +}; \ +template< typename T, typename fallback_ = boost::mpl::bool_ > \ +struct trait \ +{ \ + BOOST_STATIC_CONSTANT( bool, value = (trait_tester< T, boost::is_class< T >::value >::value) ); \ + typedef boost::mpl::bool_< trait< T, fallback_ >::value > type; \ +}; + +# define BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(trait, name, default_) \ + BOOST_MPL_HAS_XXX_TRAIT_NAMED_BCB_DEF( trait \ + , BOOST_PP_CAT(trait,_tester) \ + , name \ + , default_ ) \ +/**/ + +# else // other SFINAE-capable compilers + +# define BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(trait, name, default_) \ +template< typename T, typename fallback_ = boost::mpl::bool_ > \ +struct trait \ +{ \ + struct gcc_3_2_wknd \ + { \ + template< typename U > \ + static boost::mpl::aux::yes_tag test( \ + boost::mpl::aux::type_wrapper const volatile* \ + , boost::mpl::aux::type_wrapper* = 0 \ + ); \ + \ + static boost::mpl::aux::no_tag test(...); \ + }; \ + \ + typedef boost::mpl::aux::type_wrapper t_; \ + BOOST_STATIC_CONSTANT(bool, value = \ + sizeof(gcc_3_2_wknd::test(static_cast(0))) \ + == sizeof(boost::mpl::aux::yes_tag) \ + ); \ + typedef boost::mpl::bool_ type; \ +}; \ +/**/ + +# endif // BOOST_WORKAROUND(BOOST_MSVC, <= 1300) + + +#else // BOOST_MPL_CFG_NO_HAS_XXX + +// placeholder implementation + +# define BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(trait, name, default_) \ +template< typename T, typename fallback_ = boost::mpl::bool_ > \ +struct trait \ +{ \ + BOOST_STATIC_CONSTANT(bool, value = fallback_::value); \ + typedef fallback_ type; \ +}; \ +/**/ + +#endif + +#define BOOST_MPL_HAS_XXX_TRAIT_DEF(name) \ + BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(BOOST_PP_CAT(has_,name), name, false) \ +/**/ + + +#if !defined(BOOST_MPL_CFG_NO_HAS_XXX_TEMPLATE) + +// Create a boolean Metafunction to detect a nested template +// member. This implementation is based on a USENET newsgroup's +// posting by Aleksey Gurtovoy (comp.lang.c++.moderated, 2002-03-19), +// Rani Sharoni's USENET posting cited above, the non-template has_xxx +// implementations above, and discussion on the Boost mailing list. + +# if !defined(BOOST_MPL_HAS_XXX_NO_WRAPPED_TYPES) +# if BOOST_WORKAROUND(BOOST_MSVC, <= 1400) +# define BOOST_MPL_HAS_XXX_NO_WRAPPED_TYPES 1 +# else +# define BOOST_MPL_HAS_XXX_NO_WRAPPED_TYPES 0 +# endif +# endif + +# if !defined(BOOST_MPL_HAS_XXX_NO_EXPLICIT_TEST_FUNCTION) +# if (defined(BOOST_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS)) +# define BOOST_MPL_HAS_XXX_NO_EXPLICIT_TEST_FUNCTION 1 +# else +# define BOOST_MPL_HAS_XXX_NO_EXPLICIT_TEST_FUNCTION 0 +# endif +# endif + +# if !defined(BOOST_MPL_HAS_XXX_NEEDS_TEMPLATE_SFINAE) +# if BOOST_WORKAROUND(BOOST_MSVC, <= 1400) +# define BOOST_MPL_HAS_XXX_NEEDS_TEMPLATE_SFINAE 1 +# else +# define BOOST_MPL_HAS_XXX_NEEDS_TEMPLATE_SFINAE 0 +# endif +# endif + +// NOTE: Many internal implementation macros take a Boost.Preprocessor +// array argument called args which is of the following form. +// ( 4, ( trait, name, max_arity, default_ ) ) + +# define BOOST_MPL_HAS_MEMBER_INTROSPECTION_NAME(args) \ + BOOST_PP_CAT(BOOST_PP_ARRAY_ELEM(0, args) , _introspect) \ + /**/ + +# define BOOST_MPL_HAS_MEMBER_INTROSPECTION_SUBSTITUTE_NAME(args, n) \ + BOOST_PP_CAT(BOOST_PP_CAT(BOOST_PP_ARRAY_ELEM(0, args) , _substitute), n) \ + /**/ + +# define BOOST_MPL_HAS_MEMBER_INTROSPECTION_TEST_NAME(args) \ + BOOST_PP_CAT(BOOST_PP_ARRAY_ELEM(0, args) , _test) \ + /**/ + +// Thanks to Guillaume Melquiond for pointing out the need for the +// "substitute" template as an argument to the overloaded test +// functions to get SFINAE to work for member templates with the +// correct name but different number of arguments. +# define BOOST_MPL_HAS_MEMBER_MULTI_SUBSTITUTE(z, n, args) \ + template< \ + template< BOOST_PP_ENUM_PARAMS(BOOST_PP_INC(n), typename V) > class V \ + > \ + struct BOOST_MPL_HAS_MEMBER_INTROSPECTION_SUBSTITUTE_NAME(args, n) { \ + }; \ + /**/ + +# define BOOST_MPL_HAS_MEMBER_SUBSTITUTE(args, substitute_macro) \ + BOOST_PP_REPEAT( \ + BOOST_PP_ARRAY_ELEM(2, args) \ + , BOOST_MPL_HAS_MEMBER_MULTI_SUBSTITUTE \ + , args \ + ) \ + /**/ + +# if !BOOST_MPL_HAS_XXX_NO_EXPLICIT_TEST_FUNCTION +# define BOOST_MPL_HAS_MEMBER_REJECT(args, member_macro) \ + template< typename V > \ + static boost::mpl::aux::no_tag \ + BOOST_MPL_HAS_MEMBER_INTROSPECTION_TEST_NAME(args)(...); \ + /**/ +# else +# define BOOST_MPL_HAS_MEMBER_REJECT(args, member_macro) \ + static boost::mpl::aux::no_tag \ + BOOST_MPL_HAS_MEMBER_INTROSPECTION_TEST_NAME(args)(...); \ + /**/ +# endif + +# if !BOOST_MPL_HAS_XXX_NO_WRAPPED_TYPES +# define BOOST_MPL_HAS_MEMBER_MULTI_ACCEPT(z, n, args) \ + template< typename V > \ + static boost::mpl::aux::yes_tag \ + BOOST_MPL_HAS_MEMBER_INTROSPECTION_TEST_NAME(args)( \ + boost::mpl::aux::type_wrapper< V > const volatile* \ + , BOOST_MPL_HAS_MEMBER_INTROSPECTION_SUBSTITUTE_NAME(args, n) < \ + V::template BOOST_PP_ARRAY_ELEM(1, args) \ + >* = 0 \ + ); \ + /**/ +# define BOOST_MPL_HAS_MEMBER_ACCEPT(args, member_macro) \ + BOOST_PP_REPEAT( \ + BOOST_PP_ARRAY_ELEM(2, args) \ + , BOOST_MPL_HAS_MEMBER_MULTI_ACCEPT \ + , args \ + ) \ + /**/ +# else +# define BOOST_MPL_HAS_MEMBER_ACCEPT(args, member_macro) \ + template< typename V > \ + static boost::mpl::aux::yes_tag \ + BOOST_MPL_HAS_MEMBER_INTROSPECTION_TEST_NAME(args)( \ + V const volatile* \ + , member_macro(args, V, T)* = 0 \ + ); \ + /**/ +# endif + +# if !BOOST_MPL_HAS_XXX_NO_EXPLICIT_TEST_FUNCTION +# define BOOST_MPL_HAS_MEMBER_TEST(args) \ + sizeof(BOOST_MPL_HAS_MEMBER_INTROSPECTION_TEST_NAME(args)< U >(0)) \ + == sizeof(boost::mpl::aux::yes_tag) \ + /**/ +# else +# if !BOOST_MPL_HAS_XXX_NO_WRAPPED_TYPES +# define BOOST_MPL_HAS_MEMBER_TEST(args) \ + sizeof( \ + BOOST_MPL_HAS_MEMBER_INTROSPECTION_TEST_NAME(args)( \ + static_cast< boost::mpl::aux::type_wrapper< U >* >(0) \ + ) \ + ) == sizeof(boost::mpl::aux::yes_tag) \ + /**/ +# else +# define BOOST_MPL_HAS_MEMBER_TEST(args) \ + sizeof( \ + BOOST_MPL_HAS_MEMBER_INTROSPECTION_TEST_NAME(args)( \ + static_cast< U* >(0) \ + ) \ + ) == sizeof(boost::mpl::aux::yes_tag) \ + /**/ +# endif +# endif + +# define BOOST_MPL_HAS_MEMBER_INTROSPECT( \ + args, substitute_macro, member_macro \ + ) \ + template< typename U > \ + struct BOOST_MPL_HAS_MEMBER_INTROSPECTION_NAME(args) { \ + BOOST_MPL_HAS_MEMBER_SUBSTITUTE(args, substitute_macro) \ + BOOST_MPL_HAS_MEMBER_REJECT(args, member_macro) \ + BOOST_MPL_HAS_MEMBER_ACCEPT(args, member_macro) \ + BOOST_STATIC_CONSTANT( \ + bool, value = BOOST_MPL_HAS_MEMBER_TEST(args) \ + ); \ + typedef boost::mpl::bool_< value > type; \ + }; \ + /**/ + +# define BOOST_MPL_HAS_MEMBER_IMPLEMENTATION( \ + args, introspect_macro, substitute_macro, member_macro \ + ) \ + template< \ + typename T \ + , typename fallback_ \ + = boost::mpl::bool_< BOOST_PP_ARRAY_ELEM(3, args) > \ + > \ + class BOOST_PP_ARRAY_ELEM(0, args) { \ + introspect_macro(args, substitute_macro, member_macro) \ + public: \ + static const bool value \ + = BOOST_MPL_HAS_MEMBER_INTROSPECTION_NAME(args)< T >::value; \ + typedef typename BOOST_MPL_HAS_MEMBER_INTROSPECTION_NAME(args)< \ + T \ + >::type type; \ + }; \ + /**/ + +// BOOST_MPL_HAS_MEMBER_WITH_FUNCTION_SFINAE expands to the full +// implementation of the function-based metafunction. Compile with -E +// to see the preprocessor output for this macro. +# define BOOST_MPL_HAS_MEMBER_WITH_FUNCTION_SFINAE( \ + args, substitute_macro, member_macro \ + ) \ + BOOST_MPL_HAS_MEMBER_IMPLEMENTATION( \ + args \ + , BOOST_MPL_HAS_MEMBER_INTROSPECT \ + , substitute_macro \ + , member_macro \ + ) \ + /**/ + +# if BOOST_MPL_HAS_XXX_NEEDS_TEMPLATE_SFINAE + +# if !defined(BOOST_MPL_HAS_XXX_NEEDS_NAMESPACE_LEVEL_SUBSTITUTE) +# if BOOST_WORKAROUND(BOOST_MSVC, <= 1400) +# define BOOST_MPL_HAS_XXX_NEEDS_NAMESPACE_LEVEL_SUBSTITUTE 1 +# endif +# endif + +# if !BOOST_MPL_HAS_XXX_NEEDS_NAMESPACE_LEVEL_SUBSTITUTE +# define BOOST_MPL_HAS_MEMBER_INTROSPECTION_SUBSTITUTE_NAME_WITH_TEMPLATE_SFINAE( \ + args, n \ + ) \ + BOOST_MPL_HAS_MEMBER_INTROSPECTION_SUBSTITUTE_NAME(args, n) \ + /**/ +# else +# define BOOST_MPL_HAS_MEMBER_INTROSPECTION_SUBSTITUTE_NAME_WITH_TEMPLATE_SFINAE( \ + args, n \ + ) \ + BOOST_PP_CAT( \ + boost_mpl_has_xxx_ \ + , BOOST_MPL_HAS_MEMBER_INTROSPECTION_SUBSTITUTE_NAME(args, n) \ + ) \ + /**/ +# endif + +# define BOOST_MPL_HAS_MEMBER_INTROSPECTION_SUBSTITUTE_TAG_NAME( \ + args \ + ) \ + BOOST_PP_CAT( \ + BOOST_MPL_HAS_MEMBER_INTROSPECTION_SUBSTITUTE_NAME_WITH_TEMPLATE_SFINAE( \ + args, 0 \ + ) \ + , _tag \ + ) \ + /**/ + +# define BOOST_MPL_HAS_MEMBER_MULTI_SUBSTITUTE_WITH_TEMPLATE_SFINAE( \ + z, n, args \ + ) \ + template< \ + template< BOOST_PP_ENUM_PARAMS(BOOST_PP_INC(n), typename U) > class U \ + > \ + struct BOOST_MPL_HAS_MEMBER_INTROSPECTION_SUBSTITUTE_NAME_WITH_TEMPLATE_SFINAE( \ + args, n \ + ) { \ + typedef \ + BOOST_MPL_HAS_MEMBER_INTROSPECTION_SUBSTITUTE_TAG_NAME(args) \ + type; \ + }; \ + /**/ + +# define BOOST_MPL_HAS_MEMBER_SUBSTITUTE_WITH_TEMPLATE_SFINAE( \ + args, substitute_macro \ + ) \ + typedef void \ + BOOST_MPL_HAS_MEMBER_INTROSPECTION_SUBSTITUTE_TAG_NAME(args); \ + BOOST_PP_REPEAT( \ + BOOST_PP_ARRAY_ELEM(2, args) \ + , BOOST_MPL_HAS_MEMBER_MULTI_SUBSTITUTE_WITH_TEMPLATE_SFINAE \ + , args \ + ) \ + /**/ + +# define BOOST_MPL_HAS_MEMBER_REJECT_WITH_TEMPLATE_SFINAE( \ + args, member_macro \ + ) \ + template< \ + typename U \ + , typename V \ + = BOOST_MPL_HAS_MEMBER_INTROSPECTION_SUBSTITUTE_TAG_NAME(args) \ + > \ + struct BOOST_MPL_HAS_MEMBER_INTROSPECTION_TEST_NAME(args) { \ + BOOST_STATIC_CONSTANT(bool, value = false); \ + typedef boost::mpl::bool_< value > type; \ + }; \ + /**/ + +# define BOOST_MPL_HAS_MEMBER_MULTI_ACCEPT_WITH_TEMPLATE_SFINAE( \ + z, n, args \ + ) \ + template< typename U > \ + struct BOOST_MPL_HAS_MEMBER_INTROSPECTION_TEST_NAME(args)< \ + U \ + , typename \ + BOOST_MPL_HAS_MEMBER_INTROSPECTION_SUBSTITUTE_NAME_WITH_TEMPLATE_SFINAE( \ + args, n \ + )< \ + BOOST_MSVC_TYPENAME U::BOOST_PP_ARRAY_ELEM(1, args)< > \ + >::type \ + > { \ + BOOST_STATIC_CONSTANT(bool, value = true); \ + typedef boost::mpl::bool_< value > type; \ + }; \ + /**/ + +# define BOOST_MPL_HAS_MEMBER_ACCEPT_WITH_TEMPLATE_SFINAE( \ + args, member_macro \ + ) \ + BOOST_PP_REPEAT( \ + BOOST_PP_ARRAY_ELEM(2, args) \ + , BOOST_MPL_HAS_MEMBER_MULTI_ACCEPT_WITH_TEMPLATE_SFINAE \ + , args \ + ) \ + /**/ + +# define BOOST_MPL_HAS_MEMBER_INTROSPECT_WITH_TEMPLATE_SFINAE( \ + args, substitute_macro, member_macro \ + ) \ + BOOST_MPL_HAS_MEMBER_REJECT_WITH_TEMPLATE_SFINAE(args, member_macro) \ + BOOST_MPL_HAS_MEMBER_ACCEPT_WITH_TEMPLATE_SFINAE(args, member_macro) \ + template< typename U > \ + struct BOOST_MPL_HAS_MEMBER_INTROSPECTION_NAME(args) \ + : BOOST_MPL_HAS_MEMBER_INTROSPECTION_TEST_NAME(args)< U > { \ + }; \ + /**/ + +// BOOST_MPL_HAS_MEMBER_WITH_TEMPLATE_SFINAE expands to the full +// implementation of the template-based metafunction. Compile with -E +// to see the preprocessor output for this macro. +// +// Note that if BOOST_MPL_HAS_XXX_NEEDS_NAMESPACE_LEVEL_SUBSTITUTE is +// defined BOOST_MPL_HAS_MEMBER_SUBSTITUTE_WITH_TEMPLATE_SFINAE needs +// to be expanded at namespace level before +// BOOST_MPL_HAS_MEMBER_WITH_TEMPLATE_SFINAE can be used. +# define BOOST_MPL_HAS_MEMBER_WITH_TEMPLATE_SFINAE( \ + args, substitute_macro, member_macro \ + ) \ + BOOST_MPL_HAS_MEMBER_SUBSTITUTE_WITH_TEMPLATE_SFINAE( \ + args, substitute_macro \ + ) \ + BOOST_MPL_HAS_MEMBER_IMPLEMENTATION( \ + args \ + , BOOST_MPL_HAS_MEMBER_INTROSPECT_WITH_TEMPLATE_SFINAE \ + , substitute_macro \ + , member_macro \ + ) \ + /**/ + +# endif // BOOST_MPL_HAS_XXX_NEEDS_TEMPLATE_SFINAE + +// Note: In the current implementation the parameter and access macros +// are no longer expanded. +# if !BOOST_WORKAROUND(BOOST_MSVC, <= 1400) +# define BOOST_MPL_HAS_XXX_TEMPLATE_NAMED_DEF(trait, name, default_) \ + BOOST_MPL_HAS_MEMBER_WITH_FUNCTION_SFINAE( \ + ( 4, ( trait, name, BOOST_MPL_LIMIT_METAFUNCTION_ARITY, default_ ) ) \ + , BOOST_MPL_HAS_MEMBER_TEMPLATE_SUBSTITUTE_PARAMETER \ + , BOOST_MPL_HAS_MEMBER_TEMPLATE_ACCESS \ + ) \ + /**/ +# else +# define BOOST_MPL_HAS_XXX_TEMPLATE_NAMED_DEF(trait, name, default_) \ + BOOST_MPL_HAS_MEMBER_WITH_TEMPLATE_SFINAE( \ + ( 4, ( trait, name, BOOST_MPL_LIMIT_METAFUNCTION_ARITY, default_ ) ) \ + , BOOST_MPL_HAS_MEMBER_TEMPLATE_SUBSTITUTE_PARAMETER \ + , BOOST_MPL_HAS_MEMBER_TEMPLATE_ACCESS \ + ) \ + /**/ +# endif + +#else // BOOST_MPL_CFG_NO_HAS_XXX_TEMPLATE + +// placeholder implementation + +# define BOOST_MPL_HAS_XXX_TEMPLATE_NAMED_DEF(trait, name, default_) \ + template< typename T \ + , typename fallback_ = boost::mpl::bool_< default_ > > \ + struct trait { \ + BOOST_STATIC_CONSTANT(bool, value = fallback_::value); \ + typedef fallback_ type; \ + }; \ + /**/ + +#endif // BOOST_MPL_CFG_NO_HAS_XXX_TEMPLATE + +# define BOOST_MPL_HAS_XXX_TEMPLATE_DEF(name) \ + BOOST_MPL_HAS_XXX_TEMPLATE_NAMED_DEF( \ + BOOST_PP_CAT(has_, name), name, false \ + ) \ + /**/ + +#endif // BOOST_MPL_HAS_XXX_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/mpl/identity.hpp b/realsense-file/3rd_party/boost/boost/mpl/identity.hpp new file mode 100644 index 0000000000..8241b91425 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/identity.hpp @@ -0,0 +1,45 @@ + +#ifndef BOOST_MPL_IDENTITY_HPP_INCLUDED +#define BOOST_MPL_IDENTITY_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Id$ +// $Date$ +// $Revision$ + +#include +#include + +namespace boost { namespace mpl { + +template< + typename BOOST_MPL_AUX_NA_PARAM(T) + > +struct identity +{ + typedef T type; + BOOST_MPL_AUX_LAMBDA_SUPPORT(1, identity, (T)) +}; + +template< + typename BOOST_MPL_AUX_NA_PARAM(T) + > +struct make_identity +{ + typedef identity type; + BOOST_MPL_AUX_LAMBDA_SUPPORT(1, make_identity, (T)) +}; + +BOOST_MPL_AUX_NA_SPEC_NO_ETI(1, identity) +BOOST_MPL_AUX_NA_SPEC_NO_ETI(1, make_identity) + +}} + +#endif // BOOST_MPL_IDENTITY_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/mpl/if.hpp b/realsense-file/3rd_party/boost/boost/mpl/if.hpp new file mode 100644 index 0000000000..bb09f179b1 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/if.hpp @@ -0,0 +1,135 @@ + +#ifndef BOOST_MPL_IF_HPP_INCLUDED +#define BOOST_MPL_IF_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Id$ +// $Date$ +// $Revision$ + +#include +#include +#include +#include +#include +#include +#include + +namespace boost { namespace mpl { + +#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) + +template< + bool C + , typename T1 + , typename T2 + > +struct if_c +{ + typedef T1 type; +}; + +template< + typename T1 + , typename T2 + > +struct if_c +{ + typedef T2 type; +}; + +// agurt, 05/sep/04: nondescriptive parameter names for the sake of DigitalMars +// (and possibly MWCW < 8.0); see http://article.gmane.org/gmane.comp.lib.boost.devel/108959 +template< + typename BOOST_MPL_AUX_NA_PARAM(T1) + , typename BOOST_MPL_AUX_NA_PARAM(T2) + , typename BOOST_MPL_AUX_NA_PARAM(T3) + > +struct if_ +{ + private: + // agurt, 02/jan/03: two-step 'type' definition for the sake of aCC + typedef if_c< +#if defined(BOOST_MPL_CFG_BCC_INTEGRAL_CONSTANTS) + BOOST_MPL_AUX_VALUE_WKND(T1)::value +#else + BOOST_MPL_AUX_STATIC_CAST(bool, BOOST_MPL_AUX_VALUE_WKND(T1)::value) +#endif + , T2 + , T3 + > almost_type_; + + public: + typedef typename almost_type_::type type; + + BOOST_MPL_AUX_LAMBDA_SUPPORT(3,if_,(T1,T2,T3)) +}; + +#else + +// no partial class template specialization + +namespace aux { + +template< bool C > +struct if_impl +{ + template< typename T1, typename T2 > struct result_ + { + typedef T1 type; + }; +}; + +template<> +struct if_impl +{ + template< typename T1, typename T2 > struct result_ + { + typedef T2 type; + }; +}; + +} // namespace aux + +template< + bool C_ + , typename T1 + , typename T2 + > +struct if_c +{ + typedef typename aux::if_impl< C_ > + ::template result_::type type; +}; + +// (almost) copy & paste in order to save one more +// recursively nested template instantiation to user +template< + typename BOOST_MPL_AUX_NA_PARAM(C_) + , typename BOOST_MPL_AUX_NA_PARAM(T1) + , typename BOOST_MPL_AUX_NA_PARAM(T2) + > +struct if_ +{ + enum { msvc_wknd_ = BOOST_MPL_AUX_MSVC_VALUE_WKND(C_)::value }; + + typedef typename aux::if_impl< BOOST_MPL_AUX_STATIC_CAST(bool, msvc_wknd_) > + ::template result_::type type; + + BOOST_MPL_AUX_LAMBDA_SUPPORT(3,if_,(C_,T1,T2)) +}; + +#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +BOOST_MPL_AUX_NA_SPEC(3, if_) + +}} + +#endif // BOOST_MPL_IF_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/mpl/int.hpp b/realsense-file/3rd_party/boost/boost/mpl/int.hpp new file mode 100644 index 0000000000..bb76374277 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/int.hpp @@ -0,0 +1,22 @@ + +#ifndef BOOST_MPL_INT_HPP_INCLUDED +#define BOOST_MPL_INT_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Id$ +// $Date$ +// $Revision$ + +#include "int_fwd.hpp" + +#define AUX_WRAPPER_VALUE_TYPE int +#include "aux_/integral_wrapper.hpp" + +#endif // BOOST_MPL_INT_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/mpl/int_fwd.hpp b/realsense-file/3rd_party/boost/boost/mpl/int_fwd.hpp new file mode 100644 index 0000000000..ad8c23f69f --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/int_fwd.hpp @@ -0,0 +1,27 @@ + +#ifndef BOOST_MPL_INT_FWD_HPP_INCLUDED +#define BOOST_MPL_INT_FWD_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Id$ +// $Date$ +// $Revision$ + +#include "aux_/adl_barrier.hpp" +#include "aux_/nttp_decl.hpp" + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN + +template< BOOST_MPL_AUX_NTTP_DECL(int, N) > struct int_; + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE +BOOST_MPL_AUX_ADL_BARRIER_DECL(int_) + +#endif // BOOST_MPL_INT_FWD_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/mpl/integral_c.hpp b/realsense-file/3rd_party/boost/boost/mpl/integral_c.hpp new file mode 100644 index 0000000000..2a9b378723 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/integral_c.hpp @@ -0,0 +1,51 @@ + +#ifndef BOOST_MPL_INTEGRAL_C_HPP_INCLUDED +#define BOOST_MPL_INTEGRAL_C_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2006 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Id$ +// $Date$ +// $Revision$ + +#include +#include +#include +#include + +#if BOOST_WORKAROUND(__HP_aCC, <= 53800) +// the type of non-type template arguments may not depend on template arguments +# define AUX_WRAPPER_PARAMS(N) typename T, long N +#else +# define AUX_WRAPPER_PARAMS(N) typename T, T N +#endif + +#define AUX_WRAPPER_NAME integral_c +#define AUX_WRAPPER_VALUE_TYPE T +#define AUX_WRAPPER_INST(value) AUX_WRAPPER_NAME< T, value > +#include + + +#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \ + && !BOOST_WORKAROUND(__BORLANDC__, <= 0x551) +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +// 'bool' constant doesn't have 'next'/'prior' members +template< bool C > +struct integral_c +{ + BOOST_STATIC_CONSTANT(bool, value = C); + typedef integral_c_tag tag; + typedef integral_c type; + typedef bool value_type; + operator bool() const { return this->value; } +}; +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE +#endif + +#endif // BOOST_MPL_INTEGRAL_C_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/mpl/integral_c_fwd.hpp b/realsense-file/3rd_party/boost/boost/mpl/integral_c_fwd.hpp new file mode 100644 index 0000000000..0ad7971c14 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/integral_c_fwd.hpp @@ -0,0 +1,32 @@ + +#ifndef BOOST_MPL_INTEGRAL_C_FWD_HPP_INCLUDED +#define BOOST_MPL_INTEGRAL_C_FWD_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2006 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Id$ +// $Date$ +// $Revision$ + +#include +#include + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN + +#if BOOST_WORKAROUND(__HP_aCC, <= 53800) +// the type of non-type template arguments may not depend on template arguments +template< typename T, long N > struct integral_c; +#else +template< typename T, T N > struct integral_c; +#endif + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE +BOOST_MPL_AUX_ADL_BARRIER_DECL(integral_c) + +#endif // BOOST_MPL_INTEGRAL_C_FWD_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/mpl/integral_c_tag.hpp b/realsense-file/3rd_party/boost/boost/mpl/integral_c_tag.hpp new file mode 100644 index 0000000000..5afe2495c3 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/integral_c_tag.hpp @@ -0,0 +1,26 @@ + +#ifndef BOOST_MPL_INTEGRAL_C_TAG_HPP_INCLUDED +#define BOOST_MPL_INTEGRAL_C_TAG_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Id$ +// $Date$ +// $Revision$ + + +#include "aux_/adl_barrier.hpp" +#include "aux_/config/static_constant.hpp" + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +struct integral_c_tag { BOOST_STATIC_CONSTANT(int, value = 0); }; +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE +BOOST_MPL_AUX_ADL_BARRIER_DECL(integral_c_tag) + +#endif // BOOST_MPL_INTEGRAL_C_TAG_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/mpl/lambda.hpp b/realsense-file/3rd_party/boost/boost/mpl/lambda.hpp new file mode 100644 index 0000000000..d71788d40b --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/lambda.hpp @@ -0,0 +1,29 @@ + +#ifndef BOOST_MPL_LAMBDA_HPP_INCLUDED +#define BOOST_MPL_LAMBDA_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Id$ +// $Date$ +// $Revision$ + +#include +//#include +#include + +#if !defined(BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT) +# include +#else +# include +# include +# define BOOST_MPL_CFG_NO_IMPLICIT_METAFUNCTIONS +#endif + +#endif // BOOST_MPL_LAMBDA_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/mpl/lambda_fwd.hpp b/realsense-file/3rd_party/boost/boost/mpl/lambda_fwd.hpp new file mode 100644 index 0000000000..fde3cc43ae --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/lambda_fwd.hpp @@ -0,0 +1,57 @@ + +#ifndef BOOST_MPL_LAMBDA_FWD_HPP_INCLUDED +#define BOOST_MPL_LAMBDA_FWD_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Id$ +// $Date$ +// $Revision$ + +#include +#include +#include + +#if !defined(BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT) + +# include +# include +# include + +namespace boost { namespace mpl { + +template< + typename T = na + , typename Tag = void_ + BOOST_MPL_AUX_LAMBDA_ARITY_PARAM( + typename Arity = int_< aux::template_arity::value > + ) + > +struct lambda; + +}} + +#else // BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT + +# include + +namespace boost { namespace mpl { + +template< + typename T = na + , typename Tag = void_ + , typename Protect = true_ + > +struct lambda; + +}} + +#endif + +#endif // BOOST_MPL_LAMBDA_FWD_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/mpl/limits/arity.hpp b/realsense-file/3rd_party/boost/boost/mpl/limits/arity.hpp new file mode 100644 index 0000000000..7e56f4b3a3 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/limits/arity.hpp @@ -0,0 +1,21 @@ + +#ifndef BOOST_MPL_LIMITS_ARITY_HPP_INCLUDED +#define BOOST_MPL_LIMITS_ARITY_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Id$ +// $Date$ +// $Revision$ + +#if !defined(BOOST_MPL_LIMIT_METAFUNCTION_ARITY) +# define BOOST_MPL_LIMIT_METAFUNCTION_ARITY 5 +#endif + +#endif // BOOST_MPL_LIMITS_ARITY_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/mpl/logical.hpp b/realsense-file/3rd_party/boost/boost/mpl/logical.hpp new file mode 100644 index 0000000000..2f6154a2e1 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/logical.hpp @@ -0,0 +1,21 @@ + +#ifndef BOOST_MPL_LOGICAL_HPP_INCLUDED +#define BOOST_MPL_LOGICAL_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Id$ +// $Date$ +// $Revision$ + +#include +#include +#include + +#endif // BOOST_MPL_LOGICAL_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/mpl/not.hpp b/realsense-file/3rd_party/boost/boost/mpl/not.hpp new file mode 100644 index 0000000000..70753ba25c --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/not.hpp @@ -0,0 +1,51 @@ + +#ifndef BOOST_MPL_NOT_HPP_INCLUDED +#define BOOST_MPL_NOT_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Id$ +// $Date$ +// $Revision$ + +#include +#include +#include +#include +#include + +namespace boost { namespace mpl { + +namespace aux { + +template< BOOST_MPL_AUX_NTTP_DECL(long, C_) > // 'long' is intentional here +struct not_impl + : bool_ +{ +}; + +} // namespace aux + + +template< + typename BOOST_MPL_AUX_NA_PARAM(T) + > +struct not_ + : aux::not_impl< + BOOST_MPL_AUX_NESTED_TYPE_WKND(T)::value + > +{ + BOOST_MPL_AUX_LAMBDA_SUPPORT(1,not_,(T)) +}; + +BOOST_MPL_AUX_NA_SPEC(1,not_) + +}} + +#endif // BOOST_MPL_NOT_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/mpl/or.hpp b/realsense-file/3rd_party/boost/boost/mpl/or.hpp new file mode 100644 index 0000000000..9434f93055 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/or.hpp @@ -0,0 +1,61 @@ + +#ifndef BOOST_MPL_OR_HPP_INCLUDED +#define BOOST_MPL_OR_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Id$ +// $Date$ +// $Revision$ + +#include + +#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) + +# include +# include +# include +# include +# include + +// agurt, 19/may/04: workaround a conflict with header's +// 'or' and 'and' macros, see http://tinyurl.com/3et69; 'defined(or)' +// has to be checked in a separate condition, otherwise GCC complains +// about 'or' being an alternative token +#if defined(_MSC_VER) && !defined(__clang__) +#ifndef __GCCXML__ +#if defined(or) +# pragma push_macro("or") +# undef or +# define or(x) +#endif +#endif +#endif + +# define BOOST_MPL_PREPROCESSED_HEADER or.hpp +# include + +#if defined(_MSC_VER) && !defined(__clang__) +#ifndef __GCCXML__ +#if defined(or) +# pragma pop_macro("or") +#endif +#endif +#endif + +#else + +# define AUX778076_OP_NAME or_ +# define AUX778076_OP_VALUE1 true +# define AUX778076_OP_VALUE2 false +# include + +#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS +#endif // BOOST_MPL_OR_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/mpl/placeholders.hpp b/realsense-file/3rd_party/boost/boost/mpl/placeholders.hpp new file mode 100644 index 0000000000..7fa699bf4e --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/placeholders.hpp @@ -0,0 +1,100 @@ + +#if !defined(BOOST_PP_IS_ITERATING) + +///// header body + +#ifndef BOOST_MPL_PLACEHOLDERS_HPP_INCLUDED +#define BOOST_MPL_PLACEHOLDERS_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2001-2004 +// Copyright Peter Dimov 2001-2003 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Id$ +// $Date$ +// $Revision$ + + +#if !defined(BOOST_MPL_PREPROCESSING_MODE) +# include +# include + +# if !defined(BOOST_MPL_CFG_NO_ADL_BARRIER_NAMESPACE) +# define BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(type) \ + using ::BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::type; \ + /**/ +# else +# define BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(type) /**/ +# endif + +#endif + +#include + +#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) + +# define BOOST_MPL_PREPROCESSED_HEADER placeholders.hpp +# include + +#else + +# include +# include +# include +# include + +// watch out for GNU gettext users, who #define _(x) +#if !defined(_) || defined(BOOST_MPL_CFG_NO_UNNAMED_PLACEHOLDER_SUPPORT) +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN +typedef arg<-1> _; +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE + +namespace boost { namespace mpl { + +BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_) + +namespace placeholders { +using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_; +} + +}} +#endif + +/// agurt, 17/mar/02: one more placeholder for the last 'apply#' +/// specialization +#define BOOST_PP_ITERATION_PARAMS_1 \ + (3,(1, BOOST_MPL_LIMIT_METAFUNCTION_ARITY + 1, )) +#include BOOST_PP_ITERATE() + +#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS +#endif // BOOST_MPL_PLACEHOLDERS_HPP_INCLUDED + +///// iteration + +#else +#define i_ BOOST_PP_FRAME_ITERATION(1) + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN + +typedef arg BOOST_PP_CAT(_,i_); + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE + +namespace boost { namespace mpl { + +BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(BOOST_PP_CAT(_,i_)) + +namespace placeholders { +using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::BOOST_PP_CAT(_,i_); +} + +}} + +#undef i_ +#endif // BOOST_PP_IS_ITERATING diff --git a/realsense-file/3rd_party/boost/boost/mpl/protect.hpp b/realsense-file/3rd_party/boost/boost/mpl/protect.hpp new file mode 100644 index 0000000000..cc292a867c --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/protect.hpp @@ -0,0 +1,55 @@ + +#ifndef BOOST_MPL_PROTECT_HPP_INCLUDED +#define BOOST_MPL_PROTECT_HPP_INCLUDED + +// Copyright Peter Dimov 2001 +// Copyright Aleksey Gurtovoy 2002-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Id$ +// $Date$ +// $Revision$ + +#include +#include +#include +#include + +namespace boost { namespace mpl { + +template< + typename BOOST_MPL_AUX_NA_PARAM(T) + , int not_le_ = 0 + > +struct protect : T +{ +#if BOOST_WORKAROUND(__EDG_VERSION__, == 238) + typedef mpl::protect type; +#else + typedef protect type; +#endif +}; + +#if defined(BOOST_MPL_CFG_BROKEN_DEFAULT_PARAMETERS_IN_NESTED_TEMPLATES) +namespace aux { +template< BOOST_MPL_AUX_NTTP_DECL(int, N), typename T > +struct arity< protect, N > + : arity +{ +}; +} // namespace aux +#endif + +BOOST_MPL_AUX_NA_SPEC_MAIN(1, protect) +#if !defined(BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT) +BOOST_MPL_AUX_NA_SPEC_TEMPLATE_ARITY(1, 1, protect) +#endif + +}} + +#endif // BOOST_MPL_PROTECT_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/mpl/quote.hpp b/realsense-file/3rd_party/boost/boost/mpl/quote.hpp new file mode 100644 index 0000000000..dba5c1e4bf --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/quote.hpp @@ -0,0 +1,151 @@ + +#if !defined(BOOST_PP_IS_ITERATING) + +///// header body + +#ifndef BOOST_MPL_QUOTE_HPP_INCLUDED +#define BOOST_MPL_QUOTE_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2008 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Id$ +// $Date$ +// $Revision$ + +#if !defined(BOOST_MPL_PREPROCESSING_MODE) +# include +# include +#endif + +#include +#include + +#if defined(BOOST_MPL_CFG_NO_TEMPLATE_TEMPLATE_PARAMETERS) \ + && !defined(BOOST_MPL_CFG_BCC590_WORKAROUNDS) +# define BOOST_MPL_CFG_NO_QUOTE_TEMPLATE +#endif + +#if !defined(BOOST_MPL_CFG_NO_IMPLICIT_METAFUNCTIONS) \ + && defined(BOOST_MPL_CFG_NO_HAS_XXX) +# define BOOST_MPL_CFG_NO_IMPLICIT_METAFUNCTIONS +#endif + +#include + +#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ + && !defined(BOOST_MPL_PREPROCESSING_MODE) + +# define BOOST_MPL_PREPROCESSED_HEADER quote.hpp +# include + +#else + +# include +# include +# include +# include + +# include +# include + +#if !defined(BOOST_MPL_CFG_NO_QUOTE_TEMPLATE) + +namespace boost { namespace mpl { + +#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) + +template< typename T, bool has_type_ > +struct quote_impl +// GCC has a problem with metafunction forwarding when T is a +// specialization of a template called 'type'. +# if BOOST_WORKAROUND(__GNUC__, BOOST_TESTED_AT(4)) \ + && BOOST_WORKAROUND(__GNUC_MINOR__, BOOST_TESTED_AT(0)) \ + && BOOST_WORKAROUND(__GNUC_PATCHLEVEL__, BOOST_TESTED_AT(2)) +{ + typedef typename T::type type; +}; +# else + : T +{ +}; +# endif + +template< typename T > +struct quote_impl +{ + typedef T type; +}; + +#else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +template< bool > struct quote_impl +{ + template< typename T > struct result_ + : T + { + }; +}; + +template<> struct quote_impl +{ + template< typename T > struct result_ + { + typedef T type; + }; +}; + +#endif + +#define BOOST_PP_ITERATION_PARAMS_1 \ + (3,(1, BOOST_MPL_LIMIT_METAFUNCTION_ARITY, )) +#include BOOST_PP_ITERATE() + +}} + +#endif // BOOST_MPL_CFG_NO_QUOTE_TEMPLATE + +#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS +#endif // BOOST_MPL_QUOTE_HPP_INCLUDED + +///// iteration + +#else +#define i_ BOOST_PP_FRAME_ITERATION(1) + +template< + template< BOOST_MPL_PP_PARAMS(i_, typename P) > class F + , typename Tag = void_ + > +struct BOOST_PP_CAT(quote,i_) +{ + template< BOOST_MPL_PP_PARAMS(i_, typename U) > struct apply +#if defined(BOOST_MPL_CFG_BCC590_WORKAROUNDS) + { + typedef typename quote_impl< + F< BOOST_MPL_PP_PARAMS(i_, U) > + , aux::has_type< F< BOOST_MPL_PP_PARAMS(i_, U) > >::value + >::type type; + }; +#elif !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) + : quote_impl< + F< BOOST_MPL_PP_PARAMS(i_, U) > + , aux::has_type< F< BOOST_MPL_PP_PARAMS(i_, U) > >::value + > + { + }; +#else + : quote_impl< aux::has_type< F< BOOST_MPL_PP_PARAMS(i_, U) > >::value > + ::template result_< F< BOOST_MPL_PP_PARAMS(i_, U) > > + { + }; +#endif +}; + +#undef i_ +#endif // BOOST_PP_IS_ITERATING diff --git a/realsense-file/3rd_party/boost/boost/mpl/size_t.hpp b/realsense-file/3rd_party/boost/boost/mpl/size_t.hpp new file mode 100644 index 0000000000..24af697987 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/size_t.hpp @@ -0,0 +1,25 @@ + +#ifndef BOOST_MPL_SIZE_T_HPP_INCLUDED +#define BOOST_MPL_SIZE_T_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Id$ +// $Date$ +// $Revision$ + +#include + +#define AUX_WRAPPER_VALUE_TYPE std::size_t +#define AUX_WRAPPER_NAME size_t +#define AUX_WRAPPER_PARAMS(N) std::size_t N + +#include + +#endif // BOOST_MPL_SIZE_T_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/mpl/size_t_fwd.hpp b/realsense-file/3rd_party/boost/boost/mpl/size_t_fwd.hpp new file mode 100644 index 0000000000..16542f786a --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/size_t_fwd.hpp @@ -0,0 +1,28 @@ + +#ifndef BOOST_MPL_SIZE_T_FWD_HPP_INCLUDED +#define BOOST_MPL_SIZE_T_FWD_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2000-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Id$ +// $Date$ +// $Revision$ + +#include +#include // make sure 'size_t' is placed into 'std' +#include + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN + +template< std::size_t N > struct size_t; + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE +BOOST_MPL_AUX_ADL_BARRIER_DECL(size_t) + +#endif // BOOST_MPL_SIZE_T_FWD_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/mpl/void.hpp b/realsense-file/3rd_party/boost/boost/mpl/void.hpp new file mode 100644 index 0000000000..05457e833b --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/void.hpp @@ -0,0 +1,76 @@ + +#ifndef BOOST_MPL_VOID_HPP_INCLUDED +#define BOOST_MPL_VOID_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Id$ +// $Date$ +// $Revision$ + +#include +#include +#include +#include +#include + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN + +// [JDG Feb-4-2003] made void_ a complete type to allow it to be +// instantiated so that it can be passed in as an object that can be +// used to select an overloaded function. Possible use includes signaling +// a zero arity functor evaluation call. +struct void_ { typedef void_ type; }; + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE + +namespace boost { namespace mpl { + +template< typename T > +struct is_void_ + : false_ +{ +#if BOOST_WORKAROUND(BOOST_MSVC, < 1300) + using false_::value; +#endif +}; + +template<> +struct is_void_ + : true_ +{ +#if BOOST_WORKAROUND(BOOST_MSVC, < 1300) + using true_::value; +#endif +}; + +template< typename T > +struct is_not_void_ + : true_ +{ +#if BOOST_WORKAROUND(BOOST_MSVC, < 1300) + using true_::value; +#endif +}; + +template<> +struct is_not_void_ + : false_ +{ +#if BOOST_WORKAROUND(BOOST_MSVC, < 1300) + using false_::value; +#endif +}; + +BOOST_MPL_AUX_NA_SPEC(1, is_void_) +BOOST_MPL_AUX_NA_SPEC(1, is_not_void_) + +}} + +#endif // BOOST_MPL_VOID_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/mpl/void_fwd.hpp b/realsense-file/3rd_party/boost/boost/mpl/void_fwd.hpp new file mode 100644 index 0000000000..c72ff641e0 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/mpl/void_fwd.hpp @@ -0,0 +1,26 @@ + +#ifndef BOOST_MPL_VOID_FWD_HPP_INCLUDED +#define BOOST_MPL_VOID_FWD_HPP_INCLUDED + +// Copyright Aleksey Gurtovoy 2001-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/mpl for documentation. + +// $Id$ +// $Date$ +// $Revision$ + +#include + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN + +struct void_; + +BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE +BOOST_MPL_AUX_ADL_BARRIER_DECL(void_) + +#endif // BOOST_MPL_VOID_FWD_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/next_prior.hpp b/realsense-file/3rd_party/boost/boost/next_prior.hpp new file mode 100644 index 0000000000..feb567a07c --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/next_prior.hpp @@ -0,0 +1,165 @@ +// Boost next_prior.hpp header file ---------------------------------------// + +// (C) Copyright Dave Abrahams and Daniel Walker 1999-2003. Distributed under the Boost +// Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org/libs/utility for documentation. + +// Revision History +// 13 Dec 2003 Added next(x, n) and prior(x, n) (Daniel Walker) + +#ifndef BOOST_NEXT_PRIOR_HPP_INCLUDED +#define BOOST_NEXT_PRIOR_HPP_INCLUDED + +#include +#if defined(_MSC_VER) && _MSC_VER <= 1310 +#include +#include +#endif +#include +#include +#include +#include +#include +#include +#include + +namespace boost { + +// Helper functions for classes like bidirectional iterators not supporting +// operator+ and operator- +// +// Usage: +// const std::list::iterator p = get_some_iterator(); +// const std::list::iterator prev = boost::prior(p); +// const std::list::iterator next = boost::next(prev, 2); + +// Contributed by Dave Abrahams + +namespace next_prior_detail { + +template< typename T, typename Distance, bool HasPlus = has_plus< T, Distance >::value > +struct next_impl2 +{ + static T call(T x, Distance n) + { + std::advance(x, n); + return x; + } +}; + +template< typename T, typename Distance > +struct next_impl2< T, Distance, true > +{ + static T call(T x, Distance n) + { + return x + n; + } +}; + + +template< typename T, typename Distance, bool HasPlusAssign = has_plus_assign< T, Distance >::value > +struct next_impl1 : + public next_impl2< T, Distance > +{ +}; + +template< typename T, typename Distance > +struct next_impl1< T, Distance, true > +{ + static T call(T x, Distance n) + { + x += n; + return x; + } +}; + + +template< + typename T, + typename Distance, + typename PromotedDistance = typename integral_promotion< Distance >::type, +#if !defined(_MSC_VER) || _MSC_VER > 1310 + bool IsUInt = is_unsigned< PromotedDistance >::value +#else + // MSVC 7.1 has problems with applying is_unsigned to non-integral types + bool IsUInt = mpl::and_< is_integral< PromotedDistance >, is_unsigned< PromotedDistance > >::value +#endif +> +struct prior_impl3 +{ + static T call(T x, Distance n) + { + std::advance(x, -n); + return x; + } +}; + +template< typename T, typename Distance, typename PromotedDistance > +struct prior_impl3< T, Distance, PromotedDistance, true > +{ + static T call(T x, Distance n) + { + typedef typename make_signed< PromotedDistance >::type signed_distance; + std::advance(x, -static_cast< signed_distance >(static_cast< PromotedDistance >(n))); + return x; + } +}; + + +template< typename T, typename Distance, bool HasMinus = has_minus< T, Distance >::value > +struct prior_impl2 : + public prior_impl3< T, Distance > +{ +}; + +template< typename T, typename Distance > +struct prior_impl2< T, Distance, true > +{ + static T call(T x, Distance n) + { + return x - n; + } +}; + + +template< typename T, typename Distance, bool HasMinusAssign = has_minus_assign< T, Distance >::value > +struct prior_impl1 : + public prior_impl2< T, Distance > +{ +}; + +template< typename T, typename Distance > +struct prior_impl1< T, Distance, true > +{ + static T call(T x, Distance n) + { + x -= n; + return x; + } +}; + +} // namespace next_prior_detail + +template +inline T next(T x) { return ++x; } + +template +inline T next(T x, Distance n) +{ + return next_prior_detail::next_impl1< T, Distance >::call(x, n); +} + +template +inline T prior(T x) { return --x; } + +template +inline T prior(T x, Distance n) +{ + return next_prior_detail::prior_impl1< T, Distance >::call(x, n); +} + +} // namespace boost + +#endif // BOOST_NEXT_PRIOR_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/noncopyable.hpp b/realsense-file/3rd_party/boost/boost/noncopyable.hpp new file mode 100644 index 0000000000..227bd4ace1 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/noncopyable.hpp @@ -0,0 +1,17 @@ +/* + * Copyright (c) 2014 Glen Fernandes + * + * 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_NONCOPYABLE_HPP +#define BOOST_NONCOPYABLE_HPP + +// The header file at this path is deprecated; +// use boost/core/noncopyable.hpp instead. + +#include + +#endif diff --git a/realsense-file/3rd_party/boost/boost/none.hpp b/realsense-file/3rd_party/boost/boost/none.hpp new file mode 100644 index 0000000000..57c086da59 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/none.hpp @@ -0,0 +1,53 @@ +// Copyright (C) 2003, Fernando Luis Cacciola Carballal. +// Copyright (C) 2014 Andrzej Krzemienski. +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/optional for documentation. +// +// You are welcome to contact the author at: +// fernando_cacciola@hotmail.com +// +#ifndef BOOST_NONE_17SEP2003_HPP +#define BOOST_NONE_17SEP2003_HPP + +#include "boost/none_t.hpp" + +// NOTE: Borland users have to include this header outside any precompiled headers +// (bcc<=5.64 cannot include instance data in a precompiled header) +// -- * To be verified, now that there's no unnamed namespace + +namespace boost { + +#ifdef BOOST_OPTIONAL_USE_OLD_DEFINITION_OF_NONE +none_t const none = (static_cast(0)) ; +#else + +namespace detail { namespace optional_detail { + + // the trick here is to make boost::none defined once as a global but in a header file + template + struct none_instance + { + static const T instance; + }; + + template + const T none_instance::instance = T(); // global, but because 'tis a template, no cpp file required + +} } // namespace detail::optional_detail + + +namespace { + // TU-local + const none_t& none = detail::optional_detail::none_instance::instance; +} + +#endif + +} // namespace boost + +#endif + diff --git a/realsense-file/3rd_party/boost/boost/none_t.hpp b/realsense-file/3rd_party/boost/boost/none_t.hpp new file mode 100644 index 0000000000..d6c701851e --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/none_t.hpp @@ -0,0 +1,28 @@ +// Copyright (C) 2003, Fernando Luis Cacciola Carballal. +// Copyright (C) 2014 Andrzej Krzemienski. +// +// Use, modification, and distribution is subject to the Boost Software +// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/optional for documentation. +// +// You are welcome to contact the author at: +// fernando_cacciola@hotmail.com +// +#ifndef BOOST_NONE_T_17SEP2003_HPP +#define BOOST_NONE_T_17SEP2003_HPP + +namespace boost { + +#ifdef BOOST_OPTIONAL_USE_OLD_DEFINITION_OF_NONE +namespace detail { struct none_helper{}; } +typedef int detail::none_helper::*none_t ; +#else +class none_t {}; +#endif + +} // namespace boost + +#endif + diff --git a/realsense-file/3rd_party/boost/boost/optional.hpp b/realsense-file/3rd_party/boost/boost/optional.hpp new file mode 100644 index 0000000000..849954ad56 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/optional.hpp @@ -0,0 +1,18 @@ +// Copyright (C) 2003, Fernando Luis Cacciola Carballal. +// +// Use, modification, and distribution is subject to the Boost Software +// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/optional for documentation. +// +// You are welcome to contact the author at: +// fernando_cacciola@hotmail.com +// +#ifndef BOOST_OPTIONAL_FLC_19NOV2002_HPP +#define BOOST_OPTIONAL_FLC_19NOV2002_HPP + +#include "boost/optional/optional.hpp" + +#endif + diff --git a/realsense-file/3rd_party/boost/boost/optional/bad_optional_access.hpp b/realsense-file/3rd_party/boost/boost/optional/bad_optional_access.hpp new file mode 100644 index 0000000000..bb1380f15e --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/optional/bad_optional_access.hpp @@ -0,0 +1,32 @@ +// Copyright (C) 2014, Andrzej Krzemienski. +// +// Use, modification, and distribution is subject to the Boost Software +// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/optional for documentation. +// +// You are welcome to contact the author at: +// akrzemi1@gmail.com +// +#ifndef BOOST_BAD_OPTIONAL_ACCESS_22MAY2014_HPP +#define BOOST_BAD_OPTIONAL_ACCESS_22MAY2014_HPP + +#include +#if __cplusplus < 201103L +#include // to make converting-ctor std::string(char const*) visible +#endif + +namespace boost { + +class bad_optional_access : public std::logic_error +{ +public: + bad_optional_access() + : std::logic_error("Attempted to access the value of an uninitialized optional object.") + {} +}; + +} // namespace boost + +#endif diff --git a/realsense-file/3rd_party/boost/boost/optional/optional.hpp b/realsense-file/3rd_party/boost/boost/optional/optional.hpp new file mode 100644 index 0000000000..4c161bd8a2 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/optional/optional.hpp @@ -0,0 +1,1537 @@ +// Copyright (C) 2003, 2008 Fernando Luis Cacciola Carballal. +// Copyright (C) 2014, 2015 Andrzej Krzemienski. +// +// Use, modification, and distribution is subject to the Boost Software +// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/optional for documentation. +// +// You are welcome to contact the author at: +// fernando_cacciola@hotmail.com +// +// Revisions: +// 27 Apr 2008 (improved swap) Fernando Cacciola, Niels Dekker, Thorsten Ottosen +// 05 May 2014 (Added move semantics) Andrzej Krzemienski +// +#ifndef BOOST_OPTIONAL_OPTIONAL_FLC_19NOV2002_HPP +#define BOOST_OPTIONAL_OPTIONAL_FLC_19NOV2002_HPP + +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + + +#include + +#if (defined BOOST_NO_CXX11_RVALUE_REFERENCES) || (defined BOOST_OPTIONAL_CONFIG_NO_RVALUE_REFERENCES) +#define BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES +#endif + +#if BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION,<=700) +// AFAICT only Intel 7 correctly resolves the overload set +// that includes the in-place factory taking functions, +// so for the other icc versions, in-place factory support +// is disabled +#define BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT +#endif + +#if BOOST_WORKAROUND(__BORLANDC__, <= 0x551) +// BCB (5.5.1) cannot parse the nested template struct in an inplace factory. +#define BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT +#endif + +#if !defined(BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT) \ + && BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x581) ) +// BCB (up to 5.64) has the following bug: +// If there is a member function/operator template of the form +// template mfunc( Expr expr ) ; +// some calls are resolved to this even if there are other better matches. +// The effect of this bug is that calls to converting ctors and assignments +// are incrorrectly sink to this general catch-all member function template as shown above. +#define BOOST_OPTIONAL_WEAK_OVERLOAD_RESOLUTION +#endif + +#if defined(__GNUC__) && !defined(__INTEL_COMPILER) +// GCC since 3.3 has may_alias attribute that helps to alleviate optimizer issues with +// regard to violation of the strict aliasing rules. The optional< T > storage type is marked +// with this attribute in order to let the compiler know that it will alias objects of type T +// and silence compilation warnings. +#define BOOST_OPTIONAL_DETAIL_USE_ATTRIBUTE_MAY_ALIAS +#endif + +// Daniel Wallin discovered that bind/apply.hpp badly interacts with the apply<> +// member template of a factory as used in the optional<> implementation. +// He proposed this simple fix which is to move the call to apply<> outside +// namespace boost. +namespace boost_optional_detail +{ + template + inline void construct(Factory const& factory, void* address) + { + factory.BOOST_NESTED_TEMPLATE apply(address); + } +} + + +namespace boost { + +class in_place_factory_base ; +class typed_in_place_factory_base ; + +// This forward is needed to refer to namespace scope swap from the member swap +template void swap ( optional& x, optional& y ); + +namespace optional_detail { +// This local class is used instead of that in "aligned_storage.hpp" +// because I've found the 'official' class to ICE BCB5.5 +// when some types are used with optional<> +// (due to sizeof() passed down as a non-type template parameter) +template +class aligned_storage +{ + // Borland ICEs if unnamed unions are used for this! + union + // This works around GCC warnings about breaking strict aliasing rules when casting storage address to T* +#if defined(BOOST_OPTIONAL_DETAIL_USE_ATTRIBUTE_MAY_ALIAS) + __attribute__((__may_alias__)) +#endif + dummy_u + { + char data[ sizeof(T) ]; + BOOST_DEDUCED_TYPENAME type_with_alignment< + ::boost::alignment_of::value >::type aligner_; + } dummy_ ; + + public: + +#if defined(BOOST_OPTIONAL_DETAIL_USE_ATTRIBUTE_MAY_ALIAS) + void const* address() const { return &dummy_; } + void * address() { return &dummy_; } +#else + void const* address() const { return dummy_.data; } + void * address() { return dummy_.data; } +#endif +} ; + +template +struct types_when_isnt_ref +{ + typedef T const& reference_const_type ; + typedef T & reference_type ; +#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES + typedef T && rval_reference_type ; + typedef T && reference_type_of_temporary_wrapper; +#ifdef BOOST_MOVE_OLD_RVALUE_REF_BINDING_RULES + // GCC 4.4 has support for an early draft of rvalue references. The conforming version below + // causes warnings about returning references to a temporary. + static T&& move(T&& r) { return r; } +#else + static rval_reference_type move(reference_type r) { return boost::move(r); } +#endif +#endif + typedef T const* pointer_const_type ; + typedef T * pointer_type ; + typedef T const& argument_type ; +} ; + +template +struct types_when_is_ref +{ + typedef BOOST_DEDUCED_TYPENAME remove_reference::type raw_type ; + + typedef raw_type& reference_const_type ; + typedef raw_type& reference_type ; +#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES + typedef BOOST_DEDUCED_TYPENAME remove_const::type&& rval_reference_type ; + typedef raw_type& reference_type_of_temporary_wrapper; + static reference_type move(reference_type r) { return r; } +#endif + typedef raw_type* pointer_const_type ; + typedef raw_type* pointer_type ; + typedef raw_type& argument_type ; +} ; + +template +void prevent_binding_rvalue_ref_to_optional_lvalue_ref() +{ +#ifndef BOOST_OPTIONAL_CONFIG_ALLOW_BINDING_TO_RVALUES + BOOST_STATIC_ASSERT_MSG( + !boost::is_lvalue_reference::value || !boost::is_rvalue_reference::value, + "binding rvalue references to optional lvalue references is disallowed"); +#endif +} + +struct optional_tag {} ; + +template +class optional_base : public optional_tag +{ + private : + + typedef +#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) + BOOST_DEDUCED_TYPENAME +#endif + ::boost::detail::make_reference_content::type internal_type ; + + typedef aligned_storage storage_type ; + + typedef types_when_isnt_ref types_when_not_ref ; + typedef types_when_is_ref types_when_ref ; + + typedef optional_base this_type ; + + protected : + + typedef T value_type ; + + typedef mpl::true_ is_reference_tag ; + typedef mpl::false_ is_not_reference_tag ; + + typedef BOOST_DEDUCED_TYPENAME is_reference::type is_reference_predicate ; + + public: + typedef BOOST_DEDUCED_TYPENAME mpl::if_::type types ; + + protected: + typedef BOOST_DEDUCED_TYPENAME types::reference_type reference_type ; + typedef BOOST_DEDUCED_TYPENAME types::reference_const_type reference_const_type ; +#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES + typedef BOOST_DEDUCED_TYPENAME types::rval_reference_type rval_reference_type ; + typedef BOOST_DEDUCED_TYPENAME types::reference_type_of_temporary_wrapper reference_type_of_temporary_wrapper ; +#endif + typedef BOOST_DEDUCED_TYPENAME types::pointer_type pointer_type ; + typedef BOOST_DEDUCED_TYPENAME types::pointer_const_type pointer_const_type ; + typedef BOOST_DEDUCED_TYPENAME types::argument_type argument_type ; + + // Creates an optional uninitialized. + // No-throw + optional_base() + : + m_initialized(false) {} + + // Creates an optional uninitialized. + // No-throw + optional_base ( none_t ) + : + m_initialized(false) {} + + // Creates an optional initialized with 'val'. + // Can throw if T::T(T const&) does + optional_base ( argument_type val ) + : + m_initialized(false) + { + construct(val); + } + +#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES + // move-construct an optional initialized from an rvalue-ref to 'val'. + // Can throw if T::T(T&&) does + optional_base ( rval_reference_type val ) + : + m_initialized(false) + { + construct( boost::move(val) ); + } +#endif + + // Creates an optional initialized with 'val' IFF cond is true, otherwise creates an uninitialzed optional. + // Can throw if T::T(T const&) does + optional_base ( bool cond, argument_type val ) + : + m_initialized(false) + { + if ( cond ) + construct(val); + } + + // Creates a deep copy of another optional + // Can throw if T::T(T const&) does + optional_base ( optional_base const& rhs ) + : + m_initialized(false) + { + if ( rhs.is_initialized() ) + construct(rhs.get_impl()); + } + +#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES + // Creates a deep move of another optional + // Can throw if T::T(T&&) does + optional_base ( optional_base&& rhs ) + : + m_initialized(false) + { + if ( rhs.is_initialized() ) + construct( boost::move(rhs.get_impl()) ); + } +#endif + +#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES + + template + explicit optional_base ( Expr&& expr, PtrExpr const* tag ) + : + m_initialized(false) + { + construct(boost::forward(expr),tag); + } + +#else + // This is used for both converting and in-place constructions. + // Derived classes use the 'tag' to select the appropriate + // implementation (the correct 'construct()' overload) + template + explicit optional_base ( Expr const& expr, Expr const* tag ) + : + m_initialized(false) + { + construct(expr,tag); + } + +#endif + + + // No-throw (assuming T::~T() doesn't) + ~optional_base() { destroy() ; } + + // Assigns from another optional (deep-copies the rhs value) + void assign ( optional_base const& rhs ) + { + if (is_initialized()) + { + if ( rhs.is_initialized() ) + assign_value(rhs.get_impl(), is_reference_predicate() ); + else destroy(); + } + else + { + if ( rhs.is_initialized() ) + construct(rhs.get_impl()); + } + } + +#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES + // Assigns from another optional (deep-moves the rhs value) + void assign ( optional_base&& rhs ) + { + if (is_initialized()) + { + if ( rhs.is_initialized() ) + assign_value(boost::move(rhs.get_impl()), is_reference_predicate() ); + else destroy(); + } + else + { + if ( rhs.is_initialized() ) + construct(boost::move(rhs.get_impl())); + } + } +#endif + + // Assigns from another _convertible_ optional (deep-copies the rhs value) + template + void assign ( optional const& rhs ) + { + if (is_initialized()) + { + if ( rhs.is_initialized() ) +#ifndef BOOST_OPTIONAL_CONFIG_RESTORE_ASSIGNMENT_OF_NONCONVERTIBLE_TYPES + assign_value(rhs.get(), is_reference_predicate() ); +#else + assign_value(static_cast(rhs.get()), is_reference_predicate() ); +#endif + + else destroy(); + } + else + { + if ( rhs.is_initialized() ) +#ifndef BOOST_OPTIONAL_CONFIG_RESTORE_ASSIGNMENT_OF_NONCONVERTIBLE_TYPES + construct(rhs.get()); +#else + construct(static_cast(rhs.get())); +#endif + } + } + +#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES + // move-assigns from another _convertible_ optional (deep-moves from the rhs value) + template + void assign ( optional&& rhs ) + { + typedef BOOST_DEDUCED_TYPENAME optional::rval_reference_type ref_type; + if (is_initialized()) + { + if ( rhs.is_initialized() ) + assign_value(static_cast(rhs.get()), is_reference_predicate() ); + else destroy(); + } + else + { + if ( rhs.is_initialized() ) + construct(static_cast(rhs.get())); + } + } +#endif + + // Assigns from a T (deep-copies the rhs value) + void assign ( argument_type val ) + { + if (is_initialized()) + assign_value(val, is_reference_predicate() ); + else construct(val); + } + +#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES + // Assigns from a T (deep-moves the rhs value) + void assign ( rval_reference_type val ) + { + if (is_initialized()) + assign_value( boost::move(val), is_reference_predicate() ); + else construct( boost::move(val) ); + } +#endif + + // Assigns from "none", destroying the current value, if any, leaving this UNINITIALIZED + // No-throw (assuming T::~T() doesn't) + void assign ( none_t ) BOOST_NOEXCEPT { destroy(); } + +#ifndef BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT + +#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES + template + void assign_expr ( Expr&& expr, ExprPtr const* tag ) + { + if (is_initialized()) + assign_expr_to_initialized(boost::forward(expr),tag); + else construct(boost::forward(expr),tag); + } +#else + template + void assign_expr ( Expr const& expr, Expr const* tag ) + { + if (is_initialized()) + assign_expr_to_initialized(expr,tag); + else construct(expr,tag); + } +#endif + +#endif + + public : + + // **DEPPRECATED** Destroys the current value, if any, leaving this UNINITIALIZED + // No-throw (assuming T::~T() doesn't) + void reset() BOOST_NOEXCEPT { destroy(); } + + // **DEPPRECATED** Replaces the current value -if any- with 'val' + void reset ( argument_type val ) { assign(val); } + + // Returns a pointer to the value if this is initialized, otherwise, + // returns NULL. + // No-throw + pointer_const_type get_ptr() const { return m_initialized ? get_ptr_impl() : 0 ; } + pointer_type get_ptr() { return m_initialized ? get_ptr_impl() : 0 ; } + + bool is_initialized() const { return m_initialized ; } + + protected : + + void construct ( argument_type val ) + { + ::new (m_storage.address()) internal_type(val) ; + m_initialized = true ; + } + +#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES + void construct ( rval_reference_type val ) + { + ::new (m_storage.address()) internal_type( types::move(val) ) ; + m_initialized = true ; + } +#endif + + +#if (!defined BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES) && (!defined BOOST_NO_CXX11_VARIADIC_TEMPLATES) + // Constructs in-place + // upon exception *this is always uninitialized + template + void emplace_assign ( Args&&... args ) + { + destroy(); + ::new (m_storage.address()) internal_type( boost::forward(args)... ); + m_initialized = true ; + } +#elif (!defined BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES) + template + void emplace_assign ( Arg&& arg ) + { + destroy(); + ::new (m_storage.address()) internal_type( boost::forward(arg) ); + m_initialized = true ; + } +#else + template + void emplace_assign ( const Arg& arg ) + { + destroy(); + ::new (m_storage.address()) internal_type( arg ); + m_initialized = true ; + } + + template + void emplace_assign ( Arg& arg ) + { + destroy(); + ::new (m_storage.address()) internal_type( arg ); + m_initialized = true ; + } +#endif + +#ifndef BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT + +#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES + // Constructs in-place using the given factory + template + void construct ( Expr&& factory, in_place_factory_base const* ) + { + BOOST_STATIC_ASSERT ( ::boost::mpl::not_::value ) ; + boost_optional_detail::construct(factory, m_storage.address()); + m_initialized = true ; + } + + // Constructs in-place using the given typed factory + template + void construct ( Expr&& factory, typed_in_place_factory_base const* ) + { + BOOST_STATIC_ASSERT ( ::boost::mpl::not_::value ) ; + factory.apply(m_storage.address()) ; + m_initialized = true ; + } + + template + void assign_expr_to_initialized ( Expr&& factory, in_place_factory_base const* tag ) + { + destroy(); + construct(factory,tag); + } + + // Constructs in-place using the given typed factory + template + void assign_expr_to_initialized ( Expr&& factory, typed_in_place_factory_base const* tag ) + { + destroy(); + construct(factory,tag); + } + +#else + // Constructs in-place using the given factory + template + void construct ( Expr const& factory, in_place_factory_base const* ) + { + BOOST_STATIC_ASSERT ( ::boost::mpl::not_::value ) ; + boost_optional_detail::construct(factory, m_storage.address()); + m_initialized = true ; + } + + // Constructs in-place using the given typed factory + template + void construct ( Expr const& factory, typed_in_place_factory_base const* ) + { + BOOST_STATIC_ASSERT ( ::boost::mpl::not_::value ) ; + factory.apply(m_storage.address()) ; + m_initialized = true ; + } + + template + void assign_expr_to_initialized ( Expr const& factory, in_place_factory_base const* tag ) + { + destroy(); + construct(factory,tag); + } + + // Constructs in-place using the given typed factory + template + void assign_expr_to_initialized ( Expr const& factory, typed_in_place_factory_base const* tag ) + { + destroy(); + construct(factory,tag); + } +#endif + +#endif + +#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES + // Constructs using any expression implicitly convertible to the single argument + // of a one-argument T constructor. + // Converting constructions of optional from optional uses this function with + // 'Expr' being of type 'U' and relying on a converting constructor of T from U. + template + void construct ( Expr&& expr, void const* ) + { + new (m_storage.address()) internal_type(boost::forward(expr)) ; + m_initialized = true ; + } + + // Assigns using a form any expression implicitly convertible to the single argument + // of a T's assignment operator. + // Converting assignments of optional from optional uses this function with + // 'Expr' being of type 'U' and relying on a converting assignment of T from U. + template + void assign_expr_to_initialized ( Expr&& expr, void const* ) + { + assign_value(boost::forward(expr), is_reference_predicate()); + } +#else + // Constructs using any expression implicitly convertible to the single argument + // of a one-argument T constructor. + // Converting constructions of optional from optional uses this function with + // 'Expr' being of type 'U' and relying on a converting constructor of T from U. + template + void construct ( Expr const& expr, void const* ) + { + new (m_storage.address()) internal_type(expr) ; + m_initialized = true ; + } + + // Assigns using a form any expression implicitly convertible to the single argument + // of a T's assignment operator. + // Converting assignments of optional from optional uses this function with + // 'Expr' being of type 'U' and relying on a converting assignment of T from U. + template + void assign_expr_to_initialized ( Expr const& expr, void const* ) + { + assign_value(expr, is_reference_predicate()); + } + +#endif + +#ifdef BOOST_OPTIONAL_WEAK_OVERLOAD_RESOLUTION + // BCB5.64 (and probably lower versions) workaround. + // The in-place factories are supported by means of catch-all constructors + // and assignment operators (the functions are parameterized in terms of + // an arbitrary 'Expr' type) + // This compiler incorrectly resolves the overload set and sinks optional and optional + // to the 'Expr'-taking functions even though explicit overloads are present for them. + // Thus, the following overload is needed to properly handle the case when the 'lhs' + // is another optional. + // + // For VC<=70 compilers this workaround dosen't work becasue the comnpiler issues and error + // instead of choosing the wrong overload + // +#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES + // Notice that 'Expr' will be optional or optional (but not optional_base<..>) + template + void construct ( Expr&& expr, optional_tag const* ) + { + if ( expr.is_initialized() ) + { + // An exception can be thrown here. + // It it happens, THIS will be left uninitialized. + new (m_storage.address()) internal_type(types::move(expr.get())) ; + m_initialized = true ; + } + } +#else + // Notice that 'Expr' will be optional or optional (but not optional_base<..>) + template + void construct ( Expr const& expr, optional_tag const* ) + { + if ( expr.is_initialized() ) + { + // An exception can be thrown here. + // It it happens, THIS will be left uninitialized. + new (m_storage.address()) internal_type(expr.get()) ; + m_initialized = true ; + } + } +#endif +#endif // defined BOOST_OPTIONAL_WEAK_OVERLOAD_RESOLUTION + + void assign_value ( argument_type val, is_not_reference_tag ) { get_impl() = val; } + void assign_value ( argument_type val, is_reference_tag ) { construct(val); } +#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES + void assign_value ( rval_reference_type val, is_not_reference_tag ) { get_impl() = static_cast(val); } + void assign_value ( rval_reference_type val, is_reference_tag ) { construct( static_cast(val) ); } +#endif + + void destroy() + { + if ( m_initialized ) + destroy_impl(is_reference_predicate()) ; + } + + reference_const_type get_impl() const { return dereference(get_object(), is_reference_predicate() ) ; } + reference_type get_impl() { return dereference(get_object(), is_reference_predicate() ) ; } + + pointer_const_type get_ptr_impl() const { return cast_ptr(get_object(), is_reference_predicate() ) ; } + pointer_type get_ptr_impl() { return cast_ptr(get_object(), is_reference_predicate() ) ; } + + private : + + // internal_type can be either T or reference_content +#if defined(BOOST_OPTIONAL_DETAIL_USE_ATTRIBUTE_MAY_ALIAS) + // This workaround is supposed to silence GCC warnings about broken strict aliasing rules + internal_type const* get_object() const + { + union { void const* ap_pvoid; internal_type const* as_ptype; } caster = { m_storage.address() }; + return caster.as_ptype; + } + internal_type * get_object() + { + union { void* ap_pvoid; internal_type* as_ptype; } caster = { m_storage.address() }; + return caster.as_ptype; + } +#else + internal_type const* get_object() const { return static_cast(m_storage.address()); } + internal_type * get_object() { return static_cast (m_storage.address()); } +#endif + + // reference_content lacks an implicit conversion to T&, so the following is needed to obtain a proper reference. + reference_const_type dereference( internal_type const* p, is_not_reference_tag ) const { return *p ; } + reference_type dereference( internal_type* p, is_not_reference_tag ) { return *p ; } + reference_const_type dereference( internal_type const* p, is_reference_tag ) const { return p->get() ; } + reference_type dereference( internal_type* p, is_reference_tag ) { return p->get() ; } + +#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x581)) + void destroy_impl ( is_not_reference_tag ) { get_ptr_impl()->internal_type::~internal_type() ; m_initialized = false ; } +#else + void destroy_impl ( is_not_reference_tag ) { get_ptr_impl()->~T() ; m_initialized = false ; } +#endif + + void destroy_impl ( is_reference_tag ) { m_initialized = false ; } + + // If T is of reference type, trying to get a pointer to the held value must result in a compile-time error. + // Decent compilers should disallow conversions from reference_content* to T*, but just in case, + // the following olverloads are used to filter out the case and guarantee an error in case of T being a reference. + pointer_const_type cast_ptr( internal_type const* p, is_not_reference_tag ) const { return p ; } + pointer_type cast_ptr( internal_type * p, is_not_reference_tag ) { return p ; } + pointer_const_type cast_ptr( internal_type const* p, is_reference_tag ) const { return &p->get() ; } + pointer_type cast_ptr( internal_type * p, is_reference_tag ) { return &p->get() ; } + + bool m_initialized ; + storage_type m_storage ; +} ; + +} // namespace optional_detail + +template +class optional : public optional_detail::optional_base +{ + typedef optional_detail::optional_base base ; + + public : + + typedef optional this_type ; + + typedef BOOST_DEDUCED_TYPENAME base::value_type value_type ; + typedef BOOST_DEDUCED_TYPENAME base::reference_type reference_type ; + typedef BOOST_DEDUCED_TYPENAME base::reference_const_type reference_const_type ; +#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES + typedef BOOST_DEDUCED_TYPENAME base::rval_reference_type rval_reference_type ; + typedef BOOST_DEDUCED_TYPENAME base::reference_type_of_temporary_wrapper reference_type_of_temporary_wrapper ; +#endif + typedef BOOST_DEDUCED_TYPENAME base::pointer_type pointer_type ; + typedef BOOST_DEDUCED_TYPENAME base::pointer_const_type pointer_const_type ; + typedef BOOST_DEDUCED_TYPENAME base::argument_type argument_type ; + + // Creates an optional uninitialized. + // No-throw + optional() BOOST_NOEXCEPT : base() {} + + // Creates an optional uninitialized. + // No-throw + optional( none_t none_ ) BOOST_NOEXCEPT : base(none_) {} + + // Creates an optional initialized with 'val'. + // Can throw if T::T(T const&) does + optional ( argument_type val ) : base(val) {} + +#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES + // Creates an optional initialized with 'move(val)'. + // Can throw if T::T(T &&) does + optional ( rval_reference_type val ) : base( boost::forward(val) ) + {optional_detail::prevent_binding_rvalue_ref_to_optional_lvalue_ref();} +#endif + + // Creates an optional initialized with 'val' IFF cond is true, otherwise creates an uninitialized optional. + // Can throw if T::T(T const&) does + optional ( bool cond, argument_type val ) : base(cond,val) {} + + // NOTE: MSVC needs templated versions first + + // Creates a deep copy of another convertible optional + // Requires a valid conversion from U to T. + // Can throw if T::T(U const&) does + template + explicit optional ( optional const& rhs ) + : + base() + { + if ( rhs.is_initialized() ) + this->construct(rhs.get()); + } + +#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES + // Creates a deep move of another convertible optional + // Requires a valid conversion from U to T. + // Can throw if T::T(U&&) does + template + explicit optional ( optional && rhs ) + : + base() + { + if ( rhs.is_initialized() ) + this->construct( boost::move(rhs.get()) ); + } +#endif + +#ifndef BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT + // Creates an optional with an expression which can be either + // (a) An instance of InPlaceFactory (i.e. in_place(a,b,...,n); + // (b) An instance of TypedInPlaceFactory ( i.e. in_place(a,b,...,n); + // (c) Any expression implicitly convertible to the single type + // of a one-argument T's constructor. + // (d*) Weak compilers (BCB) might also resolved Expr as optional and optional + // even though explicit overloads are present for these. + // Depending on the above some T ctor is called. + // Can throw if the resolved T ctor throws. +#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES + + + template + explicit optional ( Expr&& expr, + BOOST_DEDUCED_TYPENAME boost::disable_if_c< + (boost::is_base_of::type>::value) || + boost::is_same::type, none_t>::value >::type* = 0 + ) + : base(boost::forward(expr),boost::addressof(expr)) + {optional_detail::prevent_binding_rvalue_ref_to_optional_lvalue_ref();} + +#else + template + explicit optional ( Expr const& expr ) : base(expr,boost::addressof(expr)) {} +#endif // !defined BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES +#endif // !defined BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT + + // Creates a deep copy of another optional + // Can throw if T::T(T const&) does + optional ( optional const& rhs ) : base( static_cast(rhs) ) {} + +#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES + // Creates a deep move of another optional + // Can throw if T::T(T&&) does + optional ( optional && rhs ) + BOOST_NOEXCEPT_IF(::boost::is_nothrow_move_constructible::value) + : base( boost::move(rhs) ) + {} + +#endif + // No-throw (assuming T::~T() doesn't) + ~optional() {} + +#if !defined(BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT) && !defined(BOOST_OPTIONAL_WEAK_OVERLOAD_RESOLUTION) + // Assigns from an expression. See corresponding constructor. + // Basic Guarantee: If the resolved T ctor throws, this is left UNINITIALIZED +#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES + + template + BOOST_DEDUCED_TYPENAME boost::disable_if_c< + boost::is_base_of::type>::value || + boost::is_same::type, none_t>::value, + optional& + >::type + operator= ( Expr&& expr ) + { + optional_detail::prevent_binding_rvalue_ref_to_optional_lvalue_ref(); + this->assign_expr(boost::forward(expr),boost::addressof(expr)); + return *this ; + } + +#else + template + optional& operator= ( Expr const& expr ) + { + this->assign_expr(expr,boost::addressof(expr)); + return *this ; + } +#endif // !defined BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES +#endif // !defined(BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT) && !defined(BOOST_OPTIONAL_WEAK_OVERLOAD_RESOLUTION) + + // Copy-assigns from another convertible optional (converts && deep-copies the rhs value) + // Requires a valid conversion from U to T. + // Basic Guarantee: If T::T( U const& ) throws, this is left UNINITIALIZED + template + optional& operator= ( optional const& rhs ) + { + this->assign(rhs); + return *this ; + } + +#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES + // Move-assigns from another convertible optional (converts && deep-moves the rhs value) + // Requires a valid conversion from U to T. + // Basic Guarantee: If T::T( U && ) throws, this is left UNINITIALIZED + template + optional& operator= ( optional && rhs ) + { + this->assign(boost::move(rhs)); + return *this ; + } +#endif + + // Assigns from another optional (deep-copies the rhs value) + // Basic Guarantee: If T::T( T const& ) throws, this is left UNINITIALIZED + // (NOTE: On BCB, this operator is not actually called and left is left UNMODIFIED in case of a throw) + optional& operator= ( optional const& rhs ) + { + this->assign( static_cast(rhs) ) ; + return *this ; + } + +#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES + // Assigns from another optional (deep-moves the rhs value) + optional& operator= ( optional && rhs ) + BOOST_NOEXCEPT_IF(::boost::is_nothrow_move_constructible::value && ::boost::is_nothrow_move_assignable::value) + { + this->assign( static_cast(rhs) ) ; + return *this ; + } +#endif + + // Assigns from a T (deep-copies the rhs value) + // Basic Guarantee: If T::( T const& ) throws, this is left UNINITIALIZED + optional& operator= ( argument_type val ) + { + this->assign( val ) ; + return *this ; + } + +#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES + // Assigns from a T (deep-moves the rhs value) + optional& operator= ( rval_reference_type val ) + { + optional_detail::prevent_binding_rvalue_ref_to_optional_lvalue_ref(); + this->assign( boost::move(val) ) ; + return *this ; + } +#endif + + // Assigns from a "none" + // Which destroys the current value, if any, leaving this UNINITIALIZED + // No-throw (assuming T::~T() doesn't) + optional& operator= ( none_t none_ ) BOOST_NOEXCEPT + { + this->assign( none_ ) ; + return *this ; + } + +#if (!defined BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES) && (!defined BOOST_NO_CXX11_VARIADIC_TEMPLATES) + // Constructs in-place + // upon exception *this is always uninitialized + template + void emplace ( Args&&... args ) + { + this->emplace_assign( boost::forward(args)... ); + } +#elif (!defined BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES) + template + void emplace ( Arg&& arg ) + { + this->emplace_assign( boost::forward(arg) ); + } +#else + template + void emplace ( const Arg& arg ) + { + this->emplace_assign( arg ); + } + + template + void emplace ( Arg& arg ) + { + this->emplace_assign( arg ); + } +#endif + + void swap( optional & arg ) + BOOST_NOEXCEPT_IF(::boost::is_nothrow_move_constructible::value && ::boost::is_nothrow_move_assignable::value) + { + // allow for Koenig lookup + boost::swap(*this, arg); + } + + + // Returns a reference to the value if this is initialized, otherwise, + // the behaviour is UNDEFINED + // No-throw + reference_const_type get() const { BOOST_ASSERT(this->is_initialized()) ; return this->get_impl(); } + reference_type get() { BOOST_ASSERT(this->is_initialized()) ; return this->get_impl(); } + + // Returns a copy of the value if this is initialized, 'v' otherwise + reference_const_type get_value_or ( reference_const_type v ) const { return this->is_initialized() ? get() : v ; } + reference_type get_value_or ( reference_type v ) { return this->is_initialized() ? get() : v ; } + + // Returns a pointer to the value if this is initialized, otherwise, + // the behaviour is UNDEFINED + // No-throw + pointer_const_type operator->() const { BOOST_ASSERT(this->is_initialized()) ; return this->get_ptr_impl() ; } + pointer_type operator->() { BOOST_ASSERT(this->is_initialized()) ; return this->get_ptr_impl() ; } + + // Returns a reference to the value if this is initialized, otherwise, + // the behaviour is UNDEFINED + // No-throw +#if (!defined BOOST_NO_CXX11_REF_QUALIFIERS) && (!defined BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES) + reference_const_type operator *() const& { return this->get() ; } + reference_type operator *() & { return this->get() ; } + reference_type_of_temporary_wrapper operator *() && { return base::types::move(this->get()) ; } +#else + reference_const_type operator *() const { return this->get() ; } + reference_type operator *() { return this->get() ; } +#endif // !defined BOOST_NO_CXX11_REF_QUALIFIERS + +#if (!defined BOOST_NO_CXX11_REF_QUALIFIERS) && (!defined BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES) + reference_const_type value() const& + { + if (this->is_initialized()) + return this->get() ; + else + throw_exception(bad_optional_access()); + } + + reference_type value() & + { + if (this->is_initialized()) + return this->get() ; + else + throw_exception(bad_optional_access()); + } + + reference_type_of_temporary_wrapper value() && + { + if (this->is_initialized()) + return base::types::move(this->get()) ; + else + throw_exception(bad_optional_access()); + } + +#else + reference_const_type value() const + { + if (this->is_initialized()) + return this->get() ; + else + throw_exception(bad_optional_access()); + } + + reference_type value() + { + if (this->is_initialized()) + return this->get() ; + else + throw_exception(bad_optional_access()); + } +#endif + + +#ifndef BOOST_NO_CXX11_REF_QUALIFIERS + template + value_type value_or ( U&& v ) const& + { + if (this->is_initialized()) + return get(); + else + return boost::forward(v); + } + + template + value_type value_or ( U&& v ) && + { + if (this->is_initialized()) + return base::types::move(get()); + else + return boost::forward(v); + } +#elif !defined BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES + template + value_type value_or ( U&& v ) const + { + if (this->is_initialized()) + return get(); + else + return boost::forward(v); + } +#else + template + value_type value_or ( U const& v ) const + { + if (this->is_initialized()) + return get(); + else + return v; + } + + template + value_type value_or ( U& v ) const + { + if (this->is_initialized()) + return get(); + else + return v; + } +#endif + + +#ifndef BOOST_NO_CXX11_REF_QUALIFIERS + template + value_type value_or_eval ( F f ) const& + { + if (this->is_initialized()) + return get(); + else + return f(); + } + + template + value_type value_or_eval ( F f ) && + { + if (this->is_initialized()) + return base::types::move(get()); + else + return f(); + } +#else + template + value_type value_or_eval ( F f ) const + { + if (this->is_initialized()) + return get(); + else + return f(); + } +#endif + + bool operator!() const BOOST_NOEXCEPT { return !this->is_initialized() ; } + + BOOST_EXPLICIT_OPERATOR_BOOL_NOEXCEPT() +} ; + +#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES +template +class optional +{ + BOOST_STATIC_ASSERT_MSG(sizeof(T) == 0, "Optional rvalue references are illegal."); +} ; +#endif + +// Returns optional(v) +template +inline +optional make_optional ( T const& v ) +{ + return optional(v); +} + +// Returns optional(cond,v) +template +inline +optional make_optional ( bool cond, T const& v ) +{ + return optional(cond,v); +} + +// Returns a reference to the value if this is initialized, otherwise, the behaviour is UNDEFINED. +// No-throw +template +inline +BOOST_DEDUCED_TYPENAME optional::reference_const_type +get ( optional const& opt ) +{ + return opt.get() ; +} + +template +inline +BOOST_DEDUCED_TYPENAME optional::reference_type +get ( optional& opt ) +{ + return opt.get() ; +} + +// Returns a pointer to the value if this is initialized, otherwise, returns NULL. +// No-throw +template +inline +BOOST_DEDUCED_TYPENAME optional::pointer_const_type +get ( optional const* opt ) +{ + return opt->get_ptr() ; +} + +template +inline +BOOST_DEDUCED_TYPENAME optional::pointer_type +get ( optional* opt ) +{ + return opt->get_ptr() ; +} + +// Returns a reference to the value if this is initialized, otherwise, the behaviour is UNDEFINED. +// No-throw +template +inline +BOOST_DEDUCED_TYPENAME optional::reference_const_type +get_optional_value_or ( optional const& opt, BOOST_DEDUCED_TYPENAME optional::reference_const_type v ) +{ + return opt.get_value_or(v) ; +} + +template +inline +BOOST_DEDUCED_TYPENAME optional::reference_type +get_optional_value_or ( optional& opt, BOOST_DEDUCED_TYPENAME optional::reference_type v ) +{ + return opt.get_value_or(v) ; +} + +// Returns a pointer to the value if this is initialized, otherwise, returns NULL. +// No-throw +template +inline +BOOST_DEDUCED_TYPENAME optional::pointer_const_type +get_pointer ( optional const& opt ) +{ + return opt.get_ptr() ; +} + +template +inline +BOOST_DEDUCED_TYPENAME optional::pointer_type +get_pointer ( optional& opt ) +{ + return opt.get_ptr() ; +} + +// The following declaration prevents a bug where operator safe-bool is used upon streaming optional object if you forget the IO header. +template +std::basic_ostream& +operator<<(std::basic_ostream& out, optional_detail::optional_tag const& v) +{ + BOOST_STATIC_ASSERT_MSG(sizeof(CharType) == 0, "If you want to output boost::optional, include header "); +} + +// optional's relational operators ( ==, !=, <, >, <=, >= ) have deep-semantics (compare values). +// WARNING: This is UNLIKE pointers. Use equal_pointees()/less_pointess() in generic code instead. + + +// +// optional vs optional cases +// + +template +inline +bool operator == ( optional const& x, optional const& y ) +{ return equal_pointees(x,y); } + +template +inline +bool operator < ( optional const& x, optional const& y ) +{ return less_pointees(x,y); } + +template +inline +bool operator != ( optional const& x, optional const& y ) +{ return !( x == y ) ; } + +template +inline +bool operator > ( optional const& x, optional const& y ) +{ return y < x ; } + +template +inline +bool operator <= ( optional const& x, optional const& y ) +{ return !( y < x ) ; } + +template +inline +bool operator >= ( optional const& x, optional const& y ) +{ return !( x < y ) ; } + + +// +// optional vs T cases +// +template +inline +bool operator == ( optional const& x, T const& y ) +{ return equal_pointees(x, optional(y)); } + +template +inline +bool operator < ( optional const& x, T const& y ) +{ return less_pointees(x, optional(y)); } + +template +inline +bool operator != ( optional const& x, T const& y ) +{ return !( x == y ) ; } + +template +inline +bool operator > ( optional const& x, T const& y ) +{ return y < x ; } + +template +inline +bool operator <= ( optional const& x, T const& y ) +{ return !( y < x ) ; } + +template +inline +bool operator >= ( optional const& x, T const& y ) +{ return !( x < y ) ; } + +// +// T vs optional cases +// + +template +inline +bool operator == ( T const& x, optional const& y ) +{ return equal_pointees( optional(x), y ); } + +template +inline +bool operator < ( T const& x, optional const& y ) +{ return less_pointees( optional(x), y ); } + +template +inline +bool operator != ( T const& x, optional const& y ) +{ return !( x == y ) ; } + +template +inline +bool operator > ( T const& x, optional const& y ) +{ return y < x ; } + +template +inline +bool operator <= ( T const& x, optional const& y ) +{ return !( y < x ) ; } + +template +inline +bool operator >= ( T const& x, optional const& y ) +{ return !( x < y ) ; } + + +// +// optional vs none cases +// + +template +inline +bool operator == ( optional const& x, none_t ) BOOST_NOEXCEPT +{ return !x; } + +template +inline +bool operator < ( optional const& x, none_t ) +{ return less_pointees(x,optional() ); } + +template +inline +bool operator != ( optional const& x, none_t ) BOOST_NOEXCEPT +{ return bool(x); } + +template +inline +bool operator > ( optional const& x, none_t y ) +{ return y < x ; } + +template +inline +bool operator <= ( optional const& x, none_t y ) +{ return !( y < x ) ; } + +template +inline +bool operator >= ( optional const& x, none_t y ) +{ return !( x < y ) ; } + +// +// none vs optional cases +// + +template +inline +bool operator == ( none_t , optional const& y ) BOOST_NOEXCEPT +{ return !y; } + +template +inline +bool operator < ( none_t , optional const& y ) +{ return less_pointees(optional() ,y); } + +template +inline +bool operator != ( none_t, optional const& y ) BOOST_NOEXCEPT +{ return bool(y); } + +template +inline +bool operator > ( none_t x, optional const& y ) +{ return y < x ; } + +template +inline +bool operator <= ( none_t x, optional const& y ) +{ return !( y < x ) ; } + +template +inline +bool operator >= ( none_t x, optional const& y ) +{ return !( x < y ) ; } + +namespace optional_detail { + +template struct swap_selector; + +template<> +struct swap_selector +{ + template + static void optional_swap ( optional& x, optional& y ) + { + const bool hasX = !!x; + const bool hasY = !!y; + + if ( !hasX && !hasY ) + return; + + if( !hasX ) + x = boost::in_place(); + else if ( !hasY ) + y = boost::in_place(); + + // Boost.Utility.Swap will take care of ADL and workarounds for broken compilers + boost::swap(x.get(),y.get()); + + if( !hasX ) + y = boost::none ; + else if( !hasY ) + x = boost::none ; + } +}; + +#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES +template<> +struct swap_selector +{ + template + static void optional_swap ( optional& x, optional& y ) + //BOOST_NOEXCEPT_IF(::boost::is_nothrow_move_constructible::value && BOOST_NOEXCEPT_EXPR(boost::swap(*x, *y))) + { + if(x) + { + if (y) + { + boost::swap(*x, *y); + } + else + { + y = boost::move(*x); + x = boost::none; + } + } + else + { + if (y) + { + x = boost::move(*y); + y = boost::none; + } + } + } +}; +#else +template<> +struct swap_selector +{ + template + static void optional_swap ( optional& x, optional& y ) + { + const bool hasX = !!x; + const bool hasY = !!y; + + if ( !hasX && hasY ) + { + x = y.get(); + y = boost::none ; + } + else if ( hasX && !hasY ) + { + y = x.get(); + x = boost::none ; + } + else if ( hasX && hasY ) + { + // Boost.Utility.Swap will take care of ADL and workarounds for broken compilers + boost::swap(x.get(),y.get()); + } + } +}; +#endif // !defined BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES + +} // namespace optional_detail + +template +struct optional_swap_should_use_default_constructor : has_nothrow_default_constructor {} ; + +template inline void swap ( optional& x, optional& y ) + //BOOST_NOEXCEPT_IF(::boost::is_nothrow_move_constructible::value && BOOST_NOEXCEPT_EXPR(boost::swap(*x, *y))) +{ + optional_detail::swap_selector::value>::optional_swap(x, y); +} + +} // namespace boost + +#endif diff --git a/realsense-file/3rd_party/boost/boost/optional/optional_fwd.hpp b/realsense-file/3rd_party/boost/boost/optional/optional_fwd.hpp new file mode 100644 index 0000000000..9b2d74cb35 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/optional/optional_fwd.hpp @@ -0,0 +1,30 @@ +// Copyright (C) 2003, 2008 Fernando Luis Cacciola Carballal. +// +// Use, modification, and distribution is subject to the Boost Software +// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/optional for documentation. +// +// You are welcome to contact the author at: +// fernando_cacciola@hotmail.com +// +// Revisions: +// 10 May 2008 (added swap related forward declaration) Niels Dekker +// +#ifndef BOOST_OPTIONAL_OPTIONAL_FWD_FLC_19NOV2002_HPP +#define BOOST_OPTIONAL_OPTIONAL_FWD_FLC_19NOV2002_HPP + + +namespace boost { + +template class optional ; + +template void swap ( optional& , optional& ); + +template struct optional_swap_should_use_default_constructor ; + +} // namespace boost + +#endif + diff --git a/realsense-file/3rd_party/boost/boost/preprocessor/arithmetic/add.hpp b/realsense-file/3rd_party/boost/boost/preprocessor/arithmetic/add.hpp new file mode 100644 index 0000000000..e6866ed466 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/preprocessor/arithmetic/add.hpp @@ -0,0 +1,51 @@ +# /* Copyright (C) 2001 +# * Housemarque Oy +# * http://www.housemarque.com +# * +# * 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) +# */ +# +# /* Revised by Paul Mensonides (2002) */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_ARITHMETIC_ADD_HPP +# define BOOST_PREPROCESSOR_ARITHMETIC_ADD_HPP +# +# include +# include +# include +# include +# include +# +# /* BOOST_PP_ADD */ +# +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() +# define BOOST_PP_ADD(x, y) BOOST_PP_TUPLE_ELEM(2, 0, BOOST_PP_WHILE(BOOST_PP_ADD_P, BOOST_PP_ADD_O, (x, y))) +# else +# define BOOST_PP_ADD(x, y) BOOST_PP_ADD_I(x, y) +# define BOOST_PP_ADD_I(x, y) BOOST_PP_TUPLE_ELEM(2, 0, BOOST_PP_WHILE(BOOST_PP_ADD_P, BOOST_PP_ADD_O, (x, y))) +# endif +# +# define BOOST_PP_ADD_P(d, xy) BOOST_PP_TUPLE_ELEM(2, 1, xy) +# +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() +# define BOOST_PP_ADD_O(d, xy) BOOST_PP_ADD_O_I xy +# else +# define BOOST_PP_ADD_O(d, xy) BOOST_PP_ADD_O_I(BOOST_PP_TUPLE_ELEM(2, 0, xy), BOOST_PP_TUPLE_ELEM(2, 1, xy)) +# endif +# +# define BOOST_PP_ADD_O_I(x, y) (BOOST_PP_INC(x), BOOST_PP_DEC(y)) +# +# /* BOOST_PP_ADD_D */ +# +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() +# define BOOST_PP_ADD_D(d, x, y) BOOST_PP_TUPLE_ELEM(2, 0, BOOST_PP_WHILE_ ## d(BOOST_PP_ADD_P, BOOST_PP_ADD_O, (x, y))) +# else +# define BOOST_PP_ADD_D(d, x, y) BOOST_PP_ADD_D_I(d, x, y) +# define BOOST_PP_ADD_D_I(d, x, y) BOOST_PP_TUPLE_ELEM(2, 0, BOOST_PP_WHILE_ ## d(BOOST_PP_ADD_P, BOOST_PP_ADD_O, (x, y))) +# endif +# +# endif diff --git a/realsense-file/3rd_party/boost/boost/preprocessor/arithmetic/dec.hpp b/realsense-file/3rd_party/boost/boost/preprocessor/arithmetic/dec.hpp new file mode 100644 index 0000000000..bef728180f --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/preprocessor/arithmetic/dec.hpp @@ -0,0 +1,288 @@ +# /* Copyright (C) 2001 +# * Housemarque Oy +# * http://www.housemarque.com +# * +# * 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) +# */ +# +# /* Revised by Paul Mensonides (2002) */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_ARITHMETIC_DEC_HPP +# define BOOST_PREPROCESSOR_ARITHMETIC_DEC_HPP +# +# include +# +# /* BOOST_PP_DEC */ +# +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() +# define BOOST_PP_DEC(x) BOOST_PP_DEC_I(x) +# else +# define BOOST_PP_DEC(x) BOOST_PP_DEC_OO((x)) +# define BOOST_PP_DEC_OO(par) BOOST_PP_DEC_I ## par +# endif +# +# define BOOST_PP_DEC_I(x) BOOST_PP_DEC_ ## x +# +# define BOOST_PP_DEC_0 0 +# define BOOST_PP_DEC_1 0 +# define BOOST_PP_DEC_2 1 +# define BOOST_PP_DEC_3 2 +# define BOOST_PP_DEC_4 3 +# define BOOST_PP_DEC_5 4 +# define BOOST_PP_DEC_6 5 +# define BOOST_PP_DEC_7 6 +# define BOOST_PP_DEC_8 7 +# define BOOST_PP_DEC_9 8 +# define BOOST_PP_DEC_10 9 +# define BOOST_PP_DEC_11 10 +# define BOOST_PP_DEC_12 11 +# define BOOST_PP_DEC_13 12 +# define BOOST_PP_DEC_14 13 +# define BOOST_PP_DEC_15 14 +# define BOOST_PP_DEC_16 15 +# define BOOST_PP_DEC_17 16 +# define BOOST_PP_DEC_18 17 +# define BOOST_PP_DEC_19 18 +# define BOOST_PP_DEC_20 19 +# define BOOST_PP_DEC_21 20 +# define BOOST_PP_DEC_22 21 +# define BOOST_PP_DEC_23 22 +# define BOOST_PP_DEC_24 23 +# define BOOST_PP_DEC_25 24 +# define BOOST_PP_DEC_26 25 +# define BOOST_PP_DEC_27 26 +# define BOOST_PP_DEC_28 27 +# define BOOST_PP_DEC_29 28 +# define BOOST_PP_DEC_30 29 +# define BOOST_PP_DEC_31 30 +# define BOOST_PP_DEC_32 31 +# define BOOST_PP_DEC_33 32 +# define BOOST_PP_DEC_34 33 +# define BOOST_PP_DEC_35 34 +# define BOOST_PP_DEC_36 35 +# define BOOST_PP_DEC_37 36 +# define BOOST_PP_DEC_38 37 +# define BOOST_PP_DEC_39 38 +# define BOOST_PP_DEC_40 39 +# define BOOST_PP_DEC_41 40 +# define BOOST_PP_DEC_42 41 +# define BOOST_PP_DEC_43 42 +# define BOOST_PP_DEC_44 43 +# define BOOST_PP_DEC_45 44 +# define BOOST_PP_DEC_46 45 +# define BOOST_PP_DEC_47 46 +# define BOOST_PP_DEC_48 47 +# define BOOST_PP_DEC_49 48 +# define BOOST_PP_DEC_50 49 +# define BOOST_PP_DEC_51 50 +# define BOOST_PP_DEC_52 51 +# define BOOST_PP_DEC_53 52 +# define BOOST_PP_DEC_54 53 +# define BOOST_PP_DEC_55 54 +# define BOOST_PP_DEC_56 55 +# define BOOST_PP_DEC_57 56 +# define BOOST_PP_DEC_58 57 +# define BOOST_PP_DEC_59 58 +# define BOOST_PP_DEC_60 59 +# define BOOST_PP_DEC_61 60 +# define BOOST_PP_DEC_62 61 +# define BOOST_PP_DEC_63 62 +# define BOOST_PP_DEC_64 63 +# define BOOST_PP_DEC_65 64 +# define BOOST_PP_DEC_66 65 +# define BOOST_PP_DEC_67 66 +# define BOOST_PP_DEC_68 67 +# define BOOST_PP_DEC_69 68 +# define BOOST_PP_DEC_70 69 +# define BOOST_PP_DEC_71 70 +# define BOOST_PP_DEC_72 71 +# define BOOST_PP_DEC_73 72 +# define BOOST_PP_DEC_74 73 +# define BOOST_PP_DEC_75 74 +# define BOOST_PP_DEC_76 75 +# define BOOST_PP_DEC_77 76 +# define BOOST_PP_DEC_78 77 +# define BOOST_PP_DEC_79 78 +# define BOOST_PP_DEC_80 79 +# define BOOST_PP_DEC_81 80 +# define BOOST_PP_DEC_82 81 +# define BOOST_PP_DEC_83 82 +# define BOOST_PP_DEC_84 83 +# define BOOST_PP_DEC_85 84 +# define BOOST_PP_DEC_86 85 +# define BOOST_PP_DEC_87 86 +# define BOOST_PP_DEC_88 87 +# define BOOST_PP_DEC_89 88 +# define BOOST_PP_DEC_90 89 +# define BOOST_PP_DEC_91 90 +# define BOOST_PP_DEC_92 91 +# define BOOST_PP_DEC_93 92 +# define BOOST_PP_DEC_94 93 +# define BOOST_PP_DEC_95 94 +# define BOOST_PP_DEC_96 95 +# define BOOST_PP_DEC_97 96 +# define BOOST_PP_DEC_98 97 +# define BOOST_PP_DEC_99 98 +# define BOOST_PP_DEC_100 99 +# define BOOST_PP_DEC_101 100 +# define BOOST_PP_DEC_102 101 +# define BOOST_PP_DEC_103 102 +# define BOOST_PP_DEC_104 103 +# define BOOST_PP_DEC_105 104 +# define BOOST_PP_DEC_106 105 +# define BOOST_PP_DEC_107 106 +# define BOOST_PP_DEC_108 107 +# define BOOST_PP_DEC_109 108 +# define BOOST_PP_DEC_110 109 +# define BOOST_PP_DEC_111 110 +# define BOOST_PP_DEC_112 111 +# define BOOST_PP_DEC_113 112 +# define BOOST_PP_DEC_114 113 +# define BOOST_PP_DEC_115 114 +# define BOOST_PP_DEC_116 115 +# define BOOST_PP_DEC_117 116 +# define BOOST_PP_DEC_118 117 +# define BOOST_PP_DEC_119 118 +# define BOOST_PP_DEC_120 119 +# define BOOST_PP_DEC_121 120 +# define BOOST_PP_DEC_122 121 +# define BOOST_PP_DEC_123 122 +# define BOOST_PP_DEC_124 123 +# define BOOST_PP_DEC_125 124 +# define BOOST_PP_DEC_126 125 +# define BOOST_PP_DEC_127 126 +# define BOOST_PP_DEC_128 127 +# define BOOST_PP_DEC_129 128 +# define BOOST_PP_DEC_130 129 +# define BOOST_PP_DEC_131 130 +# define BOOST_PP_DEC_132 131 +# define BOOST_PP_DEC_133 132 +# define BOOST_PP_DEC_134 133 +# define BOOST_PP_DEC_135 134 +# define BOOST_PP_DEC_136 135 +# define BOOST_PP_DEC_137 136 +# define BOOST_PP_DEC_138 137 +# define BOOST_PP_DEC_139 138 +# define BOOST_PP_DEC_140 139 +# define BOOST_PP_DEC_141 140 +# define BOOST_PP_DEC_142 141 +# define BOOST_PP_DEC_143 142 +# define BOOST_PP_DEC_144 143 +# define BOOST_PP_DEC_145 144 +# define BOOST_PP_DEC_146 145 +# define BOOST_PP_DEC_147 146 +# define BOOST_PP_DEC_148 147 +# define BOOST_PP_DEC_149 148 +# define BOOST_PP_DEC_150 149 +# define BOOST_PP_DEC_151 150 +# define BOOST_PP_DEC_152 151 +# define BOOST_PP_DEC_153 152 +# define BOOST_PP_DEC_154 153 +# define BOOST_PP_DEC_155 154 +# define BOOST_PP_DEC_156 155 +# define BOOST_PP_DEC_157 156 +# define BOOST_PP_DEC_158 157 +# define BOOST_PP_DEC_159 158 +# define BOOST_PP_DEC_160 159 +# define BOOST_PP_DEC_161 160 +# define BOOST_PP_DEC_162 161 +# define BOOST_PP_DEC_163 162 +# define BOOST_PP_DEC_164 163 +# define BOOST_PP_DEC_165 164 +# define BOOST_PP_DEC_166 165 +# define BOOST_PP_DEC_167 166 +# define BOOST_PP_DEC_168 167 +# define BOOST_PP_DEC_169 168 +# define BOOST_PP_DEC_170 169 +# define BOOST_PP_DEC_171 170 +# define BOOST_PP_DEC_172 171 +# define BOOST_PP_DEC_173 172 +# define BOOST_PP_DEC_174 173 +# define BOOST_PP_DEC_175 174 +# define BOOST_PP_DEC_176 175 +# define BOOST_PP_DEC_177 176 +# define BOOST_PP_DEC_178 177 +# define BOOST_PP_DEC_179 178 +# define BOOST_PP_DEC_180 179 +# define BOOST_PP_DEC_181 180 +# define BOOST_PP_DEC_182 181 +# define BOOST_PP_DEC_183 182 +# define BOOST_PP_DEC_184 183 +# define BOOST_PP_DEC_185 184 +# define BOOST_PP_DEC_186 185 +# define BOOST_PP_DEC_187 186 +# define BOOST_PP_DEC_188 187 +# define BOOST_PP_DEC_189 188 +# define BOOST_PP_DEC_190 189 +# define BOOST_PP_DEC_191 190 +# define BOOST_PP_DEC_192 191 +# define BOOST_PP_DEC_193 192 +# define BOOST_PP_DEC_194 193 +# define BOOST_PP_DEC_195 194 +# define BOOST_PP_DEC_196 195 +# define BOOST_PP_DEC_197 196 +# define BOOST_PP_DEC_198 197 +# define BOOST_PP_DEC_199 198 +# define BOOST_PP_DEC_200 199 +# define BOOST_PP_DEC_201 200 +# define BOOST_PP_DEC_202 201 +# define BOOST_PP_DEC_203 202 +# define BOOST_PP_DEC_204 203 +# define BOOST_PP_DEC_205 204 +# define BOOST_PP_DEC_206 205 +# define BOOST_PP_DEC_207 206 +# define BOOST_PP_DEC_208 207 +# define BOOST_PP_DEC_209 208 +# define BOOST_PP_DEC_210 209 +# define BOOST_PP_DEC_211 210 +# define BOOST_PP_DEC_212 211 +# define BOOST_PP_DEC_213 212 +# define BOOST_PP_DEC_214 213 +# define BOOST_PP_DEC_215 214 +# define BOOST_PP_DEC_216 215 +# define BOOST_PP_DEC_217 216 +# define BOOST_PP_DEC_218 217 +# define BOOST_PP_DEC_219 218 +# define BOOST_PP_DEC_220 219 +# define BOOST_PP_DEC_221 220 +# define BOOST_PP_DEC_222 221 +# define BOOST_PP_DEC_223 222 +# define BOOST_PP_DEC_224 223 +# define BOOST_PP_DEC_225 224 +# define BOOST_PP_DEC_226 225 +# define BOOST_PP_DEC_227 226 +# define BOOST_PP_DEC_228 227 +# define BOOST_PP_DEC_229 228 +# define BOOST_PP_DEC_230 229 +# define BOOST_PP_DEC_231 230 +# define BOOST_PP_DEC_232 231 +# define BOOST_PP_DEC_233 232 +# define BOOST_PP_DEC_234 233 +# define BOOST_PP_DEC_235 234 +# define BOOST_PP_DEC_236 235 +# define BOOST_PP_DEC_237 236 +# define BOOST_PP_DEC_238 237 +# define BOOST_PP_DEC_239 238 +# define BOOST_PP_DEC_240 239 +# define BOOST_PP_DEC_241 240 +# define BOOST_PP_DEC_242 241 +# define BOOST_PP_DEC_243 242 +# define BOOST_PP_DEC_244 243 +# define BOOST_PP_DEC_245 244 +# define BOOST_PP_DEC_246 245 +# define BOOST_PP_DEC_247 246 +# define BOOST_PP_DEC_248 247 +# define BOOST_PP_DEC_249 248 +# define BOOST_PP_DEC_250 249 +# define BOOST_PP_DEC_251 250 +# define BOOST_PP_DEC_252 251 +# define BOOST_PP_DEC_253 252 +# define BOOST_PP_DEC_254 253 +# define BOOST_PP_DEC_255 254 +# define BOOST_PP_DEC_256 255 +# +# endif diff --git a/realsense-file/3rd_party/boost/boost/preprocessor/arithmetic/inc.hpp b/realsense-file/3rd_party/boost/boost/preprocessor/arithmetic/inc.hpp new file mode 100644 index 0000000000..4c367f9704 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/preprocessor/arithmetic/inc.hpp @@ -0,0 +1,288 @@ +# /* Copyright (C) 2001 +# * Housemarque Oy +# * http://www.housemarque.com +# * +# * 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) +# */ +# +# /* Revised by Paul Mensonides (2002) */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_ARITHMETIC_INC_HPP +# define BOOST_PREPROCESSOR_ARITHMETIC_INC_HPP +# +# include +# +# /* BOOST_PP_INC */ +# +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() +# define BOOST_PP_INC(x) BOOST_PP_INC_I(x) +# else +# define BOOST_PP_INC(x) BOOST_PP_INC_OO((x)) +# define BOOST_PP_INC_OO(par) BOOST_PP_INC_I ## par +# endif +# +# define BOOST_PP_INC_I(x) BOOST_PP_INC_ ## x +# +# define BOOST_PP_INC_0 1 +# define BOOST_PP_INC_1 2 +# define BOOST_PP_INC_2 3 +# define BOOST_PP_INC_3 4 +# define BOOST_PP_INC_4 5 +# define BOOST_PP_INC_5 6 +# define BOOST_PP_INC_6 7 +# define BOOST_PP_INC_7 8 +# define BOOST_PP_INC_8 9 +# define BOOST_PP_INC_9 10 +# define BOOST_PP_INC_10 11 +# define BOOST_PP_INC_11 12 +# define BOOST_PP_INC_12 13 +# define BOOST_PP_INC_13 14 +# define BOOST_PP_INC_14 15 +# define BOOST_PP_INC_15 16 +# define BOOST_PP_INC_16 17 +# define BOOST_PP_INC_17 18 +# define BOOST_PP_INC_18 19 +# define BOOST_PP_INC_19 20 +# define BOOST_PP_INC_20 21 +# define BOOST_PP_INC_21 22 +# define BOOST_PP_INC_22 23 +# define BOOST_PP_INC_23 24 +# define BOOST_PP_INC_24 25 +# define BOOST_PP_INC_25 26 +# define BOOST_PP_INC_26 27 +# define BOOST_PP_INC_27 28 +# define BOOST_PP_INC_28 29 +# define BOOST_PP_INC_29 30 +# define BOOST_PP_INC_30 31 +# define BOOST_PP_INC_31 32 +# define BOOST_PP_INC_32 33 +# define BOOST_PP_INC_33 34 +# define BOOST_PP_INC_34 35 +# define BOOST_PP_INC_35 36 +# define BOOST_PP_INC_36 37 +# define BOOST_PP_INC_37 38 +# define BOOST_PP_INC_38 39 +# define BOOST_PP_INC_39 40 +# define BOOST_PP_INC_40 41 +# define BOOST_PP_INC_41 42 +# define BOOST_PP_INC_42 43 +# define BOOST_PP_INC_43 44 +# define BOOST_PP_INC_44 45 +# define BOOST_PP_INC_45 46 +# define BOOST_PP_INC_46 47 +# define BOOST_PP_INC_47 48 +# define BOOST_PP_INC_48 49 +# define BOOST_PP_INC_49 50 +# define BOOST_PP_INC_50 51 +# define BOOST_PP_INC_51 52 +# define BOOST_PP_INC_52 53 +# define BOOST_PP_INC_53 54 +# define BOOST_PP_INC_54 55 +# define BOOST_PP_INC_55 56 +# define BOOST_PP_INC_56 57 +# define BOOST_PP_INC_57 58 +# define BOOST_PP_INC_58 59 +# define BOOST_PP_INC_59 60 +# define BOOST_PP_INC_60 61 +# define BOOST_PP_INC_61 62 +# define BOOST_PP_INC_62 63 +# define BOOST_PP_INC_63 64 +# define BOOST_PP_INC_64 65 +# define BOOST_PP_INC_65 66 +# define BOOST_PP_INC_66 67 +# define BOOST_PP_INC_67 68 +# define BOOST_PP_INC_68 69 +# define BOOST_PP_INC_69 70 +# define BOOST_PP_INC_70 71 +# define BOOST_PP_INC_71 72 +# define BOOST_PP_INC_72 73 +# define BOOST_PP_INC_73 74 +# define BOOST_PP_INC_74 75 +# define BOOST_PP_INC_75 76 +# define BOOST_PP_INC_76 77 +# define BOOST_PP_INC_77 78 +# define BOOST_PP_INC_78 79 +# define BOOST_PP_INC_79 80 +# define BOOST_PP_INC_80 81 +# define BOOST_PP_INC_81 82 +# define BOOST_PP_INC_82 83 +# define BOOST_PP_INC_83 84 +# define BOOST_PP_INC_84 85 +# define BOOST_PP_INC_85 86 +# define BOOST_PP_INC_86 87 +# define BOOST_PP_INC_87 88 +# define BOOST_PP_INC_88 89 +# define BOOST_PP_INC_89 90 +# define BOOST_PP_INC_90 91 +# define BOOST_PP_INC_91 92 +# define BOOST_PP_INC_92 93 +# define BOOST_PP_INC_93 94 +# define BOOST_PP_INC_94 95 +# define BOOST_PP_INC_95 96 +# define BOOST_PP_INC_96 97 +# define BOOST_PP_INC_97 98 +# define BOOST_PP_INC_98 99 +# define BOOST_PP_INC_99 100 +# define BOOST_PP_INC_100 101 +# define BOOST_PP_INC_101 102 +# define BOOST_PP_INC_102 103 +# define BOOST_PP_INC_103 104 +# define BOOST_PP_INC_104 105 +# define BOOST_PP_INC_105 106 +# define BOOST_PP_INC_106 107 +# define BOOST_PP_INC_107 108 +# define BOOST_PP_INC_108 109 +# define BOOST_PP_INC_109 110 +# define BOOST_PP_INC_110 111 +# define BOOST_PP_INC_111 112 +# define BOOST_PP_INC_112 113 +# define BOOST_PP_INC_113 114 +# define BOOST_PP_INC_114 115 +# define BOOST_PP_INC_115 116 +# define BOOST_PP_INC_116 117 +# define BOOST_PP_INC_117 118 +# define BOOST_PP_INC_118 119 +# define BOOST_PP_INC_119 120 +# define BOOST_PP_INC_120 121 +# define BOOST_PP_INC_121 122 +# define BOOST_PP_INC_122 123 +# define BOOST_PP_INC_123 124 +# define BOOST_PP_INC_124 125 +# define BOOST_PP_INC_125 126 +# define BOOST_PP_INC_126 127 +# define BOOST_PP_INC_127 128 +# define BOOST_PP_INC_128 129 +# define BOOST_PP_INC_129 130 +# define BOOST_PP_INC_130 131 +# define BOOST_PP_INC_131 132 +# define BOOST_PP_INC_132 133 +# define BOOST_PP_INC_133 134 +# define BOOST_PP_INC_134 135 +# define BOOST_PP_INC_135 136 +# define BOOST_PP_INC_136 137 +# define BOOST_PP_INC_137 138 +# define BOOST_PP_INC_138 139 +# define BOOST_PP_INC_139 140 +# define BOOST_PP_INC_140 141 +# define BOOST_PP_INC_141 142 +# define BOOST_PP_INC_142 143 +# define BOOST_PP_INC_143 144 +# define BOOST_PP_INC_144 145 +# define BOOST_PP_INC_145 146 +# define BOOST_PP_INC_146 147 +# define BOOST_PP_INC_147 148 +# define BOOST_PP_INC_148 149 +# define BOOST_PP_INC_149 150 +# define BOOST_PP_INC_150 151 +# define BOOST_PP_INC_151 152 +# define BOOST_PP_INC_152 153 +# define BOOST_PP_INC_153 154 +# define BOOST_PP_INC_154 155 +# define BOOST_PP_INC_155 156 +# define BOOST_PP_INC_156 157 +# define BOOST_PP_INC_157 158 +# define BOOST_PP_INC_158 159 +# define BOOST_PP_INC_159 160 +# define BOOST_PP_INC_160 161 +# define BOOST_PP_INC_161 162 +# define BOOST_PP_INC_162 163 +# define BOOST_PP_INC_163 164 +# define BOOST_PP_INC_164 165 +# define BOOST_PP_INC_165 166 +# define BOOST_PP_INC_166 167 +# define BOOST_PP_INC_167 168 +# define BOOST_PP_INC_168 169 +# define BOOST_PP_INC_169 170 +# define BOOST_PP_INC_170 171 +# define BOOST_PP_INC_171 172 +# define BOOST_PP_INC_172 173 +# define BOOST_PP_INC_173 174 +# define BOOST_PP_INC_174 175 +# define BOOST_PP_INC_175 176 +# define BOOST_PP_INC_176 177 +# define BOOST_PP_INC_177 178 +# define BOOST_PP_INC_178 179 +# define BOOST_PP_INC_179 180 +# define BOOST_PP_INC_180 181 +# define BOOST_PP_INC_181 182 +# define BOOST_PP_INC_182 183 +# define BOOST_PP_INC_183 184 +# define BOOST_PP_INC_184 185 +# define BOOST_PP_INC_185 186 +# define BOOST_PP_INC_186 187 +# define BOOST_PP_INC_187 188 +# define BOOST_PP_INC_188 189 +# define BOOST_PP_INC_189 190 +# define BOOST_PP_INC_190 191 +# define BOOST_PP_INC_191 192 +# define BOOST_PP_INC_192 193 +# define BOOST_PP_INC_193 194 +# define BOOST_PP_INC_194 195 +# define BOOST_PP_INC_195 196 +# define BOOST_PP_INC_196 197 +# define BOOST_PP_INC_197 198 +# define BOOST_PP_INC_198 199 +# define BOOST_PP_INC_199 200 +# define BOOST_PP_INC_200 201 +# define BOOST_PP_INC_201 202 +# define BOOST_PP_INC_202 203 +# define BOOST_PP_INC_203 204 +# define BOOST_PP_INC_204 205 +# define BOOST_PP_INC_205 206 +# define BOOST_PP_INC_206 207 +# define BOOST_PP_INC_207 208 +# define BOOST_PP_INC_208 209 +# define BOOST_PP_INC_209 210 +# define BOOST_PP_INC_210 211 +# define BOOST_PP_INC_211 212 +# define BOOST_PP_INC_212 213 +# define BOOST_PP_INC_213 214 +# define BOOST_PP_INC_214 215 +# define BOOST_PP_INC_215 216 +# define BOOST_PP_INC_216 217 +# define BOOST_PP_INC_217 218 +# define BOOST_PP_INC_218 219 +# define BOOST_PP_INC_219 220 +# define BOOST_PP_INC_220 221 +# define BOOST_PP_INC_221 222 +# define BOOST_PP_INC_222 223 +# define BOOST_PP_INC_223 224 +# define BOOST_PP_INC_224 225 +# define BOOST_PP_INC_225 226 +# define BOOST_PP_INC_226 227 +# define BOOST_PP_INC_227 228 +# define BOOST_PP_INC_228 229 +# define BOOST_PP_INC_229 230 +# define BOOST_PP_INC_230 231 +# define BOOST_PP_INC_231 232 +# define BOOST_PP_INC_232 233 +# define BOOST_PP_INC_233 234 +# define BOOST_PP_INC_234 235 +# define BOOST_PP_INC_235 236 +# define BOOST_PP_INC_236 237 +# define BOOST_PP_INC_237 238 +# define BOOST_PP_INC_238 239 +# define BOOST_PP_INC_239 240 +# define BOOST_PP_INC_240 241 +# define BOOST_PP_INC_241 242 +# define BOOST_PP_INC_242 243 +# define BOOST_PP_INC_243 244 +# define BOOST_PP_INC_244 245 +# define BOOST_PP_INC_245 246 +# define BOOST_PP_INC_246 247 +# define BOOST_PP_INC_247 248 +# define BOOST_PP_INC_248 249 +# define BOOST_PP_INC_249 250 +# define BOOST_PP_INC_250 251 +# define BOOST_PP_INC_251 252 +# define BOOST_PP_INC_252 253 +# define BOOST_PP_INC_253 254 +# define BOOST_PP_INC_254 255 +# define BOOST_PP_INC_255 256 +# define BOOST_PP_INC_256 256 +# +# endif diff --git a/realsense-file/3rd_party/boost/boost/preprocessor/arithmetic/sub.hpp b/realsense-file/3rd_party/boost/boost/preprocessor/arithmetic/sub.hpp new file mode 100644 index 0000000000..3ef7a283fe --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/preprocessor/arithmetic/sub.hpp @@ -0,0 +1,50 @@ +# /* Copyright (C) 2001 +# * Housemarque Oy +# * http://www.housemarque.com +# * +# * 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) +# */ +# +# /* Revised by Paul Mensonides (2002) */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_ARITHMETIC_SUB_HPP +# define BOOST_PREPROCESSOR_ARITHMETIC_SUB_HPP +# +# include +# include +# include +# include +# +# /* BOOST_PP_SUB */ +# +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() +# define BOOST_PP_SUB(x, y) BOOST_PP_TUPLE_ELEM(2, 0, BOOST_PP_WHILE(BOOST_PP_SUB_P, BOOST_PP_SUB_O, (x, y))) +# else +# define BOOST_PP_SUB(x, y) BOOST_PP_SUB_I(x, y) +# define BOOST_PP_SUB_I(x, y) BOOST_PP_TUPLE_ELEM(2, 0, BOOST_PP_WHILE(BOOST_PP_SUB_P, BOOST_PP_SUB_O, (x, y))) +# endif +# +# define BOOST_PP_SUB_P(d, xy) BOOST_PP_TUPLE_ELEM(2, 1, xy) +# +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() +# define BOOST_PP_SUB_O(d, xy) BOOST_PP_SUB_O_I xy +# else +# define BOOST_PP_SUB_O(d, xy) BOOST_PP_SUB_O_I(BOOST_PP_TUPLE_ELEM(2, 0, xy), BOOST_PP_TUPLE_ELEM(2, 1, xy)) +# endif +# +# define BOOST_PP_SUB_O_I(x, y) (BOOST_PP_DEC(x), BOOST_PP_DEC(y)) +# +# /* BOOST_PP_SUB_D */ +# +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() +# define BOOST_PP_SUB_D(d, x, y) BOOST_PP_TUPLE_ELEM(2, 0, BOOST_PP_WHILE_ ## d(BOOST_PP_SUB_P, BOOST_PP_SUB_O, (x, y))) +# else +# define BOOST_PP_SUB_D(d, x, y) BOOST_PP_SUB_D_I(d, x, y) +# define BOOST_PP_SUB_D_I(d, x, y) BOOST_PP_TUPLE_ELEM(2, 0, BOOST_PP_WHILE_ ## d(BOOST_PP_SUB_P, BOOST_PP_SUB_O, (x, y))) +# endif +# +# endif diff --git a/realsense-file/3rd_party/boost/boost/preprocessor/array/data.hpp b/realsense-file/3rd_party/boost/boost/preprocessor/array/data.hpp new file mode 100644 index 0000000000..4b00cdc231 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/preprocessor/array/data.hpp @@ -0,0 +1,28 @@ +# /* ************************************************************************** +# * * +# * (C) Copyright Paul Mensonides 2002. +# * Distributed under the Boost Software License, Version 1.0. (See +# * accompanying file LICENSE_1_0.txt or copy at +# * http://www.boost.org/LICENSE_1_0.txt) +# * * +# ************************************************************************** */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_ARRAY_DATA_HPP +# define BOOST_PREPROCESSOR_ARRAY_DATA_HPP +# +# include +# include +# +# /* BOOST_PP_ARRAY_DATA */ +# +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() +# define BOOST_PP_ARRAY_DATA(array) BOOST_PP_TUPLE_ELEM(2, 1, array) +# else +# define BOOST_PP_ARRAY_DATA(array) BOOST_PP_ARRAY_DATA_I(array) +# define BOOST_PP_ARRAY_DATA_I(array) BOOST_PP_ARRAY_DATA_II array +# define BOOST_PP_ARRAY_DATA_II(size, data) data +# endif +# +# endif diff --git a/realsense-file/3rd_party/boost/boost/preprocessor/array/elem.hpp b/realsense-file/3rd_party/boost/boost/preprocessor/array/elem.hpp new file mode 100644 index 0000000000..4f11c08cc8 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/preprocessor/array/elem.hpp @@ -0,0 +1,29 @@ +# /* ************************************************************************** +# * * +# * (C) Copyright Paul Mensonides 2002. +# * Distributed under the Boost Software License, Version 1.0. (See +# * accompanying file LICENSE_1_0.txt or copy at +# * http://www.boost.org/LICENSE_1_0.txt) +# * * +# ************************************************************************** */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_ARRAY_ELEM_HPP +# define BOOST_PREPROCESSOR_ARRAY_ELEM_HPP +# +# include +# include +# include +# include +# +# /* BOOST_PP_ARRAY_ELEM */ +# +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() +# define BOOST_PP_ARRAY_ELEM(i, array) BOOST_PP_TUPLE_ELEM(BOOST_PP_ARRAY_SIZE(array), i, BOOST_PP_ARRAY_DATA(array)) +# else +# define BOOST_PP_ARRAY_ELEM(i, array) BOOST_PP_ARRAY_ELEM_I(i, array) +# define BOOST_PP_ARRAY_ELEM_I(i, array) BOOST_PP_TUPLE_ELEM(BOOST_PP_ARRAY_SIZE(array), i, BOOST_PP_ARRAY_DATA(array)) +# endif +# +# endif diff --git a/realsense-file/3rd_party/boost/boost/preprocessor/array/size.hpp b/realsense-file/3rd_party/boost/boost/preprocessor/array/size.hpp new file mode 100644 index 0000000000..d3d50eeae5 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/preprocessor/array/size.hpp @@ -0,0 +1,28 @@ +# /* ************************************************************************** +# * * +# * (C) Copyright Paul Mensonides 2002. +# * Distributed under the Boost Software License, Version 1.0. (See +# * accompanying file LICENSE_1_0.txt or copy at +# * http://www.boost.org/LICENSE_1_0.txt) +# * * +# ************************************************************************** */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_ARRAY_SIZE_HPP +# define BOOST_PREPROCESSOR_ARRAY_SIZE_HPP +# +# include +# include +# +# /* BOOST_PP_ARRAY_SIZE */ +# +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() +# define BOOST_PP_ARRAY_SIZE(array) BOOST_PP_TUPLE_ELEM(2, 0, array) +# else +# define BOOST_PP_ARRAY_SIZE(array) BOOST_PP_ARRAY_SIZE_I(array) +# define BOOST_PP_ARRAY_SIZE_I(array) BOOST_PP_ARRAY_SIZE_II array +# define BOOST_PP_ARRAY_SIZE_II(size, data) size +# endif +# +# endif diff --git a/realsense-file/3rd_party/boost/boost/preprocessor/cat.hpp b/realsense-file/3rd_party/boost/boost/preprocessor/cat.hpp new file mode 100644 index 0000000000..e14cdbad8e --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/preprocessor/cat.hpp @@ -0,0 +1,35 @@ +# /* Copyright (C) 2001 +# * Housemarque Oy +# * http://www.housemarque.com +# * +# * 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) +# */ +# +# /* Revised by Paul Mensonides (2002) */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_CAT_HPP +# define BOOST_PREPROCESSOR_CAT_HPP +# +# include "config/config.hpp" +# +# /* BOOST_PP_CAT */ +# +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() +# define BOOST_PP_CAT(a, b) BOOST_PP_CAT_I(a, b) +# else +# define BOOST_PP_CAT(a, b) BOOST_PP_CAT_OO((a, b)) +# define BOOST_PP_CAT_OO(par) BOOST_PP_CAT_I ## par +# endif +# +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MSVC() +# define BOOST_PP_CAT_I(a, b) a ## b +# else +# define BOOST_PP_CAT_I(a, b) BOOST_PP_CAT_II(~, a ## b) +# define BOOST_PP_CAT_II(p, res) res +# endif +# +# endif diff --git a/realsense-file/3rd_party/boost/boost/preprocessor/comma_if.hpp b/realsense-file/3rd_party/boost/boost/preprocessor/comma_if.hpp new file mode 100644 index 0000000000..0af01b97e5 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/preprocessor/comma_if.hpp @@ -0,0 +1,17 @@ +# /* ************************************************************************** +# * * +# * (C) Copyright Paul Mensonides 2002. +# * Distributed under the Boost Software License, Version 1.0. (See +# * accompanying file LICENSE_1_0.txt or copy at +# * http://www.boost.org/LICENSE_1_0.txt) +# * * +# ************************************************************************** */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_COMMA_IF_HPP +# define BOOST_PREPROCESSOR_COMMA_IF_HPP +# +# include "punctuation/comma_if.hpp" +# +# endif diff --git a/realsense-file/3rd_party/boost/boost/preprocessor/config/config.hpp b/realsense-file/3rd_party/boost/boost/preprocessor/config/config.hpp new file mode 100644 index 0000000000..6df3b43b97 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/preprocessor/config/config.hpp @@ -0,0 +1,101 @@ +# /* ************************************************************************** +# * * +# * (C) Copyright Paul Mensonides 2002-2011. * +# * (C) Copyright Edward Diener 2011. * +# * Distributed under the Boost Software License, Version 1.0. (See * +# * accompanying file LICENSE_1_0.txt or copy at * +# * http://www.boost.org/LICENSE_1_0.txt) * +# * * +# ************************************************************************** */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_CONFIG_CONFIG_HPP +# define BOOST_PREPROCESSOR_CONFIG_CONFIG_HPP +# +# /* BOOST_PP_CONFIG_FLAGS */ +# +# define BOOST_PP_CONFIG_STRICT() 0x0001 +# define BOOST_PP_CONFIG_IDEAL() 0x0002 +# +# define BOOST_PP_CONFIG_MSVC() 0x0004 +# define BOOST_PP_CONFIG_MWCC() 0x0008 +# define BOOST_PP_CONFIG_BCC() 0x0010 +# define BOOST_PP_CONFIG_EDG() 0x0020 +# define BOOST_PP_CONFIG_DMC() 0x0040 +# +# ifndef BOOST_PP_CONFIG_FLAGS +# if defined(__GCCXML__) +# define BOOST_PP_CONFIG_FLAGS() (BOOST_PP_CONFIG_STRICT()) +# elif defined(__WAVE__) +# define BOOST_PP_CONFIG_FLAGS() (BOOST_PP_CONFIG_STRICT()) +# elif defined(__MWERKS__) && __MWERKS__ >= 0x3200 +# define BOOST_PP_CONFIG_FLAGS() (BOOST_PP_CONFIG_STRICT()) +# elif defined(__EDG__) || defined(__EDG_VERSION__) +# if defined(_MSC_VER) && (defined(__INTELLISENSE__) || __EDG_VERSION__ >= 308) +# define BOOST_PP_CONFIG_FLAGS() (BOOST_PP_CONFIG_MSVC()) +# else +# define BOOST_PP_CONFIG_FLAGS() (BOOST_PP_CONFIG_EDG() | BOOST_PP_CONFIG_STRICT()) +# endif +# elif defined(__MWERKS__) +# define BOOST_PP_CONFIG_FLAGS() (BOOST_PP_CONFIG_MWCC()) +# elif defined(__DMC__) +# define BOOST_PP_CONFIG_FLAGS() (BOOST_PP_CONFIG_DMC()) +# elif defined(__BORLANDC__) && __BORLANDC__ >= 0x581 +# define BOOST_PP_CONFIG_FLAGS() (BOOST_PP_CONFIG_STRICT()) +# elif defined(__BORLANDC__) || defined(__IBMC__) || defined(__IBMCPP__) || defined(__SUNPRO_CC) +# define BOOST_PP_CONFIG_FLAGS() (BOOST_PP_CONFIG_BCC()) +# elif defined(_MSC_VER) && !defined(__clang__) +# define BOOST_PP_CONFIG_FLAGS() (BOOST_PP_CONFIG_MSVC()) +# else +# define BOOST_PP_CONFIG_FLAGS() (BOOST_PP_CONFIG_STRICT()) +# endif +# endif +# +# /* BOOST_PP_CONFIG_EXTENDED_LINE_INFO */ +# +# ifndef BOOST_PP_CONFIG_EXTENDED_LINE_INFO +# define BOOST_PP_CONFIG_EXTENDED_LINE_INFO 0 +# endif +# +# /* BOOST_PP_CONFIG_ERRORS */ +# +# ifndef BOOST_PP_CONFIG_ERRORS +# ifdef NDEBUG +# define BOOST_PP_CONFIG_ERRORS 0 +# else +# define BOOST_PP_CONFIG_ERRORS 1 +# endif +# endif +# +# /* BOOST_PP_VARIADICS */ +# +# if !defined BOOST_PP_VARIADICS +# /* variadic support explicitly disabled for all untested compilers */ +# if defined __GCCXML__ || defined __CUDACC__ || defined __PATHSCALE__ || defined __DMC__ || defined __CODEGEARC__ || defined __BORLANDC__ || defined __MWERKS__ || defined __SUNPRO_CC || defined __HP_aCC && !defined __EDG__ || defined __MRC__ || defined __SC__ || defined __IBMCPP__ || defined __PGI +# define BOOST_PP_VARIADICS 0 +# /* VC++ (C/C++) */ +# elif defined _MSC_VER && _MSC_VER >= 1400 && (!defined __EDG__ || defined(__INTELLISENSE__)) && !defined __clang__ +# define BOOST_PP_VARIADICS 1 +# define BOOST_PP_VARIADICS_MSVC 1 +# /* Wave (C/C++), GCC (C++) */ +# elif defined __WAVE__ && __WAVE_HAS_VARIADICS__ || defined __GNUC__ && __GXX_EXPERIMENTAL_CXX0X__ +# define BOOST_PP_VARIADICS 1 +# /* EDG-based (C/C++), GCC (C), and unknown (C/C++) */ +# elif !defined __cplusplus && __STDC_VERSION__ >= 199901L || __cplusplus >= 201103L +# define BOOST_PP_VARIADICS 1 +# else +# define BOOST_PP_VARIADICS 0 +# endif +# elif !BOOST_PP_VARIADICS + 1 < 2 +# undef BOOST_PP_VARIADICS +# define BOOST_PP_VARIADICS 1 +# if defined _MSC_VER && _MSC_VER >= 1400 && (defined(__INTELLISENSE__) || !(defined __EDG__ || defined __GCCXML__ || defined __CUDACC__ || defined __PATHSCALE__ || defined __clang__ || defined __DMC__ || defined __CODEGEARC__ || defined __BORLANDC__ || defined __MWERKS__ || defined __SUNPRO_CC || defined __HP_aCC || defined __MRC__ || defined __SC__ || defined __IBMCPP__ || defined __PGI)) +# define BOOST_PP_VARIADICS_MSVC 1 +# endif +# else +# undef BOOST_PP_VARIADICS +# define BOOST_PP_VARIADICS 0 +# endif +# +# endif diff --git a/realsense-file/3rd_party/boost/boost/preprocessor/control/detail/msvc/while.hpp b/realsense-file/3rd_party/boost/boost/preprocessor/control/detail/msvc/while.hpp new file mode 100644 index 0000000000..e3cc685527 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/preprocessor/control/detail/msvc/while.hpp @@ -0,0 +1,277 @@ +# /* Copyright (C) 2001 +# * Housemarque Oy +# * http://www.housemarque.com +# * +# * 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) +# */ +# +# /* Revised by Paul Mensonides (2002) */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_CONTROL_DETAIL_MSVC_WHILE_HPP +# define BOOST_PREPROCESSOR_CONTROL_DETAIL_MSVC_WHILE_HPP +# +# include +# include +# +# define BOOST_PP_WHILE_1(p, o, s) BOOST_PP_IF(p(2, s), BOOST_PP_WHILE_2, s BOOST_PP_TUPLE_EAT_3)(p, o, o(2, s)) +# define BOOST_PP_WHILE_2(p, o, s) BOOST_PP_IF(p(3, s), BOOST_PP_WHILE_3, s BOOST_PP_TUPLE_EAT_3)(p, o, o(3, s)) +# define BOOST_PP_WHILE_3(p, o, s) BOOST_PP_IF(p(4, s), BOOST_PP_WHILE_4, s BOOST_PP_TUPLE_EAT_3)(p, o, o(4, s)) +# define BOOST_PP_WHILE_4(p, o, s) BOOST_PP_IF(p(5, s), BOOST_PP_WHILE_5, s BOOST_PP_TUPLE_EAT_3)(p, o, o(5, s)) +# define BOOST_PP_WHILE_5(p, o, s) BOOST_PP_IF(p(6, s), BOOST_PP_WHILE_6, s BOOST_PP_TUPLE_EAT_3)(p, o, o(6, s)) +# define BOOST_PP_WHILE_6(p, o, s) BOOST_PP_IF(p(7, s), BOOST_PP_WHILE_7, s BOOST_PP_TUPLE_EAT_3)(p, o, o(7, s)) +# define BOOST_PP_WHILE_7(p, o, s) BOOST_PP_IF(p(8, s), BOOST_PP_WHILE_8, s BOOST_PP_TUPLE_EAT_3)(p, o, o(8, s)) +# define BOOST_PP_WHILE_8(p, o, s) BOOST_PP_IF(p(9, s), BOOST_PP_WHILE_9, s BOOST_PP_TUPLE_EAT_3)(p, o, o(9, s)) +# define BOOST_PP_WHILE_9(p, o, s) BOOST_PP_IF(p(10, s), BOOST_PP_WHILE_10, s BOOST_PP_TUPLE_EAT_3)(p, o, o(10, s)) +# define BOOST_PP_WHILE_10(p, o, s) BOOST_PP_IF(p(11, s), BOOST_PP_WHILE_11, s BOOST_PP_TUPLE_EAT_3)(p, o, o(11, s)) +# define BOOST_PP_WHILE_11(p, o, s) BOOST_PP_IF(p(12, s), BOOST_PP_WHILE_12, s BOOST_PP_TUPLE_EAT_3)(p, o, o(12, s)) +# define BOOST_PP_WHILE_12(p, o, s) BOOST_PP_IF(p(13, s), BOOST_PP_WHILE_13, s BOOST_PP_TUPLE_EAT_3)(p, o, o(13, s)) +# define BOOST_PP_WHILE_13(p, o, s) BOOST_PP_IF(p(14, s), BOOST_PP_WHILE_14, s BOOST_PP_TUPLE_EAT_3)(p, o, o(14, s)) +# define BOOST_PP_WHILE_14(p, o, s) BOOST_PP_IF(p(15, s), BOOST_PP_WHILE_15, s BOOST_PP_TUPLE_EAT_3)(p, o, o(15, s)) +# define BOOST_PP_WHILE_15(p, o, s) BOOST_PP_IF(p(16, s), BOOST_PP_WHILE_16, s BOOST_PP_TUPLE_EAT_3)(p, o, o(16, s)) +# define BOOST_PP_WHILE_16(p, o, s) BOOST_PP_IF(p(17, s), BOOST_PP_WHILE_17, s BOOST_PP_TUPLE_EAT_3)(p, o, o(17, s)) +# define BOOST_PP_WHILE_17(p, o, s) BOOST_PP_IF(p(18, s), BOOST_PP_WHILE_18, s BOOST_PP_TUPLE_EAT_3)(p, o, o(18, s)) +# define BOOST_PP_WHILE_18(p, o, s) BOOST_PP_IF(p(19, s), BOOST_PP_WHILE_19, s BOOST_PP_TUPLE_EAT_3)(p, o, o(19, s)) +# define BOOST_PP_WHILE_19(p, o, s) BOOST_PP_IF(p(20, s), BOOST_PP_WHILE_20, s BOOST_PP_TUPLE_EAT_3)(p, o, o(20, s)) +# define BOOST_PP_WHILE_20(p, o, s) BOOST_PP_IF(p(21, s), BOOST_PP_WHILE_21, s BOOST_PP_TUPLE_EAT_3)(p, o, o(21, s)) +# define BOOST_PP_WHILE_21(p, o, s) BOOST_PP_IF(p(22, s), BOOST_PP_WHILE_22, s BOOST_PP_TUPLE_EAT_3)(p, o, o(22, s)) +# define BOOST_PP_WHILE_22(p, o, s) BOOST_PP_IF(p(23, s), BOOST_PP_WHILE_23, s BOOST_PP_TUPLE_EAT_3)(p, o, o(23, s)) +# define BOOST_PP_WHILE_23(p, o, s) BOOST_PP_IF(p(24, s), BOOST_PP_WHILE_24, s BOOST_PP_TUPLE_EAT_3)(p, o, o(24, s)) +# define BOOST_PP_WHILE_24(p, o, s) BOOST_PP_IF(p(25, s), BOOST_PP_WHILE_25, s BOOST_PP_TUPLE_EAT_3)(p, o, o(25, s)) +# define BOOST_PP_WHILE_25(p, o, s) BOOST_PP_IF(p(26, s), BOOST_PP_WHILE_26, s BOOST_PP_TUPLE_EAT_3)(p, o, o(26, s)) +# define BOOST_PP_WHILE_26(p, o, s) BOOST_PP_IF(p(27, s), BOOST_PP_WHILE_27, s BOOST_PP_TUPLE_EAT_3)(p, o, o(27, s)) +# define BOOST_PP_WHILE_27(p, o, s) BOOST_PP_IF(p(28, s), BOOST_PP_WHILE_28, s BOOST_PP_TUPLE_EAT_3)(p, o, o(28, s)) +# define BOOST_PP_WHILE_28(p, o, s) BOOST_PP_IF(p(29, s), BOOST_PP_WHILE_29, s BOOST_PP_TUPLE_EAT_3)(p, o, o(29, s)) +# define BOOST_PP_WHILE_29(p, o, s) BOOST_PP_IF(p(30, s), BOOST_PP_WHILE_30, s BOOST_PP_TUPLE_EAT_3)(p, o, o(30, s)) +# define BOOST_PP_WHILE_30(p, o, s) BOOST_PP_IF(p(31, s), BOOST_PP_WHILE_31, s BOOST_PP_TUPLE_EAT_3)(p, o, o(31, s)) +# define BOOST_PP_WHILE_31(p, o, s) BOOST_PP_IF(p(32, s), BOOST_PP_WHILE_32, s BOOST_PP_TUPLE_EAT_3)(p, o, o(32, s)) +# define BOOST_PP_WHILE_32(p, o, s) BOOST_PP_IF(p(33, s), BOOST_PP_WHILE_33, s BOOST_PP_TUPLE_EAT_3)(p, o, o(33, s)) +# define BOOST_PP_WHILE_33(p, o, s) BOOST_PP_IF(p(34, s), BOOST_PP_WHILE_34, s BOOST_PP_TUPLE_EAT_3)(p, o, o(34, s)) +# define BOOST_PP_WHILE_34(p, o, s) BOOST_PP_IF(p(35, s), BOOST_PP_WHILE_35, s BOOST_PP_TUPLE_EAT_3)(p, o, o(35, s)) +# define BOOST_PP_WHILE_35(p, o, s) BOOST_PP_IF(p(36, s), BOOST_PP_WHILE_36, s BOOST_PP_TUPLE_EAT_3)(p, o, o(36, s)) +# define BOOST_PP_WHILE_36(p, o, s) BOOST_PP_IF(p(37, s), BOOST_PP_WHILE_37, s BOOST_PP_TUPLE_EAT_3)(p, o, o(37, s)) +# define BOOST_PP_WHILE_37(p, o, s) BOOST_PP_IF(p(38, s), BOOST_PP_WHILE_38, s BOOST_PP_TUPLE_EAT_3)(p, o, o(38, s)) +# define BOOST_PP_WHILE_38(p, o, s) BOOST_PP_IF(p(39, s), BOOST_PP_WHILE_39, s BOOST_PP_TUPLE_EAT_3)(p, o, o(39, s)) +# define BOOST_PP_WHILE_39(p, o, s) BOOST_PP_IF(p(40, s), BOOST_PP_WHILE_40, s BOOST_PP_TUPLE_EAT_3)(p, o, o(40, s)) +# define BOOST_PP_WHILE_40(p, o, s) BOOST_PP_IF(p(41, s), BOOST_PP_WHILE_41, s BOOST_PP_TUPLE_EAT_3)(p, o, o(41, s)) +# define BOOST_PP_WHILE_41(p, o, s) BOOST_PP_IF(p(42, s), BOOST_PP_WHILE_42, s BOOST_PP_TUPLE_EAT_3)(p, o, o(42, s)) +# define BOOST_PP_WHILE_42(p, o, s) BOOST_PP_IF(p(43, s), BOOST_PP_WHILE_43, s BOOST_PP_TUPLE_EAT_3)(p, o, o(43, s)) +# define BOOST_PP_WHILE_43(p, o, s) BOOST_PP_IF(p(44, s), BOOST_PP_WHILE_44, s BOOST_PP_TUPLE_EAT_3)(p, o, o(44, s)) +# define BOOST_PP_WHILE_44(p, o, s) BOOST_PP_IF(p(45, s), BOOST_PP_WHILE_45, s BOOST_PP_TUPLE_EAT_3)(p, o, o(45, s)) +# define BOOST_PP_WHILE_45(p, o, s) BOOST_PP_IF(p(46, s), BOOST_PP_WHILE_46, s BOOST_PP_TUPLE_EAT_3)(p, o, o(46, s)) +# define BOOST_PP_WHILE_46(p, o, s) BOOST_PP_IF(p(47, s), BOOST_PP_WHILE_47, s BOOST_PP_TUPLE_EAT_3)(p, o, o(47, s)) +# define BOOST_PP_WHILE_47(p, o, s) BOOST_PP_IF(p(48, s), BOOST_PP_WHILE_48, s BOOST_PP_TUPLE_EAT_3)(p, o, o(48, s)) +# define BOOST_PP_WHILE_48(p, o, s) BOOST_PP_IF(p(49, s), BOOST_PP_WHILE_49, s BOOST_PP_TUPLE_EAT_3)(p, o, o(49, s)) +# define BOOST_PP_WHILE_49(p, o, s) BOOST_PP_IF(p(50, s), BOOST_PP_WHILE_50, s BOOST_PP_TUPLE_EAT_3)(p, o, o(50, s)) +# define BOOST_PP_WHILE_50(p, o, s) BOOST_PP_IF(p(51, s), BOOST_PP_WHILE_51, s BOOST_PP_TUPLE_EAT_3)(p, o, o(51, s)) +# define BOOST_PP_WHILE_51(p, o, s) BOOST_PP_IF(p(52, s), BOOST_PP_WHILE_52, s BOOST_PP_TUPLE_EAT_3)(p, o, o(52, s)) +# define BOOST_PP_WHILE_52(p, o, s) BOOST_PP_IF(p(53, s), BOOST_PP_WHILE_53, s BOOST_PP_TUPLE_EAT_3)(p, o, o(53, s)) +# define BOOST_PP_WHILE_53(p, o, s) BOOST_PP_IF(p(54, s), BOOST_PP_WHILE_54, s BOOST_PP_TUPLE_EAT_3)(p, o, o(54, s)) +# define BOOST_PP_WHILE_54(p, o, s) BOOST_PP_IF(p(55, s), BOOST_PP_WHILE_55, s BOOST_PP_TUPLE_EAT_3)(p, o, o(55, s)) +# define BOOST_PP_WHILE_55(p, o, s) BOOST_PP_IF(p(56, s), BOOST_PP_WHILE_56, s BOOST_PP_TUPLE_EAT_3)(p, o, o(56, s)) +# define BOOST_PP_WHILE_56(p, o, s) BOOST_PP_IF(p(57, s), BOOST_PP_WHILE_57, s BOOST_PP_TUPLE_EAT_3)(p, o, o(57, s)) +# define BOOST_PP_WHILE_57(p, o, s) BOOST_PP_IF(p(58, s), BOOST_PP_WHILE_58, s BOOST_PP_TUPLE_EAT_3)(p, o, o(58, s)) +# define BOOST_PP_WHILE_58(p, o, s) BOOST_PP_IF(p(59, s), BOOST_PP_WHILE_59, s BOOST_PP_TUPLE_EAT_3)(p, o, o(59, s)) +# define BOOST_PP_WHILE_59(p, o, s) BOOST_PP_IF(p(60, s), BOOST_PP_WHILE_60, s BOOST_PP_TUPLE_EAT_3)(p, o, o(60, s)) +# define BOOST_PP_WHILE_60(p, o, s) BOOST_PP_IF(p(61, s), BOOST_PP_WHILE_61, s BOOST_PP_TUPLE_EAT_3)(p, o, o(61, s)) +# define BOOST_PP_WHILE_61(p, o, s) BOOST_PP_IF(p(62, s), BOOST_PP_WHILE_62, s BOOST_PP_TUPLE_EAT_3)(p, o, o(62, s)) +# define BOOST_PP_WHILE_62(p, o, s) BOOST_PP_IF(p(63, s), BOOST_PP_WHILE_63, s BOOST_PP_TUPLE_EAT_3)(p, o, o(63, s)) +# define BOOST_PP_WHILE_63(p, o, s) BOOST_PP_IF(p(64, s), BOOST_PP_WHILE_64, s BOOST_PP_TUPLE_EAT_3)(p, o, o(64, s)) +# define BOOST_PP_WHILE_64(p, o, s) BOOST_PP_IF(p(65, s), BOOST_PP_WHILE_65, s BOOST_PP_TUPLE_EAT_3)(p, o, o(65, s)) +# define BOOST_PP_WHILE_65(p, o, s) BOOST_PP_IF(p(66, s), BOOST_PP_WHILE_66, s BOOST_PP_TUPLE_EAT_3)(p, o, o(66, s)) +# define BOOST_PP_WHILE_66(p, o, s) BOOST_PP_IF(p(67, s), BOOST_PP_WHILE_67, s BOOST_PP_TUPLE_EAT_3)(p, o, o(67, s)) +# define BOOST_PP_WHILE_67(p, o, s) BOOST_PP_IF(p(68, s), BOOST_PP_WHILE_68, s BOOST_PP_TUPLE_EAT_3)(p, o, o(68, s)) +# define BOOST_PP_WHILE_68(p, o, s) BOOST_PP_IF(p(69, s), BOOST_PP_WHILE_69, s BOOST_PP_TUPLE_EAT_3)(p, o, o(69, s)) +# define BOOST_PP_WHILE_69(p, o, s) BOOST_PP_IF(p(70, s), BOOST_PP_WHILE_70, s BOOST_PP_TUPLE_EAT_3)(p, o, o(70, s)) +# define BOOST_PP_WHILE_70(p, o, s) BOOST_PP_IF(p(71, s), BOOST_PP_WHILE_71, s BOOST_PP_TUPLE_EAT_3)(p, o, o(71, s)) +# define BOOST_PP_WHILE_71(p, o, s) BOOST_PP_IF(p(72, s), BOOST_PP_WHILE_72, s BOOST_PP_TUPLE_EAT_3)(p, o, o(72, s)) +# define BOOST_PP_WHILE_72(p, o, s) BOOST_PP_IF(p(73, s), BOOST_PP_WHILE_73, s BOOST_PP_TUPLE_EAT_3)(p, o, o(73, s)) +# define BOOST_PP_WHILE_73(p, o, s) BOOST_PP_IF(p(74, s), BOOST_PP_WHILE_74, s BOOST_PP_TUPLE_EAT_3)(p, o, o(74, s)) +# define BOOST_PP_WHILE_74(p, o, s) BOOST_PP_IF(p(75, s), BOOST_PP_WHILE_75, s BOOST_PP_TUPLE_EAT_3)(p, o, o(75, s)) +# define BOOST_PP_WHILE_75(p, o, s) BOOST_PP_IF(p(76, s), BOOST_PP_WHILE_76, s BOOST_PP_TUPLE_EAT_3)(p, o, o(76, s)) +# define BOOST_PP_WHILE_76(p, o, s) BOOST_PP_IF(p(77, s), BOOST_PP_WHILE_77, s BOOST_PP_TUPLE_EAT_3)(p, o, o(77, s)) +# define BOOST_PP_WHILE_77(p, o, s) BOOST_PP_IF(p(78, s), BOOST_PP_WHILE_78, s BOOST_PP_TUPLE_EAT_3)(p, o, o(78, s)) +# define BOOST_PP_WHILE_78(p, o, s) BOOST_PP_IF(p(79, s), BOOST_PP_WHILE_79, s BOOST_PP_TUPLE_EAT_3)(p, o, o(79, s)) +# define BOOST_PP_WHILE_79(p, o, s) BOOST_PP_IF(p(80, s), BOOST_PP_WHILE_80, s BOOST_PP_TUPLE_EAT_3)(p, o, o(80, s)) +# define BOOST_PP_WHILE_80(p, o, s) BOOST_PP_IF(p(81, s), BOOST_PP_WHILE_81, s BOOST_PP_TUPLE_EAT_3)(p, o, o(81, s)) +# define BOOST_PP_WHILE_81(p, o, s) BOOST_PP_IF(p(82, s), BOOST_PP_WHILE_82, s BOOST_PP_TUPLE_EAT_3)(p, o, o(82, s)) +# define BOOST_PP_WHILE_82(p, o, s) BOOST_PP_IF(p(83, s), BOOST_PP_WHILE_83, s BOOST_PP_TUPLE_EAT_3)(p, o, o(83, s)) +# define BOOST_PP_WHILE_83(p, o, s) BOOST_PP_IF(p(84, s), BOOST_PP_WHILE_84, s BOOST_PP_TUPLE_EAT_3)(p, o, o(84, s)) +# define BOOST_PP_WHILE_84(p, o, s) BOOST_PP_IF(p(85, s), BOOST_PP_WHILE_85, s BOOST_PP_TUPLE_EAT_3)(p, o, o(85, s)) +# define BOOST_PP_WHILE_85(p, o, s) BOOST_PP_IF(p(86, s), BOOST_PP_WHILE_86, s BOOST_PP_TUPLE_EAT_3)(p, o, o(86, s)) +# define BOOST_PP_WHILE_86(p, o, s) BOOST_PP_IF(p(87, s), BOOST_PP_WHILE_87, s BOOST_PP_TUPLE_EAT_3)(p, o, o(87, s)) +# define BOOST_PP_WHILE_87(p, o, s) BOOST_PP_IF(p(88, s), BOOST_PP_WHILE_88, s BOOST_PP_TUPLE_EAT_3)(p, o, o(88, s)) +# define BOOST_PP_WHILE_88(p, o, s) BOOST_PP_IF(p(89, s), BOOST_PP_WHILE_89, s BOOST_PP_TUPLE_EAT_3)(p, o, o(89, s)) +# define BOOST_PP_WHILE_89(p, o, s) BOOST_PP_IF(p(90, s), BOOST_PP_WHILE_90, s BOOST_PP_TUPLE_EAT_3)(p, o, o(90, s)) +# define BOOST_PP_WHILE_90(p, o, s) BOOST_PP_IF(p(91, s), BOOST_PP_WHILE_91, s BOOST_PP_TUPLE_EAT_3)(p, o, o(91, s)) +# define BOOST_PP_WHILE_91(p, o, s) BOOST_PP_IF(p(92, s), BOOST_PP_WHILE_92, s BOOST_PP_TUPLE_EAT_3)(p, o, o(92, s)) +# define BOOST_PP_WHILE_92(p, o, s) BOOST_PP_IF(p(93, s), BOOST_PP_WHILE_93, s BOOST_PP_TUPLE_EAT_3)(p, o, o(93, s)) +# define BOOST_PP_WHILE_93(p, o, s) BOOST_PP_IF(p(94, s), BOOST_PP_WHILE_94, s BOOST_PP_TUPLE_EAT_3)(p, o, o(94, s)) +# define BOOST_PP_WHILE_94(p, o, s) BOOST_PP_IF(p(95, s), BOOST_PP_WHILE_95, s BOOST_PP_TUPLE_EAT_3)(p, o, o(95, s)) +# define BOOST_PP_WHILE_95(p, o, s) BOOST_PP_IF(p(96, s), BOOST_PP_WHILE_96, s BOOST_PP_TUPLE_EAT_3)(p, o, o(96, s)) +# define BOOST_PP_WHILE_96(p, o, s) BOOST_PP_IF(p(97, s), BOOST_PP_WHILE_97, s BOOST_PP_TUPLE_EAT_3)(p, o, o(97, s)) +# define BOOST_PP_WHILE_97(p, o, s) BOOST_PP_IF(p(98, s), BOOST_PP_WHILE_98, s BOOST_PP_TUPLE_EAT_3)(p, o, o(98, s)) +# define BOOST_PP_WHILE_98(p, o, s) BOOST_PP_IF(p(99, s), BOOST_PP_WHILE_99, s BOOST_PP_TUPLE_EAT_3)(p, o, o(99, s)) +# define BOOST_PP_WHILE_99(p, o, s) BOOST_PP_IF(p(100, s), BOOST_PP_WHILE_100, s BOOST_PP_TUPLE_EAT_3)(p, o, o(100, s)) +# define BOOST_PP_WHILE_100(p, o, s) BOOST_PP_IF(p(101, s), BOOST_PP_WHILE_101, s BOOST_PP_TUPLE_EAT_3)(p, o, o(101, s)) +# define BOOST_PP_WHILE_101(p, o, s) BOOST_PP_IF(p(102, s), BOOST_PP_WHILE_102, s BOOST_PP_TUPLE_EAT_3)(p, o, o(102, s)) +# define BOOST_PP_WHILE_102(p, o, s) BOOST_PP_IF(p(103, s), BOOST_PP_WHILE_103, s BOOST_PP_TUPLE_EAT_3)(p, o, o(103, s)) +# define BOOST_PP_WHILE_103(p, o, s) BOOST_PP_IF(p(104, s), BOOST_PP_WHILE_104, s BOOST_PP_TUPLE_EAT_3)(p, o, o(104, s)) +# define BOOST_PP_WHILE_104(p, o, s) BOOST_PP_IF(p(105, s), BOOST_PP_WHILE_105, s BOOST_PP_TUPLE_EAT_3)(p, o, o(105, s)) +# define BOOST_PP_WHILE_105(p, o, s) BOOST_PP_IF(p(106, s), BOOST_PP_WHILE_106, s BOOST_PP_TUPLE_EAT_3)(p, o, o(106, s)) +# define BOOST_PP_WHILE_106(p, o, s) BOOST_PP_IF(p(107, s), BOOST_PP_WHILE_107, s BOOST_PP_TUPLE_EAT_3)(p, o, o(107, s)) +# define BOOST_PP_WHILE_107(p, o, s) BOOST_PP_IF(p(108, s), BOOST_PP_WHILE_108, s BOOST_PP_TUPLE_EAT_3)(p, o, o(108, s)) +# define BOOST_PP_WHILE_108(p, o, s) BOOST_PP_IF(p(109, s), BOOST_PP_WHILE_109, s BOOST_PP_TUPLE_EAT_3)(p, o, o(109, s)) +# define BOOST_PP_WHILE_109(p, o, s) BOOST_PP_IF(p(110, s), BOOST_PP_WHILE_110, s BOOST_PP_TUPLE_EAT_3)(p, o, o(110, s)) +# define BOOST_PP_WHILE_110(p, o, s) BOOST_PP_IF(p(111, s), BOOST_PP_WHILE_111, s BOOST_PP_TUPLE_EAT_3)(p, o, o(111, s)) +# define BOOST_PP_WHILE_111(p, o, s) BOOST_PP_IF(p(112, s), BOOST_PP_WHILE_112, s BOOST_PP_TUPLE_EAT_3)(p, o, o(112, s)) +# define BOOST_PP_WHILE_112(p, o, s) BOOST_PP_IF(p(113, s), BOOST_PP_WHILE_113, s BOOST_PP_TUPLE_EAT_3)(p, o, o(113, s)) +# define BOOST_PP_WHILE_113(p, o, s) BOOST_PP_IF(p(114, s), BOOST_PP_WHILE_114, s BOOST_PP_TUPLE_EAT_3)(p, o, o(114, s)) +# define BOOST_PP_WHILE_114(p, o, s) BOOST_PP_IF(p(115, s), BOOST_PP_WHILE_115, s BOOST_PP_TUPLE_EAT_3)(p, o, o(115, s)) +# define BOOST_PP_WHILE_115(p, o, s) BOOST_PP_IF(p(116, s), BOOST_PP_WHILE_116, s BOOST_PP_TUPLE_EAT_3)(p, o, o(116, s)) +# define BOOST_PP_WHILE_116(p, o, s) BOOST_PP_IF(p(117, s), BOOST_PP_WHILE_117, s BOOST_PP_TUPLE_EAT_3)(p, o, o(117, s)) +# define BOOST_PP_WHILE_117(p, o, s) BOOST_PP_IF(p(118, s), BOOST_PP_WHILE_118, s BOOST_PP_TUPLE_EAT_3)(p, o, o(118, s)) +# define BOOST_PP_WHILE_118(p, o, s) BOOST_PP_IF(p(119, s), BOOST_PP_WHILE_119, s BOOST_PP_TUPLE_EAT_3)(p, o, o(119, s)) +# define BOOST_PP_WHILE_119(p, o, s) BOOST_PP_IF(p(120, s), BOOST_PP_WHILE_120, s BOOST_PP_TUPLE_EAT_3)(p, o, o(120, s)) +# define BOOST_PP_WHILE_120(p, o, s) BOOST_PP_IF(p(121, s), BOOST_PP_WHILE_121, s BOOST_PP_TUPLE_EAT_3)(p, o, o(121, s)) +# define BOOST_PP_WHILE_121(p, o, s) BOOST_PP_IF(p(122, s), BOOST_PP_WHILE_122, s BOOST_PP_TUPLE_EAT_3)(p, o, o(122, s)) +# define BOOST_PP_WHILE_122(p, o, s) BOOST_PP_IF(p(123, s), BOOST_PP_WHILE_123, s BOOST_PP_TUPLE_EAT_3)(p, o, o(123, s)) +# define BOOST_PP_WHILE_123(p, o, s) BOOST_PP_IF(p(124, s), BOOST_PP_WHILE_124, s BOOST_PP_TUPLE_EAT_3)(p, o, o(124, s)) +# define BOOST_PP_WHILE_124(p, o, s) BOOST_PP_IF(p(125, s), BOOST_PP_WHILE_125, s BOOST_PP_TUPLE_EAT_3)(p, o, o(125, s)) +# define BOOST_PP_WHILE_125(p, o, s) BOOST_PP_IF(p(126, s), BOOST_PP_WHILE_126, s BOOST_PP_TUPLE_EAT_3)(p, o, o(126, s)) +# define BOOST_PP_WHILE_126(p, o, s) BOOST_PP_IF(p(127, s), BOOST_PP_WHILE_127, s BOOST_PP_TUPLE_EAT_3)(p, o, o(127, s)) +# define BOOST_PP_WHILE_127(p, o, s) BOOST_PP_IF(p(128, s), BOOST_PP_WHILE_128, s BOOST_PP_TUPLE_EAT_3)(p, o, o(128, s)) +# define BOOST_PP_WHILE_128(p, o, s) BOOST_PP_IF(p(129, s), BOOST_PP_WHILE_129, s BOOST_PP_TUPLE_EAT_3)(p, o, o(129, s)) +# define BOOST_PP_WHILE_129(p, o, s) BOOST_PP_IF(p(130, s), BOOST_PP_WHILE_130, s BOOST_PP_TUPLE_EAT_3)(p, o, o(130, s)) +# define BOOST_PP_WHILE_130(p, o, s) BOOST_PP_IF(p(131, s), BOOST_PP_WHILE_131, s BOOST_PP_TUPLE_EAT_3)(p, o, o(131, s)) +# define BOOST_PP_WHILE_131(p, o, s) BOOST_PP_IF(p(132, s), BOOST_PP_WHILE_132, s BOOST_PP_TUPLE_EAT_3)(p, o, o(132, s)) +# define BOOST_PP_WHILE_132(p, o, s) BOOST_PP_IF(p(133, s), BOOST_PP_WHILE_133, s BOOST_PP_TUPLE_EAT_3)(p, o, o(133, s)) +# define BOOST_PP_WHILE_133(p, o, s) BOOST_PP_IF(p(134, s), BOOST_PP_WHILE_134, s BOOST_PP_TUPLE_EAT_3)(p, o, o(134, s)) +# define BOOST_PP_WHILE_134(p, o, s) BOOST_PP_IF(p(135, s), BOOST_PP_WHILE_135, s BOOST_PP_TUPLE_EAT_3)(p, o, o(135, s)) +# define BOOST_PP_WHILE_135(p, o, s) BOOST_PP_IF(p(136, s), BOOST_PP_WHILE_136, s BOOST_PP_TUPLE_EAT_3)(p, o, o(136, s)) +# define BOOST_PP_WHILE_136(p, o, s) BOOST_PP_IF(p(137, s), BOOST_PP_WHILE_137, s BOOST_PP_TUPLE_EAT_3)(p, o, o(137, s)) +# define BOOST_PP_WHILE_137(p, o, s) BOOST_PP_IF(p(138, s), BOOST_PP_WHILE_138, s BOOST_PP_TUPLE_EAT_3)(p, o, o(138, s)) +# define BOOST_PP_WHILE_138(p, o, s) BOOST_PP_IF(p(139, s), BOOST_PP_WHILE_139, s BOOST_PP_TUPLE_EAT_3)(p, o, o(139, s)) +# define BOOST_PP_WHILE_139(p, o, s) BOOST_PP_IF(p(140, s), BOOST_PP_WHILE_140, s BOOST_PP_TUPLE_EAT_3)(p, o, o(140, s)) +# define BOOST_PP_WHILE_140(p, o, s) BOOST_PP_IF(p(141, s), BOOST_PP_WHILE_141, s BOOST_PP_TUPLE_EAT_3)(p, o, o(141, s)) +# define BOOST_PP_WHILE_141(p, o, s) BOOST_PP_IF(p(142, s), BOOST_PP_WHILE_142, s BOOST_PP_TUPLE_EAT_3)(p, o, o(142, s)) +# define BOOST_PP_WHILE_142(p, o, s) BOOST_PP_IF(p(143, s), BOOST_PP_WHILE_143, s BOOST_PP_TUPLE_EAT_3)(p, o, o(143, s)) +# define BOOST_PP_WHILE_143(p, o, s) BOOST_PP_IF(p(144, s), BOOST_PP_WHILE_144, s BOOST_PP_TUPLE_EAT_3)(p, o, o(144, s)) +# define BOOST_PP_WHILE_144(p, o, s) BOOST_PP_IF(p(145, s), BOOST_PP_WHILE_145, s BOOST_PP_TUPLE_EAT_3)(p, o, o(145, s)) +# define BOOST_PP_WHILE_145(p, o, s) BOOST_PP_IF(p(146, s), BOOST_PP_WHILE_146, s BOOST_PP_TUPLE_EAT_3)(p, o, o(146, s)) +# define BOOST_PP_WHILE_146(p, o, s) BOOST_PP_IF(p(147, s), BOOST_PP_WHILE_147, s BOOST_PP_TUPLE_EAT_3)(p, o, o(147, s)) +# define BOOST_PP_WHILE_147(p, o, s) BOOST_PP_IF(p(148, s), BOOST_PP_WHILE_148, s BOOST_PP_TUPLE_EAT_3)(p, o, o(148, s)) +# define BOOST_PP_WHILE_148(p, o, s) BOOST_PP_IF(p(149, s), BOOST_PP_WHILE_149, s BOOST_PP_TUPLE_EAT_3)(p, o, o(149, s)) +# define BOOST_PP_WHILE_149(p, o, s) BOOST_PP_IF(p(150, s), BOOST_PP_WHILE_150, s BOOST_PP_TUPLE_EAT_3)(p, o, o(150, s)) +# define BOOST_PP_WHILE_150(p, o, s) BOOST_PP_IF(p(151, s), BOOST_PP_WHILE_151, s BOOST_PP_TUPLE_EAT_3)(p, o, o(151, s)) +# define BOOST_PP_WHILE_151(p, o, s) BOOST_PP_IF(p(152, s), BOOST_PP_WHILE_152, s BOOST_PP_TUPLE_EAT_3)(p, o, o(152, s)) +# define BOOST_PP_WHILE_152(p, o, s) BOOST_PP_IF(p(153, s), BOOST_PP_WHILE_153, s BOOST_PP_TUPLE_EAT_3)(p, o, o(153, s)) +# define BOOST_PP_WHILE_153(p, o, s) BOOST_PP_IF(p(154, s), BOOST_PP_WHILE_154, s BOOST_PP_TUPLE_EAT_3)(p, o, o(154, s)) +# define BOOST_PP_WHILE_154(p, o, s) BOOST_PP_IF(p(155, s), BOOST_PP_WHILE_155, s BOOST_PP_TUPLE_EAT_3)(p, o, o(155, s)) +# define BOOST_PP_WHILE_155(p, o, s) BOOST_PP_IF(p(156, s), BOOST_PP_WHILE_156, s BOOST_PP_TUPLE_EAT_3)(p, o, o(156, s)) +# define BOOST_PP_WHILE_156(p, o, s) BOOST_PP_IF(p(157, s), BOOST_PP_WHILE_157, s BOOST_PP_TUPLE_EAT_3)(p, o, o(157, s)) +# define BOOST_PP_WHILE_157(p, o, s) BOOST_PP_IF(p(158, s), BOOST_PP_WHILE_158, s BOOST_PP_TUPLE_EAT_3)(p, o, o(158, s)) +# define BOOST_PP_WHILE_158(p, o, s) BOOST_PP_IF(p(159, s), BOOST_PP_WHILE_159, s BOOST_PP_TUPLE_EAT_3)(p, o, o(159, s)) +# define BOOST_PP_WHILE_159(p, o, s) BOOST_PP_IF(p(160, s), BOOST_PP_WHILE_160, s BOOST_PP_TUPLE_EAT_3)(p, o, o(160, s)) +# define BOOST_PP_WHILE_160(p, o, s) BOOST_PP_IF(p(161, s), BOOST_PP_WHILE_161, s BOOST_PP_TUPLE_EAT_3)(p, o, o(161, s)) +# define BOOST_PP_WHILE_161(p, o, s) BOOST_PP_IF(p(162, s), BOOST_PP_WHILE_162, s BOOST_PP_TUPLE_EAT_3)(p, o, o(162, s)) +# define BOOST_PP_WHILE_162(p, o, s) BOOST_PP_IF(p(163, s), BOOST_PP_WHILE_163, s BOOST_PP_TUPLE_EAT_3)(p, o, o(163, s)) +# define BOOST_PP_WHILE_163(p, o, s) BOOST_PP_IF(p(164, s), BOOST_PP_WHILE_164, s BOOST_PP_TUPLE_EAT_3)(p, o, o(164, s)) +# define BOOST_PP_WHILE_164(p, o, s) BOOST_PP_IF(p(165, s), BOOST_PP_WHILE_165, s BOOST_PP_TUPLE_EAT_3)(p, o, o(165, s)) +# define BOOST_PP_WHILE_165(p, o, s) BOOST_PP_IF(p(166, s), BOOST_PP_WHILE_166, s BOOST_PP_TUPLE_EAT_3)(p, o, o(166, s)) +# define BOOST_PP_WHILE_166(p, o, s) BOOST_PP_IF(p(167, s), BOOST_PP_WHILE_167, s BOOST_PP_TUPLE_EAT_3)(p, o, o(167, s)) +# define BOOST_PP_WHILE_167(p, o, s) BOOST_PP_IF(p(168, s), BOOST_PP_WHILE_168, s BOOST_PP_TUPLE_EAT_3)(p, o, o(168, s)) +# define BOOST_PP_WHILE_168(p, o, s) BOOST_PP_IF(p(169, s), BOOST_PP_WHILE_169, s BOOST_PP_TUPLE_EAT_3)(p, o, o(169, s)) +# define BOOST_PP_WHILE_169(p, o, s) BOOST_PP_IF(p(170, s), BOOST_PP_WHILE_170, s BOOST_PP_TUPLE_EAT_3)(p, o, o(170, s)) +# define BOOST_PP_WHILE_170(p, o, s) BOOST_PP_IF(p(171, s), BOOST_PP_WHILE_171, s BOOST_PP_TUPLE_EAT_3)(p, o, o(171, s)) +# define BOOST_PP_WHILE_171(p, o, s) BOOST_PP_IF(p(172, s), BOOST_PP_WHILE_172, s BOOST_PP_TUPLE_EAT_3)(p, o, o(172, s)) +# define BOOST_PP_WHILE_172(p, o, s) BOOST_PP_IF(p(173, s), BOOST_PP_WHILE_173, s BOOST_PP_TUPLE_EAT_3)(p, o, o(173, s)) +# define BOOST_PP_WHILE_173(p, o, s) BOOST_PP_IF(p(174, s), BOOST_PP_WHILE_174, s BOOST_PP_TUPLE_EAT_3)(p, o, o(174, s)) +# define BOOST_PP_WHILE_174(p, o, s) BOOST_PP_IF(p(175, s), BOOST_PP_WHILE_175, s BOOST_PP_TUPLE_EAT_3)(p, o, o(175, s)) +# define BOOST_PP_WHILE_175(p, o, s) BOOST_PP_IF(p(176, s), BOOST_PP_WHILE_176, s BOOST_PP_TUPLE_EAT_3)(p, o, o(176, s)) +# define BOOST_PP_WHILE_176(p, o, s) BOOST_PP_IF(p(177, s), BOOST_PP_WHILE_177, s BOOST_PP_TUPLE_EAT_3)(p, o, o(177, s)) +# define BOOST_PP_WHILE_177(p, o, s) BOOST_PP_IF(p(178, s), BOOST_PP_WHILE_178, s BOOST_PP_TUPLE_EAT_3)(p, o, o(178, s)) +# define BOOST_PP_WHILE_178(p, o, s) BOOST_PP_IF(p(179, s), BOOST_PP_WHILE_179, s BOOST_PP_TUPLE_EAT_3)(p, o, o(179, s)) +# define BOOST_PP_WHILE_179(p, o, s) BOOST_PP_IF(p(180, s), BOOST_PP_WHILE_180, s BOOST_PP_TUPLE_EAT_3)(p, o, o(180, s)) +# define BOOST_PP_WHILE_180(p, o, s) BOOST_PP_IF(p(181, s), BOOST_PP_WHILE_181, s BOOST_PP_TUPLE_EAT_3)(p, o, o(181, s)) +# define BOOST_PP_WHILE_181(p, o, s) BOOST_PP_IF(p(182, s), BOOST_PP_WHILE_182, s BOOST_PP_TUPLE_EAT_3)(p, o, o(182, s)) +# define BOOST_PP_WHILE_182(p, o, s) BOOST_PP_IF(p(183, s), BOOST_PP_WHILE_183, s BOOST_PP_TUPLE_EAT_3)(p, o, o(183, s)) +# define BOOST_PP_WHILE_183(p, o, s) BOOST_PP_IF(p(184, s), BOOST_PP_WHILE_184, s BOOST_PP_TUPLE_EAT_3)(p, o, o(184, s)) +# define BOOST_PP_WHILE_184(p, o, s) BOOST_PP_IF(p(185, s), BOOST_PP_WHILE_185, s BOOST_PP_TUPLE_EAT_3)(p, o, o(185, s)) +# define BOOST_PP_WHILE_185(p, o, s) BOOST_PP_IF(p(186, s), BOOST_PP_WHILE_186, s BOOST_PP_TUPLE_EAT_3)(p, o, o(186, s)) +# define BOOST_PP_WHILE_186(p, o, s) BOOST_PP_IF(p(187, s), BOOST_PP_WHILE_187, s BOOST_PP_TUPLE_EAT_3)(p, o, o(187, s)) +# define BOOST_PP_WHILE_187(p, o, s) BOOST_PP_IF(p(188, s), BOOST_PP_WHILE_188, s BOOST_PP_TUPLE_EAT_3)(p, o, o(188, s)) +# define BOOST_PP_WHILE_188(p, o, s) BOOST_PP_IF(p(189, s), BOOST_PP_WHILE_189, s BOOST_PP_TUPLE_EAT_3)(p, o, o(189, s)) +# define BOOST_PP_WHILE_189(p, o, s) BOOST_PP_IF(p(190, s), BOOST_PP_WHILE_190, s BOOST_PP_TUPLE_EAT_3)(p, o, o(190, s)) +# define BOOST_PP_WHILE_190(p, o, s) BOOST_PP_IF(p(191, s), BOOST_PP_WHILE_191, s BOOST_PP_TUPLE_EAT_3)(p, o, o(191, s)) +# define BOOST_PP_WHILE_191(p, o, s) BOOST_PP_IF(p(192, s), BOOST_PP_WHILE_192, s BOOST_PP_TUPLE_EAT_3)(p, o, o(192, s)) +# define BOOST_PP_WHILE_192(p, o, s) BOOST_PP_IF(p(193, s), BOOST_PP_WHILE_193, s BOOST_PP_TUPLE_EAT_3)(p, o, o(193, s)) +# define BOOST_PP_WHILE_193(p, o, s) BOOST_PP_IF(p(194, s), BOOST_PP_WHILE_194, s BOOST_PP_TUPLE_EAT_3)(p, o, o(194, s)) +# define BOOST_PP_WHILE_194(p, o, s) BOOST_PP_IF(p(195, s), BOOST_PP_WHILE_195, s BOOST_PP_TUPLE_EAT_3)(p, o, o(195, s)) +# define BOOST_PP_WHILE_195(p, o, s) BOOST_PP_IF(p(196, s), BOOST_PP_WHILE_196, s BOOST_PP_TUPLE_EAT_3)(p, o, o(196, s)) +# define BOOST_PP_WHILE_196(p, o, s) BOOST_PP_IF(p(197, s), BOOST_PP_WHILE_197, s BOOST_PP_TUPLE_EAT_3)(p, o, o(197, s)) +# define BOOST_PP_WHILE_197(p, o, s) BOOST_PP_IF(p(198, s), BOOST_PP_WHILE_198, s BOOST_PP_TUPLE_EAT_3)(p, o, o(198, s)) +# define BOOST_PP_WHILE_198(p, o, s) BOOST_PP_IF(p(199, s), BOOST_PP_WHILE_199, s BOOST_PP_TUPLE_EAT_3)(p, o, o(199, s)) +# define BOOST_PP_WHILE_199(p, o, s) BOOST_PP_IF(p(200, s), BOOST_PP_WHILE_200, s BOOST_PP_TUPLE_EAT_3)(p, o, o(200, s)) +# define BOOST_PP_WHILE_200(p, o, s) BOOST_PP_IF(p(201, s), BOOST_PP_WHILE_201, s BOOST_PP_TUPLE_EAT_3)(p, o, o(201, s)) +# define BOOST_PP_WHILE_201(p, o, s) BOOST_PP_IF(p(202, s), BOOST_PP_WHILE_202, s BOOST_PP_TUPLE_EAT_3)(p, o, o(202, s)) +# define BOOST_PP_WHILE_202(p, o, s) BOOST_PP_IF(p(203, s), BOOST_PP_WHILE_203, s BOOST_PP_TUPLE_EAT_3)(p, o, o(203, s)) +# define BOOST_PP_WHILE_203(p, o, s) BOOST_PP_IF(p(204, s), BOOST_PP_WHILE_204, s BOOST_PP_TUPLE_EAT_3)(p, o, o(204, s)) +# define BOOST_PP_WHILE_204(p, o, s) BOOST_PP_IF(p(205, s), BOOST_PP_WHILE_205, s BOOST_PP_TUPLE_EAT_3)(p, o, o(205, s)) +# define BOOST_PP_WHILE_205(p, o, s) BOOST_PP_IF(p(206, s), BOOST_PP_WHILE_206, s BOOST_PP_TUPLE_EAT_3)(p, o, o(206, s)) +# define BOOST_PP_WHILE_206(p, o, s) BOOST_PP_IF(p(207, s), BOOST_PP_WHILE_207, s BOOST_PP_TUPLE_EAT_3)(p, o, o(207, s)) +# define BOOST_PP_WHILE_207(p, o, s) BOOST_PP_IF(p(208, s), BOOST_PP_WHILE_208, s BOOST_PP_TUPLE_EAT_3)(p, o, o(208, s)) +# define BOOST_PP_WHILE_208(p, o, s) BOOST_PP_IF(p(209, s), BOOST_PP_WHILE_209, s BOOST_PP_TUPLE_EAT_3)(p, o, o(209, s)) +# define BOOST_PP_WHILE_209(p, o, s) BOOST_PP_IF(p(210, s), BOOST_PP_WHILE_210, s BOOST_PP_TUPLE_EAT_3)(p, o, o(210, s)) +# define BOOST_PP_WHILE_210(p, o, s) BOOST_PP_IF(p(211, s), BOOST_PP_WHILE_211, s BOOST_PP_TUPLE_EAT_3)(p, o, o(211, s)) +# define BOOST_PP_WHILE_211(p, o, s) BOOST_PP_IF(p(212, s), BOOST_PP_WHILE_212, s BOOST_PP_TUPLE_EAT_3)(p, o, o(212, s)) +# define BOOST_PP_WHILE_212(p, o, s) BOOST_PP_IF(p(213, s), BOOST_PP_WHILE_213, s BOOST_PP_TUPLE_EAT_3)(p, o, o(213, s)) +# define BOOST_PP_WHILE_213(p, o, s) BOOST_PP_IF(p(214, s), BOOST_PP_WHILE_214, s BOOST_PP_TUPLE_EAT_3)(p, o, o(214, s)) +# define BOOST_PP_WHILE_214(p, o, s) BOOST_PP_IF(p(215, s), BOOST_PP_WHILE_215, s BOOST_PP_TUPLE_EAT_3)(p, o, o(215, s)) +# define BOOST_PP_WHILE_215(p, o, s) BOOST_PP_IF(p(216, s), BOOST_PP_WHILE_216, s BOOST_PP_TUPLE_EAT_3)(p, o, o(216, s)) +# define BOOST_PP_WHILE_216(p, o, s) BOOST_PP_IF(p(217, s), BOOST_PP_WHILE_217, s BOOST_PP_TUPLE_EAT_3)(p, o, o(217, s)) +# define BOOST_PP_WHILE_217(p, o, s) BOOST_PP_IF(p(218, s), BOOST_PP_WHILE_218, s BOOST_PP_TUPLE_EAT_3)(p, o, o(218, s)) +# define BOOST_PP_WHILE_218(p, o, s) BOOST_PP_IF(p(219, s), BOOST_PP_WHILE_219, s BOOST_PP_TUPLE_EAT_3)(p, o, o(219, s)) +# define BOOST_PP_WHILE_219(p, o, s) BOOST_PP_IF(p(220, s), BOOST_PP_WHILE_220, s BOOST_PP_TUPLE_EAT_3)(p, o, o(220, s)) +# define BOOST_PP_WHILE_220(p, o, s) BOOST_PP_IF(p(221, s), BOOST_PP_WHILE_221, s BOOST_PP_TUPLE_EAT_3)(p, o, o(221, s)) +# define BOOST_PP_WHILE_221(p, o, s) BOOST_PP_IF(p(222, s), BOOST_PP_WHILE_222, s BOOST_PP_TUPLE_EAT_3)(p, o, o(222, s)) +# define BOOST_PP_WHILE_222(p, o, s) BOOST_PP_IF(p(223, s), BOOST_PP_WHILE_223, s BOOST_PP_TUPLE_EAT_3)(p, o, o(223, s)) +# define BOOST_PP_WHILE_223(p, o, s) BOOST_PP_IF(p(224, s), BOOST_PP_WHILE_224, s BOOST_PP_TUPLE_EAT_3)(p, o, o(224, s)) +# define BOOST_PP_WHILE_224(p, o, s) BOOST_PP_IF(p(225, s), BOOST_PP_WHILE_225, s BOOST_PP_TUPLE_EAT_3)(p, o, o(225, s)) +# define BOOST_PP_WHILE_225(p, o, s) BOOST_PP_IF(p(226, s), BOOST_PP_WHILE_226, s BOOST_PP_TUPLE_EAT_3)(p, o, o(226, s)) +# define BOOST_PP_WHILE_226(p, o, s) BOOST_PP_IF(p(227, s), BOOST_PP_WHILE_227, s BOOST_PP_TUPLE_EAT_3)(p, o, o(227, s)) +# define BOOST_PP_WHILE_227(p, o, s) BOOST_PP_IF(p(228, s), BOOST_PP_WHILE_228, s BOOST_PP_TUPLE_EAT_3)(p, o, o(228, s)) +# define BOOST_PP_WHILE_228(p, o, s) BOOST_PP_IF(p(229, s), BOOST_PP_WHILE_229, s BOOST_PP_TUPLE_EAT_3)(p, o, o(229, s)) +# define BOOST_PP_WHILE_229(p, o, s) BOOST_PP_IF(p(230, s), BOOST_PP_WHILE_230, s BOOST_PP_TUPLE_EAT_3)(p, o, o(230, s)) +# define BOOST_PP_WHILE_230(p, o, s) BOOST_PP_IF(p(231, s), BOOST_PP_WHILE_231, s BOOST_PP_TUPLE_EAT_3)(p, o, o(231, s)) +# define BOOST_PP_WHILE_231(p, o, s) BOOST_PP_IF(p(232, s), BOOST_PP_WHILE_232, s BOOST_PP_TUPLE_EAT_3)(p, o, o(232, s)) +# define BOOST_PP_WHILE_232(p, o, s) BOOST_PP_IF(p(233, s), BOOST_PP_WHILE_233, s BOOST_PP_TUPLE_EAT_3)(p, o, o(233, s)) +# define BOOST_PP_WHILE_233(p, o, s) BOOST_PP_IF(p(234, s), BOOST_PP_WHILE_234, s BOOST_PP_TUPLE_EAT_3)(p, o, o(234, s)) +# define BOOST_PP_WHILE_234(p, o, s) BOOST_PP_IF(p(235, s), BOOST_PP_WHILE_235, s BOOST_PP_TUPLE_EAT_3)(p, o, o(235, s)) +# define BOOST_PP_WHILE_235(p, o, s) BOOST_PP_IF(p(236, s), BOOST_PP_WHILE_236, s BOOST_PP_TUPLE_EAT_3)(p, o, o(236, s)) +# define BOOST_PP_WHILE_236(p, o, s) BOOST_PP_IF(p(237, s), BOOST_PP_WHILE_237, s BOOST_PP_TUPLE_EAT_3)(p, o, o(237, s)) +# define BOOST_PP_WHILE_237(p, o, s) BOOST_PP_IF(p(238, s), BOOST_PP_WHILE_238, s BOOST_PP_TUPLE_EAT_3)(p, o, o(238, s)) +# define BOOST_PP_WHILE_238(p, o, s) BOOST_PP_IF(p(239, s), BOOST_PP_WHILE_239, s BOOST_PP_TUPLE_EAT_3)(p, o, o(239, s)) +# define BOOST_PP_WHILE_239(p, o, s) BOOST_PP_IF(p(240, s), BOOST_PP_WHILE_240, s BOOST_PP_TUPLE_EAT_3)(p, o, o(240, s)) +# define BOOST_PP_WHILE_240(p, o, s) BOOST_PP_IF(p(241, s), BOOST_PP_WHILE_241, s BOOST_PP_TUPLE_EAT_3)(p, o, o(241, s)) +# define BOOST_PP_WHILE_241(p, o, s) BOOST_PP_IF(p(242, s), BOOST_PP_WHILE_242, s BOOST_PP_TUPLE_EAT_3)(p, o, o(242, s)) +# define BOOST_PP_WHILE_242(p, o, s) BOOST_PP_IF(p(243, s), BOOST_PP_WHILE_243, s BOOST_PP_TUPLE_EAT_3)(p, o, o(243, s)) +# define BOOST_PP_WHILE_243(p, o, s) BOOST_PP_IF(p(244, s), BOOST_PP_WHILE_244, s BOOST_PP_TUPLE_EAT_3)(p, o, o(244, s)) +# define BOOST_PP_WHILE_244(p, o, s) BOOST_PP_IF(p(245, s), BOOST_PP_WHILE_245, s BOOST_PP_TUPLE_EAT_3)(p, o, o(245, s)) +# define BOOST_PP_WHILE_245(p, o, s) BOOST_PP_IF(p(246, s), BOOST_PP_WHILE_246, s BOOST_PP_TUPLE_EAT_3)(p, o, o(246, s)) +# define BOOST_PP_WHILE_246(p, o, s) BOOST_PP_IF(p(247, s), BOOST_PP_WHILE_247, s BOOST_PP_TUPLE_EAT_3)(p, o, o(247, s)) +# define BOOST_PP_WHILE_247(p, o, s) BOOST_PP_IF(p(248, s), BOOST_PP_WHILE_248, s BOOST_PP_TUPLE_EAT_3)(p, o, o(248, s)) +# define BOOST_PP_WHILE_248(p, o, s) BOOST_PP_IF(p(249, s), BOOST_PP_WHILE_249, s BOOST_PP_TUPLE_EAT_3)(p, o, o(249, s)) +# define BOOST_PP_WHILE_249(p, o, s) BOOST_PP_IF(p(250, s), BOOST_PP_WHILE_250, s BOOST_PP_TUPLE_EAT_3)(p, o, o(250, s)) +# define BOOST_PP_WHILE_250(p, o, s) BOOST_PP_IF(p(251, s), BOOST_PP_WHILE_251, s BOOST_PP_TUPLE_EAT_3)(p, o, o(251, s)) +# define BOOST_PP_WHILE_251(p, o, s) BOOST_PP_IF(p(252, s), BOOST_PP_WHILE_252, s BOOST_PP_TUPLE_EAT_3)(p, o, o(252, s)) +# define BOOST_PP_WHILE_252(p, o, s) BOOST_PP_IF(p(253, s), BOOST_PP_WHILE_253, s BOOST_PP_TUPLE_EAT_3)(p, o, o(253, s)) +# define BOOST_PP_WHILE_253(p, o, s) BOOST_PP_IF(p(254, s), BOOST_PP_WHILE_254, s BOOST_PP_TUPLE_EAT_3)(p, o, o(254, s)) +# define BOOST_PP_WHILE_254(p, o, s) BOOST_PP_IF(p(255, s), BOOST_PP_WHILE_255, s BOOST_PP_TUPLE_EAT_3)(p, o, o(255, s)) +# define BOOST_PP_WHILE_255(p, o, s) BOOST_PP_IF(p(256, s), BOOST_PP_WHILE_256, s BOOST_PP_TUPLE_EAT_3)(p, o, o(256, s)) +# define BOOST_PP_WHILE_256(p, o, s) BOOST_PP_IF(p(257, s), BOOST_PP_WHILE_257, s BOOST_PP_TUPLE_EAT_3)(p, o, o(257, s)) +# +# endif diff --git a/realsense-file/3rd_party/boost/boost/preprocessor/control/expr_iif.hpp b/realsense-file/3rd_party/boost/boost/preprocessor/control/expr_iif.hpp new file mode 100644 index 0000000000..01818fe6fe --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/preprocessor/control/expr_iif.hpp @@ -0,0 +1,31 @@ +# /* ************************************************************************** +# * * +# * (C) Copyright Paul Mensonides 2002. +# * Distributed under the Boost Software License, Version 1.0. (See +# * accompanying file LICENSE_1_0.txt or copy at +# * http://www.boost.org/LICENSE_1_0.txt) +# * * +# ************************************************************************** */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_CONTROL_EXPR_IIF_HPP +# define BOOST_PREPROCESSOR_CONTROL_EXPR_IIF_HPP +# +# include +# +# /* BOOST_PP_EXPR_IIF */ +# +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() +# define BOOST_PP_EXPR_IIF(bit, expr) BOOST_PP_EXPR_IIF_I(bit, expr) +# else +# define BOOST_PP_EXPR_IIF(bit, expr) BOOST_PP_EXPR_IIF_OO((bit, expr)) +# define BOOST_PP_EXPR_IIF_OO(par) BOOST_PP_EXPR_IIF_I ## par +# endif +# +# define BOOST_PP_EXPR_IIF_I(bit, expr) BOOST_PP_EXPR_IIF_ ## bit(expr) +# +# define BOOST_PP_EXPR_IIF_0(expr) +# define BOOST_PP_EXPR_IIF_1(expr) expr +# +# endif diff --git a/realsense-file/3rd_party/boost/boost/preprocessor/control/if.hpp b/realsense-file/3rd_party/boost/boost/preprocessor/control/if.hpp new file mode 100644 index 0000000000..7d488e855f --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/preprocessor/control/if.hpp @@ -0,0 +1,30 @@ +# /* Copyright (C) 2001 +# * Housemarque Oy +# * http://www.housemarque.com +# * +# * 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) +# */ +# +# /* Revised by Paul Mensonides (2002) */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_CONTROL_IF_HPP +# define BOOST_PREPROCESSOR_CONTROL_IF_HPP +# +# include "../config/config.hpp" +# include "../control/iif.hpp" +# include "../logical/bool.hpp" +# +# /* BOOST_PP_IF */ +# +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() +# define BOOST_PP_IF(cond, t, f) BOOST_PP_IIF(BOOST_PP_BOOL(cond), t, f) +# else +# define BOOST_PP_IF(cond, t, f) BOOST_PP_IF_I(cond, t, f) +# define BOOST_PP_IF_I(cond, t, f) BOOST_PP_IIF(BOOST_PP_BOOL(cond), t, f) +# endif +# +# endif diff --git a/realsense-file/3rd_party/boost/boost/preprocessor/control/iif.hpp b/realsense-file/3rd_party/boost/boost/preprocessor/control/iif.hpp new file mode 100644 index 0000000000..4d86a80eeb --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/preprocessor/control/iif.hpp @@ -0,0 +1,34 @@ +# /* ************************************************************************** +# * * +# * (C) Copyright Paul Mensonides 2002. +# * Distributed under the Boost Software License, Version 1.0. (See +# * accompanying file LICENSE_1_0.txt or copy at +# * http://www.boost.org/LICENSE_1_0.txt) +# * * +# ************************************************************************** */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_CONTROL_IIF_HPP +# define BOOST_PREPROCESSOR_CONTROL_IIF_HPP +# +# include "../config/config.hpp" +# +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() +# define BOOST_PP_IIF(bit, t, f) BOOST_PP_IIF_I(bit, t, f) +# else +# define BOOST_PP_IIF(bit, t, f) BOOST_PP_IIF_OO((bit, t, f)) +# define BOOST_PP_IIF_OO(par) BOOST_PP_IIF_I ## par +# endif +# +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MSVC() +# define BOOST_PP_IIF_I(bit, t, f) BOOST_PP_IIF_ ## bit(t, f) +# else +# define BOOST_PP_IIF_I(bit, t, f) BOOST_PP_IIF_II(BOOST_PP_IIF_ ## bit(t, f)) +# define BOOST_PP_IIF_II(id) id +# endif +# +# define BOOST_PP_IIF_0(t, f) f +# define BOOST_PP_IIF_1(t, f) t +# +# endif diff --git a/realsense-file/3rd_party/boost/boost/preprocessor/control/while.hpp b/realsense-file/3rd_party/boost/boost/preprocessor/control/while.hpp new file mode 100644 index 0000000000..31f97467f2 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/preprocessor/control/while.hpp @@ -0,0 +1,312 @@ +# /* Copyright (C) 2001 +# * Housemarque Oy +# * http://www.housemarque.com +# * +# * 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) +# */ +# +# /* Revised by Paul Mensonides (2002) */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_CONTROL_WHILE_HPP +# define BOOST_PREPROCESSOR_CONTROL_WHILE_HPP +# +# include +# include +# include +# include +# include +# include +# include +# +# /* BOOST_PP_WHILE */ +# +# if 0 +# define BOOST_PP_WHILE(pred, op, state) +# endif +# +# define BOOST_PP_WHILE BOOST_PP_CAT(BOOST_PP_WHILE_, BOOST_PP_AUTO_REC(BOOST_PP_WHILE_P, 256)) +# +# if BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() +# define BOOST_PP_WHILE_P(n) BOOST_PP_BITAND(BOOST_PP_CAT(BOOST_PP_WHILE_CHECK_, BOOST_PP_WHILE_ ## n(BOOST_PP_WHILE_F, BOOST_PP_NIL, BOOST_PP_NIL)), BOOST_PP_BITAND(BOOST_PP_CAT(BOOST_PP_LIST_FOLD_LEFT_CHECK_, BOOST_PP_LIST_FOLD_LEFT_ ## n(BOOST_PP_NIL, BOOST_PP_NIL, BOOST_PP_NIL)), BOOST_PP_CAT(BOOST_PP_LIST_FOLD_RIGHT_CHECK_, BOOST_PP_LIST_FOLD_RIGHT_ ## n(BOOST_PP_NIL, BOOST_PP_NIL, BOOST_PP_NIL)))) +# else +# define BOOST_PP_WHILE_P(n) BOOST_PP_BITAND(BOOST_PP_CAT(BOOST_PP_WHILE_CHECK_, BOOST_PP_WHILE_ ## n(BOOST_PP_WHILE_F, BOOST_PP_NIL, BOOST_PP_NIL)), BOOST_PP_CAT(BOOST_PP_LIST_FOLD_LEFT_CHECK_, BOOST_PP_LIST_FOLD_LEFT_ ## n(BOOST_PP_NIL, BOOST_PP_NIL, BOOST_PP_NIL))) +# endif +# +# define BOOST_PP_WHILE_F(d, _) 0 +# +# if BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() +# include +# elif BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MSVC() +# include +# elif BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_DMC() +# include +# else +# include +# endif +# +# define BOOST_PP_WHILE_257(p, o, s) BOOST_PP_ERROR(0x0001) +# +# define BOOST_PP_WHILE_CHECK_BOOST_PP_NIL 1 +# +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_1(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_2(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_3(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_4(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_5(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_6(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_7(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_8(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_9(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_10(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_11(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_12(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_13(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_14(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_15(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_16(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_17(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_18(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_19(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_20(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_21(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_22(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_23(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_24(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_25(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_26(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_27(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_28(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_29(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_30(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_31(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_32(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_33(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_34(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_35(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_36(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_37(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_38(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_39(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_40(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_41(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_42(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_43(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_44(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_45(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_46(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_47(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_48(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_49(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_50(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_51(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_52(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_53(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_54(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_55(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_56(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_57(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_58(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_59(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_60(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_61(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_62(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_63(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_64(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_65(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_66(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_67(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_68(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_69(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_70(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_71(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_72(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_73(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_74(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_75(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_76(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_77(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_78(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_79(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_80(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_81(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_82(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_83(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_84(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_85(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_86(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_87(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_88(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_89(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_90(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_91(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_92(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_93(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_94(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_95(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_96(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_97(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_98(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_99(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_100(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_101(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_102(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_103(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_104(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_105(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_106(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_107(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_108(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_109(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_110(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_111(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_112(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_113(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_114(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_115(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_116(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_117(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_118(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_119(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_120(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_121(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_122(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_123(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_124(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_125(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_126(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_127(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_128(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_129(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_130(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_131(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_132(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_133(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_134(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_135(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_136(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_137(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_138(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_139(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_140(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_141(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_142(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_143(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_144(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_145(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_146(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_147(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_148(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_149(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_150(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_151(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_152(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_153(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_154(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_155(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_156(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_157(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_158(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_159(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_160(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_161(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_162(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_163(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_164(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_165(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_166(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_167(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_168(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_169(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_170(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_171(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_172(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_173(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_174(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_175(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_176(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_177(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_178(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_179(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_180(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_181(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_182(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_183(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_184(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_185(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_186(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_187(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_188(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_189(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_190(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_191(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_192(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_193(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_194(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_195(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_196(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_197(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_198(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_199(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_200(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_201(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_202(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_203(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_204(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_205(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_206(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_207(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_208(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_209(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_210(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_211(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_212(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_213(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_214(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_215(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_216(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_217(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_218(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_219(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_220(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_221(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_222(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_223(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_224(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_225(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_226(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_227(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_228(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_229(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_230(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_231(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_232(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_233(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_234(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_235(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_236(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_237(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_238(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_239(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_240(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_241(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_242(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_243(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_244(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_245(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_246(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_247(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_248(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_249(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_250(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_251(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_252(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_253(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_254(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_255(p, o, s) 0 +# define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_256(p, o, s) 0 +# +# endif diff --git a/realsense-file/3rd_party/boost/boost/preprocessor/debug/error.hpp b/realsense-file/3rd_party/boost/boost/preprocessor/debug/error.hpp new file mode 100644 index 0000000000..8941caf5be --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/preprocessor/debug/error.hpp @@ -0,0 +1,33 @@ +# /* ************************************************************************** +# * * +# * (C) Copyright Paul Mensonides 2002. +# * Distributed under the Boost Software License, Version 1.0. (See +# * accompanying file LICENSE_1_0.txt or copy at +# * http://www.boost.org/LICENSE_1_0.txt) +# * * +# ************************************************************************** */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_DEBUG_ERROR_HPP +# define BOOST_PREPROCESSOR_DEBUG_ERROR_HPP +# +# include +# include +# +# /* BOOST_PP_ERROR */ +# +# if BOOST_PP_CONFIG_ERRORS +# define BOOST_PP_ERROR(code) BOOST_PP_CAT(BOOST_PP_ERROR_, code) +# endif +# +# define BOOST_PP_ERROR_0x0000 BOOST_PP_ERROR(0x0000, BOOST_PP_INDEX_OUT_OF_BOUNDS) +# define BOOST_PP_ERROR_0x0001 BOOST_PP_ERROR(0x0001, BOOST_PP_WHILE_OVERFLOW) +# define BOOST_PP_ERROR_0x0002 BOOST_PP_ERROR(0x0002, BOOST_PP_FOR_OVERFLOW) +# define BOOST_PP_ERROR_0x0003 BOOST_PP_ERROR(0x0003, BOOST_PP_REPEAT_OVERFLOW) +# define BOOST_PP_ERROR_0x0004 BOOST_PP_ERROR(0x0004, BOOST_PP_LIST_FOLD_OVERFLOW) +# define BOOST_PP_ERROR_0x0005 BOOST_PP_ERROR(0x0005, BOOST_PP_SEQ_FOLD_OVERFLOW) +# define BOOST_PP_ERROR_0x0006 BOOST_PP_ERROR(0x0006, BOOST_PP_ARITHMETIC_OVERFLOW) +# define BOOST_PP_ERROR_0x0007 BOOST_PP_ERROR(0x0007, BOOST_PP_DIVISION_BY_ZERO) +# +# endif diff --git a/realsense-file/3rd_party/boost/boost/preprocessor/detail/auto_rec.hpp b/realsense-file/3rd_party/boost/boost/preprocessor/detail/auto_rec.hpp new file mode 100644 index 0000000000..9e706fa74c --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/preprocessor/detail/auto_rec.hpp @@ -0,0 +1,293 @@ +# /* ************************************************************************** +# * * +# * (C) Copyright Paul Mensonides 2002. +# * Distributed under the Boost Software License, Version 1.0. (See +# * accompanying file LICENSE_1_0.txt or copy at +# * http://www.boost.org/LICENSE_1_0.txt) +# * * +# ************************************************************************** */ +# +# /* See http://www.boost.org for most recent version. */ +# +# include +# +# if BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_DMC() +# include +# else +# +# ifndef BOOST_PREPROCESSOR_DETAIL_AUTO_REC_HPP +# define BOOST_PREPROCESSOR_DETAIL_AUTO_REC_HPP +# +# include +# +# /* BOOST_PP_AUTO_REC */ +# +# define BOOST_PP_AUTO_REC(pred, n) BOOST_PP_NODE_ENTRY_ ## n(pred) +# +# define BOOST_PP_NODE_ENTRY_256(p) BOOST_PP_NODE_128(p)(p)(p)(p)(p)(p)(p)(p) +# define BOOST_PP_NODE_ENTRY_128(p) BOOST_PP_NODE_64(p)(p)(p)(p)(p)(p)(p) +# define BOOST_PP_NODE_ENTRY_64(p) BOOST_PP_NODE_32(p)(p)(p)(p)(p)(p) +# define BOOST_PP_NODE_ENTRY_32(p) BOOST_PP_NODE_16(p)(p)(p)(p)(p) +# define BOOST_PP_NODE_ENTRY_16(p) BOOST_PP_NODE_8(p)(p)(p)(p) +# define BOOST_PP_NODE_ENTRY_8(p) BOOST_PP_NODE_4(p)(p)(p) +# define BOOST_PP_NODE_ENTRY_4(p) BOOST_PP_NODE_2(p)(p) +# define BOOST_PP_NODE_ENTRY_2(p) BOOST_PP_NODE_1(p) +# +# define BOOST_PP_NODE_128(p) BOOST_PP_IIF(p(128), BOOST_PP_NODE_64, BOOST_PP_NODE_192) +# define BOOST_PP_NODE_64(p) BOOST_PP_IIF(p(64), BOOST_PP_NODE_32, BOOST_PP_NODE_96) +# define BOOST_PP_NODE_32(p) BOOST_PP_IIF(p(32), BOOST_PP_NODE_16, BOOST_PP_NODE_48) +# define BOOST_PP_NODE_16(p) BOOST_PP_IIF(p(16), BOOST_PP_NODE_8, BOOST_PP_NODE_24) +# define BOOST_PP_NODE_8(p) BOOST_PP_IIF(p(8), BOOST_PP_NODE_4, BOOST_PP_NODE_12) +# define BOOST_PP_NODE_4(p) BOOST_PP_IIF(p(4), BOOST_PP_NODE_2, BOOST_PP_NODE_6) +# define BOOST_PP_NODE_2(p) BOOST_PP_IIF(p(2), BOOST_PP_NODE_1, BOOST_PP_NODE_3) +# define BOOST_PP_NODE_1(p) BOOST_PP_IIF(p(1), 1, 2) +# define BOOST_PP_NODE_3(p) BOOST_PP_IIF(p(3), 3, 4) +# define BOOST_PP_NODE_6(p) BOOST_PP_IIF(p(6), BOOST_PP_NODE_5, BOOST_PP_NODE_7) +# define BOOST_PP_NODE_5(p) BOOST_PP_IIF(p(5), 5, 6) +# define BOOST_PP_NODE_7(p) BOOST_PP_IIF(p(7), 7, 8) +# define BOOST_PP_NODE_12(p) BOOST_PP_IIF(p(12), BOOST_PP_NODE_10, BOOST_PP_NODE_14) +# define BOOST_PP_NODE_10(p) BOOST_PP_IIF(p(10), BOOST_PP_NODE_9, BOOST_PP_NODE_11) +# define BOOST_PP_NODE_9(p) BOOST_PP_IIF(p(9), 9, 10) +# define BOOST_PP_NODE_11(p) BOOST_PP_IIF(p(11), 11, 12) +# define BOOST_PP_NODE_14(p) BOOST_PP_IIF(p(14), BOOST_PP_NODE_13, BOOST_PP_NODE_15) +# define BOOST_PP_NODE_13(p) BOOST_PP_IIF(p(13), 13, 14) +# define BOOST_PP_NODE_15(p) BOOST_PP_IIF(p(15), 15, 16) +# define BOOST_PP_NODE_24(p) BOOST_PP_IIF(p(24), BOOST_PP_NODE_20, BOOST_PP_NODE_28) +# define BOOST_PP_NODE_20(p) BOOST_PP_IIF(p(20), BOOST_PP_NODE_18, BOOST_PP_NODE_22) +# define BOOST_PP_NODE_18(p) BOOST_PP_IIF(p(18), BOOST_PP_NODE_17, BOOST_PP_NODE_19) +# define BOOST_PP_NODE_17(p) BOOST_PP_IIF(p(17), 17, 18) +# define BOOST_PP_NODE_19(p) BOOST_PP_IIF(p(19), 19, 20) +# define BOOST_PP_NODE_22(p) BOOST_PP_IIF(p(22), BOOST_PP_NODE_21, BOOST_PP_NODE_23) +# define BOOST_PP_NODE_21(p) BOOST_PP_IIF(p(21), 21, 22) +# define BOOST_PP_NODE_23(p) BOOST_PP_IIF(p(23), 23, 24) +# define BOOST_PP_NODE_28(p) BOOST_PP_IIF(p(28), BOOST_PP_NODE_26, BOOST_PP_NODE_30) +# define BOOST_PP_NODE_26(p) BOOST_PP_IIF(p(26), BOOST_PP_NODE_25, BOOST_PP_NODE_27) +# define BOOST_PP_NODE_25(p) BOOST_PP_IIF(p(25), 25, 26) +# define BOOST_PP_NODE_27(p) BOOST_PP_IIF(p(27), 27, 28) +# define BOOST_PP_NODE_30(p) BOOST_PP_IIF(p(30), BOOST_PP_NODE_29, BOOST_PP_NODE_31) +# define BOOST_PP_NODE_29(p) BOOST_PP_IIF(p(29), 29, 30) +# define BOOST_PP_NODE_31(p) BOOST_PP_IIF(p(31), 31, 32) +# define BOOST_PP_NODE_48(p) BOOST_PP_IIF(p(48), BOOST_PP_NODE_40, BOOST_PP_NODE_56) +# define BOOST_PP_NODE_40(p) BOOST_PP_IIF(p(40), BOOST_PP_NODE_36, BOOST_PP_NODE_44) +# define BOOST_PP_NODE_36(p) BOOST_PP_IIF(p(36), BOOST_PP_NODE_34, BOOST_PP_NODE_38) +# define BOOST_PP_NODE_34(p) BOOST_PP_IIF(p(34), BOOST_PP_NODE_33, BOOST_PP_NODE_35) +# define BOOST_PP_NODE_33(p) BOOST_PP_IIF(p(33), 33, 34) +# define BOOST_PP_NODE_35(p) BOOST_PP_IIF(p(35), 35, 36) +# define BOOST_PP_NODE_38(p) BOOST_PP_IIF(p(38), BOOST_PP_NODE_37, BOOST_PP_NODE_39) +# define BOOST_PP_NODE_37(p) BOOST_PP_IIF(p(37), 37, 38) +# define BOOST_PP_NODE_39(p) BOOST_PP_IIF(p(39), 39, 40) +# define BOOST_PP_NODE_44(p) BOOST_PP_IIF(p(44), BOOST_PP_NODE_42, BOOST_PP_NODE_46) +# define BOOST_PP_NODE_42(p) BOOST_PP_IIF(p(42), BOOST_PP_NODE_41, BOOST_PP_NODE_43) +# define BOOST_PP_NODE_41(p) BOOST_PP_IIF(p(41), 41, 42) +# define BOOST_PP_NODE_43(p) BOOST_PP_IIF(p(43), 43, 44) +# define BOOST_PP_NODE_46(p) BOOST_PP_IIF(p(46), BOOST_PP_NODE_45, BOOST_PP_NODE_47) +# define BOOST_PP_NODE_45(p) BOOST_PP_IIF(p(45), 45, 46) +# define BOOST_PP_NODE_47(p) BOOST_PP_IIF(p(47), 47, 48) +# define BOOST_PP_NODE_56(p) BOOST_PP_IIF(p(56), BOOST_PP_NODE_52, BOOST_PP_NODE_60) +# define BOOST_PP_NODE_52(p) BOOST_PP_IIF(p(52), BOOST_PP_NODE_50, BOOST_PP_NODE_54) +# define BOOST_PP_NODE_50(p) BOOST_PP_IIF(p(50), BOOST_PP_NODE_49, BOOST_PP_NODE_51) +# define BOOST_PP_NODE_49(p) BOOST_PP_IIF(p(49), 49, 50) +# define BOOST_PP_NODE_51(p) BOOST_PP_IIF(p(51), 51, 52) +# define BOOST_PP_NODE_54(p) BOOST_PP_IIF(p(54), BOOST_PP_NODE_53, BOOST_PP_NODE_55) +# define BOOST_PP_NODE_53(p) BOOST_PP_IIF(p(53), 53, 54) +# define BOOST_PP_NODE_55(p) BOOST_PP_IIF(p(55), 55, 56) +# define BOOST_PP_NODE_60(p) BOOST_PP_IIF(p(60), BOOST_PP_NODE_58, BOOST_PP_NODE_62) +# define BOOST_PP_NODE_58(p) BOOST_PP_IIF(p(58), BOOST_PP_NODE_57, BOOST_PP_NODE_59) +# define BOOST_PP_NODE_57(p) BOOST_PP_IIF(p(57), 57, 58) +# define BOOST_PP_NODE_59(p) BOOST_PP_IIF(p(59), 59, 60) +# define BOOST_PP_NODE_62(p) BOOST_PP_IIF(p(62), BOOST_PP_NODE_61, BOOST_PP_NODE_63) +# define BOOST_PP_NODE_61(p) BOOST_PP_IIF(p(61), 61, 62) +# define BOOST_PP_NODE_63(p) BOOST_PP_IIF(p(63), 63, 64) +# define BOOST_PP_NODE_96(p) BOOST_PP_IIF(p(96), BOOST_PP_NODE_80, BOOST_PP_NODE_112) +# define BOOST_PP_NODE_80(p) BOOST_PP_IIF(p(80), BOOST_PP_NODE_72, BOOST_PP_NODE_88) +# define BOOST_PP_NODE_72(p) BOOST_PP_IIF(p(72), BOOST_PP_NODE_68, BOOST_PP_NODE_76) +# define BOOST_PP_NODE_68(p) BOOST_PP_IIF(p(68), BOOST_PP_NODE_66, BOOST_PP_NODE_70) +# define BOOST_PP_NODE_66(p) BOOST_PP_IIF(p(66), BOOST_PP_NODE_65, BOOST_PP_NODE_67) +# define BOOST_PP_NODE_65(p) BOOST_PP_IIF(p(65), 65, 66) +# define BOOST_PP_NODE_67(p) BOOST_PP_IIF(p(67), 67, 68) +# define BOOST_PP_NODE_70(p) BOOST_PP_IIF(p(70), BOOST_PP_NODE_69, BOOST_PP_NODE_71) +# define BOOST_PP_NODE_69(p) BOOST_PP_IIF(p(69), 69, 70) +# define BOOST_PP_NODE_71(p) BOOST_PP_IIF(p(71), 71, 72) +# define BOOST_PP_NODE_76(p) BOOST_PP_IIF(p(76), BOOST_PP_NODE_74, BOOST_PP_NODE_78) +# define BOOST_PP_NODE_74(p) BOOST_PP_IIF(p(74), BOOST_PP_NODE_73, BOOST_PP_NODE_75) +# define BOOST_PP_NODE_73(p) BOOST_PP_IIF(p(73), 73, 74) +# define BOOST_PP_NODE_75(p) BOOST_PP_IIF(p(75), 75, 76) +# define BOOST_PP_NODE_78(p) BOOST_PP_IIF(p(78), BOOST_PP_NODE_77, BOOST_PP_NODE_79) +# define BOOST_PP_NODE_77(p) BOOST_PP_IIF(p(77), 77, 78) +# define BOOST_PP_NODE_79(p) BOOST_PP_IIF(p(79), 79, 80) +# define BOOST_PP_NODE_88(p) BOOST_PP_IIF(p(88), BOOST_PP_NODE_84, BOOST_PP_NODE_92) +# define BOOST_PP_NODE_84(p) BOOST_PP_IIF(p(84), BOOST_PP_NODE_82, BOOST_PP_NODE_86) +# define BOOST_PP_NODE_82(p) BOOST_PP_IIF(p(82), BOOST_PP_NODE_81, BOOST_PP_NODE_83) +# define BOOST_PP_NODE_81(p) BOOST_PP_IIF(p(81), 81, 82) +# define BOOST_PP_NODE_83(p) BOOST_PP_IIF(p(83), 83, 84) +# define BOOST_PP_NODE_86(p) BOOST_PP_IIF(p(86), BOOST_PP_NODE_85, BOOST_PP_NODE_87) +# define BOOST_PP_NODE_85(p) BOOST_PP_IIF(p(85), 85, 86) +# define BOOST_PP_NODE_87(p) BOOST_PP_IIF(p(87), 87, 88) +# define BOOST_PP_NODE_92(p) BOOST_PP_IIF(p(92), BOOST_PP_NODE_90, BOOST_PP_NODE_94) +# define BOOST_PP_NODE_90(p) BOOST_PP_IIF(p(90), BOOST_PP_NODE_89, BOOST_PP_NODE_91) +# define BOOST_PP_NODE_89(p) BOOST_PP_IIF(p(89), 89, 90) +# define BOOST_PP_NODE_91(p) BOOST_PP_IIF(p(91), 91, 92) +# define BOOST_PP_NODE_94(p) BOOST_PP_IIF(p(94), BOOST_PP_NODE_93, BOOST_PP_NODE_95) +# define BOOST_PP_NODE_93(p) BOOST_PP_IIF(p(93), 93, 94) +# define BOOST_PP_NODE_95(p) BOOST_PP_IIF(p(95), 95, 96) +# define BOOST_PP_NODE_112(p) BOOST_PP_IIF(p(112), BOOST_PP_NODE_104, BOOST_PP_NODE_120) +# define BOOST_PP_NODE_104(p) BOOST_PP_IIF(p(104), BOOST_PP_NODE_100, BOOST_PP_NODE_108) +# define BOOST_PP_NODE_100(p) BOOST_PP_IIF(p(100), BOOST_PP_NODE_98, BOOST_PP_NODE_102) +# define BOOST_PP_NODE_98(p) BOOST_PP_IIF(p(98), BOOST_PP_NODE_97, BOOST_PP_NODE_99) +# define BOOST_PP_NODE_97(p) BOOST_PP_IIF(p(97), 97, 98) +# define BOOST_PP_NODE_99(p) BOOST_PP_IIF(p(99), 99, 100) +# define BOOST_PP_NODE_102(p) BOOST_PP_IIF(p(102), BOOST_PP_NODE_101, BOOST_PP_NODE_103) +# define BOOST_PP_NODE_101(p) BOOST_PP_IIF(p(101), 101, 102) +# define BOOST_PP_NODE_103(p) BOOST_PP_IIF(p(103), 103, 104) +# define BOOST_PP_NODE_108(p) BOOST_PP_IIF(p(108), BOOST_PP_NODE_106, BOOST_PP_NODE_110) +# define BOOST_PP_NODE_106(p) BOOST_PP_IIF(p(106), BOOST_PP_NODE_105, BOOST_PP_NODE_107) +# define BOOST_PP_NODE_105(p) BOOST_PP_IIF(p(105), 105, 106) +# define BOOST_PP_NODE_107(p) BOOST_PP_IIF(p(107), 107, 108) +# define BOOST_PP_NODE_110(p) BOOST_PP_IIF(p(110), BOOST_PP_NODE_109, BOOST_PP_NODE_111) +# define BOOST_PP_NODE_109(p) BOOST_PP_IIF(p(109), 109, 110) +# define BOOST_PP_NODE_111(p) BOOST_PP_IIF(p(111), 111, 112) +# define BOOST_PP_NODE_120(p) BOOST_PP_IIF(p(120), BOOST_PP_NODE_116, BOOST_PP_NODE_124) +# define BOOST_PP_NODE_116(p) BOOST_PP_IIF(p(116), BOOST_PP_NODE_114, BOOST_PP_NODE_118) +# define BOOST_PP_NODE_114(p) BOOST_PP_IIF(p(114), BOOST_PP_NODE_113, BOOST_PP_NODE_115) +# define BOOST_PP_NODE_113(p) BOOST_PP_IIF(p(113), 113, 114) +# define BOOST_PP_NODE_115(p) BOOST_PP_IIF(p(115), 115, 116) +# define BOOST_PP_NODE_118(p) BOOST_PP_IIF(p(118), BOOST_PP_NODE_117, BOOST_PP_NODE_119) +# define BOOST_PP_NODE_117(p) BOOST_PP_IIF(p(117), 117, 118) +# define BOOST_PP_NODE_119(p) BOOST_PP_IIF(p(119), 119, 120) +# define BOOST_PP_NODE_124(p) BOOST_PP_IIF(p(124), BOOST_PP_NODE_122, BOOST_PP_NODE_126) +# define BOOST_PP_NODE_122(p) BOOST_PP_IIF(p(122), BOOST_PP_NODE_121, BOOST_PP_NODE_123) +# define BOOST_PP_NODE_121(p) BOOST_PP_IIF(p(121), 121, 122) +# define BOOST_PP_NODE_123(p) BOOST_PP_IIF(p(123), 123, 124) +# define BOOST_PP_NODE_126(p) BOOST_PP_IIF(p(126), BOOST_PP_NODE_125, BOOST_PP_NODE_127) +# define BOOST_PP_NODE_125(p) BOOST_PP_IIF(p(125), 125, 126) +# define BOOST_PP_NODE_127(p) BOOST_PP_IIF(p(127), 127, 128) +# define BOOST_PP_NODE_192(p) BOOST_PP_IIF(p(192), BOOST_PP_NODE_160, BOOST_PP_NODE_224) +# define BOOST_PP_NODE_160(p) BOOST_PP_IIF(p(160), BOOST_PP_NODE_144, BOOST_PP_NODE_176) +# define BOOST_PP_NODE_144(p) BOOST_PP_IIF(p(144), BOOST_PP_NODE_136, BOOST_PP_NODE_152) +# define BOOST_PP_NODE_136(p) BOOST_PP_IIF(p(136), BOOST_PP_NODE_132, BOOST_PP_NODE_140) +# define BOOST_PP_NODE_132(p) BOOST_PP_IIF(p(132), BOOST_PP_NODE_130, BOOST_PP_NODE_134) +# define BOOST_PP_NODE_130(p) BOOST_PP_IIF(p(130), BOOST_PP_NODE_129, BOOST_PP_NODE_131) +# define BOOST_PP_NODE_129(p) BOOST_PP_IIF(p(129), 129, 130) +# define BOOST_PP_NODE_131(p) BOOST_PP_IIF(p(131), 131, 132) +# define BOOST_PP_NODE_134(p) BOOST_PP_IIF(p(134), BOOST_PP_NODE_133, BOOST_PP_NODE_135) +# define BOOST_PP_NODE_133(p) BOOST_PP_IIF(p(133), 133, 134) +# define BOOST_PP_NODE_135(p) BOOST_PP_IIF(p(135), 135, 136) +# define BOOST_PP_NODE_140(p) BOOST_PP_IIF(p(140), BOOST_PP_NODE_138, BOOST_PP_NODE_142) +# define BOOST_PP_NODE_138(p) BOOST_PP_IIF(p(138), BOOST_PP_NODE_137, BOOST_PP_NODE_139) +# define BOOST_PP_NODE_137(p) BOOST_PP_IIF(p(137), 137, 138) +# define BOOST_PP_NODE_139(p) BOOST_PP_IIF(p(139), 139, 140) +# define BOOST_PP_NODE_142(p) BOOST_PP_IIF(p(142), BOOST_PP_NODE_141, BOOST_PP_NODE_143) +# define BOOST_PP_NODE_141(p) BOOST_PP_IIF(p(141), 141, 142) +# define BOOST_PP_NODE_143(p) BOOST_PP_IIF(p(143), 143, 144) +# define BOOST_PP_NODE_152(p) BOOST_PP_IIF(p(152), BOOST_PP_NODE_148, BOOST_PP_NODE_156) +# define BOOST_PP_NODE_148(p) BOOST_PP_IIF(p(148), BOOST_PP_NODE_146, BOOST_PP_NODE_150) +# define BOOST_PP_NODE_146(p) BOOST_PP_IIF(p(146), BOOST_PP_NODE_145, BOOST_PP_NODE_147) +# define BOOST_PP_NODE_145(p) BOOST_PP_IIF(p(145), 145, 146) +# define BOOST_PP_NODE_147(p) BOOST_PP_IIF(p(147), 147, 148) +# define BOOST_PP_NODE_150(p) BOOST_PP_IIF(p(150), BOOST_PP_NODE_149, BOOST_PP_NODE_151) +# define BOOST_PP_NODE_149(p) BOOST_PP_IIF(p(149), 149, 150) +# define BOOST_PP_NODE_151(p) BOOST_PP_IIF(p(151), 151, 152) +# define BOOST_PP_NODE_156(p) BOOST_PP_IIF(p(156), BOOST_PP_NODE_154, BOOST_PP_NODE_158) +# define BOOST_PP_NODE_154(p) BOOST_PP_IIF(p(154), BOOST_PP_NODE_153, BOOST_PP_NODE_155) +# define BOOST_PP_NODE_153(p) BOOST_PP_IIF(p(153), 153, 154) +# define BOOST_PP_NODE_155(p) BOOST_PP_IIF(p(155), 155, 156) +# define BOOST_PP_NODE_158(p) BOOST_PP_IIF(p(158), BOOST_PP_NODE_157, BOOST_PP_NODE_159) +# define BOOST_PP_NODE_157(p) BOOST_PP_IIF(p(157), 157, 158) +# define BOOST_PP_NODE_159(p) BOOST_PP_IIF(p(159), 159, 160) +# define BOOST_PP_NODE_176(p) BOOST_PP_IIF(p(176), BOOST_PP_NODE_168, BOOST_PP_NODE_184) +# define BOOST_PP_NODE_168(p) BOOST_PP_IIF(p(168), BOOST_PP_NODE_164, BOOST_PP_NODE_172) +# define BOOST_PP_NODE_164(p) BOOST_PP_IIF(p(164), BOOST_PP_NODE_162, BOOST_PP_NODE_166) +# define BOOST_PP_NODE_162(p) BOOST_PP_IIF(p(162), BOOST_PP_NODE_161, BOOST_PP_NODE_163) +# define BOOST_PP_NODE_161(p) BOOST_PP_IIF(p(161), 161, 162) +# define BOOST_PP_NODE_163(p) BOOST_PP_IIF(p(163), 163, 164) +# define BOOST_PP_NODE_166(p) BOOST_PP_IIF(p(166), BOOST_PP_NODE_165, BOOST_PP_NODE_167) +# define BOOST_PP_NODE_165(p) BOOST_PP_IIF(p(165), 165, 166) +# define BOOST_PP_NODE_167(p) BOOST_PP_IIF(p(167), 167, 168) +# define BOOST_PP_NODE_172(p) BOOST_PP_IIF(p(172), BOOST_PP_NODE_170, BOOST_PP_NODE_174) +# define BOOST_PP_NODE_170(p) BOOST_PP_IIF(p(170), BOOST_PP_NODE_169, BOOST_PP_NODE_171) +# define BOOST_PP_NODE_169(p) BOOST_PP_IIF(p(169), 169, 170) +# define BOOST_PP_NODE_171(p) BOOST_PP_IIF(p(171), 171, 172) +# define BOOST_PP_NODE_174(p) BOOST_PP_IIF(p(174), BOOST_PP_NODE_173, BOOST_PP_NODE_175) +# define BOOST_PP_NODE_173(p) BOOST_PP_IIF(p(173), 173, 174) +# define BOOST_PP_NODE_175(p) BOOST_PP_IIF(p(175), 175, 176) +# define BOOST_PP_NODE_184(p) BOOST_PP_IIF(p(184), BOOST_PP_NODE_180, BOOST_PP_NODE_188) +# define BOOST_PP_NODE_180(p) BOOST_PP_IIF(p(180), BOOST_PP_NODE_178, BOOST_PP_NODE_182) +# define BOOST_PP_NODE_178(p) BOOST_PP_IIF(p(178), BOOST_PP_NODE_177, BOOST_PP_NODE_179) +# define BOOST_PP_NODE_177(p) BOOST_PP_IIF(p(177), 177, 178) +# define BOOST_PP_NODE_179(p) BOOST_PP_IIF(p(179), 179, 180) +# define BOOST_PP_NODE_182(p) BOOST_PP_IIF(p(182), BOOST_PP_NODE_181, BOOST_PP_NODE_183) +# define BOOST_PP_NODE_181(p) BOOST_PP_IIF(p(181), 181, 182) +# define BOOST_PP_NODE_183(p) BOOST_PP_IIF(p(183), 183, 184) +# define BOOST_PP_NODE_188(p) BOOST_PP_IIF(p(188), BOOST_PP_NODE_186, BOOST_PP_NODE_190) +# define BOOST_PP_NODE_186(p) BOOST_PP_IIF(p(186), BOOST_PP_NODE_185, BOOST_PP_NODE_187) +# define BOOST_PP_NODE_185(p) BOOST_PP_IIF(p(185), 185, 186) +# define BOOST_PP_NODE_187(p) BOOST_PP_IIF(p(187), 187, 188) +# define BOOST_PP_NODE_190(p) BOOST_PP_IIF(p(190), BOOST_PP_NODE_189, BOOST_PP_NODE_191) +# define BOOST_PP_NODE_189(p) BOOST_PP_IIF(p(189), 189, 190) +# define BOOST_PP_NODE_191(p) BOOST_PP_IIF(p(191), 191, 192) +# define BOOST_PP_NODE_224(p) BOOST_PP_IIF(p(224), BOOST_PP_NODE_208, BOOST_PP_NODE_240) +# define BOOST_PP_NODE_208(p) BOOST_PP_IIF(p(208), BOOST_PP_NODE_200, BOOST_PP_NODE_216) +# define BOOST_PP_NODE_200(p) BOOST_PP_IIF(p(200), BOOST_PP_NODE_196, BOOST_PP_NODE_204) +# define BOOST_PP_NODE_196(p) BOOST_PP_IIF(p(196), BOOST_PP_NODE_194, BOOST_PP_NODE_198) +# define BOOST_PP_NODE_194(p) BOOST_PP_IIF(p(194), BOOST_PP_NODE_193, BOOST_PP_NODE_195) +# define BOOST_PP_NODE_193(p) BOOST_PP_IIF(p(193), 193, 194) +# define BOOST_PP_NODE_195(p) BOOST_PP_IIF(p(195), 195, 196) +# define BOOST_PP_NODE_198(p) BOOST_PP_IIF(p(198), BOOST_PP_NODE_197, BOOST_PP_NODE_199) +# define BOOST_PP_NODE_197(p) BOOST_PP_IIF(p(197), 197, 198) +# define BOOST_PP_NODE_199(p) BOOST_PP_IIF(p(199), 199, 200) +# define BOOST_PP_NODE_204(p) BOOST_PP_IIF(p(204), BOOST_PP_NODE_202, BOOST_PP_NODE_206) +# define BOOST_PP_NODE_202(p) BOOST_PP_IIF(p(202), BOOST_PP_NODE_201, BOOST_PP_NODE_203) +# define BOOST_PP_NODE_201(p) BOOST_PP_IIF(p(201), 201, 202) +# define BOOST_PP_NODE_203(p) BOOST_PP_IIF(p(203), 203, 204) +# define BOOST_PP_NODE_206(p) BOOST_PP_IIF(p(206), BOOST_PP_NODE_205, BOOST_PP_NODE_207) +# define BOOST_PP_NODE_205(p) BOOST_PP_IIF(p(205), 205, 206) +# define BOOST_PP_NODE_207(p) BOOST_PP_IIF(p(207), 207, 208) +# define BOOST_PP_NODE_216(p) BOOST_PP_IIF(p(216), BOOST_PP_NODE_212, BOOST_PP_NODE_220) +# define BOOST_PP_NODE_212(p) BOOST_PP_IIF(p(212), BOOST_PP_NODE_210, BOOST_PP_NODE_214) +# define BOOST_PP_NODE_210(p) BOOST_PP_IIF(p(210), BOOST_PP_NODE_209, BOOST_PP_NODE_211) +# define BOOST_PP_NODE_209(p) BOOST_PP_IIF(p(209), 209, 210) +# define BOOST_PP_NODE_211(p) BOOST_PP_IIF(p(211), 211, 212) +# define BOOST_PP_NODE_214(p) BOOST_PP_IIF(p(214), BOOST_PP_NODE_213, BOOST_PP_NODE_215) +# define BOOST_PP_NODE_213(p) BOOST_PP_IIF(p(213), 213, 214) +# define BOOST_PP_NODE_215(p) BOOST_PP_IIF(p(215), 215, 216) +# define BOOST_PP_NODE_220(p) BOOST_PP_IIF(p(220), BOOST_PP_NODE_218, BOOST_PP_NODE_222) +# define BOOST_PP_NODE_218(p) BOOST_PP_IIF(p(218), BOOST_PP_NODE_217, BOOST_PP_NODE_219) +# define BOOST_PP_NODE_217(p) BOOST_PP_IIF(p(217), 217, 218) +# define BOOST_PP_NODE_219(p) BOOST_PP_IIF(p(219), 219, 220) +# define BOOST_PP_NODE_222(p) BOOST_PP_IIF(p(222), BOOST_PP_NODE_221, BOOST_PP_NODE_223) +# define BOOST_PP_NODE_221(p) BOOST_PP_IIF(p(221), 221, 222) +# define BOOST_PP_NODE_223(p) BOOST_PP_IIF(p(223), 223, 224) +# define BOOST_PP_NODE_240(p) BOOST_PP_IIF(p(240), BOOST_PP_NODE_232, BOOST_PP_NODE_248) +# define BOOST_PP_NODE_232(p) BOOST_PP_IIF(p(232), BOOST_PP_NODE_228, BOOST_PP_NODE_236) +# define BOOST_PP_NODE_228(p) BOOST_PP_IIF(p(228), BOOST_PP_NODE_226, BOOST_PP_NODE_230) +# define BOOST_PP_NODE_226(p) BOOST_PP_IIF(p(226), BOOST_PP_NODE_225, BOOST_PP_NODE_227) +# define BOOST_PP_NODE_225(p) BOOST_PP_IIF(p(225), 225, 226) +# define BOOST_PP_NODE_227(p) BOOST_PP_IIF(p(227), 227, 228) +# define BOOST_PP_NODE_230(p) BOOST_PP_IIF(p(230), BOOST_PP_NODE_229, BOOST_PP_NODE_231) +# define BOOST_PP_NODE_229(p) BOOST_PP_IIF(p(229), 229, 230) +# define BOOST_PP_NODE_231(p) BOOST_PP_IIF(p(231), 231, 232) +# define BOOST_PP_NODE_236(p) BOOST_PP_IIF(p(236), BOOST_PP_NODE_234, BOOST_PP_NODE_238) +# define BOOST_PP_NODE_234(p) BOOST_PP_IIF(p(234), BOOST_PP_NODE_233, BOOST_PP_NODE_235) +# define BOOST_PP_NODE_233(p) BOOST_PP_IIF(p(233), 233, 234) +# define BOOST_PP_NODE_235(p) BOOST_PP_IIF(p(235), 235, 236) +# define BOOST_PP_NODE_238(p) BOOST_PP_IIF(p(238), BOOST_PP_NODE_237, BOOST_PP_NODE_239) +# define BOOST_PP_NODE_237(p) BOOST_PP_IIF(p(237), 237, 238) +# define BOOST_PP_NODE_239(p) BOOST_PP_IIF(p(239), 239, 240) +# define BOOST_PP_NODE_248(p) BOOST_PP_IIF(p(248), BOOST_PP_NODE_244, BOOST_PP_NODE_252) +# define BOOST_PP_NODE_244(p) BOOST_PP_IIF(p(244), BOOST_PP_NODE_242, BOOST_PP_NODE_246) +# define BOOST_PP_NODE_242(p) BOOST_PP_IIF(p(242), BOOST_PP_NODE_241, BOOST_PP_NODE_243) +# define BOOST_PP_NODE_241(p) BOOST_PP_IIF(p(241), 241, 242) +# define BOOST_PP_NODE_243(p) BOOST_PP_IIF(p(243), 243, 244) +# define BOOST_PP_NODE_246(p) BOOST_PP_IIF(p(246), BOOST_PP_NODE_245, BOOST_PP_NODE_247) +# define BOOST_PP_NODE_245(p) BOOST_PP_IIF(p(245), 245, 246) +# define BOOST_PP_NODE_247(p) BOOST_PP_IIF(p(247), 247, 248) +# define BOOST_PP_NODE_252(p) BOOST_PP_IIF(p(252), BOOST_PP_NODE_250, BOOST_PP_NODE_254) +# define BOOST_PP_NODE_250(p) BOOST_PP_IIF(p(250), BOOST_PP_NODE_249, BOOST_PP_NODE_251) +# define BOOST_PP_NODE_249(p) BOOST_PP_IIF(p(249), 249, 250) +# define BOOST_PP_NODE_251(p) BOOST_PP_IIF(p(251), 251, 252) +# define BOOST_PP_NODE_254(p) BOOST_PP_IIF(p(254), BOOST_PP_NODE_253, BOOST_PP_NODE_255) +# define BOOST_PP_NODE_253(p) BOOST_PP_IIF(p(253), 253, 254) +# define BOOST_PP_NODE_255(p) BOOST_PP_IIF(p(255), 255, 256) +# +# endif +# endif diff --git a/realsense-file/3rd_party/boost/boost/preprocessor/detail/check.hpp b/realsense-file/3rd_party/boost/boost/preprocessor/detail/check.hpp new file mode 100644 index 0000000000..8e374c635a --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/preprocessor/detail/check.hpp @@ -0,0 +1,48 @@ +# /* ************************************************************************** +# * * +# * (C) Copyright Paul Mensonides 2002. +# * Distributed under the Boost Software License, Version 1.0. (See +# * accompanying file LICENSE_1_0.txt or copy at +# * http://www.boost.org/LICENSE_1_0.txt) +# * * +# ************************************************************************** */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_DETAIL_CHECK_HPP +# define BOOST_PREPROCESSOR_DETAIL_CHECK_HPP +# +# include +# include +# +# /* BOOST_PP_CHECK */ +# +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() +# define BOOST_PP_CHECK(x, type) BOOST_PP_CHECK_D(x, type) +# else +# define BOOST_PP_CHECK(x, type) BOOST_PP_CHECK_OO((x, type)) +# define BOOST_PP_CHECK_OO(par) BOOST_PP_CHECK_D ## par +# endif +# +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MSVC() && ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_DMC() +# define BOOST_PP_CHECK_D(x, type) BOOST_PP_CHECK_1(BOOST_PP_CAT(BOOST_PP_CHECK_RESULT_, type x)) +# define BOOST_PP_CHECK_1(chk) BOOST_PP_CHECK_2(chk) +# define BOOST_PP_CHECK_2(res, _) res +# elif BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MSVC() +# define BOOST_PP_CHECK_D(x, type) BOOST_PP_CHECK_1(type x) +# define BOOST_PP_CHECK_1(chk) BOOST_PP_CHECK_2(chk) +# define BOOST_PP_CHECK_2(chk) BOOST_PP_CHECK_3((BOOST_PP_CHECK_RESULT_ ## chk)) +# define BOOST_PP_CHECK_3(im) BOOST_PP_CHECK_5(BOOST_PP_CHECK_4 im) +# define BOOST_PP_CHECK_4(res, _) res +# define BOOST_PP_CHECK_5(res) res +# else /* DMC */ +# define BOOST_PP_CHECK_D(x, type) BOOST_PP_CHECK_OO((type x)) +# define BOOST_PP_CHECK_OO(par) BOOST_PP_CHECK_0 ## par +# define BOOST_PP_CHECK_0(chk) BOOST_PP_CHECK_1(BOOST_PP_CAT(BOOST_PP_CHECK_RESULT_, chk)) +# define BOOST_PP_CHECK_1(chk) BOOST_PP_CHECK_2(chk) +# define BOOST_PP_CHECK_2(res, _) res +# endif +# +# define BOOST_PP_CHECK_RESULT_1 1, BOOST_PP_NIL +# +# endif diff --git a/realsense-file/3rd_party/boost/boost/preprocessor/detail/is_binary.hpp b/realsense-file/3rd_party/boost/boost/preprocessor/detail/is_binary.hpp new file mode 100644 index 0000000000..f2180e54ee --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/preprocessor/detail/is_binary.hpp @@ -0,0 +1,30 @@ +# /* ************************************************************************** +# * * +# * (C) Copyright Paul Mensonides 2002. +# * Distributed under the Boost Software License, Version 1.0. (See +# * accompanying file LICENSE_1_0.txt or copy at +# * http://www.boost.org/LICENSE_1_0.txt) +# * * +# ************************************************************************** */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_DETAIL_IS_BINARY_HPP +# define BOOST_PREPROCESSOR_DETAIL_IS_BINARY_HPP +# +# include +# include +# +# /* BOOST_PP_IS_BINARY */ +# +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() +# define BOOST_PP_IS_BINARY(x) BOOST_PP_CHECK(x, BOOST_PP_IS_BINARY_CHECK) +# else +# define BOOST_PP_IS_BINARY(x) BOOST_PP_IS_BINARY_I(x) +# define BOOST_PP_IS_BINARY_I(x) BOOST_PP_CHECK(x, BOOST_PP_IS_BINARY_CHECK) +# endif +# +# define BOOST_PP_IS_BINARY_CHECK(a, b) 1 +# define BOOST_PP_CHECK_RESULT_BOOST_PP_IS_BINARY_CHECK 0, BOOST_PP_NIL +# +# endif diff --git a/realsense-file/3rd_party/boost/boost/preprocessor/empty.hpp b/realsense-file/3rd_party/boost/boost/preprocessor/empty.hpp new file mode 100644 index 0000000000..2367897b3c --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/preprocessor/empty.hpp @@ -0,0 +1,17 @@ +# /* ************************************************************************** +# * * +# * (C) Copyright Paul Mensonides 2002. +# * Distributed under the Boost Software License, Version 1.0. (See +# * accompanying file LICENSE_1_0.txt or copy at +# * http://www.boost.org/LICENSE_1_0.txt) +# * * +# ************************************************************************** */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_EMPTY_HPP +# define BOOST_PREPROCESSOR_EMPTY_HPP +# +# include +# +# endif diff --git a/realsense-file/3rd_party/boost/boost/preprocessor/enum.hpp b/realsense-file/3rd_party/boost/boost/preprocessor/enum.hpp new file mode 100644 index 0000000000..a5bd7e06d9 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/preprocessor/enum.hpp @@ -0,0 +1,17 @@ +# /* ************************************************************************** +# * * +# * (C) Copyright Paul Mensonides 2002. +# * Distributed under the Boost Software License, Version 1.0. (See +# * accompanying file LICENSE_1_0.txt or copy at +# * http://www.boost.org/LICENSE_1_0.txt) +# * * +# ************************************************************************** */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_ENUM_HPP +# define BOOST_PREPROCESSOR_ENUM_HPP +# +# include +# +# endif diff --git a/realsense-file/3rd_party/boost/boost/preprocessor/enum_params.hpp b/realsense-file/3rd_party/boost/boost/preprocessor/enum_params.hpp new file mode 100644 index 0000000000..4b033501af --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/preprocessor/enum_params.hpp @@ -0,0 +1,17 @@ +# /* ************************************************************************** +# * * +# * (C) Copyright Paul Mensonides 2002. +# * Distributed under the Boost Software License, Version 1.0. (See +# * accompanying file LICENSE_1_0.txt or copy at +# * http://www.boost.org/LICENSE_1_0.txt) +# * * +# ************************************************************************** */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_ENUM_PARAMS_HPP +# define BOOST_PREPROCESSOR_ENUM_PARAMS_HPP +# +# include +# +# endif diff --git a/realsense-file/3rd_party/boost/boost/preprocessor/facilities/detail/is_empty.hpp b/realsense-file/3rd_party/boost/boost/preprocessor/facilities/detail/is_empty.hpp new file mode 100644 index 0000000000..c24c92f1fc --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/preprocessor/facilities/detail/is_empty.hpp @@ -0,0 +1,55 @@ +# /* ************************************************************************** +# * * +# * (C) Copyright Edward Diener 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) +# * * +# ************************************************************************** */ +# +# /* See http://www.boost.org for most recent version. */ +# +#ifndef BOOST_PREPROCESSOR_DETAIL_IS_EMPTY_HPP +#define BOOST_PREPROCESSOR_DETAIL_IS_EMPTY_HPP + +#include + +#if BOOST_PP_VARIADICS_MSVC + +# pragma warning(once:4002) + +#define BOOST_PP_DETAIL_IS_EMPTY_IIF_0(t, b) b +#define BOOST_PP_DETAIL_IS_EMPTY_IIF_1(t, b) t + +#else + +#define BOOST_PP_DETAIL_IS_EMPTY_IIF_0(t, ...) __VA_ARGS__ +#define BOOST_PP_DETAIL_IS_EMPTY_IIF_1(t, ...) t + +#endif + +#if BOOST_PP_VARIADICS_MSVC && _MSC_VER <= 1400 + +#define BOOST_PP_DETAIL_IS_EMPTY_PROCESS(param) \ + BOOST_PP_IS_BEGIN_PARENS \ + ( \ + BOOST_PP_DETAIL_IS_EMPTY_NON_FUNCTION_C param () \ + ) \ +/**/ + +#else + +#define BOOST_PP_DETAIL_IS_EMPTY_PROCESS(...) \ + BOOST_PP_IS_BEGIN_PARENS \ + ( \ + BOOST_PP_DETAIL_IS_EMPTY_NON_FUNCTION_C __VA_ARGS__ () \ + ) \ +/**/ + +#endif + +#define BOOST_PP_DETAIL_IS_EMPTY_PRIMITIVE_CAT(a, b) a ## b +#define BOOST_PP_DETAIL_IS_EMPTY_IIF(bit) BOOST_PP_DETAIL_IS_EMPTY_PRIMITIVE_CAT(BOOST_PP_DETAIL_IS_EMPTY_IIF_,bit) +#define BOOST_PP_DETAIL_IS_EMPTY_NON_FUNCTION_C(...) () + +#endif /* BOOST_PREPROCESSOR_DETAIL_IS_EMPTY_HPP */ diff --git a/realsense-file/3rd_party/boost/boost/preprocessor/facilities/empty.hpp b/realsense-file/3rd_party/boost/boost/preprocessor/facilities/empty.hpp new file mode 100644 index 0000000000..85f83f1705 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/preprocessor/facilities/empty.hpp @@ -0,0 +1,23 @@ +# /* Copyright (C) 2001 +# * Housemarque Oy +# * http://www.housemarque.com +# * +# * 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) +# */ +# +# /* Revised by Paul Mensonides (2002) */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_FACILITIES_EMPTY_HPP +# define BOOST_PREPROCESSOR_FACILITIES_EMPTY_HPP +# +# include "boost/preprocessor/config/config.hpp" +# +# /* BOOST_PP_EMPTY */ +# +# define BOOST_PP_EMPTY() +# +# endif diff --git a/realsense-file/3rd_party/boost/boost/preprocessor/facilities/expand.hpp b/realsense-file/3rd_party/boost/boost/preprocessor/facilities/expand.hpp new file mode 100644 index 0000000000..562d5fd228 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/preprocessor/facilities/expand.hpp @@ -0,0 +1,28 @@ +# /* Copyright (C) 2001 +# * Housemarque Oy +# * http://www.housemarque.com +# * +# * 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) +# */ +# +# /* Revised by Paul Mensonides (2002) */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_FACILITIES_EXPAND_HPP +# define BOOST_PREPROCESSOR_FACILITIES_EXPAND_HPP +# +# include +# +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() && ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_DMC() +# define BOOST_PP_EXPAND(x) BOOST_PP_EXPAND_I(x) +# else +# define BOOST_PP_EXPAND(x) BOOST_PP_EXPAND_OO((x)) +# define BOOST_PP_EXPAND_OO(par) BOOST_PP_EXPAND_I ## par +# endif +# +# define BOOST_PP_EXPAND_I(x) x +# +# endif diff --git a/realsense-file/3rd_party/boost/boost/preprocessor/facilities/identity.hpp b/realsense-file/3rd_party/boost/boost/preprocessor/facilities/identity.hpp new file mode 100644 index 0000000000..f79b3cea59 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/preprocessor/facilities/identity.hpp @@ -0,0 +1,23 @@ +# /* Copyright (C) 2001 +# * Housemarque Oy +# * http://www.housemarque.com +# * +# * 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) +# */ +# +# /* Revised by Paul Mensonides (2002) */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_FACILITIES_IDENTITY_HPP +# define BOOST_PREPROCESSOR_FACILITIES_IDENTITY_HPP +# +# include +# +# /* BOOST_PP_IDENTITY */ +# +# define BOOST_PP_IDENTITY(item) item BOOST_PP_EMPTY +# +# endif diff --git a/realsense-file/3rd_party/boost/boost/preprocessor/facilities/is_1.hpp b/realsense-file/3rd_party/boost/boost/preprocessor/facilities/is_1.hpp new file mode 100644 index 0000000000..b3dba6d69b --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/preprocessor/facilities/is_1.hpp @@ -0,0 +1,23 @@ +# /* ************************************************************************** +# * * +# * (C) Copyright Paul Mensonides 2003. +# * Distributed under the Boost Software License, Version 1.0. (See +# * accompanying file LICENSE_1_0.txt or copy at +# * http://www.boost.org/LICENSE_1_0.txt) +# * * +# ************************************************************************** */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_FACILITIES_IS_1_HPP +# define BOOST_PREPROCESSOR_FACILITIES_IS_1_HPP +# +# include +# include +# +# /* BOOST_PP_IS_1 */ +# +# define BOOST_PP_IS_1(x) BOOST_PP_IS_EMPTY(BOOST_PP_CAT(BOOST_PP_IS_1_HELPER_, x)) +# define BOOST_PP_IS_1_HELPER_1 +# +# endif diff --git a/realsense-file/3rd_party/boost/boost/preprocessor/facilities/is_empty.hpp b/realsense-file/3rd_party/boost/boost/preprocessor/facilities/is_empty.hpp new file mode 100644 index 0000000000..6ceb045258 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/preprocessor/facilities/is_empty.hpp @@ -0,0 +1,56 @@ +# /* ************************************************************************** +# * * +# * (C) Copyright Paul Mensonides 2003. +# * (C) Copyright Edward Diener 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) +# * * +# ************************************************************************** */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_FACILITIES_IS_EMPTY_HPP +# define BOOST_PREPROCESSOR_FACILITIES_IS_EMPTY_HPP +# +# include +# +# if BOOST_PP_VARIADICS +# +# include +# +# else +# +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MSVC() && ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() +# include +# include +# else +# include +# include +# endif +# +# /* BOOST_PP_IS_EMPTY */ +# +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MSVC() && ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() +# define BOOST_PP_IS_EMPTY(x) BOOST_PP_IS_EMPTY_I(x BOOST_PP_IS_EMPTY_HELPER) +# define BOOST_PP_IS_EMPTY_I(contents) BOOST_PP_TUPLE_ELEM(2, 1, (BOOST_PP_IS_EMPTY_DEF_ ## contents())) +# define BOOST_PP_IS_EMPTY_DEF_BOOST_PP_IS_EMPTY_HELPER 1, BOOST_PP_IDENTITY(1) +# define BOOST_PP_IS_EMPTY_HELPER() , 0 +# else +# if BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MSVC() +# define BOOST_PP_IS_EMPTY(x) BOOST_PP_IS_EMPTY_I(BOOST_PP_IS_EMPTY_HELPER x ()) +# define BOOST_PP_IS_EMPTY_I(test) BOOST_PP_IS_EMPTY_II(BOOST_PP_SPLIT(0, BOOST_PP_CAT(BOOST_PP_IS_EMPTY_DEF_, test))) +# define BOOST_PP_IS_EMPTY_II(id) id +# else +# define BOOST_PP_IS_EMPTY(x) BOOST_PP_IS_EMPTY_I((BOOST_PP_IS_EMPTY_HELPER x ())) +# define BOOST_PP_IS_EMPTY_I(par) BOOST_PP_IS_EMPTY_II ## par +# define BOOST_PP_IS_EMPTY_II(test) BOOST_PP_SPLIT(0, BOOST_PP_CAT(BOOST_PP_IS_EMPTY_DEF_, test)) +# endif +# define BOOST_PP_IS_EMPTY_HELPER() 1 +# define BOOST_PP_IS_EMPTY_DEF_1 1, BOOST_PP_NIL +# define BOOST_PP_IS_EMPTY_DEF_BOOST_PP_IS_EMPTY_HELPER 0, BOOST_PP_NIL +# endif +# +# endif /* BOOST_PP_VARIADICS */ +# +# endif /* BOOST_PREPROCESSOR_FACILITIES_IS_EMPTY_HPP */ diff --git a/realsense-file/3rd_party/boost/boost/preprocessor/facilities/is_empty_variadic.hpp b/realsense-file/3rd_party/boost/boost/preprocessor/facilities/is_empty_variadic.hpp new file mode 100644 index 0000000000..8ce6d43192 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/preprocessor/facilities/is_empty_variadic.hpp @@ -0,0 +1,57 @@ +# /* ************************************************************************** +# * * +# * (C) Copyright Edward Diener 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) +# * * +# ************************************************************************** */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_FACILITIES_IS_EMPTY_VARIADIC_HPP +# define BOOST_PREPROCESSOR_FACILITIES_IS_EMPTY_VARIADIC_HPP +# +# include +# +# if BOOST_PP_VARIADICS +# +# include +# include +# +#if BOOST_PP_VARIADICS_MSVC && _MSC_VER <= 1400 +# +#define BOOST_PP_IS_EMPTY(param) \ + BOOST_PP_DETAIL_IS_EMPTY_IIF \ + ( \ + BOOST_PP_IS_BEGIN_PARENS \ + ( \ + param \ + ) \ + ) \ + ( \ + BOOST_PP_IS_EMPTY_ZERO, \ + BOOST_PP_DETAIL_IS_EMPTY_PROCESS \ + ) \ + (param) \ +/**/ +#define BOOST_PP_IS_EMPTY_ZERO(param) 0 +# else +#define BOOST_PP_IS_EMPTY(...) \ + BOOST_PP_DETAIL_IS_EMPTY_IIF \ + ( \ + BOOST_PP_IS_BEGIN_PARENS \ + ( \ + __VA_ARGS__ \ + ) \ + ) \ + ( \ + BOOST_PP_IS_EMPTY_ZERO, \ + BOOST_PP_DETAIL_IS_EMPTY_PROCESS \ + ) \ + (__VA_ARGS__) \ +/**/ +#define BOOST_PP_IS_EMPTY_ZERO(...) 0 +# endif /* BOOST_PP_VARIADICS_MSVC && _MSC_VER <= 1400 */ +# endif /* BOOST_PP_VARIADICS */ +# endif /* BOOST_PREPROCESSOR_FACILITIES_IS_EMPTY_VARIADIC_HPP */ diff --git a/realsense-file/3rd_party/boost/boost/preprocessor/facilities/overload.hpp b/realsense-file/3rd_party/boost/boost/preprocessor/facilities/overload.hpp new file mode 100644 index 0000000000..105d0a1a9d --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/preprocessor/facilities/overload.hpp @@ -0,0 +1,25 @@ +# /* ************************************************************************** +# * * +# * (C) Copyright Paul Mensonides 2011. * +# * (C) Copyright Edward Diener 2011. * +# * Distributed under the Boost Software License, Version 1.0. (See * +# * accompanying file LICENSE_1_0.txt or copy at * +# * http://www.boost.org/LICENSE_1_0.txt) * +# * * +# ************************************************************************** */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_FACILITIES_OVERLOAD_HPP +# define BOOST_PREPROCESSOR_FACILITIES_OVERLOAD_HPP +# +# include +# include +# +# /* BOOST_PP_OVERLOAD */ +# +# if BOOST_PP_VARIADICS +# define BOOST_PP_OVERLOAD(prefix, ...) BOOST_PP_CAT(prefix, BOOST_PP_VARIADIC_SIZE(__VA_ARGS__)) +# endif +# +# endif diff --git a/realsense-file/3rd_party/boost/boost/preprocessor/identity.hpp b/realsense-file/3rd_party/boost/boost/preprocessor/identity.hpp new file mode 100644 index 0000000000..23f37a49ea --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/preprocessor/identity.hpp @@ -0,0 +1,17 @@ +# /* ************************************************************************** +# * * +# * (C) Copyright Paul Mensonides 2002. +# * Distributed under the Boost Software License, Version 1.0. (See +# * accompanying file LICENSE_1_0.txt or copy at +# * http://www.boost.org/LICENSE_1_0.txt) +# * * +# ************************************************************************** */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_IDENTITY_HPP +# define BOOST_PREPROCESSOR_IDENTITY_HPP +# +# include +# +# endif diff --git a/realsense-file/3rd_party/boost/boost/preprocessor/inc.hpp b/realsense-file/3rd_party/boost/boost/preprocessor/inc.hpp new file mode 100644 index 0000000000..b11e899c96 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/preprocessor/inc.hpp @@ -0,0 +1,17 @@ +# /* ************************************************************************** +# * * +# * (C) Copyright Paul Mensonides 2002. +# * Distributed under the Boost Software License, Version 1.0. (See +# * accompanying file LICENSE_1_0.txt or copy at +# * http://www.boost.org/LICENSE_1_0.txt) +# * * +# ************************************************************************** */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_INC_HPP +# define BOOST_PREPROCESSOR_INC_HPP +# +# include +# +# endif diff --git a/realsense-file/3rd_party/boost/boost/preprocessor/iterate.hpp b/realsense-file/3rd_party/boost/boost/preprocessor/iterate.hpp new file mode 100644 index 0000000000..b3b4aeb57d --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/preprocessor/iterate.hpp @@ -0,0 +1,17 @@ +# /* ************************************************************************** +# * * +# * (C) Copyright Paul Mensonides 2002. +# * Distributed under the Boost Software License, Version 1.0. (See +# * accompanying file LICENSE_1_0.txt or copy at +# * http://www.boost.org/LICENSE_1_0.txt) +# * * +# ************************************************************************** */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_ITERATE_HPP +# define BOOST_PREPROCESSOR_ITERATE_HPP +# +# include +# +# endif diff --git a/realsense-file/3rd_party/boost/boost/preprocessor/iteration/detail/bounds/lower1.hpp b/realsense-file/3rd_party/boost/boost/preprocessor/iteration/detail/bounds/lower1.hpp new file mode 100644 index 0000000000..6c4dad2245 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/preprocessor/iteration/detail/bounds/lower1.hpp @@ -0,0 +1,99 @@ +# /* ************************************************************************** +# * * +# * (C) Copyright Paul Mensonides 2002. +# * Distributed under the Boost Software License, Version 1.0. (See +# * accompanying file LICENSE_1_0.txt or copy at +# * http://www.boost.org/LICENSE_1_0.txt) +# * * +# ************************************************************************** */ +# +# /* See http://www.boost.org for most recent version. */ +# +# include +# +# undef BOOST_PP_ITERATION_START_1 +# +# undef BOOST_PP_ITERATION_START_1_DIGIT_1 +# undef BOOST_PP_ITERATION_START_1_DIGIT_2 +# undef BOOST_PP_ITERATION_START_1_DIGIT_3 +# undef BOOST_PP_ITERATION_START_1_DIGIT_4 +# undef BOOST_PP_ITERATION_START_1_DIGIT_5 +# undef BOOST_PP_ITERATION_START_1_DIGIT_6 +# undef BOOST_PP_ITERATION_START_1_DIGIT_7 +# undef BOOST_PP_ITERATION_START_1_DIGIT_8 +# undef BOOST_PP_ITERATION_START_1_DIGIT_9 +# undef BOOST_PP_ITERATION_START_1_DIGIT_10 +# +# if BOOST_PP_SLOT_TEMP_3 == 0 +# define BOOST_PP_ITERATION_START_1_DIGIT_3 0 +# elif BOOST_PP_SLOT_TEMP_3 == 1 +# define BOOST_PP_ITERATION_START_1_DIGIT_3 1 +# elif BOOST_PP_SLOT_TEMP_3 == 2 +# define BOOST_PP_ITERATION_START_1_DIGIT_3 2 +# elif BOOST_PP_SLOT_TEMP_3 == 3 +# define BOOST_PP_ITERATION_START_1_DIGIT_3 3 +# elif BOOST_PP_SLOT_TEMP_3 == 4 +# define BOOST_PP_ITERATION_START_1_DIGIT_3 4 +# elif BOOST_PP_SLOT_TEMP_3 == 5 +# define BOOST_PP_ITERATION_START_1_DIGIT_3 5 +# elif BOOST_PP_SLOT_TEMP_3 == 6 +# define BOOST_PP_ITERATION_START_1_DIGIT_3 6 +# elif BOOST_PP_SLOT_TEMP_3 == 7 +# define BOOST_PP_ITERATION_START_1_DIGIT_3 7 +# elif BOOST_PP_SLOT_TEMP_3 == 8 +# define BOOST_PP_ITERATION_START_1_DIGIT_3 8 +# elif BOOST_PP_SLOT_TEMP_3 == 9 +# define BOOST_PP_ITERATION_START_1_DIGIT_3 9 +# endif +# +# if BOOST_PP_SLOT_TEMP_2 == 0 +# define BOOST_PP_ITERATION_START_1_DIGIT_2 0 +# elif BOOST_PP_SLOT_TEMP_2 == 1 +# define BOOST_PP_ITERATION_START_1_DIGIT_2 1 +# elif BOOST_PP_SLOT_TEMP_2 == 2 +# define BOOST_PP_ITERATION_START_1_DIGIT_2 2 +# elif BOOST_PP_SLOT_TEMP_2 == 3 +# define BOOST_PP_ITERATION_START_1_DIGIT_2 3 +# elif BOOST_PP_SLOT_TEMP_2 == 4 +# define BOOST_PP_ITERATION_START_1_DIGIT_2 4 +# elif BOOST_PP_SLOT_TEMP_2 == 5 +# define BOOST_PP_ITERATION_START_1_DIGIT_2 5 +# elif BOOST_PP_SLOT_TEMP_2 == 6 +# define BOOST_PP_ITERATION_START_1_DIGIT_2 6 +# elif BOOST_PP_SLOT_TEMP_2 == 7 +# define BOOST_PP_ITERATION_START_1_DIGIT_2 7 +# elif BOOST_PP_SLOT_TEMP_2 == 8 +# define BOOST_PP_ITERATION_START_1_DIGIT_2 8 +# elif BOOST_PP_SLOT_TEMP_2 == 9 +# define BOOST_PP_ITERATION_START_1_DIGIT_2 9 +# endif +# +# if BOOST_PP_SLOT_TEMP_1 == 0 +# define BOOST_PP_ITERATION_START_1_DIGIT_1 0 +# elif BOOST_PP_SLOT_TEMP_1 == 1 +# define BOOST_PP_ITERATION_START_1_DIGIT_1 1 +# elif BOOST_PP_SLOT_TEMP_1 == 2 +# define BOOST_PP_ITERATION_START_1_DIGIT_1 2 +# elif BOOST_PP_SLOT_TEMP_1 == 3 +# define BOOST_PP_ITERATION_START_1_DIGIT_1 3 +# elif BOOST_PP_SLOT_TEMP_1 == 4 +# define BOOST_PP_ITERATION_START_1_DIGIT_1 4 +# elif BOOST_PP_SLOT_TEMP_1 == 5 +# define BOOST_PP_ITERATION_START_1_DIGIT_1 5 +# elif BOOST_PP_SLOT_TEMP_1 == 6 +# define BOOST_PP_ITERATION_START_1_DIGIT_1 6 +# elif BOOST_PP_SLOT_TEMP_1 == 7 +# define BOOST_PP_ITERATION_START_1_DIGIT_1 7 +# elif BOOST_PP_SLOT_TEMP_1 == 8 +# define BOOST_PP_ITERATION_START_1_DIGIT_1 8 +# elif BOOST_PP_SLOT_TEMP_1 == 9 +# define BOOST_PP_ITERATION_START_1_DIGIT_1 9 +# endif +# +# if BOOST_PP_ITERATION_START_1_DIGIT_3 +# define BOOST_PP_ITERATION_START_1 BOOST_PP_SLOT_CC_3(BOOST_PP_ITERATION_START_1_DIGIT_3, BOOST_PP_ITERATION_START_1_DIGIT_2, BOOST_PP_ITERATION_START_1_DIGIT_1) +# elif BOOST_PP_ITERATION_START_1_DIGIT_2 +# define BOOST_PP_ITERATION_START_1 BOOST_PP_SLOT_CC_2(BOOST_PP_ITERATION_START_1_DIGIT_2, BOOST_PP_ITERATION_START_1_DIGIT_1) +# else +# define BOOST_PP_ITERATION_START_1 BOOST_PP_ITERATION_START_1_DIGIT_1 +# endif diff --git a/realsense-file/3rd_party/boost/boost/preprocessor/iteration/detail/bounds/upper1.hpp b/realsense-file/3rd_party/boost/boost/preprocessor/iteration/detail/bounds/upper1.hpp new file mode 100644 index 0000000000..db0732dba6 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/preprocessor/iteration/detail/bounds/upper1.hpp @@ -0,0 +1,99 @@ +# /* ************************************************************************** +# * * +# * (C) Copyright Paul Mensonides 2002. +# * Distributed under the Boost Software License, Version 1.0. (See +# * accompanying file LICENSE_1_0.txt or copy at +# * http://www.boost.org/LICENSE_1_0.txt) +# * * +# ************************************************************************** */ +# +# /* See http://www.boost.org for most recent version. */ +# +# include +# +# undef BOOST_PP_ITERATION_FINISH_1 +# +# undef BOOST_PP_ITERATION_FINISH_1_DIGIT_1 +# undef BOOST_PP_ITERATION_FINISH_1_DIGIT_2 +# undef BOOST_PP_ITERATION_FINISH_1_DIGIT_3 +# undef BOOST_PP_ITERATION_FINISH_1_DIGIT_4 +# undef BOOST_PP_ITERATION_FINISH_1_DIGIT_5 +# undef BOOST_PP_ITERATION_FINISH_1_DIGIT_6 +# undef BOOST_PP_ITERATION_FINISH_1_DIGIT_7 +# undef BOOST_PP_ITERATION_FINISH_1_DIGIT_8 +# undef BOOST_PP_ITERATION_FINISH_1_DIGIT_9 +# undef BOOST_PP_ITERATION_FINISH_1_DIGIT_10 +# +# if BOOST_PP_SLOT_TEMP_3 == 0 +# define BOOST_PP_ITERATION_FINISH_1_DIGIT_3 0 +# elif BOOST_PP_SLOT_TEMP_3 == 1 +# define BOOST_PP_ITERATION_FINISH_1_DIGIT_3 1 +# elif BOOST_PP_SLOT_TEMP_3 == 2 +# define BOOST_PP_ITERATION_FINISH_1_DIGIT_3 2 +# elif BOOST_PP_SLOT_TEMP_3 == 3 +# define BOOST_PP_ITERATION_FINISH_1_DIGIT_3 3 +# elif BOOST_PP_SLOT_TEMP_3 == 4 +# define BOOST_PP_ITERATION_FINISH_1_DIGIT_3 4 +# elif BOOST_PP_SLOT_TEMP_3 == 5 +# define BOOST_PP_ITERATION_FINISH_1_DIGIT_3 5 +# elif BOOST_PP_SLOT_TEMP_3 == 6 +# define BOOST_PP_ITERATION_FINISH_1_DIGIT_3 6 +# elif BOOST_PP_SLOT_TEMP_3 == 7 +# define BOOST_PP_ITERATION_FINISH_1_DIGIT_3 7 +# elif BOOST_PP_SLOT_TEMP_3 == 8 +# define BOOST_PP_ITERATION_FINISH_1_DIGIT_3 8 +# elif BOOST_PP_SLOT_TEMP_3 == 9 +# define BOOST_PP_ITERATION_FINISH_1_DIGIT_3 9 +# endif +# +# if BOOST_PP_SLOT_TEMP_2 == 0 +# define BOOST_PP_ITERATION_FINISH_1_DIGIT_2 0 +# elif BOOST_PP_SLOT_TEMP_2 == 1 +# define BOOST_PP_ITERATION_FINISH_1_DIGIT_2 1 +# elif BOOST_PP_SLOT_TEMP_2 == 2 +# define BOOST_PP_ITERATION_FINISH_1_DIGIT_2 2 +# elif BOOST_PP_SLOT_TEMP_2 == 3 +# define BOOST_PP_ITERATION_FINISH_1_DIGIT_2 3 +# elif BOOST_PP_SLOT_TEMP_2 == 4 +# define BOOST_PP_ITERATION_FINISH_1_DIGIT_2 4 +# elif BOOST_PP_SLOT_TEMP_2 == 5 +# define BOOST_PP_ITERATION_FINISH_1_DIGIT_2 5 +# elif BOOST_PP_SLOT_TEMP_2 == 6 +# define BOOST_PP_ITERATION_FINISH_1_DIGIT_2 6 +# elif BOOST_PP_SLOT_TEMP_2 == 7 +# define BOOST_PP_ITERATION_FINISH_1_DIGIT_2 7 +# elif BOOST_PP_SLOT_TEMP_2 == 8 +# define BOOST_PP_ITERATION_FINISH_1_DIGIT_2 8 +# elif BOOST_PP_SLOT_TEMP_2 == 9 +# define BOOST_PP_ITERATION_FINISH_1_DIGIT_2 9 +# endif +# +# if BOOST_PP_SLOT_TEMP_1 == 0 +# define BOOST_PP_ITERATION_FINISH_1_DIGIT_1 0 +# elif BOOST_PP_SLOT_TEMP_1 == 1 +# define BOOST_PP_ITERATION_FINISH_1_DIGIT_1 1 +# elif BOOST_PP_SLOT_TEMP_1 == 2 +# define BOOST_PP_ITERATION_FINISH_1_DIGIT_1 2 +# elif BOOST_PP_SLOT_TEMP_1 == 3 +# define BOOST_PP_ITERATION_FINISH_1_DIGIT_1 3 +# elif BOOST_PP_SLOT_TEMP_1 == 4 +# define BOOST_PP_ITERATION_FINISH_1_DIGIT_1 4 +# elif BOOST_PP_SLOT_TEMP_1 == 5 +# define BOOST_PP_ITERATION_FINISH_1_DIGIT_1 5 +# elif BOOST_PP_SLOT_TEMP_1 == 6 +# define BOOST_PP_ITERATION_FINISH_1_DIGIT_1 6 +# elif BOOST_PP_SLOT_TEMP_1 == 7 +# define BOOST_PP_ITERATION_FINISH_1_DIGIT_1 7 +# elif BOOST_PP_SLOT_TEMP_1 == 8 +# define BOOST_PP_ITERATION_FINISH_1_DIGIT_1 8 +# elif BOOST_PP_SLOT_TEMP_1 == 9 +# define BOOST_PP_ITERATION_FINISH_1_DIGIT_1 9 +# endif +# +# if BOOST_PP_ITERATION_FINISH_1_DIGIT_3 +# define BOOST_PP_ITERATION_FINISH_1 BOOST_PP_SLOT_CC_3(BOOST_PP_ITERATION_FINISH_1_DIGIT_3, BOOST_PP_ITERATION_FINISH_1_DIGIT_2, BOOST_PP_ITERATION_FINISH_1_DIGIT_1) +# elif BOOST_PP_ITERATION_FINISH_1_DIGIT_2 +# define BOOST_PP_ITERATION_FINISH_1 BOOST_PP_SLOT_CC_2(BOOST_PP_ITERATION_FINISH_1_DIGIT_2, BOOST_PP_ITERATION_FINISH_1_DIGIT_1) +# else +# define BOOST_PP_ITERATION_FINISH_1 BOOST_PP_ITERATION_FINISH_1_DIGIT_1 +# endif diff --git a/realsense-file/3rd_party/boost/boost/preprocessor/iteration/detail/iter/forward1.hpp b/realsense-file/3rd_party/boost/boost/preprocessor/iteration/detail/iter/forward1.hpp new file mode 100644 index 0000000000..2ee8eeb232 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/preprocessor/iteration/detail/iter/forward1.hpp @@ -0,0 +1,1342 @@ +# /* ************************************************************************** +# * * +# * (C) Copyright Paul Mensonides 2002. +# * Distributed under the Boost Software License, Version 1.0. (See +# * accompanying file LICENSE_1_0.txt or copy at +# * http://www.boost.org/LICENSE_1_0.txt) +# * * +# ************************************************************************** */ +# +# /* See http://www.boost.org for most recent version. */ +# +# if defined(BOOST_PP_ITERATION_LIMITS) +# if !defined(BOOST_PP_FILENAME_1) +# error BOOST_PP_ERROR: depth #1 filename is not defined +# endif +# define BOOST_PP_VALUE BOOST_PP_TUPLE_ELEM(2, 0, BOOST_PP_ITERATION_LIMITS) +# include +# define BOOST_PP_VALUE BOOST_PP_TUPLE_ELEM(2, 1, BOOST_PP_ITERATION_LIMITS) +# include +# define BOOST_PP_ITERATION_FLAGS_1() 0 +# undef BOOST_PP_ITERATION_LIMITS +# elif defined(BOOST_PP_ITERATION_PARAMS_1) +# define BOOST_PP_VALUE BOOST_PP_ARRAY_ELEM(0, BOOST_PP_ITERATION_PARAMS_1) +# include +# define BOOST_PP_VALUE BOOST_PP_ARRAY_ELEM(1, BOOST_PP_ITERATION_PARAMS_1) +# include +# define BOOST_PP_FILENAME_1 BOOST_PP_ARRAY_ELEM(2, BOOST_PP_ITERATION_PARAMS_1) +# if BOOST_PP_ARRAY_SIZE(BOOST_PP_ITERATION_PARAMS_1) >= 4 +# define BOOST_PP_ITERATION_FLAGS_1() BOOST_PP_ARRAY_ELEM(3, BOOST_PP_ITERATION_PARAMS_1) +# else +# define BOOST_PP_ITERATION_FLAGS_1() 0 +# endif +# else +# error BOOST_PP_ERROR: depth #1 iteration boundaries or filename not defined +# endif +# +# undef BOOST_PP_ITERATION_DEPTH +# define BOOST_PP_ITERATION_DEPTH() 1 +# +# define BOOST_PP_IS_ITERATING 1 +# +# if (BOOST_PP_ITERATION_START_1) > (BOOST_PP_ITERATION_FINISH_1) +# include +# else +# if BOOST_PP_ITERATION_START_1 <= 0 && BOOST_PP_ITERATION_FINISH_1 >= 0 +# define BOOST_PP_ITERATION_1 0 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 1 && BOOST_PP_ITERATION_FINISH_1 >= 1 +# define BOOST_PP_ITERATION_1 1 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 2 && BOOST_PP_ITERATION_FINISH_1 >= 2 +# define BOOST_PP_ITERATION_1 2 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 3 && BOOST_PP_ITERATION_FINISH_1 >= 3 +# define BOOST_PP_ITERATION_1 3 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 4 && BOOST_PP_ITERATION_FINISH_1 >= 4 +# define BOOST_PP_ITERATION_1 4 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 5 && BOOST_PP_ITERATION_FINISH_1 >= 5 +# define BOOST_PP_ITERATION_1 5 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 6 && BOOST_PP_ITERATION_FINISH_1 >= 6 +# define BOOST_PP_ITERATION_1 6 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 7 && BOOST_PP_ITERATION_FINISH_1 >= 7 +# define BOOST_PP_ITERATION_1 7 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 8 && BOOST_PP_ITERATION_FINISH_1 >= 8 +# define BOOST_PP_ITERATION_1 8 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 9 && BOOST_PP_ITERATION_FINISH_1 >= 9 +# define BOOST_PP_ITERATION_1 9 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 10 && BOOST_PP_ITERATION_FINISH_1 >= 10 +# define BOOST_PP_ITERATION_1 10 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 11 && BOOST_PP_ITERATION_FINISH_1 >= 11 +# define BOOST_PP_ITERATION_1 11 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 12 && BOOST_PP_ITERATION_FINISH_1 >= 12 +# define BOOST_PP_ITERATION_1 12 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 13 && BOOST_PP_ITERATION_FINISH_1 >= 13 +# define BOOST_PP_ITERATION_1 13 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 14 && BOOST_PP_ITERATION_FINISH_1 >= 14 +# define BOOST_PP_ITERATION_1 14 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 15 && BOOST_PP_ITERATION_FINISH_1 >= 15 +# define BOOST_PP_ITERATION_1 15 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 16 && BOOST_PP_ITERATION_FINISH_1 >= 16 +# define BOOST_PP_ITERATION_1 16 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 17 && BOOST_PP_ITERATION_FINISH_1 >= 17 +# define BOOST_PP_ITERATION_1 17 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 18 && BOOST_PP_ITERATION_FINISH_1 >= 18 +# define BOOST_PP_ITERATION_1 18 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 19 && BOOST_PP_ITERATION_FINISH_1 >= 19 +# define BOOST_PP_ITERATION_1 19 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 20 && BOOST_PP_ITERATION_FINISH_1 >= 20 +# define BOOST_PP_ITERATION_1 20 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 21 && BOOST_PP_ITERATION_FINISH_1 >= 21 +# define BOOST_PP_ITERATION_1 21 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 22 && BOOST_PP_ITERATION_FINISH_1 >= 22 +# define BOOST_PP_ITERATION_1 22 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 23 && BOOST_PP_ITERATION_FINISH_1 >= 23 +# define BOOST_PP_ITERATION_1 23 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 24 && BOOST_PP_ITERATION_FINISH_1 >= 24 +# define BOOST_PP_ITERATION_1 24 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 25 && BOOST_PP_ITERATION_FINISH_1 >= 25 +# define BOOST_PP_ITERATION_1 25 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 26 && BOOST_PP_ITERATION_FINISH_1 >= 26 +# define BOOST_PP_ITERATION_1 26 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 27 && BOOST_PP_ITERATION_FINISH_1 >= 27 +# define BOOST_PP_ITERATION_1 27 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 28 && BOOST_PP_ITERATION_FINISH_1 >= 28 +# define BOOST_PP_ITERATION_1 28 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 29 && BOOST_PP_ITERATION_FINISH_1 >= 29 +# define BOOST_PP_ITERATION_1 29 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 30 && BOOST_PP_ITERATION_FINISH_1 >= 30 +# define BOOST_PP_ITERATION_1 30 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 31 && BOOST_PP_ITERATION_FINISH_1 >= 31 +# define BOOST_PP_ITERATION_1 31 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 32 && BOOST_PP_ITERATION_FINISH_1 >= 32 +# define BOOST_PP_ITERATION_1 32 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 33 && BOOST_PP_ITERATION_FINISH_1 >= 33 +# define BOOST_PP_ITERATION_1 33 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 34 && BOOST_PP_ITERATION_FINISH_1 >= 34 +# define BOOST_PP_ITERATION_1 34 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 35 && BOOST_PP_ITERATION_FINISH_1 >= 35 +# define BOOST_PP_ITERATION_1 35 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 36 && BOOST_PP_ITERATION_FINISH_1 >= 36 +# define BOOST_PP_ITERATION_1 36 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 37 && BOOST_PP_ITERATION_FINISH_1 >= 37 +# define BOOST_PP_ITERATION_1 37 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 38 && BOOST_PP_ITERATION_FINISH_1 >= 38 +# define BOOST_PP_ITERATION_1 38 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 39 && BOOST_PP_ITERATION_FINISH_1 >= 39 +# define BOOST_PP_ITERATION_1 39 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 40 && BOOST_PP_ITERATION_FINISH_1 >= 40 +# define BOOST_PP_ITERATION_1 40 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 41 && BOOST_PP_ITERATION_FINISH_1 >= 41 +# define BOOST_PP_ITERATION_1 41 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 42 && BOOST_PP_ITERATION_FINISH_1 >= 42 +# define BOOST_PP_ITERATION_1 42 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 43 && BOOST_PP_ITERATION_FINISH_1 >= 43 +# define BOOST_PP_ITERATION_1 43 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 44 && BOOST_PP_ITERATION_FINISH_1 >= 44 +# define BOOST_PP_ITERATION_1 44 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 45 && BOOST_PP_ITERATION_FINISH_1 >= 45 +# define BOOST_PP_ITERATION_1 45 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 46 && BOOST_PP_ITERATION_FINISH_1 >= 46 +# define BOOST_PP_ITERATION_1 46 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 47 && BOOST_PP_ITERATION_FINISH_1 >= 47 +# define BOOST_PP_ITERATION_1 47 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 48 && BOOST_PP_ITERATION_FINISH_1 >= 48 +# define BOOST_PP_ITERATION_1 48 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 49 && BOOST_PP_ITERATION_FINISH_1 >= 49 +# define BOOST_PP_ITERATION_1 49 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 50 && BOOST_PP_ITERATION_FINISH_1 >= 50 +# define BOOST_PP_ITERATION_1 50 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 51 && BOOST_PP_ITERATION_FINISH_1 >= 51 +# define BOOST_PP_ITERATION_1 51 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 52 && BOOST_PP_ITERATION_FINISH_1 >= 52 +# define BOOST_PP_ITERATION_1 52 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 53 && BOOST_PP_ITERATION_FINISH_1 >= 53 +# define BOOST_PP_ITERATION_1 53 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 54 && BOOST_PP_ITERATION_FINISH_1 >= 54 +# define BOOST_PP_ITERATION_1 54 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 55 && BOOST_PP_ITERATION_FINISH_1 >= 55 +# define BOOST_PP_ITERATION_1 55 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 56 && BOOST_PP_ITERATION_FINISH_1 >= 56 +# define BOOST_PP_ITERATION_1 56 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 57 && BOOST_PP_ITERATION_FINISH_1 >= 57 +# define BOOST_PP_ITERATION_1 57 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 58 && BOOST_PP_ITERATION_FINISH_1 >= 58 +# define BOOST_PP_ITERATION_1 58 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 59 && BOOST_PP_ITERATION_FINISH_1 >= 59 +# define BOOST_PP_ITERATION_1 59 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 60 && BOOST_PP_ITERATION_FINISH_1 >= 60 +# define BOOST_PP_ITERATION_1 60 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 61 && BOOST_PP_ITERATION_FINISH_1 >= 61 +# define BOOST_PP_ITERATION_1 61 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 62 && BOOST_PP_ITERATION_FINISH_1 >= 62 +# define BOOST_PP_ITERATION_1 62 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 63 && BOOST_PP_ITERATION_FINISH_1 >= 63 +# define BOOST_PP_ITERATION_1 63 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 64 && BOOST_PP_ITERATION_FINISH_1 >= 64 +# define BOOST_PP_ITERATION_1 64 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 65 && BOOST_PP_ITERATION_FINISH_1 >= 65 +# define BOOST_PP_ITERATION_1 65 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 66 && BOOST_PP_ITERATION_FINISH_1 >= 66 +# define BOOST_PP_ITERATION_1 66 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 67 && BOOST_PP_ITERATION_FINISH_1 >= 67 +# define BOOST_PP_ITERATION_1 67 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 68 && BOOST_PP_ITERATION_FINISH_1 >= 68 +# define BOOST_PP_ITERATION_1 68 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 69 && BOOST_PP_ITERATION_FINISH_1 >= 69 +# define BOOST_PP_ITERATION_1 69 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 70 && BOOST_PP_ITERATION_FINISH_1 >= 70 +# define BOOST_PP_ITERATION_1 70 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 71 && BOOST_PP_ITERATION_FINISH_1 >= 71 +# define BOOST_PP_ITERATION_1 71 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 72 && BOOST_PP_ITERATION_FINISH_1 >= 72 +# define BOOST_PP_ITERATION_1 72 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 73 && BOOST_PP_ITERATION_FINISH_1 >= 73 +# define BOOST_PP_ITERATION_1 73 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 74 && BOOST_PP_ITERATION_FINISH_1 >= 74 +# define BOOST_PP_ITERATION_1 74 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 75 && BOOST_PP_ITERATION_FINISH_1 >= 75 +# define BOOST_PP_ITERATION_1 75 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 76 && BOOST_PP_ITERATION_FINISH_1 >= 76 +# define BOOST_PP_ITERATION_1 76 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 77 && BOOST_PP_ITERATION_FINISH_1 >= 77 +# define BOOST_PP_ITERATION_1 77 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 78 && BOOST_PP_ITERATION_FINISH_1 >= 78 +# define BOOST_PP_ITERATION_1 78 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 79 && BOOST_PP_ITERATION_FINISH_1 >= 79 +# define BOOST_PP_ITERATION_1 79 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 80 && BOOST_PP_ITERATION_FINISH_1 >= 80 +# define BOOST_PP_ITERATION_1 80 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 81 && BOOST_PP_ITERATION_FINISH_1 >= 81 +# define BOOST_PP_ITERATION_1 81 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 82 && BOOST_PP_ITERATION_FINISH_1 >= 82 +# define BOOST_PP_ITERATION_1 82 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 83 && BOOST_PP_ITERATION_FINISH_1 >= 83 +# define BOOST_PP_ITERATION_1 83 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 84 && BOOST_PP_ITERATION_FINISH_1 >= 84 +# define BOOST_PP_ITERATION_1 84 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 85 && BOOST_PP_ITERATION_FINISH_1 >= 85 +# define BOOST_PP_ITERATION_1 85 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 86 && BOOST_PP_ITERATION_FINISH_1 >= 86 +# define BOOST_PP_ITERATION_1 86 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 87 && BOOST_PP_ITERATION_FINISH_1 >= 87 +# define BOOST_PP_ITERATION_1 87 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 88 && BOOST_PP_ITERATION_FINISH_1 >= 88 +# define BOOST_PP_ITERATION_1 88 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 89 && BOOST_PP_ITERATION_FINISH_1 >= 89 +# define BOOST_PP_ITERATION_1 89 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 90 && BOOST_PP_ITERATION_FINISH_1 >= 90 +# define BOOST_PP_ITERATION_1 90 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 91 && BOOST_PP_ITERATION_FINISH_1 >= 91 +# define BOOST_PP_ITERATION_1 91 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 92 && BOOST_PP_ITERATION_FINISH_1 >= 92 +# define BOOST_PP_ITERATION_1 92 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 93 && BOOST_PP_ITERATION_FINISH_1 >= 93 +# define BOOST_PP_ITERATION_1 93 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 94 && BOOST_PP_ITERATION_FINISH_1 >= 94 +# define BOOST_PP_ITERATION_1 94 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 95 && BOOST_PP_ITERATION_FINISH_1 >= 95 +# define BOOST_PP_ITERATION_1 95 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 96 && BOOST_PP_ITERATION_FINISH_1 >= 96 +# define BOOST_PP_ITERATION_1 96 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 97 && BOOST_PP_ITERATION_FINISH_1 >= 97 +# define BOOST_PP_ITERATION_1 97 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 98 && BOOST_PP_ITERATION_FINISH_1 >= 98 +# define BOOST_PP_ITERATION_1 98 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 99 && BOOST_PP_ITERATION_FINISH_1 >= 99 +# define BOOST_PP_ITERATION_1 99 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 100 && BOOST_PP_ITERATION_FINISH_1 >= 100 +# define BOOST_PP_ITERATION_1 100 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 101 && BOOST_PP_ITERATION_FINISH_1 >= 101 +# define BOOST_PP_ITERATION_1 101 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 102 && BOOST_PP_ITERATION_FINISH_1 >= 102 +# define BOOST_PP_ITERATION_1 102 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 103 && BOOST_PP_ITERATION_FINISH_1 >= 103 +# define BOOST_PP_ITERATION_1 103 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 104 && BOOST_PP_ITERATION_FINISH_1 >= 104 +# define BOOST_PP_ITERATION_1 104 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 105 && BOOST_PP_ITERATION_FINISH_1 >= 105 +# define BOOST_PP_ITERATION_1 105 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 106 && BOOST_PP_ITERATION_FINISH_1 >= 106 +# define BOOST_PP_ITERATION_1 106 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 107 && BOOST_PP_ITERATION_FINISH_1 >= 107 +# define BOOST_PP_ITERATION_1 107 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 108 && BOOST_PP_ITERATION_FINISH_1 >= 108 +# define BOOST_PP_ITERATION_1 108 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 109 && BOOST_PP_ITERATION_FINISH_1 >= 109 +# define BOOST_PP_ITERATION_1 109 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 110 && BOOST_PP_ITERATION_FINISH_1 >= 110 +# define BOOST_PP_ITERATION_1 110 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 111 && BOOST_PP_ITERATION_FINISH_1 >= 111 +# define BOOST_PP_ITERATION_1 111 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 112 && BOOST_PP_ITERATION_FINISH_1 >= 112 +# define BOOST_PP_ITERATION_1 112 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 113 && BOOST_PP_ITERATION_FINISH_1 >= 113 +# define BOOST_PP_ITERATION_1 113 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 114 && BOOST_PP_ITERATION_FINISH_1 >= 114 +# define BOOST_PP_ITERATION_1 114 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 115 && BOOST_PP_ITERATION_FINISH_1 >= 115 +# define BOOST_PP_ITERATION_1 115 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 116 && BOOST_PP_ITERATION_FINISH_1 >= 116 +# define BOOST_PP_ITERATION_1 116 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 117 && BOOST_PP_ITERATION_FINISH_1 >= 117 +# define BOOST_PP_ITERATION_1 117 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 118 && BOOST_PP_ITERATION_FINISH_1 >= 118 +# define BOOST_PP_ITERATION_1 118 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 119 && BOOST_PP_ITERATION_FINISH_1 >= 119 +# define BOOST_PP_ITERATION_1 119 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 120 && BOOST_PP_ITERATION_FINISH_1 >= 120 +# define BOOST_PP_ITERATION_1 120 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 121 && BOOST_PP_ITERATION_FINISH_1 >= 121 +# define BOOST_PP_ITERATION_1 121 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 122 && BOOST_PP_ITERATION_FINISH_1 >= 122 +# define BOOST_PP_ITERATION_1 122 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 123 && BOOST_PP_ITERATION_FINISH_1 >= 123 +# define BOOST_PP_ITERATION_1 123 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 124 && BOOST_PP_ITERATION_FINISH_1 >= 124 +# define BOOST_PP_ITERATION_1 124 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 125 && BOOST_PP_ITERATION_FINISH_1 >= 125 +# define BOOST_PP_ITERATION_1 125 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 126 && BOOST_PP_ITERATION_FINISH_1 >= 126 +# define BOOST_PP_ITERATION_1 126 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 127 && BOOST_PP_ITERATION_FINISH_1 >= 127 +# define BOOST_PP_ITERATION_1 127 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 128 && BOOST_PP_ITERATION_FINISH_1 >= 128 +# define BOOST_PP_ITERATION_1 128 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 129 && BOOST_PP_ITERATION_FINISH_1 >= 129 +# define BOOST_PP_ITERATION_1 129 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 130 && BOOST_PP_ITERATION_FINISH_1 >= 130 +# define BOOST_PP_ITERATION_1 130 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 131 && BOOST_PP_ITERATION_FINISH_1 >= 131 +# define BOOST_PP_ITERATION_1 131 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 132 && BOOST_PP_ITERATION_FINISH_1 >= 132 +# define BOOST_PP_ITERATION_1 132 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 133 && BOOST_PP_ITERATION_FINISH_1 >= 133 +# define BOOST_PP_ITERATION_1 133 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 134 && BOOST_PP_ITERATION_FINISH_1 >= 134 +# define BOOST_PP_ITERATION_1 134 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 135 && BOOST_PP_ITERATION_FINISH_1 >= 135 +# define BOOST_PP_ITERATION_1 135 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 136 && BOOST_PP_ITERATION_FINISH_1 >= 136 +# define BOOST_PP_ITERATION_1 136 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 137 && BOOST_PP_ITERATION_FINISH_1 >= 137 +# define BOOST_PP_ITERATION_1 137 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 138 && BOOST_PP_ITERATION_FINISH_1 >= 138 +# define BOOST_PP_ITERATION_1 138 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 139 && BOOST_PP_ITERATION_FINISH_1 >= 139 +# define BOOST_PP_ITERATION_1 139 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 140 && BOOST_PP_ITERATION_FINISH_1 >= 140 +# define BOOST_PP_ITERATION_1 140 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 141 && BOOST_PP_ITERATION_FINISH_1 >= 141 +# define BOOST_PP_ITERATION_1 141 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 142 && BOOST_PP_ITERATION_FINISH_1 >= 142 +# define BOOST_PP_ITERATION_1 142 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 143 && BOOST_PP_ITERATION_FINISH_1 >= 143 +# define BOOST_PP_ITERATION_1 143 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 144 && BOOST_PP_ITERATION_FINISH_1 >= 144 +# define BOOST_PP_ITERATION_1 144 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 145 && BOOST_PP_ITERATION_FINISH_1 >= 145 +# define BOOST_PP_ITERATION_1 145 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 146 && BOOST_PP_ITERATION_FINISH_1 >= 146 +# define BOOST_PP_ITERATION_1 146 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 147 && BOOST_PP_ITERATION_FINISH_1 >= 147 +# define BOOST_PP_ITERATION_1 147 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 148 && BOOST_PP_ITERATION_FINISH_1 >= 148 +# define BOOST_PP_ITERATION_1 148 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 149 && BOOST_PP_ITERATION_FINISH_1 >= 149 +# define BOOST_PP_ITERATION_1 149 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 150 && BOOST_PP_ITERATION_FINISH_1 >= 150 +# define BOOST_PP_ITERATION_1 150 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 151 && BOOST_PP_ITERATION_FINISH_1 >= 151 +# define BOOST_PP_ITERATION_1 151 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 152 && BOOST_PP_ITERATION_FINISH_1 >= 152 +# define BOOST_PP_ITERATION_1 152 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 153 && BOOST_PP_ITERATION_FINISH_1 >= 153 +# define BOOST_PP_ITERATION_1 153 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 154 && BOOST_PP_ITERATION_FINISH_1 >= 154 +# define BOOST_PP_ITERATION_1 154 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 155 && BOOST_PP_ITERATION_FINISH_1 >= 155 +# define BOOST_PP_ITERATION_1 155 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 156 && BOOST_PP_ITERATION_FINISH_1 >= 156 +# define BOOST_PP_ITERATION_1 156 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 157 && BOOST_PP_ITERATION_FINISH_1 >= 157 +# define BOOST_PP_ITERATION_1 157 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 158 && BOOST_PP_ITERATION_FINISH_1 >= 158 +# define BOOST_PP_ITERATION_1 158 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 159 && BOOST_PP_ITERATION_FINISH_1 >= 159 +# define BOOST_PP_ITERATION_1 159 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 160 && BOOST_PP_ITERATION_FINISH_1 >= 160 +# define BOOST_PP_ITERATION_1 160 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 161 && BOOST_PP_ITERATION_FINISH_1 >= 161 +# define BOOST_PP_ITERATION_1 161 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 162 && BOOST_PP_ITERATION_FINISH_1 >= 162 +# define BOOST_PP_ITERATION_1 162 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 163 && BOOST_PP_ITERATION_FINISH_1 >= 163 +# define BOOST_PP_ITERATION_1 163 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 164 && BOOST_PP_ITERATION_FINISH_1 >= 164 +# define BOOST_PP_ITERATION_1 164 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 165 && BOOST_PP_ITERATION_FINISH_1 >= 165 +# define BOOST_PP_ITERATION_1 165 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 166 && BOOST_PP_ITERATION_FINISH_1 >= 166 +# define BOOST_PP_ITERATION_1 166 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 167 && BOOST_PP_ITERATION_FINISH_1 >= 167 +# define BOOST_PP_ITERATION_1 167 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 168 && BOOST_PP_ITERATION_FINISH_1 >= 168 +# define BOOST_PP_ITERATION_1 168 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 169 && BOOST_PP_ITERATION_FINISH_1 >= 169 +# define BOOST_PP_ITERATION_1 169 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 170 && BOOST_PP_ITERATION_FINISH_1 >= 170 +# define BOOST_PP_ITERATION_1 170 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 171 && BOOST_PP_ITERATION_FINISH_1 >= 171 +# define BOOST_PP_ITERATION_1 171 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 172 && BOOST_PP_ITERATION_FINISH_1 >= 172 +# define BOOST_PP_ITERATION_1 172 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 173 && BOOST_PP_ITERATION_FINISH_1 >= 173 +# define BOOST_PP_ITERATION_1 173 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 174 && BOOST_PP_ITERATION_FINISH_1 >= 174 +# define BOOST_PP_ITERATION_1 174 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 175 && BOOST_PP_ITERATION_FINISH_1 >= 175 +# define BOOST_PP_ITERATION_1 175 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 176 && BOOST_PP_ITERATION_FINISH_1 >= 176 +# define BOOST_PP_ITERATION_1 176 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 177 && BOOST_PP_ITERATION_FINISH_1 >= 177 +# define BOOST_PP_ITERATION_1 177 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 178 && BOOST_PP_ITERATION_FINISH_1 >= 178 +# define BOOST_PP_ITERATION_1 178 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 179 && BOOST_PP_ITERATION_FINISH_1 >= 179 +# define BOOST_PP_ITERATION_1 179 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 180 && BOOST_PP_ITERATION_FINISH_1 >= 180 +# define BOOST_PP_ITERATION_1 180 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 181 && BOOST_PP_ITERATION_FINISH_1 >= 181 +# define BOOST_PP_ITERATION_1 181 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 182 && BOOST_PP_ITERATION_FINISH_1 >= 182 +# define BOOST_PP_ITERATION_1 182 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 183 && BOOST_PP_ITERATION_FINISH_1 >= 183 +# define BOOST_PP_ITERATION_1 183 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 184 && BOOST_PP_ITERATION_FINISH_1 >= 184 +# define BOOST_PP_ITERATION_1 184 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 185 && BOOST_PP_ITERATION_FINISH_1 >= 185 +# define BOOST_PP_ITERATION_1 185 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 186 && BOOST_PP_ITERATION_FINISH_1 >= 186 +# define BOOST_PP_ITERATION_1 186 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 187 && BOOST_PP_ITERATION_FINISH_1 >= 187 +# define BOOST_PP_ITERATION_1 187 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 188 && BOOST_PP_ITERATION_FINISH_1 >= 188 +# define BOOST_PP_ITERATION_1 188 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 189 && BOOST_PP_ITERATION_FINISH_1 >= 189 +# define BOOST_PP_ITERATION_1 189 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 190 && BOOST_PP_ITERATION_FINISH_1 >= 190 +# define BOOST_PP_ITERATION_1 190 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 191 && BOOST_PP_ITERATION_FINISH_1 >= 191 +# define BOOST_PP_ITERATION_1 191 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 192 && BOOST_PP_ITERATION_FINISH_1 >= 192 +# define BOOST_PP_ITERATION_1 192 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 193 && BOOST_PP_ITERATION_FINISH_1 >= 193 +# define BOOST_PP_ITERATION_1 193 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 194 && BOOST_PP_ITERATION_FINISH_1 >= 194 +# define BOOST_PP_ITERATION_1 194 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 195 && BOOST_PP_ITERATION_FINISH_1 >= 195 +# define BOOST_PP_ITERATION_1 195 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 196 && BOOST_PP_ITERATION_FINISH_1 >= 196 +# define BOOST_PP_ITERATION_1 196 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 197 && BOOST_PP_ITERATION_FINISH_1 >= 197 +# define BOOST_PP_ITERATION_1 197 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 198 && BOOST_PP_ITERATION_FINISH_1 >= 198 +# define BOOST_PP_ITERATION_1 198 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 199 && BOOST_PP_ITERATION_FINISH_1 >= 199 +# define BOOST_PP_ITERATION_1 199 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 200 && BOOST_PP_ITERATION_FINISH_1 >= 200 +# define BOOST_PP_ITERATION_1 200 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 201 && BOOST_PP_ITERATION_FINISH_1 >= 201 +# define BOOST_PP_ITERATION_1 201 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 202 && BOOST_PP_ITERATION_FINISH_1 >= 202 +# define BOOST_PP_ITERATION_1 202 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 203 && BOOST_PP_ITERATION_FINISH_1 >= 203 +# define BOOST_PP_ITERATION_1 203 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 204 && BOOST_PP_ITERATION_FINISH_1 >= 204 +# define BOOST_PP_ITERATION_1 204 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 205 && BOOST_PP_ITERATION_FINISH_1 >= 205 +# define BOOST_PP_ITERATION_1 205 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 206 && BOOST_PP_ITERATION_FINISH_1 >= 206 +# define BOOST_PP_ITERATION_1 206 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 207 && BOOST_PP_ITERATION_FINISH_1 >= 207 +# define BOOST_PP_ITERATION_1 207 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 208 && BOOST_PP_ITERATION_FINISH_1 >= 208 +# define BOOST_PP_ITERATION_1 208 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 209 && BOOST_PP_ITERATION_FINISH_1 >= 209 +# define BOOST_PP_ITERATION_1 209 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 210 && BOOST_PP_ITERATION_FINISH_1 >= 210 +# define BOOST_PP_ITERATION_1 210 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 211 && BOOST_PP_ITERATION_FINISH_1 >= 211 +# define BOOST_PP_ITERATION_1 211 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 212 && BOOST_PP_ITERATION_FINISH_1 >= 212 +# define BOOST_PP_ITERATION_1 212 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 213 && BOOST_PP_ITERATION_FINISH_1 >= 213 +# define BOOST_PP_ITERATION_1 213 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 214 && BOOST_PP_ITERATION_FINISH_1 >= 214 +# define BOOST_PP_ITERATION_1 214 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 215 && BOOST_PP_ITERATION_FINISH_1 >= 215 +# define BOOST_PP_ITERATION_1 215 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 216 && BOOST_PP_ITERATION_FINISH_1 >= 216 +# define BOOST_PP_ITERATION_1 216 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 217 && BOOST_PP_ITERATION_FINISH_1 >= 217 +# define BOOST_PP_ITERATION_1 217 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 218 && BOOST_PP_ITERATION_FINISH_1 >= 218 +# define BOOST_PP_ITERATION_1 218 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 219 && BOOST_PP_ITERATION_FINISH_1 >= 219 +# define BOOST_PP_ITERATION_1 219 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 220 && BOOST_PP_ITERATION_FINISH_1 >= 220 +# define BOOST_PP_ITERATION_1 220 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 221 && BOOST_PP_ITERATION_FINISH_1 >= 221 +# define BOOST_PP_ITERATION_1 221 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 222 && BOOST_PP_ITERATION_FINISH_1 >= 222 +# define BOOST_PP_ITERATION_1 222 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 223 && BOOST_PP_ITERATION_FINISH_1 >= 223 +# define BOOST_PP_ITERATION_1 223 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 224 && BOOST_PP_ITERATION_FINISH_1 >= 224 +# define BOOST_PP_ITERATION_1 224 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 225 && BOOST_PP_ITERATION_FINISH_1 >= 225 +# define BOOST_PP_ITERATION_1 225 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 226 && BOOST_PP_ITERATION_FINISH_1 >= 226 +# define BOOST_PP_ITERATION_1 226 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 227 && BOOST_PP_ITERATION_FINISH_1 >= 227 +# define BOOST_PP_ITERATION_1 227 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 228 && BOOST_PP_ITERATION_FINISH_1 >= 228 +# define BOOST_PP_ITERATION_1 228 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 229 && BOOST_PP_ITERATION_FINISH_1 >= 229 +# define BOOST_PP_ITERATION_1 229 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 230 && BOOST_PP_ITERATION_FINISH_1 >= 230 +# define BOOST_PP_ITERATION_1 230 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 231 && BOOST_PP_ITERATION_FINISH_1 >= 231 +# define BOOST_PP_ITERATION_1 231 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 232 && BOOST_PP_ITERATION_FINISH_1 >= 232 +# define BOOST_PP_ITERATION_1 232 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 233 && BOOST_PP_ITERATION_FINISH_1 >= 233 +# define BOOST_PP_ITERATION_1 233 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 234 && BOOST_PP_ITERATION_FINISH_1 >= 234 +# define BOOST_PP_ITERATION_1 234 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 235 && BOOST_PP_ITERATION_FINISH_1 >= 235 +# define BOOST_PP_ITERATION_1 235 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 236 && BOOST_PP_ITERATION_FINISH_1 >= 236 +# define BOOST_PP_ITERATION_1 236 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 237 && BOOST_PP_ITERATION_FINISH_1 >= 237 +# define BOOST_PP_ITERATION_1 237 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 238 && BOOST_PP_ITERATION_FINISH_1 >= 238 +# define BOOST_PP_ITERATION_1 238 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 239 && BOOST_PP_ITERATION_FINISH_1 >= 239 +# define BOOST_PP_ITERATION_1 239 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 240 && BOOST_PP_ITERATION_FINISH_1 >= 240 +# define BOOST_PP_ITERATION_1 240 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 241 && BOOST_PP_ITERATION_FINISH_1 >= 241 +# define BOOST_PP_ITERATION_1 241 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 242 && BOOST_PP_ITERATION_FINISH_1 >= 242 +# define BOOST_PP_ITERATION_1 242 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 243 && BOOST_PP_ITERATION_FINISH_1 >= 243 +# define BOOST_PP_ITERATION_1 243 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 244 && BOOST_PP_ITERATION_FINISH_1 >= 244 +# define BOOST_PP_ITERATION_1 244 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 245 && BOOST_PP_ITERATION_FINISH_1 >= 245 +# define BOOST_PP_ITERATION_1 245 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 246 && BOOST_PP_ITERATION_FINISH_1 >= 246 +# define BOOST_PP_ITERATION_1 246 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 247 && BOOST_PP_ITERATION_FINISH_1 >= 247 +# define BOOST_PP_ITERATION_1 247 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 248 && BOOST_PP_ITERATION_FINISH_1 >= 248 +# define BOOST_PP_ITERATION_1 248 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 249 && BOOST_PP_ITERATION_FINISH_1 >= 249 +# define BOOST_PP_ITERATION_1 249 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 250 && BOOST_PP_ITERATION_FINISH_1 >= 250 +# define BOOST_PP_ITERATION_1 250 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 251 && BOOST_PP_ITERATION_FINISH_1 >= 251 +# define BOOST_PP_ITERATION_1 251 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 252 && BOOST_PP_ITERATION_FINISH_1 >= 252 +# define BOOST_PP_ITERATION_1 252 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 253 && BOOST_PP_ITERATION_FINISH_1 >= 253 +# define BOOST_PP_ITERATION_1 253 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 254 && BOOST_PP_ITERATION_FINISH_1 >= 254 +# define BOOST_PP_ITERATION_1 254 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 255 && BOOST_PP_ITERATION_FINISH_1 >= 255 +# define BOOST_PP_ITERATION_1 255 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# if BOOST_PP_ITERATION_START_1 <= 256 && BOOST_PP_ITERATION_FINISH_1 >= 256 +# define BOOST_PP_ITERATION_1 256 +# include BOOST_PP_FILENAME_1 +# undef BOOST_PP_ITERATION_1 +# endif +# endif +# +# undef BOOST_PP_IS_ITERATING +# +# undef BOOST_PP_ITERATION_DEPTH +# define BOOST_PP_ITERATION_DEPTH() 0 +# +# undef BOOST_PP_ITERATION_START_1 +# undef BOOST_PP_ITERATION_FINISH_1 +# undef BOOST_PP_FILENAME_1 +# +# undef BOOST_PP_ITERATION_FLAGS_1 +# undef BOOST_PP_ITERATION_PARAMS_1 diff --git a/realsense-file/3rd_party/boost/boost/preprocessor/iteration/iterate.hpp b/realsense-file/3rd_party/boost/boost/preprocessor/iteration/iterate.hpp new file mode 100644 index 0000000000..7b57655af6 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/preprocessor/iteration/iterate.hpp @@ -0,0 +1,82 @@ +# /* ************************************************************************** +# * * +# * (C) Copyright Paul Mensonides 2002. +# * Distributed under the Boost Software License, Version 1.0. (See +# * accompanying file LICENSE_1_0.txt or copy at +# * http://www.boost.org/LICENSE_1_0.txt) +# * * +# ************************************************************************** */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_ITERATION_ITERATE_HPP +# define BOOST_PREPROCESSOR_ITERATION_ITERATE_HPP +# +# include +# include +# include +# include +# include +# include +# include +# +# /* BOOST_PP_ITERATION_DEPTH */ +# +# define BOOST_PP_ITERATION_DEPTH() 0 +# +# /* BOOST_PP_ITERATION */ +# +# define BOOST_PP_ITERATION() BOOST_PP_CAT(BOOST_PP_ITERATION_, BOOST_PP_ITERATION_DEPTH()) +# +# /* BOOST_PP_ITERATION_START && BOOST_PP_ITERATION_FINISH */ +# +# define BOOST_PP_ITERATION_START() BOOST_PP_CAT(BOOST_PP_ITERATION_START_, BOOST_PP_ITERATION_DEPTH()) +# define BOOST_PP_ITERATION_FINISH() BOOST_PP_CAT(BOOST_PP_ITERATION_FINISH_, BOOST_PP_ITERATION_DEPTH()) +# +# /* BOOST_PP_ITERATION_FLAGS */ +# +# define BOOST_PP_ITERATION_FLAGS() (BOOST_PP_CAT(BOOST_PP_ITERATION_FLAGS_, BOOST_PP_ITERATION_DEPTH())()) +# +# /* BOOST_PP_FRAME_ITERATION */ +# +# define BOOST_PP_FRAME_ITERATION(i) BOOST_PP_CAT(BOOST_PP_ITERATION_, i) +# +# /* BOOST_PP_FRAME_START && BOOST_PP_FRAME_FINISH */ +# +# define BOOST_PP_FRAME_START(i) BOOST_PP_CAT(BOOST_PP_ITERATION_START_, i) +# define BOOST_PP_FRAME_FINISH(i) BOOST_PP_CAT(BOOST_PP_ITERATION_FINISH_, i) +# +# /* BOOST_PP_FRAME_FLAGS */ +# +# define BOOST_PP_FRAME_FLAGS(i) (BOOST_PP_CAT(BOOST_PP_ITERATION_FLAGS_, i)()) +# +# /* BOOST_PP_RELATIVE_ITERATION */ +# +# define BOOST_PP_RELATIVE_ITERATION(i) BOOST_PP_CAT(BOOST_PP_RELATIVE_, i)(BOOST_PP_ITERATION_) +# +# define BOOST_PP_RELATIVE_0(m) BOOST_PP_CAT(m, BOOST_PP_ITERATION_DEPTH()) +# define BOOST_PP_RELATIVE_1(m) BOOST_PP_CAT(m, BOOST_PP_DEC(BOOST_PP_ITERATION_DEPTH())) +# define BOOST_PP_RELATIVE_2(m) BOOST_PP_CAT(m, BOOST_PP_DEC(BOOST_PP_DEC(BOOST_PP_ITERATION_DEPTH()))) +# define BOOST_PP_RELATIVE_3(m) BOOST_PP_CAT(m, BOOST_PP_DEC(BOOST_PP_DEC(BOOST_PP_DEC(BOOST_PP_ITERATION_DEPTH())))) +# define BOOST_PP_RELATIVE_4(m) BOOST_PP_CAT(m, BOOST_PP_DEC(BOOST_PP_DEC(BOOST_PP_DEC(BOOST_PP_DEC(BOOST_PP_ITERATION_DEPTH()))))) +# +# /* BOOST_PP_RELATIVE_START && BOOST_PP_RELATIVE_FINISH */ +# +# define BOOST_PP_RELATIVE_START(i) BOOST_PP_CAT(BOOST_PP_RELATIVE_, i)(BOOST_PP_ITERATION_START_) +# define BOOST_PP_RELATIVE_FINISH(i) BOOST_PP_CAT(BOOST_PP_RELATIVE_, i)(BOOST_PP_ITERATION_FINISH_) +# +# /* BOOST_PP_RELATIVE_FLAGS */ +# +# define BOOST_PP_RELATIVE_FLAGS(i) (BOOST_PP_CAT(BOOST_PP_RELATIVE_, i)(BOOST_PP_ITERATION_FLAGS_)()) +# +# /* BOOST_PP_ITERATE */ +# +# define BOOST_PP_ITERATE() BOOST_PP_CAT(BOOST_PP_ITERATE_, BOOST_PP_INC(BOOST_PP_ITERATION_DEPTH())) +# +# define BOOST_PP_ITERATE_1 +# define BOOST_PP_ITERATE_2 +# define BOOST_PP_ITERATE_3 +# define BOOST_PP_ITERATE_4 +# define BOOST_PP_ITERATE_5 +# +# endif diff --git a/realsense-file/3rd_party/boost/boost/preprocessor/list/adt.hpp b/realsense-file/3rd_party/boost/boost/preprocessor/list/adt.hpp new file mode 100644 index 0000000000..0743af6fec --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/preprocessor/list/adt.hpp @@ -0,0 +1,73 @@ +# /* Copyright (C) 2001 +# * Housemarque Oy +# * http://www.housemarque.com +# * +# * Distributed under the Boost Software License, Version 1.0. (See +# * accompanying file LICENSE_1_0.txt or copy at +# * http://www.boost.org/LICENSE_1_0.txt) +# * +# * See http://www.boost.org for most recent version. +# */ +# +# /* Revised by Paul Mensonides (2002) */ +# +# ifndef BOOST_PREPROCESSOR_LIST_ADT_HPP +# define BOOST_PREPROCESSOR_LIST_ADT_HPP +# +# include +# include +# include +# include +# +# /* BOOST_PP_LIST_CONS */ +# +# define BOOST_PP_LIST_CONS(head, tail) (head, tail) +# +# /* BOOST_PP_LIST_NIL */ +# +# define BOOST_PP_LIST_NIL BOOST_PP_NIL +# +# /* BOOST_PP_LIST_FIRST */ +# +# define BOOST_PP_LIST_FIRST(list) BOOST_PP_LIST_FIRST_D(list) +# +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() +# define BOOST_PP_LIST_FIRST_D(list) BOOST_PP_LIST_FIRST_I list +# else +# define BOOST_PP_LIST_FIRST_D(list) BOOST_PP_LIST_FIRST_I ## list +# endif +# +# define BOOST_PP_LIST_FIRST_I(head, tail) head +# +# /* BOOST_PP_LIST_REST */ +# +# define BOOST_PP_LIST_REST(list) BOOST_PP_LIST_REST_D(list) +# +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() +# define BOOST_PP_LIST_REST_D(list) BOOST_PP_LIST_REST_I list +# else +# define BOOST_PP_LIST_REST_D(list) BOOST_PP_LIST_REST_I ## list +# endif +# +# define BOOST_PP_LIST_REST_I(head, tail) tail +# +# /* BOOST_PP_LIST_IS_CONS */ +# +# if BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_BCC() +# define BOOST_PP_LIST_IS_CONS(list) BOOST_PP_LIST_IS_CONS_D(list) +# define BOOST_PP_LIST_IS_CONS_D(list) BOOST_PP_LIST_IS_CONS_ ## list +# define BOOST_PP_LIST_IS_CONS_(head, tail) 1 +# define BOOST_PP_LIST_IS_CONS_BOOST_PP_NIL 0 +# else +# define BOOST_PP_LIST_IS_CONS(list) BOOST_PP_IS_BINARY(list) +# endif +# +# /* BOOST_PP_LIST_IS_NIL */ +# +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_BCC() +# define BOOST_PP_LIST_IS_NIL(list) BOOST_PP_COMPL(BOOST_PP_IS_BINARY(list)) +# else +# define BOOST_PP_LIST_IS_NIL(list) BOOST_PP_COMPL(BOOST_PP_LIST_IS_CONS(list)) +# endif +# +# endif diff --git a/realsense-file/3rd_party/boost/boost/preprocessor/list/append.hpp b/realsense-file/3rd_party/boost/boost/preprocessor/list/append.hpp new file mode 100644 index 0000000000..d26e1afb2f --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/preprocessor/list/append.hpp @@ -0,0 +1,40 @@ +# /* Copyright (C) 2001 +# * Housemarque Oy +# * http://www.housemarque.com +# * +# * 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) +# */ +# +# /* Revised by Paul Mensonides (2002) */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_LIST_APPEND_HPP +# define BOOST_PREPROCESSOR_LIST_APPEND_HPP +# +# include +# include +# +# /* BOOST_PP_LIST_APPEND */ +# +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() +# define BOOST_PP_LIST_APPEND(a, b) BOOST_PP_LIST_FOLD_RIGHT(BOOST_PP_LIST_APPEND_O, b, a) +# else +# define BOOST_PP_LIST_APPEND(a, b) BOOST_PP_LIST_APPEND_I(a, b) +# define BOOST_PP_LIST_APPEND_I(a, b) BOOST_PP_LIST_FOLD_RIGHT(BOOST_PP_LIST_APPEND_O, b, a) +# endif +# +# define BOOST_PP_LIST_APPEND_O(d, s, x) (x, s) +# +# /* BOOST_PP_LIST_APPEND_D */ +# +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() +# define BOOST_PP_LIST_APPEND_D(d, a, b) BOOST_PP_LIST_FOLD_RIGHT_ ## d(BOOST_PP_LIST_APPEND_O, b, a) +# else +# define BOOST_PP_LIST_APPEND_D(d, a, b) BOOST_PP_LIST_APPEND_D_I(d, a, b) +# define BOOST_PP_LIST_APPEND_D_I(d, a, b) BOOST_PP_LIST_FOLD_RIGHT_ ## d(BOOST_PP_LIST_APPEND_O, b, a) +# endif +# +# endif diff --git a/realsense-file/3rd_party/boost/boost/preprocessor/list/detail/fold_left.hpp b/realsense-file/3rd_party/boost/boost/preprocessor/list/detail/fold_left.hpp new file mode 100644 index 0000000000..ed4f622293 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/preprocessor/list/detail/fold_left.hpp @@ -0,0 +1,279 @@ +# /* Copyright (C) 2001 +# * Housemarque Oy +# * http://www.housemarque.com +# * +# * 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) +# */ +# +# /* Revised by Paul Mensonides (2002) */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_LIST_DETAIL_FOLD_LEFT_HPP +# define BOOST_PREPROCESSOR_LIST_DETAIL_FOLD_LEFT_HPP +# +# include +# include +# include +# include +# +# define BOOST_PP_LIST_FOLD_LEFT_1(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_2, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(2, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_2(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_3, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(3, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_3(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_4, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(4, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_4(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_5, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(5, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_5(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_6, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(6, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_6(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_7, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(7, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_7(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_8, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(8, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_8(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_9, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(9, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_9(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_10, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(10, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_10(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_11, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(11, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_11(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_12, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(12, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_12(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_13, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(13, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_13(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_14, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(14, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_14(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_15, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(15, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_15(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_16, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(16, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_16(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_17, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(17, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_17(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_18, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(18, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_18(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_19, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(19, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_19(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_20, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(20, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_20(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_21, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(21, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_21(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_22, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(22, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_22(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_23, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(23, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_23(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_24, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(24, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_24(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_25, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(25, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_25(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_26, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(26, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_26(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_27, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(27, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_27(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_28, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(28, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_28(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_29, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(29, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_29(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_30, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(30, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_30(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_31, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(31, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_31(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_32, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(32, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_32(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_33, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(33, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_33(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_34, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(34, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_34(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_35, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(35, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_35(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_36, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(36, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_36(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_37, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(37, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_37(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_38, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(38, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_38(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_39, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(39, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_39(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_40, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(40, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_40(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_41, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(41, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_41(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_42, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(42, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_42(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_43, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(43, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_43(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_44, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(44, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_44(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_45, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(45, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_45(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_46, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(46, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_46(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_47, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(47, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_47(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_48, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(48, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_48(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_49, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(49, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_49(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_50, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(50, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_50(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_51, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(51, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_51(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_52, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(52, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_52(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_53, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(53, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_53(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_54, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(54, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_54(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_55, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(55, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_55(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_56, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(56, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_56(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_57, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(57, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_57(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_58, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(58, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_58(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_59, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(59, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_59(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_60, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(60, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_60(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_61, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(61, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_61(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_62, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(62, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_62(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_63, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(63, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_63(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_64, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(64, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_64(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_65, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(65, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_65(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_66, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(66, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_66(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_67, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(67, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_67(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_68, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(68, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_68(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_69, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(69, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_69(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_70, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(70, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_70(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_71, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(71, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_71(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_72, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(72, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_72(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_73, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(73, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_73(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_74, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(74, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_74(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_75, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(75, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_75(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_76, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(76, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_76(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_77, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(77, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_77(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_78, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(78, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_78(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_79, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(79, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_79(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_80, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(80, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_80(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_81, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(81, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_81(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_82, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(82, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_82(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_83, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(83, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_83(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_84, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(84, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_84(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_85, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(85, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_85(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_86, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(86, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_86(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_87, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(87, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_87(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_88, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(88, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_88(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_89, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(89, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_89(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_90, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(90, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_90(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_91, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(91, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_91(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_92, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(92, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_92(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_93, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(93, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_93(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_94, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(94, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_94(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_95, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(95, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_95(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_96, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(96, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_96(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_97, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(97, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_97(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_98, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(98, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_98(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_99, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(99, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_99(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_100, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(100, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_100(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_101, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(101, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_101(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_102, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(102, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_102(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_103, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(103, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_103(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_104, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(104, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_104(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_105, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(105, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_105(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_106, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(106, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_106(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_107, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(107, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_107(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_108, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(108, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_108(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_109, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(109, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_109(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_110, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(110, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_110(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_111, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(111, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_111(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_112, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(112, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_112(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_113, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(113, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_113(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_114, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(114, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_114(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_115, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(115, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_115(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_116, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(116, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_116(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_117, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(117, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_117(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_118, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(118, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_118(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_119, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(119, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_119(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_120, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(120, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_120(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_121, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(121, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_121(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_122, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(122, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_122(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_123, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(123, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_123(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_124, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(124, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_124(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_125, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(125, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_125(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_126, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(126, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_126(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_127, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(127, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_127(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_128, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(128, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_128(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_129, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(129, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_129(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_130, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(130, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_130(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_131, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(131, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_131(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_132, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(132, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_132(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_133, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(133, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_133(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_134, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(134, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_134(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_135, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(135, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_135(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_136, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(136, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_136(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_137, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(137, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_137(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_138, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(138, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_138(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_139, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(139, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_139(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_140, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(140, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_140(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_141, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(141, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_141(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_142, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(142, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_142(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_143, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(143, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_143(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_144, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(144, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_144(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_145, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(145, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_145(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_146, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(146, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_146(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_147, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(147, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_147(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_148, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(148, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_148(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_149, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(149, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_149(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_150, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(150, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_150(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_151, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(151, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_151(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_152, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(152, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_152(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_153, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(153, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_153(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_154, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(154, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_154(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_155, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(155, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_155(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_156, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(156, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_156(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_157, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(157, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_157(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_158, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(158, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_158(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_159, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(159, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_159(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_160, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(160, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_160(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_161, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(161, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_161(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_162, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(162, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_162(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_163, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(163, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_163(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_164, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(164, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_164(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_165, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(165, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_165(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_166, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(166, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_166(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_167, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(167, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_167(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_168, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(168, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_168(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_169, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(169, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_169(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_170, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(170, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_170(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_171, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(171, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_171(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_172, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(172, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_172(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_173, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(173, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_173(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_174, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(174, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_174(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_175, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(175, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_175(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_176, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(176, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_176(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_177, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(177, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_177(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_178, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(178, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_178(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_179, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(179, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_179(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_180, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(180, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_180(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_181, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(181, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_181(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_182, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(182, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_182(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_183, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(183, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_183(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_184, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(184, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_184(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_185, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(185, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_185(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_186, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(186, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_186(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_187, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(187, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_187(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_188, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(188, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_188(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_189, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(189, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_189(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_190, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(190, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_190(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_191, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(191, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_191(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_192, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(192, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_192(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_193, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(193, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_193(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_194, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(194, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_194(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_195, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(195, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_195(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_196, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(196, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_196(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_197, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(197, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_197(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_198, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(198, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_198(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_199, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(199, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_199(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_200, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(200, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_200(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_201, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(201, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_201(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_202, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(202, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_202(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_203, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(203, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_203(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_204, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(204, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_204(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_205, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(205, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_205(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_206, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(206, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_206(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_207, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(207, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_207(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_208, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(208, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_208(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_209, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(209, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_209(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_210, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(210, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_210(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_211, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(211, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_211(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_212, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(212, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_212(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_213, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(213, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_213(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_214, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(214, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_214(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_215, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(215, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_215(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_216, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(216, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_216(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_217, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(217, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_217(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_218, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(218, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_218(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_219, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(219, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_219(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_220, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(220, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_220(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_221, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(221, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_221(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_222, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(222, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_222(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_223, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(223, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_223(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_224, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(224, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_224(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_225, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(225, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_225(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_226, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(226, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_226(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_227, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(227, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_227(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_228, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(228, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_228(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_229, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(229, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_229(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_230, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(230, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_230(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_231, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(231, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_231(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_232, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(232, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_232(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_233, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(233, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_233(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_234, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(234, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_234(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_235, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(235, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_235(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_236, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(236, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_236(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_237, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(237, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_237(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_238, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(238, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_238(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_239, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(239, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_239(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_240, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(240, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_240(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_241, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(241, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_241(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_242, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(242, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_242(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_243, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(243, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_243(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_244, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(244, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_244(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_245, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(245, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_245(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_246, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(246, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_246(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_247, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(247, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_247(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_248, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(248, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_248(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_249, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(249, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_249(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_250, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(250, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_250(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_251, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(251, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_251(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_252, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(252, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_252(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_253, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(253, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_253(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_254, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(254, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_254(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_255, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(255, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_255(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_256, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(256, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# define BOOST_PP_LIST_FOLD_LEFT_256(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_257, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(257, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) +# +# endif diff --git a/realsense-file/3rd_party/boost/boost/preprocessor/list/detail/fold_right.hpp b/realsense-file/3rd_party/boost/boost/preprocessor/list/detail/fold_right.hpp new file mode 100644 index 0000000000..feca39b243 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/preprocessor/list/detail/fold_right.hpp @@ -0,0 +1,277 @@ +# /* Copyright (C) 2001 +# * Housemarque Oy +# * http://www.housemarque.com +# * +# * 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) +# */ +# +# /* Revised by Paul Mensonides (2002) */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_LIST_DETAIL_FOLD_RIGHT_HPP +# define BOOST_PREPROCESSOR_LIST_DETAIL_FOLD_RIGHT_HPP +# +# include +# include +# +# define BOOST_PP_LIST_FOLD_RIGHT_1(o, s, l) BOOST_PP_LIST_FOLD_LEFT_1(o, s, BOOST_PP_LIST_REVERSE_D(1, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_2(o, s, l) BOOST_PP_LIST_FOLD_LEFT_2(o, s, BOOST_PP_LIST_REVERSE_D(2, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_3(o, s, l) BOOST_PP_LIST_FOLD_LEFT_3(o, s, BOOST_PP_LIST_REVERSE_D(3, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_4(o, s, l) BOOST_PP_LIST_FOLD_LEFT_4(o, s, BOOST_PP_LIST_REVERSE_D(4, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_5(o, s, l) BOOST_PP_LIST_FOLD_LEFT_5(o, s, BOOST_PP_LIST_REVERSE_D(5, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_6(o, s, l) BOOST_PP_LIST_FOLD_LEFT_6(o, s, BOOST_PP_LIST_REVERSE_D(6, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_7(o, s, l) BOOST_PP_LIST_FOLD_LEFT_7(o, s, BOOST_PP_LIST_REVERSE_D(7, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_8(o, s, l) BOOST_PP_LIST_FOLD_LEFT_8(o, s, BOOST_PP_LIST_REVERSE_D(8, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_9(o, s, l) BOOST_PP_LIST_FOLD_LEFT_9(o, s, BOOST_PP_LIST_REVERSE_D(9, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_10(o, s, l) BOOST_PP_LIST_FOLD_LEFT_10(o, s, BOOST_PP_LIST_REVERSE_D(10, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_11(o, s, l) BOOST_PP_LIST_FOLD_LEFT_11(o, s, BOOST_PP_LIST_REVERSE_D(11, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_12(o, s, l) BOOST_PP_LIST_FOLD_LEFT_12(o, s, BOOST_PP_LIST_REVERSE_D(12, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_13(o, s, l) BOOST_PP_LIST_FOLD_LEFT_13(o, s, BOOST_PP_LIST_REVERSE_D(13, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_14(o, s, l) BOOST_PP_LIST_FOLD_LEFT_14(o, s, BOOST_PP_LIST_REVERSE_D(14, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_15(o, s, l) BOOST_PP_LIST_FOLD_LEFT_15(o, s, BOOST_PP_LIST_REVERSE_D(15, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_16(o, s, l) BOOST_PP_LIST_FOLD_LEFT_16(o, s, BOOST_PP_LIST_REVERSE_D(16, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_17(o, s, l) BOOST_PP_LIST_FOLD_LEFT_17(o, s, BOOST_PP_LIST_REVERSE_D(17, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_18(o, s, l) BOOST_PP_LIST_FOLD_LEFT_18(o, s, BOOST_PP_LIST_REVERSE_D(18, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_19(o, s, l) BOOST_PP_LIST_FOLD_LEFT_19(o, s, BOOST_PP_LIST_REVERSE_D(19, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_20(o, s, l) BOOST_PP_LIST_FOLD_LEFT_20(o, s, BOOST_PP_LIST_REVERSE_D(20, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_21(o, s, l) BOOST_PP_LIST_FOLD_LEFT_21(o, s, BOOST_PP_LIST_REVERSE_D(21, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_22(o, s, l) BOOST_PP_LIST_FOLD_LEFT_22(o, s, BOOST_PP_LIST_REVERSE_D(22, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_23(o, s, l) BOOST_PP_LIST_FOLD_LEFT_23(o, s, BOOST_PP_LIST_REVERSE_D(23, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_24(o, s, l) BOOST_PP_LIST_FOLD_LEFT_24(o, s, BOOST_PP_LIST_REVERSE_D(24, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_25(o, s, l) BOOST_PP_LIST_FOLD_LEFT_25(o, s, BOOST_PP_LIST_REVERSE_D(25, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_26(o, s, l) BOOST_PP_LIST_FOLD_LEFT_26(o, s, BOOST_PP_LIST_REVERSE_D(26, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_27(o, s, l) BOOST_PP_LIST_FOLD_LEFT_27(o, s, BOOST_PP_LIST_REVERSE_D(27, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_28(o, s, l) BOOST_PP_LIST_FOLD_LEFT_28(o, s, BOOST_PP_LIST_REVERSE_D(28, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_29(o, s, l) BOOST_PP_LIST_FOLD_LEFT_29(o, s, BOOST_PP_LIST_REVERSE_D(29, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_30(o, s, l) BOOST_PP_LIST_FOLD_LEFT_30(o, s, BOOST_PP_LIST_REVERSE_D(30, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_31(o, s, l) BOOST_PP_LIST_FOLD_LEFT_31(o, s, BOOST_PP_LIST_REVERSE_D(31, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_32(o, s, l) BOOST_PP_LIST_FOLD_LEFT_32(o, s, BOOST_PP_LIST_REVERSE_D(32, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_33(o, s, l) BOOST_PP_LIST_FOLD_LEFT_33(o, s, BOOST_PP_LIST_REVERSE_D(33, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_34(o, s, l) BOOST_PP_LIST_FOLD_LEFT_34(o, s, BOOST_PP_LIST_REVERSE_D(34, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_35(o, s, l) BOOST_PP_LIST_FOLD_LEFT_35(o, s, BOOST_PP_LIST_REVERSE_D(35, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_36(o, s, l) BOOST_PP_LIST_FOLD_LEFT_36(o, s, BOOST_PP_LIST_REVERSE_D(36, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_37(o, s, l) BOOST_PP_LIST_FOLD_LEFT_37(o, s, BOOST_PP_LIST_REVERSE_D(37, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_38(o, s, l) BOOST_PP_LIST_FOLD_LEFT_38(o, s, BOOST_PP_LIST_REVERSE_D(38, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_39(o, s, l) BOOST_PP_LIST_FOLD_LEFT_39(o, s, BOOST_PP_LIST_REVERSE_D(39, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_40(o, s, l) BOOST_PP_LIST_FOLD_LEFT_40(o, s, BOOST_PP_LIST_REVERSE_D(40, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_41(o, s, l) BOOST_PP_LIST_FOLD_LEFT_41(o, s, BOOST_PP_LIST_REVERSE_D(41, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_42(o, s, l) BOOST_PP_LIST_FOLD_LEFT_42(o, s, BOOST_PP_LIST_REVERSE_D(42, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_43(o, s, l) BOOST_PP_LIST_FOLD_LEFT_43(o, s, BOOST_PP_LIST_REVERSE_D(43, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_44(o, s, l) BOOST_PP_LIST_FOLD_LEFT_44(o, s, BOOST_PP_LIST_REVERSE_D(44, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_45(o, s, l) BOOST_PP_LIST_FOLD_LEFT_45(o, s, BOOST_PP_LIST_REVERSE_D(45, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_46(o, s, l) BOOST_PP_LIST_FOLD_LEFT_46(o, s, BOOST_PP_LIST_REVERSE_D(46, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_47(o, s, l) BOOST_PP_LIST_FOLD_LEFT_47(o, s, BOOST_PP_LIST_REVERSE_D(47, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_48(o, s, l) BOOST_PP_LIST_FOLD_LEFT_48(o, s, BOOST_PP_LIST_REVERSE_D(48, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_49(o, s, l) BOOST_PP_LIST_FOLD_LEFT_49(o, s, BOOST_PP_LIST_REVERSE_D(49, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_50(o, s, l) BOOST_PP_LIST_FOLD_LEFT_50(o, s, BOOST_PP_LIST_REVERSE_D(50, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_51(o, s, l) BOOST_PP_LIST_FOLD_LEFT_51(o, s, BOOST_PP_LIST_REVERSE_D(51, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_52(o, s, l) BOOST_PP_LIST_FOLD_LEFT_52(o, s, BOOST_PP_LIST_REVERSE_D(52, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_53(o, s, l) BOOST_PP_LIST_FOLD_LEFT_53(o, s, BOOST_PP_LIST_REVERSE_D(53, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_54(o, s, l) BOOST_PP_LIST_FOLD_LEFT_54(o, s, BOOST_PP_LIST_REVERSE_D(54, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_55(o, s, l) BOOST_PP_LIST_FOLD_LEFT_55(o, s, BOOST_PP_LIST_REVERSE_D(55, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_56(o, s, l) BOOST_PP_LIST_FOLD_LEFT_56(o, s, BOOST_PP_LIST_REVERSE_D(56, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_57(o, s, l) BOOST_PP_LIST_FOLD_LEFT_57(o, s, BOOST_PP_LIST_REVERSE_D(57, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_58(o, s, l) BOOST_PP_LIST_FOLD_LEFT_58(o, s, BOOST_PP_LIST_REVERSE_D(58, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_59(o, s, l) BOOST_PP_LIST_FOLD_LEFT_59(o, s, BOOST_PP_LIST_REVERSE_D(59, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_60(o, s, l) BOOST_PP_LIST_FOLD_LEFT_60(o, s, BOOST_PP_LIST_REVERSE_D(60, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_61(o, s, l) BOOST_PP_LIST_FOLD_LEFT_61(o, s, BOOST_PP_LIST_REVERSE_D(61, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_62(o, s, l) BOOST_PP_LIST_FOLD_LEFT_62(o, s, BOOST_PP_LIST_REVERSE_D(62, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_63(o, s, l) BOOST_PP_LIST_FOLD_LEFT_63(o, s, BOOST_PP_LIST_REVERSE_D(63, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_64(o, s, l) BOOST_PP_LIST_FOLD_LEFT_64(o, s, BOOST_PP_LIST_REVERSE_D(64, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_65(o, s, l) BOOST_PP_LIST_FOLD_LEFT_65(o, s, BOOST_PP_LIST_REVERSE_D(65, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_66(o, s, l) BOOST_PP_LIST_FOLD_LEFT_66(o, s, BOOST_PP_LIST_REVERSE_D(66, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_67(o, s, l) BOOST_PP_LIST_FOLD_LEFT_67(o, s, BOOST_PP_LIST_REVERSE_D(67, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_68(o, s, l) BOOST_PP_LIST_FOLD_LEFT_68(o, s, BOOST_PP_LIST_REVERSE_D(68, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_69(o, s, l) BOOST_PP_LIST_FOLD_LEFT_69(o, s, BOOST_PP_LIST_REVERSE_D(69, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_70(o, s, l) BOOST_PP_LIST_FOLD_LEFT_70(o, s, BOOST_PP_LIST_REVERSE_D(70, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_71(o, s, l) BOOST_PP_LIST_FOLD_LEFT_71(o, s, BOOST_PP_LIST_REVERSE_D(71, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_72(o, s, l) BOOST_PP_LIST_FOLD_LEFT_72(o, s, BOOST_PP_LIST_REVERSE_D(72, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_73(o, s, l) BOOST_PP_LIST_FOLD_LEFT_73(o, s, BOOST_PP_LIST_REVERSE_D(73, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_74(o, s, l) BOOST_PP_LIST_FOLD_LEFT_74(o, s, BOOST_PP_LIST_REVERSE_D(74, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_75(o, s, l) BOOST_PP_LIST_FOLD_LEFT_75(o, s, BOOST_PP_LIST_REVERSE_D(75, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_76(o, s, l) BOOST_PP_LIST_FOLD_LEFT_76(o, s, BOOST_PP_LIST_REVERSE_D(76, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_77(o, s, l) BOOST_PP_LIST_FOLD_LEFT_77(o, s, BOOST_PP_LIST_REVERSE_D(77, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_78(o, s, l) BOOST_PP_LIST_FOLD_LEFT_78(o, s, BOOST_PP_LIST_REVERSE_D(78, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_79(o, s, l) BOOST_PP_LIST_FOLD_LEFT_79(o, s, BOOST_PP_LIST_REVERSE_D(79, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_80(o, s, l) BOOST_PP_LIST_FOLD_LEFT_80(o, s, BOOST_PP_LIST_REVERSE_D(80, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_81(o, s, l) BOOST_PP_LIST_FOLD_LEFT_81(o, s, BOOST_PP_LIST_REVERSE_D(81, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_82(o, s, l) BOOST_PP_LIST_FOLD_LEFT_82(o, s, BOOST_PP_LIST_REVERSE_D(82, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_83(o, s, l) BOOST_PP_LIST_FOLD_LEFT_83(o, s, BOOST_PP_LIST_REVERSE_D(83, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_84(o, s, l) BOOST_PP_LIST_FOLD_LEFT_84(o, s, BOOST_PP_LIST_REVERSE_D(84, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_85(o, s, l) BOOST_PP_LIST_FOLD_LEFT_85(o, s, BOOST_PP_LIST_REVERSE_D(85, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_86(o, s, l) BOOST_PP_LIST_FOLD_LEFT_86(o, s, BOOST_PP_LIST_REVERSE_D(86, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_87(o, s, l) BOOST_PP_LIST_FOLD_LEFT_87(o, s, BOOST_PP_LIST_REVERSE_D(87, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_88(o, s, l) BOOST_PP_LIST_FOLD_LEFT_88(o, s, BOOST_PP_LIST_REVERSE_D(88, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_89(o, s, l) BOOST_PP_LIST_FOLD_LEFT_89(o, s, BOOST_PP_LIST_REVERSE_D(89, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_90(o, s, l) BOOST_PP_LIST_FOLD_LEFT_90(o, s, BOOST_PP_LIST_REVERSE_D(90, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_91(o, s, l) BOOST_PP_LIST_FOLD_LEFT_91(o, s, BOOST_PP_LIST_REVERSE_D(91, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_92(o, s, l) BOOST_PP_LIST_FOLD_LEFT_92(o, s, BOOST_PP_LIST_REVERSE_D(92, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_93(o, s, l) BOOST_PP_LIST_FOLD_LEFT_93(o, s, BOOST_PP_LIST_REVERSE_D(93, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_94(o, s, l) BOOST_PP_LIST_FOLD_LEFT_94(o, s, BOOST_PP_LIST_REVERSE_D(94, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_95(o, s, l) BOOST_PP_LIST_FOLD_LEFT_95(o, s, BOOST_PP_LIST_REVERSE_D(95, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_96(o, s, l) BOOST_PP_LIST_FOLD_LEFT_96(o, s, BOOST_PP_LIST_REVERSE_D(96, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_97(o, s, l) BOOST_PP_LIST_FOLD_LEFT_97(o, s, BOOST_PP_LIST_REVERSE_D(97, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_98(o, s, l) BOOST_PP_LIST_FOLD_LEFT_98(o, s, BOOST_PP_LIST_REVERSE_D(98, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_99(o, s, l) BOOST_PP_LIST_FOLD_LEFT_99(o, s, BOOST_PP_LIST_REVERSE_D(99, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_100(o, s, l) BOOST_PP_LIST_FOLD_LEFT_100(o, s, BOOST_PP_LIST_REVERSE_D(100, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_101(o, s, l) BOOST_PP_LIST_FOLD_LEFT_101(o, s, BOOST_PP_LIST_REVERSE_D(101, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_102(o, s, l) BOOST_PP_LIST_FOLD_LEFT_102(o, s, BOOST_PP_LIST_REVERSE_D(102, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_103(o, s, l) BOOST_PP_LIST_FOLD_LEFT_103(o, s, BOOST_PP_LIST_REVERSE_D(103, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_104(o, s, l) BOOST_PP_LIST_FOLD_LEFT_104(o, s, BOOST_PP_LIST_REVERSE_D(104, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_105(o, s, l) BOOST_PP_LIST_FOLD_LEFT_105(o, s, BOOST_PP_LIST_REVERSE_D(105, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_106(o, s, l) BOOST_PP_LIST_FOLD_LEFT_106(o, s, BOOST_PP_LIST_REVERSE_D(106, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_107(o, s, l) BOOST_PP_LIST_FOLD_LEFT_107(o, s, BOOST_PP_LIST_REVERSE_D(107, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_108(o, s, l) BOOST_PP_LIST_FOLD_LEFT_108(o, s, BOOST_PP_LIST_REVERSE_D(108, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_109(o, s, l) BOOST_PP_LIST_FOLD_LEFT_109(o, s, BOOST_PP_LIST_REVERSE_D(109, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_110(o, s, l) BOOST_PP_LIST_FOLD_LEFT_110(o, s, BOOST_PP_LIST_REVERSE_D(110, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_111(o, s, l) BOOST_PP_LIST_FOLD_LEFT_111(o, s, BOOST_PP_LIST_REVERSE_D(111, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_112(o, s, l) BOOST_PP_LIST_FOLD_LEFT_112(o, s, BOOST_PP_LIST_REVERSE_D(112, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_113(o, s, l) BOOST_PP_LIST_FOLD_LEFT_113(o, s, BOOST_PP_LIST_REVERSE_D(113, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_114(o, s, l) BOOST_PP_LIST_FOLD_LEFT_114(o, s, BOOST_PP_LIST_REVERSE_D(114, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_115(o, s, l) BOOST_PP_LIST_FOLD_LEFT_115(o, s, BOOST_PP_LIST_REVERSE_D(115, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_116(o, s, l) BOOST_PP_LIST_FOLD_LEFT_116(o, s, BOOST_PP_LIST_REVERSE_D(116, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_117(o, s, l) BOOST_PP_LIST_FOLD_LEFT_117(o, s, BOOST_PP_LIST_REVERSE_D(117, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_118(o, s, l) BOOST_PP_LIST_FOLD_LEFT_118(o, s, BOOST_PP_LIST_REVERSE_D(118, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_119(o, s, l) BOOST_PP_LIST_FOLD_LEFT_119(o, s, BOOST_PP_LIST_REVERSE_D(119, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_120(o, s, l) BOOST_PP_LIST_FOLD_LEFT_120(o, s, BOOST_PP_LIST_REVERSE_D(120, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_121(o, s, l) BOOST_PP_LIST_FOLD_LEFT_121(o, s, BOOST_PP_LIST_REVERSE_D(121, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_122(o, s, l) BOOST_PP_LIST_FOLD_LEFT_122(o, s, BOOST_PP_LIST_REVERSE_D(122, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_123(o, s, l) BOOST_PP_LIST_FOLD_LEFT_123(o, s, BOOST_PP_LIST_REVERSE_D(123, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_124(o, s, l) BOOST_PP_LIST_FOLD_LEFT_124(o, s, BOOST_PP_LIST_REVERSE_D(124, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_125(o, s, l) BOOST_PP_LIST_FOLD_LEFT_125(o, s, BOOST_PP_LIST_REVERSE_D(125, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_126(o, s, l) BOOST_PP_LIST_FOLD_LEFT_126(o, s, BOOST_PP_LIST_REVERSE_D(126, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_127(o, s, l) BOOST_PP_LIST_FOLD_LEFT_127(o, s, BOOST_PP_LIST_REVERSE_D(127, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_128(o, s, l) BOOST_PP_LIST_FOLD_LEFT_128(o, s, BOOST_PP_LIST_REVERSE_D(128, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_129(o, s, l) BOOST_PP_LIST_FOLD_LEFT_129(o, s, BOOST_PP_LIST_REVERSE_D(129, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_130(o, s, l) BOOST_PP_LIST_FOLD_LEFT_130(o, s, BOOST_PP_LIST_REVERSE_D(130, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_131(o, s, l) BOOST_PP_LIST_FOLD_LEFT_131(o, s, BOOST_PP_LIST_REVERSE_D(131, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_132(o, s, l) BOOST_PP_LIST_FOLD_LEFT_132(o, s, BOOST_PP_LIST_REVERSE_D(132, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_133(o, s, l) BOOST_PP_LIST_FOLD_LEFT_133(o, s, BOOST_PP_LIST_REVERSE_D(133, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_134(o, s, l) BOOST_PP_LIST_FOLD_LEFT_134(o, s, BOOST_PP_LIST_REVERSE_D(134, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_135(o, s, l) BOOST_PP_LIST_FOLD_LEFT_135(o, s, BOOST_PP_LIST_REVERSE_D(135, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_136(o, s, l) BOOST_PP_LIST_FOLD_LEFT_136(o, s, BOOST_PP_LIST_REVERSE_D(136, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_137(o, s, l) BOOST_PP_LIST_FOLD_LEFT_137(o, s, BOOST_PP_LIST_REVERSE_D(137, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_138(o, s, l) BOOST_PP_LIST_FOLD_LEFT_138(o, s, BOOST_PP_LIST_REVERSE_D(138, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_139(o, s, l) BOOST_PP_LIST_FOLD_LEFT_139(o, s, BOOST_PP_LIST_REVERSE_D(139, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_140(o, s, l) BOOST_PP_LIST_FOLD_LEFT_140(o, s, BOOST_PP_LIST_REVERSE_D(140, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_141(o, s, l) BOOST_PP_LIST_FOLD_LEFT_141(o, s, BOOST_PP_LIST_REVERSE_D(141, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_142(o, s, l) BOOST_PP_LIST_FOLD_LEFT_142(o, s, BOOST_PP_LIST_REVERSE_D(142, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_143(o, s, l) BOOST_PP_LIST_FOLD_LEFT_143(o, s, BOOST_PP_LIST_REVERSE_D(143, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_144(o, s, l) BOOST_PP_LIST_FOLD_LEFT_144(o, s, BOOST_PP_LIST_REVERSE_D(144, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_145(o, s, l) BOOST_PP_LIST_FOLD_LEFT_145(o, s, BOOST_PP_LIST_REVERSE_D(145, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_146(o, s, l) BOOST_PP_LIST_FOLD_LEFT_146(o, s, BOOST_PP_LIST_REVERSE_D(146, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_147(o, s, l) BOOST_PP_LIST_FOLD_LEFT_147(o, s, BOOST_PP_LIST_REVERSE_D(147, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_148(o, s, l) BOOST_PP_LIST_FOLD_LEFT_148(o, s, BOOST_PP_LIST_REVERSE_D(148, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_149(o, s, l) BOOST_PP_LIST_FOLD_LEFT_149(o, s, BOOST_PP_LIST_REVERSE_D(149, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_150(o, s, l) BOOST_PP_LIST_FOLD_LEFT_150(o, s, BOOST_PP_LIST_REVERSE_D(150, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_151(o, s, l) BOOST_PP_LIST_FOLD_LEFT_151(o, s, BOOST_PP_LIST_REVERSE_D(151, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_152(o, s, l) BOOST_PP_LIST_FOLD_LEFT_152(o, s, BOOST_PP_LIST_REVERSE_D(152, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_153(o, s, l) BOOST_PP_LIST_FOLD_LEFT_153(o, s, BOOST_PP_LIST_REVERSE_D(153, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_154(o, s, l) BOOST_PP_LIST_FOLD_LEFT_154(o, s, BOOST_PP_LIST_REVERSE_D(154, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_155(o, s, l) BOOST_PP_LIST_FOLD_LEFT_155(o, s, BOOST_PP_LIST_REVERSE_D(155, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_156(o, s, l) BOOST_PP_LIST_FOLD_LEFT_156(o, s, BOOST_PP_LIST_REVERSE_D(156, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_157(o, s, l) BOOST_PP_LIST_FOLD_LEFT_157(o, s, BOOST_PP_LIST_REVERSE_D(157, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_158(o, s, l) BOOST_PP_LIST_FOLD_LEFT_158(o, s, BOOST_PP_LIST_REVERSE_D(158, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_159(o, s, l) BOOST_PP_LIST_FOLD_LEFT_159(o, s, BOOST_PP_LIST_REVERSE_D(159, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_160(o, s, l) BOOST_PP_LIST_FOLD_LEFT_160(o, s, BOOST_PP_LIST_REVERSE_D(160, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_161(o, s, l) BOOST_PP_LIST_FOLD_LEFT_161(o, s, BOOST_PP_LIST_REVERSE_D(161, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_162(o, s, l) BOOST_PP_LIST_FOLD_LEFT_162(o, s, BOOST_PP_LIST_REVERSE_D(162, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_163(o, s, l) BOOST_PP_LIST_FOLD_LEFT_163(o, s, BOOST_PP_LIST_REVERSE_D(163, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_164(o, s, l) BOOST_PP_LIST_FOLD_LEFT_164(o, s, BOOST_PP_LIST_REVERSE_D(164, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_165(o, s, l) BOOST_PP_LIST_FOLD_LEFT_165(o, s, BOOST_PP_LIST_REVERSE_D(165, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_166(o, s, l) BOOST_PP_LIST_FOLD_LEFT_166(o, s, BOOST_PP_LIST_REVERSE_D(166, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_167(o, s, l) BOOST_PP_LIST_FOLD_LEFT_167(o, s, BOOST_PP_LIST_REVERSE_D(167, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_168(o, s, l) BOOST_PP_LIST_FOLD_LEFT_168(o, s, BOOST_PP_LIST_REVERSE_D(168, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_169(o, s, l) BOOST_PP_LIST_FOLD_LEFT_169(o, s, BOOST_PP_LIST_REVERSE_D(169, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_170(o, s, l) BOOST_PP_LIST_FOLD_LEFT_170(o, s, BOOST_PP_LIST_REVERSE_D(170, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_171(o, s, l) BOOST_PP_LIST_FOLD_LEFT_171(o, s, BOOST_PP_LIST_REVERSE_D(171, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_172(o, s, l) BOOST_PP_LIST_FOLD_LEFT_172(o, s, BOOST_PP_LIST_REVERSE_D(172, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_173(o, s, l) BOOST_PP_LIST_FOLD_LEFT_173(o, s, BOOST_PP_LIST_REVERSE_D(173, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_174(o, s, l) BOOST_PP_LIST_FOLD_LEFT_174(o, s, BOOST_PP_LIST_REVERSE_D(174, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_175(o, s, l) BOOST_PP_LIST_FOLD_LEFT_175(o, s, BOOST_PP_LIST_REVERSE_D(175, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_176(o, s, l) BOOST_PP_LIST_FOLD_LEFT_176(o, s, BOOST_PP_LIST_REVERSE_D(176, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_177(o, s, l) BOOST_PP_LIST_FOLD_LEFT_177(o, s, BOOST_PP_LIST_REVERSE_D(177, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_178(o, s, l) BOOST_PP_LIST_FOLD_LEFT_178(o, s, BOOST_PP_LIST_REVERSE_D(178, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_179(o, s, l) BOOST_PP_LIST_FOLD_LEFT_179(o, s, BOOST_PP_LIST_REVERSE_D(179, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_180(o, s, l) BOOST_PP_LIST_FOLD_LEFT_180(o, s, BOOST_PP_LIST_REVERSE_D(180, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_181(o, s, l) BOOST_PP_LIST_FOLD_LEFT_181(o, s, BOOST_PP_LIST_REVERSE_D(181, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_182(o, s, l) BOOST_PP_LIST_FOLD_LEFT_182(o, s, BOOST_PP_LIST_REVERSE_D(182, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_183(o, s, l) BOOST_PP_LIST_FOLD_LEFT_183(o, s, BOOST_PP_LIST_REVERSE_D(183, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_184(o, s, l) BOOST_PP_LIST_FOLD_LEFT_184(o, s, BOOST_PP_LIST_REVERSE_D(184, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_185(o, s, l) BOOST_PP_LIST_FOLD_LEFT_185(o, s, BOOST_PP_LIST_REVERSE_D(185, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_186(o, s, l) BOOST_PP_LIST_FOLD_LEFT_186(o, s, BOOST_PP_LIST_REVERSE_D(186, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_187(o, s, l) BOOST_PP_LIST_FOLD_LEFT_187(o, s, BOOST_PP_LIST_REVERSE_D(187, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_188(o, s, l) BOOST_PP_LIST_FOLD_LEFT_188(o, s, BOOST_PP_LIST_REVERSE_D(188, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_189(o, s, l) BOOST_PP_LIST_FOLD_LEFT_189(o, s, BOOST_PP_LIST_REVERSE_D(189, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_190(o, s, l) BOOST_PP_LIST_FOLD_LEFT_190(o, s, BOOST_PP_LIST_REVERSE_D(190, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_191(o, s, l) BOOST_PP_LIST_FOLD_LEFT_191(o, s, BOOST_PP_LIST_REVERSE_D(191, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_192(o, s, l) BOOST_PP_LIST_FOLD_LEFT_192(o, s, BOOST_PP_LIST_REVERSE_D(192, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_193(o, s, l) BOOST_PP_LIST_FOLD_LEFT_193(o, s, BOOST_PP_LIST_REVERSE_D(193, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_194(o, s, l) BOOST_PP_LIST_FOLD_LEFT_194(o, s, BOOST_PP_LIST_REVERSE_D(194, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_195(o, s, l) BOOST_PP_LIST_FOLD_LEFT_195(o, s, BOOST_PP_LIST_REVERSE_D(195, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_196(o, s, l) BOOST_PP_LIST_FOLD_LEFT_196(o, s, BOOST_PP_LIST_REVERSE_D(196, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_197(o, s, l) BOOST_PP_LIST_FOLD_LEFT_197(o, s, BOOST_PP_LIST_REVERSE_D(197, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_198(o, s, l) BOOST_PP_LIST_FOLD_LEFT_198(o, s, BOOST_PP_LIST_REVERSE_D(198, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_199(o, s, l) BOOST_PP_LIST_FOLD_LEFT_199(o, s, BOOST_PP_LIST_REVERSE_D(199, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_200(o, s, l) BOOST_PP_LIST_FOLD_LEFT_200(o, s, BOOST_PP_LIST_REVERSE_D(200, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_201(o, s, l) BOOST_PP_LIST_FOLD_LEFT_201(o, s, BOOST_PP_LIST_REVERSE_D(201, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_202(o, s, l) BOOST_PP_LIST_FOLD_LEFT_202(o, s, BOOST_PP_LIST_REVERSE_D(202, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_203(o, s, l) BOOST_PP_LIST_FOLD_LEFT_203(o, s, BOOST_PP_LIST_REVERSE_D(203, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_204(o, s, l) BOOST_PP_LIST_FOLD_LEFT_204(o, s, BOOST_PP_LIST_REVERSE_D(204, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_205(o, s, l) BOOST_PP_LIST_FOLD_LEFT_205(o, s, BOOST_PP_LIST_REVERSE_D(205, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_206(o, s, l) BOOST_PP_LIST_FOLD_LEFT_206(o, s, BOOST_PP_LIST_REVERSE_D(206, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_207(o, s, l) BOOST_PP_LIST_FOLD_LEFT_207(o, s, BOOST_PP_LIST_REVERSE_D(207, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_208(o, s, l) BOOST_PP_LIST_FOLD_LEFT_208(o, s, BOOST_PP_LIST_REVERSE_D(208, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_209(o, s, l) BOOST_PP_LIST_FOLD_LEFT_209(o, s, BOOST_PP_LIST_REVERSE_D(209, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_210(o, s, l) BOOST_PP_LIST_FOLD_LEFT_210(o, s, BOOST_PP_LIST_REVERSE_D(210, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_211(o, s, l) BOOST_PP_LIST_FOLD_LEFT_211(o, s, BOOST_PP_LIST_REVERSE_D(211, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_212(o, s, l) BOOST_PP_LIST_FOLD_LEFT_212(o, s, BOOST_PP_LIST_REVERSE_D(212, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_213(o, s, l) BOOST_PP_LIST_FOLD_LEFT_213(o, s, BOOST_PP_LIST_REVERSE_D(213, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_214(o, s, l) BOOST_PP_LIST_FOLD_LEFT_214(o, s, BOOST_PP_LIST_REVERSE_D(214, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_215(o, s, l) BOOST_PP_LIST_FOLD_LEFT_215(o, s, BOOST_PP_LIST_REVERSE_D(215, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_216(o, s, l) BOOST_PP_LIST_FOLD_LEFT_216(o, s, BOOST_PP_LIST_REVERSE_D(216, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_217(o, s, l) BOOST_PP_LIST_FOLD_LEFT_217(o, s, BOOST_PP_LIST_REVERSE_D(217, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_218(o, s, l) BOOST_PP_LIST_FOLD_LEFT_218(o, s, BOOST_PP_LIST_REVERSE_D(218, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_219(o, s, l) BOOST_PP_LIST_FOLD_LEFT_219(o, s, BOOST_PP_LIST_REVERSE_D(219, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_220(o, s, l) BOOST_PP_LIST_FOLD_LEFT_220(o, s, BOOST_PP_LIST_REVERSE_D(220, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_221(o, s, l) BOOST_PP_LIST_FOLD_LEFT_221(o, s, BOOST_PP_LIST_REVERSE_D(221, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_222(o, s, l) BOOST_PP_LIST_FOLD_LEFT_222(o, s, BOOST_PP_LIST_REVERSE_D(222, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_223(o, s, l) BOOST_PP_LIST_FOLD_LEFT_223(o, s, BOOST_PP_LIST_REVERSE_D(223, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_224(o, s, l) BOOST_PP_LIST_FOLD_LEFT_224(o, s, BOOST_PP_LIST_REVERSE_D(224, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_225(o, s, l) BOOST_PP_LIST_FOLD_LEFT_225(o, s, BOOST_PP_LIST_REVERSE_D(225, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_226(o, s, l) BOOST_PP_LIST_FOLD_LEFT_226(o, s, BOOST_PP_LIST_REVERSE_D(226, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_227(o, s, l) BOOST_PP_LIST_FOLD_LEFT_227(o, s, BOOST_PP_LIST_REVERSE_D(227, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_228(o, s, l) BOOST_PP_LIST_FOLD_LEFT_228(o, s, BOOST_PP_LIST_REVERSE_D(228, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_229(o, s, l) BOOST_PP_LIST_FOLD_LEFT_229(o, s, BOOST_PP_LIST_REVERSE_D(229, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_230(o, s, l) BOOST_PP_LIST_FOLD_LEFT_230(o, s, BOOST_PP_LIST_REVERSE_D(230, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_231(o, s, l) BOOST_PP_LIST_FOLD_LEFT_231(o, s, BOOST_PP_LIST_REVERSE_D(231, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_232(o, s, l) BOOST_PP_LIST_FOLD_LEFT_232(o, s, BOOST_PP_LIST_REVERSE_D(232, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_233(o, s, l) BOOST_PP_LIST_FOLD_LEFT_233(o, s, BOOST_PP_LIST_REVERSE_D(233, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_234(o, s, l) BOOST_PP_LIST_FOLD_LEFT_234(o, s, BOOST_PP_LIST_REVERSE_D(234, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_235(o, s, l) BOOST_PP_LIST_FOLD_LEFT_235(o, s, BOOST_PP_LIST_REVERSE_D(235, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_236(o, s, l) BOOST_PP_LIST_FOLD_LEFT_236(o, s, BOOST_PP_LIST_REVERSE_D(236, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_237(o, s, l) BOOST_PP_LIST_FOLD_LEFT_237(o, s, BOOST_PP_LIST_REVERSE_D(237, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_238(o, s, l) BOOST_PP_LIST_FOLD_LEFT_238(o, s, BOOST_PP_LIST_REVERSE_D(238, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_239(o, s, l) BOOST_PP_LIST_FOLD_LEFT_239(o, s, BOOST_PP_LIST_REVERSE_D(239, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_240(o, s, l) BOOST_PP_LIST_FOLD_LEFT_240(o, s, BOOST_PP_LIST_REVERSE_D(240, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_241(o, s, l) BOOST_PP_LIST_FOLD_LEFT_241(o, s, BOOST_PP_LIST_REVERSE_D(241, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_242(o, s, l) BOOST_PP_LIST_FOLD_LEFT_242(o, s, BOOST_PP_LIST_REVERSE_D(242, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_243(o, s, l) BOOST_PP_LIST_FOLD_LEFT_243(o, s, BOOST_PP_LIST_REVERSE_D(243, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_244(o, s, l) BOOST_PP_LIST_FOLD_LEFT_244(o, s, BOOST_PP_LIST_REVERSE_D(244, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_245(o, s, l) BOOST_PP_LIST_FOLD_LEFT_245(o, s, BOOST_PP_LIST_REVERSE_D(245, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_246(o, s, l) BOOST_PP_LIST_FOLD_LEFT_246(o, s, BOOST_PP_LIST_REVERSE_D(246, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_247(o, s, l) BOOST_PP_LIST_FOLD_LEFT_247(o, s, BOOST_PP_LIST_REVERSE_D(247, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_248(o, s, l) BOOST_PP_LIST_FOLD_LEFT_248(o, s, BOOST_PP_LIST_REVERSE_D(248, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_249(o, s, l) BOOST_PP_LIST_FOLD_LEFT_249(o, s, BOOST_PP_LIST_REVERSE_D(249, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_250(o, s, l) BOOST_PP_LIST_FOLD_LEFT_250(o, s, BOOST_PP_LIST_REVERSE_D(250, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_251(o, s, l) BOOST_PP_LIST_FOLD_LEFT_251(o, s, BOOST_PP_LIST_REVERSE_D(251, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_252(o, s, l) BOOST_PP_LIST_FOLD_LEFT_252(o, s, BOOST_PP_LIST_REVERSE_D(252, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_253(o, s, l) BOOST_PP_LIST_FOLD_LEFT_253(o, s, BOOST_PP_LIST_REVERSE_D(253, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_254(o, s, l) BOOST_PP_LIST_FOLD_LEFT_254(o, s, BOOST_PP_LIST_REVERSE_D(254, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_255(o, s, l) BOOST_PP_LIST_FOLD_LEFT_255(o, s, BOOST_PP_LIST_REVERSE_D(255, l)) +# define BOOST_PP_LIST_FOLD_RIGHT_256(o, s, l) BOOST_PP_LIST_FOLD_LEFT_256(o, s, BOOST_PP_LIST_REVERSE_D(256, l)) +# +# endif diff --git a/realsense-file/3rd_party/boost/boost/preprocessor/list/fold_left.hpp b/realsense-file/3rd_party/boost/boost/preprocessor/list/fold_left.hpp new file mode 100644 index 0000000000..bd945c014b --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/preprocessor/list/fold_left.hpp @@ -0,0 +1,303 @@ +# /* Copyright (C) 2001 +# * Housemarque Oy +# * http://www.housemarque.com +# * +# * 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) +# */ +# +# /* Revised by Paul Mensonides (2002) */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_LIST_FOLD_LEFT_HPP +# define BOOST_PREPROCESSOR_LIST_FOLD_LEFT_HPP +# +# include +# include +# include +# include +# +# /* BOOST_PP_LIST_FOLD_LEFT */ +# +# if 0 +# define BOOST_PP_LIST_FOLD_LEFT(op, state, list) +# endif +# +# define BOOST_PP_LIST_FOLD_LEFT BOOST_PP_CAT(BOOST_PP_LIST_FOLD_LEFT_, BOOST_PP_AUTO_REC(BOOST_PP_WHILE_P, 256)) +# +# define BOOST_PP_LIST_FOLD_LEFT_257(o, s, l) BOOST_PP_ERROR(0x0004) +# +# define BOOST_PP_LIST_FOLD_LEFT_D(d, o, s, l) BOOST_PP_LIST_FOLD_LEFT_ ## d(o, s, l) +# define BOOST_PP_LIST_FOLD_LEFT_2ND BOOST_PP_LIST_FOLD_LEFT +# define BOOST_PP_LIST_FOLD_LEFT_2ND_D BOOST_PP_LIST_FOLD_LEFT_D +# +# if BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() +# include +# elif BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_DMC() +# include +# else +# include +# endif +# +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_NIL 1 +# +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_1(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_2(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_3(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_4(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_5(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_6(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_7(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_8(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_9(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_10(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_11(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_12(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_13(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_14(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_15(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_16(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_17(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_18(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_19(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_20(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_21(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_22(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_23(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_24(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_25(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_26(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_27(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_28(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_29(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_30(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_31(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_32(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_33(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_34(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_35(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_36(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_37(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_38(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_39(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_40(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_41(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_42(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_43(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_44(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_45(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_46(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_47(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_48(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_49(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_50(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_51(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_52(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_53(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_54(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_55(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_56(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_57(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_58(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_59(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_60(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_61(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_62(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_63(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_64(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_65(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_66(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_67(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_68(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_69(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_70(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_71(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_72(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_73(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_74(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_75(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_76(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_77(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_78(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_79(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_80(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_81(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_82(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_83(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_84(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_85(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_86(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_87(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_88(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_89(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_90(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_91(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_92(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_93(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_94(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_95(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_96(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_97(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_98(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_99(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_100(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_101(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_102(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_103(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_104(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_105(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_106(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_107(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_108(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_109(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_110(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_111(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_112(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_113(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_114(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_115(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_116(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_117(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_118(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_119(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_120(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_121(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_122(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_123(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_124(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_125(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_126(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_127(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_128(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_129(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_130(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_131(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_132(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_133(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_134(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_135(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_136(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_137(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_138(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_139(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_140(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_141(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_142(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_143(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_144(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_145(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_146(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_147(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_148(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_149(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_150(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_151(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_152(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_153(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_154(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_155(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_156(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_157(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_158(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_159(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_160(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_161(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_162(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_163(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_164(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_165(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_166(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_167(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_168(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_169(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_170(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_171(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_172(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_173(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_174(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_175(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_176(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_177(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_178(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_179(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_180(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_181(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_182(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_183(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_184(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_185(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_186(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_187(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_188(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_189(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_190(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_191(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_192(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_193(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_194(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_195(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_196(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_197(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_198(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_199(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_200(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_201(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_202(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_203(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_204(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_205(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_206(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_207(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_208(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_209(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_210(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_211(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_212(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_213(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_214(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_215(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_216(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_217(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_218(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_219(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_220(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_221(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_222(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_223(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_224(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_225(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_226(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_227(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_228(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_229(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_230(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_231(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_232(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_233(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_234(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_235(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_236(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_237(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_238(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_239(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_240(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_241(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_242(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_243(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_244(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_245(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_246(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_247(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_248(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_249(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_250(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_251(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_252(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_253(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_254(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_255(o, s, l) 0 +# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_256(o, s, l) 0 +# +# endif diff --git a/realsense-file/3rd_party/boost/boost/preprocessor/list/fold_right.hpp b/realsense-file/3rd_party/boost/boost/preprocessor/list/fold_right.hpp new file mode 100644 index 0000000000..19a63e6e52 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/preprocessor/list/fold_right.hpp @@ -0,0 +1,40 @@ +# /* Copyright (C) 2001 +# * Housemarque Oy +# * http://www.housemarque.com +# * +# * 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) +# */ +# +# /* Revised by Paul Mensonides (2002) */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_LIST_FOLD_RIGHT_HPP +# define BOOST_PREPROCESSOR_LIST_FOLD_RIGHT_HPP +# +# include +# include +# include +# include +# +# if 0 +# define BOOST_PP_LIST_FOLD_RIGHT(op, state, list) +# endif +# +# define BOOST_PP_LIST_FOLD_RIGHT BOOST_PP_CAT(BOOST_PP_LIST_FOLD_RIGHT_, BOOST_PP_AUTO_REC(BOOST_PP_WHILE_P, 256)) +# +# define BOOST_PP_LIST_FOLD_RIGHT_257(o, s, l) BOOST_PP_ERROR(0x0004) +# +# define BOOST_PP_LIST_FOLD_RIGHT_D(d, o, s, l) BOOST_PP_LIST_FOLD_RIGHT_ ## d(o, s, l) +# define BOOST_PP_LIST_FOLD_RIGHT_2ND BOOST_PP_LIST_FOLD_RIGHT +# define BOOST_PP_LIST_FOLD_RIGHT_2ND_D BOOST_PP_LIST_FOLD_RIGHT_D +# +# if BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() +# include +# else +# include +# endif +# +# endif diff --git a/realsense-file/3rd_party/boost/boost/preprocessor/list/for_each_i.hpp b/realsense-file/3rd_party/boost/boost/preprocessor/list/for_each_i.hpp new file mode 100644 index 0000000000..87ec39ce6d --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/preprocessor/list/for_each_i.hpp @@ -0,0 +1,65 @@ +# /* Copyright (C) 2001 +# * Housemarque Oy +# * http://www.housemarque.com +# * +# * 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) +# */ +# +# /* Revised by Paul Mensonides (2002) */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_LIST_LIST_FOR_EACH_I_HPP +# define BOOST_PREPROCESSOR_LIST_LIST_FOR_EACH_I_HPP +# +# include +# include +# include +# include +# include +# include +# +# /* BOOST_PP_LIST_FOR_EACH_I */ +# +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() && ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MSVC() +# define BOOST_PP_LIST_FOR_EACH_I(macro, data, list) BOOST_PP_FOR((macro, data, list, 0), BOOST_PP_LIST_FOR_EACH_I_P, BOOST_PP_LIST_FOR_EACH_I_O, BOOST_PP_LIST_FOR_EACH_I_M) +# else +# define BOOST_PP_LIST_FOR_EACH_I(macro, data, list) BOOST_PP_LIST_FOR_EACH_I_I(macro, data, list) +# define BOOST_PP_LIST_FOR_EACH_I_I(macro, data, list) BOOST_PP_FOR((macro, data, list, 0), BOOST_PP_LIST_FOR_EACH_I_P, BOOST_PP_LIST_FOR_EACH_I_O, BOOST_PP_LIST_FOR_EACH_I_M) +# endif +# +# if BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_STRICT() +# define BOOST_PP_LIST_FOR_EACH_I_P(r, x) BOOST_PP_LIST_FOR_EACH_I_P_D x +# define BOOST_PP_LIST_FOR_EACH_I_P_D(m, d, l, i) BOOST_PP_LIST_IS_CONS(l) +# else +# define BOOST_PP_LIST_FOR_EACH_I_P(r, x) BOOST_PP_LIST_IS_CONS(BOOST_PP_TUPLE_ELEM(4, 2, x)) +# endif +# +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() +# define BOOST_PP_LIST_FOR_EACH_I_O(r, x) BOOST_PP_LIST_FOR_EACH_I_O_D x +# define BOOST_PP_LIST_FOR_EACH_I_O_D(m, d, l, i) (m, d, BOOST_PP_LIST_REST(l), BOOST_PP_INC(i)) +# else +# define BOOST_PP_LIST_FOR_EACH_I_O(r, x) (BOOST_PP_TUPLE_ELEM(4, 0, x), BOOST_PP_TUPLE_ELEM(4, 1, x), BOOST_PP_LIST_REST(BOOST_PP_TUPLE_ELEM(4, 2, x)), BOOST_PP_INC(BOOST_PP_TUPLE_ELEM(4, 3, x))) +# endif +# +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() +# define BOOST_PP_LIST_FOR_EACH_I_M(r, x) BOOST_PP_LIST_FOR_EACH_I_M_D(r, BOOST_PP_TUPLE_ELEM(4, 0, x), BOOST_PP_TUPLE_ELEM(4, 1, x), BOOST_PP_TUPLE_ELEM(4, 2, x), BOOST_PP_TUPLE_ELEM(4, 3, x)) +# else +# define BOOST_PP_LIST_FOR_EACH_I_M(r, x) BOOST_PP_LIST_FOR_EACH_I_M_I(r, BOOST_PP_TUPLE_REM_4 x) +# define BOOST_PP_LIST_FOR_EACH_I_M_I(r, x_e) BOOST_PP_LIST_FOR_EACH_I_M_D(r, x_e) +# endif +# +# define BOOST_PP_LIST_FOR_EACH_I_M_D(r, m, d, l, i) m(r, d, i, BOOST_PP_LIST_FIRST(l)) +# +# /* BOOST_PP_LIST_FOR_EACH_I_R */ +# +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() +# define BOOST_PP_LIST_FOR_EACH_I_R(r, macro, data, list) BOOST_PP_FOR_ ## r((macro, data, list, 0), BOOST_PP_LIST_FOR_EACH_I_P, BOOST_PP_LIST_FOR_EACH_I_O, BOOST_PP_LIST_FOR_EACH_I_M) +# else +# define BOOST_PP_LIST_FOR_EACH_I_R(r, macro, data, list) BOOST_PP_LIST_FOR_EACH_I_R_I(r, macro, data, list) +# define BOOST_PP_LIST_FOR_EACH_I_R_I(r, macro, data, list) BOOST_PP_FOR_ ## r((macro, data, list, 0), BOOST_PP_LIST_FOR_EACH_I_P, BOOST_PP_LIST_FOR_EACH_I_O, BOOST_PP_LIST_FOR_EACH_I_M) +# endif +# +# endif diff --git a/realsense-file/3rd_party/boost/boost/preprocessor/list/reverse.hpp b/realsense-file/3rd_party/boost/boost/preprocessor/list/reverse.hpp new file mode 100644 index 0000000000..88e6d85bce --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/preprocessor/list/reverse.hpp @@ -0,0 +1,40 @@ +# /* Copyright (C) 2001 +# * Housemarque Oy +# * http://www.housemarque.com +# * +# * 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) +# */ +# +# /* Revised by Paul Mensonides (2002) */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_LIST_REVERSE_HPP +# define BOOST_PREPROCESSOR_LIST_REVERSE_HPP +# +# include +# include +# +# /* BOOST_PP_LIST_REVERSE */ +# +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() +# define BOOST_PP_LIST_REVERSE(list) BOOST_PP_LIST_FOLD_LEFT(BOOST_PP_LIST_REVERSE_O, BOOST_PP_NIL, list) +# else +# define BOOST_PP_LIST_REVERSE(list) BOOST_PP_LIST_REVERSE_I(list) +# define BOOST_PP_LIST_REVERSE_I(list) BOOST_PP_LIST_FOLD_LEFT(BOOST_PP_LIST_REVERSE_O, BOOST_PP_NIL, list) +# endif +# +# define BOOST_PP_LIST_REVERSE_O(d, s, x) (x, s) +# +# /* BOOST_PP_LIST_REVERSE_D */ +# +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() +# define BOOST_PP_LIST_REVERSE_D(d, list) BOOST_PP_LIST_FOLD_LEFT_ ## d(BOOST_PP_LIST_REVERSE_O, BOOST_PP_NIL, list) +# else +# define BOOST_PP_LIST_REVERSE_D(d, list) BOOST_PP_LIST_REVERSE_D_I(d, list) +# define BOOST_PP_LIST_REVERSE_D_I(d, list) BOOST_PP_LIST_FOLD_LEFT_ ## d(BOOST_PP_LIST_REVERSE_O, BOOST_PP_NIL, list) +# endif +# +# endif diff --git a/realsense-file/3rd_party/boost/boost/preprocessor/list/transform.hpp b/realsense-file/3rd_party/boost/boost/preprocessor/list/transform.hpp new file mode 100644 index 0000000000..1b53336a3e --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/preprocessor/list/transform.hpp @@ -0,0 +1,49 @@ +# /* Copyright (C) 2001 +# * Housemarque Oy +# * http://www.housemarque.com +# * +# * 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) +# */ +# +# /* Revised by Paul Mensonides (2002) */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_LIST_TRANSFORM_HPP +# define BOOST_PREPROCESSOR_LIST_TRANSFORM_HPP +# +# include +# include +# include +# include +# +# /* BOOST_PP_LIST_TRANSFORM */ +# +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() +# define BOOST_PP_LIST_TRANSFORM(op, data, list) BOOST_PP_TUPLE_ELEM(3, 2, BOOST_PP_LIST_FOLD_RIGHT(BOOST_PP_LIST_TRANSFORM_O, (op, data, BOOST_PP_NIL), list)) +# else +# define BOOST_PP_LIST_TRANSFORM(op, data, list) BOOST_PP_LIST_TRANSFORM_I(op, data, list) +# define BOOST_PP_LIST_TRANSFORM_I(op, data, list) BOOST_PP_TUPLE_ELEM(3, 2, BOOST_PP_LIST_FOLD_RIGHT(BOOST_PP_LIST_TRANSFORM_O, (op, data, BOOST_PP_NIL), list)) +# endif +# +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() +# define BOOST_PP_LIST_TRANSFORM_O(d, odr, elem) BOOST_PP_LIST_TRANSFORM_O_D(d, BOOST_PP_TUPLE_ELEM(3, 0, odr), BOOST_PP_TUPLE_ELEM(3, 1, odr), BOOST_PP_TUPLE_ELEM(3, 2, odr), elem) +# else +# define BOOST_PP_LIST_TRANSFORM_O(d, odr, elem) BOOST_PP_LIST_TRANSFORM_O_I(d, BOOST_PP_TUPLE_REM_3 odr, elem) +# define BOOST_PP_LIST_TRANSFORM_O_I(d, im, elem) BOOST_PP_LIST_TRANSFORM_O_D(d, im, elem) +# endif +# +# define BOOST_PP_LIST_TRANSFORM_O_D(d, op, data, res, elem) (op, data, (op(d, data, elem), res)) +# +# /* BOOST_PP_LIST_TRANSFORM_D */ +# +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() +# define BOOST_PP_LIST_TRANSFORM_D(d, op, data, list) BOOST_PP_TUPLE_ELEM(3, 2, BOOST_PP_LIST_FOLD_RIGHT_ ## d(BOOST_PP_LIST_TRANSFORM_O, (op, data, BOOST_PP_NIL), list)) +# else +# define BOOST_PP_LIST_TRANSFORM_D(d, op, data, list) BOOST_PP_LIST_TRANSFORM_D_I(d, op, data, list) +# define BOOST_PP_LIST_TRANSFORM_D_I(d, op, data, list) BOOST_PP_TUPLE_ELEM(3, 2, BOOST_PP_LIST_FOLD_RIGHT_ ## d(BOOST_PP_LIST_TRANSFORM_O, (op, data, BOOST_PP_NIL), list)) +# endif +# +# endif diff --git a/realsense-file/3rd_party/boost/boost/preprocessor/logical/and.hpp b/realsense-file/3rd_party/boost/boost/preprocessor/logical/and.hpp new file mode 100644 index 0000000000..1db8e2b9fa --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/preprocessor/logical/and.hpp @@ -0,0 +1,30 @@ +# /* Copyright (C) 2001 +# * Housemarque Oy +# * http://www.housemarque.com +# * +# * 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) +# */ +# +# /* Revised by Paul Mensonides (2002) */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_LOGICAL_AND_HPP +# define BOOST_PREPROCESSOR_LOGICAL_AND_HPP +# +# include +# include +# include +# +# /* BOOST_PP_AND */ +# +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() +# define BOOST_PP_AND(p, q) BOOST_PP_BITAND(BOOST_PP_BOOL(p), BOOST_PP_BOOL(q)) +# else +# define BOOST_PP_AND(p, q) BOOST_PP_AND_I(p, q) +# define BOOST_PP_AND_I(p, q) BOOST_PP_BITAND(BOOST_PP_BOOL(p), BOOST_PP_BOOL(q)) +# endif +# +# endif diff --git a/realsense-file/3rd_party/boost/boost/preprocessor/logical/bitand.hpp b/realsense-file/3rd_party/boost/boost/preprocessor/logical/bitand.hpp new file mode 100644 index 0000000000..2e1c7382e1 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/preprocessor/logical/bitand.hpp @@ -0,0 +1,38 @@ +# /* ************************************************************************** +# * * +# * (C) Copyright Paul Mensonides 2002. +# * Distributed under the Boost Software License, Version 1.0. (See +# * accompanying file LICENSE_1_0.txt or copy at +# * http://www.boost.org/LICENSE_1_0.txt) +# * * +# ************************************************************************** */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_LOGICAL_BITAND_HPP +# define BOOST_PREPROCESSOR_LOGICAL_BITAND_HPP +# +# include +# +# /* BOOST_PP_BITAND */ +# +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() +# define BOOST_PP_BITAND(x, y) BOOST_PP_BITAND_I(x, y) +# else +# define BOOST_PP_BITAND(x, y) BOOST_PP_BITAND_OO((x, y)) +# define BOOST_PP_BITAND_OO(par) BOOST_PP_BITAND_I ## par +# endif +# +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MSVC() +# define BOOST_PP_BITAND_I(x, y) BOOST_PP_BITAND_ ## x ## y +# else +# define BOOST_PP_BITAND_I(x, y) BOOST_PP_BITAND_ID(BOOST_PP_BITAND_ ## x ## y) +# define BOOST_PP_BITAND_ID(res) res +# endif +# +# define BOOST_PP_BITAND_00 0 +# define BOOST_PP_BITAND_01 0 +# define BOOST_PP_BITAND_10 0 +# define BOOST_PP_BITAND_11 1 +# +# endif diff --git a/realsense-file/3rd_party/boost/boost/preprocessor/logical/bool.hpp b/realsense-file/3rd_party/boost/boost/preprocessor/logical/bool.hpp new file mode 100644 index 0000000000..6772570cd6 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/preprocessor/logical/bool.hpp @@ -0,0 +1,288 @@ +# /* Copyright (C) 2001 +# * Housemarque Oy +# * http://www.housemarque.com +# * +# * 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) +# */ +# +# /* Revised by Paul Mensonides (2002) */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_LOGICAL_BOOL_HPP +# define BOOST_PREPROCESSOR_LOGICAL_BOOL_HPP +# +# include "../config/config.hpp" +# +# /* BOOST_PP_BOOL */ +# +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() +# define BOOST_PP_BOOL(x) BOOST_PP_BOOL_I(x) +# else +# define BOOST_PP_BOOL(x) BOOST_PP_BOOL_OO((x)) +# define BOOST_PP_BOOL_OO(par) BOOST_PP_BOOL_I ## par +# endif +# +# define BOOST_PP_BOOL_I(x) BOOST_PP_BOOL_ ## x +# +# define BOOST_PP_BOOL_0 0 +# define BOOST_PP_BOOL_1 1 +# define BOOST_PP_BOOL_2 1 +# define BOOST_PP_BOOL_3 1 +# define BOOST_PP_BOOL_4 1 +# define BOOST_PP_BOOL_5 1 +# define BOOST_PP_BOOL_6 1 +# define BOOST_PP_BOOL_7 1 +# define BOOST_PP_BOOL_8 1 +# define BOOST_PP_BOOL_9 1 +# define BOOST_PP_BOOL_10 1 +# define BOOST_PP_BOOL_11 1 +# define BOOST_PP_BOOL_12 1 +# define BOOST_PP_BOOL_13 1 +# define BOOST_PP_BOOL_14 1 +# define BOOST_PP_BOOL_15 1 +# define BOOST_PP_BOOL_16 1 +# define BOOST_PP_BOOL_17 1 +# define BOOST_PP_BOOL_18 1 +# define BOOST_PP_BOOL_19 1 +# define BOOST_PP_BOOL_20 1 +# define BOOST_PP_BOOL_21 1 +# define BOOST_PP_BOOL_22 1 +# define BOOST_PP_BOOL_23 1 +# define BOOST_PP_BOOL_24 1 +# define BOOST_PP_BOOL_25 1 +# define BOOST_PP_BOOL_26 1 +# define BOOST_PP_BOOL_27 1 +# define BOOST_PP_BOOL_28 1 +# define BOOST_PP_BOOL_29 1 +# define BOOST_PP_BOOL_30 1 +# define BOOST_PP_BOOL_31 1 +# define BOOST_PP_BOOL_32 1 +# define BOOST_PP_BOOL_33 1 +# define BOOST_PP_BOOL_34 1 +# define BOOST_PP_BOOL_35 1 +# define BOOST_PP_BOOL_36 1 +# define BOOST_PP_BOOL_37 1 +# define BOOST_PP_BOOL_38 1 +# define BOOST_PP_BOOL_39 1 +# define BOOST_PP_BOOL_40 1 +# define BOOST_PP_BOOL_41 1 +# define BOOST_PP_BOOL_42 1 +# define BOOST_PP_BOOL_43 1 +# define BOOST_PP_BOOL_44 1 +# define BOOST_PP_BOOL_45 1 +# define BOOST_PP_BOOL_46 1 +# define BOOST_PP_BOOL_47 1 +# define BOOST_PP_BOOL_48 1 +# define BOOST_PP_BOOL_49 1 +# define BOOST_PP_BOOL_50 1 +# define BOOST_PP_BOOL_51 1 +# define BOOST_PP_BOOL_52 1 +# define BOOST_PP_BOOL_53 1 +# define BOOST_PP_BOOL_54 1 +# define BOOST_PP_BOOL_55 1 +# define BOOST_PP_BOOL_56 1 +# define BOOST_PP_BOOL_57 1 +# define BOOST_PP_BOOL_58 1 +# define BOOST_PP_BOOL_59 1 +# define BOOST_PP_BOOL_60 1 +# define BOOST_PP_BOOL_61 1 +# define BOOST_PP_BOOL_62 1 +# define BOOST_PP_BOOL_63 1 +# define BOOST_PP_BOOL_64 1 +# define BOOST_PP_BOOL_65 1 +# define BOOST_PP_BOOL_66 1 +# define BOOST_PP_BOOL_67 1 +# define BOOST_PP_BOOL_68 1 +# define BOOST_PP_BOOL_69 1 +# define BOOST_PP_BOOL_70 1 +# define BOOST_PP_BOOL_71 1 +# define BOOST_PP_BOOL_72 1 +# define BOOST_PP_BOOL_73 1 +# define BOOST_PP_BOOL_74 1 +# define BOOST_PP_BOOL_75 1 +# define BOOST_PP_BOOL_76 1 +# define BOOST_PP_BOOL_77 1 +# define BOOST_PP_BOOL_78 1 +# define BOOST_PP_BOOL_79 1 +# define BOOST_PP_BOOL_80 1 +# define BOOST_PP_BOOL_81 1 +# define BOOST_PP_BOOL_82 1 +# define BOOST_PP_BOOL_83 1 +# define BOOST_PP_BOOL_84 1 +# define BOOST_PP_BOOL_85 1 +# define BOOST_PP_BOOL_86 1 +# define BOOST_PP_BOOL_87 1 +# define BOOST_PP_BOOL_88 1 +# define BOOST_PP_BOOL_89 1 +# define BOOST_PP_BOOL_90 1 +# define BOOST_PP_BOOL_91 1 +# define BOOST_PP_BOOL_92 1 +# define BOOST_PP_BOOL_93 1 +# define BOOST_PP_BOOL_94 1 +# define BOOST_PP_BOOL_95 1 +# define BOOST_PP_BOOL_96 1 +# define BOOST_PP_BOOL_97 1 +# define BOOST_PP_BOOL_98 1 +# define BOOST_PP_BOOL_99 1 +# define BOOST_PP_BOOL_100 1 +# define BOOST_PP_BOOL_101 1 +# define BOOST_PP_BOOL_102 1 +# define BOOST_PP_BOOL_103 1 +# define BOOST_PP_BOOL_104 1 +# define BOOST_PP_BOOL_105 1 +# define BOOST_PP_BOOL_106 1 +# define BOOST_PP_BOOL_107 1 +# define BOOST_PP_BOOL_108 1 +# define BOOST_PP_BOOL_109 1 +# define BOOST_PP_BOOL_110 1 +# define BOOST_PP_BOOL_111 1 +# define BOOST_PP_BOOL_112 1 +# define BOOST_PP_BOOL_113 1 +# define BOOST_PP_BOOL_114 1 +# define BOOST_PP_BOOL_115 1 +# define BOOST_PP_BOOL_116 1 +# define BOOST_PP_BOOL_117 1 +# define BOOST_PP_BOOL_118 1 +# define BOOST_PP_BOOL_119 1 +# define BOOST_PP_BOOL_120 1 +# define BOOST_PP_BOOL_121 1 +# define BOOST_PP_BOOL_122 1 +# define BOOST_PP_BOOL_123 1 +# define BOOST_PP_BOOL_124 1 +# define BOOST_PP_BOOL_125 1 +# define BOOST_PP_BOOL_126 1 +# define BOOST_PP_BOOL_127 1 +# define BOOST_PP_BOOL_128 1 +# define BOOST_PP_BOOL_129 1 +# define BOOST_PP_BOOL_130 1 +# define BOOST_PP_BOOL_131 1 +# define BOOST_PP_BOOL_132 1 +# define BOOST_PP_BOOL_133 1 +# define BOOST_PP_BOOL_134 1 +# define BOOST_PP_BOOL_135 1 +# define BOOST_PP_BOOL_136 1 +# define BOOST_PP_BOOL_137 1 +# define BOOST_PP_BOOL_138 1 +# define BOOST_PP_BOOL_139 1 +# define BOOST_PP_BOOL_140 1 +# define BOOST_PP_BOOL_141 1 +# define BOOST_PP_BOOL_142 1 +# define BOOST_PP_BOOL_143 1 +# define BOOST_PP_BOOL_144 1 +# define BOOST_PP_BOOL_145 1 +# define BOOST_PP_BOOL_146 1 +# define BOOST_PP_BOOL_147 1 +# define BOOST_PP_BOOL_148 1 +# define BOOST_PP_BOOL_149 1 +# define BOOST_PP_BOOL_150 1 +# define BOOST_PP_BOOL_151 1 +# define BOOST_PP_BOOL_152 1 +# define BOOST_PP_BOOL_153 1 +# define BOOST_PP_BOOL_154 1 +# define BOOST_PP_BOOL_155 1 +# define BOOST_PP_BOOL_156 1 +# define BOOST_PP_BOOL_157 1 +# define BOOST_PP_BOOL_158 1 +# define BOOST_PP_BOOL_159 1 +# define BOOST_PP_BOOL_160 1 +# define BOOST_PP_BOOL_161 1 +# define BOOST_PP_BOOL_162 1 +# define BOOST_PP_BOOL_163 1 +# define BOOST_PP_BOOL_164 1 +# define BOOST_PP_BOOL_165 1 +# define BOOST_PP_BOOL_166 1 +# define BOOST_PP_BOOL_167 1 +# define BOOST_PP_BOOL_168 1 +# define BOOST_PP_BOOL_169 1 +# define BOOST_PP_BOOL_170 1 +# define BOOST_PP_BOOL_171 1 +# define BOOST_PP_BOOL_172 1 +# define BOOST_PP_BOOL_173 1 +# define BOOST_PP_BOOL_174 1 +# define BOOST_PP_BOOL_175 1 +# define BOOST_PP_BOOL_176 1 +# define BOOST_PP_BOOL_177 1 +# define BOOST_PP_BOOL_178 1 +# define BOOST_PP_BOOL_179 1 +# define BOOST_PP_BOOL_180 1 +# define BOOST_PP_BOOL_181 1 +# define BOOST_PP_BOOL_182 1 +# define BOOST_PP_BOOL_183 1 +# define BOOST_PP_BOOL_184 1 +# define BOOST_PP_BOOL_185 1 +# define BOOST_PP_BOOL_186 1 +# define BOOST_PP_BOOL_187 1 +# define BOOST_PP_BOOL_188 1 +# define BOOST_PP_BOOL_189 1 +# define BOOST_PP_BOOL_190 1 +# define BOOST_PP_BOOL_191 1 +# define BOOST_PP_BOOL_192 1 +# define BOOST_PP_BOOL_193 1 +# define BOOST_PP_BOOL_194 1 +# define BOOST_PP_BOOL_195 1 +# define BOOST_PP_BOOL_196 1 +# define BOOST_PP_BOOL_197 1 +# define BOOST_PP_BOOL_198 1 +# define BOOST_PP_BOOL_199 1 +# define BOOST_PP_BOOL_200 1 +# define BOOST_PP_BOOL_201 1 +# define BOOST_PP_BOOL_202 1 +# define BOOST_PP_BOOL_203 1 +# define BOOST_PP_BOOL_204 1 +# define BOOST_PP_BOOL_205 1 +# define BOOST_PP_BOOL_206 1 +# define BOOST_PP_BOOL_207 1 +# define BOOST_PP_BOOL_208 1 +# define BOOST_PP_BOOL_209 1 +# define BOOST_PP_BOOL_210 1 +# define BOOST_PP_BOOL_211 1 +# define BOOST_PP_BOOL_212 1 +# define BOOST_PP_BOOL_213 1 +# define BOOST_PP_BOOL_214 1 +# define BOOST_PP_BOOL_215 1 +# define BOOST_PP_BOOL_216 1 +# define BOOST_PP_BOOL_217 1 +# define BOOST_PP_BOOL_218 1 +# define BOOST_PP_BOOL_219 1 +# define BOOST_PP_BOOL_220 1 +# define BOOST_PP_BOOL_221 1 +# define BOOST_PP_BOOL_222 1 +# define BOOST_PP_BOOL_223 1 +# define BOOST_PP_BOOL_224 1 +# define BOOST_PP_BOOL_225 1 +# define BOOST_PP_BOOL_226 1 +# define BOOST_PP_BOOL_227 1 +# define BOOST_PP_BOOL_228 1 +# define BOOST_PP_BOOL_229 1 +# define BOOST_PP_BOOL_230 1 +# define BOOST_PP_BOOL_231 1 +# define BOOST_PP_BOOL_232 1 +# define BOOST_PP_BOOL_233 1 +# define BOOST_PP_BOOL_234 1 +# define BOOST_PP_BOOL_235 1 +# define BOOST_PP_BOOL_236 1 +# define BOOST_PP_BOOL_237 1 +# define BOOST_PP_BOOL_238 1 +# define BOOST_PP_BOOL_239 1 +# define BOOST_PP_BOOL_240 1 +# define BOOST_PP_BOOL_241 1 +# define BOOST_PP_BOOL_242 1 +# define BOOST_PP_BOOL_243 1 +# define BOOST_PP_BOOL_244 1 +# define BOOST_PP_BOOL_245 1 +# define BOOST_PP_BOOL_246 1 +# define BOOST_PP_BOOL_247 1 +# define BOOST_PP_BOOL_248 1 +# define BOOST_PP_BOOL_249 1 +# define BOOST_PP_BOOL_250 1 +# define BOOST_PP_BOOL_251 1 +# define BOOST_PP_BOOL_252 1 +# define BOOST_PP_BOOL_253 1 +# define BOOST_PP_BOOL_254 1 +# define BOOST_PP_BOOL_255 1 +# define BOOST_PP_BOOL_256 1 +# +# endif diff --git a/realsense-file/3rd_party/boost/boost/preprocessor/logical/compl.hpp b/realsense-file/3rd_party/boost/boost/preprocessor/logical/compl.hpp new file mode 100644 index 0000000000..751068b4ab --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/preprocessor/logical/compl.hpp @@ -0,0 +1,36 @@ +# /* ************************************************************************** +# * * +# * (C) Copyright Paul Mensonides 2002. +# * Distributed under the Boost Software License, Version 1.0. (See +# * accompanying file LICENSE_1_0.txt or copy at +# * http://www.boost.org/LICENSE_1_0.txt) +# * * +# ************************************************************************** */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_LOGICAL_COMPL_HPP +# define BOOST_PREPROCESSOR_LOGICAL_COMPL_HPP +# +# include +# +# /* BOOST_PP_COMPL */ +# +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() +# define BOOST_PP_COMPL(x) BOOST_PP_COMPL_I(x) +# else +# define BOOST_PP_COMPL(x) BOOST_PP_COMPL_OO((x)) +# define BOOST_PP_COMPL_OO(par) BOOST_PP_COMPL_I ## par +# endif +# +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MSVC() +# define BOOST_PP_COMPL_I(x) BOOST_PP_COMPL_ ## x +# else +# define BOOST_PP_COMPL_I(x) BOOST_PP_COMPL_ID(BOOST_PP_COMPL_ ## x) +# define BOOST_PP_COMPL_ID(id) id +# endif +# +# define BOOST_PP_COMPL_0 1 +# define BOOST_PP_COMPL_1 0 +# +# endif diff --git a/realsense-file/3rd_party/boost/boost/preprocessor/punctuation/comma.hpp b/realsense-file/3rd_party/boost/boost/preprocessor/punctuation/comma.hpp new file mode 100644 index 0000000000..405effd149 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/preprocessor/punctuation/comma.hpp @@ -0,0 +1,21 @@ +# /* Copyright (C) 2001 +# * Housemarque Oy +# * http://www.housemarque.com +# * +# * 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) +# */ +# +# /* Revised by Paul Mensonides (2002) */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_PUNCTUATION_COMMA_HPP +# define BOOST_PREPROCESSOR_PUNCTUATION_COMMA_HPP +# +# /* BOOST_PP_COMMA */ +# +# define BOOST_PP_COMMA() , +# +# endif diff --git a/realsense-file/3rd_party/boost/boost/preprocessor/punctuation/comma_if.hpp b/realsense-file/3rd_party/boost/boost/preprocessor/punctuation/comma_if.hpp new file mode 100644 index 0000000000..d816d41ab3 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/preprocessor/punctuation/comma_if.hpp @@ -0,0 +1,31 @@ +# /* Copyright (C) 2001 +# * Housemarque Oy +# * http://www.housemarque.com +# * +# * 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) +# */ +# +# /* Revised by Paul Mensonides (2002) */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_PUNCTUATION_COMMA_IF_HPP +# define BOOST_PREPROCESSOR_PUNCTUATION_COMMA_IF_HPP +# +# include "../config/config.hpp" +# include "../control/if.hpp" +# include "../facilities/empty.hpp" +# include "comma.hpp" +# +# /* BOOST_PP_COMMA_IF */ +# +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() +# define BOOST_PP_COMMA_IF(cond) BOOST_PP_IF(cond, BOOST_PP_COMMA, BOOST_PP_EMPTY)() +# else +# define BOOST_PP_COMMA_IF(cond) BOOST_PP_COMMA_IF_I(cond) +# define BOOST_PP_COMMA_IF_I(cond) BOOST_PP_IF(cond, BOOST_PP_COMMA, BOOST_PP_EMPTY)() +# endif +# +# endif diff --git a/realsense-file/3rd_party/boost/boost/preprocessor/punctuation/detail/is_begin_parens.hpp b/realsense-file/3rd_party/boost/boost/preprocessor/punctuation/detail/is_begin_parens.hpp new file mode 100644 index 0000000000..5b492cf259 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/preprocessor/punctuation/detail/is_begin_parens.hpp @@ -0,0 +1,48 @@ +# /* ************************************************************************** +# * * +# * (C) Copyright Edward Diener 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) +# * * +# ************************************************************************** */ +# +# /* See http://www.boost.org for most recent version. */ +# +#ifndef BOOST_PREPROCESSOR_DETAIL_IS_BEGIN_PARENS_HPP +#define BOOST_PREPROCESSOR_DETAIL_IS_BEGIN_PARENS_HPP + +#if BOOST_PP_VARIADICS_MSVC + +#include + +#define BOOST_PP_DETAIL_VD_IBP_CAT(a, b) BOOST_PP_DETAIL_VD_IBP_CAT_I(a, b) +#define BOOST_PP_DETAIL_VD_IBP_CAT_I(a, b) BOOST_PP_DETAIL_VD_IBP_CAT_II(a ## b) +#define BOOST_PP_DETAIL_VD_IBP_CAT_II(res) res + +#define BOOST_PP_DETAIL_IBP_SPLIT(i, ...) \ + BOOST_PP_DETAIL_VD_IBP_CAT(BOOST_PP_DETAIL_IBP_PRIMITIVE_CAT(BOOST_PP_DETAIL_IBP_SPLIT_,i)(__VA_ARGS__),BOOST_PP_EMPTY()) \ +/**/ + +#define BOOST_PP_DETAIL_IBP_IS_VARIADIC_C(...) 1 1 + +#else + +#define BOOST_PP_DETAIL_IBP_SPLIT(i, ...) \ + BOOST_PP_DETAIL_IBP_PRIMITIVE_CAT(BOOST_PP_DETAIL_IBP_SPLIT_,i)(__VA_ARGS__) \ +/**/ + +#define BOOST_PP_DETAIL_IBP_IS_VARIADIC_C(...) 1 + +#endif /* BOOST_PP_VARIADICS_MSVC */ + +#define BOOST_PP_DETAIL_IBP_SPLIT_0(a, ...) a +#define BOOST_PP_DETAIL_IBP_SPLIT_1(a, ...) __VA_ARGS__ + +#define BOOST_PP_DETAIL_IBP_CAT(a, ...) BOOST_PP_DETAIL_IBP_PRIMITIVE_CAT(a,__VA_ARGS__) +#define BOOST_PP_DETAIL_IBP_PRIMITIVE_CAT(a, ...) a ## __VA_ARGS__ + +#define BOOST_PP_DETAIL_IBP_IS_VARIADIC_R_1 1, +#define BOOST_PP_DETAIL_IBP_IS_VARIADIC_R_BOOST_PP_DETAIL_IBP_IS_VARIADIC_C 0, + +#endif /* BOOST_PREPROCESSOR_DETAIL_IS_BEGIN_PARENS_HPP */ diff --git a/realsense-file/3rd_party/boost/boost/preprocessor/punctuation/is_begin_parens.hpp b/realsense-file/3rd_party/boost/boost/preprocessor/punctuation/is_begin_parens.hpp new file mode 100644 index 0000000000..8aecc69f35 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/preprocessor/punctuation/is_begin_parens.hpp @@ -0,0 +1,51 @@ +# /* ************************************************************************** +# * * +# * (C) Copyright Edward Diener 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) +# * * +# ************************************************************************** */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_IS_BEGIN_PARENS_HPP +# define BOOST_PREPROCESSOR_IS_BEGIN_PARENS_HPP + +# include + +#if BOOST_PP_VARIADICS + +#include + +#if BOOST_PP_VARIADICS_MSVC && _MSC_VER <= 1400 + +#define BOOST_PP_IS_BEGIN_PARENS(param) \ + BOOST_PP_DETAIL_IBP_SPLIT \ + ( \ + 0, \ + BOOST_PP_DETAIL_IBP_CAT \ + ( \ + BOOST_PP_DETAIL_IBP_IS_VARIADIC_R_, \ + BOOST_PP_DETAIL_IBP_IS_VARIADIC_C param \ + ) \ + ) \ +/**/ + +#else + +#define BOOST_PP_IS_BEGIN_PARENS(...) \ + BOOST_PP_DETAIL_IBP_SPLIT \ + ( \ + 0, \ + BOOST_PP_DETAIL_IBP_CAT \ + ( \ + BOOST_PP_DETAIL_IBP_IS_VARIADIC_R_, \ + BOOST_PP_DETAIL_IBP_IS_VARIADIC_C __VA_ARGS__ \ + ) \ + ) \ +/**/ + +#endif /* BOOST_PP_VARIADICS_MSVC && _MSC_VER <= 1400 */ +#endif /* BOOST_PP_VARIADICS */ +#endif /* BOOST_PREPROCESSOR_IS_BEGIN_PARENS_HPP */ diff --git a/realsense-file/3rd_party/boost/boost/preprocessor/punctuation/paren.hpp b/realsense-file/3rd_party/boost/boost/preprocessor/punctuation/paren.hpp new file mode 100644 index 0000000000..66b25d8a4c --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/preprocessor/punctuation/paren.hpp @@ -0,0 +1,23 @@ +# /* ************************************************************************** +# * * +# * (C) Copyright Paul Mensonides 2002. +# * Distributed under the Boost Software License, Version 1.0. (See +# * accompanying file LICENSE_1_0.txt or copy at +# * http://www.boost.org/LICENSE_1_0.txt) +# * * +# ************************************************************************** */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_PUNCTUATION_PAREN_HPP +# define BOOST_PREPROCESSOR_PUNCTUATION_PAREN_HPP +# +# /* BOOST_PP_LPAREN */ +# +# define BOOST_PP_LPAREN() ( +# +# /* BOOST_PP_RPAREN */ +# +# define BOOST_PP_RPAREN() ) +# +# endif diff --git a/realsense-file/3rd_party/boost/boost/preprocessor/repeat.hpp b/realsense-file/3rd_party/boost/boost/preprocessor/repeat.hpp new file mode 100644 index 0000000000..0893c13850 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/preprocessor/repeat.hpp @@ -0,0 +1,17 @@ +# /* ************************************************************************** +# * * +# * (C) Copyright Paul Mensonides 2002. +# * Distributed under the Boost Software License, Version 1.0. (See +# * accompanying file LICENSE_1_0.txt or copy at +# * http://www.boost.org/LICENSE_1_0.txt) +# * * +# ************************************************************************** */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_REPEAT_HPP +# define BOOST_PREPROCESSOR_REPEAT_HPP +# +# include +# +# endif diff --git a/realsense-file/3rd_party/boost/boost/preprocessor/repetition/detail/msvc/for.hpp b/realsense-file/3rd_party/boost/boost/preprocessor/repetition/detail/msvc/for.hpp new file mode 100644 index 0000000000..5bb179fe9e --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/preprocessor/repetition/detail/msvc/for.hpp @@ -0,0 +1,277 @@ +# /* Copyright (C) 2001 +# * Housemarque Oy +# * http://www.housemarque.com +# * +# * 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) +# */ +# +# /* Revised by Paul Mensonides (2002) */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_REPETITION_DETAIL_MSVC_FOR_HPP +# define BOOST_PREPROCESSOR_REPETITION_DETAIL_MSVC_FOR_HPP +# +# include +# include +# +# define BOOST_PP_FOR_1(s, p, o, m) BOOST_PP_IF(p(2, s), m, BOOST_PP_TUPLE_EAT_2)(2, s) BOOST_PP_IF(p(2, s), BOOST_PP_FOR_2, BOOST_PP_TUPLE_EAT_4)(o(2, s), p, o, m) +# define BOOST_PP_FOR_2(s, p, o, m) BOOST_PP_IF(p(3, s), m, BOOST_PP_TUPLE_EAT_2)(3, s) BOOST_PP_IF(p(3, s), BOOST_PP_FOR_3, BOOST_PP_TUPLE_EAT_4)(o(3, s), p, o, m) +# define BOOST_PP_FOR_3(s, p, o, m) BOOST_PP_IF(p(4, s), m, BOOST_PP_TUPLE_EAT_2)(4, s) BOOST_PP_IF(p(4, s), BOOST_PP_FOR_4, BOOST_PP_TUPLE_EAT_4)(o(4, s), p, o, m) +# define BOOST_PP_FOR_4(s, p, o, m) BOOST_PP_IF(p(5, s), m, BOOST_PP_TUPLE_EAT_2)(5, s) BOOST_PP_IF(p(5, s), BOOST_PP_FOR_5, BOOST_PP_TUPLE_EAT_4)(o(5, s), p, o, m) +# define BOOST_PP_FOR_5(s, p, o, m) BOOST_PP_IF(p(6, s), m, BOOST_PP_TUPLE_EAT_2)(6, s) BOOST_PP_IF(p(6, s), BOOST_PP_FOR_6, BOOST_PP_TUPLE_EAT_4)(o(6, s), p, o, m) +# define BOOST_PP_FOR_6(s, p, o, m) BOOST_PP_IF(p(7, s), m, BOOST_PP_TUPLE_EAT_2)(7, s) BOOST_PP_IF(p(7, s), BOOST_PP_FOR_7, BOOST_PP_TUPLE_EAT_4)(o(7, s), p, o, m) +# define BOOST_PP_FOR_7(s, p, o, m) BOOST_PP_IF(p(8, s), m, BOOST_PP_TUPLE_EAT_2)(8, s) BOOST_PP_IF(p(8, s), BOOST_PP_FOR_8, BOOST_PP_TUPLE_EAT_4)(o(8, s), p, o, m) +# define BOOST_PP_FOR_8(s, p, o, m) BOOST_PP_IF(p(9, s), m, BOOST_PP_TUPLE_EAT_2)(9, s) BOOST_PP_IF(p(9, s), BOOST_PP_FOR_9, BOOST_PP_TUPLE_EAT_4)(o(9, s), p, o, m) +# define BOOST_PP_FOR_9(s, p, o, m) BOOST_PP_IF(p(10, s), m, BOOST_PP_TUPLE_EAT_2)(10, s) BOOST_PP_IF(p(10, s), BOOST_PP_FOR_10, BOOST_PP_TUPLE_EAT_4)(o(10, s), p, o, m) +# define BOOST_PP_FOR_10(s, p, o, m) BOOST_PP_IF(p(11, s), m, BOOST_PP_TUPLE_EAT_2)(11, s) BOOST_PP_IF(p(11, s), BOOST_PP_FOR_11, BOOST_PP_TUPLE_EAT_4)(o(11, s), p, o, m) +# define BOOST_PP_FOR_11(s, p, o, m) BOOST_PP_IF(p(12, s), m, BOOST_PP_TUPLE_EAT_2)(12, s) BOOST_PP_IF(p(12, s), BOOST_PP_FOR_12, BOOST_PP_TUPLE_EAT_4)(o(12, s), p, o, m) +# define BOOST_PP_FOR_12(s, p, o, m) BOOST_PP_IF(p(13, s), m, BOOST_PP_TUPLE_EAT_2)(13, s) BOOST_PP_IF(p(13, s), BOOST_PP_FOR_13, BOOST_PP_TUPLE_EAT_4)(o(13, s), p, o, m) +# define BOOST_PP_FOR_13(s, p, o, m) BOOST_PP_IF(p(14, s), m, BOOST_PP_TUPLE_EAT_2)(14, s) BOOST_PP_IF(p(14, s), BOOST_PP_FOR_14, BOOST_PP_TUPLE_EAT_4)(o(14, s), p, o, m) +# define BOOST_PP_FOR_14(s, p, o, m) BOOST_PP_IF(p(15, s), m, BOOST_PP_TUPLE_EAT_2)(15, s) BOOST_PP_IF(p(15, s), BOOST_PP_FOR_15, BOOST_PP_TUPLE_EAT_4)(o(15, s), p, o, m) +# define BOOST_PP_FOR_15(s, p, o, m) BOOST_PP_IF(p(16, s), m, BOOST_PP_TUPLE_EAT_2)(16, s) BOOST_PP_IF(p(16, s), BOOST_PP_FOR_16, BOOST_PP_TUPLE_EAT_4)(o(16, s), p, o, m) +# define BOOST_PP_FOR_16(s, p, o, m) BOOST_PP_IF(p(17, s), m, BOOST_PP_TUPLE_EAT_2)(17, s) BOOST_PP_IF(p(17, s), BOOST_PP_FOR_17, BOOST_PP_TUPLE_EAT_4)(o(17, s), p, o, m) +# define BOOST_PP_FOR_17(s, p, o, m) BOOST_PP_IF(p(18, s), m, BOOST_PP_TUPLE_EAT_2)(18, s) BOOST_PP_IF(p(18, s), BOOST_PP_FOR_18, BOOST_PP_TUPLE_EAT_4)(o(18, s), p, o, m) +# define BOOST_PP_FOR_18(s, p, o, m) BOOST_PP_IF(p(19, s), m, BOOST_PP_TUPLE_EAT_2)(19, s) BOOST_PP_IF(p(19, s), BOOST_PP_FOR_19, BOOST_PP_TUPLE_EAT_4)(o(19, s), p, o, m) +# define BOOST_PP_FOR_19(s, p, o, m) BOOST_PP_IF(p(20, s), m, BOOST_PP_TUPLE_EAT_2)(20, s) BOOST_PP_IF(p(20, s), BOOST_PP_FOR_20, BOOST_PP_TUPLE_EAT_4)(o(20, s), p, o, m) +# define BOOST_PP_FOR_20(s, p, o, m) BOOST_PP_IF(p(21, s), m, BOOST_PP_TUPLE_EAT_2)(21, s) BOOST_PP_IF(p(21, s), BOOST_PP_FOR_21, BOOST_PP_TUPLE_EAT_4)(o(21, s), p, o, m) +# define BOOST_PP_FOR_21(s, p, o, m) BOOST_PP_IF(p(22, s), m, BOOST_PP_TUPLE_EAT_2)(22, s) BOOST_PP_IF(p(22, s), BOOST_PP_FOR_22, BOOST_PP_TUPLE_EAT_4)(o(22, s), p, o, m) +# define BOOST_PP_FOR_22(s, p, o, m) BOOST_PP_IF(p(23, s), m, BOOST_PP_TUPLE_EAT_2)(23, s) BOOST_PP_IF(p(23, s), BOOST_PP_FOR_23, BOOST_PP_TUPLE_EAT_4)(o(23, s), p, o, m) +# define BOOST_PP_FOR_23(s, p, o, m) BOOST_PP_IF(p(24, s), m, BOOST_PP_TUPLE_EAT_2)(24, s) BOOST_PP_IF(p(24, s), BOOST_PP_FOR_24, BOOST_PP_TUPLE_EAT_4)(o(24, s), p, o, m) +# define BOOST_PP_FOR_24(s, p, o, m) BOOST_PP_IF(p(25, s), m, BOOST_PP_TUPLE_EAT_2)(25, s) BOOST_PP_IF(p(25, s), BOOST_PP_FOR_25, BOOST_PP_TUPLE_EAT_4)(o(25, s), p, o, m) +# define BOOST_PP_FOR_25(s, p, o, m) BOOST_PP_IF(p(26, s), m, BOOST_PP_TUPLE_EAT_2)(26, s) BOOST_PP_IF(p(26, s), BOOST_PP_FOR_26, BOOST_PP_TUPLE_EAT_4)(o(26, s), p, o, m) +# define BOOST_PP_FOR_26(s, p, o, m) BOOST_PP_IF(p(27, s), m, BOOST_PP_TUPLE_EAT_2)(27, s) BOOST_PP_IF(p(27, s), BOOST_PP_FOR_27, BOOST_PP_TUPLE_EAT_4)(o(27, s), p, o, m) +# define BOOST_PP_FOR_27(s, p, o, m) BOOST_PP_IF(p(28, s), m, BOOST_PP_TUPLE_EAT_2)(28, s) BOOST_PP_IF(p(28, s), BOOST_PP_FOR_28, BOOST_PP_TUPLE_EAT_4)(o(28, s), p, o, m) +# define BOOST_PP_FOR_28(s, p, o, m) BOOST_PP_IF(p(29, s), m, BOOST_PP_TUPLE_EAT_2)(29, s) BOOST_PP_IF(p(29, s), BOOST_PP_FOR_29, BOOST_PP_TUPLE_EAT_4)(o(29, s), p, o, m) +# define BOOST_PP_FOR_29(s, p, o, m) BOOST_PP_IF(p(30, s), m, BOOST_PP_TUPLE_EAT_2)(30, s) BOOST_PP_IF(p(30, s), BOOST_PP_FOR_30, BOOST_PP_TUPLE_EAT_4)(o(30, s), p, o, m) +# define BOOST_PP_FOR_30(s, p, o, m) BOOST_PP_IF(p(31, s), m, BOOST_PP_TUPLE_EAT_2)(31, s) BOOST_PP_IF(p(31, s), BOOST_PP_FOR_31, BOOST_PP_TUPLE_EAT_4)(o(31, s), p, o, m) +# define BOOST_PP_FOR_31(s, p, o, m) BOOST_PP_IF(p(32, s), m, BOOST_PP_TUPLE_EAT_2)(32, s) BOOST_PP_IF(p(32, s), BOOST_PP_FOR_32, BOOST_PP_TUPLE_EAT_4)(o(32, s), p, o, m) +# define BOOST_PP_FOR_32(s, p, o, m) BOOST_PP_IF(p(33, s), m, BOOST_PP_TUPLE_EAT_2)(33, s) BOOST_PP_IF(p(33, s), BOOST_PP_FOR_33, BOOST_PP_TUPLE_EAT_4)(o(33, s), p, o, m) +# define BOOST_PP_FOR_33(s, p, o, m) BOOST_PP_IF(p(34, s), m, BOOST_PP_TUPLE_EAT_2)(34, s) BOOST_PP_IF(p(34, s), BOOST_PP_FOR_34, BOOST_PP_TUPLE_EAT_4)(o(34, s), p, o, m) +# define BOOST_PP_FOR_34(s, p, o, m) BOOST_PP_IF(p(35, s), m, BOOST_PP_TUPLE_EAT_2)(35, s) BOOST_PP_IF(p(35, s), BOOST_PP_FOR_35, BOOST_PP_TUPLE_EAT_4)(o(35, s), p, o, m) +# define BOOST_PP_FOR_35(s, p, o, m) BOOST_PP_IF(p(36, s), m, BOOST_PP_TUPLE_EAT_2)(36, s) BOOST_PP_IF(p(36, s), BOOST_PP_FOR_36, BOOST_PP_TUPLE_EAT_4)(o(36, s), p, o, m) +# define BOOST_PP_FOR_36(s, p, o, m) BOOST_PP_IF(p(37, s), m, BOOST_PP_TUPLE_EAT_2)(37, s) BOOST_PP_IF(p(37, s), BOOST_PP_FOR_37, BOOST_PP_TUPLE_EAT_4)(o(37, s), p, o, m) +# define BOOST_PP_FOR_37(s, p, o, m) BOOST_PP_IF(p(38, s), m, BOOST_PP_TUPLE_EAT_2)(38, s) BOOST_PP_IF(p(38, s), BOOST_PP_FOR_38, BOOST_PP_TUPLE_EAT_4)(o(38, s), p, o, m) +# define BOOST_PP_FOR_38(s, p, o, m) BOOST_PP_IF(p(39, s), m, BOOST_PP_TUPLE_EAT_2)(39, s) BOOST_PP_IF(p(39, s), BOOST_PP_FOR_39, BOOST_PP_TUPLE_EAT_4)(o(39, s), p, o, m) +# define BOOST_PP_FOR_39(s, p, o, m) BOOST_PP_IF(p(40, s), m, BOOST_PP_TUPLE_EAT_2)(40, s) BOOST_PP_IF(p(40, s), BOOST_PP_FOR_40, BOOST_PP_TUPLE_EAT_4)(o(40, s), p, o, m) +# define BOOST_PP_FOR_40(s, p, o, m) BOOST_PP_IF(p(41, s), m, BOOST_PP_TUPLE_EAT_2)(41, s) BOOST_PP_IF(p(41, s), BOOST_PP_FOR_41, BOOST_PP_TUPLE_EAT_4)(o(41, s), p, o, m) +# define BOOST_PP_FOR_41(s, p, o, m) BOOST_PP_IF(p(42, s), m, BOOST_PP_TUPLE_EAT_2)(42, s) BOOST_PP_IF(p(42, s), BOOST_PP_FOR_42, BOOST_PP_TUPLE_EAT_4)(o(42, s), p, o, m) +# define BOOST_PP_FOR_42(s, p, o, m) BOOST_PP_IF(p(43, s), m, BOOST_PP_TUPLE_EAT_2)(43, s) BOOST_PP_IF(p(43, s), BOOST_PP_FOR_43, BOOST_PP_TUPLE_EAT_4)(o(43, s), p, o, m) +# define BOOST_PP_FOR_43(s, p, o, m) BOOST_PP_IF(p(44, s), m, BOOST_PP_TUPLE_EAT_2)(44, s) BOOST_PP_IF(p(44, s), BOOST_PP_FOR_44, BOOST_PP_TUPLE_EAT_4)(o(44, s), p, o, m) +# define BOOST_PP_FOR_44(s, p, o, m) BOOST_PP_IF(p(45, s), m, BOOST_PP_TUPLE_EAT_2)(45, s) BOOST_PP_IF(p(45, s), BOOST_PP_FOR_45, BOOST_PP_TUPLE_EAT_4)(o(45, s), p, o, m) +# define BOOST_PP_FOR_45(s, p, o, m) BOOST_PP_IF(p(46, s), m, BOOST_PP_TUPLE_EAT_2)(46, s) BOOST_PP_IF(p(46, s), BOOST_PP_FOR_46, BOOST_PP_TUPLE_EAT_4)(o(46, s), p, o, m) +# define BOOST_PP_FOR_46(s, p, o, m) BOOST_PP_IF(p(47, s), m, BOOST_PP_TUPLE_EAT_2)(47, s) BOOST_PP_IF(p(47, s), BOOST_PP_FOR_47, BOOST_PP_TUPLE_EAT_4)(o(47, s), p, o, m) +# define BOOST_PP_FOR_47(s, p, o, m) BOOST_PP_IF(p(48, s), m, BOOST_PP_TUPLE_EAT_2)(48, s) BOOST_PP_IF(p(48, s), BOOST_PP_FOR_48, BOOST_PP_TUPLE_EAT_4)(o(48, s), p, o, m) +# define BOOST_PP_FOR_48(s, p, o, m) BOOST_PP_IF(p(49, s), m, BOOST_PP_TUPLE_EAT_2)(49, s) BOOST_PP_IF(p(49, s), BOOST_PP_FOR_49, BOOST_PP_TUPLE_EAT_4)(o(49, s), p, o, m) +# define BOOST_PP_FOR_49(s, p, o, m) BOOST_PP_IF(p(50, s), m, BOOST_PP_TUPLE_EAT_2)(50, s) BOOST_PP_IF(p(50, s), BOOST_PP_FOR_50, BOOST_PP_TUPLE_EAT_4)(o(50, s), p, o, m) +# define BOOST_PP_FOR_50(s, p, o, m) BOOST_PP_IF(p(51, s), m, BOOST_PP_TUPLE_EAT_2)(51, s) BOOST_PP_IF(p(51, s), BOOST_PP_FOR_51, BOOST_PP_TUPLE_EAT_4)(o(51, s), p, o, m) +# define BOOST_PP_FOR_51(s, p, o, m) BOOST_PP_IF(p(52, s), m, BOOST_PP_TUPLE_EAT_2)(52, s) BOOST_PP_IF(p(52, s), BOOST_PP_FOR_52, BOOST_PP_TUPLE_EAT_4)(o(52, s), p, o, m) +# define BOOST_PP_FOR_52(s, p, o, m) BOOST_PP_IF(p(53, s), m, BOOST_PP_TUPLE_EAT_2)(53, s) BOOST_PP_IF(p(53, s), BOOST_PP_FOR_53, BOOST_PP_TUPLE_EAT_4)(o(53, s), p, o, m) +# define BOOST_PP_FOR_53(s, p, o, m) BOOST_PP_IF(p(54, s), m, BOOST_PP_TUPLE_EAT_2)(54, s) BOOST_PP_IF(p(54, s), BOOST_PP_FOR_54, BOOST_PP_TUPLE_EAT_4)(o(54, s), p, o, m) +# define BOOST_PP_FOR_54(s, p, o, m) BOOST_PP_IF(p(55, s), m, BOOST_PP_TUPLE_EAT_2)(55, s) BOOST_PP_IF(p(55, s), BOOST_PP_FOR_55, BOOST_PP_TUPLE_EAT_4)(o(55, s), p, o, m) +# define BOOST_PP_FOR_55(s, p, o, m) BOOST_PP_IF(p(56, s), m, BOOST_PP_TUPLE_EAT_2)(56, s) BOOST_PP_IF(p(56, s), BOOST_PP_FOR_56, BOOST_PP_TUPLE_EAT_4)(o(56, s), p, o, m) +# define BOOST_PP_FOR_56(s, p, o, m) BOOST_PP_IF(p(57, s), m, BOOST_PP_TUPLE_EAT_2)(57, s) BOOST_PP_IF(p(57, s), BOOST_PP_FOR_57, BOOST_PP_TUPLE_EAT_4)(o(57, s), p, o, m) +# define BOOST_PP_FOR_57(s, p, o, m) BOOST_PP_IF(p(58, s), m, BOOST_PP_TUPLE_EAT_2)(58, s) BOOST_PP_IF(p(58, s), BOOST_PP_FOR_58, BOOST_PP_TUPLE_EAT_4)(o(58, s), p, o, m) +# define BOOST_PP_FOR_58(s, p, o, m) BOOST_PP_IF(p(59, s), m, BOOST_PP_TUPLE_EAT_2)(59, s) BOOST_PP_IF(p(59, s), BOOST_PP_FOR_59, BOOST_PP_TUPLE_EAT_4)(o(59, s), p, o, m) +# define BOOST_PP_FOR_59(s, p, o, m) BOOST_PP_IF(p(60, s), m, BOOST_PP_TUPLE_EAT_2)(60, s) BOOST_PP_IF(p(60, s), BOOST_PP_FOR_60, BOOST_PP_TUPLE_EAT_4)(o(60, s), p, o, m) +# define BOOST_PP_FOR_60(s, p, o, m) BOOST_PP_IF(p(61, s), m, BOOST_PP_TUPLE_EAT_2)(61, s) BOOST_PP_IF(p(61, s), BOOST_PP_FOR_61, BOOST_PP_TUPLE_EAT_4)(o(61, s), p, o, m) +# define BOOST_PP_FOR_61(s, p, o, m) BOOST_PP_IF(p(62, s), m, BOOST_PP_TUPLE_EAT_2)(62, s) BOOST_PP_IF(p(62, s), BOOST_PP_FOR_62, BOOST_PP_TUPLE_EAT_4)(o(62, s), p, o, m) +# define BOOST_PP_FOR_62(s, p, o, m) BOOST_PP_IF(p(63, s), m, BOOST_PP_TUPLE_EAT_2)(63, s) BOOST_PP_IF(p(63, s), BOOST_PP_FOR_63, BOOST_PP_TUPLE_EAT_4)(o(63, s), p, o, m) +# define BOOST_PP_FOR_63(s, p, o, m) BOOST_PP_IF(p(64, s), m, BOOST_PP_TUPLE_EAT_2)(64, s) BOOST_PP_IF(p(64, s), BOOST_PP_FOR_64, BOOST_PP_TUPLE_EAT_4)(o(64, s), p, o, m) +# define BOOST_PP_FOR_64(s, p, o, m) BOOST_PP_IF(p(65, s), m, BOOST_PP_TUPLE_EAT_2)(65, s) BOOST_PP_IF(p(65, s), BOOST_PP_FOR_65, BOOST_PP_TUPLE_EAT_4)(o(65, s), p, o, m) +# define BOOST_PP_FOR_65(s, p, o, m) BOOST_PP_IF(p(66, s), m, BOOST_PP_TUPLE_EAT_2)(66, s) BOOST_PP_IF(p(66, s), BOOST_PP_FOR_66, BOOST_PP_TUPLE_EAT_4)(o(66, s), p, o, m) +# define BOOST_PP_FOR_66(s, p, o, m) BOOST_PP_IF(p(67, s), m, BOOST_PP_TUPLE_EAT_2)(67, s) BOOST_PP_IF(p(67, s), BOOST_PP_FOR_67, BOOST_PP_TUPLE_EAT_4)(o(67, s), p, o, m) +# define BOOST_PP_FOR_67(s, p, o, m) BOOST_PP_IF(p(68, s), m, BOOST_PP_TUPLE_EAT_2)(68, s) BOOST_PP_IF(p(68, s), BOOST_PP_FOR_68, BOOST_PP_TUPLE_EAT_4)(o(68, s), p, o, m) +# define BOOST_PP_FOR_68(s, p, o, m) BOOST_PP_IF(p(69, s), m, BOOST_PP_TUPLE_EAT_2)(69, s) BOOST_PP_IF(p(69, s), BOOST_PP_FOR_69, BOOST_PP_TUPLE_EAT_4)(o(69, s), p, o, m) +# define BOOST_PP_FOR_69(s, p, o, m) BOOST_PP_IF(p(70, s), m, BOOST_PP_TUPLE_EAT_2)(70, s) BOOST_PP_IF(p(70, s), BOOST_PP_FOR_70, BOOST_PP_TUPLE_EAT_4)(o(70, s), p, o, m) +# define BOOST_PP_FOR_70(s, p, o, m) BOOST_PP_IF(p(71, s), m, BOOST_PP_TUPLE_EAT_2)(71, s) BOOST_PP_IF(p(71, s), BOOST_PP_FOR_71, BOOST_PP_TUPLE_EAT_4)(o(71, s), p, o, m) +# define BOOST_PP_FOR_71(s, p, o, m) BOOST_PP_IF(p(72, s), m, BOOST_PP_TUPLE_EAT_2)(72, s) BOOST_PP_IF(p(72, s), BOOST_PP_FOR_72, BOOST_PP_TUPLE_EAT_4)(o(72, s), p, o, m) +# define BOOST_PP_FOR_72(s, p, o, m) BOOST_PP_IF(p(73, s), m, BOOST_PP_TUPLE_EAT_2)(73, s) BOOST_PP_IF(p(73, s), BOOST_PP_FOR_73, BOOST_PP_TUPLE_EAT_4)(o(73, s), p, o, m) +# define BOOST_PP_FOR_73(s, p, o, m) BOOST_PP_IF(p(74, s), m, BOOST_PP_TUPLE_EAT_2)(74, s) BOOST_PP_IF(p(74, s), BOOST_PP_FOR_74, BOOST_PP_TUPLE_EAT_4)(o(74, s), p, o, m) +# define BOOST_PP_FOR_74(s, p, o, m) BOOST_PP_IF(p(75, s), m, BOOST_PP_TUPLE_EAT_2)(75, s) BOOST_PP_IF(p(75, s), BOOST_PP_FOR_75, BOOST_PP_TUPLE_EAT_4)(o(75, s), p, o, m) +# define BOOST_PP_FOR_75(s, p, o, m) BOOST_PP_IF(p(76, s), m, BOOST_PP_TUPLE_EAT_2)(76, s) BOOST_PP_IF(p(76, s), BOOST_PP_FOR_76, BOOST_PP_TUPLE_EAT_4)(o(76, s), p, o, m) +# define BOOST_PP_FOR_76(s, p, o, m) BOOST_PP_IF(p(77, s), m, BOOST_PP_TUPLE_EAT_2)(77, s) BOOST_PP_IF(p(77, s), BOOST_PP_FOR_77, BOOST_PP_TUPLE_EAT_4)(o(77, s), p, o, m) +# define BOOST_PP_FOR_77(s, p, o, m) BOOST_PP_IF(p(78, s), m, BOOST_PP_TUPLE_EAT_2)(78, s) BOOST_PP_IF(p(78, s), BOOST_PP_FOR_78, BOOST_PP_TUPLE_EAT_4)(o(78, s), p, o, m) +# define BOOST_PP_FOR_78(s, p, o, m) BOOST_PP_IF(p(79, s), m, BOOST_PP_TUPLE_EAT_2)(79, s) BOOST_PP_IF(p(79, s), BOOST_PP_FOR_79, BOOST_PP_TUPLE_EAT_4)(o(79, s), p, o, m) +# define BOOST_PP_FOR_79(s, p, o, m) BOOST_PP_IF(p(80, s), m, BOOST_PP_TUPLE_EAT_2)(80, s) BOOST_PP_IF(p(80, s), BOOST_PP_FOR_80, BOOST_PP_TUPLE_EAT_4)(o(80, s), p, o, m) +# define BOOST_PP_FOR_80(s, p, o, m) BOOST_PP_IF(p(81, s), m, BOOST_PP_TUPLE_EAT_2)(81, s) BOOST_PP_IF(p(81, s), BOOST_PP_FOR_81, BOOST_PP_TUPLE_EAT_4)(o(81, s), p, o, m) +# define BOOST_PP_FOR_81(s, p, o, m) BOOST_PP_IF(p(82, s), m, BOOST_PP_TUPLE_EAT_2)(82, s) BOOST_PP_IF(p(82, s), BOOST_PP_FOR_82, BOOST_PP_TUPLE_EAT_4)(o(82, s), p, o, m) +# define BOOST_PP_FOR_82(s, p, o, m) BOOST_PP_IF(p(83, s), m, BOOST_PP_TUPLE_EAT_2)(83, s) BOOST_PP_IF(p(83, s), BOOST_PP_FOR_83, BOOST_PP_TUPLE_EAT_4)(o(83, s), p, o, m) +# define BOOST_PP_FOR_83(s, p, o, m) BOOST_PP_IF(p(84, s), m, BOOST_PP_TUPLE_EAT_2)(84, s) BOOST_PP_IF(p(84, s), BOOST_PP_FOR_84, BOOST_PP_TUPLE_EAT_4)(o(84, s), p, o, m) +# define BOOST_PP_FOR_84(s, p, o, m) BOOST_PP_IF(p(85, s), m, BOOST_PP_TUPLE_EAT_2)(85, s) BOOST_PP_IF(p(85, s), BOOST_PP_FOR_85, BOOST_PP_TUPLE_EAT_4)(o(85, s), p, o, m) +# define BOOST_PP_FOR_85(s, p, o, m) BOOST_PP_IF(p(86, s), m, BOOST_PP_TUPLE_EAT_2)(86, s) BOOST_PP_IF(p(86, s), BOOST_PP_FOR_86, BOOST_PP_TUPLE_EAT_4)(o(86, s), p, o, m) +# define BOOST_PP_FOR_86(s, p, o, m) BOOST_PP_IF(p(87, s), m, BOOST_PP_TUPLE_EAT_2)(87, s) BOOST_PP_IF(p(87, s), BOOST_PP_FOR_87, BOOST_PP_TUPLE_EAT_4)(o(87, s), p, o, m) +# define BOOST_PP_FOR_87(s, p, o, m) BOOST_PP_IF(p(88, s), m, BOOST_PP_TUPLE_EAT_2)(88, s) BOOST_PP_IF(p(88, s), BOOST_PP_FOR_88, BOOST_PP_TUPLE_EAT_4)(o(88, s), p, o, m) +# define BOOST_PP_FOR_88(s, p, o, m) BOOST_PP_IF(p(89, s), m, BOOST_PP_TUPLE_EAT_2)(89, s) BOOST_PP_IF(p(89, s), BOOST_PP_FOR_89, BOOST_PP_TUPLE_EAT_4)(o(89, s), p, o, m) +# define BOOST_PP_FOR_89(s, p, o, m) BOOST_PP_IF(p(90, s), m, BOOST_PP_TUPLE_EAT_2)(90, s) BOOST_PP_IF(p(90, s), BOOST_PP_FOR_90, BOOST_PP_TUPLE_EAT_4)(o(90, s), p, o, m) +# define BOOST_PP_FOR_90(s, p, o, m) BOOST_PP_IF(p(91, s), m, BOOST_PP_TUPLE_EAT_2)(91, s) BOOST_PP_IF(p(91, s), BOOST_PP_FOR_91, BOOST_PP_TUPLE_EAT_4)(o(91, s), p, o, m) +# define BOOST_PP_FOR_91(s, p, o, m) BOOST_PP_IF(p(92, s), m, BOOST_PP_TUPLE_EAT_2)(92, s) BOOST_PP_IF(p(92, s), BOOST_PP_FOR_92, BOOST_PP_TUPLE_EAT_4)(o(92, s), p, o, m) +# define BOOST_PP_FOR_92(s, p, o, m) BOOST_PP_IF(p(93, s), m, BOOST_PP_TUPLE_EAT_2)(93, s) BOOST_PP_IF(p(93, s), BOOST_PP_FOR_93, BOOST_PP_TUPLE_EAT_4)(o(93, s), p, o, m) +# define BOOST_PP_FOR_93(s, p, o, m) BOOST_PP_IF(p(94, s), m, BOOST_PP_TUPLE_EAT_2)(94, s) BOOST_PP_IF(p(94, s), BOOST_PP_FOR_94, BOOST_PP_TUPLE_EAT_4)(o(94, s), p, o, m) +# define BOOST_PP_FOR_94(s, p, o, m) BOOST_PP_IF(p(95, s), m, BOOST_PP_TUPLE_EAT_2)(95, s) BOOST_PP_IF(p(95, s), BOOST_PP_FOR_95, BOOST_PP_TUPLE_EAT_4)(o(95, s), p, o, m) +# define BOOST_PP_FOR_95(s, p, o, m) BOOST_PP_IF(p(96, s), m, BOOST_PP_TUPLE_EAT_2)(96, s) BOOST_PP_IF(p(96, s), BOOST_PP_FOR_96, BOOST_PP_TUPLE_EAT_4)(o(96, s), p, o, m) +# define BOOST_PP_FOR_96(s, p, o, m) BOOST_PP_IF(p(97, s), m, BOOST_PP_TUPLE_EAT_2)(97, s) BOOST_PP_IF(p(97, s), BOOST_PP_FOR_97, BOOST_PP_TUPLE_EAT_4)(o(97, s), p, o, m) +# define BOOST_PP_FOR_97(s, p, o, m) BOOST_PP_IF(p(98, s), m, BOOST_PP_TUPLE_EAT_2)(98, s) BOOST_PP_IF(p(98, s), BOOST_PP_FOR_98, BOOST_PP_TUPLE_EAT_4)(o(98, s), p, o, m) +# define BOOST_PP_FOR_98(s, p, o, m) BOOST_PP_IF(p(99, s), m, BOOST_PP_TUPLE_EAT_2)(99, s) BOOST_PP_IF(p(99, s), BOOST_PP_FOR_99, BOOST_PP_TUPLE_EAT_4)(o(99, s), p, o, m) +# define BOOST_PP_FOR_99(s, p, o, m) BOOST_PP_IF(p(100, s), m, BOOST_PP_TUPLE_EAT_2)(100, s) BOOST_PP_IF(p(100, s), BOOST_PP_FOR_100, BOOST_PP_TUPLE_EAT_4)(o(100, s), p, o, m) +# define BOOST_PP_FOR_100(s, p, o, m) BOOST_PP_IF(p(101, s), m, BOOST_PP_TUPLE_EAT_2)(101, s) BOOST_PP_IF(p(101, s), BOOST_PP_FOR_101, BOOST_PP_TUPLE_EAT_4)(o(101, s), p, o, m) +# define BOOST_PP_FOR_101(s, p, o, m) BOOST_PP_IF(p(102, s), m, BOOST_PP_TUPLE_EAT_2)(102, s) BOOST_PP_IF(p(102, s), BOOST_PP_FOR_102, BOOST_PP_TUPLE_EAT_4)(o(102, s), p, o, m) +# define BOOST_PP_FOR_102(s, p, o, m) BOOST_PP_IF(p(103, s), m, BOOST_PP_TUPLE_EAT_2)(103, s) BOOST_PP_IF(p(103, s), BOOST_PP_FOR_103, BOOST_PP_TUPLE_EAT_4)(o(103, s), p, o, m) +# define BOOST_PP_FOR_103(s, p, o, m) BOOST_PP_IF(p(104, s), m, BOOST_PP_TUPLE_EAT_2)(104, s) BOOST_PP_IF(p(104, s), BOOST_PP_FOR_104, BOOST_PP_TUPLE_EAT_4)(o(104, s), p, o, m) +# define BOOST_PP_FOR_104(s, p, o, m) BOOST_PP_IF(p(105, s), m, BOOST_PP_TUPLE_EAT_2)(105, s) BOOST_PP_IF(p(105, s), BOOST_PP_FOR_105, BOOST_PP_TUPLE_EAT_4)(o(105, s), p, o, m) +# define BOOST_PP_FOR_105(s, p, o, m) BOOST_PP_IF(p(106, s), m, BOOST_PP_TUPLE_EAT_2)(106, s) BOOST_PP_IF(p(106, s), BOOST_PP_FOR_106, BOOST_PP_TUPLE_EAT_4)(o(106, s), p, o, m) +# define BOOST_PP_FOR_106(s, p, o, m) BOOST_PP_IF(p(107, s), m, BOOST_PP_TUPLE_EAT_2)(107, s) BOOST_PP_IF(p(107, s), BOOST_PP_FOR_107, BOOST_PP_TUPLE_EAT_4)(o(107, s), p, o, m) +# define BOOST_PP_FOR_107(s, p, o, m) BOOST_PP_IF(p(108, s), m, BOOST_PP_TUPLE_EAT_2)(108, s) BOOST_PP_IF(p(108, s), BOOST_PP_FOR_108, BOOST_PP_TUPLE_EAT_4)(o(108, s), p, o, m) +# define BOOST_PP_FOR_108(s, p, o, m) BOOST_PP_IF(p(109, s), m, BOOST_PP_TUPLE_EAT_2)(109, s) BOOST_PP_IF(p(109, s), BOOST_PP_FOR_109, BOOST_PP_TUPLE_EAT_4)(o(109, s), p, o, m) +# define BOOST_PP_FOR_109(s, p, o, m) BOOST_PP_IF(p(110, s), m, BOOST_PP_TUPLE_EAT_2)(110, s) BOOST_PP_IF(p(110, s), BOOST_PP_FOR_110, BOOST_PP_TUPLE_EAT_4)(o(110, s), p, o, m) +# define BOOST_PP_FOR_110(s, p, o, m) BOOST_PP_IF(p(111, s), m, BOOST_PP_TUPLE_EAT_2)(111, s) BOOST_PP_IF(p(111, s), BOOST_PP_FOR_111, BOOST_PP_TUPLE_EAT_4)(o(111, s), p, o, m) +# define BOOST_PP_FOR_111(s, p, o, m) BOOST_PP_IF(p(112, s), m, BOOST_PP_TUPLE_EAT_2)(112, s) BOOST_PP_IF(p(112, s), BOOST_PP_FOR_112, BOOST_PP_TUPLE_EAT_4)(o(112, s), p, o, m) +# define BOOST_PP_FOR_112(s, p, o, m) BOOST_PP_IF(p(113, s), m, BOOST_PP_TUPLE_EAT_2)(113, s) BOOST_PP_IF(p(113, s), BOOST_PP_FOR_113, BOOST_PP_TUPLE_EAT_4)(o(113, s), p, o, m) +# define BOOST_PP_FOR_113(s, p, o, m) BOOST_PP_IF(p(114, s), m, BOOST_PP_TUPLE_EAT_2)(114, s) BOOST_PP_IF(p(114, s), BOOST_PP_FOR_114, BOOST_PP_TUPLE_EAT_4)(o(114, s), p, o, m) +# define BOOST_PP_FOR_114(s, p, o, m) BOOST_PP_IF(p(115, s), m, BOOST_PP_TUPLE_EAT_2)(115, s) BOOST_PP_IF(p(115, s), BOOST_PP_FOR_115, BOOST_PP_TUPLE_EAT_4)(o(115, s), p, o, m) +# define BOOST_PP_FOR_115(s, p, o, m) BOOST_PP_IF(p(116, s), m, BOOST_PP_TUPLE_EAT_2)(116, s) BOOST_PP_IF(p(116, s), BOOST_PP_FOR_116, BOOST_PP_TUPLE_EAT_4)(o(116, s), p, o, m) +# define BOOST_PP_FOR_116(s, p, o, m) BOOST_PP_IF(p(117, s), m, BOOST_PP_TUPLE_EAT_2)(117, s) BOOST_PP_IF(p(117, s), BOOST_PP_FOR_117, BOOST_PP_TUPLE_EAT_4)(o(117, s), p, o, m) +# define BOOST_PP_FOR_117(s, p, o, m) BOOST_PP_IF(p(118, s), m, BOOST_PP_TUPLE_EAT_2)(118, s) BOOST_PP_IF(p(118, s), BOOST_PP_FOR_118, BOOST_PP_TUPLE_EAT_4)(o(118, s), p, o, m) +# define BOOST_PP_FOR_118(s, p, o, m) BOOST_PP_IF(p(119, s), m, BOOST_PP_TUPLE_EAT_2)(119, s) BOOST_PP_IF(p(119, s), BOOST_PP_FOR_119, BOOST_PP_TUPLE_EAT_4)(o(119, s), p, o, m) +# define BOOST_PP_FOR_119(s, p, o, m) BOOST_PP_IF(p(120, s), m, BOOST_PP_TUPLE_EAT_2)(120, s) BOOST_PP_IF(p(120, s), BOOST_PP_FOR_120, BOOST_PP_TUPLE_EAT_4)(o(120, s), p, o, m) +# define BOOST_PP_FOR_120(s, p, o, m) BOOST_PP_IF(p(121, s), m, BOOST_PP_TUPLE_EAT_2)(121, s) BOOST_PP_IF(p(121, s), BOOST_PP_FOR_121, BOOST_PP_TUPLE_EAT_4)(o(121, s), p, o, m) +# define BOOST_PP_FOR_121(s, p, o, m) BOOST_PP_IF(p(122, s), m, BOOST_PP_TUPLE_EAT_2)(122, s) BOOST_PP_IF(p(122, s), BOOST_PP_FOR_122, BOOST_PP_TUPLE_EAT_4)(o(122, s), p, o, m) +# define BOOST_PP_FOR_122(s, p, o, m) BOOST_PP_IF(p(123, s), m, BOOST_PP_TUPLE_EAT_2)(123, s) BOOST_PP_IF(p(123, s), BOOST_PP_FOR_123, BOOST_PP_TUPLE_EAT_4)(o(123, s), p, o, m) +# define BOOST_PP_FOR_123(s, p, o, m) BOOST_PP_IF(p(124, s), m, BOOST_PP_TUPLE_EAT_2)(124, s) BOOST_PP_IF(p(124, s), BOOST_PP_FOR_124, BOOST_PP_TUPLE_EAT_4)(o(124, s), p, o, m) +# define BOOST_PP_FOR_124(s, p, o, m) BOOST_PP_IF(p(125, s), m, BOOST_PP_TUPLE_EAT_2)(125, s) BOOST_PP_IF(p(125, s), BOOST_PP_FOR_125, BOOST_PP_TUPLE_EAT_4)(o(125, s), p, o, m) +# define BOOST_PP_FOR_125(s, p, o, m) BOOST_PP_IF(p(126, s), m, BOOST_PP_TUPLE_EAT_2)(126, s) BOOST_PP_IF(p(126, s), BOOST_PP_FOR_126, BOOST_PP_TUPLE_EAT_4)(o(126, s), p, o, m) +# define BOOST_PP_FOR_126(s, p, o, m) BOOST_PP_IF(p(127, s), m, BOOST_PP_TUPLE_EAT_2)(127, s) BOOST_PP_IF(p(127, s), BOOST_PP_FOR_127, BOOST_PP_TUPLE_EAT_4)(o(127, s), p, o, m) +# define BOOST_PP_FOR_127(s, p, o, m) BOOST_PP_IF(p(128, s), m, BOOST_PP_TUPLE_EAT_2)(128, s) BOOST_PP_IF(p(128, s), BOOST_PP_FOR_128, BOOST_PP_TUPLE_EAT_4)(o(128, s), p, o, m) +# define BOOST_PP_FOR_128(s, p, o, m) BOOST_PP_IF(p(129, s), m, BOOST_PP_TUPLE_EAT_2)(129, s) BOOST_PP_IF(p(129, s), BOOST_PP_FOR_129, BOOST_PP_TUPLE_EAT_4)(o(129, s), p, o, m) +# define BOOST_PP_FOR_129(s, p, o, m) BOOST_PP_IF(p(130, s), m, BOOST_PP_TUPLE_EAT_2)(130, s) BOOST_PP_IF(p(130, s), BOOST_PP_FOR_130, BOOST_PP_TUPLE_EAT_4)(o(130, s), p, o, m) +# define BOOST_PP_FOR_130(s, p, o, m) BOOST_PP_IF(p(131, s), m, BOOST_PP_TUPLE_EAT_2)(131, s) BOOST_PP_IF(p(131, s), BOOST_PP_FOR_131, BOOST_PP_TUPLE_EAT_4)(o(131, s), p, o, m) +# define BOOST_PP_FOR_131(s, p, o, m) BOOST_PP_IF(p(132, s), m, BOOST_PP_TUPLE_EAT_2)(132, s) BOOST_PP_IF(p(132, s), BOOST_PP_FOR_132, BOOST_PP_TUPLE_EAT_4)(o(132, s), p, o, m) +# define BOOST_PP_FOR_132(s, p, o, m) BOOST_PP_IF(p(133, s), m, BOOST_PP_TUPLE_EAT_2)(133, s) BOOST_PP_IF(p(133, s), BOOST_PP_FOR_133, BOOST_PP_TUPLE_EAT_4)(o(133, s), p, o, m) +# define BOOST_PP_FOR_133(s, p, o, m) BOOST_PP_IF(p(134, s), m, BOOST_PP_TUPLE_EAT_2)(134, s) BOOST_PP_IF(p(134, s), BOOST_PP_FOR_134, BOOST_PP_TUPLE_EAT_4)(o(134, s), p, o, m) +# define BOOST_PP_FOR_134(s, p, o, m) BOOST_PP_IF(p(135, s), m, BOOST_PP_TUPLE_EAT_2)(135, s) BOOST_PP_IF(p(135, s), BOOST_PP_FOR_135, BOOST_PP_TUPLE_EAT_4)(o(135, s), p, o, m) +# define BOOST_PP_FOR_135(s, p, o, m) BOOST_PP_IF(p(136, s), m, BOOST_PP_TUPLE_EAT_2)(136, s) BOOST_PP_IF(p(136, s), BOOST_PP_FOR_136, BOOST_PP_TUPLE_EAT_4)(o(136, s), p, o, m) +# define BOOST_PP_FOR_136(s, p, o, m) BOOST_PP_IF(p(137, s), m, BOOST_PP_TUPLE_EAT_2)(137, s) BOOST_PP_IF(p(137, s), BOOST_PP_FOR_137, BOOST_PP_TUPLE_EAT_4)(o(137, s), p, o, m) +# define BOOST_PP_FOR_137(s, p, o, m) BOOST_PP_IF(p(138, s), m, BOOST_PP_TUPLE_EAT_2)(138, s) BOOST_PP_IF(p(138, s), BOOST_PP_FOR_138, BOOST_PP_TUPLE_EAT_4)(o(138, s), p, o, m) +# define BOOST_PP_FOR_138(s, p, o, m) BOOST_PP_IF(p(139, s), m, BOOST_PP_TUPLE_EAT_2)(139, s) BOOST_PP_IF(p(139, s), BOOST_PP_FOR_139, BOOST_PP_TUPLE_EAT_4)(o(139, s), p, o, m) +# define BOOST_PP_FOR_139(s, p, o, m) BOOST_PP_IF(p(140, s), m, BOOST_PP_TUPLE_EAT_2)(140, s) BOOST_PP_IF(p(140, s), BOOST_PP_FOR_140, BOOST_PP_TUPLE_EAT_4)(o(140, s), p, o, m) +# define BOOST_PP_FOR_140(s, p, o, m) BOOST_PP_IF(p(141, s), m, BOOST_PP_TUPLE_EAT_2)(141, s) BOOST_PP_IF(p(141, s), BOOST_PP_FOR_141, BOOST_PP_TUPLE_EAT_4)(o(141, s), p, o, m) +# define BOOST_PP_FOR_141(s, p, o, m) BOOST_PP_IF(p(142, s), m, BOOST_PP_TUPLE_EAT_2)(142, s) BOOST_PP_IF(p(142, s), BOOST_PP_FOR_142, BOOST_PP_TUPLE_EAT_4)(o(142, s), p, o, m) +# define BOOST_PP_FOR_142(s, p, o, m) BOOST_PP_IF(p(143, s), m, BOOST_PP_TUPLE_EAT_2)(143, s) BOOST_PP_IF(p(143, s), BOOST_PP_FOR_143, BOOST_PP_TUPLE_EAT_4)(o(143, s), p, o, m) +# define BOOST_PP_FOR_143(s, p, o, m) BOOST_PP_IF(p(144, s), m, BOOST_PP_TUPLE_EAT_2)(144, s) BOOST_PP_IF(p(144, s), BOOST_PP_FOR_144, BOOST_PP_TUPLE_EAT_4)(o(144, s), p, o, m) +# define BOOST_PP_FOR_144(s, p, o, m) BOOST_PP_IF(p(145, s), m, BOOST_PP_TUPLE_EAT_2)(145, s) BOOST_PP_IF(p(145, s), BOOST_PP_FOR_145, BOOST_PP_TUPLE_EAT_4)(o(145, s), p, o, m) +# define BOOST_PP_FOR_145(s, p, o, m) BOOST_PP_IF(p(146, s), m, BOOST_PP_TUPLE_EAT_2)(146, s) BOOST_PP_IF(p(146, s), BOOST_PP_FOR_146, BOOST_PP_TUPLE_EAT_4)(o(146, s), p, o, m) +# define BOOST_PP_FOR_146(s, p, o, m) BOOST_PP_IF(p(147, s), m, BOOST_PP_TUPLE_EAT_2)(147, s) BOOST_PP_IF(p(147, s), BOOST_PP_FOR_147, BOOST_PP_TUPLE_EAT_4)(o(147, s), p, o, m) +# define BOOST_PP_FOR_147(s, p, o, m) BOOST_PP_IF(p(148, s), m, BOOST_PP_TUPLE_EAT_2)(148, s) BOOST_PP_IF(p(148, s), BOOST_PP_FOR_148, BOOST_PP_TUPLE_EAT_4)(o(148, s), p, o, m) +# define BOOST_PP_FOR_148(s, p, o, m) BOOST_PP_IF(p(149, s), m, BOOST_PP_TUPLE_EAT_2)(149, s) BOOST_PP_IF(p(149, s), BOOST_PP_FOR_149, BOOST_PP_TUPLE_EAT_4)(o(149, s), p, o, m) +# define BOOST_PP_FOR_149(s, p, o, m) BOOST_PP_IF(p(150, s), m, BOOST_PP_TUPLE_EAT_2)(150, s) BOOST_PP_IF(p(150, s), BOOST_PP_FOR_150, BOOST_PP_TUPLE_EAT_4)(o(150, s), p, o, m) +# define BOOST_PP_FOR_150(s, p, o, m) BOOST_PP_IF(p(151, s), m, BOOST_PP_TUPLE_EAT_2)(151, s) BOOST_PP_IF(p(151, s), BOOST_PP_FOR_151, BOOST_PP_TUPLE_EAT_4)(o(151, s), p, o, m) +# define BOOST_PP_FOR_151(s, p, o, m) BOOST_PP_IF(p(152, s), m, BOOST_PP_TUPLE_EAT_2)(152, s) BOOST_PP_IF(p(152, s), BOOST_PP_FOR_152, BOOST_PP_TUPLE_EAT_4)(o(152, s), p, o, m) +# define BOOST_PP_FOR_152(s, p, o, m) BOOST_PP_IF(p(153, s), m, BOOST_PP_TUPLE_EAT_2)(153, s) BOOST_PP_IF(p(153, s), BOOST_PP_FOR_153, BOOST_PP_TUPLE_EAT_4)(o(153, s), p, o, m) +# define BOOST_PP_FOR_153(s, p, o, m) BOOST_PP_IF(p(154, s), m, BOOST_PP_TUPLE_EAT_2)(154, s) BOOST_PP_IF(p(154, s), BOOST_PP_FOR_154, BOOST_PP_TUPLE_EAT_4)(o(154, s), p, o, m) +# define BOOST_PP_FOR_154(s, p, o, m) BOOST_PP_IF(p(155, s), m, BOOST_PP_TUPLE_EAT_2)(155, s) BOOST_PP_IF(p(155, s), BOOST_PP_FOR_155, BOOST_PP_TUPLE_EAT_4)(o(155, s), p, o, m) +# define BOOST_PP_FOR_155(s, p, o, m) BOOST_PP_IF(p(156, s), m, BOOST_PP_TUPLE_EAT_2)(156, s) BOOST_PP_IF(p(156, s), BOOST_PP_FOR_156, BOOST_PP_TUPLE_EAT_4)(o(156, s), p, o, m) +# define BOOST_PP_FOR_156(s, p, o, m) BOOST_PP_IF(p(157, s), m, BOOST_PP_TUPLE_EAT_2)(157, s) BOOST_PP_IF(p(157, s), BOOST_PP_FOR_157, BOOST_PP_TUPLE_EAT_4)(o(157, s), p, o, m) +# define BOOST_PP_FOR_157(s, p, o, m) BOOST_PP_IF(p(158, s), m, BOOST_PP_TUPLE_EAT_2)(158, s) BOOST_PP_IF(p(158, s), BOOST_PP_FOR_158, BOOST_PP_TUPLE_EAT_4)(o(158, s), p, o, m) +# define BOOST_PP_FOR_158(s, p, o, m) BOOST_PP_IF(p(159, s), m, BOOST_PP_TUPLE_EAT_2)(159, s) BOOST_PP_IF(p(159, s), BOOST_PP_FOR_159, BOOST_PP_TUPLE_EAT_4)(o(159, s), p, o, m) +# define BOOST_PP_FOR_159(s, p, o, m) BOOST_PP_IF(p(160, s), m, BOOST_PP_TUPLE_EAT_2)(160, s) BOOST_PP_IF(p(160, s), BOOST_PP_FOR_160, BOOST_PP_TUPLE_EAT_4)(o(160, s), p, o, m) +# define BOOST_PP_FOR_160(s, p, o, m) BOOST_PP_IF(p(161, s), m, BOOST_PP_TUPLE_EAT_2)(161, s) BOOST_PP_IF(p(161, s), BOOST_PP_FOR_161, BOOST_PP_TUPLE_EAT_4)(o(161, s), p, o, m) +# define BOOST_PP_FOR_161(s, p, o, m) BOOST_PP_IF(p(162, s), m, BOOST_PP_TUPLE_EAT_2)(162, s) BOOST_PP_IF(p(162, s), BOOST_PP_FOR_162, BOOST_PP_TUPLE_EAT_4)(o(162, s), p, o, m) +# define BOOST_PP_FOR_162(s, p, o, m) BOOST_PP_IF(p(163, s), m, BOOST_PP_TUPLE_EAT_2)(163, s) BOOST_PP_IF(p(163, s), BOOST_PP_FOR_163, BOOST_PP_TUPLE_EAT_4)(o(163, s), p, o, m) +# define BOOST_PP_FOR_163(s, p, o, m) BOOST_PP_IF(p(164, s), m, BOOST_PP_TUPLE_EAT_2)(164, s) BOOST_PP_IF(p(164, s), BOOST_PP_FOR_164, BOOST_PP_TUPLE_EAT_4)(o(164, s), p, o, m) +# define BOOST_PP_FOR_164(s, p, o, m) BOOST_PP_IF(p(165, s), m, BOOST_PP_TUPLE_EAT_2)(165, s) BOOST_PP_IF(p(165, s), BOOST_PP_FOR_165, BOOST_PP_TUPLE_EAT_4)(o(165, s), p, o, m) +# define BOOST_PP_FOR_165(s, p, o, m) BOOST_PP_IF(p(166, s), m, BOOST_PP_TUPLE_EAT_2)(166, s) BOOST_PP_IF(p(166, s), BOOST_PP_FOR_166, BOOST_PP_TUPLE_EAT_4)(o(166, s), p, o, m) +# define BOOST_PP_FOR_166(s, p, o, m) BOOST_PP_IF(p(167, s), m, BOOST_PP_TUPLE_EAT_2)(167, s) BOOST_PP_IF(p(167, s), BOOST_PP_FOR_167, BOOST_PP_TUPLE_EAT_4)(o(167, s), p, o, m) +# define BOOST_PP_FOR_167(s, p, o, m) BOOST_PP_IF(p(168, s), m, BOOST_PP_TUPLE_EAT_2)(168, s) BOOST_PP_IF(p(168, s), BOOST_PP_FOR_168, BOOST_PP_TUPLE_EAT_4)(o(168, s), p, o, m) +# define BOOST_PP_FOR_168(s, p, o, m) BOOST_PP_IF(p(169, s), m, BOOST_PP_TUPLE_EAT_2)(169, s) BOOST_PP_IF(p(169, s), BOOST_PP_FOR_169, BOOST_PP_TUPLE_EAT_4)(o(169, s), p, o, m) +# define BOOST_PP_FOR_169(s, p, o, m) BOOST_PP_IF(p(170, s), m, BOOST_PP_TUPLE_EAT_2)(170, s) BOOST_PP_IF(p(170, s), BOOST_PP_FOR_170, BOOST_PP_TUPLE_EAT_4)(o(170, s), p, o, m) +# define BOOST_PP_FOR_170(s, p, o, m) BOOST_PP_IF(p(171, s), m, BOOST_PP_TUPLE_EAT_2)(171, s) BOOST_PP_IF(p(171, s), BOOST_PP_FOR_171, BOOST_PP_TUPLE_EAT_4)(o(171, s), p, o, m) +# define BOOST_PP_FOR_171(s, p, o, m) BOOST_PP_IF(p(172, s), m, BOOST_PP_TUPLE_EAT_2)(172, s) BOOST_PP_IF(p(172, s), BOOST_PP_FOR_172, BOOST_PP_TUPLE_EAT_4)(o(172, s), p, o, m) +# define BOOST_PP_FOR_172(s, p, o, m) BOOST_PP_IF(p(173, s), m, BOOST_PP_TUPLE_EAT_2)(173, s) BOOST_PP_IF(p(173, s), BOOST_PP_FOR_173, BOOST_PP_TUPLE_EAT_4)(o(173, s), p, o, m) +# define BOOST_PP_FOR_173(s, p, o, m) BOOST_PP_IF(p(174, s), m, BOOST_PP_TUPLE_EAT_2)(174, s) BOOST_PP_IF(p(174, s), BOOST_PP_FOR_174, BOOST_PP_TUPLE_EAT_4)(o(174, s), p, o, m) +# define BOOST_PP_FOR_174(s, p, o, m) BOOST_PP_IF(p(175, s), m, BOOST_PP_TUPLE_EAT_2)(175, s) BOOST_PP_IF(p(175, s), BOOST_PP_FOR_175, BOOST_PP_TUPLE_EAT_4)(o(175, s), p, o, m) +# define BOOST_PP_FOR_175(s, p, o, m) BOOST_PP_IF(p(176, s), m, BOOST_PP_TUPLE_EAT_2)(176, s) BOOST_PP_IF(p(176, s), BOOST_PP_FOR_176, BOOST_PP_TUPLE_EAT_4)(o(176, s), p, o, m) +# define BOOST_PP_FOR_176(s, p, o, m) BOOST_PP_IF(p(177, s), m, BOOST_PP_TUPLE_EAT_2)(177, s) BOOST_PP_IF(p(177, s), BOOST_PP_FOR_177, BOOST_PP_TUPLE_EAT_4)(o(177, s), p, o, m) +# define BOOST_PP_FOR_177(s, p, o, m) BOOST_PP_IF(p(178, s), m, BOOST_PP_TUPLE_EAT_2)(178, s) BOOST_PP_IF(p(178, s), BOOST_PP_FOR_178, BOOST_PP_TUPLE_EAT_4)(o(178, s), p, o, m) +# define BOOST_PP_FOR_178(s, p, o, m) BOOST_PP_IF(p(179, s), m, BOOST_PP_TUPLE_EAT_2)(179, s) BOOST_PP_IF(p(179, s), BOOST_PP_FOR_179, BOOST_PP_TUPLE_EAT_4)(o(179, s), p, o, m) +# define BOOST_PP_FOR_179(s, p, o, m) BOOST_PP_IF(p(180, s), m, BOOST_PP_TUPLE_EAT_2)(180, s) BOOST_PP_IF(p(180, s), BOOST_PP_FOR_180, BOOST_PP_TUPLE_EAT_4)(o(180, s), p, o, m) +# define BOOST_PP_FOR_180(s, p, o, m) BOOST_PP_IF(p(181, s), m, BOOST_PP_TUPLE_EAT_2)(181, s) BOOST_PP_IF(p(181, s), BOOST_PP_FOR_181, BOOST_PP_TUPLE_EAT_4)(o(181, s), p, o, m) +# define BOOST_PP_FOR_181(s, p, o, m) BOOST_PP_IF(p(182, s), m, BOOST_PP_TUPLE_EAT_2)(182, s) BOOST_PP_IF(p(182, s), BOOST_PP_FOR_182, BOOST_PP_TUPLE_EAT_4)(o(182, s), p, o, m) +# define BOOST_PP_FOR_182(s, p, o, m) BOOST_PP_IF(p(183, s), m, BOOST_PP_TUPLE_EAT_2)(183, s) BOOST_PP_IF(p(183, s), BOOST_PP_FOR_183, BOOST_PP_TUPLE_EAT_4)(o(183, s), p, o, m) +# define BOOST_PP_FOR_183(s, p, o, m) BOOST_PP_IF(p(184, s), m, BOOST_PP_TUPLE_EAT_2)(184, s) BOOST_PP_IF(p(184, s), BOOST_PP_FOR_184, BOOST_PP_TUPLE_EAT_4)(o(184, s), p, o, m) +# define BOOST_PP_FOR_184(s, p, o, m) BOOST_PP_IF(p(185, s), m, BOOST_PP_TUPLE_EAT_2)(185, s) BOOST_PP_IF(p(185, s), BOOST_PP_FOR_185, BOOST_PP_TUPLE_EAT_4)(o(185, s), p, o, m) +# define BOOST_PP_FOR_185(s, p, o, m) BOOST_PP_IF(p(186, s), m, BOOST_PP_TUPLE_EAT_2)(186, s) BOOST_PP_IF(p(186, s), BOOST_PP_FOR_186, BOOST_PP_TUPLE_EAT_4)(o(186, s), p, o, m) +# define BOOST_PP_FOR_186(s, p, o, m) BOOST_PP_IF(p(187, s), m, BOOST_PP_TUPLE_EAT_2)(187, s) BOOST_PP_IF(p(187, s), BOOST_PP_FOR_187, BOOST_PP_TUPLE_EAT_4)(o(187, s), p, o, m) +# define BOOST_PP_FOR_187(s, p, o, m) BOOST_PP_IF(p(188, s), m, BOOST_PP_TUPLE_EAT_2)(188, s) BOOST_PP_IF(p(188, s), BOOST_PP_FOR_188, BOOST_PP_TUPLE_EAT_4)(o(188, s), p, o, m) +# define BOOST_PP_FOR_188(s, p, o, m) BOOST_PP_IF(p(189, s), m, BOOST_PP_TUPLE_EAT_2)(189, s) BOOST_PP_IF(p(189, s), BOOST_PP_FOR_189, BOOST_PP_TUPLE_EAT_4)(o(189, s), p, o, m) +# define BOOST_PP_FOR_189(s, p, o, m) BOOST_PP_IF(p(190, s), m, BOOST_PP_TUPLE_EAT_2)(190, s) BOOST_PP_IF(p(190, s), BOOST_PP_FOR_190, BOOST_PP_TUPLE_EAT_4)(o(190, s), p, o, m) +# define BOOST_PP_FOR_190(s, p, o, m) BOOST_PP_IF(p(191, s), m, BOOST_PP_TUPLE_EAT_2)(191, s) BOOST_PP_IF(p(191, s), BOOST_PP_FOR_191, BOOST_PP_TUPLE_EAT_4)(o(191, s), p, o, m) +# define BOOST_PP_FOR_191(s, p, o, m) BOOST_PP_IF(p(192, s), m, BOOST_PP_TUPLE_EAT_2)(192, s) BOOST_PP_IF(p(192, s), BOOST_PP_FOR_192, BOOST_PP_TUPLE_EAT_4)(o(192, s), p, o, m) +# define BOOST_PP_FOR_192(s, p, o, m) BOOST_PP_IF(p(193, s), m, BOOST_PP_TUPLE_EAT_2)(193, s) BOOST_PP_IF(p(193, s), BOOST_PP_FOR_193, BOOST_PP_TUPLE_EAT_4)(o(193, s), p, o, m) +# define BOOST_PP_FOR_193(s, p, o, m) BOOST_PP_IF(p(194, s), m, BOOST_PP_TUPLE_EAT_2)(194, s) BOOST_PP_IF(p(194, s), BOOST_PP_FOR_194, BOOST_PP_TUPLE_EAT_4)(o(194, s), p, o, m) +# define BOOST_PP_FOR_194(s, p, o, m) BOOST_PP_IF(p(195, s), m, BOOST_PP_TUPLE_EAT_2)(195, s) BOOST_PP_IF(p(195, s), BOOST_PP_FOR_195, BOOST_PP_TUPLE_EAT_4)(o(195, s), p, o, m) +# define BOOST_PP_FOR_195(s, p, o, m) BOOST_PP_IF(p(196, s), m, BOOST_PP_TUPLE_EAT_2)(196, s) BOOST_PP_IF(p(196, s), BOOST_PP_FOR_196, BOOST_PP_TUPLE_EAT_4)(o(196, s), p, o, m) +# define BOOST_PP_FOR_196(s, p, o, m) BOOST_PP_IF(p(197, s), m, BOOST_PP_TUPLE_EAT_2)(197, s) BOOST_PP_IF(p(197, s), BOOST_PP_FOR_197, BOOST_PP_TUPLE_EAT_4)(o(197, s), p, o, m) +# define BOOST_PP_FOR_197(s, p, o, m) BOOST_PP_IF(p(198, s), m, BOOST_PP_TUPLE_EAT_2)(198, s) BOOST_PP_IF(p(198, s), BOOST_PP_FOR_198, BOOST_PP_TUPLE_EAT_4)(o(198, s), p, o, m) +# define BOOST_PP_FOR_198(s, p, o, m) BOOST_PP_IF(p(199, s), m, BOOST_PP_TUPLE_EAT_2)(199, s) BOOST_PP_IF(p(199, s), BOOST_PP_FOR_199, BOOST_PP_TUPLE_EAT_4)(o(199, s), p, o, m) +# define BOOST_PP_FOR_199(s, p, o, m) BOOST_PP_IF(p(200, s), m, BOOST_PP_TUPLE_EAT_2)(200, s) BOOST_PP_IF(p(200, s), BOOST_PP_FOR_200, BOOST_PP_TUPLE_EAT_4)(o(200, s), p, o, m) +# define BOOST_PP_FOR_200(s, p, o, m) BOOST_PP_IF(p(201, s), m, BOOST_PP_TUPLE_EAT_2)(201, s) BOOST_PP_IF(p(201, s), BOOST_PP_FOR_201, BOOST_PP_TUPLE_EAT_4)(o(201, s), p, o, m) +# define BOOST_PP_FOR_201(s, p, o, m) BOOST_PP_IF(p(202, s), m, BOOST_PP_TUPLE_EAT_2)(202, s) BOOST_PP_IF(p(202, s), BOOST_PP_FOR_202, BOOST_PP_TUPLE_EAT_4)(o(202, s), p, o, m) +# define BOOST_PP_FOR_202(s, p, o, m) BOOST_PP_IF(p(203, s), m, BOOST_PP_TUPLE_EAT_2)(203, s) BOOST_PP_IF(p(203, s), BOOST_PP_FOR_203, BOOST_PP_TUPLE_EAT_4)(o(203, s), p, o, m) +# define BOOST_PP_FOR_203(s, p, o, m) BOOST_PP_IF(p(204, s), m, BOOST_PP_TUPLE_EAT_2)(204, s) BOOST_PP_IF(p(204, s), BOOST_PP_FOR_204, BOOST_PP_TUPLE_EAT_4)(o(204, s), p, o, m) +# define BOOST_PP_FOR_204(s, p, o, m) BOOST_PP_IF(p(205, s), m, BOOST_PP_TUPLE_EAT_2)(205, s) BOOST_PP_IF(p(205, s), BOOST_PP_FOR_205, BOOST_PP_TUPLE_EAT_4)(o(205, s), p, o, m) +# define BOOST_PP_FOR_205(s, p, o, m) BOOST_PP_IF(p(206, s), m, BOOST_PP_TUPLE_EAT_2)(206, s) BOOST_PP_IF(p(206, s), BOOST_PP_FOR_206, BOOST_PP_TUPLE_EAT_4)(o(206, s), p, o, m) +# define BOOST_PP_FOR_206(s, p, o, m) BOOST_PP_IF(p(207, s), m, BOOST_PP_TUPLE_EAT_2)(207, s) BOOST_PP_IF(p(207, s), BOOST_PP_FOR_207, BOOST_PP_TUPLE_EAT_4)(o(207, s), p, o, m) +# define BOOST_PP_FOR_207(s, p, o, m) BOOST_PP_IF(p(208, s), m, BOOST_PP_TUPLE_EAT_2)(208, s) BOOST_PP_IF(p(208, s), BOOST_PP_FOR_208, BOOST_PP_TUPLE_EAT_4)(o(208, s), p, o, m) +# define BOOST_PP_FOR_208(s, p, o, m) BOOST_PP_IF(p(209, s), m, BOOST_PP_TUPLE_EAT_2)(209, s) BOOST_PP_IF(p(209, s), BOOST_PP_FOR_209, BOOST_PP_TUPLE_EAT_4)(o(209, s), p, o, m) +# define BOOST_PP_FOR_209(s, p, o, m) BOOST_PP_IF(p(210, s), m, BOOST_PP_TUPLE_EAT_2)(210, s) BOOST_PP_IF(p(210, s), BOOST_PP_FOR_210, BOOST_PP_TUPLE_EAT_4)(o(210, s), p, o, m) +# define BOOST_PP_FOR_210(s, p, o, m) BOOST_PP_IF(p(211, s), m, BOOST_PP_TUPLE_EAT_2)(211, s) BOOST_PP_IF(p(211, s), BOOST_PP_FOR_211, BOOST_PP_TUPLE_EAT_4)(o(211, s), p, o, m) +# define BOOST_PP_FOR_211(s, p, o, m) BOOST_PP_IF(p(212, s), m, BOOST_PP_TUPLE_EAT_2)(212, s) BOOST_PP_IF(p(212, s), BOOST_PP_FOR_212, BOOST_PP_TUPLE_EAT_4)(o(212, s), p, o, m) +# define BOOST_PP_FOR_212(s, p, o, m) BOOST_PP_IF(p(213, s), m, BOOST_PP_TUPLE_EAT_2)(213, s) BOOST_PP_IF(p(213, s), BOOST_PP_FOR_213, BOOST_PP_TUPLE_EAT_4)(o(213, s), p, o, m) +# define BOOST_PP_FOR_213(s, p, o, m) BOOST_PP_IF(p(214, s), m, BOOST_PP_TUPLE_EAT_2)(214, s) BOOST_PP_IF(p(214, s), BOOST_PP_FOR_214, BOOST_PP_TUPLE_EAT_4)(o(214, s), p, o, m) +# define BOOST_PP_FOR_214(s, p, o, m) BOOST_PP_IF(p(215, s), m, BOOST_PP_TUPLE_EAT_2)(215, s) BOOST_PP_IF(p(215, s), BOOST_PP_FOR_215, BOOST_PP_TUPLE_EAT_4)(o(215, s), p, o, m) +# define BOOST_PP_FOR_215(s, p, o, m) BOOST_PP_IF(p(216, s), m, BOOST_PP_TUPLE_EAT_2)(216, s) BOOST_PP_IF(p(216, s), BOOST_PP_FOR_216, BOOST_PP_TUPLE_EAT_4)(o(216, s), p, o, m) +# define BOOST_PP_FOR_216(s, p, o, m) BOOST_PP_IF(p(217, s), m, BOOST_PP_TUPLE_EAT_2)(217, s) BOOST_PP_IF(p(217, s), BOOST_PP_FOR_217, BOOST_PP_TUPLE_EAT_4)(o(217, s), p, o, m) +# define BOOST_PP_FOR_217(s, p, o, m) BOOST_PP_IF(p(218, s), m, BOOST_PP_TUPLE_EAT_2)(218, s) BOOST_PP_IF(p(218, s), BOOST_PP_FOR_218, BOOST_PP_TUPLE_EAT_4)(o(218, s), p, o, m) +# define BOOST_PP_FOR_218(s, p, o, m) BOOST_PP_IF(p(219, s), m, BOOST_PP_TUPLE_EAT_2)(219, s) BOOST_PP_IF(p(219, s), BOOST_PP_FOR_219, BOOST_PP_TUPLE_EAT_4)(o(219, s), p, o, m) +# define BOOST_PP_FOR_219(s, p, o, m) BOOST_PP_IF(p(220, s), m, BOOST_PP_TUPLE_EAT_2)(220, s) BOOST_PP_IF(p(220, s), BOOST_PP_FOR_220, BOOST_PP_TUPLE_EAT_4)(o(220, s), p, o, m) +# define BOOST_PP_FOR_220(s, p, o, m) BOOST_PP_IF(p(221, s), m, BOOST_PP_TUPLE_EAT_2)(221, s) BOOST_PP_IF(p(221, s), BOOST_PP_FOR_221, BOOST_PP_TUPLE_EAT_4)(o(221, s), p, o, m) +# define BOOST_PP_FOR_221(s, p, o, m) BOOST_PP_IF(p(222, s), m, BOOST_PP_TUPLE_EAT_2)(222, s) BOOST_PP_IF(p(222, s), BOOST_PP_FOR_222, BOOST_PP_TUPLE_EAT_4)(o(222, s), p, o, m) +# define BOOST_PP_FOR_222(s, p, o, m) BOOST_PP_IF(p(223, s), m, BOOST_PP_TUPLE_EAT_2)(223, s) BOOST_PP_IF(p(223, s), BOOST_PP_FOR_223, BOOST_PP_TUPLE_EAT_4)(o(223, s), p, o, m) +# define BOOST_PP_FOR_223(s, p, o, m) BOOST_PP_IF(p(224, s), m, BOOST_PP_TUPLE_EAT_2)(224, s) BOOST_PP_IF(p(224, s), BOOST_PP_FOR_224, BOOST_PP_TUPLE_EAT_4)(o(224, s), p, o, m) +# define BOOST_PP_FOR_224(s, p, o, m) BOOST_PP_IF(p(225, s), m, BOOST_PP_TUPLE_EAT_2)(225, s) BOOST_PP_IF(p(225, s), BOOST_PP_FOR_225, BOOST_PP_TUPLE_EAT_4)(o(225, s), p, o, m) +# define BOOST_PP_FOR_225(s, p, o, m) BOOST_PP_IF(p(226, s), m, BOOST_PP_TUPLE_EAT_2)(226, s) BOOST_PP_IF(p(226, s), BOOST_PP_FOR_226, BOOST_PP_TUPLE_EAT_4)(o(226, s), p, o, m) +# define BOOST_PP_FOR_226(s, p, o, m) BOOST_PP_IF(p(227, s), m, BOOST_PP_TUPLE_EAT_2)(227, s) BOOST_PP_IF(p(227, s), BOOST_PP_FOR_227, BOOST_PP_TUPLE_EAT_4)(o(227, s), p, o, m) +# define BOOST_PP_FOR_227(s, p, o, m) BOOST_PP_IF(p(228, s), m, BOOST_PP_TUPLE_EAT_2)(228, s) BOOST_PP_IF(p(228, s), BOOST_PP_FOR_228, BOOST_PP_TUPLE_EAT_4)(o(228, s), p, o, m) +# define BOOST_PP_FOR_228(s, p, o, m) BOOST_PP_IF(p(229, s), m, BOOST_PP_TUPLE_EAT_2)(229, s) BOOST_PP_IF(p(229, s), BOOST_PP_FOR_229, BOOST_PP_TUPLE_EAT_4)(o(229, s), p, o, m) +# define BOOST_PP_FOR_229(s, p, o, m) BOOST_PP_IF(p(230, s), m, BOOST_PP_TUPLE_EAT_2)(230, s) BOOST_PP_IF(p(230, s), BOOST_PP_FOR_230, BOOST_PP_TUPLE_EAT_4)(o(230, s), p, o, m) +# define BOOST_PP_FOR_230(s, p, o, m) BOOST_PP_IF(p(231, s), m, BOOST_PP_TUPLE_EAT_2)(231, s) BOOST_PP_IF(p(231, s), BOOST_PP_FOR_231, BOOST_PP_TUPLE_EAT_4)(o(231, s), p, o, m) +# define BOOST_PP_FOR_231(s, p, o, m) BOOST_PP_IF(p(232, s), m, BOOST_PP_TUPLE_EAT_2)(232, s) BOOST_PP_IF(p(232, s), BOOST_PP_FOR_232, BOOST_PP_TUPLE_EAT_4)(o(232, s), p, o, m) +# define BOOST_PP_FOR_232(s, p, o, m) BOOST_PP_IF(p(233, s), m, BOOST_PP_TUPLE_EAT_2)(233, s) BOOST_PP_IF(p(233, s), BOOST_PP_FOR_233, BOOST_PP_TUPLE_EAT_4)(o(233, s), p, o, m) +# define BOOST_PP_FOR_233(s, p, o, m) BOOST_PP_IF(p(234, s), m, BOOST_PP_TUPLE_EAT_2)(234, s) BOOST_PP_IF(p(234, s), BOOST_PP_FOR_234, BOOST_PP_TUPLE_EAT_4)(o(234, s), p, o, m) +# define BOOST_PP_FOR_234(s, p, o, m) BOOST_PP_IF(p(235, s), m, BOOST_PP_TUPLE_EAT_2)(235, s) BOOST_PP_IF(p(235, s), BOOST_PP_FOR_235, BOOST_PP_TUPLE_EAT_4)(o(235, s), p, o, m) +# define BOOST_PP_FOR_235(s, p, o, m) BOOST_PP_IF(p(236, s), m, BOOST_PP_TUPLE_EAT_2)(236, s) BOOST_PP_IF(p(236, s), BOOST_PP_FOR_236, BOOST_PP_TUPLE_EAT_4)(o(236, s), p, o, m) +# define BOOST_PP_FOR_236(s, p, o, m) BOOST_PP_IF(p(237, s), m, BOOST_PP_TUPLE_EAT_2)(237, s) BOOST_PP_IF(p(237, s), BOOST_PP_FOR_237, BOOST_PP_TUPLE_EAT_4)(o(237, s), p, o, m) +# define BOOST_PP_FOR_237(s, p, o, m) BOOST_PP_IF(p(238, s), m, BOOST_PP_TUPLE_EAT_2)(238, s) BOOST_PP_IF(p(238, s), BOOST_PP_FOR_238, BOOST_PP_TUPLE_EAT_4)(o(238, s), p, o, m) +# define BOOST_PP_FOR_238(s, p, o, m) BOOST_PP_IF(p(239, s), m, BOOST_PP_TUPLE_EAT_2)(239, s) BOOST_PP_IF(p(239, s), BOOST_PP_FOR_239, BOOST_PP_TUPLE_EAT_4)(o(239, s), p, o, m) +# define BOOST_PP_FOR_239(s, p, o, m) BOOST_PP_IF(p(240, s), m, BOOST_PP_TUPLE_EAT_2)(240, s) BOOST_PP_IF(p(240, s), BOOST_PP_FOR_240, BOOST_PP_TUPLE_EAT_4)(o(240, s), p, o, m) +# define BOOST_PP_FOR_240(s, p, o, m) BOOST_PP_IF(p(241, s), m, BOOST_PP_TUPLE_EAT_2)(241, s) BOOST_PP_IF(p(241, s), BOOST_PP_FOR_241, BOOST_PP_TUPLE_EAT_4)(o(241, s), p, o, m) +# define BOOST_PP_FOR_241(s, p, o, m) BOOST_PP_IF(p(242, s), m, BOOST_PP_TUPLE_EAT_2)(242, s) BOOST_PP_IF(p(242, s), BOOST_PP_FOR_242, BOOST_PP_TUPLE_EAT_4)(o(242, s), p, o, m) +# define BOOST_PP_FOR_242(s, p, o, m) BOOST_PP_IF(p(243, s), m, BOOST_PP_TUPLE_EAT_2)(243, s) BOOST_PP_IF(p(243, s), BOOST_PP_FOR_243, BOOST_PP_TUPLE_EAT_4)(o(243, s), p, o, m) +# define BOOST_PP_FOR_243(s, p, o, m) BOOST_PP_IF(p(244, s), m, BOOST_PP_TUPLE_EAT_2)(244, s) BOOST_PP_IF(p(244, s), BOOST_PP_FOR_244, BOOST_PP_TUPLE_EAT_4)(o(244, s), p, o, m) +# define BOOST_PP_FOR_244(s, p, o, m) BOOST_PP_IF(p(245, s), m, BOOST_PP_TUPLE_EAT_2)(245, s) BOOST_PP_IF(p(245, s), BOOST_PP_FOR_245, BOOST_PP_TUPLE_EAT_4)(o(245, s), p, o, m) +# define BOOST_PP_FOR_245(s, p, o, m) BOOST_PP_IF(p(246, s), m, BOOST_PP_TUPLE_EAT_2)(246, s) BOOST_PP_IF(p(246, s), BOOST_PP_FOR_246, BOOST_PP_TUPLE_EAT_4)(o(246, s), p, o, m) +# define BOOST_PP_FOR_246(s, p, o, m) BOOST_PP_IF(p(247, s), m, BOOST_PP_TUPLE_EAT_2)(247, s) BOOST_PP_IF(p(247, s), BOOST_PP_FOR_247, BOOST_PP_TUPLE_EAT_4)(o(247, s), p, o, m) +# define BOOST_PP_FOR_247(s, p, o, m) BOOST_PP_IF(p(248, s), m, BOOST_PP_TUPLE_EAT_2)(248, s) BOOST_PP_IF(p(248, s), BOOST_PP_FOR_248, BOOST_PP_TUPLE_EAT_4)(o(248, s), p, o, m) +# define BOOST_PP_FOR_248(s, p, o, m) BOOST_PP_IF(p(249, s), m, BOOST_PP_TUPLE_EAT_2)(249, s) BOOST_PP_IF(p(249, s), BOOST_PP_FOR_249, BOOST_PP_TUPLE_EAT_4)(o(249, s), p, o, m) +# define BOOST_PP_FOR_249(s, p, o, m) BOOST_PP_IF(p(250, s), m, BOOST_PP_TUPLE_EAT_2)(250, s) BOOST_PP_IF(p(250, s), BOOST_PP_FOR_250, BOOST_PP_TUPLE_EAT_4)(o(250, s), p, o, m) +# define BOOST_PP_FOR_250(s, p, o, m) BOOST_PP_IF(p(251, s), m, BOOST_PP_TUPLE_EAT_2)(251, s) BOOST_PP_IF(p(251, s), BOOST_PP_FOR_251, BOOST_PP_TUPLE_EAT_4)(o(251, s), p, o, m) +# define BOOST_PP_FOR_251(s, p, o, m) BOOST_PP_IF(p(252, s), m, BOOST_PP_TUPLE_EAT_2)(252, s) BOOST_PP_IF(p(252, s), BOOST_PP_FOR_252, BOOST_PP_TUPLE_EAT_4)(o(252, s), p, o, m) +# define BOOST_PP_FOR_252(s, p, o, m) BOOST_PP_IF(p(253, s), m, BOOST_PP_TUPLE_EAT_2)(253, s) BOOST_PP_IF(p(253, s), BOOST_PP_FOR_253, BOOST_PP_TUPLE_EAT_4)(o(253, s), p, o, m) +# define BOOST_PP_FOR_253(s, p, o, m) BOOST_PP_IF(p(254, s), m, BOOST_PP_TUPLE_EAT_2)(254, s) BOOST_PP_IF(p(254, s), BOOST_PP_FOR_254, BOOST_PP_TUPLE_EAT_4)(o(254, s), p, o, m) +# define BOOST_PP_FOR_254(s, p, o, m) BOOST_PP_IF(p(255, s), m, BOOST_PP_TUPLE_EAT_2)(255, s) BOOST_PP_IF(p(255, s), BOOST_PP_FOR_255, BOOST_PP_TUPLE_EAT_4)(o(255, s), p, o, m) +# define BOOST_PP_FOR_255(s, p, o, m) BOOST_PP_IF(p(256, s), m, BOOST_PP_TUPLE_EAT_2)(256, s) BOOST_PP_IF(p(256, s), BOOST_PP_FOR_256, BOOST_PP_TUPLE_EAT_4)(o(256, s), p, o, m) +# define BOOST_PP_FOR_256(s, p, o, m) BOOST_PP_IF(p(257, s), m, BOOST_PP_TUPLE_EAT_2)(257, s) BOOST_PP_IF(p(257, s), BOOST_PP_FOR_257, BOOST_PP_TUPLE_EAT_4)(o(257, s), p, o, m) +# +# endif diff --git a/realsense-file/3rd_party/boost/boost/preprocessor/repetition/enum.hpp b/realsense-file/3rd_party/boost/boost/preprocessor/repetition/enum.hpp new file mode 100644 index 0000000000..8b4ab9a51c --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/preprocessor/repetition/enum.hpp @@ -0,0 +1,66 @@ +# /* Copyright (C) 2001 +# * Housemarque Oy +# * http://www.housemarque.com +# * +# * 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) +# */ +# +# /* Revised by Paul Mensonides (2002) */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_REPETITION_ENUM_HPP +# define BOOST_PREPROCESSOR_REPETITION_ENUM_HPP +# +# include +# include +# include +# include +# include +# include +# include +# include +# +# /* BOOST_PP_ENUM */ +# +# if 0 +# define BOOST_PP_ENUM(count, macro, data) +# endif +# +# define BOOST_PP_ENUM BOOST_PP_CAT(BOOST_PP_ENUM_, BOOST_PP_AUTO_REC(BOOST_PP_REPEAT_P, 4)) +# +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() +# define BOOST_PP_ENUM_1(c, m, d) BOOST_PP_REPEAT_1(c, BOOST_PP_ENUM_M_1, (m, d)) +# define BOOST_PP_ENUM_2(c, m, d) BOOST_PP_REPEAT_2(c, BOOST_PP_ENUM_M_2, (m, d)) +# define BOOST_PP_ENUM_3(c, m, d) BOOST_PP_REPEAT_3(c, BOOST_PP_ENUM_M_3, (m, d)) +# else +# define BOOST_PP_ENUM_1(c, m, d) BOOST_PP_ENUM_1_I(c, m, d) +# define BOOST_PP_ENUM_2(c, m, d) BOOST_PP_ENUM_2_I(c, m, d) +# define BOOST_PP_ENUM_3(c, m, d) BOOST_PP_ENUM_3_I(c, m, d) +# define BOOST_PP_ENUM_1_I(c, m, d) BOOST_PP_REPEAT_1(c, BOOST_PP_ENUM_M_1, (m, d)) +# define BOOST_PP_ENUM_2_I(c, m, d) BOOST_PP_REPEAT_2(c, BOOST_PP_ENUM_M_2, (m, d)) +# define BOOST_PP_ENUM_3_I(c, m, d) BOOST_PP_REPEAT_3(c, BOOST_PP_ENUM_M_3, (m, d)) +# endif +# +# define BOOST_PP_ENUM_4(c, m, d) BOOST_PP_ERROR(0x0003) +# +# if BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_STRICT() +# define BOOST_PP_ENUM_M_1(z, n, md) BOOST_PP_ENUM_M_1_IM(z, n, BOOST_PP_TUPLE_REM_2 md) +# define BOOST_PP_ENUM_M_2(z, n, md) BOOST_PP_ENUM_M_2_IM(z, n, BOOST_PP_TUPLE_REM_2 md) +# define BOOST_PP_ENUM_M_3(z, n, md) BOOST_PP_ENUM_M_3_IM(z, n, BOOST_PP_TUPLE_REM_2 md) +# define BOOST_PP_ENUM_M_1_IM(z, n, im) BOOST_PP_ENUM_M_1_I(z, n, im) +# define BOOST_PP_ENUM_M_2_IM(z, n, im) BOOST_PP_ENUM_M_2_I(z, n, im) +# define BOOST_PP_ENUM_M_3_IM(z, n, im) BOOST_PP_ENUM_M_3_I(z, n, im) +# else +# define BOOST_PP_ENUM_M_1(z, n, md) BOOST_PP_ENUM_M_1_I(z, n, BOOST_PP_TUPLE_ELEM(2, 0, md), BOOST_PP_TUPLE_ELEM(2, 1, md)) +# define BOOST_PP_ENUM_M_2(z, n, md) BOOST_PP_ENUM_M_2_I(z, n, BOOST_PP_TUPLE_ELEM(2, 0, md), BOOST_PP_TUPLE_ELEM(2, 1, md)) +# define BOOST_PP_ENUM_M_3(z, n, md) BOOST_PP_ENUM_M_3_I(z, n, BOOST_PP_TUPLE_ELEM(2, 0, md), BOOST_PP_TUPLE_ELEM(2, 1, md)) +# endif +# +# define BOOST_PP_ENUM_M_1_I(z, n, m, d) BOOST_PP_COMMA_IF(n) m(z, n, d) +# define BOOST_PP_ENUM_M_2_I(z, n, m, d) BOOST_PP_COMMA_IF(n) m(z, n, d) +# define BOOST_PP_ENUM_M_3_I(z, n, m, d) BOOST_PP_COMMA_IF(n) m(z, n, d) +# +# endif diff --git a/realsense-file/3rd_party/boost/boost/preprocessor/repetition/enum_binary_params.hpp b/realsense-file/3rd_party/boost/boost/preprocessor/repetition/enum_binary_params.hpp new file mode 100644 index 0000000000..eb6a4948db --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/preprocessor/repetition/enum_binary_params.hpp @@ -0,0 +1,54 @@ +# /* ************************************************************************** +# * * +# * (C) Copyright Paul Mensonides 2002. +# * Distributed under the Boost Software License, Version 1.0. (See +# * accompanying file LICENSE_1_0.txt or copy at +# * http://www.boost.org/LICENSE_1_0.txt) +# * * +# ************************************************************************** */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_REPETITION_ENUM_BINARY_PARAMS_HPP +# define BOOST_PREPROCESSOR_REPETITION_ENUM_BINARY_PARAMS_HPP +# +# include +# include +# include +# include +# include +# include +# +# /* BOOST_PP_ENUM_BINARY_PARAMS */ +# +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() +# define BOOST_PP_ENUM_BINARY_PARAMS(count, p1, p2) BOOST_PP_REPEAT(count, BOOST_PP_ENUM_BINARY_PARAMS_M, (p1, p2)) +# else +# define BOOST_PP_ENUM_BINARY_PARAMS(count, p1, p2) BOOST_PP_ENUM_BINARY_PARAMS_I(count, p1, p2) +# define BOOST_PP_ENUM_BINARY_PARAMS_I(count, p1, p2) BOOST_PP_REPEAT(count, BOOST_PP_ENUM_BINARY_PARAMS_M, (p1, p2)) +# endif +# +# if BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_STRICT() +# define BOOST_PP_ENUM_BINARY_PARAMS_M(z, n, pp) BOOST_PP_ENUM_BINARY_PARAMS_M_IM(z, n, BOOST_PP_TUPLE_REM_2 pp) +# define BOOST_PP_ENUM_BINARY_PARAMS_M_IM(z, n, im) BOOST_PP_ENUM_BINARY_PARAMS_M_I(z, n, im) +# else +# define BOOST_PP_ENUM_BINARY_PARAMS_M(z, n, pp) BOOST_PP_ENUM_BINARY_PARAMS_M_I(z, n, BOOST_PP_TUPLE_ELEM(2, 0, pp), BOOST_PP_TUPLE_ELEM(2, 1, pp)) +# endif +# +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MSVC() +# define BOOST_PP_ENUM_BINARY_PARAMS_M_I(z, n, p1, p2) BOOST_PP_ENUM_BINARY_PARAMS_M_II(z, n, p1, p2) +# define BOOST_PP_ENUM_BINARY_PARAMS_M_II(z, n, p1, p2) BOOST_PP_COMMA_IF(n) p1 ## n p2 ## n +# else +# define BOOST_PP_ENUM_BINARY_PARAMS_M_I(z, n, p1, p2) BOOST_PP_COMMA_IF(n) BOOST_PP_CAT(p1, n) BOOST_PP_CAT(p2, n) +# endif +# +# /* BOOST_PP_ENUM_BINARY_PARAMS_Z */ +# +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() +# define BOOST_PP_ENUM_BINARY_PARAMS_Z(z, count, p1, p2) BOOST_PP_REPEAT_ ## z(count, BOOST_PP_ENUM_BINARY_PARAMS_M, (p1, p2)) +# else +# define BOOST_PP_ENUM_BINARY_PARAMS_Z(z, count, p1, p2) BOOST_PP_ENUM_BINARY_PARAMS_Z_I(z, count, p1, p2) +# define BOOST_PP_ENUM_BINARY_PARAMS_Z_I(z, count, p1, p2) BOOST_PP_REPEAT_ ## z(count, BOOST_PP_ENUM_BINARY_PARAMS_M, (p1, p2)) +# endif +# +# endif diff --git a/realsense-file/3rd_party/boost/boost/preprocessor/repetition/enum_params.hpp b/realsense-file/3rd_party/boost/boost/preprocessor/repetition/enum_params.hpp new file mode 100644 index 0000000000..8bfa036ee4 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/preprocessor/repetition/enum_params.hpp @@ -0,0 +1,41 @@ +# /* Copyright (C) 2001 +# * Housemarque Oy +# * http://www.housemarque.com +# * +# * 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) +# */ +# +# /* Revised by Paul Mensonides (2002) */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_REPETITION_ENUM_PARAMS_HPP +# define BOOST_PREPROCESSOR_REPETITION_ENUM_PARAMS_HPP +# +# include +# include +# include +# +# /* BOOST_PP_ENUM_PARAMS */ +# +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() +# define BOOST_PP_ENUM_PARAMS(count, param) BOOST_PP_REPEAT(count, BOOST_PP_ENUM_PARAMS_M, param) +# else +# define BOOST_PP_ENUM_PARAMS(count, param) BOOST_PP_ENUM_PARAMS_I(count, param) +# define BOOST_PP_ENUM_PARAMS_I(count, param) BOOST_PP_REPEAT(count, BOOST_PP_ENUM_PARAMS_M, param) +# endif +# +# define BOOST_PP_ENUM_PARAMS_M(z, n, param) BOOST_PP_COMMA_IF(n) param ## n +# +# /* BOOST_PP_ENUM_PARAMS_Z */ +# +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() +# define BOOST_PP_ENUM_PARAMS_Z(z, count, param) BOOST_PP_REPEAT_ ## z(count, BOOST_PP_ENUM_PARAMS_M, param) +# else +# define BOOST_PP_ENUM_PARAMS_Z(z, count, param) BOOST_PP_ENUM_PARAMS_Z_I(z, count, param) +# define BOOST_PP_ENUM_PARAMS_Z_I(z, count, param) BOOST_PP_REPEAT_ ## z(count, BOOST_PP_ENUM_PARAMS_M, param) +# endif +# +# endif diff --git a/realsense-file/3rd_party/boost/boost/preprocessor/repetition/enum_trailing_params.hpp b/realsense-file/3rd_party/boost/boost/preprocessor/repetition/enum_trailing_params.hpp new file mode 100644 index 0000000000..33ad8ca996 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/preprocessor/repetition/enum_trailing_params.hpp @@ -0,0 +1,38 @@ +# /* ************************************************************************** +# * * +# * (C) Copyright Paul Mensonides 2002. +# * Distributed under the Boost Software License, Version 1.0. (See +# * accompanying file LICENSE_1_0.txt or copy at +# * http://www.boost.org/LICENSE_1_0.txt) +# * * +# ************************************************************************** */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_REPETITION_ENUM_TRAILING_PARAMS_HPP +# define BOOST_PREPROCESSOR_REPETITION_ENUM_TRAILING_PARAMS_HPP +# +# include +# include +# +# /* BOOST_PP_ENUM_TRAILING_PARAMS */ +# +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() +# define BOOST_PP_ENUM_TRAILING_PARAMS(count, param) BOOST_PP_REPEAT(count, BOOST_PP_ENUM_TRAILING_PARAMS_M, param) +# else +# define BOOST_PP_ENUM_TRAILING_PARAMS(count, param) BOOST_PP_ENUM_TRAILING_PARAMS_I(count, param) +# define BOOST_PP_ENUM_TRAILING_PARAMS_I(count, param) BOOST_PP_REPEAT(count, BOOST_PP_ENUM_TRAILING_PARAMS_M, param) +# endif +# +# define BOOST_PP_ENUM_TRAILING_PARAMS_M(z, n, param) , param ## n +# +# /* BOOST_PP_ENUM_TRAILING_PARAMS_Z */ +# +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() +# define BOOST_PP_ENUM_TRAILING_PARAMS_Z(z, count, param) BOOST_PP_REPEAT_ ## z(count, BOOST_PP_ENUM_TRAILING_PARAMS_M, param) +# else +# define BOOST_PP_ENUM_TRAILING_PARAMS_Z(z, count, param) BOOST_PP_ENUM_TRAILING_PARAMS_Z_I(z, count, param) +# define BOOST_PP_ENUM_TRAILING_PARAMS_Z_I(z, count, param) BOOST_PP_REPEAT_ ## z(count, BOOST_PP_ENUM_TRAILING_PARAMS_M, param) +# endif +# +# endif diff --git a/realsense-file/3rd_party/boost/boost/preprocessor/repetition/for.hpp b/realsense-file/3rd_party/boost/boost/preprocessor/repetition/for.hpp new file mode 100644 index 0000000000..716814f156 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/preprocessor/repetition/for.hpp @@ -0,0 +1,306 @@ +# /* Copyright (C) 2001 +# * Housemarque Oy +# * http://www.housemarque.com +# * +# * 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) +# */ +# +# /* Revised by Paul Mensonides (2002) */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_REPETITION_FOR_HPP +# define BOOST_PREPROCESSOR_REPETITION_FOR_HPP +# +# include +# include +# include +# +# /* BOOST_PP_FOR */ +# +# if 0 +# define BOOST_PP_FOR(state, pred, op, macro) +# endif +# +# define BOOST_PP_FOR BOOST_PP_CAT(BOOST_PP_FOR_, BOOST_PP_AUTO_REC(BOOST_PP_FOR_P, 256)) +# +# define BOOST_PP_FOR_P(n) BOOST_PP_CAT(BOOST_PP_FOR_CHECK_, BOOST_PP_FOR_ ## n(1, BOOST_PP_FOR_SR_P, BOOST_PP_FOR_SR_O, BOOST_PP_FOR_SR_M)) +# +# define BOOST_PP_FOR_SR_P(r, s) s +# define BOOST_PP_FOR_SR_O(r, s) 0 +# define BOOST_PP_FOR_SR_M(r, s) BOOST_PP_NIL +# +# if BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() +# include +# elif BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MSVC() +# include +# elif BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_DMC() +# include +# else +# include +# endif +# +# define BOOST_PP_FOR_257(s, p, o, m) BOOST_PP_ERROR(0x0002) +# +# define BOOST_PP_FOR_CHECK_BOOST_PP_NIL 1 +# +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_1(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_2(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_3(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_4(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_5(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_6(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_7(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_8(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_9(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_10(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_11(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_12(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_13(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_14(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_15(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_16(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_17(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_18(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_19(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_20(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_21(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_22(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_23(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_24(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_25(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_26(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_27(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_28(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_29(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_30(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_31(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_32(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_33(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_34(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_35(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_36(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_37(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_38(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_39(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_40(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_41(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_42(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_43(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_44(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_45(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_46(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_47(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_48(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_49(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_50(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_51(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_52(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_53(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_54(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_55(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_56(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_57(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_58(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_59(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_60(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_61(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_62(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_63(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_64(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_65(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_66(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_67(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_68(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_69(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_70(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_71(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_72(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_73(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_74(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_75(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_76(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_77(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_78(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_79(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_80(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_81(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_82(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_83(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_84(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_85(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_86(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_87(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_88(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_89(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_90(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_91(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_92(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_93(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_94(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_95(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_96(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_97(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_98(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_99(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_100(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_101(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_102(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_103(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_104(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_105(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_106(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_107(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_108(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_109(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_110(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_111(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_112(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_113(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_114(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_115(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_116(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_117(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_118(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_119(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_120(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_121(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_122(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_123(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_124(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_125(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_126(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_127(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_128(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_129(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_130(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_131(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_132(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_133(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_134(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_135(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_136(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_137(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_138(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_139(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_140(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_141(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_142(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_143(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_144(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_145(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_146(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_147(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_148(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_149(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_150(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_151(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_152(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_153(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_154(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_155(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_156(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_157(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_158(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_159(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_160(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_161(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_162(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_163(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_164(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_165(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_166(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_167(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_168(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_169(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_170(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_171(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_172(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_173(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_174(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_175(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_176(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_177(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_178(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_179(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_180(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_181(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_182(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_183(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_184(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_185(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_186(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_187(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_188(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_189(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_190(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_191(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_192(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_193(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_194(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_195(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_196(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_197(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_198(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_199(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_200(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_201(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_202(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_203(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_204(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_205(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_206(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_207(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_208(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_209(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_210(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_211(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_212(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_213(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_214(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_215(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_216(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_217(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_218(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_219(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_220(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_221(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_222(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_223(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_224(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_225(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_226(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_227(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_228(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_229(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_230(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_231(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_232(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_233(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_234(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_235(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_236(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_237(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_238(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_239(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_240(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_241(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_242(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_243(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_244(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_245(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_246(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_247(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_248(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_249(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_250(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_251(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_252(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_253(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_254(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_255(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_256(s, p, o, m) 0 +# +# endif diff --git a/realsense-file/3rd_party/boost/boost/preprocessor/repetition/repeat.hpp b/realsense-file/3rd_party/boost/boost/preprocessor/repetition/repeat.hpp new file mode 100644 index 0000000000..fa31de39b6 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/preprocessor/repetition/repeat.hpp @@ -0,0 +1,825 @@ +# /* Copyright (C) 2001 +# * Housemarque Oy +# * http://www.housemarque.com +# * +# * 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) +# */ +# +# /* Revised by Paul Mensonides (2002) */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_REPETITION_REPEAT_HPP +# define BOOST_PREPROCESSOR_REPETITION_REPEAT_HPP +# +# include +# include +# include +# include +# include +# +# /* BOOST_PP_REPEAT */ +# +# if 0 +# define BOOST_PP_REPEAT(count, macro, data) +# endif +# +# define BOOST_PP_REPEAT BOOST_PP_CAT(BOOST_PP_REPEAT_, BOOST_PP_AUTO_REC(BOOST_PP_REPEAT_P, 4)) +# +# define BOOST_PP_REPEAT_P(n) BOOST_PP_CAT(BOOST_PP_REPEAT_CHECK_, BOOST_PP_REPEAT_ ## n(1, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3, BOOST_PP_NIL)) +# +# define BOOST_PP_REPEAT_CHECK_BOOST_PP_NIL 1 +# define BOOST_PP_REPEAT_CHECK_BOOST_PP_REPEAT_1(c, m, d) 0 +# define BOOST_PP_REPEAT_CHECK_BOOST_PP_REPEAT_2(c, m, d) 0 +# define BOOST_PP_REPEAT_CHECK_BOOST_PP_REPEAT_3(c, m, d) 0 +# +# define BOOST_PP_REPEAT_1(c, m, d) BOOST_PP_REPEAT_1_I(c, m, d) +# define BOOST_PP_REPEAT_2(c, m, d) BOOST_PP_REPEAT_2_I(c, m, d) +# define BOOST_PP_REPEAT_3(c, m, d) BOOST_PP_REPEAT_3_I(c, m, d) +# define BOOST_PP_REPEAT_4(c, m, d) BOOST_PP_ERROR(0x0003) +# +# define BOOST_PP_REPEAT_1_I(c, m, d) BOOST_PP_REPEAT_1_ ## c(m, d) +# define BOOST_PP_REPEAT_2_I(c, m, d) BOOST_PP_REPEAT_2_ ## c(m, d) +# define BOOST_PP_REPEAT_3_I(c, m, d) BOOST_PP_REPEAT_3_ ## c(m, d) +# +# define BOOST_PP_REPEAT_1ST BOOST_PP_REPEAT_1 +# define BOOST_PP_REPEAT_2ND BOOST_PP_REPEAT_2 +# define BOOST_PP_REPEAT_3RD BOOST_PP_REPEAT_3 +# +# define BOOST_PP_REPEAT_1_0(m, d) +# define BOOST_PP_REPEAT_1_1(m, d) m(2, 0, d) +# define BOOST_PP_REPEAT_1_2(m, d) BOOST_PP_REPEAT_1_1(m, d) m(2, 1, d) +# define BOOST_PP_REPEAT_1_3(m, d) BOOST_PP_REPEAT_1_2(m, d) m(2, 2, d) +# define BOOST_PP_REPEAT_1_4(m, d) BOOST_PP_REPEAT_1_3(m, d) m(2, 3, d) +# define BOOST_PP_REPEAT_1_5(m, d) BOOST_PP_REPEAT_1_4(m, d) m(2, 4, d) +# define BOOST_PP_REPEAT_1_6(m, d) BOOST_PP_REPEAT_1_5(m, d) m(2, 5, d) +# define BOOST_PP_REPEAT_1_7(m, d) BOOST_PP_REPEAT_1_6(m, d) m(2, 6, d) +# define BOOST_PP_REPEAT_1_8(m, d) BOOST_PP_REPEAT_1_7(m, d) m(2, 7, d) +# define BOOST_PP_REPEAT_1_9(m, d) BOOST_PP_REPEAT_1_8(m, d) m(2, 8, d) +# define BOOST_PP_REPEAT_1_10(m, d) BOOST_PP_REPEAT_1_9(m, d) m(2, 9, d) +# define BOOST_PP_REPEAT_1_11(m, d) BOOST_PP_REPEAT_1_10(m, d) m(2, 10, d) +# define BOOST_PP_REPEAT_1_12(m, d) BOOST_PP_REPEAT_1_11(m, d) m(2, 11, d) +# define BOOST_PP_REPEAT_1_13(m, d) BOOST_PP_REPEAT_1_12(m, d) m(2, 12, d) +# define BOOST_PP_REPEAT_1_14(m, d) BOOST_PP_REPEAT_1_13(m, d) m(2, 13, d) +# define BOOST_PP_REPEAT_1_15(m, d) BOOST_PP_REPEAT_1_14(m, d) m(2, 14, d) +# define BOOST_PP_REPEAT_1_16(m, d) BOOST_PP_REPEAT_1_15(m, d) m(2, 15, d) +# define BOOST_PP_REPEAT_1_17(m, d) BOOST_PP_REPEAT_1_16(m, d) m(2, 16, d) +# define BOOST_PP_REPEAT_1_18(m, d) BOOST_PP_REPEAT_1_17(m, d) m(2, 17, d) +# define BOOST_PP_REPEAT_1_19(m, d) BOOST_PP_REPEAT_1_18(m, d) m(2, 18, d) +# define BOOST_PP_REPEAT_1_20(m, d) BOOST_PP_REPEAT_1_19(m, d) m(2, 19, d) +# define BOOST_PP_REPEAT_1_21(m, d) BOOST_PP_REPEAT_1_20(m, d) m(2, 20, d) +# define BOOST_PP_REPEAT_1_22(m, d) BOOST_PP_REPEAT_1_21(m, d) m(2, 21, d) +# define BOOST_PP_REPEAT_1_23(m, d) BOOST_PP_REPEAT_1_22(m, d) m(2, 22, d) +# define BOOST_PP_REPEAT_1_24(m, d) BOOST_PP_REPEAT_1_23(m, d) m(2, 23, d) +# define BOOST_PP_REPEAT_1_25(m, d) BOOST_PP_REPEAT_1_24(m, d) m(2, 24, d) +# define BOOST_PP_REPEAT_1_26(m, d) BOOST_PP_REPEAT_1_25(m, d) m(2, 25, d) +# define BOOST_PP_REPEAT_1_27(m, d) BOOST_PP_REPEAT_1_26(m, d) m(2, 26, d) +# define BOOST_PP_REPEAT_1_28(m, d) BOOST_PP_REPEAT_1_27(m, d) m(2, 27, d) +# define BOOST_PP_REPEAT_1_29(m, d) BOOST_PP_REPEAT_1_28(m, d) m(2, 28, d) +# define BOOST_PP_REPEAT_1_30(m, d) BOOST_PP_REPEAT_1_29(m, d) m(2, 29, d) +# define BOOST_PP_REPEAT_1_31(m, d) BOOST_PP_REPEAT_1_30(m, d) m(2, 30, d) +# define BOOST_PP_REPEAT_1_32(m, d) BOOST_PP_REPEAT_1_31(m, d) m(2, 31, d) +# define BOOST_PP_REPEAT_1_33(m, d) BOOST_PP_REPEAT_1_32(m, d) m(2, 32, d) +# define BOOST_PP_REPEAT_1_34(m, d) BOOST_PP_REPEAT_1_33(m, d) m(2, 33, d) +# define BOOST_PP_REPEAT_1_35(m, d) BOOST_PP_REPEAT_1_34(m, d) m(2, 34, d) +# define BOOST_PP_REPEAT_1_36(m, d) BOOST_PP_REPEAT_1_35(m, d) m(2, 35, d) +# define BOOST_PP_REPEAT_1_37(m, d) BOOST_PP_REPEAT_1_36(m, d) m(2, 36, d) +# define BOOST_PP_REPEAT_1_38(m, d) BOOST_PP_REPEAT_1_37(m, d) m(2, 37, d) +# define BOOST_PP_REPEAT_1_39(m, d) BOOST_PP_REPEAT_1_38(m, d) m(2, 38, d) +# define BOOST_PP_REPEAT_1_40(m, d) BOOST_PP_REPEAT_1_39(m, d) m(2, 39, d) +# define BOOST_PP_REPEAT_1_41(m, d) BOOST_PP_REPEAT_1_40(m, d) m(2, 40, d) +# define BOOST_PP_REPEAT_1_42(m, d) BOOST_PP_REPEAT_1_41(m, d) m(2, 41, d) +# define BOOST_PP_REPEAT_1_43(m, d) BOOST_PP_REPEAT_1_42(m, d) m(2, 42, d) +# define BOOST_PP_REPEAT_1_44(m, d) BOOST_PP_REPEAT_1_43(m, d) m(2, 43, d) +# define BOOST_PP_REPEAT_1_45(m, d) BOOST_PP_REPEAT_1_44(m, d) m(2, 44, d) +# define BOOST_PP_REPEAT_1_46(m, d) BOOST_PP_REPEAT_1_45(m, d) m(2, 45, d) +# define BOOST_PP_REPEAT_1_47(m, d) BOOST_PP_REPEAT_1_46(m, d) m(2, 46, d) +# define BOOST_PP_REPEAT_1_48(m, d) BOOST_PP_REPEAT_1_47(m, d) m(2, 47, d) +# define BOOST_PP_REPEAT_1_49(m, d) BOOST_PP_REPEAT_1_48(m, d) m(2, 48, d) +# define BOOST_PP_REPEAT_1_50(m, d) BOOST_PP_REPEAT_1_49(m, d) m(2, 49, d) +# define BOOST_PP_REPEAT_1_51(m, d) BOOST_PP_REPEAT_1_50(m, d) m(2, 50, d) +# define BOOST_PP_REPEAT_1_52(m, d) BOOST_PP_REPEAT_1_51(m, d) m(2, 51, d) +# define BOOST_PP_REPEAT_1_53(m, d) BOOST_PP_REPEAT_1_52(m, d) m(2, 52, d) +# define BOOST_PP_REPEAT_1_54(m, d) BOOST_PP_REPEAT_1_53(m, d) m(2, 53, d) +# define BOOST_PP_REPEAT_1_55(m, d) BOOST_PP_REPEAT_1_54(m, d) m(2, 54, d) +# define BOOST_PP_REPEAT_1_56(m, d) BOOST_PP_REPEAT_1_55(m, d) m(2, 55, d) +# define BOOST_PP_REPEAT_1_57(m, d) BOOST_PP_REPEAT_1_56(m, d) m(2, 56, d) +# define BOOST_PP_REPEAT_1_58(m, d) BOOST_PP_REPEAT_1_57(m, d) m(2, 57, d) +# define BOOST_PP_REPEAT_1_59(m, d) BOOST_PP_REPEAT_1_58(m, d) m(2, 58, d) +# define BOOST_PP_REPEAT_1_60(m, d) BOOST_PP_REPEAT_1_59(m, d) m(2, 59, d) +# define BOOST_PP_REPEAT_1_61(m, d) BOOST_PP_REPEAT_1_60(m, d) m(2, 60, d) +# define BOOST_PP_REPEAT_1_62(m, d) BOOST_PP_REPEAT_1_61(m, d) m(2, 61, d) +# define BOOST_PP_REPEAT_1_63(m, d) BOOST_PP_REPEAT_1_62(m, d) m(2, 62, d) +# define BOOST_PP_REPEAT_1_64(m, d) BOOST_PP_REPEAT_1_63(m, d) m(2, 63, d) +# define BOOST_PP_REPEAT_1_65(m, d) BOOST_PP_REPEAT_1_64(m, d) m(2, 64, d) +# define BOOST_PP_REPEAT_1_66(m, d) BOOST_PP_REPEAT_1_65(m, d) m(2, 65, d) +# define BOOST_PP_REPEAT_1_67(m, d) BOOST_PP_REPEAT_1_66(m, d) m(2, 66, d) +# define BOOST_PP_REPEAT_1_68(m, d) BOOST_PP_REPEAT_1_67(m, d) m(2, 67, d) +# define BOOST_PP_REPEAT_1_69(m, d) BOOST_PP_REPEAT_1_68(m, d) m(2, 68, d) +# define BOOST_PP_REPEAT_1_70(m, d) BOOST_PP_REPEAT_1_69(m, d) m(2, 69, d) +# define BOOST_PP_REPEAT_1_71(m, d) BOOST_PP_REPEAT_1_70(m, d) m(2, 70, d) +# define BOOST_PP_REPEAT_1_72(m, d) BOOST_PP_REPEAT_1_71(m, d) m(2, 71, d) +# define BOOST_PP_REPEAT_1_73(m, d) BOOST_PP_REPEAT_1_72(m, d) m(2, 72, d) +# define BOOST_PP_REPEAT_1_74(m, d) BOOST_PP_REPEAT_1_73(m, d) m(2, 73, d) +# define BOOST_PP_REPEAT_1_75(m, d) BOOST_PP_REPEAT_1_74(m, d) m(2, 74, d) +# define BOOST_PP_REPEAT_1_76(m, d) BOOST_PP_REPEAT_1_75(m, d) m(2, 75, d) +# define BOOST_PP_REPEAT_1_77(m, d) BOOST_PP_REPEAT_1_76(m, d) m(2, 76, d) +# define BOOST_PP_REPEAT_1_78(m, d) BOOST_PP_REPEAT_1_77(m, d) m(2, 77, d) +# define BOOST_PP_REPEAT_1_79(m, d) BOOST_PP_REPEAT_1_78(m, d) m(2, 78, d) +# define BOOST_PP_REPEAT_1_80(m, d) BOOST_PP_REPEAT_1_79(m, d) m(2, 79, d) +# define BOOST_PP_REPEAT_1_81(m, d) BOOST_PP_REPEAT_1_80(m, d) m(2, 80, d) +# define BOOST_PP_REPEAT_1_82(m, d) BOOST_PP_REPEAT_1_81(m, d) m(2, 81, d) +# define BOOST_PP_REPEAT_1_83(m, d) BOOST_PP_REPEAT_1_82(m, d) m(2, 82, d) +# define BOOST_PP_REPEAT_1_84(m, d) BOOST_PP_REPEAT_1_83(m, d) m(2, 83, d) +# define BOOST_PP_REPEAT_1_85(m, d) BOOST_PP_REPEAT_1_84(m, d) m(2, 84, d) +# define BOOST_PP_REPEAT_1_86(m, d) BOOST_PP_REPEAT_1_85(m, d) m(2, 85, d) +# define BOOST_PP_REPEAT_1_87(m, d) BOOST_PP_REPEAT_1_86(m, d) m(2, 86, d) +# define BOOST_PP_REPEAT_1_88(m, d) BOOST_PP_REPEAT_1_87(m, d) m(2, 87, d) +# define BOOST_PP_REPEAT_1_89(m, d) BOOST_PP_REPEAT_1_88(m, d) m(2, 88, d) +# define BOOST_PP_REPEAT_1_90(m, d) BOOST_PP_REPEAT_1_89(m, d) m(2, 89, d) +# define BOOST_PP_REPEAT_1_91(m, d) BOOST_PP_REPEAT_1_90(m, d) m(2, 90, d) +# define BOOST_PP_REPEAT_1_92(m, d) BOOST_PP_REPEAT_1_91(m, d) m(2, 91, d) +# define BOOST_PP_REPEAT_1_93(m, d) BOOST_PP_REPEAT_1_92(m, d) m(2, 92, d) +# define BOOST_PP_REPEAT_1_94(m, d) BOOST_PP_REPEAT_1_93(m, d) m(2, 93, d) +# define BOOST_PP_REPEAT_1_95(m, d) BOOST_PP_REPEAT_1_94(m, d) m(2, 94, d) +# define BOOST_PP_REPEAT_1_96(m, d) BOOST_PP_REPEAT_1_95(m, d) m(2, 95, d) +# define BOOST_PP_REPEAT_1_97(m, d) BOOST_PP_REPEAT_1_96(m, d) m(2, 96, d) +# define BOOST_PP_REPEAT_1_98(m, d) BOOST_PP_REPEAT_1_97(m, d) m(2, 97, d) +# define BOOST_PP_REPEAT_1_99(m, d) BOOST_PP_REPEAT_1_98(m, d) m(2, 98, d) +# define BOOST_PP_REPEAT_1_100(m, d) BOOST_PP_REPEAT_1_99(m, d) m(2, 99, d) +# define BOOST_PP_REPEAT_1_101(m, d) BOOST_PP_REPEAT_1_100(m, d) m(2, 100, d) +# define BOOST_PP_REPEAT_1_102(m, d) BOOST_PP_REPEAT_1_101(m, d) m(2, 101, d) +# define BOOST_PP_REPEAT_1_103(m, d) BOOST_PP_REPEAT_1_102(m, d) m(2, 102, d) +# define BOOST_PP_REPEAT_1_104(m, d) BOOST_PP_REPEAT_1_103(m, d) m(2, 103, d) +# define BOOST_PP_REPEAT_1_105(m, d) BOOST_PP_REPEAT_1_104(m, d) m(2, 104, d) +# define BOOST_PP_REPEAT_1_106(m, d) BOOST_PP_REPEAT_1_105(m, d) m(2, 105, d) +# define BOOST_PP_REPEAT_1_107(m, d) BOOST_PP_REPEAT_1_106(m, d) m(2, 106, d) +# define BOOST_PP_REPEAT_1_108(m, d) BOOST_PP_REPEAT_1_107(m, d) m(2, 107, d) +# define BOOST_PP_REPEAT_1_109(m, d) BOOST_PP_REPEAT_1_108(m, d) m(2, 108, d) +# define BOOST_PP_REPEAT_1_110(m, d) BOOST_PP_REPEAT_1_109(m, d) m(2, 109, d) +# define BOOST_PP_REPEAT_1_111(m, d) BOOST_PP_REPEAT_1_110(m, d) m(2, 110, d) +# define BOOST_PP_REPEAT_1_112(m, d) BOOST_PP_REPEAT_1_111(m, d) m(2, 111, d) +# define BOOST_PP_REPEAT_1_113(m, d) BOOST_PP_REPEAT_1_112(m, d) m(2, 112, d) +# define BOOST_PP_REPEAT_1_114(m, d) BOOST_PP_REPEAT_1_113(m, d) m(2, 113, d) +# define BOOST_PP_REPEAT_1_115(m, d) BOOST_PP_REPEAT_1_114(m, d) m(2, 114, d) +# define BOOST_PP_REPEAT_1_116(m, d) BOOST_PP_REPEAT_1_115(m, d) m(2, 115, d) +# define BOOST_PP_REPEAT_1_117(m, d) BOOST_PP_REPEAT_1_116(m, d) m(2, 116, d) +# define BOOST_PP_REPEAT_1_118(m, d) BOOST_PP_REPEAT_1_117(m, d) m(2, 117, d) +# define BOOST_PP_REPEAT_1_119(m, d) BOOST_PP_REPEAT_1_118(m, d) m(2, 118, d) +# define BOOST_PP_REPEAT_1_120(m, d) BOOST_PP_REPEAT_1_119(m, d) m(2, 119, d) +# define BOOST_PP_REPEAT_1_121(m, d) BOOST_PP_REPEAT_1_120(m, d) m(2, 120, d) +# define BOOST_PP_REPEAT_1_122(m, d) BOOST_PP_REPEAT_1_121(m, d) m(2, 121, d) +# define BOOST_PP_REPEAT_1_123(m, d) BOOST_PP_REPEAT_1_122(m, d) m(2, 122, d) +# define BOOST_PP_REPEAT_1_124(m, d) BOOST_PP_REPEAT_1_123(m, d) m(2, 123, d) +# define BOOST_PP_REPEAT_1_125(m, d) BOOST_PP_REPEAT_1_124(m, d) m(2, 124, d) +# define BOOST_PP_REPEAT_1_126(m, d) BOOST_PP_REPEAT_1_125(m, d) m(2, 125, d) +# define BOOST_PP_REPEAT_1_127(m, d) BOOST_PP_REPEAT_1_126(m, d) m(2, 126, d) +# define BOOST_PP_REPEAT_1_128(m, d) BOOST_PP_REPEAT_1_127(m, d) m(2, 127, d) +# define BOOST_PP_REPEAT_1_129(m, d) BOOST_PP_REPEAT_1_128(m, d) m(2, 128, d) +# define BOOST_PP_REPEAT_1_130(m, d) BOOST_PP_REPEAT_1_129(m, d) m(2, 129, d) +# define BOOST_PP_REPEAT_1_131(m, d) BOOST_PP_REPEAT_1_130(m, d) m(2, 130, d) +# define BOOST_PP_REPEAT_1_132(m, d) BOOST_PP_REPEAT_1_131(m, d) m(2, 131, d) +# define BOOST_PP_REPEAT_1_133(m, d) BOOST_PP_REPEAT_1_132(m, d) m(2, 132, d) +# define BOOST_PP_REPEAT_1_134(m, d) BOOST_PP_REPEAT_1_133(m, d) m(2, 133, d) +# define BOOST_PP_REPEAT_1_135(m, d) BOOST_PP_REPEAT_1_134(m, d) m(2, 134, d) +# define BOOST_PP_REPEAT_1_136(m, d) BOOST_PP_REPEAT_1_135(m, d) m(2, 135, d) +# define BOOST_PP_REPEAT_1_137(m, d) BOOST_PP_REPEAT_1_136(m, d) m(2, 136, d) +# define BOOST_PP_REPEAT_1_138(m, d) BOOST_PP_REPEAT_1_137(m, d) m(2, 137, d) +# define BOOST_PP_REPEAT_1_139(m, d) BOOST_PP_REPEAT_1_138(m, d) m(2, 138, d) +# define BOOST_PP_REPEAT_1_140(m, d) BOOST_PP_REPEAT_1_139(m, d) m(2, 139, d) +# define BOOST_PP_REPEAT_1_141(m, d) BOOST_PP_REPEAT_1_140(m, d) m(2, 140, d) +# define BOOST_PP_REPEAT_1_142(m, d) BOOST_PP_REPEAT_1_141(m, d) m(2, 141, d) +# define BOOST_PP_REPEAT_1_143(m, d) BOOST_PP_REPEAT_1_142(m, d) m(2, 142, d) +# define BOOST_PP_REPEAT_1_144(m, d) BOOST_PP_REPEAT_1_143(m, d) m(2, 143, d) +# define BOOST_PP_REPEAT_1_145(m, d) BOOST_PP_REPEAT_1_144(m, d) m(2, 144, d) +# define BOOST_PP_REPEAT_1_146(m, d) BOOST_PP_REPEAT_1_145(m, d) m(2, 145, d) +# define BOOST_PP_REPEAT_1_147(m, d) BOOST_PP_REPEAT_1_146(m, d) m(2, 146, d) +# define BOOST_PP_REPEAT_1_148(m, d) BOOST_PP_REPEAT_1_147(m, d) m(2, 147, d) +# define BOOST_PP_REPEAT_1_149(m, d) BOOST_PP_REPEAT_1_148(m, d) m(2, 148, d) +# define BOOST_PP_REPEAT_1_150(m, d) BOOST_PP_REPEAT_1_149(m, d) m(2, 149, d) +# define BOOST_PP_REPEAT_1_151(m, d) BOOST_PP_REPEAT_1_150(m, d) m(2, 150, d) +# define BOOST_PP_REPEAT_1_152(m, d) BOOST_PP_REPEAT_1_151(m, d) m(2, 151, d) +# define BOOST_PP_REPEAT_1_153(m, d) BOOST_PP_REPEAT_1_152(m, d) m(2, 152, d) +# define BOOST_PP_REPEAT_1_154(m, d) BOOST_PP_REPEAT_1_153(m, d) m(2, 153, d) +# define BOOST_PP_REPEAT_1_155(m, d) BOOST_PP_REPEAT_1_154(m, d) m(2, 154, d) +# define BOOST_PP_REPEAT_1_156(m, d) BOOST_PP_REPEAT_1_155(m, d) m(2, 155, d) +# define BOOST_PP_REPEAT_1_157(m, d) BOOST_PP_REPEAT_1_156(m, d) m(2, 156, d) +# define BOOST_PP_REPEAT_1_158(m, d) BOOST_PP_REPEAT_1_157(m, d) m(2, 157, d) +# define BOOST_PP_REPEAT_1_159(m, d) BOOST_PP_REPEAT_1_158(m, d) m(2, 158, d) +# define BOOST_PP_REPEAT_1_160(m, d) BOOST_PP_REPEAT_1_159(m, d) m(2, 159, d) +# define BOOST_PP_REPEAT_1_161(m, d) BOOST_PP_REPEAT_1_160(m, d) m(2, 160, d) +# define BOOST_PP_REPEAT_1_162(m, d) BOOST_PP_REPEAT_1_161(m, d) m(2, 161, d) +# define BOOST_PP_REPEAT_1_163(m, d) BOOST_PP_REPEAT_1_162(m, d) m(2, 162, d) +# define BOOST_PP_REPEAT_1_164(m, d) BOOST_PP_REPEAT_1_163(m, d) m(2, 163, d) +# define BOOST_PP_REPEAT_1_165(m, d) BOOST_PP_REPEAT_1_164(m, d) m(2, 164, d) +# define BOOST_PP_REPEAT_1_166(m, d) BOOST_PP_REPEAT_1_165(m, d) m(2, 165, d) +# define BOOST_PP_REPEAT_1_167(m, d) BOOST_PP_REPEAT_1_166(m, d) m(2, 166, d) +# define BOOST_PP_REPEAT_1_168(m, d) BOOST_PP_REPEAT_1_167(m, d) m(2, 167, d) +# define BOOST_PP_REPEAT_1_169(m, d) BOOST_PP_REPEAT_1_168(m, d) m(2, 168, d) +# define BOOST_PP_REPEAT_1_170(m, d) BOOST_PP_REPEAT_1_169(m, d) m(2, 169, d) +# define BOOST_PP_REPEAT_1_171(m, d) BOOST_PP_REPEAT_1_170(m, d) m(2, 170, d) +# define BOOST_PP_REPEAT_1_172(m, d) BOOST_PP_REPEAT_1_171(m, d) m(2, 171, d) +# define BOOST_PP_REPEAT_1_173(m, d) BOOST_PP_REPEAT_1_172(m, d) m(2, 172, d) +# define BOOST_PP_REPEAT_1_174(m, d) BOOST_PP_REPEAT_1_173(m, d) m(2, 173, d) +# define BOOST_PP_REPEAT_1_175(m, d) BOOST_PP_REPEAT_1_174(m, d) m(2, 174, d) +# define BOOST_PP_REPEAT_1_176(m, d) BOOST_PP_REPEAT_1_175(m, d) m(2, 175, d) +# define BOOST_PP_REPEAT_1_177(m, d) BOOST_PP_REPEAT_1_176(m, d) m(2, 176, d) +# define BOOST_PP_REPEAT_1_178(m, d) BOOST_PP_REPEAT_1_177(m, d) m(2, 177, d) +# define BOOST_PP_REPEAT_1_179(m, d) BOOST_PP_REPEAT_1_178(m, d) m(2, 178, d) +# define BOOST_PP_REPEAT_1_180(m, d) BOOST_PP_REPEAT_1_179(m, d) m(2, 179, d) +# define BOOST_PP_REPEAT_1_181(m, d) BOOST_PP_REPEAT_1_180(m, d) m(2, 180, d) +# define BOOST_PP_REPEAT_1_182(m, d) BOOST_PP_REPEAT_1_181(m, d) m(2, 181, d) +# define BOOST_PP_REPEAT_1_183(m, d) BOOST_PP_REPEAT_1_182(m, d) m(2, 182, d) +# define BOOST_PP_REPEAT_1_184(m, d) BOOST_PP_REPEAT_1_183(m, d) m(2, 183, d) +# define BOOST_PP_REPEAT_1_185(m, d) BOOST_PP_REPEAT_1_184(m, d) m(2, 184, d) +# define BOOST_PP_REPEAT_1_186(m, d) BOOST_PP_REPEAT_1_185(m, d) m(2, 185, d) +# define BOOST_PP_REPEAT_1_187(m, d) BOOST_PP_REPEAT_1_186(m, d) m(2, 186, d) +# define BOOST_PP_REPEAT_1_188(m, d) BOOST_PP_REPEAT_1_187(m, d) m(2, 187, d) +# define BOOST_PP_REPEAT_1_189(m, d) BOOST_PP_REPEAT_1_188(m, d) m(2, 188, d) +# define BOOST_PP_REPEAT_1_190(m, d) BOOST_PP_REPEAT_1_189(m, d) m(2, 189, d) +# define BOOST_PP_REPEAT_1_191(m, d) BOOST_PP_REPEAT_1_190(m, d) m(2, 190, d) +# define BOOST_PP_REPEAT_1_192(m, d) BOOST_PP_REPEAT_1_191(m, d) m(2, 191, d) +# define BOOST_PP_REPEAT_1_193(m, d) BOOST_PP_REPEAT_1_192(m, d) m(2, 192, d) +# define BOOST_PP_REPEAT_1_194(m, d) BOOST_PP_REPEAT_1_193(m, d) m(2, 193, d) +# define BOOST_PP_REPEAT_1_195(m, d) BOOST_PP_REPEAT_1_194(m, d) m(2, 194, d) +# define BOOST_PP_REPEAT_1_196(m, d) BOOST_PP_REPEAT_1_195(m, d) m(2, 195, d) +# define BOOST_PP_REPEAT_1_197(m, d) BOOST_PP_REPEAT_1_196(m, d) m(2, 196, d) +# define BOOST_PP_REPEAT_1_198(m, d) BOOST_PP_REPEAT_1_197(m, d) m(2, 197, d) +# define BOOST_PP_REPEAT_1_199(m, d) BOOST_PP_REPEAT_1_198(m, d) m(2, 198, d) +# define BOOST_PP_REPEAT_1_200(m, d) BOOST_PP_REPEAT_1_199(m, d) m(2, 199, d) +# define BOOST_PP_REPEAT_1_201(m, d) BOOST_PP_REPEAT_1_200(m, d) m(2, 200, d) +# define BOOST_PP_REPEAT_1_202(m, d) BOOST_PP_REPEAT_1_201(m, d) m(2, 201, d) +# define BOOST_PP_REPEAT_1_203(m, d) BOOST_PP_REPEAT_1_202(m, d) m(2, 202, d) +# define BOOST_PP_REPEAT_1_204(m, d) BOOST_PP_REPEAT_1_203(m, d) m(2, 203, d) +# define BOOST_PP_REPEAT_1_205(m, d) BOOST_PP_REPEAT_1_204(m, d) m(2, 204, d) +# define BOOST_PP_REPEAT_1_206(m, d) BOOST_PP_REPEAT_1_205(m, d) m(2, 205, d) +# define BOOST_PP_REPEAT_1_207(m, d) BOOST_PP_REPEAT_1_206(m, d) m(2, 206, d) +# define BOOST_PP_REPEAT_1_208(m, d) BOOST_PP_REPEAT_1_207(m, d) m(2, 207, d) +# define BOOST_PP_REPEAT_1_209(m, d) BOOST_PP_REPEAT_1_208(m, d) m(2, 208, d) +# define BOOST_PP_REPEAT_1_210(m, d) BOOST_PP_REPEAT_1_209(m, d) m(2, 209, d) +# define BOOST_PP_REPEAT_1_211(m, d) BOOST_PP_REPEAT_1_210(m, d) m(2, 210, d) +# define BOOST_PP_REPEAT_1_212(m, d) BOOST_PP_REPEAT_1_211(m, d) m(2, 211, d) +# define BOOST_PP_REPEAT_1_213(m, d) BOOST_PP_REPEAT_1_212(m, d) m(2, 212, d) +# define BOOST_PP_REPEAT_1_214(m, d) BOOST_PP_REPEAT_1_213(m, d) m(2, 213, d) +# define BOOST_PP_REPEAT_1_215(m, d) BOOST_PP_REPEAT_1_214(m, d) m(2, 214, d) +# define BOOST_PP_REPEAT_1_216(m, d) BOOST_PP_REPEAT_1_215(m, d) m(2, 215, d) +# define BOOST_PP_REPEAT_1_217(m, d) BOOST_PP_REPEAT_1_216(m, d) m(2, 216, d) +# define BOOST_PP_REPEAT_1_218(m, d) BOOST_PP_REPEAT_1_217(m, d) m(2, 217, d) +# define BOOST_PP_REPEAT_1_219(m, d) BOOST_PP_REPEAT_1_218(m, d) m(2, 218, d) +# define BOOST_PP_REPEAT_1_220(m, d) BOOST_PP_REPEAT_1_219(m, d) m(2, 219, d) +# define BOOST_PP_REPEAT_1_221(m, d) BOOST_PP_REPEAT_1_220(m, d) m(2, 220, d) +# define BOOST_PP_REPEAT_1_222(m, d) BOOST_PP_REPEAT_1_221(m, d) m(2, 221, d) +# define BOOST_PP_REPEAT_1_223(m, d) BOOST_PP_REPEAT_1_222(m, d) m(2, 222, d) +# define BOOST_PP_REPEAT_1_224(m, d) BOOST_PP_REPEAT_1_223(m, d) m(2, 223, d) +# define BOOST_PP_REPEAT_1_225(m, d) BOOST_PP_REPEAT_1_224(m, d) m(2, 224, d) +# define BOOST_PP_REPEAT_1_226(m, d) BOOST_PP_REPEAT_1_225(m, d) m(2, 225, d) +# define BOOST_PP_REPEAT_1_227(m, d) BOOST_PP_REPEAT_1_226(m, d) m(2, 226, d) +# define BOOST_PP_REPEAT_1_228(m, d) BOOST_PP_REPEAT_1_227(m, d) m(2, 227, d) +# define BOOST_PP_REPEAT_1_229(m, d) BOOST_PP_REPEAT_1_228(m, d) m(2, 228, d) +# define BOOST_PP_REPEAT_1_230(m, d) BOOST_PP_REPEAT_1_229(m, d) m(2, 229, d) +# define BOOST_PP_REPEAT_1_231(m, d) BOOST_PP_REPEAT_1_230(m, d) m(2, 230, d) +# define BOOST_PP_REPEAT_1_232(m, d) BOOST_PP_REPEAT_1_231(m, d) m(2, 231, d) +# define BOOST_PP_REPEAT_1_233(m, d) BOOST_PP_REPEAT_1_232(m, d) m(2, 232, d) +# define BOOST_PP_REPEAT_1_234(m, d) BOOST_PP_REPEAT_1_233(m, d) m(2, 233, d) +# define BOOST_PP_REPEAT_1_235(m, d) BOOST_PP_REPEAT_1_234(m, d) m(2, 234, d) +# define BOOST_PP_REPEAT_1_236(m, d) BOOST_PP_REPEAT_1_235(m, d) m(2, 235, d) +# define BOOST_PP_REPEAT_1_237(m, d) BOOST_PP_REPEAT_1_236(m, d) m(2, 236, d) +# define BOOST_PP_REPEAT_1_238(m, d) BOOST_PP_REPEAT_1_237(m, d) m(2, 237, d) +# define BOOST_PP_REPEAT_1_239(m, d) BOOST_PP_REPEAT_1_238(m, d) m(2, 238, d) +# define BOOST_PP_REPEAT_1_240(m, d) BOOST_PP_REPEAT_1_239(m, d) m(2, 239, d) +# define BOOST_PP_REPEAT_1_241(m, d) BOOST_PP_REPEAT_1_240(m, d) m(2, 240, d) +# define BOOST_PP_REPEAT_1_242(m, d) BOOST_PP_REPEAT_1_241(m, d) m(2, 241, d) +# define BOOST_PP_REPEAT_1_243(m, d) BOOST_PP_REPEAT_1_242(m, d) m(2, 242, d) +# define BOOST_PP_REPEAT_1_244(m, d) BOOST_PP_REPEAT_1_243(m, d) m(2, 243, d) +# define BOOST_PP_REPEAT_1_245(m, d) BOOST_PP_REPEAT_1_244(m, d) m(2, 244, d) +# define BOOST_PP_REPEAT_1_246(m, d) BOOST_PP_REPEAT_1_245(m, d) m(2, 245, d) +# define BOOST_PP_REPEAT_1_247(m, d) BOOST_PP_REPEAT_1_246(m, d) m(2, 246, d) +# define BOOST_PP_REPEAT_1_248(m, d) BOOST_PP_REPEAT_1_247(m, d) m(2, 247, d) +# define BOOST_PP_REPEAT_1_249(m, d) BOOST_PP_REPEAT_1_248(m, d) m(2, 248, d) +# define BOOST_PP_REPEAT_1_250(m, d) BOOST_PP_REPEAT_1_249(m, d) m(2, 249, d) +# define BOOST_PP_REPEAT_1_251(m, d) BOOST_PP_REPEAT_1_250(m, d) m(2, 250, d) +# define BOOST_PP_REPEAT_1_252(m, d) BOOST_PP_REPEAT_1_251(m, d) m(2, 251, d) +# define BOOST_PP_REPEAT_1_253(m, d) BOOST_PP_REPEAT_1_252(m, d) m(2, 252, d) +# define BOOST_PP_REPEAT_1_254(m, d) BOOST_PP_REPEAT_1_253(m, d) m(2, 253, d) +# define BOOST_PP_REPEAT_1_255(m, d) BOOST_PP_REPEAT_1_254(m, d) m(2, 254, d) +# define BOOST_PP_REPEAT_1_256(m, d) BOOST_PP_REPEAT_1_255(m, d) m(2, 255, d) +# +# define BOOST_PP_REPEAT_2_0(m, d) +# define BOOST_PP_REPEAT_2_1(m, d) m(3, 0, d) +# define BOOST_PP_REPEAT_2_2(m, d) BOOST_PP_REPEAT_2_1(m, d) m(3, 1, d) +# define BOOST_PP_REPEAT_2_3(m, d) BOOST_PP_REPEAT_2_2(m, d) m(3, 2, d) +# define BOOST_PP_REPEAT_2_4(m, d) BOOST_PP_REPEAT_2_3(m, d) m(3, 3, d) +# define BOOST_PP_REPEAT_2_5(m, d) BOOST_PP_REPEAT_2_4(m, d) m(3, 4, d) +# define BOOST_PP_REPEAT_2_6(m, d) BOOST_PP_REPEAT_2_5(m, d) m(3, 5, d) +# define BOOST_PP_REPEAT_2_7(m, d) BOOST_PP_REPEAT_2_6(m, d) m(3, 6, d) +# define BOOST_PP_REPEAT_2_8(m, d) BOOST_PP_REPEAT_2_7(m, d) m(3, 7, d) +# define BOOST_PP_REPEAT_2_9(m, d) BOOST_PP_REPEAT_2_8(m, d) m(3, 8, d) +# define BOOST_PP_REPEAT_2_10(m, d) BOOST_PP_REPEAT_2_9(m, d) m(3, 9, d) +# define BOOST_PP_REPEAT_2_11(m, d) BOOST_PP_REPEAT_2_10(m, d) m(3, 10, d) +# define BOOST_PP_REPEAT_2_12(m, d) BOOST_PP_REPEAT_2_11(m, d) m(3, 11, d) +# define BOOST_PP_REPEAT_2_13(m, d) BOOST_PP_REPEAT_2_12(m, d) m(3, 12, d) +# define BOOST_PP_REPEAT_2_14(m, d) BOOST_PP_REPEAT_2_13(m, d) m(3, 13, d) +# define BOOST_PP_REPEAT_2_15(m, d) BOOST_PP_REPEAT_2_14(m, d) m(3, 14, d) +# define BOOST_PP_REPEAT_2_16(m, d) BOOST_PP_REPEAT_2_15(m, d) m(3, 15, d) +# define BOOST_PP_REPEAT_2_17(m, d) BOOST_PP_REPEAT_2_16(m, d) m(3, 16, d) +# define BOOST_PP_REPEAT_2_18(m, d) BOOST_PP_REPEAT_2_17(m, d) m(3, 17, d) +# define BOOST_PP_REPEAT_2_19(m, d) BOOST_PP_REPEAT_2_18(m, d) m(3, 18, d) +# define BOOST_PP_REPEAT_2_20(m, d) BOOST_PP_REPEAT_2_19(m, d) m(3, 19, d) +# define BOOST_PP_REPEAT_2_21(m, d) BOOST_PP_REPEAT_2_20(m, d) m(3, 20, d) +# define BOOST_PP_REPEAT_2_22(m, d) BOOST_PP_REPEAT_2_21(m, d) m(3, 21, d) +# define BOOST_PP_REPEAT_2_23(m, d) BOOST_PP_REPEAT_2_22(m, d) m(3, 22, d) +# define BOOST_PP_REPEAT_2_24(m, d) BOOST_PP_REPEAT_2_23(m, d) m(3, 23, d) +# define BOOST_PP_REPEAT_2_25(m, d) BOOST_PP_REPEAT_2_24(m, d) m(3, 24, d) +# define BOOST_PP_REPEAT_2_26(m, d) BOOST_PP_REPEAT_2_25(m, d) m(3, 25, d) +# define BOOST_PP_REPEAT_2_27(m, d) BOOST_PP_REPEAT_2_26(m, d) m(3, 26, d) +# define BOOST_PP_REPEAT_2_28(m, d) BOOST_PP_REPEAT_2_27(m, d) m(3, 27, d) +# define BOOST_PP_REPEAT_2_29(m, d) BOOST_PP_REPEAT_2_28(m, d) m(3, 28, d) +# define BOOST_PP_REPEAT_2_30(m, d) BOOST_PP_REPEAT_2_29(m, d) m(3, 29, d) +# define BOOST_PP_REPEAT_2_31(m, d) BOOST_PP_REPEAT_2_30(m, d) m(3, 30, d) +# define BOOST_PP_REPEAT_2_32(m, d) BOOST_PP_REPEAT_2_31(m, d) m(3, 31, d) +# define BOOST_PP_REPEAT_2_33(m, d) BOOST_PP_REPEAT_2_32(m, d) m(3, 32, d) +# define BOOST_PP_REPEAT_2_34(m, d) BOOST_PP_REPEAT_2_33(m, d) m(3, 33, d) +# define BOOST_PP_REPEAT_2_35(m, d) BOOST_PP_REPEAT_2_34(m, d) m(3, 34, d) +# define BOOST_PP_REPEAT_2_36(m, d) BOOST_PP_REPEAT_2_35(m, d) m(3, 35, d) +# define BOOST_PP_REPEAT_2_37(m, d) BOOST_PP_REPEAT_2_36(m, d) m(3, 36, d) +# define BOOST_PP_REPEAT_2_38(m, d) BOOST_PP_REPEAT_2_37(m, d) m(3, 37, d) +# define BOOST_PP_REPEAT_2_39(m, d) BOOST_PP_REPEAT_2_38(m, d) m(3, 38, d) +# define BOOST_PP_REPEAT_2_40(m, d) BOOST_PP_REPEAT_2_39(m, d) m(3, 39, d) +# define BOOST_PP_REPEAT_2_41(m, d) BOOST_PP_REPEAT_2_40(m, d) m(3, 40, d) +# define BOOST_PP_REPEAT_2_42(m, d) BOOST_PP_REPEAT_2_41(m, d) m(3, 41, d) +# define BOOST_PP_REPEAT_2_43(m, d) BOOST_PP_REPEAT_2_42(m, d) m(3, 42, d) +# define BOOST_PP_REPEAT_2_44(m, d) BOOST_PP_REPEAT_2_43(m, d) m(3, 43, d) +# define BOOST_PP_REPEAT_2_45(m, d) BOOST_PP_REPEAT_2_44(m, d) m(3, 44, d) +# define BOOST_PP_REPEAT_2_46(m, d) BOOST_PP_REPEAT_2_45(m, d) m(3, 45, d) +# define BOOST_PP_REPEAT_2_47(m, d) BOOST_PP_REPEAT_2_46(m, d) m(3, 46, d) +# define BOOST_PP_REPEAT_2_48(m, d) BOOST_PP_REPEAT_2_47(m, d) m(3, 47, d) +# define BOOST_PP_REPEAT_2_49(m, d) BOOST_PP_REPEAT_2_48(m, d) m(3, 48, d) +# define BOOST_PP_REPEAT_2_50(m, d) BOOST_PP_REPEAT_2_49(m, d) m(3, 49, d) +# define BOOST_PP_REPEAT_2_51(m, d) BOOST_PP_REPEAT_2_50(m, d) m(3, 50, d) +# define BOOST_PP_REPEAT_2_52(m, d) BOOST_PP_REPEAT_2_51(m, d) m(3, 51, d) +# define BOOST_PP_REPEAT_2_53(m, d) BOOST_PP_REPEAT_2_52(m, d) m(3, 52, d) +# define BOOST_PP_REPEAT_2_54(m, d) BOOST_PP_REPEAT_2_53(m, d) m(3, 53, d) +# define BOOST_PP_REPEAT_2_55(m, d) BOOST_PP_REPEAT_2_54(m, d) m(3, 54, d) +# define BOOST_PP_REPEAT_2_56(m, d) BOOST_PP_REPEAT_2_55(m, d) m(3, 55, d) +# define BOOST_PP_REPEAT_2_57(m, d) BOOST_PP_REPEAT_2_56(m, d) m(3, 56, d) +# define BOOST_PP_REPEAT_2_58(m, d) BOOST_PP_REPEAT_2_57(m, d) m(3, 57, d) +# define BOOST_PP_REPEAT_2_59(m, d) BOOST_PP_REPEAT_2_58(m, d) m(3, 58, d) +# define BOOST_PP_REPEAT_2_60(m, d) BOOST_PP_REPEAT_2_59(m, d) m(3, 59, d) +# define BOOST_PP_REPEAT_2_61(m, d) BOOST_PP_REPEAT_2_60(m, d) m(3, 60, d) +# define BOOST_PP_REPEAT_2_62(m, d) BOOST_PP_REPEAT_2_61(m, d) m(3, 61, d) +# define BOOST_PP_REPEAT_2_63(m, d) BOOST_PP_REPEAT_2_62(m, d) m(3, 62, d) +# define BOOST_PP_REPEAT_2_64(m, d) BOOST_PP_REPEAT_2_63(m, d) m(3, 63, d) +# define BOOST_PP_REPEAT_2_65(m, d) BOOST_PP_REPEAT_2_64(m, d) m(3, 64, d) +# define BOOST_PP_REPEAT_2_66(m, d) BOOST_PP_REPEAT_2_65(m, d) m(3, 65, d) +# define BOOST_PP_REPEAT_2_67(m, d) BOOST_PP_REPEAT_2_66(m, d) m(3, 66, d) +# define BOOST_PP_REPEAT_2_68(m, d) BOOST_PP_REPEAT_2_67(m, d) m(3, 67, d) +# define BOOST_PP_REPEAT_2_69(m, d) BOOST_PP_REPEAT_2_68(m, d) m(3, 68, d) +# define BOOST_PP_REPEAT_2_70(m, d) BOOST_PP_REPEAT_2_69(m, d) m(3, 69, d) +# define BOOST_PP_REPEAT_2_71(m, d) BOOST_PP_REPEAT_2_70(m, d) m(3, 70, d) +# define BOOST_PP_REPEAT_2_72(m, d) BOOST_PP_REPEAT_2_71(m, d) m(3, 71, d) +# define BOOST_PP_REPEAT_2_73(m, d) BOOST_PP_REPEAT_2_72(m, d) m(3, 72, d) +# define BOOST_PP_REPEAT_2_74(m, d) BOOST_PP_REPEAT_2_73(m, d) m(3, 73, d) +# define BOOST_PP_REPEAT_2_75(m, d) BOOST_PP_REPEAT_2_74(m, d) m(3, 74, d) +# define BOOST_PP_REPEAT_2_76(m, d) BOOST_PP_REPEAT_2_75(m, d) m(3, 75, d) +# define BOOST_PP_REPEAT_2_77(m, d) BOOST_PP_REPEAT_2_76(m, d) m(3, 76, d) +# define BOOST_PP_REPEAT_2_78(m, d) BOOST_PP_REPEAT_2_77(m, d) m(3, 77, d) +# define BOOST_PP_REPEAT_2_79(m, d) BOOST_PP_REPEAT_2_78(m, d) m(3, 78, d) +# define BOOST_PP_REPEAT_2_80(m, d) BOOST_PP_REPEAT_2_79(m, d) m(3, 79, d) +# define BOOST_PP_REPEAT_2_81(m, d) BOOST_PP_REPEAT_2_80(m, d) m(3, 80, d) +# define BOOST_PP_REPEAT_2_82(m, d) BOOST_PP_REPEAT_2_81(m, d) m(3, 81, d) +# define BOOST_PP_REPEAT_2_83(m, d) BOOST_PP_REPEAT_2_82(m, d) m(3, 82, d) +# define BOOST_PP_REPEAT_2_84(m, d) BOOST_PP_REPEAT_2_83(m, d) m(3, 83, d) +# define BOOST_PP_REPEAT_2_85(m, d) BOOST_PP_REPEAT_2_84(m, d) m(3, 84, d) +# define BOOST_PP_REPEAT_2_86(m, d) BOOST_PP_REPEAT_2_85(m, d) m(3, 85, d) +# define BOOST_PP_REPEAT_2_87(m, d) BOOST_PP_REPEAT_2_86(m, d) m(3, 86, d) +# define BOOST_PP_REPEAT_2_88(m, d) BOOST_PP_REPEAT_2_87(m, d) m(3, 87, d) +# define BOOST_PP_REPEAT_2_89(m, d) BOOST_PP_REPEAT_2_88(m, d) m(3, 88, d) +# define BOOST_PP_REPEAT_2_90(m, d) BOOST_PP_REPEAT_2_89(m, d) m(3, 89, d) +# define BOOST_PP_REPEAT_2_91(m, d) BOOST_PP_REPEAT_2_90(m, d) m(3, 90, d) +# define BOOST_PP_REPEAT_2_92(m, d) BOOST_PP_REPEAT_2_91(m, d) m(3, 91, d) +# define BOOST_PP_REPEAT_2_93(m, d) BOOST_PP_REPEAT_2_92(m, d) m(3, 92, d) +# define BOOST_PP_REPEAT_2_94(m, d) BOOST_PP_REPEAT_2_93(m, d) m(3, 93, d) +# define BOOST_PP_REPEAT_2_95(m, d) BOOST_PP_REPEAT_2_94(m, d) m(3, 94, d) +# define BOOST_PP_REPEAT_2_96(m, d) BOOST_PP_REPEAT_2_95(m, d) m(3, 95, d) +# define BOOST_PP_REPEAT_2_97(m, d) BOOST_PP_REPEAT_2_96(m, d) m(3, 96, d) +# define BOOST_PP_REPEAT_2_98(m, d) BOOST_PP_REPEAT_2_97(m, d) m(3, 97, d) +# define BOOST_PP_REPEAT_2_99(m, d) BOOST_PP_REPEAT_2_98(m, d) m(3, 98, d) +# define BOOST_PP_REPEAT_2_100(m, d) BOOST_PP_REPEAT_2_99(m, d) m(3, 99, d) +# define BOOST_PP_REPEAT_2_101(m, d) BOOST_PP_REPEAT_2_100(m, d) m(3, 100, d) +# define BOOST_PP_REPEAT_2_102(m, d) BOOST_PP_REPEAT_2_101(m, d) m(3, 101, d) +# define BOOST_PP_REPEAT_2_103(m, d) BOOST_PP_REPEAT_2_102(m, d) m(3, 102, d) +# define BOOST_PP_REPEAT_2_104(m, d) BOOST_PP_REPEAT_2_103(m, d) m(3, 103, d) +# define BOOST_PP_REPEAT_2_105(m, d) BOOST_PP_REPEAT_2_104(m, d) m(3, 104, d) +# define BOOST_PP_REPEAT_2_106(m, d) BOOST_PP_REPEAT_2_105(m, d) m(3, 105, d) +# define BOOST_PP_REPEAT_2_107(m, d) BOOST_PP_REPEAT_2_106(m, d) m(3, 106, d) +# define BOOST_PP_REPEAT_2_108(m, d) BOOST_PP_REPEAT_2_107(m, d) m(3, 107, d) +# define BOOST_PP_REPEAT_2_109(m, d) BOOST_PP_REPEAT_2_108(m, d) m(3, 108, d) +# define BOOST_PP_REPEAT_2_110(m, d) BOOST_PP_REPEAT_2_109(m, d) m(3, 109, d) +# define BOOST_PP_REPEAT_2_111(m, d) BOOST_PP_REPEAT_2_110(m, d) m(3, 110, d) +# define BOOST_PP_REPEAT_2_112(m, d) BOOST_PP_REPEAT_2_111(m, d) m(3, 111, d) +# define BOOST_PP_REPEAT_2_113(m, d) BOOST_PP_REPEAT_2_112(m, d) m(3, 112, d) +# define BOOST_PP_REPEAT_2_114(m, d) BOOST_PP_REPEAT_2_113(m, d) m(3, 113, d) +# define BOOST_PP_REPEAT_2_115(m, d) BOOST_PP_REPEAT_2_114(m, d) m(3, 114, d) +# define BOOST_PP_REPEAT_2_116(m, d) BOOST_PP_REPEAT_2_115(m, d) m(3, 115, d) +# define BOOST_PP_REPEAT_2_117(m, d) BOOST_PP_REPEAT_2_116(m, d) m(3, 116, d) +# define BOOST_PP_REPEAT_2_118(m, d) BOOST_PP_REPEAT_2_117(m, d) m(3, 117, d) +# define BOOST_PP_REPEAT_2_119(m, d) BOOST_PP_REPEAT_2_118(m, d) m(3, 118, d) +# define BOOST_PP_REPEAT_2_120(m, d) BOOST_PP_REPEAT_2_119(m, d) m(3, 119, d) +# define BOOST_PP_REPEAT_2_121(m, d) BOOST_PP_REPEAT_2_120(m, d) m(3, 120, d) +# define BOOST_PP_REPEAT_2_122(m, d) BOOST_PP_REPEAT_2_121(m, d) m(3, 121, d) +# define BOOST_PP_REPEAT_2_123(m, d) BOOST_PP_REPEAT_2_122(m, d) m(3, 122, d) +# define BOOST_PP_REPEAT_2_124(m, d) BOOST_PP_REPEAT_2_123(m, d) m(3, 123, d) +# define BOOST_PP_REPEAT_2_125(m, d) BOOST_PP_REPEAT_2_124(m, d) m(3, 124, d) +# define BOOST_PP_REPEAT_2_126(m, d) BOOST_PP_REPEAT_2_125(m, d) m(3, 125, d) +# define BOOST_PP_REPEAT_2_127(m, d) BOOST_PP_REPEAT_2_126(m, d) m(3, 126, d) +# define BOOST_PP_REPEAT_2_128(m, d) BOOST_PP_REPEAT_2_127(m, d) m(3, 127, d) +# define BOOST_PP_REPEAT_2_129(m, d) BOOST_PP_REPEAT_2_128(m, d) m(3, 128, d) +# define BOOST_PP_REPEAT_2_130(m, d) BOOST_PP_REPEAT_2_129(m, d) m(3, 129, d) +# define BOOST_PP_REPEAT_2_131(m, d) BOOST_PP_REPEAT_2_130(m, d) m(3, 130, d) +# define BOOST_PP_REPEAT_2_132(m, d) BOOST_PP_REPEAT_2_131(m, d) m(3, 131, d) +# define BOOST_PP_REPEAT_2_133(m, d) BOOST_PP_REPEAT_2_132(m, d) m(3, 132, d) +# define BOOST_PP_REPEAT_2_134(m, d) BOOST_PP_REPEAT_2_133(m, d) m(3, 133, d) +# define BOOST_PP_REPEAT_2_135(m, d) BOOST_PP_REPEAT_2_134(m, d) m(3, 134, d) +# define BOOST_PP_REPEAT_2_136(m, d) BOOST_PP_REPEAT_2_135(m, d) m(3, 135, d) +# define BOOST_PP_REPEAT_2_137(m, d) BOOST_PP_REPEAT_2_136(m, d) m(3, 136, d) +# define BOOST_PP_REPEAT_2_138(m, d) BOOST_PP_REPEAT_2_137(m, d) m(3, 137, d) +# define BOOST_PP_REPEAT_2_139(m, d) BOOST_PP_REPEAT_2_138(m, d) m(3, 138, d) +# define BOOST_PP_REPEAT_2_140(m, d) BOOST_PP_REPEAT_2_139(m, d) m(3, 139, d) +# define BOOST_PP_REPEAT_2_141(m, d) BOOST_PP_REPEAT_2_140(m, d) m(3, 140, d) +# define BOOST_PP_REPEAT_2_142(m, d) BOOST_PP_REPEAT_2_141(m, d) m(3, 141, d) +# define BOOST_PP_REPEAT_2_143(m, d) BOOST_PP_REPEAT_2_142(m, d) m(3, 142, d) +# define BOOST_PP_REPEAT_2_144(m, d) BOOST_PP_REPEAT_2_143(m, d) m(3, 143, d) +# define BOOST_PP_REPEAT_2_145(m, d) BOOST_PP_REPEAT_2_144(m, d) m(3, 144, d) +# define BOOST_PP_REPEAT_2_146(m, d) BOOST_PP_REPEAT_2_145(m, d) m(3, 145, d) +# define BOOST_PP_REPEAT_2_147(m, d) BOOST_PP_REPEAT_2_146(m, d) m(3, 146, d) +# define BOOST_PP_REPEAT_2_148(m, d) BOOST_PP_REPEAT_2_147(m, d) m(3, 147, d) +# define BOOST_PP_REPEAT_2_149(m, d) BOOST_PP_REPEAT_2_148(m, d) m(3, 148, d) +# define BOOST_PP_REPEAT_2_150(m, d) BOOST_PP_REPEAT_2_149(m, d) m(3, 149, d) +# define BOOST_PP_REPEAT_2_151(m, d) BOOST_PP_REPEAT_2_150(m, d) m(3, 150, d) +# define BOOST_PP_REPEAT_2_152(m, d) BOOST_PP_REPEAT_2_151(m, d) m(3, 151, d) +# define BOOST_PP_REPEAT_2_153(m, d) BOOST_PP_REPEAT_2_152(m, d) m(3, 152, d) +# define BOOST_PP_REPEAT_2_154(m, d) BOOST_PP_REPEAT_2_153(m, d) m(3, 153, d) +# define BOOST_PP_REPEAT_2_155(m, d) BOOST_PP_REPEAT_2_154(m, d) m(3, 154, d) +# define BOOST_PP_REPEAT_2_156(m, d) BOOST_PP_REPEAT_2_155(m, d) m(3, 155, d) +# define BOOST_PP_REPEAT_2_157(m, d) BOOST_PP_REPEAT_2_156(m, d) m(3, 156, d) +# define BOOST_PP_REPEAT_2_158(m, d) BOOST_PP_REPEAT_2_157(m, d) m(3, 157, d) +# define BOOST_PP_REPEAT_2_159(m, d) BOOST_PP_REPEAT_2_158(m, d) m(3, 158, d) +# define BOOST_PP_REPEAT_2_160(m, d) BOOST_PP_REPEAT_2_159(m, d) m(3, 159, d) +# define BOOST_PP_REPEAT_2_161(m, d) BOOST_PP_REPEAT_2_160(m, d) m(3, 160, d) +# define BOOST_PP_REPEAT_2_162(m, d) BOOST_PP_REPEAT_2_161(m, d) m(3, 161, d) +# define BOOST_PP_REPEAT_2_163(m, d) BOOST_PP_REPEAT_2_162(m, d) m(3, 162, d) +# define BOOST_PP_REPEAT_2_164(m, d) BOOST_PP_REPEAT_2_163(m, d) m(3, 163, d) +# define BOOST_PP_REPEAT_2_165(m, d) BOOST_PP_REPEAT_2_164(m, d) m(3, 164, d) +# define BOOST_PP_REPEAT_2_166(m, d) BOOST_PP_REPEAT_2_165(m, d) m(3, 165, d) +# define BOOST_PP_REPEAT_2_167(m, d) BOOST_PP_REPEAT_2_166(m, d) m(3, 166, d) +# define BOOST_PP_REPEAT_2_168(m, d) BOOST_PP_REPEAT_2_167(m, d) m(3, 167, d) +# define BOOST_PP_REPEAT_2_169(m, d) BOOST_PP_REPEAT_2_168(m, d) m(3, 168, d) +# define BOOST_PP_REPEAT_2_170(m, d) BOOST_PP_REPEAT_2_169(m, d) m(3, 169, d) +# define BOOST_PP_REPEAT_2_171(m, d) BOOST_PP_REPEAT_2_170(m, d) m(3, 170, d) +# define BOOST_PP_REPEAT_2_172(m, d) BOOST_PP_REPEAT_2_171(m, d) m(3, 171, d) +# define BOOST_PP_REPEAT_2_173(m, d) BOOST_PP_REPEAT_2_172(m, d) m(3, 172, d) +# define BOOST_PP_REPEAT_2_174(m, d) BOOST_PP_REPEAT_2_173(m, d) m(3, 173, d) +# define BOOST_PP_REPEAT_2_175(m, d) BOOST_PP_REPEAT_2_174(m, d) m(3, 174, d) +# define BOOST_PP_REPEAT_2_176(m, d) BOOST_PP_REPEAT_2_175(m, d) m(3, 175, d) +# define BOOST_PP_REPEAT_2_177(m, d) BOOST_PP_REPEAT_2_176(m, d) m(3, 176, d) +# define BOOST_PP_REPEAT_2_178(m, d) BOOST_PP_REPEAT_2_177(m, d) m(3, 177, d) +# define BOOST_PP_REPEAT_2_179(m, d) BOOST_PP_REPEAT_2_178(m, d) m(3, 178, d) +# define BOOST_PP_REPEAT_2_180(m, d) BOOST_PP_REPEAT_2_179(m, d) m(3, 179, d) +# define BOOST_PP_REPEAT_2_181(m, d) BOOST_PP_REPEAT_2_180(m, d) m(3, 180, d) +# define BOOST_PP_REPEAT_2_182(m, d) BOOST_PP_REPEAT_2_181(m, d) m(3, 181, d) +# define BOOST_PP_REPEAT_2_183(m, d) BOOST_PP_REPEAT_2_182(m, d) m(3, 182, d) +# define BOOST_PP_REPEAT_2_184(m, d) BOOST_PP_REPEAT_2_183(m, d) m(3, 183, d) +# define BOOST_PP_REPEAT_2_185(m, d) BOOST_PP_REPEAT_2_184(m, d) m(3, 184, d) +# define BOOST_PP_REPEAT_2_186(m, d) BOOST_PP_REPEAT_2_185(m, d) m(3, 185, d) +# define BOOST_PP_REPEAT_2_187(m, d) BOOST_PP_REPEAT_2_186(m, d) m(3, 186, d) +# define BOOST_PP_REPEAT_2_188(m, d) BOOST_PP_REPEAT_2_187(m, d) m(3, 187, d) +# define BOOST_PP_REPEAT_2_189(m, d) BOOST_PP_REPEAT_2_188(m, d) m(3, 188, d) +# define BOOST_PP_REPEAT_2_190(m, d) BOOST_PP_REPEAT_2_189(m, d) m(3, 189, d) +# define BOOST_PP_REPEAT_2_191(m, d) BOOST_PP_REPEAT_2_190(m, d) m(3, 190, d) +# define BOOST_PP_REPEAT_2_192(m, d) BOOST_PP_REPEAT_2_191(m, d) m(3, 191, d) +# define BOOST_PP_REPEAT_2_193(m, d) BOOST_PP_REPEAT_2_192(m, d) m(3, 192, d) +# define BOOST_PP_REPEAT_2_194(m, d) BOOST_PP_REPEAT_2_193(m, d) m(3, 193, d) +# define BOOST_PP_REPEAT_2_195(m, d) BOOST_PP_REPEAT_2_194(m, d) m(3, 194, d) +# define BOOST_PP_REPEAT_2_196(m, d) BOOST_PP_REPEAT_2_195(m, d) m(3, 195, d) +# define BOOST_PP_REPEAT_2_197(m, d) BOOST_PP_REPEAT_2_196(m, d) m(3, 196, d) +# define BOOST_PP_REPEAT_2_198(m, d) BOOST_PP_REPEAT_2_197(m, d) m(3, 197, d) +# define BOOST_PP_REPEAT_2_199(m, d) BOOST_PP_REPEAT_2_198(m, d) m(3, 198, d) +# define BOOST_PP_REPEAT_2_200(m, d) BOOST_PP_REPEAT_2_199(m, d) m(3, 199, d) +# define BOOST_PP_REPEAT_2_201(m, d) BOOST_PP_REPEAT_2_200(m, d) m(3, 200, d) +# define BOOST_PP_REPEAT_2_202(m, d) BOOST_PP_REPEAT_2_201(m, d) m(3, 201, d) +# define BOOST_PP_REPEAT_2_203(m, d) BOOST_PP_REPEAT_2_202(m, d) m(3, 202, d) +# define BOOST_PP_REPEAT_2_204(m, d) BOOST_PP_REPEAT_2_203(m, d) m(3, 203, d) +# define BOOST_PP_REPEAT_2_205(m, d) BOOST_PP_REPEAT_2_204(m, d) m(3, 204, d) +# define BOOST_PP_REPEAT_2_206(m, d) BOOST_PP_REPEAT_2_205(m, d) m(3, 205, d) +# define BOOST_PP_REPEAT_2_207(m, d) BOOST_PP_REPEAT_2_206(m, d) m(3, 206, d) +# define BOOST_PP_REPEAT_2_208(m, d) BOOST_PP_REPEAT_2_207(m, d) m(3, 207, d) +# define BOOST_PP_REPEAT_2_209(m, d) BOOST_PP_REPEAT_2_208(m, d) m(3, 208, d) +# define BOOST_PP_REPEAT_2_210(m, d) BOOST_PP_REPEAT_2_209(m, d) m(3, 209, d) +# define BOOST_PP_REPEAT_2_211(m, d) BOOST_PP_REPEAT_2_210(m, d) m(3, 210, d) +# define BOOST_PP_REPEAT_2_212(m, d) BOOST_PP_REPEAT_2_211(m, d) m(3, 211, d) +# define BOOST_PP_REPEAT_2_213(m, d) BOOST_PP_REPEAT_2_212(m, d) m(3, 212, d) +# define BOOST_PP_REPEAT_2_214(m, d) BOOST_PP_REPEAT_2_213(m, d) m(3, 213, d) +# define BOOST_PP_REPEAT_2_215(m, d) BOOST_PP_REPEAT_2_214(m, d) m(3, 214, d) +# define BOOST_PP_REPEAT_2_216(m, d) BOOST_PP_REPEAT_2_215(m, d) m(3, 215, d) +# define BOOST_PP_REPEAT_2_217(m, d) BOOST_PP_REPEAT_2_216(m, d) m(3, 216, d) +# define BOOST_PP_REPEAT_2_218(m, d) BOOST_PP_REPEAT_2_217(m, d) m(3, 217, d) +# define BOOST_PP_REPEAT_2_219(m, d) BOOST_PP_REPEAT_2_218(m, d) m(3, 218, d) +# define BOOST_PP_REPEAT_2_220(m, d) BOOST_PP_REPEAT_2_219(m, d) m(3, 219, d) +# define BOOST_PP_REPEAT_2_221(m, d) BOOST_PP_REPEAT_2_220(m, d) m(3, 220, d) +# define BOOST_PP_REPEAT_2_222(m, d) BOOST_PP_REPEAT_2_221(m, d) m(3, 221, d) +# define BOOST_PP_REPEAT_2_223(m, d) BOOST_PP_REPEAT_2_222(m, d) m(3, 222, d) +# define BOOST_PP_REPEAT_2_224(m, d) BOOST_PP_REPEAT_2_223(m, d) m(3, 223, d) +# define BOOST_PP_REPEAT_2_225(m, d) BOOST_PP_REPEAT_2_224(m, d) m(3, 224, d) +# define BOOST_PP_REPEAT_2_226(m, d) BOOST_PP_REPEAT_2_225(m, d) m(3, 225, d) +# define BOOST_PP_REPEAT_2_227(m, d) BOOST_PP_REPEAT_2_226(m, d) m(3, 226, d) +# define BOOST_PP_REPEAT_2_228(m, d) BOOST_PP_REPEAT_2_227(m, d) m(3, 227, d) +# define BOOST_PP_REPEAT_2_229(m, d) BOOST_PP_REPEAT_2_228(m, d) m(3, 228, d) +# define BOOST_PP_REPEAT_2_230(m, d) BOOST_PP_REPEAT_2_229(m, d) m(3, 229, d) +# define BOOST_PP_REPEAT_2_231(m, d) BOOST_PP_REPEAT_2_230(m, d) m(3, 230, d) +# define BOOST_PP_REPEAT_2_232(m, d) BOOST_PP_REPEAT_2_231(m, d) m(3, 231, d) +# define BOOST_PP_REPEAT_2_233(m, d) BOOST_PP_REPEAT_2_232(m, d) m(3, 232, d) +# define BOOST_PP_REPEAT_2_234(m, d) BOOST_PP_REPEAT_2_233(m, d) m(3, 233, d) +# define BOOST_PP_REPEAT_2_235(m, d) BOOST_PP_REPEAT_2_234(m, d) m(3, 234, d) +# define BOOST_PP_REPEAT_2_236(m, d) BOOST_PP_REPEAT_2_235(m, d) m(3, 235, d) +# define BOOST_PP_REPEAT_2_237(m, d) BOOST_PP_REPEAT_2_236(m, d) m(3, 236, d) +# define BOOST_PP_REPEAT_2_238(m, d) BOOST_PP_REPEAT_2_237(m, d) m(3, 237, d) +# define BOOST_PP_REPEAT_2_239(m, d) BOOST_PP_REPEAT_2_238(m, d) m(3, 238, d) +# define BOOST_PP_REPEAT_2_240(m, d) BOOST_PP_REPEAT_2_239(m, d) m(3, 239, d) +# define BOOST_PP_REPEAT_2_241(m, d) BOOST_PP_REPEAT_2_240(m, d) m(3, 240, d) +# define BOOST_PP_REPEAT_2_242(m, d) BOOST_PP_REPEAT_2_241(m, d) m(3, 241, d) +# define BOOST_PP_REPEAT_2_243(m, d) BOOST_PP_REPEAT_2_242(m, d) m(3, 242, d) +# define BOOST_PP_REPEAT_2_244(m, d) BOOST_PP_REPEAT_2_243(m, d) m(3, 243, d) +# define BOOST_PP_REPEAT_2_245(m, d) BOOST_PP_REPEAT_2_244(m, d) m(3, 244, d) +# define BOOST_PP_REPEAT_2_246(m, d) BOOST_PP_REPEAT_2_245(m, d) m(3, 245, d) +# define BOOST_PP_REPEAT_2_247(m, d) BOOST_PP_REPEAT_2_246(m, d) m(3, 246, d) +# define BOOST_PP_REPEAT_2_248(m, d) BOOST_PP_REPEAT_2_247(m, d) m(3, 247, d) +# define BOOST_PP_REPEAT_2_249(m, d) BOOST_PP_REPEAT_2_248(m, d) m(3, 248, d) +# define BOOST_PP_REPEAT_2_250(m, d) BOOST_PP_REPEAT_2_249(m, d) m(3, 249, d) +# define BOOST_PP_REPEAT_2_251(m, d) BOOST_PP_REPEAT_2_250(m, d) m(3, 250, d) +# define BOOST_PP_REPEAT_2_252(m, d) BOOST_PP_REPEAT_2_251(m, d) m(3, 251, d) +# define BOOST_PP_REPEAT_2_253(m, d) BOOST_PP_REPEAT_2_252(m, d) m(3, 252, d) +# define BOOST_PP_REPEAT_2_254(m, d) BOOST_PP_REPEAT_2_253(m, d) m(3, 253, d) +# define BOOST_PP_REPEAT_2_255(m, d) BOOST_PP_REPEAT_2_254(m, d) m(3, 254, d) +# define BOOST_PP_REPEAT_2_256(m, d) BOOST_PP_REPEAT_2_255(m, d) m(3, 255, d) +# +# define BOOST_PP_REPEAT_3_0(m, d) +# define BOOST_PP_REPEAT_3_1(m, d) m(4, 0, d) +# define BOOST_PP_REPEAT_3_2(m, d) BOOST_PP_REPEAT_3_1(m, d) m(4, 1, d) +# define BOOST_PP_REPEAT_3_3(m, d) BOOST_PP_REPEAT_3_2(m, d) m(4, 2, d) +# define BOOST_PP_REPEAT_3_4(m, d) BOOST_PP_REPEAT_3_3(m, d) m(4, 3, d) +# define BOOST_PP_REPEAT_3_5(m, d) BOOST_PP_REPEAT_3_4(m, d) m(4, 4, d) +# define BOOST_PP_REPEAT_3_6(m, d) BOOST_PP_REPEAT_3_5(m, d) m(4, 5, d) +# define BOOST_PP_REPEAT_3_7(m, d) BOOST_PP_REPEAT_3_6(m, d) m(4, 6, d) +# define BOOST_PP_REPEAT_3_8(m, d) BOOST_PP_REPEAT_3_7(m, d) m(4, 7, d) +# define BOOST_PP_REPEAT_3_9(m, d) BOOST_PP_REPEAT_3_8(m, d) m(4, 8, d) +# define BOOST_PP_REPEAT_3_10(m, d) BOOST_PP_REPEAT_3_9(m, d) m(4, 9, d) +# define BOOST_PP_REPEAT_3_11(m, d) BOOST_PP_REPEAT_3_10(m, d) m(4, 10, d) +# define BOOST_PP_REPEAT_3_12(m, d) BOOST_PP_REPEAT_3_11(m, d) m(4, 11, d) +# define BOOST_PP_REPEAT_3_13(m, d) BOOST_PP_REPEAT_3_12(m, d) m(4, 12, d) +# define BOOST_PP_REPEAT_3_14(m, d) BOOST_PP_REPEAT_3_13(m, d) m(4, 13, d) +# define BOOST_PP_REPEAT_3_15(m, d) BOOST_PP_REPEAT_3_14(m, d) m(4, 14, d) +# define BOOST_PP_REPEAT_3_16(m, d) BOOST_PP_REPEAT_3_15(m, d) m(4, 15, d) +# define BOOST_PP_REPEAT_3_17(m, d) BOOST_PP_REPEAT_3_16(m, d) m(4, 16, d) +# define BOOST_PP_REPEAT_3_18(m, d) BOOST_PP_REPEAT_3_17(m, d) m(4, 17, d) +# define BOOST_PP_REPEAT_3_19(m, d) BOOST_PP_REPEAT_3_18(m, d) m(4, 18, d) +# define BOOST_PP_REPEAT_3_20(m, d) BOOST_PP_REPEAT_3_19(m, d) m(4, 19, d) +# define BOOST_PP_REPEAT_3_21(m, d) BOOST_PP_REPEAT_3_20(m, d) m(4, 20, d) +# define BOOST_PP_REPEAT_3_22(m, d) BOOST_PP_REPEAT_3_21(m, d) m(4, 21, d) +# define BOOST_PP_REPEAT_3_23(m, d) BOOST_PP_REPEAT_3_22(m, d) m(4, 22, d) +# define BOOST_PP_REPEAT_3_24(m, d) BOOST_PP_REPEAT_3_23(m, d) m(4, 23, d) +# define BOOST_PP_REPEAT_3_25(m, d) BOOST_PP_REPEAT_3_24(m, d) m(4, 24, d) +# define BOOST_PP_REPEAT_3_26(m, d) BOOST_PP_REPEAT_3_25(m, d) m(4, 25, d) +# define BOOST_PP_REPEAT_3_27(m, d) BOOST_PP_REPEAT_3_26(m, d) m(4, 26, d) +# define BOOST_PP_REPEAT_3_28(m, d) BOOST_PP_REPEAT_3_27(m, d) m(4, 27, d) +# define BOOST_PP_REPEAT_3_29(m, d) BOOST_PP_REPEAT_3_28(m, d) m(4, 28, d) +# define BOOST_PP_REPEAT_3_30(m, d) BOOST_PP_REPEAT_3_29(m, d) m(4, 29, d) +# define BOOST_PP_REPEAT_3_31(m, d) BOOST_PP_REPEAT_3_30(m, d) m(4, 30, d) +# define BOOST_PP_REPEAT_3_32(m, d) BOOST_PP_REPEAT_3_31(m, d) m(4, 31, d) +# define BOOST_PP_REPEAT_3_33(m, d) BOOST_PP_REPEAT_3_32(m, d) m(4, 32, d) +# define BOOST_PP_REPEAT_3_34(m, d) BOOST_PP_REPEAT_3_33(m, d) m(4, 33, d) +# define BOOST_PP_REPEAT_3_35(m, d) BOOST_PP_REPEAT_3_34(m, d) m(4, 34, d) +# define BOOST_PP_REPEAT_3_36(m, d) BOOST_PP_REPEAT_3_35(m, d) m(4, 35, d) +# define BOOST_PP_REPEAT_3_37(m, d) BOOST_PP_REPEAT_3_36(m, d) m(4, 36, d) +# define BOOST_PP_REPEAT_3_38(m, d) BOOST_PP_REPEAT_3_37(m, d) m(4, 37, d) +# define BOOST_PP_REPEAT_3_39(m, d) BOOST_PP_REPEAT_3_38(m, d) m(4, 38, d) +# define BOOST_PP_REPEAT_3_40(m, d) BOOST_PP_REPEAT_3_39(m, d) m(4, 39, d) +# define BOOST_PP_REPEAT_3_41(m, d) BOOST_PP_REPEAT_3_40(m, d) m(4, 40, d) +# define BOOST_PP_REPEAT_3_42(m, d) BOOST_PP_REPEAT_3_41(m, d) m(4, 41, d) +# define BOOST_PP_REPEAT_3_43(m, d) BOOST_PP_REPEAT_3_42(m, d) m(4, 42, d) +# define BOOST_PP_REPEAT_3_44(m, d) BOOST_PP_REPEAT_3_43(m, d) m(4, 43, d) +# define BOOST_PP_REPEAT_3_45(m, d) BOOST_PP_REPEAT_3_44(m, d) m(4, 44, d) +# define BOOST_PP_REPEAT_3_46(m, d) BOOST_PP_REPEAT_3_45(m, d) m(4, 45, d) +# define BOOST_PP_REPEAT_3_47(m, d) BOOST_PP_REPEAT_3_46(m, d) m(4, 46, d) +# define BOOST_PP_REPEAT_3_48(m, d) BOOST_PP_REPEAT_3_47(m, d) m(4, 47, d) +# define BOOST_PP_REPEAT_3_49(m, d) BOOST_PP_REPEAT_3_48(m, d) m(4, 48, d) +# define BOOST_PP_REPEAT_3_50(m, d) BOOST_PP_REPEAT_3_49(m, d) m(4, 49, d) +# define BOOST_PP_REPEAT_3_51(m, d) BOOST_PP_REPEAT_3_50(m, d) m(4, 50, d) +# define BOOST_PP_REPEAT_3_52(m, d) BOOST_PP_REPEAT_3_51(m, d) m(4, 51, d) +# define BOOST_PP_REPEAT_3_53(m, d) BOOST_PP_REPEAT_3_52(m, d) m(4, 52, d) +# define BOOST_PP_REPEAT_3_54(m, d) BOOST_PP_REPEAT_3_53(m, d) m(4, 53, d) +# define BOOST_PP_REPEAT_3_55(m, d) BOOST_PP_REPEAT_3_54(m, d) m(4, 54, d) +# define BOOST_PP_REPEAT_3_56(m, d) BOOST_PP_REPEAT_3_55(m, d) m(4, 55, d) +# define BOOST_PP_REPEAT_3_57(m, d) BOOST_PP_REPEAT_3_56(m, d) m(4, 56, d) +# define BOOST_PP_REPEAT_3_58(m, d) BOOST_PP_REPEAT_3_57(m, d) m(4, 57, d) +# define BOOST_PP_REPEAT_3_59(m, d) BOOST_PP_REPEAT_3_58(m, d) m(4, 58, d) +# define BOOST_PP_REPEAT_3_60(m, d) BOOST_PP_REPEAT_3_59(m, d) m(4, 59, d) +# define BOOST_PP_REPEAT_3_61(m, d) BOOST_PP_REPEAT_3_60(m, d) m(4, 60, d) +# define BOOST_PP_REPEAT_3_62(m, d) BOOST_PP_REPEAT_3_61(m, d) m(4, 61, d) +# define BOOST_PP_REPEAT_3_63(m, d) BOOST_PP_REPEAT_3_62(m, d) m(4, 62, d) +# define BOOST_PP_REPEAT_3_64(m, d) BOOST_PP_REPEAT_3_63(m, d) m(4, 63, d) +# define BOOST_PP_REPEAT_3_65(m, d) BOOST_PP_REPEAT_3_64(m, d) m(4, 64, d) +# define BOOST_PP_REPEAT_3_66(m, d) BOOST_PP_REPEAT_3_65(m, d) m(4, 65, d) +# define BOOST_PP_REPEAT_3_67(m, d) BOOST_PP_REPEAT_3_66(m, d) m(4, 66, d) +# define BOOST_PP_REPEAT_3_68(m, d) BOOST_PP_REPEAT_3_67(m, d) m(4, 67, d) +# define BOOST_PP_REPEAT_3_69(m, d) BOOST_PP_REPEAT_3_68(m, d) m(4, 68, d) +# define BOOST_PP_REPEAT_3_70(m, d) BOOST_PP_REPEAT_3_69(m, d) m(4, 69, d) +# define BOOST_PP_REPEAT_3_71(m, d) BOOST_PP_REPEAT_3_70(m, d) m(4, 70, d) +# define BOOST_PP_REPEAT_3_72(m, d) BOOST_PP_REPEAT_3_71(m, d) m(4, 71, d) +# define BOOST_PP_REPEAT_3_73(m, d) BOOST_PP_REPEAT_3_72(m, d) m(4, 72, d) +# define BOOST_PP_REPEAT_3_74(m, d) BOOST_PP_REPEAT_3_73(m, d) m(4, 73, d) +# define BOOST_PP_REPEAT_3_75(m, d) BOOST_PP_REPEAT_3_74(m, d) m(4, 74, d) +# define BOOST_PP_REPEAT_3_76(m, d) BOOST_PP_REPEAT_3_75(m, d) m(4, 75, d) +# define BOOST_PP_REPEAT_3_77(m, d) BOOST_PP_REPEAT_3_76(m, d) m(4, 76, d) +# define BOOST_PP_REPEAT_3_78(m, d) BOOST_PP_REPEAT_3_77(m, d) m(4, 77, d) +# define BOOST_PP_REPEAT_3_79(m, d) BOOST_PP_REPEAT_3_78(m, d) m(4, 78, d) +# define BOOST_PP_REPEAT_3_80(m, d) BOOST_PP_REPEAT_3_79(m, d) m(4, 79, d) +# define BOOST_PP_REPEAT_3_81(m, d) BOOST_PP_REPEAT_3_80(m, d) m(4, 80, d) +# define BOOST_PP_REPEAT_3_82(m, d) BOOST_PP_REPEAT_3_81(m, d) m(4, 81, d) +# define BOOST_PP_REPEAT_3_83(m, d) BOOST_PP_REPEAT_3_82(m, d) m(4, 82, d) +# define BOOST_PP_REPEAT_3_84(m, d) BOOST_PP_REPEAT_3_83(m, d) m(4, 83, d) +# define BOOST_PP_REPEAT_3_85(m, d) BOOST_PP_REPEAT_3_84(m, d) m(4, 84, d) +# define BOOST_PP_REPEAT_3_86(m, d) BOOST_PP_REPEAT_3_85(m, d) m(4, 85, d) +# define BOOST_PP_REPEAT_3_87(m, d) BOOST_PP_REPEAT_3_86(m, d) m(4, 86, d) +# define BOOST_PP_REPEAT_3_88(m, d) BOOST_PP_REPEAT_3_87(m, d) m(4, 87, d) +# define BOOST_PP_REPEAT_3_89(m, d) BOOST_PP_REPEAT_3_88(m, d) m(4, 88, d) +# define BOOST_PP_REPEAT_3_90(m, d) BOOST_PP_REPEAT_3_89(m, d) m(4, 89, d) +# define BOOST_PP_REPEAT_3_91(m, d) BOOST_PP_REPEAT_3_90(m, d) m(4, 90, d) +# define BOOST_PP_REPEAT_3_92(m, d) BOOST_PP_REPEAT_3_91(m, d) m(4, 91, d) +# define BOOST_PP_REPEAT_3_93(m, d) BOOST_PP_REPEAT_3_92(m, d) m(4, 92, d) +# define BOOST_PP_REPEAT_3_94(m, d) BOOST_PP_REPEAT_3_93(m, d) m(4, 93, d) +# define BOOST_PP_REPEAT_3_95(m, d) BOOST_PP_REPEAT_3_94(m, d) m(4, 94, d) +# define BOOST_PP_REPEAT_3_96(m, d) BOOST_PP_REPEAT_3_95(m, d) m(4, 95, d) +# define BOOST_PP_REPEAT_3_97(m, d) BOOST_PP_REPEAT_3_96(m, d) m(4, 96, d) +# define BOOST_PP_REPEAT_3_98(m, d) BOOST_PP_REPEAT_3_97(m, d) m(4, 97, d) +# define BOOST_PP_REPEAT_3_99(m, d) BOOST_PP_REPEAT_3_98(m, d) m(4, 98, d) +# define BOOST_PP_REPEAT_3_100(m, d) BOOST_PP_REPEAT_3_99(m, d) m(4, 99, d) +# define BOOST_PP_REPEAT_3_101(m, d) BOOST_PP_REPEAT_3_100(m, d) m(4, 100, d) +# define BOOST_PP_REPEAT_3_102(m, d) BOOST_PP_REPEAT_3_101(m, d) m(4, 101, d) +# define BOOST_PP_REPEAT_3_103(m, d) BOOST_PP_REPEAT_3_102(m, d) m(4, 102, d) +# define BOOST_PP_REPEAT_3_104(m, d) BOOST_PP_REPEAT_3_103(m, d) m(4, 103, d) +# define BOOST_PP_REPEAT_3_105(m, d) BOOST_PP_REPEAT_3_104(m, d) m(4, 104, d) +# define BOOST_PP_REPEAT_3_106(m, d) BOOST_PP_REPEAT_3_105(m, d) m(4, 105, d) +# define BOOST_PP_REPEAT_3_107(m, d) BOOST_PP_REPEAT_3_106(m, d) m(4, 106, d) +# define BOOST_PP_REPEAT_3_108(m, d) BOOST_PP_REPEAT_3_107(m, d) m(4, 107, d) +# define BOOST_PP_REPEAT_3_109(m, d) BOOST_PP_REPEAT_3_108(m, d) m(4, 108, d) +# define BOOST_PP_REPEAT_3_110(m, d) BOOST_PP_REPEAT_3_109(m, d) m(4, 109, d) +# define BOOST_PP_REPEAT_3_111(m, d) BOOST_PP_REPEAT_3_110(m, d) m(4, 110, d) +# define BOOST_PP_REPEAT_3_112(m, d) BOOST_PP_REPEAT_3_111(m, d) m(4, 111, d) +# define BOOST_PP_REPEAT_3_113(m, d) BOOST_PP_REPEAT_3_112(m, d) m(4, 112, d) +# define BOOST_PP_REPEAT_3_114(m, d) BOOST_PP_REPEAT_3_113(m, d) m(4, 113, d) +# define BOOST_PP_REPEAT_3_115(m, d) BOOST_PP_REPEAT_3_114(m, d) m(4, 114, d) +# define BOOST_PP_REPEAT_3_116(m, d) BOOST_PP_REPEAT_3_115(m, d) m(4, 115, d) +# define BOOST_PP_REPEAT_3_117(m, d) BOOST_PP_REPEAT_3_116(m, d) m(4, 116, d) +# define BOOST_PP_REPEAT_3_118(m, d) BOOST_PP_REPEAT_3_117(m, d) m(4, 117, d) +# define BOOST_PP_REPEAT_3_119(m, d) BOOST_PP_REPEAT_3_118(m, d) m(4, 118, d) +# define BOOST_PP_REPEAT_3_120(m, d) BOOST_PP_REPEAT_3_119(m, d) m(4, 119, d) +# define BOOST_PP_REPEAT_3_121(m, d) BOOST_PP_REPEAT_3_120(m, d) m(4, 120, d) +# define BOOST_PP_REPEAT_3_122(m, d) BOOST_PP_REPEAT_3_121(m, d) m(4, 121, d) +# define BOOST_PP_REPEAT_3_123(m, d) BOOST_PP_REPEAT_3_122(m, d) m(4, 122, d) +# define BOOST_PP_REPEAT_3_124(m, d) BOOST_PP_REPEAT_3_123(m, d) m(4, 123, d) +# define BOOST_PP_REPEAT_3_125(m, d) BOOST_PP_REPEAT_3_124(m, d) m(4, 124, d) +# define BOOST_PP_REPEAT_3_126(m, d) BOOST_PP_REPEAT_3_125(m, d) m(4, 125, d) +# define BOOST_PP_REPEAT_3_127(m, d) BOOST_PP_REPEAT_3_126(m, d) m(4, 126, d) +# define BOOST_PP_REPEAT_3_128(m, d) BOOST_PP_REPEAT_3_127(m, d) m(4, 127, d) +# define BOOST_PP_REPEAT_3_129(m, d) BOOST_PP_REPEAT_3_128(m, d) m(4, 128, d) +# define BOOST_PP_REPEAT_3_130(m, d) BOOST_PP_REPEAT_3_129(m, d) m(4, 129, d) +# define BOOST_PP_REPEAT_3_131(m, d) BOOST_PP_REPEAT_3_130(m, d) m(4, 130, d) +# define BOOST_PP_REPEAT_3_132(m, d) BOOST_PP_REPEAT_3_131(m, d) m(4, 131, d) +# define BOOST_PP_REPEAT_3_133(m, d) BOOST_PP_REPEAT_3_132(m, d) m(4, 132, d) +# define BOOST_PP_REPEAT_3_134(m, d) BOOST_PP_REPEAT_3_133(m, d) m(4, 133, d) +# define BOOST_PP_REPEAT_3_135(m, d) BOOST_PP_REPEAT_3_134(m, d) m(4, 134, d) +# define BOOST_PP_REPEAT_3_136(m, d) BOOST_PP_REPEAT_3_135(m, d) m(4, 135, d) +# define BOOST_PP_REPEAT_3_137(m, d) BOOST_PP_REPEAT_3_136(m, d) m(4, 136, d) +# define BOOST_PP_REPEAT_3_138(m, d) BOOST_PP_REPEAT_3_137(m, d) m(4, 137, d) +# define BOOST_PP_REPEAT_3_139(m, d) BOOST_PP_REPEAT_3_138(m, d) m(4, 138, d) +# define BOOST_PP_REPEAT_3_140(m, d) BOOST_PP_REPEAT_3_139(m, d) m(4, 139, d) +# define BOOST_PP_REPEAT_3_141(m, d) BOOST_PP_REPEAT_3_140(m, d) m(4, 140, d) +# define BOOST_PP_REPEAT_3_142(m, d) BOOST_PP_REPEAT_3_141(m, d) m(4, 141, d) +# define BOOST_PP_REPEAT_3_143(m, d) BOOST_PP_REPEAT_3_142(m, d) m(4, 142, d) +# define BOOST_PP_REPEAT_3_144(m, d) BOOST_PP_REPEAT_3_143(m, d) m(4, 143, d) +# define BOOST_PP_REPEAT_3_145(m, d) BOOST_PP_REPEAT_3_144(m, d) m(4, 144, d) +# define BOOST_PP_REPEAT_3_146(m, d) BOOST_PP_REPEAT_3_145(m, d) m(4, 145, d) +# define BOOST_PP_REPEAT_3_147(m, d) BOOST_PP_REPEAT_3_146(m, d) m(4, 146, d) +# define BOOST_PP_REPEAT_3_148(m, d) BOOST_PP_REPEAT_3_147(m, d) m(4, 147, d) +# define BOOST_PP_REPEAT_3_149(m, d) BOOST_PP_REPEAT_3_148(m, d) m(4, 148, d) +# define BOOST_PP_REPEAT_3_150(m, d) BOOST_PP_REPEAT_3_149(m, d) m(4, 149, d) +# define BOOST_PP_REPEAT_3_151(m, d) BOOST_PP_REPEAT_3_150(m, d) m(4, 150, d) +# define BOOST_PP_REPEAT_3_152(m, d) BOOST_PP_REPEAT_3_151(m, d) m(4, 151, d) +# define BOOST_PP_REPEAT_3_153(m, d) BOOST_PP_REPEAT_3_152(m, d) m(4, 152, d) +# define BOOST_PP_REPEAT_3_154(m, d) BOOST_PP_REPEAT_3_153(m, d) m(4, 153, d) +# define BOOST_PP_REPEAT_3_155(m, d) BOOST_PP_REPEAT_3_154(m, d) m(4, 154, d) +# define BOOST_PP_REPEAT_3_156(m, d) BOOST_PP_REPEAT_3_155(m, d) m(4, 155, d) +# define BOOST_PP_REPEAT_3_157(m, d) BOOST_PP_REPEAT_3_156(m, d) m(4, 156, d) +# define BOOST_PP_REPEAT_3_158(m, d) BOOST_PP_REPEAT_3_157(m, d) m(4, 157, d) +# define BOOST_PP_REPEAT_3_159(m, d) BOOST_PP_REPEAT_3_158(m, d) m(4, 158, d) +# define BOOST_PP_REPEAT_3_160(m, d) BOOST_PP_REPEAT_3_159(m, d) m(4, 159, d) +# define BOOST_PP_REPEAT_3_161(m, d) BOOST_PP_REPEAT_3_160(m, d) m(4, 160, d) +# define BOOST_PP_REPEAT_3_162(m, d) BOOST_PP_REPEAT_3_161(m, d) m(4, 161, d) +# define BOOST_PP_REPEAT_3_163(m, d) BOOST_PP_REPEAT_3_162(m, d) m(4, 162, d) +# define BOOST_PP_REPEAT_3_164(m, d) BOOST_PP_REPEAT_3_163(m, d) m(4, 163, d) +# define BOOST_PP_REPEAT_3_165(m, d) BOOST_PP_REPEAT_3_164(m, d) m(4, 164, d) +# define BOOST_PP_REPEAT_3_166(m, d) BOOST_PP_REPEAT_3_165(m, d) m(4, 165, d) +# define BOOST_PP_REPEAT_3_167(m, d) BOOST_PP_REPEAT_3_166(m, d) m(4, 166, d) +# define BOOST_PP_REPEAT_3_168(m, d) BOOST_PP_REPEAT_3_167(m, d) m(4, 167, d) +# define BOOST_PP_REPEAT_3_169(m, d) BOOST_PP_REPEAT_3_168(m, d) m(4, 168, d) +# define BOOST_PP_REPEAT_3_170(m, d) BOOST_PP_REPEAT_3_169(m, d) m(4, 169, d) +# define BOOST_PP_REPEAT_3_171(m, d) BOOST_PP_REPEAT_3_170(m, d) m(4, 170, d) +# define BOOST_PP_REPEAT_3_172(m, d) BOOST_PP_REPEAT_3_171(m, d) m(4, 171, d) +# define BOOST_PP_REPEAT_3_173(m, d) BOOST_PP_REPEAT_3_172(m, d) m(4, 172, d) +# define BOOST_PP_REPEAT_3_174(m, d) BOOST_PP_REPEAT_3_173(m, d) m(4, 173, d) +# define BOOST_PP_REPEAT_3_175(m, d) BOOST_PP_REPEAT_3_174(m, d) m(4, 174, d) +# define BOOST_PP_REPEAT_3_176(m, d) BOOST_PP_REPEAT_3_175(m, d) m(4, 175, d) +# define BOOST_PP_REPEAT_3_177(m, d) BOOST_PP_REPEAT_3_176(m, d) m(4, 176, d) +# define BOOST_PP_REPEAT_3_178(m, d) BOOST_PP_REPEAT_3_177(m, d) m(4, 177, d) +# define BOOST_PP_REPEAT_3_179(m, d) BOOST_PP_REPEAT_3_178(m, d) m(4, 178, d) +# define BOOST_PP_REPEAT_3_180(m, d) BOOST_PP_REPEAT_3_179(m, d) m(4, 179, d) +# define BOOST_PP_REPEAT_3_181(m, d) BOOST_PP_REPEAT_3_180(m, d) m(4, 180, d) +# define BOOST_PP_REPEAT_3_182(m, d) BOOST_PP_REPEAT_3_181(m, d) m(4, 181, d) +# define BOOST_PP_REPEAT_3_183(m, d) BOOST_PP_REPEAT_3_182(m, d) m(4, 182, d) +# define BOOST_PP_REPEAT_3_184(m, d) BOOST_PP_REPEAT_3_183(m, d) m(4, 183, d) +# define BOOST_PP_REPEAT_3_185(m, d) BOOST_PP_REPEAT_3_184(m, d) m(4, 184, d) +# define BOOST_PP_REPEAT_3_186(m, d) BOOST_PP_REPEAT_3_185(m, d) m(4, 185, d) +# define BOOST_PP_REPEAT_3_187(m, d) BOOST_PP_REPEAT_3_186(m, d) m(4, 186, d) +# define BOOST_PP_REPEAT_3_188(m, d) BOOST_PP_REPEAT_3_187(m, d) m(4, 187, d) +# define BOOST_PP_REPEAT_3_189(m, d) BOOST_PP_REPEAT_3_188(m, d) m(4, 188, d) +# define BOOST_PP_REPEAT_3_190(m, d) BOOST_PP_REPEAT_3_189(m, d) m(4, 189, d) +# define BOOST_PP_REPEAT_3_191(m, d) BOOST_PP_REPEAT_3_190(m, d) m(4, 190, d) +# define BOOST_PP_REPEAT_3_192(m, d) BOOST_PP_REPEAT_3_191(m, d) m(4, 191, d) +# define BOOST_PP_REPEAT_3_193(m, d) BOOST_PP_REPEAT_3_192(m, d) m(4, 192, d) +# define BOOST_PP_REPEAT_3_194(m, d) BOOST_PP_REPEAT_3_193(m, d) m(4, 193, d) +# define BOOST_PP_REPEAT_3_195(m, d) BOOST_PP_REPEAT_3_194(m, d) m(4, 194, d) +# define BOOST_PP_REPEAT_3_196(m, d) BOOST_PP_REPEAT_3_195(m, d) m(4, 195, d) +# define BOOST_PP_REPEAT_3_197(m, d) BOOST_PP_REPEAT_3_196(m, d) m(4, 196, d) +# define BOOST_PP_REPEAT_3_198(m, d) BOOST_PP_REPEAT_3_197(m, d) m(4, 197, d) +# define BOOST_PP_REPEAT_3_199(m, d) BOOST_PP_REPEAT_3_198(m, d) m(4, 198, d) +# define BOOST_PP_REPEAT_3_200(m, d) BOOST_PP_REPEAT_3_199(m, d) m(4, 199, d) +# define BOOST_PP_REPEAT_3_201(m, d) BOOST_PP_REPEAT_3_200(m, d) m(4, 200, d) +# define BOOST_PP_REPEAT_3_202(m, d) BOOST_PP_REPEAT_3_201(m, d) m(4, 201, d) +# define BOOST_PP_REPEAT_3_203(m, d) BOOST_PP_REPEAT_3_202(m, d) m(4, 202, d) +# define BOOST_PP_REPEAT_3_204(m, d) BOOST_PP_REPEAT_3_203(m, d) m(4, 203, d) +# define BOOST_PP_REPEAT_3_205(m, d) BOOST_PP_REPEAT_3_204(m, d) m(4, 204, d) +# define BOOST_PP_REPEAT_3_206(m, d) BOOST_PP_REPEAT_3_205(m, d) m(4, 205, d) +# define BOOST_PP_REPEAT_3_207(m, d) BOOST_PP_REPEAT_3_206(m, d) m(4, 206, d) +# define BOOST_PP_REPEAT_3_208(m, d) BOOST_PP_REPEAT_3_207(m, d) m(4, 207, d) +# define BOOST_PP_REPEAT_3_209(m, d) BOOST_PP_REPEAT_3_208(m, d) m(4, 208, d) +# define BOOST_PP_REPEAT_3_210(m, d) BOOST_PP_REPEAT_3_209(m, d) m(4, 209, d) +# define BOOST_PP_REPEAT_3_211(m, d) BOOST_PP_REPEAT_3_210(m, d) m(4, 210, d) +# define BOOST_PP_REPEAT_3_212(m, d) BOOST_PP_REPEAT_3_211(m, d) m(4, 211, d) +# define BOOST_PP_REPEAT_3_213(m, d) BOOST_PP_REPEAT_3_212(m, d) m(4, 212, d) +# define BOOST_PP_REPEAT_3_214(m, d) BOOST_PP_REPEAT_3_213(m, d) m(4, 213, d) +# define BOOST_PP_REPEAT_3_215(m, d) BOOST_PP_REPEAT_3_214(m, d) m(4, 214, d) +# define BOOST_PP_REPEAT_3_216(m, d) BOOST_PP_REPEAT_3_215(m, d) m(4, 215, d) +# define BOOST_PP_REPEAT_3_217(m, d) BOOST_PP_REPEAT_3_216(m, d) m(4, 216, d) +# define BOOST_PP_REPEAT_3_218(m, d) BOOST_PP_REPEAT_3_217(m, d) m(4, 217, d) +# define BOOST_PP_REPEAT_3_219(m, d) BOOST_PP_REPEAT_3_218(m, d) m(4, 218, d) +# define BOOST_PP_REPEAT_3_220(m, d) BOOST_PP_REPEAT_3_219(m, d) m(4, 219, d) +# define BOOST_PP_REPEAT_3_221(m, d) BOOST_PP_REPEAT_3_220(m, d) m(4, 220, d) +# define BOOST_PP_REPEAT_3_222(m, d) BOOST_PP_REPEAT_3_221(m, d) m(4, 221, d) +# define BOOST_PP_REPEAT_3_223(m, d) BOOST_PP_REPEAT_3_222(m, d) m(4, 222, d) +# define BOOST_PP_REPEAT_3_224(m, d) BOOST_PP_REPEAT_3_223(m, d) m(4, 223, d) +# define BOOST_PP_REPEAT_3_225(m, d) BOOST_PP_REPEAT_3_224(m, d) m(4, 224, d) +# define BOOST_PP_REPEAT_3_226(m, d) BOOST_PP_REPEAT_3_225(m, d) m(4, 225, d) +# define BOOST_PP_REPEAT_3_227(m, d) BOOST_PP_REPEAT_3_226(m, d) m(4, 226, d) +# define BOOST_PP_REPEAT_3_228(m, d) BOOST_PP_REPEAT_3_227(m, d) m(4, 227, d) +# define BOOST_PP_REPEAT_3_229(m, d) BOOST_PP_REPEAT_3_228(m, d) m(4, 228, d) +# define BOOST_PP_REPEAT_3_230(m, d) BOOST_PP_REPEAT_3_229(m, d) m(4, 229, d) +# define BOOST_PP_REPEAT_3_231(m, d) BOOST_PP_REPEAT_3_230(m, d) m(4, 230, d) +# define BOOST_PP_REPEAT_3_232(m, d) BOOST_PP_REPEAT_3_231(m, d) m(4, 231, d) +# define BOOST_PP_REPEAT_3_233(m, d) BOOST_PP_REPEAT_3_232(m, d) m(4, 232, d) +# define BOOST_PP_REPEAT_3_234(m, d) BOOST_PP_REPEAT_3_233(m, d) m(4, 233, d) +# define BOOST_PP_REPEAT_3_235(m, d) BOOST_PP_REPEAT_3_234(m, d) m(4, 234, d) +# define BOOST_PP_REPEAT_3_236(m, d) BOOST_PP_REPEAT_3_235(m, d) m(4, 235, d) +# define BOOST_PP_REPEAT_3_237(m, d) BOOST_PP_REPEAT_3_236(m, d) m(4, 236, d) +# define BOOST_PP_REPEAT_3_238(m, d) BOOST_PP_REPEAT_3_237(m, d) m(4, 237, d) +# define BOOST_PP_REPEAT_3_239(m, d) BOOST_PP_REPEAT_3_238(m, d) m(4, 238, d) +# define BOOST_PP_REPEAT_3_240(m, d) BOOST_PP_REPEAT_3_239(m, d) m(4, 239, d) +# define BOOST_PP_REPEAT_3_241(m, d) BOOST_PP_REPEAT_3_240(m, d) m(4, 240, d) +# define BOOST_PP_REPEAT_3_242(m, d) BOOST_PP_REPEAT_3_241(m, d) m(4, 241, d) +# define BOOST_PP_REPEAT_3_243(m, d) BOOST_PP_REPEAT_3_242(m, d) m(4, 242, d) +# define BOOST_PP_REPEAT_3_244(m, d) BOOST_PP_REPEAT_3_243(m, d) m(4, 243, d) +# define BOOST_PP_REPEAT_3_245(m, d) BOOST_PP_REPEAT_3_244(m, d) m(4, 244, d) +# define BOOST_PP_REPEAT_3_246(m, d) BOOST_PP_REPEAT_3_245(m, d) m(4, 245, d) +# define BOOST_PP_REPEAT_3_247(m, d) BOOST_PP_REPEAT_3_246(m, d) m(4, 246, d) +# define BOOST_PP_REPEAT_3_248(m, d) BOOST_PP_REPEAT_3_247(m, d) m(4, 247, d) +# define BOOST_PP_REPEAT_3_249(m, d) BOOST_PP_REPEAT_3_248(m, d) m(4, 248, d) +# define BOOST_PP_REPEAT_3_250(m, d) BOOST_PP_REPEAT_3_249(m, d) m(4, 249, d) +# define BOOST_PP_REPEAT_3_251(m, d) BOOST_PP_REPEAT_3_250(m, d) m(4, 250, d) +# define BOOST_PP_REPEAT_3_252(m, d) BOOST_PP_REPEAT_3_251(m, d) m(4, 251, d) +# define BOOST_PP_REPEAT_3_253(m, d) BOOST_PP_REPEAT_3_252(m, d) m(4, 252, d) +# define BOOST_PP_REPEAT_3_254(m, d) BOOST_PP_REPEAT_3_253(m, d) m(4, 253, d) +# define BOOST_PP_REPEAT_3_255(m, d) BOOST_PP_REPEAT_3_254(m, d) m(4, 254, d) +# define BOOST_PP_REPEAT_3_256(m, d) BOOST_PP_REPEAT_3_255(m, d) m(4, 255, d) +# +# endif diff --git a/realsense-file/3rd_party/boost/boost/preprocessor/repetition/repeat_from_to.hpp b/realsense-file/3rd_party/boost/boost/preprocessor/repetition/repeat_from_to.hpp new file mode 100644 index 0000000000..161bc81250 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/preprocessor/repetition/repeat_from_to.hpp @@ -0,0 +1,87 @@ +# /* Copyright (C) 2001 +# * Housemarque Oy +# * http://www.housemarque.com +# * +# * 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) +# */ +# +# /* Revised by Paul Mensonides (2002) */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_REPETITION_REPEAT_FROM_TO_HPP +# define BOOST_PREPROCESSOR_REPETITION_REPEAT_FROM_TO_HPP +# +# include +# include +# include +# include +# include +# include +# include +# include +# include +# include +# +# /* BOOST_PP_REPEAT_FROM_TO */ +# +# if 0 +# define BOOST_PP_REPEAT_FROM_TO(first, last, macro, data) +# endif +# +# define BOOST_PP_REPEAT_FROM_TO BOOST_PP_CAT(BOOST_PP_REPEAT_FROM_TO_, BOOST_PP_AUTO_REC(BOOST_PP_REPEAT_P, 4)) +# +# define BOOST_PP_REPEAT_FROM_TO_1(f, l, m, dt) BOOST_PP_REPEAT_FROM_TO_D_1(BOOST_PP_AUTO_REC(BOOST_PP_WHILE_P, 256), f, l, m, dt) +# define BOOST_PP_REPEAT_FROM_TO_2(f, l, m, dt) BOOST_PP_REPEAT_FROM_TO_D_2(BOOST_PP_AUTO_REC(BOOST_PP_WHILE_P, 256), f, l, m, dt) +# define BOOST_PP_REPEAT_FROM_TO_3(f, l, m, dt) BOOST_PP_REPEAT_FROM_TO_D_3(BOOST_PP_AUTO_REC(BOOST_PP_WHILE_P, 256), f, l, m, dt) +# define BOOST_PP_REPEAT_FROM_TO_4(f, l, m, dt) BOOST_PP_ERROR(0x0003) +# +# define BOOST_PP_REPEAT_FROM_TO_1ST BOOST_PP_REPEAT_FROM_TO_1 +# define BOOST_PP_REPEAT_FROM_TO_2ND BOOST_PP_REPEAT_FROM_TO_2 +# define BOOST_PP_REPEAT_FROM_TO_3RD BOOST_PP_REPEAT_FROM_TO_3 +# +# /* BOOST_PP_REPEAT_FROM_TO_D */ +# +# if 0 +# define BOOST_PP_REPEAT_FROM_TO_D(d, first, last, macro, data) +# endif +# +# define BOOST_PP_REPEAT_FROM_TO_D BOOST_PP_CAT(BOOST_PP_REPEAT_FROM_TO_D_, BOOST_PP_AUTO_REC(BOOST_PP_REPEAT_P, 4)) +# +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() +# define BOOST_PP_REPEAT_FROM_TO_D_1(d, f, l, m, dt) BOOST_PP_REPEAT_1(BOOST_PP_SUB_D(d, l, f), BOOST_PP_REPEAT_FROM_TO_M_1, (d, f, m, dt)) +# define BOOST_PP_REPEAT_FROM_TO_D_2(d, f, l, m, dt) BOOST_PP_REPEAT_2(BOOST_PP_SUB_D(d, l, f), BOOST_PP_REPEAT_FROM_TO_M_2, (d, f, m, dt)) +# define BOOST_PP_REPEAT_FROM_TO_D_3(d, f, l, m, dt) BOOST_PP_REPEAT_3(BOOST_PP_SUB_D(d, l, f), BOOST_PP_REPEAT_FROM_TO_M_3, (d, f, m, dt)) +# else +# define BOOST_PP_REPEAT_FROM_TO_D_1(d, f, l, m, dt) BOOST_PP_REPEAT_FROM_TO_D_1_I(d, f, l, m, dt) +# define BOOST_PP_REPEAT_FROM_TO_D_2(d, f, l, m, dt) BOOST_PP_REPEAT_FROM_TO_D_2_I(d, f, l, m, dt) +# define BOOST_PP_REPEAT_FROM_TO_D_3(d, f, l, m, dt) BOOST_PP_REPEAT_FROM_TO_D_3_I(d, f, l, m, dt) +# define BOOST_PP_REPEAT_FROM_TO_D_1_I(d, f, l, m, dt) BOOST_PP_REPEAT_1(BOOST_PP_SUB_D(d, l, f), BOOST_PP_REPEAT_FROM_TO_M_1, (d, f, m, dt)) +# define BOOST_PP_REPEAT_FROM_TO_D_2_I(d, f, l, m, dt) BOOST_PP_REPEAT_2(BOOST_PP_SUB_D(d, l, f), BOOST_PP_REPEAT_FROM_TO_M_2, (d, f, m, dt)) +# define BOOST_PP_REPEAT_FROM_TO_D_3_I(d, f, l, m, dt) BOOST_PP_REPEAT_3(BOOST_PP_SUB_D(d, l, f), BOOST_PP_REPEAT_FROM_TO_M_3, (d, f, m, dt)) +# endif +# +# if BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_STRICT() +# define BOOST_PP_REPEAT_FROM_TO_M_1(z, n, dfmd) BOOST_PP_REPEAT_FROM_TO_M_1_IM(z, n, BOOST_PP_TUPLE_REM_4 dfmd) +# define BOOST_PP_REPEAT_FROM_TO_M_2(z, n, dfmd) BOOST_PP_REPEAT_FROM_TO_M_2_IM(z, n, BOOST_PP_TUPLE_REM_4 dfmd) +# define BOOST_PP_REPEAT_FROM_TO_M_3(z, n, dfmd) BOOST_PP_REPEAT_FROM_TO_M_3_IM(z, n, BOOST_PP_TUPLE_REM_4 dfmd) +# define BOOST_PP_REPEAT_FROM_TO_M_1_IM(z, n, im) BOOST_PP_REPEAT_FROM_TO_M_1_I(z, n, im) +# define BOOST_PP_REPEAT_FROM_TO_M_2_IM(z, n, im) BOOST_PP_REPEAT_FROM_TO_M_2_I(z, n, im) +# define BOOST_PP_REPEAT_FROM_TO_M_3_IM(z, n, im) BOOST_PP_REPEAT_FROM_TO_M_3_I(z, n, im) +# else +# define BOOST_PP_REPEAT_FROM_TO_M_1(z, n, dfmd) BOOST_PP_REPEAT_FROM_TO_M_1_I(z, n, BOOST_PP_TUPLE_ELEM(4, 0, dfmd), BOOST_PP_TUPLE_ELEM(4, 1, dfmd), BOOST_PP_TUPLE_ELEM(4, 2, dfmd), BOOST_PP_TUPLE_ELEM(4, 3, dfmd)) +# define BOOST_PP_REPEAT_FROM_TO_M_2(z, n, dfmd) BOOST_PP_REPEAT_FROM_TO_M_2_I(z, n, BOOST_PP_TUPLE_ELEM(4, 0, dfmd), BOOST_PP_TUPLE_ELEM(4, 1, dfmd), BOOST_PP_TUPLE_ELEM(4, 2, dfmd), BOOST_PP_TUPLE_ELEM(4, 3, dfmd)) +# define BOOST_PP_REPEAT_FROM_TO_M_3(z, n, dfmd) BOOST_PP_REPEAT_FROM_TO_M_3_I(z, n, BOOST_PP_TUPLE_ELEM(4, 0, dfmd), BOOST_PP_TUPLE_ELEM(4, 1, dfmd), BOOST_PP_TUPLE_ELEM(4, 2, dfmd), BOOST_PP_TUPLE_ELEM(4, 3, dfmd)) +# endif +# +# define BOOST_PP_REPEAT_FROM_TO_M_1_I(z, n, d, f, m, dt) BOOST_PP_REPEAT_FROM_TO_M_1_II(z, BOOST_PP_ADD_D(d, n, f), m, dt) +# define BOOST_PP_REPEAT_FROM_TO_M_2_I(z, n, d, f, m, dt) BOOST_PP_REPEAT_FROM_TO_M_2_II(z, BOOST_PP_ADD_D(d, n, f), m, dt) +# define BOOST_PP_REPEAT_FROM_TO_M_3_I(z, n, d, f, m, dt) BOOST_PP_REPEAT_FROM_TO_M_3_II(z, BOOST_PP_ADD_D(d, n, f), m, dt) +# +# define BOOST_PP_REPEAT_FROM_TO_M_1_II(z, n, m, dt) m(z, n, dt) +# define BOOST_PP_REPEAT_FROM_TO_M_2_II(z, n, m, dt) m(z, n, dt) +# define BOOST_PP_REPEAT_FROM_TO_M_3_II(z, n, m, dt) m(z, n, dt) +# +# endif diff --git a/realsense-file/3rd_party/boost/boost/preprocessor/slot/detail/def.hpp b/realsense-file/3rd_party/boost/boost/preprocessor/slot/detail/def.hpp new file mode 100644 index 0000000000..105a43b603 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/preprocessor/slot/detail/def.hpp @@ -0,0 +1,49 @@ +# /* ************************************************************************** +# * * +# * (C) Copyright Paul Mensonides 2002. +# * Distributed under the Boost Software License, Version 1.0. (See +# * accompanying file LICENSE_1_0.txt or copy at +# * http://www.boost.org/LICENSE_1_0.txt) +# * * +# ************************************************************************** */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_SLOT_DETAIL_DEF_HPP +# define BOOST_PREPROCESSOR_SLOT_DETAIL_DEF_HPP +# +# /* BOOST_PP_SLOT_OFFSET_x */ +# +# define BOOST_PP_SLOT_OFFSET_10(x) (x) % 1000000000UL +# define BOOST_PP_SLOT_OFFSET_9(x) BOOST_PP_SLOT_OFFSET_10(x) % 100000000UL +# define BOOST_PP_SLOT_OFFSET_8(x) BOOST_PP_SLOT_OFFSET_9(x) % 10000000UL +# define BOOST_PP_SLOT_OFFSET_7(x) BOOST_PP_SLOT_OFFSET_8(x) % 1000000UL +# define BOOST_PP_SLOT_OFFSET_6(x) BOOST_PP_SLOT_OFFSET_7(x) % 100000UL +# define BOOST_PP_SLOT_OFFSET_5(x) BOOST_PP_SLOT_OFFSET_6(x) % 10000UL +# define BOOST_PP_SLOT_OFFSET_4(x) BOOST_PP_SLOT_OFFSET_5(x) % 1000UL +# define BOOST_PP_SLOT_OFFSET_3(x) BOOST_PP_SLOT_OFFSET_4(x) % 100UL +# define BOOST_PP_SLOT_OFFSET_2(x) BOOST_PP_SLOT_OFFSET_3(x) % 10UL +# +# /* BOOST_PP_SLOT_CC_x */ +# +# define BOOST_PP_SLOT_CC_2(a, b) BOOST_PP_SLOT_CC_2_D(a, b) +# define BOOST_PP_SLOT_CC_3(a, b, c) BOOST_PP_SLOT_CC_3_D(a, b, c) +# define BOOST_PP_SLOT_CC_4(a, b, c, d) BOOST_PP_SLOT_CC_4_D(a, b, c, d) +# define BOOST_PP_SLOT_CC_5(a, b, c, d, e) BOOST_PP_SLOT_CC_5_D(a, b, c, d, e) +# define BOOST_PP_SLOT_CC_6(a, b, c, d, e, f) BOOST_PP_SLOT_CC_6_D(a, b, c, d, e, f) +# define BOOST_PP_SLOT_CC_7(a, b, c, d, e, f, g) BOOST_PP_SLOT_CC_7_D(a, b, c, d, e, f, g) +# define BOOST_PP_SLOT_CC_8(a, b, c, d, e, f, g, h) BOOST_PP_SLOT_CC_8_D(a, b, c, d, e, f, g, h) +# define BOOST_PP_SLOT_CC_9(a, b, c, d, e, f, g, h, i) BOOST_PP_SLOT_CC_9_D(a, b, c, d, e, f, g, h, i) +# define BOOST_PP_SLOT_CC_10(a, b, c, d, e, f, g, h, i, j) BOOST_PP_SLOT_CC_10_D(a, b, c, d, e, f, g, h, i, j) +# +# define BOOST_PP_SLOT_CC_2_D(a, b) a ## b +# define BOOST_PP_SLOT_CC_3_D(a, b, c) a ## b ## c +# define BOOST_PP_SLOT_CC_4_D(a, b, c, d) a ## b ## c ## d +# define BOOST_PP_SLOT_CC_5_D(a, b, c, d, e) a ## b ## c ## d ## e +# define BOOST_PP_SLOT_CC_6_D(a, b, c, d, e, f) a ## b ## c ## d ## e ## f +# define BOOST_PP_SLOT_CC_7_D(a, b, c, d, e, f, g) a ## b ## c ## d ## e ## f ## g +# define BOOST_PP_SLOT_CC_8_D(a, b, c, d, e, f, g, h) a ## b ## c ## d ## e ## f ## g ## h +# define BOOST_PP_SLOT_CC_9_D(a, b, c, d, e, f, g, h, i) a ## b ## c ## d ## e ## f ## g ## h ## i +# define BOOST_PP_SLOT_CC_10_D(a, b, c, d, e, f, g, h, i, j) a ## b ## c ## d ## e ## f ## g ## h ## i ## j +# +# endif diff --git a/realsense-file/3rd_party/boost/boost/preprocessor/slot/detail/shared.hpp b/realsense-file/3rd_party/boost/boost/preprocessor/slot/detail/shared.hpp new file mode 100644 index 0000000000..83370def93 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/preprocessor/slot/detail/shared.hpp @@ -0,0 +1,247 @@ +# /* ************************************************************************** +# * * +# * (C) Copyright Paul Mensonides 2002. +# * Distributed under the Boost Software License, Version 1.0. (See +# * accompanying file LICENSE_1_0.txt or copy at +# * http://www.boost.org/LICENSE_1_0.txt) +# * * +# ************************************************************************** */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PP_VALUE +# error BOOST_PP_ERROR: BOOST_PP_VALUE is not defined +# endif +# +# undef BOOST_PP_SLOT_TEMP_1 +# undef BOOST_PP_SLOT_TEMP_2 +# undef BOOST_PP_SLOT_TEMP_3 +# undef BOOST_PP_SLOT_TEMP_4 +# undef BOOST_PP_SLOT_TEMP_5 +# undef BOOST_PP_SLOT_TEMP_6 +# undef BOOST_PP_SLOT_TEMP_7 +# undef BOOST_PP_SLOT_TEMP_8 +# undef BOOST_PP_SLOT_TEMP_9 +# undef BOOST_PP_SLOT_TEMP_10 +# +# if (BOOST_PP_VALUE) / 1000000000UL == 0 +# define BOOST_PP_SLOT_TEMP_10 0 +# elif (BOOST_PP_VALUE) / 1000000000UL == 1 +# define BOOST_PP_SLOT_TEMP_10 1 +# elif (BOOST_PP_VALUE) / 1000000000UL == 2 +# define BOOST_PP_SLOT_TEMP_10 2 +# elif (BOOST_PP_VALUE) / 1000000000UL == 3 +# define BOOST_PP_SLOT_TEMP_10 3 +# elif (BOOST_PP_VALUE) / 1000000000UL == 4 +# define BOOST_PP_SLOT_TEMP_10 4 +# elif (BOOST_PP_VALUE) / 1000000000UL == 5 +# define BOOST_PP_SLOT_TEMP_10 5 +# elif (BOOST_PP_VALUE) / 1000000000UL == 6 +# define BOOST_PP_SLOT_TEMP_10 6 +# elif (BOOST_PP_VALUE) / 1000000000UL == 7 +# define BOOST_PP_SLOT_TEMP_10 7 +# elif (BOOST_PP_VALUE) / 1000000000UL == 8 +# define BOOST_PP_SLOT_TEMP_10 8 +# elif (BOOST_PP_VALUE) / 1000000000UL == 9 +# define BOOST_PP_SLOT_TEMP_10 9 +# endif +# +# if BOOST_PP_SLOT_OFFSET_10(BOOST_PP_VALUE) / 100000000UL == 0 +# define BOOST_PP_SLOT_TEMP_9 0 +# elif BOOST_PP_SLOT_OFFSET_10(BOOST_PP_VALUE) / 100000000UL == 1 +# define BOOST_PP_SLOT_TEMP_9 1 +# elif BOOST_PP_SLOT_OFFSET_10(BOOST_PP_VALUE) / 100000000UL == 2 +# define BOOST_PP_SLOT_TEMP_9 2 +# elif BOOST_PP_SLOT_OFFSET_10(BOOST_PP_VALUE) / 100000000UL == 3 +# define BOOST_PP_SLOT_TEMP_9 3 +# elif BOOST_PP_SLOT_OFFSET_10(BOOST_PP_VALUE) / 100000000UL == 4 +# define BOOST_PP_SLOT_TEMP_9 4 +# elif BOOST_PP_SLOT_OFFSET_10(BOOST_PP_VALUE) / 100000000UL == 5 +# define BOOST_PP_SLOT_TEMP_9 5 +# elif BOOST_PP_SLOT_OFFSET_10(BOOST_PP_VALUE) / 100000000UL == 6 +# define BOOST_PP_SLOT_TEMP_9 6 +# elif BOOST_PP_SLOT_OFFSET_10(BOOST_PP_VALUE) / 100000000UL == 7 +# define BOOST_PP_SLOT_TEMP_9 7 +# elif BOOST_PP_SLOT_OFFSET_10(BOOST_PP_VALUE) / 100000000UL == 8 +# define BOOST_PP_SLOT_TEMP_9 8 +# elif BOOST_PP_SLOT_OFFSET_10(BOOST_PP_VALUE) / 100000000UL == 9 +# define BOOST_PP_SLOT_TEMP_9 9 +# endif +# +# if BOOST_PP_SLOT_OFFSET_9(BOOST_PP_VALUE) / 10000000UL == 0 +# define BOOST_PP_SLOT_TEMP_8 0 +# elif BOOST_PP_SLOT_OFFSET_9(BOOST_PP_VALUE) / 10000000UL == 1 +# define BOOST_PP_SLOT_TEMP_8 1 +# elif BOOST_PP_SLOT_OFFSET_9(BOOST_PP_VALUE) / 10000000UL == 2 +# define BOOST_PP_SLOT_TEMP_8 2 +# elif BOOST_PP_SLOT_OFFSET_9(BOOST_PP_VALUE) / 10000000UL == 3 +# define BOOST_PP_SLOT_TEMP_8 3 +# elif BOOST_PP_SLOT_OFFSET_9(BOOST_PP_VALUE) / 10000000UL == 4 +# define BOOST_PP_SLOT_TEMP_8 4 +# elif BOOST_PP_SLOT_OFFSET_9(BOOST_PP_VALUE) / 10000000UL == 5 +# define BOOST_PP_SLOT_TEMP_8 5 +# elif BOOST_PP_SLOT_OFFSET_9(BOOST_PP_VALUE) / 10000000UL == 6 +# define BOOST_PP_SLOT_TEMP_8 6 +# elif BOOST_PP_SLOT_OFFSET_9(BOOST_PP_VALUE) / 10000000UL == 7 +# define BOOST_PP_SLOT_TEMP_8 7 +# elif BOOST_PP_SLOT_OFFSET_9(BOOST_PP_VALUE) / 10000000UL == 8 +# define BOOST_PP_SLOT_TEMP_8 8 +# elif BOOST_PP_SLOT_OFFSET_9(BOOST_PP_VALUE) / 10000000UL == 9 +# define BOOST_PP_SLOT_TEMP_8 9 +# endif +# +# if BOOST_PP_SLOT_OFFSET_8(BOOST_PP_VALUE) / 1000000UL == 0 +# define BOOST_PP_SLOT_TEMP_7 0 +# elif BOOST_PP_SLOT_OFFSET_8(BOOST_PP_VALUE) / 1000000UL == 1 +# define BOOST_PP_SLOT_TEMP_7 1 +# elif BOOST_PP_SLOT_OFFSET_8(BOOST_PP_VALUE) / 1000000UL == 2 +# define BOOST_PP_SLOT_TEMP_7 2 +# elif BOOST_PP_SLOT_OFFSET_8(BOOST_PP_VALUE) / 1000000UL == 3 +# define BOOST_PP_SLOT_TEMP_7 3 +# elif BOOST_PP_SLOT_OFFSET_8(BOOST_PP_VALUE) / 1000000UL == 4 +# define BOOST_PP_SLOT_TEMP_7 4 +# elif BOOST_PP_SLOT_OFFSET_8(BOOST_PP_VALUE) / 1000000UL == 5 +# define BOOST_PP_SLOT_TEMP_7 5 +# elif BOOST_PP_SLOT_OFFSET_8(BOOST_PP_VALUE) / 1000000UL == 6 +# define BOOST_PP_SLOT_TEMP_7 6 +# elif BOOST_PP_SLOT_OFFSET_8(BOOST_PP_VALUE) / 1000000UL == 7 +# define BOOST_PP_SLOT_TEMP_7 7 +# elif BOOST_PP_SLOT_OFFSET_8(BOOST_PP_VALUE) / 1000000UL == 8 +# define BOOST_PP_SLOT_TEMP_7 8 +# elif BOOST_PP_SLOT_OFFSET_8(BOOST_PP_VALUE) / 1000000UL == 9 +# define BOOST_PP_SLOT_TEMP_7 9 +# endif +# +# if BOOST_PP_SLOT_OFFSET_7(BOOST_PP_VALUE) / 100000UL == 0 +# define BOOST_PP_SLOT_TEMP_6 0 +# elif BOOST_PP_SLOT_OFFSET_7(BOOST_PP_VALUE) / 100000UL == 1 +# define BOOST_PP_SLOT_TEMP_6 1 +# elif BOOST_PP_SLOT_OFFSET_7(BOOST_PP_VALUE) / 100000UL == 2 +# define BOOST_PP_SLOT_TEMP_6 2 +# elif BOOST_PP_SLOT_OFFSET_7(BOOST_PP_VALUE) / 100000UL == 3 +# define BOOST_PP_SLOT_TEMP_6 3 +# elif BOOST_PP_SLOT_OFFSET_7(BOOST_PP_VALUE) / 100000UL == 4 +# define BOOST_PP_SLOT_TEMP_6 4 +# elif BOOST_PP_SLOT_OFFSET_7(BOOST_PP_VALUE) / 100000UL == 5 +# define BOOST_PP_SLOT_TEMP_6 5 +# elif BOOST_PP_SLOT_OFFSET_7(BOOST_PP_VALUE) / 100000UL == 6 +# define BOOST_PP_SLOT_TEMP_6 6 +# elif BOOST_PP_SLOT_OFFSET_7(BOOST_PP_VALUE) / 100000UL == 7 +# define BOOST_PP_SLOT_TEMP_6 7 +# elif BOOST_PP_SLOT_OFFSET_7(BOOST_PP_VALUE) / 100000UL == 8 +# define BOOST_PP_SLOT_TEMP_6 8 +# elif BOOST_PP_SLOT_OFFSET_7(BOOST_PP_VALUE) / 100000UL == 9 +# define BOOST_PP_SLOT_TEMP_6 9 +# endif +# +# if BOOST_PP_SLOT_OFFSET_6(BOOST_PP_VALUE) / 10000UL == 0 +# define BOOST_PP_SLOT_TEMP_5 0 +# elif BOOST_PP_SLOT_OFFSET_6(BOOST_PP_VALUE) / 10000UL == 1 +# define BOOST_PP_SLOT_TEMP_5 1 +# elif BOOST_PP_SLOT_OFFSET_6(BOOST_PP_VALUE) / 10000UL == 2 +# define BOOST_PP_SLOT_TEMP_5 2 +# elif BOOST_PP_SLOT_OFFSET_6(BOOST_PP_VALUE) / 10000UL == 3 +# define BOOST_PP_SLOT_TEMP_5 3 +# elif BOOST_PP_SLOT_OFFSET_6(BOOST_PP_VALUE) / 10000UL == 4 +# define BOOST_PP_SLOT_TEMP_5 4 +# elif BOOST_PP_SLOT_OFFSET_6(BOOST_PP_VALUE) / 10000UL == 5 +# define BOOST_PP_SLOT_TEMP_5 5 +# elif BOOST_PP_SLOT_OFFSET_6(BOOST_PP_VALUE) / 10000UL == 6 +# define BOOST_PP_SLOT_TEMP_5 6 +# elif BOOST_PP_SLOT_OFFSET_6(BOOST_PP_VALUE) / 10000UL == 7 +# define BOOST_PP_SLOT_TEMP_5 7 +# elif BOOST_PP_SLOT_OFFSET_6(BOOST_PP_VALUE) / 10000UL == 8 +# define BOOST_PP_SLOT_TEMP_5 8 +# elif BOOST_PP_SLOT_OFFSET_6(BOOST_PP_VALUE) / 10000UL == 9 +# define BOOST_PP_SLOT_TEMP_5 9 +# endif +# +# if BOOST_PP_SLOT_OFFSET_5(BOOST_PP_VALUE) / 1000UL == 0 +# define BOOST_PP_SLOT_TEMP_4 0 +# elif BOOST_PP_SLOT_OFFSET_5(BOOST_PP_VALUE) / 1000UL == 1 +# define BOOST_PP_SLOT_TEMP_4 1 +# elif BOOST_PP_SLOT_OFFSET_5(BOOST_PP_VALUE) / 1000UL == 2 +# define BOOST_PP_SLOT_TEMP_4 2 +# elif BOOST_PP_SLOT_OFFSET_5(BOOST_PP_VALUE) / 1000UL == 3 +# define BOOST_PP_SLOT_TEMP_4 3 +# elif BOOST_PP_SLOT_OFFSET_5(BOOST_PP_VALUE) / 1000UL == 4 +# define BOOST_PP_SLOT_TEMP_4 4 +# elif BOOST_PP_SLOT_OFFSET_5(BOOST_PP_VALUE) / 1000UL == 5 +# define BOOST_PP_SLOT_TEMP_4 5 +# elif BOOST_PP_SLOT_OFFSET_5(BOOST_PP_VALUE) / 1000UL == 6 +# define BOOST_PP_SLOT_TEMP_4 6 +# elif BOOST_PP_SLOT_OFFSET_5(BOOST_PP_VALUE) / 1000UL == 7 +# define BOOST_PP_SLOT_TEMP_4 7 +# elif BOOST_PP_SLOT_OFFSET_5(BOOST_PP_VALUE) / 1000UL == 8 +# define BOOST_PP_SLOT_TEMP_4 8 +# elif BOOST_PP_SLOT_OFFSET_5(BOOST_PP_VALUE) / 1000UL == 9 +# define BOOST_PP_SLOT_TEMP_4 9 +# endif +# +# if BOOST_PP_SLOT_OFFSET_4(BOOST_PP_VALUE) / 100UL == 0 +# define BOOST_PP_SLOT_TEMP_3 0 +# elif BOOST_PP_SLOT_OFFSET_4(BOOST_PP_VALUE) / 100UL == 1 +# define BOOST_PP_SLOT_TEMP_3 1 +# elif BOOST_PP_SLOT_OFFSET_4(BOOST_PP_VALUE) / 100UL == 2 +# define BOOST_PP_SLOT_TEMP_3 2 +# elif BOOST_PP_SLOT_OFFSET_4(BOOST_PP_VALUE) / 100UL == 3 +# define BOOST_PP_SLOT_TEMP_3 3 +# elif BOOST_PP_SLOT_OFFSET_4(BOOST_PP_VALUE) / 100UL == 4 +# define BOOST_PP_SLOT_TEMP_3 4 +# elif BOOST_PP_SLOT_OFFSET_4(BOOST_PP_VALUE) / 100UL == 5 +# define BOOST_PP_SLOT_TEMP_3 5 +# elif BOOST_PP_SLOT_OFFSET_4(BOOST_PP_VALUE) / 100UL == 6 +# define BOOST_PP_SLOT_TEMP_3 6 +# elif BOOST_PP_SLOT_OFFSET_4(BOOST_PP_VALUE) / 100UL == 7 +# define BOOST_PP_SLOT_TEMP_3 7 +# elif BOOST_PP_SLOT_OFFSET_4(BOOST_PP_VALUE) / 100UL == 8 +# define BOOST_PP_SLOT_TEMP_3 8 +# elif BOOST_PP_SLOT_OFFSET_4(BOOST_PP_VALUE) / 100UL == 9 +# define BOOST_PP_SLOT_TEMP_3 9 +# endif +# +# if BOOST_PP_SLOT_OFFSET_3(BOOST_PP_VALUE) / 10UL == 0 +# define BOOST_PP_SLOT_TEMP_2 0 +# elif BOOST_PP_SLOT_OFFSET_3(BOOST_PP_VALUE) / 10UL == 1 +# define BOOST_PP_SLOT_TEMP_2 1 +# elif BOOST_PP_SLOT_OFFSET_3(BOOST_PP_VALUE) / 10UL == 2 +# define BOOST_PP_SLOT_TEMP_2 2 +# elif BOOST_PP_SLOT_OFFSET_3(BOOST_PP_VALUE) / 10UL == 3 +# define BOOST_PP_SLOT_TEMP_2 3 +# elif BOOST_PP_SLOT_OFFSET_3(BOOST_PP_VALUE) / 10UL == 4 +# define BOOST_PP_SLOT_TEMP_2 4 +# elif BOOST_PP_SLOT_OFFSET_3(BOOST_PP_VALUE) / 10UL == 5 +# define BOOST_PP_SLOT_TEMP_2 5 +# elif BOOST_PP_SLOT_OFFSET_3(BOOST_PP_VALUE) / 10UL == 6 +# define BOOST_PP_SLOT_TEMP_2 6 +# elif BOOST_PP_SLOT_OFFSET_3(BOOST_PP_VALUE) / 10UL == 7 +# define BOOST_PP_SLOT_TEMP_2 7 +# elif BOOST_PP_SLOT_OFFSET_3(BOOST_PP_VALUE) / 10UL == 8 +# define BOOST_PP_SLOT_TEMP_2 8 +# elif BOOST_PP_SLOT_OFFSET_3(BOOST_PP_VALUE) / 10UL == 9 +# define BOOST_PP_SLOT_TEMP_2 9 +# endif +# +# if BOOST_PP_SLOT_OFFSET_2(BOOST_PP_VALUE) == 0 +# define BOOST_PP_SLOT_TEMP_1 0 +# elif BOOST_PP_SLOT_OFFSET_2(BOOST_PP_VALUE) == 1 +# define BOOST_PP_SLOT_TEMP_1 1 +# elif BOOST_PP_SLOT_OFFSET_2(BOOST_PP_VALUE) == 2 +# define BOOST_PP_SLOT_TEMP_1 2 +# elif BOOST_PP_SLOT_OFFSET_2(BOOST_PP_VALUE) == 3 +# define BOOST_PP_SLOT_TEMP_1 3 +# elif BOOST_PP_SLOT_OFFSET_2(BOOST_PP_VALUE) == 4 +# define BOOST_PP_SLOT_TEMP_1 4 +# elif BOOST_PP_SLOT_OFFSET_2(BOOST_PP_VALUE) == 5 +# define BOOST_PP_SLOT_TEMP_1 5 +# elif BOOST_PP_SLOT_OFFSET_2(BOOST_PP_VALUE) == 6 +# define BOOST_PP_SLOT_TEMP_1 6 +# elif BOOST_PP_SLOT_OFFSET_2(BOOST_PP_VALUE) == 7 +# define BOOST_PP_SLOT_TEMP_1 7 +# elif BOOST_PP_SLOT_OFFSET_2(BOOST_PP_VALUE) == 8 +# define BOOST_PP_SLOT_TEMP_1 8 +# elif BOOST_PP_SLOT_OFFSET_2(BOOST_PP_VALUE) == 9 +# define BOOST_PP_SLOT_TEMP_1 9 +# endif +# +# undef BOOST_PP_VALUE diff --git a/realsense-file/3rd_party/boost/boost/preprocessor/slot/slot.hpp b/realsense-file/3rd_party/boost/boost/preprocessor/slot/slot.hpp new file mode 100644 index 0000000000..13127ee1c9 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/preprocessor/slot/slot.hpp @@ -0,0 +1,32 @@ +# /* ************************************************************************** +# * * +# * (C) Copyright Paul Mensonides 2002. +# * Distributed under the Boost Software License, Version 1.0. (See +# * accompanying file LICENSE_1_0.txt or copy at +# * http://www.boost.org/LICENSE_1_0.txt) +# * * +# ************************************************************************** */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_SLOT_SLOT_HPP +# define BOOST_PREPROCESSOR_SLOT_SLOT_HPP +# +# include +# include +# +# /* BOOST_PP_ASSIGN_SLOT */ +# +# define BOOST_PP_ASSIGN_SLOT(i) BOOST_PP_CAT(BOOST_PP_ASSIGN_SLOT_, i) +# +# define BOOST_PP_ASSIGN_SLOT_1 +# define BOOST_PP_ASSIGN_SLOT_2 +# define BOOST_PP_ASSIGN_SLOT_3 +# define BOOST_PP_ASSIGN_SLOT_4 +# define BOOST_PP_ASSIGN_SLOT_5 +# +# /* BOOST_PP_SLOT */ +# +# define BOOST_PP_SLOT(i) BOOST_PP_CAT(BOOST_PP_SLOT_, i)() +# +# endif diff --git a/realsense-file/3rd_party/boost/boost/preprocessor/stringize.hpp b/realsense-file/3rd_party/boost/boost/preprocessor/stringize.hpp new file mode 100644 index 0000000000..db3127e2df --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/preprocessor/stringize.hpp @@ -0,0 +1,33 @@ +# /* Copyright (C) 2001 +# * Housemarque Oy +# * http://www.housemarque.com +# * +# * 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) +# */ +# +# /* Revised by Paul Mensonides (2002) */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_STRINGIZE_HPP +# define BOOST_PREPROCESSOR_STRINGIZE_HPP +# +# include +# +# /* BOOST_PP_STRINGIZE */ +# +# if BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MSVC() +# define BOOST_PP_STRINGIZE(text) BOOST_PP_STRINGIZE_A((text)) +# define BOOST_PP_STRINGIZE_A(arg) BOOST_PP_STRINGIZE_I arg +# elif BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() +# define BOOST_PP_STRINGIZE(text) BOOST_PP_STRINGIZE_OO((text)) +# define BOOST_PP_STRINGIZE_OO(par) BOOST_PP_STRINGIZE_I ## par +# else +# define BOOST_PP_STRINGIZE(text) BOOST_PP_STRINGIZE_I(text) +# endif +# +# define BOOST_PP_STRINGIZE_I(text) #text +# +# endif diff --git a/realsense-file/3rd_party/boost/boost/preprocessor/tuple/detail/is_single_return.hpp b/realsense-file/3rd_party/boost/boost/preprocessor/tuple/detail/is_single_return.hpp new file mode 100644 index 0000000000..dfc5af6407 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/preprocessor/tuple/detail/is_single_return.hpp @@ -0,0 +1,28 @@ +# /* ************************************************************************** +# * * +# * (C) Copyright Edward Diener 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) * +# * * +# ************************************************************************** */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_TUPLE_DETAIL_IS_SINGLE_RETURN_HPP +# define BOOST_PREPROCESSOR_TUPLE_DETAIL_IS_SINGLE_RETURN_HPP +# +# include +# +# /* BOOST_PP_TUPLE_IS_SINGLE_RETURN */ +# +# if BOOST_PP_VARIADICS && BOOST_PP_VARIADICS_MSVC +# include +# include +# include +# define BOOST_PP_TUPLE_IS_SINGLE_RETURN(sr,nsr,tuple) \ + BOOST_PP_IIF(BOOST_PP_IS_1(BOOST_PP_TUPLE_SIZE(tuple)),sr,nsr) \ + /**/ +# endif /* BOOST_PP_VARIADICS && BOOST_PP_VARIADICS_MSVC */ +# +# endif /* BOOST_PREPROCESSOR_TUPLE_DETAIL_IS_SINGLE_RETURN_HPP */ diff --git a/realsense-file/3rd_party/boost/boost/preprocessor/tuple/eat.hpp b/realsense-file/3rd_party/boost/boost/preprocessor/tuple/eat.hpp new file mode 100644 index 0000000000..77224d9d01 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/preprocessor/tuple/eat.hpp @@ -0,0 +1,106 @@ +# /* Copyright (C) 2001 +# * Housemarque Oy +# * http://www.housemarque.com +# * +# * 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) +# */ +# +# /* Revised by Paul Mensonides (2002-2011) */ +# /* Revised by Edward Diener (2011) */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_TUPLE_EAT_HPP +# define BOOST_PREPROCESSOR_TUPLE_EAT_HPP +# +# include +# +# /* BOOST_PP_EAT */ +# +# if BOOST_PP_VARIADICS +# define BOOST_PP_EAT(...) +# else +# define BOOST_PP_EAT(x) +# endif +# +# /* BOOST_PP_TUPLE_EAT */ +# +# if BOOST_PP_VARIADICS +# define BOOST_PP_TUPLE_EAT(size) BOOST_PP_EAT +# else +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() +# define BOOST_PP_TUPLE_EAT(size) BOOST_PP_TUPLE_EAT_I(size) +# else +# define BOOST_PP_TUPLE_EAT(size) BOOST_PP_TUPLE_EAT_OO((size)) +# define BOOST_PP_TUPLE_EAT_OO(par) BOOST_PP_TUPLE_EAT_I ## par +# endif +# define BOOST_PP_TUPLE_EAT_I(size) BOOST_PP_TUPLE_EAT_ ## size +# endif +# define BOOST_PP_TUPLE_EAT_1(e0) +# define BOOST_PP_TUPLE_EAT_2(e0, e1) +# define BOOST_PP_TUPLE_EAT_3(e0, e1, e2) +# define BOOST_PP_TUPLE_EAT_4(e0, e1, e2, e3) +# define BOOST_PP_TUPLE_EAT_5(e0, e1, e2, e3, e4) +# define BOOST_PP_TUPLE_EAT_6(e0, e1, e2, e3, e4, e5) +# define BOOST_PP_TUPLE_EAT_7(e0, e1, e2, e3, e4, e5, e6) +# define BOOST_PP_TUPLE_EAT_8(e0, e1, e2, e3, e4, e5, e6, e7) +# define BOOST_PP_TUPLE_EAT_9(e0, e1, e2, e3, e4, e5, e6, e7, e8) +# define BOOST_PP_TUPLE_EAT_10(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9) +# define BOOST_PP_TUPLE_EAT_11(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10) +# define BOOST_PP_TUPLE_EAT_12(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11) +# define BOOST_PP_TUPLE_EAT_13(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12) +# define BOOST_PP_TUPLE_EAT_14(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13) +# define BOOST_PP_TUPLE_EAT_15(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14) +# define BOOST_PP_TUPLE_EAT_16(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15) +# define BOOST_PP_TUPLE_EAT_17(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16) +# define BOOST_PP_TUPLE_EAT_18(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17) +# define BOOST_PP_TUPLE_EAT_19(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18) +# define BOOST_PP_TUPLE_EAT_20(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19) +# define BOOST_PP_TUPLE_EAT_21(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20) +# define BOOST_PP_TUPLE_EAT_22(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21) +# define BOOST_PP_TUPLE_EAT_23(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22) +# define BOOST_PP_TUPLE_EAT_24(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23) +# define BOOST_PP_TUPLE_EAT_25(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24) +# define BOOST_PP_TUPLE_EAT_26(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25) +# define BOOST_PP_TUPLE_EAT_27(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26) +# define BOOST_PP_TUPLE_EAT_28(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27) +# define BOOST_PP_TUPLE_EAT_29(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28) +# define BOOST_PP_TUPLE_EAT_30(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29) +# define BOOST_PP_TUPLE_EAT_31(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30) +# define BOOST_PP_TUPLE_EAT_32(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31) +# define BOOST_PP_TUPLE_EAT_33(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32) +# define BOOST_PP_TUPLE_EAT_34(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33) +# define BOOST_PP_TUPLE_EAT_35(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34) +# define BOOST_PP_TUPLE_EAT_36(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35) +# define BOOST_PP_TUPLE_EAT_37(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36) +# define BOOST_PP_TUPLE_EAT_38(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37) +# define BOOST_PP_TUPLE_EAT_39(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38) +# define BOOST_PP_TUPLE_EAT_40(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39) +# define BOOST_PP_TUPLE_EAT_41(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40) +# define BOOST_PP_TUPLE_EAT_42(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41) +# define BOOST_PP_TUPLE_EAT_43(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42) +# define BOOST_PP_TUPLE_EAT_44(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43) +# define BOOST_PP_TUPLE_EAT_45(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44) +# define BOOST_PP_TUPLE_EAT_46(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45) +# define BOOST_PP_TUPLE_EAT_47(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46) +# define BOOST_PP_TUPLE_EAT_48(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47) +# define BOOST_PP_TUPLE_EAT_49(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48) +# define BOOST_PP_TUPLE_EAT_50(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49) +# define BOOST_PP_TUPLE_EAT_51(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50) +# define BOOST_PP_TUPLE_EAT_52(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51) +# define BOOST_PP_TUPLE_EAT_53(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52) +# define BOOST_PP_TUPLE_EAT_54(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53) +# define BOOST_PP_TUPLE_EAT_55(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54) +# define BOOST_PP_TUPLE_EAT_56(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55) +# define BOOST_PP_TUPLE_EAT_57(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56) +# define BOOST_PP_TUPLE_EAT_58(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57) +# define BOOST_PP_TUPLE_EAT_59(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58) +# define BOOST_PP_TUPLE_EAT_60(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59) +# define BOOST_PP_TUPLE_EAT_61(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60) +# define BOOST_PP_TUPLE_EAT_62(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61) +# define BOOST_PP_TUPLE_EAT_63(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62) +# define BOOST_PP_TUPLE_EAT_64(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) +# +# endif diff --git a/realsense-file/3rd_party/boost/boost/preprocessor/tuple/elem.hpp b/realsense-file/3rd_party/boost/boost/preprocessor/tuple/elem.hpp new file mode 100644 index 0000000000..0e7c592701 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/preprocessor/tuple/elem.hpp @@ -0,0 +1,201 @@ +# /* Copyright (C) 2001 +# * Housemarque Oy +# * http://www.housemarque.com +# * +# * 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) +# */ +# +# /* Revised by Paul Mensonides (2002-2011) */ +# /* Revised by Edward Diener (2011,2014) */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_TUPLE_ELEM_HPP +# define BOOST_PREPROCESSOR_TUPLE_ELEM_HPP +# +# include +# include +# include +# include +# include +# include +# include +# +# if BOOST_PP_VARIADICS +# if BOOST_PP_VARIADICS_MSVC +# define BOOST_PP_TUPLE_ELEM(...) BOOST_PP_TUPLE_ELEM_I(BOOST_PP_OVERLOAD(BOOST_PP_TUPLE_ELEM_O_, __VA_ARGS__), (__VA_ARGS__)) +# define BOOST_PP_TUPLE_ELEM_I(m, args) BOOST_PP_TUPLE_ELEM_II(m, args) +# define BOOST_PP_TUPLE_ELEM_II(m, args) BOOST_PP_CAT(m ## args,) +/* + Use BOOST_PP_REM_CAT if it is a single element tuple ( which might be empty ) + else use BOOST_PP_REM. This fixes a VC++ problem with an empty tuple and BOOST_PP_TUPLE_ELEM + functionality. See tuple_elem_bug_test.cxx. +*/ +# define BOOST_PP_TUPLE_ELEM_O_2(n, tuple) \ + BOOST_PP_VARIADIC_ELEM(n, BOOST_PP_EXPAND(BOOST_PP_TUPLE_IS_SINGLE_RETURN(BOOST_PP_REM_CAT,BOOST_PP_REM,tuple) tuple)) \ + /**/ +# else +# define BOOST_PP_TUPLE_ELEM(...) BOOST_PP_OVERLOAD(BOOST_PP_TUPLE_ELEM_O_, __VA_ARGS__)(__VA_ARGS__) +# define BOOST_PP_TUPLE_ELEM_O_2(n, tuple) BOOST_PP_VARIADIC_ELEM(n, BOOST_PP_REM tuple) +# endif +# define BOOST_PP_TUPLE_ELEM_O_3(size, n, tuple) BOOST_PP_TUPLE_ELEM_O_2(n, tuple) +# else +# if BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MSVC() +# define BOOST_PP_TUPLE_ELEM(size, n, tuple) BOOST_PP_TUPLE_ELEM_I(BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM_, n), BOOST_PP_CAT(BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM_E_, size), tuple)) +# define BOOST_PP_TUPLE_ELEM_I(m, args) BOOST_PP_TUPLE_ELEM_II(m, args) +# define BOOST_PP_TUPLE_ELEM_II(m, args) BOOST_PP_CAT(m ## args,) +# elif BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() +# define BOOST_PP_TUPLE_ELEM(size, n, tuple) BOOST_PP_TUPLE_ELEM_I_OO((size, n, tuple)) +# define BOOST_PP_TUPLE_ELEM_I_OO(par) BOOST_PP_TUPLE_ELEM_I ## par +# define BOOST_PP_TUPLE_ELEM_I(size, n, tuple) BOOST_PP_TUPLE_ELEM_II((n, BOOST_PP_TUPLE_ELEM_E_ ## size ## tuple)) +# define BOOST_PP_TUPLE_ELEM_II(par) BOOST_PP_TUPLE_ELEM_III_OO(par) +# define BOOST_PP_TUPLE_ELEM_III_OO(par) BOOST_PP_TUPLE_ELEM_III ## par +# define BOOST_PP_TUPLE_ELEM_III(n, etuple) BOOST_PP_TUPLE_ELEM_ ## n ## etuple +# else +# define BOOST_PP_TUPLE_ELEM(size, n, tuple) BOOST_PP_TUPLE_ELEM_I(BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM_, n) BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM_E_, size) tuple) +# define BOOST_PP_TUPLE_ELEM_I(x) x +# endif +# define BOOST_PP_TUPLE_ELEM_E_1(e0) (e0, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) +# define BOOST_PP_TUPLE_ELEM_E_2(e0, e1) (e0, e1, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) +# define BOOST_PP_TUPLE_ELEM_E_3(e0, e1, e2) (e0, e1, e2, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) +# define BOOST_PP_TUPLE_ELEM_E_4(e0, e1, e2, e3) (e0, e1, e2, e3, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) +# define BOOST_PP_TUPLE_ELEM_E_5(e0, e1, e2, e3, e4) (e0, e1, e2, e3, e4, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) +# define BOOST_PP_TUPLE_ELEM_E_6(e0, e1, e2, e3, e4, e5) (e0, e1, e2, e3, e4, e5, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) +# define BOOST_PP_TUPLE_ELEM_E_7(e0, e1, e2, e3, e4, e5, e6) (e0, e1, e2, e3, e4, e5, e6, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) +# define BOOST_PP_TUPLE_ELEM_E_8(e0, e1, e2, e3, e4, e5, e6, e7) (e0, e1, e2, e3, e4, e5, e6, e7, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) +# define BOOST_PP_TUPLE_ELEM_E_9(e0, e1, e2, e3, e4, e5, e6, e7, e8) (e0, e1, e2, e3, e4, e5, e6, e7, e8, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) +# define BOOST_PP_TUPLE_ELEM_E_10(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) +# define BOOST_PP_TUPLE_ELEM_E_11(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) +# define BOOST_PP_TUPLE_ELEM_E_12(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) +# define BOOST_PP_TUPLE_ELEM_E_13(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) +# define BOOST_PP_TUPLE_ELEM_E_14(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) +# define BOOST_PP_TUPLE_ELEM_E_15(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) +# define BOOST_PP_TUPLE_ELEM_E_16(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) +# define BOOST_PP_TUPLE_ELEM_E_17(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) +# define BOOST_PP_TUPLE_ELEM_E_18(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) +# define BOOST_PP_TUPLE_ELEM_E_19(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) +# define BOOST_PP_TUPLE_ELEM_E_20(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) +# define BOOST_PP_TUPLE_ELEM_E_21(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) +# define BOOST_PP_TUPLE_ELEM_E_22(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) +# define BOOST_PP_TUPLE_ELEM_E_23(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) +# define BOOST_PP_TUPLE_ELEM_E_24(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) +# define BOOST_PP_TUPLE_ELEM_E_25(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) +# define BOOST_PP_TUPLE_ELEM_E_26(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) +# define BOOST_PP_TUPLE_ELEM_E_27(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) +# define BOOST_PP_TUPLE_ELEM_E_28(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) +# define BOOST_PP_TUPLE_ELEM_E_29(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) +# define BOOST_PP_TUPLE_ELEM_E_30(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) +# define BOOST_PP_TUPLE_ELEM_E_31(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) +# define BOOST_PP_TUPLE_ELEM_E_32(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) +# define BOOST_PP_TUPLE_ELEM_E_33(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) +# define BOOST_PP_TUPLE_ELEM_E_34(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) +# define BOOST_PP_TUPLE_ELEM_E_35(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) +# define BOOST_PP_TUPLE_ELEM_E_36(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) +# define BOOST_PP_TUPLE_ELEM_E_37(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) +# define BOOST_PP_TUPLE_ELEM_E_38(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) +# define BOOST_PP_TUPLE_ELEM_E_39(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) +# define BOOST_PP_TUPLE_ELEM_E_40(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) +# define BOOST_PP_TUPLE_ELEM_E_41(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) +# define BOOST_PP_TUPLE_ELEM_E_42(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) +# define BOOST_PP_TUPLE_ELEM_E_43(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) +# define BOOST_PP_TUPLE_ELEM_E_44(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) +# define BOOST_PP_TUPLE_ELEM_E_45(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) +# define BOOST_PP_TUPLE_ELEM_E_46(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) +# define BOOST_PP_TUPLE_ELEM_E_47(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) +# define BOOST_PP_TUPLE_ELEM_E_48(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) +# define BOOST_PP_TUPLE_ELEM_E_49(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) +# define BOOST_PP_TUPLE_ELEM_E_50(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) +# define BOOST_PP_TUPLE_ELEM_E_51(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) +# define BOOST_PP_TUPLE_ELEM_E_52(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) +# define BOOST_PP_TUPLE_ELEM_E_53(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) +# define BOOST_PP_TUPLE_ELEM_E_54(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) +# define BOOST_PP_TUPLE_ELEM_E_55(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, ?, ?, ?, ?, ?, ?, ?, ?, ?) +# define BOOST_PP_TUPLE_ELEM_E_56(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, ?, ?, ?, ?, ?, ?, ?, ?) +# define BOOST_PP_TUPLE_ELEM_E_57(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, ?, ?, ?, ?, ?, ?, ?) +# define BOOST_PP_TUPLE_ELEM_E_58(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, ?, ?, ?, ?, ?, ?) +# define BOOST_PP_TUPLE_ELEM_E_59(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, ?, ?, ?, ?, ?) +# define BOOST_PP_TUPLE_ELEM_E_60(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, ?, ?, ?, ?) +# define BOOST_PP_TUPLE_ELEM_E_61(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, ?, ?, ?) +# define BOOST_PP_TUPLE_ELEM_E_62(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, ?, ?) +# define BOOST_PP_TUPLE_ELEM_E_63(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, ?) +# define BOOST_PP_TUPLE_ELEM_E_64 +# define BOOST_PP_TUPLE_ELEM_0(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e0 +# define BOOST_PP_TUPLE_ELEM_1(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e1 +# define BOOST_PP_TUPLE_ELEM_2(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e2 +# define BOOST_PP_TUPLE_ELEM_3(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e3 +# define BOOST_PP_TUPLE_ELEM_4(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e4 +# define BOOST_PP_TUPLE_ELEM_5(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e5 +# define BOOST_PP_TUPLE_ELEM_6(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e6 +# define BOOST_PP_TUPLE_ELEM_7(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e7 +# define BOOST_PP_TUPLE_ELEM_8(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e8 +# define BOOST_PP_TUPLE_ELEM_9(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e9 +# define BOOST_PP_TUPLE_ELEM_10(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e10 +# define BOOST_PP_TUPLE_ELEM_11(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e11 +# define BOOST_PP_TUPLE_ELEM_12(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e12 +# define BOOST_PP_TUPLE_ELEM_13(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e13 +# define BOOST_PP_TUPLE_ELEM_14(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e14 +# define BOOST_PP_TUPLE_ELEM_15(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e15 +# define BOOST_PP_TUPLE_ELEM_16(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e16 +# define BOOST_PP_TUPLE_ELEM_17(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e17 +# define BOOST_PP_TUPLE_ELEM_18(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e18 +# define BOOST_PP_TUPLE_ELEM_19(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e19 +# define BOOST_PP_TUPLE_ELEM_20(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e20 +# define BOOST_PP_TUPLE_ELEM_21(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e21 +# define BOOST_PP_TUPLE_ELEM_22(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e22 +# define BOOST_PP_TUPLE_ELEM_23(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e23 +# define BOOST_PP_TUPLE_ELEM_24(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e24 +# define BOOST_PP_TUPLE_ELEM_25(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e25 +# define BOOST_PP_TUPLE_ELEM_26(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e26 +# define BOOST_PP_TUPLE_ELEM_27(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e27 +# define BOOST_PP_TUPLE_ELEM_28(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e28 +# define BOOST_PP_TUPLE_ELEM_29(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e29 +# define BOOST_PP_TUPLE_ELEM_30(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e30 +# define BOOST_PP_TUPLE_ELEM_31(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e31 +# define BOOST_PP_TUPLE_ELEM_32(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e32 +# define BOOST_PP_TUPLE_ELEM_33(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e33 +# define BOOST_PP_TUPLE_ELEM_34(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e34 +# define BOOST_PP_TUPLE_ELEM_35(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e35 +# define BOOST_PP_TUPLE_ELEM_36(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e36 +# define BOOST_PP_TUPLE_ELEM_37(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e37 +# define BOOST_PP_TUPLE_ELEM_38(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e38 +# define BOOST_PP_TUPLE_ELEM_39(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e39 +# define BOOST_PP_TUPLE_ELEM_40(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e40 +# define BOOST_PP_TUPLE_ELEM_41(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e41 +# define BOOST_PP_TUPLE_ELEM_42(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e42 +# define BOOST_PP_TUPLE_ELEM_43(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e43 +# define BOOST_PP_TUPLE_ELEM_44(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e44 +# define BOOST_PP_TUPLE_ELEM_45(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e45 +# define BOOST_PP_TUPLE_ELEM_46(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e46 +# define BOOST_PP_TUPLE_ELEM_47(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e47 +# define BOOST_PP_TUPLE_ELEM_48(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e48 +# define BOOST_PP_TUPLE_ELEM_49(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e49 +# define BOOST_PP_TUPLE_ELEM_50(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e50 +# define BOOST_PP_TUPLE_ELEM_51(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e51 +# define BOOST_PP_TUPLE_ELEM_52(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e52 +# define BOOST_PP_TUPLE_ELEM_53(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e53 +# define BOOST_PP_TUPLE_ELEM_54(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e54 +# define BOOST_PP_TUPLE_ELEM_55(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e55 +# define BOOST_PP_TUPLE_ELEM_56(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e56 +# define BOOST_PP_TUPLE_ELEM_57(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e57 +# define BOOST_PP_TUPLE_ELEM_58(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e58 +# define BOOST_PP_TUPLE_ELEM_59(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e59 +# define BOOST_PP_TUPLE_ELEM_60(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e60 +# define BOOST_PP_TUPLE_ELEM_61(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e61 +# define BOOST_PP_TUPLE_ELEM_62(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e62 +# define BOOST_PP_TUPLE_ELEM_63(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e63 +# endif +# +# /* directly used elsewhere in Boost... */ +# +# define BOOST_PP_TUPLE_ELEM_1_0(a) a +# +# define BOOST_PP_TUPLE_ELEM_2_0(a, b) a +# define BOOST_PP_TUPLE_ELEM_2_1(a, b) b +# +# define BOOST_PP_TUPLE_ELEM_3_0(a, b, c) a +# define BOOST_PP_TUPLE_ELEM_3_1(a, b, c) b +# define BOOST_PP_TUPLE_ELEM_3_2(a, b, c) c +# +# endif diff --git a/realsense-file/3rd_party/boost/boost/preprocessor/tuple/rem.hpp b/realsense-file/3rd_party/boost/boost/preprocessor/tuple/rem.hpp new file mode 100644 index 0000000000..d1e686530d --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/preprocessor/tuple/rem.hpp @@ -0,0 +1,149 @@ +# /* ************************************************************************** +# * * +# * (C) Copyright Paul Mensonides 2002-2011. * +# * (C) Copyright Edward Diener 2011,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) * +# * * +# ************************************************************************** */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_TUPLE_REM_HPP +# define BOOST_PREPROCESSOR_TUPLE_REM_HPP +# +# include +# include +# include +# include +# include +# +# /* BOOST_PP_REM */ +# +# if BOOST_PP_VARIADICS +# if BOOST_PP_VARIADICS_MSVC + /* To be used internally when __VA_ARGS__ could be empty ( or is a single element ) */ +# define BOOST_PP_REM_CAT(...) BOOST_PP_CAT(__VA_ARGS__,) +# endif +# define BOOST_PP_REM(...) __VA_ARGS__ +# else +# define BOOST_PP_REM(x) x +# endif +# +# /* BOOST_PP_TUPLE_REM */ +# +/* + VC++8.0 cannot handle the variadic version of BOOST_PP_TUPLE_REM(size) +*/ +# if BOOST_PP_VARIADICS && !(BOOST_PP_VARIADICS_MSVC && _MSC_VER <= 1400) +# if BOOST_PP_VARIADICS_MSVC + /* To be used internally when the size could be 0 ( or 1 ) */ +# define BOOST_PP_TUPLE_REM_CAT(size) BOOST_PP_REM_CAT +# endif +# define BOOST_PP_TUPLE_REM(size) BOOST_PP_REM +# else +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() +# define BOOST_PP_TUPLE_REM(size) BOOST_PP_TUPLE_REM_I(size) +# else +# define BOOST_PP_TUPLE_REM(size) BOOST_PP_TUPLE_REM_OO((size)) +# define BOOST_PP_TUPLE_REM_OO(par) BOOST_PP_TUPLE_REM_I ## par +# endif +# define BOOST_PP_TUPLE_REM_I(size) BOOST_PP_TUPLE_REM_ ## size +# endif +# define BOOST_PP_TUPLE_REM_0() +# define BOOST_PP_TUPLE_REM_1(e0) e0 +# define BOOST_PP_TUPLE_REM_2(e0, e1) e0, e1 +# define BOOST_PP_TUPLE_REM_3(e0, e1, e2) e0, e1, e2 +# define BOOST_PP_TUPLE_REM_4(e0, e1, e2, e3) e0, e1, e2, e3 +# define BOOST_PP_TUPLE_REM_5(e0, e1, e2, e3, e4) e0, e1, e2, e3, e4 +# define BOOST_PP_TUPLE_REM_6(e0, e1, e2, e3, e4, e5) e0, e1, e2, e3, e4, e5 +# define BOOST_PP_TUPLE_REM_7(e0, e1, e2, e3, e4, e5, e6) e0, e1, e2, e3, e4, e5, e6 +# define BOOST_PP_TUPLE_REM_8(e0, e1, e2, e3, e4, e5, e6, e7) e0, e1, e2, e3, e4, e5, e6, e7 +# define BOOST_PP_TUPLE_REM_9(e0, e1, e2, e3, e4, e5, e6, e7, e8) e0, e1, e2, e3, e4, e5, e6, e7, e8 +# define BOOST_PP_TUPLE_REM_10(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9 +# define BOOST_PP_TUPLE_REM_11(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10 +# define BOOST_PP_TUPLE_REM_12(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11 +# define BOOST_PP_TUPLE_REM_13(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12 +# define BOOST_PP_TUPLE_REM_14(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13 +# define BOOST_PP_TUPLE_REM_15(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14 +# define BOOST_PP_TUPLE_REM_16(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15 +# define BOOST_PP_TUPLE_REM_17(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16 +# define BOOST_PP_TUPLE_REM_18(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17 +# define BOOST_PP_TUPLE_REM_19(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18 +# define BOOST_PP_TUPLE_REM_20(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19 +# define BOOST_PP_TUPLE_REM_21(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20 +# define BOOST_PP_TUPLE_REM_22(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21 +# define BOOST_PP_TUPLE_REM_23(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22 +# define BOOST_PP_TUPLE_REM_24(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23 +# define BOOST_PP_TUPLE_REM_25(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24 +# define BOOST_PP_TUPLE_REM_26(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25 +# define BOOST_PP_TUPLE_REM_27(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26 +# define BOOST_PP_TUPLE_REM_28(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27 +# define BOOST_PP_TUPLE_REM_29(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28 +# define BOOST_PP_TUPLE_REM_30(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29 +# define BOOST_PP_TUPLE_REM_31(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30 +# define BOOST_PP_TUPLE_REM_32(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31 +# define BOOST_PP_TUPLE_REM_33(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32 +# define BOOST_PP_TUPLE_REM_34(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33 +# define BOOST_PP_TUPLE_REM_35(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34 +# define BOOST_PP_TUPLE_REM_36(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35 +# define BOOST_PP_TUPLE_REM_37(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36 +# define BOOST_PP_TUPLE_REM_38(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37 +# define BOOST_PP_TUPLE_REM_39(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38 +# define BOOST_PP_TUPLE_REM_40(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39 +# define BOOST_PP_TUPLE_REM_41(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40 +# define BOOST_PP_TUPLE_REM_42(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41 +# define BOOST_PP_TUPLE_REM_43(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42 +# define BOOST_PP_TUPLE_REM_44(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43 +# define BOOST_PP_TUPLE_REM_45(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44 +# define BOOST_PP_TUPLE_REM_46(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45 +# define BOOST_PP_TUPLE_REM_47(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46 +# define BOOST_PP_TUPLE_REM_48(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47 +# define BOOST_PP_TUPLE_REM_49(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48 +# define BOOST_PP_TUPLE_REM_50(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49 +# define BOOST_PP_TUPLE_REM_51(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50 +# define BOOST_PP_TUPLE_REM_52(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51 +# define BOOST_PP_TUPLE_REM_53(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52 +# define BOOST_PP_TUPLE_REM_54(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53 +# define BOOST_PP_TUPLE_REM_55(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54 +# define BOOST_PP_TUPLE_REM_56(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55 +# define BOOST_PP_TUPLE_REM_57(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56 +# define BOOST_PP_TUPLE_REM_58(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57 +# define BOOST_PP_TUPLE_REM_59(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58 +# define BOOST_PP_TUPLE_REM_60(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59 +# define BOOST_PP_TUPLE_REM_61(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60 +# define BOOST_PP_TUPLE_REM_62(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61 +# define BOOST_PP_TUPLE_REM_63(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62 +# define BOOST_PP_TUPLE_REM_64(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63 +# +# /* BOOST_PP_TUPLE_REM_CTOR */ +# +# if BOOST_PP_VARIADICS +# if BOOST_PP_VARIADICS_MSVC +# define BOOST_PP_TUPLE_REM_CTOR(...) BOOST_PP_TUPLE_REM_CTOR_I(BOOST_PP_OVERLOAD(BOOST_PP_TUPLE_REM_CTOR_O_, __VA_ARGS__), (__VA_ARGS__)) +# define BOOST_PP_TUPLE_REM_CTOR_I(m, args) BOOST_PP_TUPLE_REM_CTOR_II(m, args) +# define BOOST_PP_TUPLE_REM_CTOR_II(m, args) BOOST_PP_CAT(m ## args,) +# define BOOST_PP_TUPLE_REM_CTOR_O_1(tuple) BOOST_PP_EXPAND(BOOST_PP_TUPLE_IS_SINGLE_RETURN(BOOST_PP_REM_CAT,BOOST_PP_REM,tuple) tuple) +# else +# define BOOST_PP_TUPLE_REM_CTOR(...) BOOST_PP_OVERLOAD(BOOST_PP_TUPLE_REM_CTOR_O_, __VA_ARGS__)(__VA_ARGS__) +# define BOOST_PP_TUPLE_REM_CTOR_O_1(tuple) BOOST_PP_REM tuple +# endif +# define BOOST_PP_TUPLE_REM_CTOR_O_2(size, tuple) BOOST_PP_TUPLE_REM_CTOR_O_1(tuple) +# else +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() +# define BOOST_PP_TUPLE_REM_CTOR(size, tuple) BOOST_PP_TUPLE_REM_CTOR_I(BOOST_PP_TUPLE_REM(size), tuple) +# else +# define BOOST_PP_TUPLE_REM_CTOR(size, tuple) BOOST_PP_TUPLE_REM_CTOR_D(size, tuple) +# define BOOST_PP_TUPLE_REM_CTOR_D(size, tuple) BOOST_PP_TUPLE_REM_CTOR_I(BOOST_PP_TUPLE_REM(size), tuple) +# endif +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() +# define BOOST_PP_TUPLE_REM_CTOR_I(ext, tuple) ext tuple +# else +# define BOOST_PP_TUPLE_REM_CTOR_I(ext, tuple) BOOST_PP_TUPLE_REM_CTOR_OO((ext, tuple)) +# define BOOST_PP_TUPLE_REM_CTOR_OO(par) BOOST_PP_TUPLE_REM_CTOR_II ## par +# define BOOST_PP_TUPLE_REM_CTOR_II(ext, tuple) ext ## tuple +# endif +# endif +# +# endif diff --git a/realsense-file/3rd_party/boost/boost/preprocessor/tuple/size.hpp b/realsense-file/3rd_party/boost/boost/preprocessor/tuple/size.hpp new file mode 100644 index 0000000000..1874be071b --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/preprocessor/tuple/size.hpp @@ -0,0 +1,28 @@ +# /* ************************************************************************** +# * * +# * (C) Copyright Edward Diener 2011. * +# * (C) Copyright Paul Mensonides 2011. * +# * Distributed under the Boost Software License, Version 1.0. (See * +# * accompanying file LICENSE_1_0.txt or copy at * +# * http://www.boost.org/LICENSE_1_0.txt) * +# * * +# ************************************************************************** */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_TUPLE_SIZE_HPP +# define BOOST_PREPROCESSOR_TUPLE_SIZE_HPP +# +# include +# include +# include +# +# if BOOST_PP_VARIADICS +# if BOOST_PP_VARIADICS_MSVC +# define BOOST_PP_TUPLE_SIZE(tuple) BOOST_PP_CAT(BOOST_PP_VARIADIC_SIZE tuple,) +# else +# define BOOST_PP_TUPLE_SIZE(tuple) BOOST_PP_VARIADIC_SIZE tuple +# endif +# endif +# +# endif diff --git a/realsense-file/3rd_party/boost/boost/preprocessor/tuple/to_list.hpp b/realsense-file/3rd_party/boost/boost/preprocessor/tuple/to_list.hpp new file mode 100644 index 0000000000..aff96f406e --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/preprocessor/tuple/to_list.hpp @@ -0,0 +1,118 @@ +# /* Copyright (C) 2001 +# * Housemarque Oy +# * http://www.housemarque.com +# * +# * 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) +# */ +# +# /* Revised by Paul Mensonides (2002-2011) */ +# /* Revised by Edward Diener (2011) */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_TUPLE_TO_LIST_HPP +# define BOOST_PREPROCESSOR_TUPLE_TO_LIST_HPP +# +# include +# include +# include +# include +# include +# +# /* BOOST_PP_TUPLE_TO_LIST */ +# +# if BOOST_PP_VARIADICS +# if BOOST_PP_VARIADICS_MSVC +# define BOOST_PP_TUPLE_TO_LIST(...) BOOST_PP_TUPLE_TO_LIST_I(BOOST_PP_OVERLOAD(BOOST_PP_TUPLE_TO_LIST_O_, __VA_ARGS__), (__VA_ARGS__)) +# define BOOST_PP_TUPLE_TO_LIST_I(m, args) BOOST_PP_TUPLE_TO_LIST_II(m, args) +# define BOOST_PP_TUPLE_TO_LIST_II(m, args) BOOST_PP_CAT(m ## args,) +# define BOOST_PP_TUPLE_TO_LIST_O_1(tuple) BOOST_PP_CAT(BOOST_PP_TUPLE_TO_LIST_, BOOST_PP_TUPLE_SIZE(tuple)) tuple +# else +# define BOOST_PP_TUPLE_TO_LIST(...) BOOST_PP_OVERLOAD(BOOST_PP_TUPLE_TO_LIST_O_, __VA_ARGS__)(__VA_ARGS__) +# define BOOST_PP_TUPLE_TO_LIST_O_1(tuple) BOOST_PP_CAT(BOOST_PP_TUPLE_TO_LIST_, BOOST_PP_VARIADIC_SIZE tuple) tuple +# endif +# define BOOST_PP_TUPLE_TO_LIST_O_2(size, tuple) BOOST_PP_TUPLE_TO_LIST_O_1(tuple) +# else +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() +# define BOOST_PP_TUPLE_TO_LIST(size, tuple) BOOST_PP_TUPLE_TO_LIST_I(size, tuple) +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MSVC() +# define BOOST_PP_TUPLE_TO_LIST_I(s, t) BOOST_PP_TUPLE_TO_LIST_ ## s t +# else +# define BOOST_PP_TUPLE_TO_LIST_I(s, t) BOOST_PP_TUPLE_TO_LIST_II(BOOST_PP_TUPLE_TO_LIST_ ## s t) +# define BOOST_PP_TUPLE_TO_LIST_II(res) res +# endif +# else +# define BOOST_PP_TUPLE_TO_LIST(size, tuple) BOOST_PP_TUPLE_TO_LIST_OO((size, tuple)) +# define BOOST_PP_TUPLE_TO_LIST_OO(par) BOOST_PP_TUPLE_TO_LIST_I ## par +# define BOOST_PP_TUPLE_TO_LIST_I(s, t) BOOST_PP_TUPLE_TO_LIST_ ## s ## t +# endif +# endif +# +# define BOOST_PP_TUPLE_TO_LIST_1(e0) (e0, BOOST_PP_NIL) +# define BOOST_PP_TUPLE_TO_LIST_2(e0, e1) (e0, (e1, BOOST_PP_NIL)) +# define BOOST_PP_TUPLE_TO_LIST_3(e0, e1, e2) (e0, (e1, (e2, BOOST_PP_NIL))) +# define BOOST_PP_TUPLE_TO_LIST_4(e0, e1, e2, e3) (e0, (e1, (e2, (e3, BOOST_PP_NIL)))) +# define BOOST_PP_TUPLE_TO_LIST_5(e0, e1, e2, e3, e4) (e0, (e1, (e2, (e3, (e4, BOOST_PP_NIL))))) +# define BOOST_PP_TUPLE_TO_LIST_6(e0, e1, e2, e3, e4, e5) (e0, (e1, (e2, (e3, (e4, (e5, BOOST_PP_NIL)))))) +# define BOOST_PP_TUPLE_TO_LIST_7(e0, e1, e2, e3, e4, e5, e6) (e0, (e1, (e2, (e3, (e4, (e5, (e6, BOOST_PP_NIL))))))) +# define BOOST_PP_TUPLE_TO_LIST_8(e0, e1, e2, e3, e4, e5, e6, e7) (e0, (e1, (e2, (e3, (e4, (e5, (e6, (e7, BOOST_PP_NIL)))))))) +# define BOOST_PP_TUPLE_TO_LIST_9(e0, e1, e2, e3, e4, e5, e6, e7, e8) (e0, (e1, (e2, (e3, (e4, (e5, (e6, (e7, (e8, BOOST_PP_NIL))))))))) +# define BOOST_PP_TUPLE_TO_LIST_10(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9) (e0, (e1, (e2, (e3, (e4, (e5, (e6, (e7, (e8, (e9, BOOST_PP_NIL)))))))))) +# define BOOST_PP_TUPLE_TO_LIST_11(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10) (e0, (e1, (e2, (e3, (e4, (e5, (e6, (e7, (e8, (e9, (e10, BOOST_PP_NIL))))))))))) +# define BOOST_PP_TUPLE_TO_LIST_12(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11) (e0, (e1, (e2, (e3, (e4, (e5, (e6, (e7, (e8, (e9, (e10, (e11, BOOST_PP_NIL)))))))))))) +# define BOOST_PP_TUPLE_TO_LIST_13(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12) (e0, (e1, (e2, (e3, (e4, (e5, (e6, (e7, (e8, (e9, (e10, (e11, (e12, BOOST_PP_NIL))))))))))))) +# define BOOST_PP_TUPLE_TO_LIST_14(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13) (e0, (e1, (e2, (e3, (e4, (e5, (e6, (e7, (e8, (e9, (e10, (e11, (e12, (e13, BOOST_PP_NIL)))))))))))))) +# define BOOST_PP_TUPLE_TO_LIST_15(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14) (e0, (e1, (e2, (e3, (e4, (e5, (e6, (e7, (e8, (e9, (e10, (e11, (e12, (e13, (e14, BOOST_PP_NIL))))))))))))))) +# define BOOST_PP_TUPLE_TO_LIST_16(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15) (e0, (e1, (e2, (e3, (e4, (e5, (e6, (e7, (e8, (e9, (e10, (e11, (e12, (e13, (e14, (e15, BOOST_PP_NIL)))))))))))))))) +# define BOOST_PP_TUPLE_TO_LIST_17(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16) (e0, (e1, (e2, (e3, (e4, (e5, (e6, (e7, (e8, (e9, (e10, (e11, (e12, (e13, (e14, (e15, (e16, BOOST_PP_NIL))))))))))))))))) +# define BOOST_PP_TUPLE_TO_LIST_18(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17) (e0, (e1, (e2, (e3, (e4, (e5, (e6, (e7, (e8, (e9, (e10, (e11, (e12, (e13, (e14, (e15, (e16, (e17, BOOST_PP_NIL)))))))))))))))))) +# define BOOST_PP_TUPLE_TO_LIST_19(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18) (e0, (e1, (e2, (e3, (e4, (e5, (e6, (e7, (e8, (e9, (e10, (e11, (e12, (e13, (e14, (e15, (e16, (e17, (e18, BOOST_PP_NIL))))))))))))))))))) +# define BOOST_PP_TUPLE_TO_LIST_20(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19) (e0, (e1, (e2, (e3, (e4, (e5, (e6, (e7, (e8, (e9, (e10, (e11, (e12, (e13, (e14, (e15, (e16, (e17, (e18, (e19, BOOST_PP_NIL)))))))))))))))))))) +# define BOOST_PP_TUPLE_TO_LIST_21(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20) (e0, (e1, (e2, (e3, (e4, (e5, (e6, (e7, (e8, (e9, (e10, (e11, (e12, (e13, (e14, (e15, (e16, (e17, (e18, (e19, (e20, BOOST_PP_NIL))))))))))))))))))))) +# define BOOST_PP_TUPLE_TO_LIST_22(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21) (e0, (e1, (e2, (e3, (e4, (e5, (e6, (e7, (e8, (e9, (e10, (e11, (e12, (e13, (e14, (e15, (e16, (e17, (e18, (e19, (e20, (e21, BOOST_PP_NIL)))))))))))))))))))))) +# define BOOST_PP_TUPLE_TO_LIST_23(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22) (e0, (e1, (e2, (e3, (e4, (e5, (e6, (e7, (e8, (e9, (e10, (e11, (e12, (e13, (e14, (e15, (e16, (e17, (e18, (e19, (e20, (e21, (e22, BOOST_PP_NIL))))))))))))))))))))))) +# define BOOST_PP_TUPLE_TO_LIST_24(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23) (e0, (e1, (e2, (e3, (e4, (e5, (e6, (e7, (e8, (e9, (e10, (e11, (e12, (e13, (e14, (e15, (e16, (e17, (e18, (e19, (e20, (e21, (e22, (e23, BOOST_PP_NIL)))))))))))))))))))))))) +# define BOOST_PP_TUPLE_TO_LIST_25(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24) (e0, (e1, (e2, (e3, (e4, (e5, (e6, (e7, (e8, (e9, (e10, (e11, (e12, (e13, (e14, (e15, (e16, (e17, (e18, (e19, (e20, (e21, (e22, (e23, (e24, BOOST_PP_NIL))))))))))))))))))))))))) +# define BOOST_PP_TUPLE_TO_LIST_26(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25) (e0, (e1, (e2, (e3, (e4, (e5, (e6, (e7, (e8, (e9, (e10, (e11, (e12, (e13, (e14, (e15, (e16, (e17, (e18, (e19, (e20, (e21, (e22, (e23, (e24, (e25, BOOST_PP_NIL)))))))))))))))))))))))))) +# define BOOST_PP_TUPLE_TO_LIST_27(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26) (e0, (e1, (e2, (e3, (e4, (e5, (e6, (e7, (e8, (e9, (e10, (e11, (e12, (e13, (e14, (e15, (e16, (e17, (e18, (e19, (e20, (e21, (e22, (e23, (e24, (e25, (e26, BOOST_PP_NIL))))))))))))))))))))))))))) +# define BOOST_PP_TUPLE_TO_LIST_28(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27) (e0, (e1, (e2, (e3, (e4, (e5, (e6, (e7, (e8, (e9, (e10, (e11, (e12, (e13, (e14, (e15, (e16, (e17, (e18, (e19, (e20, (e21, (e22, (e23, (e24, (e25, (e26, (e27, BOOST_PP_NIL)))))))))))))))))))))))))))) +# define BOOST_PP_TUPLE_TO_LIST_29(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28) (e0, (e1, (e2, (e3, (e4, (e5, (e6, (e7, (e8, (e9, (e10, (e11, (e12, (e13, (e14, (e15, (e16, (e17, (e18, (e19, (e20, (e21, (e22, (e23, (e24, (e25, (e26, (e27, (e28, BOOST_PP_NIL))))))))))))))))))))))))))))) +# define BOOST_PP_TUPLE_TO_LIST_30(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29) (e0, (e1, (e2, (e3, (e4, (e5, (e6, (e7, (e8, (e9, (e10, (e11, (e12, (e13, (e14, (e15, (e16, (e17, (e18, (e19, (e20, (e21, (e22, (e23, (e24, (e25, (e26, (e27, (e28, (e29, BOOST_PP_NIL)))))))))))))))))))))))))))))) +# define BOOST_PP_TUPLE_TO_LIST_31(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30) (e0, (e1, (e2, (e3, (e4, (e5, (e6, (e7, (e8, (e9, (e10, (e11, (e12, (e13, (e14, (e15, (e16, (e17, (e18, (e19, (e20, (e21, (e22, (e23, (e24, (e25, (e26, (e27, (e28, (e29, (e30, BOOST_PP_NIL))))))))))))))))))))))))))))))) +# define BOOST_PP_TUPLE_TO_LIST_32(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31) (e0, (e1, (e2, (e3, (e4, (e5, (e6, (e7, (e8, (e9, (e10, (e11, (e12, (e13, (e14, (e15, (e16, (e17, (e18, (e19, (e20, (e21, (e22, (e23, (e24, (e25, (e26, (e27, (e28, (e29, (e30, (e31, BOOST_PP_NIL)))))))))))))))))))))))))))))))) +# define BOOST_PP_TUPLE_TO_LIST_33(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32) (e0, (e1, (e2, (e3, (e4, (e5, (e6, (e7, (e8, (e9, (e10, (e11, (e12, (e13, (e14, (e15, (e16, (e17, (e18, (e19, (e20, (e21, (e22, (e23, (e24, (e25, (e26, (e27, (e28, (e29, (e30, (e31, (e32, BOOST_PP_NIL))))))))))))))))))))))))))))))))) +# define BOOST_PP_TUPLE_TO_LIST_34(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33) (e0, (e1, (e2, (e3, (e4, (e5, (e6, (e7, (e8, (e9, (e10, (e11, (e12, (e13, (e14, (e15, (e16, (e17, (e18, (e19, (e20, (e21, (e22, (e23, (e24, (e25, (e26, (e27, (e28, (e29, (e30, (e31, (e32, (e33, BOOST_PP_NIL)))))))))))))))))))))))))))))))))) +# define BOOST_PP_TUPLE_TO_LIST_35(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34) (e0, (e1, (e2, (e3, (e4, (e5, (e6, (e7, (e8, (e9, (e10, (e11, (e12, (e13, (e14, (e15, (e16, (e17, (e18, (e19, (e20, (e21, (e22, (e23, (e24, (e25, (e26, (e27, (e28, (e29, (e30, (e31, (e32, (e33, (e34, BOOST_PP_NIL))))))))))))))))))))))))))))))))))) +# define BOOST_PP_TUPLE_TO_LIST_36(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35) (e0, (e1, (e2, (e3, (e4, (e5, (e6, (e7, (e8, (e9, (e10, (e11, (e12, (e13, (e14, (e15, (e16, (e17, (e18, (e19, (e20, (e21, (e22, (e23, (e24, (e25, (e26, (e27, (e28, (e29, (e30, (e31, (e32, (e33, (e34, (e35, BOOST_PP_NIL)))))))))))))))))))))))))))))))))))) +# define BOOST_PP_TUPLE_TO_LIST_37(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36) (e0, (e1, (e2, (e3, (e4, (e5, (e6, (e7, (e8, (e9, (e10, (e11, (e12, (e13, (e14, (e15, (e16, (e17, (e18, (e19, (e20, (e21, (e22, (e23, (e24, (e25, (e26, (e27, (e28, (e29, (e30, (e31, (e32, (e33, (e34, (e35, (e36, BOOST_PP_NIL))))))))))))))))))))))))))))))))))))) +# define BOOST_PP_TUPLE_TO_LIST_38(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37) (e0, (e1, (e2, (e3, (e4, (e5, (e6, (e7, (e8, (e9, (e10, (e11, (e12, (e13, (e14, (e15, (e16, (e17, (e18, (e19, (e20, (e21, (e22, (e23, (e24, (e25, (e26, (e27, (e28, (e29, (e30, (e31, (e32, (e33, (e34, (e35, (e36, (e37, BOOST_PP_NIL)))))))))))))))))))))))))))))))))))))) +# define BOOST_PP_TUPLE_TO_LIST_39(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38) (e0, (e1, (e2, (e3, (e4, (e5, (e6, (e7, (e8, (e9, (e10, (e11, (e12, (e13, (e14, (e15, (e16, (e17, (e18, (e19, (e20, (e21, (e22, (e23, (e24, (e25, (e26, (e27, (e28, (e29, (e30, (e31, (e32, (e33, (e34, (e35, (e36, (e37, (e38, BOOST_PP_NIL))))))))))))))))))))))))))))))))))))))) +# define BOOST_PP_TUPLE_TO_LIST_40(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39) (e0, (e1, (e2, (e3, (e4, (e5, (e6, (e7, (e8, (e9, (e10, (e11, (e12, (e13, (e14, (e15, (e16, (e17, (e18, (e19, (e20, (e21, (e22, (e23, (e24, (e25, (e26, (e27, (e28, (e29, (e30, (e31, (e32, (e33, (e34, (e35, (e36, (e37, (e38, (e39, BOOST_PP_NIL)))))))))))))))))))))))))))))))))))))))) +# define BOOST_PP_TUPLE_TO_LIST_41(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40) (e0, (e1, (e2, (e3, (e4, (e5, (e6, (e7, (e8, (e9, (e10, (e11, (e12, (e13, (e14, (e15, (e16, (e17, (e18, (e19, (e20, (e21, (e22, (e23, (e24, (e25, (e26, (e27, (e28, (e29, (e30, (e31, (e32, (e33, (e34, (e35, (e36, (e37, (e38, (e39, (e40, BOOST_PP_NIL))))))))))))))))))))))))))))))))))))))))) +# define BOOST_PP_TUPLE_TO_LIST_42(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41) (e0, (e1, (e2, (e3, (e4, (e5, (e6, (e7, (e8, (e9, (e10, (e11, (e12, (e13, (e14, (e15, (e16, (e17, (e18, (e19, (e20, (e21, (e22, (e23, (e24, (e25, (e26, (e27, (e28, (e29, (e30, (e31, (e32, (e33, (e34, (e35, (e36, (e37, (e38, (e39, (e40, (e41, BOOST_PP_NIL)))))))))))))))))))))))))))))))))))))))))) +# define BOOST_PP_TUPLE_TO_LIST_43(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42) (e0, (e1, (e2, (e3, (e4, (e5, (e6, (e7, (e8, (e9, (e10, (e11, (e12, (e13, (e14, (e15, (e16, (e17, (e18, (e19, (e20, (e21, (e22, (e23, (e24, (e25, (e26, (e27, (e28, (e29, (e30, (e31, (e32, (e33, (e34, (e35, (e36, (e37, (e38, (e39, (e40, (e41, (e42, BOOST_PP_NIL))))))))))))))))))))))))))))))))))))))))))) +# define BOOST_PP_TUPLE_TO_LIST_44(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43) (e0, (e1, (e2, (e3, (e4, (e5, (e6, (e7, (e8, (e9, (e10, (e11, (e12, (e13, (e14, (e15, (e16, (e17, (e18, (e19, (e20, (e21, (e22, (e23, (e24, (e25, (e26, (e27, (e28, (e29, (e30, (e31, (e32, (e33, (e34, (e35, (e36, (e37, (e38, (e39, (e40, (e41, (e42, (e43, BOOST_PP_NIL)))))))))))))))))))))))))))))))))))))))))))) +# define BOOST_PP_TUPLE_TO_LIST_45(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44) (e0, (e1, (e2, (e3, (e4, (e5, (e6, (e7, (e8, (e9, (e10, (e11, (e12, (e13, (e14, (e15, (e16, (e17, (e18, (e19, (e20, (e21, (e22, (e23, (e24, (e25, (e26, (e27, (e28, (e29, (e30, (e31, (e32, (e33, (e34, (e35, (e36, (e37, (e38, (e39, (e40, (e41, (e42, (e43, (e44, BOOST_PP_NIL))))))))))))))))))))))))))))))))))))))))))))) +# define BOOST_PP_TUPLE_TO_LIST_46(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45) (e0, (e1, (e2, (e3, (e4, (e5, (e6, (e7, (e8, (e9, (e10, (e11, (e12, (e13, (e14, (e15, (e16, (e17, (e18, (e19, (e20, (e21, (e22, (e23, (e24, (e25, (e26, (e27, (e28, (e29, (e30, (e31, (e32, (e33, (e34, (e35, (e36, (e37, (e38, (e39, (e40, (e41, (e42, (e43, (e44, (e45, BOOST_PP_NIL)))))))))))))))))))))))))))))))))))))))))))))) +# define BOOST_PP_TUPLE_TO_LIST_47(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46) (e0, (e1, (e2, (e3, (e4, (e5, (e6, (e7, (e8, (e9, (e10, (e11, (e12, (e13, (e14, (e15, (e16, (e17, (e18, (e19, (e20, (e21, (e22, (e23, (e24, (e25, (e26, (e27, (e28, (e29, (e30, (e31, (e32, (e33, (e34, (e35, (e36, (e37, (e38, (e39, (e40, (e41, (e42, (e43, (e44, (e45, (e46, BOOST_PP_NIL))))))))))))))))))))))))))))))))))))))))))))))) +# define BOOST_PP_TUPLE_TO_LIST_48(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47) (e0, (e1, (e2, (e3, (e4, (e5, (e6, (e7, (e8, (e9, (e10, (e11, (e12, (e13, (e14, (e15, (e16, (e17, (e18, (e19, (e20, (e21, (e22, (e23, (e24, (e25, (e26, (e27, (e28, (e29, (e30, (e31, (e32, (e33, (e34, (e35, (e36, (e37, (e38, (e39, (e40, (e41, (e42, (e43, (e44, (e45, (e46, (e47, BOOST_PP_NIL)))))))))))))))))))))))))))))))))))))))))))))))) +# define BOOST_PP_TUPLE_TO_LIST_49(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48) (e0, (e1, (e2, (e3, (e4, (e5, (e6, (e7, (e8, (e9, (e10, (e11, (e12, (e13, (e14, (e15, (e16, (e17, (e18, (e19, (e20, (e21, (e22, (e23, (e24, (e25, (e26, (e27, (e28, (e29, (e30, (e31, (e32, (e33, (e34, (e35, (e36, (e37, (e38, (e39, (e40, (e41, (e42, (e43, (e44, (e45, (e46, (e47, (e48, BOOST_PP_NIL))))))))))))))))))))))))))))))))))))))))))))))))) +# define BOOST_PP_TUPLE_TO_LIST_50(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49) (e0, (e1, (e2, (e3, (e4, (e5, (e6, (e7, (e8, (e9, (e10, (e11, (e12, (e13, (e14, (e15, (e16, (e17, (e18, (e19, (e20, (e21, (e22, (e23, (e24, (e25, (e26, (e27, (e28, (e29, (e30, (e31, (e32, (e33, (e34, (e35, (e36, (e37, (e38, (e39, (e40, (e41, (e42, (e43, (e44, (e45, (e46, (e47, (e48, (e49, BOOST_PP_NIL)))))))))))))))))))))))))))))))))))))))))))))))))) +# define BOOST_PP_TUPLE_TO_LIST_51(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50) (e0, (e1, (e2, (e3, (e4, (e5, (e6, (e7, (e8, (e9, (e10, (e11, (e12, (e13, (e14, (e15, (e16, (e17, (e18, (e19, (e20, (e21, (e22, (e23, (e24, (e25, (e26, (e27, (e28, (e29, (e30, (e31, (e32, (e33, (e34, (e35, (e36, (e37, (e38, (e39, (e40, (e41, (e42, (e43, (e44, (e45, (e46, (e47, (e48, (e49, (e50, BOOST_PP_NIL))))))))))))))))))))))))))))))))))))))))))))))))))) +# define BOOST_PP_TUPLE_TO_LIST_52(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51) (e0, (e1, (e2, (e3, (e4, (e5, (e6, (e7, (e8, (e9, (e10, (e11, (e12, (e13, (e14, (e15, (e16, (e17, (e18, (e19, (e20, (e21, (e22, (e23, (e24, (e25, (e26, (e27, (e28, (e29, (e30, (e31, (e32, (e33, (e34, (e35, (e36, (e37, (e38, (e39, (e40, (e41, (e42, (e43, (e44, (e45, (e46, (e47, (e48, (e49, (e50, (e51, BOOST_PP_NIL)))))))))))))))))))))))))))))))))))))))))))))))))))) +# define BOOST_PP_TUPLE_TO_LIST_53(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52) (e0, (e1, (e2, (e3, (e4, (e5, (e6, (e7, (e8, (e9, (e10, (e11, (e12, (e13, (e14, (e15, (e16, (e17, (e18, (e19, (e20, (e21, (e22, (e23, (e24, (e25, (e26, (e27, (e28, (e29, (e30, (e31, (e32, (e33, (e34, (e35, (e36, (e37, (e38, (e39, (e40, (e41, (e42, (e43, (e44, (e45, (e46, (e47, (e48, (e49, (e50, (e51, (e52, BOOST_PP_NIL))))))))))))))))))))))))))))))))))))))))))))))))))))) +# define BOOST_PP_TUPLE_TO_LIST_54(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53) (e0, (e1, (e2, (e3, (e4, (e5, (e6, (e7, (e8, (e9, (e10, (e11, (e12, (e13, (e14, (e15, (e16, (e17, (e18, (e19, (e20, (e21, (e22, (e23, (e24, (e25, (e26, (e27, (e28, (e29, (e30, (e31, (e32, (e33, (e34, (e35, (e36, (e37, (e38, (e39, (e40, (e41, (e42, (e43, (e44, (e45, (e46, (e47, (e48, (e49, (e50, (e51, (e52, (e53, BOOST_PP_NIL)))))))))))))))))))))))))))))))))))))))))))))))))))))) +# define BOOST_PP_TUPLE_TO_LIST_55(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54) (e0, (e1, (e2, (e3, (e4, (e5, (e6, (e7, (e8, (e9, (e10, (e11, (e12, (e13, (e14, (e15, (e16, (e17, (e18, (e19, (e20, (e21, (e22, (e23, (e24, (e25, (e26, (e27, (e28, (e29, (e30, (e31, (e32, (e33, (e34, (e35, (e36, (e37, (e38, (e39, (e40, (e41, (e42, (e43, (e44, (e45, (e46, (e47, (e48, (e49, (e50, (e51, (e52, (e53, (e54, BOOST_PP_NIL))))))))))))))))))))))))))))))))))))))))))))))))))))))) +# define BOOST_PP_TUPLE_TO_LIST_56(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55) (e0, (e1, (e2, (e3, (e4, (e5, (e6, (e7, (e8, (e9, (e10, (e11, (e12, (e13, (e14, (e15, (e16, (e17, (e18, (e19, (e20, (e21, (e22, (e23, (e24, (e25, (e26, (e27, (e28, (e29, (e30, (e31, (e32, (e33, (e34, (e35, (e36, (e37, (e38, (e39, (e40, (e41, (e42, (e43, (e44, (e45, (e46, (e47, (e48, (e49, (e50, (e51, (e52, (e53, (e54, (e55, BOOST_PP_NIL)))))))))))))))))))))))))))))))))))))))))))))))))))))))) +# define BOOST_PP_TUPLE_TO_LIST_57(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56) (e0, (e1, (e2, (e3, (e4, (e5, (e6, (e7, (e8, (e9, (e10, (e11, (e12, (e13, (e14, (e15, (e16, (e17, (e18, (e19, (e20, (e21, (e22, (e23, (e24, (e25, (e26, (e27, (e28, (e29, (e30, (e31, (e32, (e33, (e34, (e35, (e36, (e37, (e38, (e39, (e40, (e41, (e42, (e43, (e44, (e45, (e46, (e47, (e48, (e49, (e50, (e51, (e52, (e53, (e54, (e55, (e56, BOOST_PP_NIL))))))))))))))))))))))))))))))))))))))))))))))))))))))))) +# define BOOST_PP_TUPLE_TO_LIST_58(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57) (e0, (e1, (e2, (e3, (e4, (e5, (e6, (e7, (e8, (e9, (e10, (e11, (e12, (e13, (e14, (e15, (e16, (e17, (e18, (e19, (e20, (e21, (e22, (e23, (e24, (e25, (e26, (e27, (e28, (e29, (e30, (e31, (e32, (e33, (e34, (e35, (e36, (e37, (e38, (e39, (e40, (e41, (e42, (e43, (e44, (e45, (e46, (e47, (e48, (e49, (e50, (e51, (e52, (e53, (e54, (e55, (e56, (e57, BOOST_PP_NIL)))))))))))))))))))))))))))))))))))))))))))))))))))))))))) +# define BOOST_PP_TUPLE_TO_LIST_59(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58) (e0, (e1, (e2, (e3, (e4, (e5, (e6, (e7, (e8, (e9, (e10, (e11, (e12, (e13, (e14, (e15, (e16, (e17, (e18, (e19, (e20, (e21, (e22, (e23, (e24, (e25, (e26, (e27, (e28, (e29, (e30, (e31, (e32, (e33, (e34, (e35, (e36, (e37, (e38, (e39, (e40, (e41, (e42, (e43, (e44, (e45, (e46, (e47, (e48, (e49, (e50, (e51, (e52, (e53, (e54, (e55, (e56, (e57, (e58, BOOST_PP_NIL))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) +# define BOOST_PP_TUPLE_TO_LIST_60(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59) (e0, (e1, (e2, (e3, (e4, (e5, (e6, (e7, (e8, (e9, (e10, (e11, (e12, (e13, (e14, (e15, (e16, (e17, (e18, (e19, (e20, (e21, (e22, (e23, (e24, (e25, (e26, (e27, (e28, (e29, (e30, (e31, (e32, (e33, (e34, (e35, (e36, (e37, (e38, (e39, (e40, (e41, (e42, (e43, (e44, (e45, (e46, (e47, (e48, (e49, (e50, (e51, (e52, (e53, (e54, (e55, (e56, (e57, (e58, (e59, BOOST_PP_NIL)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) +# define BOOST_PP_TUPLE_TO_LIST_61(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60) (e0, (e1, (e2, (e3, (e4, (e5, (e6, (e7, (e8, (e9, (e10, (e11, (e12, (e13, (e14, (e15, (e16, (e17, (e18, (e19, (e20, (e21, (e22, (e23, (e24, (e25, (e26, (e27, (e28, (e29, (e30, (e31, (e32, (e33, (e34, (e35, (e36, (e37, (e38, (e39, (e40, (e41, (e42, (e43, (e44, (e45, (e46, (e47, (e48, (e49, (e50, (e51, (e52, (e53, (e54, (e55, (e56, (e57, (e58, (e59, (e60, BOOST_PP_NIL))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) +# define BOOST_PP_TUPLE_TO_LIST_62(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61) (e0, (e1, (e2, (e3, (e4, (e5, (e6, (e7, (e8, (e9, (e10, (e11, (e12, (e13, (e14, (e15, (e16, (e17, (e18, (e19, (e20, (e21, (e22, (e23, (e24, (e25, (e26, (e27, (e28, (e29, (e30, (e31, (e32, (e33, (e34, (e35, (e36, (e37, (e38, (e39, (e40, (e41, (e42, (e43, (e44, (e45, (e46, (e47, (e48, (e49, (e50, (e51, (e52, (e53, (e54, (e55, (e56, (e57, (e58, (e59, (e60, (e61, BOOST_PP_NIL)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) +# define BOOST_PP_TUPLE_TO_LIST_63(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62) (e0, (e1, (e2, (e3, (e4, (e5, (e6, (e7, (e8, (e9, (e10, (e11, (e12, (e13, (e14, (e15, (e16, (e17, (e18, (e19, (e20, (e21, (e22, (e23, (e24, (e25, (e26, (e27, (e28, (e29, (e30, (e31, (e32, (e33, (e34, (e35, (e36, (e37, (e38, (e39, (e40, (e41, (e42, (e43, (e44, (e45, (e46, (e47, (e48, (e49, (e50, (e51, (e52, (e53, (e54, (e55, (e56, (e57, (e58, (e59, (e60, (e61, (e62, BOOST_PP_NIL))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) +# define BOOST_PP_TUPLE_TO_LIST_64(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) (e0, (e1, (e2, (e3, (e4, (e5, (e6, (e7, (e8, (e9, (e10, (e11, (e12, (e13, (e14, (e15, (e16, (e17, (e18, (e19, (e20, (e21, (e22, (e23, (e24, (e25, (e26, (e27, (e28, (e29, (e30, (e31, (e32, (e33, (e34, (e35, (e36, (e37, (e38, (e39, (e40, (e41, (e42, (e43, (e44, (e45, (e46, (e47, (e48, (e49, (e50, (e51, (e52, (e53, (e54, (e55, (e56, (e57, (e58, (e59, (e60, (e61, (e62, (e63, BOOST_PP_NIL)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) +# +# endif diff --git a/realsense-file/3rd_party/boost/boost/preprocessor/variadic/elem.hpp b/realsense-file/3rd_party/boost/boost/preprocessor/variadic/elem.hpp new file mode 100644 index 0000000000..f604c9bd0d --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/preprocessor/variadic/elem.hpp @@ -0,0 +1,94 @@ +# /* ************************************************************************** +# * * +# * (C) Copyright Edward Diener 2011. * +# * (C) Copyright Paul Mensonides 2011. * +# * Distributed under the Boost Software License, Version 1.0. (See * +# * accompanying file LICENSE_1_0.txt or copy at * +# * http://www.boost.org/LICENSE_1_0.txt) * +# * * +# ************************************************************************** */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_VARIADIC_ELEM_HPP +# define BOOST_PREPROCESSOR_VARIADIC_ELEM_HPP +# +# include +# include +# +# /* BOOST_PP_VARIADIC_ELEM */ +# +# if BOOST_PP_VARIADICS +# if BOOST_PP_VARIADICS_MSVC +# define BOOST_PP_VARIADIC_ELEM(n, ...) BOOST_PP_VARIADIC_ELEM_I(n,__VA_ARGS__) +# define BOOST_PP_VARIADIC_ELEM_I(n, ...) BOOST_PP_CAT(BOOST_PP_CAT(BOOST_PP_VARIADIC_ELEM_, n)(__VA_ARGS__,),) +# else +# define BOOST_PP_VARIADIC_ELEM(n, ...) BOOST_PP_CAT(BOOST_PP_VARIADIC_ELEM_, n)(__VA_ARGS__,) +# endif +# define BOOST_PP_VARIADIC_ELEM_0(e0, ...) e0 +# define BOOST_PP_VARIADIC_ELEM_1(e0, e1, ...) e1 +# define BOOST_PP_VARIADIC_ELEM_2(e0, e1, e2, ...) e2 +# define BOOST_PP_VARIADIC_ELEM_3(e0, e1, e2, e3, ...) e3 +# define BOOST_PP_VARIADIC_ELEM_4(e0, e1, e2, e3, e4, ...) e4 +# define BOOST_PP_VARIADIC_ELEM_5(e0, e1, e2, e3, e4, e5, ...) e5 +# define BOOST_PP_VARIADIC_ELEM_6(e0, e1, e2, e3, e4, e5, e6, ...) e6 +# define BOOST_PP_VARIADIC_ELEM_7(e0, e1, e2, e3, e4, e5, e6, e7, ...) e7 +# define BOOST_PP_VARIADIC_ELEM_8(e0, e1, e2, e3, e4, e5, e6, e7, e8, ...) e8 +# define BOOST_PP_VARIADIC_ELEM_9(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, ...) e9 +# define BOOST_PP_VARIADIC_ELEM_10(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, ...) e10 +# define BOOST_PP_VARIADIC_ELEM_11(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, ...) e11 +# define BOOST_PP_VARIADIC_ELEM_12(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, ...) e12 +# define BOOST_PP_VARIADIC_ELEM_13(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, ...) e13 +# define BOOST_PP_VARIADIC_ELEM_14(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, ...) e14 +# define BOOST_PP_VARIADIC_ELEM_15(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, ...) e15 +# define BOOST_PP_VARIADIC_ELEM_16(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, ...) e16 +# define BOOST_PP_VARIADIC_ELEM_17(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, ...) e17 +# define BOOST_PP_VARIADIC_ELEM_18(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, ...) e18 +# define BOOST_PP_VARIADIC_ELEM_19(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, ...) e19 +# define BOOST_PP_VARIADIC_ELEM_20(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, ...) e20 +# define BOOST_PP_VARIADIC_ELEM_21(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, ...) e21 +# define BOOST_PP_VARIADIC_ELEM_22(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, ...) e22 +# define BOOST_PP_VARIADIC_ELEM_23(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, ...) e23 +# define BOOST_PP_VARIADIC_ELEM_24(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, ...) e24 +# define BOOST_PP_VARIADIC_ELEM_25(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, ...) e25 +# define BOOST_PP_VARIADIC_ELEM_26(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, ...) e26 +# define BOOST_PP_VARIADIC_ELEM_27(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, ...) e27 +# define BOOST_PP_VARIADIC_ELEM_28(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, ...) e28 +# define BOOST_PP_VARIADIC_ELEM_29(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, ...) e29 +# define BOOST_PP_VARIADIC_ELEM_30(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, ...) e30 +# define BOOST_PP_VARIADIC_ELEM_31(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, ...) e31 +# define BOOST_PP_VARIADIC_ELEM_32(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, ...) e32 +# define BOOST_PP_VARIADIC_ELEM_33(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, ...) e33 +# define BOOST_PP_VARIADIC_ELEM_34(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, ...) e34 +# define BOOST_PP_VARIADIC_ELEM_35(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, ...) e35 +# define BOOST_PP_VARIADIC_ELEM_36(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, ...) e36 +# define BOOST_PP_VARIADIC_ELEM_37(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, ...) e37 +# define BOOST_PP_VARIADIC_ELEM_38(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, ...) e38 +# define BOOST_PP_VARIADIC_ELEM_39(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, ...) e39 +# define BOOST_PP_VARIADIC_ELEM_40(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, ...) e40 +# define BOOST_PP_VARIADIC_ELEM_41(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, ...) e41 +# define BOOST_PP_VARIADIC_ELEM_42(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, ...) e42 +# define BOOST_PP_VARIADIC_ELEM_43(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, ...) e43 +# define BOOST_PP_VARIADIC_ELEM_44(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, ...) e44 +# define BOOST_PP_VARIADIC_ELEM_45(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, ...) e45 +# define BOOST_PP_VARIADIC_ELEM_46(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, ...) e46 +# define BOOST_PP_VARIADIC_ELEM_47(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, ...) e47 +# define BOOST_PP_VARIADIC_ELEM_48(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, ...) e48 +# define BOOST_PP_VARIADIC_ELEM_49(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, ...) e49 +# define BOOST_PP_VARIADIC_ELEM_50(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, ...) e50 +# define BOOST_PP_VARIADIC_ELEM_51(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, ...) e51 +# define BOOST_PP_VARIADIC_ELEM_52(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, ...) e52 +# define BOOST_PP_VARIADIC_ELEM_53(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, ...) e53 +# define BOOST_PP_VARIADIC_ELEM_54(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, ...) e54 +# define BOOST_PP_VARIADIC_ELEM_55(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, ...) e55 +# define BOOST_PP_VARIADIC_ELEM_56(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, ...) e56 +# define BOOST_PP_VARIADIC_ELEM_57(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, ...) e57 +# define BOOST_PP_VARIADIC_ELEM_58(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, ...) e58 +# define BOOST_PP_VARIADIC_ELEM_59(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, ...) e59 +# define BOOST_PP_VARIADIC_ELEM_60(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, ...) e60 +# define BOOST_PP_VARIADIC_ELEM_61(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, ...) e61 +# define BOOST_PP_VARIADIC_ELEM_62(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, ...) e62 +# define BOOST_PP_VARIADIC_ELEM_63(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63, ...) e63 +# endif +# +# endif diff --git a/realsense-file/3rd_party/boost/boost/preprocessor/variadic/size.hpp b/realsense-file/3rd_party/boost/boost/preprocessor/variadic/size.hpp new file mode 100644 index 0000000000..f12f1fd67e --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/preprocessor/variadic/size.hpp @@ -0,0 +1,30 @@ +# /* ************************************************************************** +# * * +# * (C) Copyright Edward Diener 2011. * +# * (C) Copyright Paul Mensonides 2011. * +# * Distributed under the Boost Software License, Version 1.0. (See * +# * accompanying file LICENSE_1_0.txt or copy at * +# * http://www.boost.org/LICENSE_1_0.txt) * +# * * +# ************************************************************************** */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_VARIADIC_SIZE_HPP +# define BOOST_PREPROCESSOR_VARIADIC_SIZE_HPP +# +# include +# include +# +# /* BOOST_PP_VARIADIC_SIZE */ +# +# if BOOST_PP_VARIADICS +# if BOOST_PP_VARIADICS_MSVC +# define BOOST_PP_VARIADIC_SIZE(...) BOOST_PP_CAT(BOOST_PP_VARIADIC_SIZE_I(__VA_ARGS__, 64, 63, 62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 52, 51, 50, 49, 48, 47, 46, 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1,),) +# else +# define BOOST_PP_VARIADIC_SIZE(...) BOOST_PP_VARIADIC_SIZE_I(__VA_ARGS__, 64, 63, 62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 52, 51, 50, 49, 48, 47, 46, 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1,) +# endif +# define BOOST_PP_VARIADIC_SIZE_I(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63, size, ...) size +# endif +# +# endif diff --git a/realsense-file/3rd_party/boost/boost/range/begin.hpp b/realsense-file/3rd_party/boost/boost/range/begin.hpp new file mode 100644 index 0000000000..2073ed61cd --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/range/begin.hpp @@ -0,0 +1,135 @@ +// Boost.Range library +// +// Copyright Thorsten Ottosen 2003-2004. Use, modification and +// distribution is subject to 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) +// +// For more information, see http://www.boost.org/libs/range/ +// + +#ifndef BOOST_RANGE_BEGIN_HPP +#define BOOST_RANGE_BEGIN_HPP + +#if defined(_MSC_VER) +# pragma once +#endif + +#include + +#ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING +#include +#else + +#include + +namespace boost +{ + +#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) +namespace range_detail +{ +#endif + + ////////////////////////////////////////////////////////////////////// + // primary template + ////////////////////////////////////////////////////////////////////// + + template< typename C > + inline BOOST_DEDUCED_TYPENAME range_iterator::type + range_begin( C& c ) + { + // + // If you get a compile-error here, it is most likely because + // you have not implemented range_begin() properly in + // the namespace of C + // + return c.begin(); + } + + ////////////////////////////////////////////////////////////////////// + // pair + ////////////////////////////////////////////////////////////////////// + + template< typename Iterator > + inline Iterator range_begin( const std::pair& p ) + { + return p.first; + } + + template< typename Iterator > + inline Iterator range_begin( std::pair& p ) + { + return p.first; + } + + ////////////////////////////////////////////////////////////////////// + // array + ////////////////////////////////////////////////////////////////////// + + // + // May this be discarded? Or is it needed for bad compilers? + // + template< typename T, std::size_t sz > + inline const T* range_begin( const T (&a)[sz] ) + { + return a; + } + + template< typename T, std::size_t sz > + inline T* range_begin( T (&a)[sz] ) + { + return a; + } + + +#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) +} // namespace 'range_detail' +#endif + +// Use a ADL namespace barrier to avoid ambiguity with other unqualified +// calls. This is particularly important with C++0x encouraging +// unqualified calls to begin/end. +namespace range_adl_barrier +{ + +template< class T > +inline BOOST_DEDUCED_TYPENAME range_iterator::type begin( T& r ) +{ +#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) + using namespace range_detail; +#endif + return range_begin( r ); +} + +template< class T > +inline BOOST_DEDUCED_TYPENAME range_iterator::type begin( const T& r ) +{ +#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) + using namespace range_detail; +#endif + return range_begin( r ); +} + + } // namespace range_adl_barrier +} // namespace boost + +#endif // BOOST_NO_FUNCTION_TEMPLATE_ORDERING + +namespace boost +{ + namespace range_adl_barrier + { + template< class T > + inline BOOST_DEDUCED_TYPENAME range_iterator::type + const_begin( const T& r ) + { + return boost::range_adl_barrier::begin( r ); + } + } // namespace range_adl_barrier + + using namespace range_adl_barrier; +} // namespace boost + +#endif + diff --git a/realsense-file/3rd_party/boost/boost/range/config.hpp b/realsense-file/3rd_party/boost/boost/range/config.hpp new file mode 100644 index 0000000000..c2403654b8 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/range/config.hpp @@ -0,0 +1,56 @@ +// Boost.Range library +// +// Copyright Thorsten Ottosen 2003-2004. Use, modification and +// distribution is subject to 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) +// +// For more information, see http://www.boost.org/libs/range/ +// + +#ifndef BOOST_RANGE_CONFIG_HPP +#define BOOST_RANGE_CONFIG_HPP + +#include + +#if defined(_MSC_VER) +# pragma once +#endif + +#include + +#ifdef BOOST_RANGE_DEDUCED_TYPENAME +#error "macro already defined!" +#endif + +#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) +# define BOOST_RANGE_DEDUCED_TYPENAME typename +#else +#define BOOST_RANGE_DEDUCED_TYPENAME BOOST_DEDUCED_TYPENAME +#endif + +#ifdef BOOST_RANGE_NO_ARRAY_SUPPORT +#error "macro already defined!" +#endif + +#if BOOST_WORKAROUND( __MWERKS__, <= 0x3003 ) +#define BOOST_RANGE_NO_ARRAY_SUPPORT 1 +#endif + +#ifdef BOOST_RANGE_NO_ARRAY_SUPPORT +#define BOOST_RANGE_ARRAY_REF() (boost_range_array) +#define BOOST_RANGE_NO_STATIC_ASSERT +#else +#define BOOST_RANGE_ARRAY_REF() (&boost_range_array) +#endif + +#if defined(__GNUC__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7))) +# define BOOST_RANGE_UNUSED __attribute__((unused)) +#else +# define BOOST_RANGE_UNUSED +#endif + + + +#endif + diff --git a/realsense-file/3rd_party/boost/boost/range/const_iterator.hpp b/realsense-file/3rd_party/boost/boost/range/const_iterator.hpp new file mode 100644 index 0000000000..b0e90d1a7f --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/range/const_iterator.hpp @@ -0,0 +1,76 @@ +// Boost.Range library +// +// Copyright Thorsten Ottosen 2003-2004. Use, modification and +// distribution is subject to 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) +// +// For more information, see http://www.boost.org/libs/range/ +// + +#ifndef BOOST_RANGE_CONST_ITERATOR_HPP +#define BOOST_RANGE_CONST_ITERATOR_HPP + +#if defined(_MSC_VER) +# pragma once +#endif + +#include + +#include +#include +#include +#include +#include +#include + +namespace boost +{ + ////////////////////////////////////////////////////////////////////////// + // default + ////////////////////////////////////////////////////////////////////////// + + namespace range_detail + { + +BOOST_RANGE_EXTRACT_OPTIONAL_TYPE( const_iterator ) + +template< typename C > +struct range_const_iterator + : extract_const_iterator +{}; + +////////////////////////////////////////////////////////////////////////// +// pair +////////////////////////////////////////////////////////////////////////// + +template< typename Iterator > +struct range_const_iterator > +{ + typedef Iterator type; +}; + +////////////////////////////////////////////////////////////////////////// +// array +////////////////////////////////////////////////////////////////////////// + +template< typename T, std::size_t sz > +struct range_const_iterator< T[sz] > +{ + typedef const T* type; +}; + + } // namespace range_detail + +template +struct range_const_iterator + : range_detail::range_const_iterator< + BOOST_DEDUCED_TYPENAME remove_reference::type + > +{ +}; + +} // namespace boost + + +#endif diff --git a/realsense-file/3rd_party/boost/boost/range/detail/common.hpp b/realsense-file/3rd_party/boost/boost/range/detail/common.hpp new file mode 100644 index 0000000000..f2a7e0ebcd --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/range/detail/common.hpp @@ -0,0 +1,117 @@ +// Boost.Range library +// +// Copyright Thorsten Ottosen 2003-2004. Use, modification and +// distribution is subject to 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) +// +// For more information, see http://www.boost.org/libs/range/ +// + +#ifndef BOOST_RANGE_DETAIL_COMMON_HPP +#define BOOST_RANGE_DETAIL_COMMON_HPP + +#if defined(_MSC_VER) +# pragma once +#endif + +#include +#include +#include +#include +#include +#include +#include + +////////////////////////////////////////////////////////////////////////////// +// missing partial specialization workaround. +////////////////////////////////////////////////////////////////////////////// + +namespace boost +{ + namespace range_detail + { + // 1 = std containers + // 2 = std::pair + // 3 = const std::pair + // 4 = array + // 5 = const array + // 6 = char array + // 7 = wchar_t array + // 8 = char* + // 9 = const char* + // 10 = whar_t* + // 11 = const wchar_t* + // 12 = string + + typedef mpl::int_<1>::type std_container_; + typedef mpl::int_<2>::type std_pair_; + typedef mpl::int_<3>::type const_std_pair_; + typedef mpl::int_<4>::type array_; + typedef mpl::int_<5>::type const_array_; + typedef mpl::int_<6>::type char_array_; + typedef mpl::int_<7>::type wchar_t_array_; + typedef mpl::int_<8>::type char_ptr_; + typedef mpl::int_<9>::type const_char_ptr_; + typedef mpl::int_<10>::type wchar_t_ptr_; + typedef mpl::int_<11>::type const_wchar_t_ptr_; + typedef mpl::int_<12>::type string_; + + template< typename C > + struct range_helper + { + static C* c; + static C ptr; + + BOOST_STATIC_CONSTANT( bool, is_pair_ = sizeof( boost::range_detail::is_pair_impl( c ) ) == sizeof( yes_type ) ); + BOOST_STATIC_CONSTANT( bool, is_char_ptr_ = sizeof( boost::range_detail::is_char_ptr_impl( ptr ) ) == sizeof( yes_type ) ); + BOOST_STATIC_CONSTANT( bool, is_const_char_ptr_ = sizeof( boost::range_detail::is_const_char_ptr_impl( ptr ) ) == sizeof( yes_type ) ); + BOOST_STATIC_CONSTANT( bool, is_wchar_t_ptr_ = sizeof( boost::range_detail::is_wchar_t_ptr_impl( ptr ) ) == sizeof( yes_type ) ); + BOOST_STATIC_CONSTANT( bool, is_const_wchar_t_ptr_ = sizeof( boost::range_detail::is_const_wchar_t_ptr_impl( ptr ) ) == sizeof( yes_type ) ); + BOOST_STATIC_CONSTANT( bool, is_char_array_ = sizeof( boost::range_detail::is_char_array_impl( ptr ) ) == sizeof( yes_type ) ); + BOOST_STATIC_CONSTANT( bool, is_wchar_t_array_ = sizeof( boost::range_detail::is_wchar_t_array_impl( ptr ) ) == sizeof( yes_type ) ); + BOOST_STATIC_CONSTANT( bool, is_string_ = (boost::type_traits::ice_or::value )); + BOOST_STATIC_CONSTANT( bool, is_array_ = boost::is_array::value ); + + }; + + template< typename C > + class range + { + typedef BOOST_RANGE_DEDUCED_TYPENAME boost::mpl::if_c< ::boost::range_detail::range_helper::is_pair_, + boost::range_detail::std_pair_, + void >::type pair_t; + typedef BOOST_RANGE_DEDUCED_TYPENAME boost::mpl::if_c< ::boost::range_detail::range_helper::is_array_, + boost::range_detail::array_, + pair_t >::type array_t; + typedef BOOST_RANGE_DEDUCED_TYPENAME boost::mpl::if_c< ::boost::range_detail::range_helper::is_string_, + boost::range_detail::string_, + array_t >::type string_t; + typedef BOOST_RANGE_DEDUCED_TYPENAME boost::mpl::if_c< ::boost::range_detail::range_helper::is_const_char_ptr_, + boost::range_detail::const_char_ptr_, + string_t >::type const_char_ptr_t; + typedef BOOST_RANGE_DEDUCED_TYPENAME boost::mpl::if_c< ::boost::range_detail::range_helper::is_char_ptr_, + boost::range_detail::char_ptr_, + const_char_ptr_t >::type char_ptr_t; + typedef BOOST_RANGE_DEDUCED_TYPENAME boost::mpl::if_c< ::boost::range_detail::range_helper::is_const_wchar_t_ptr_, + boost::range_detail::const_wchar_t_ptr_, + char_ptr_t >::type const_wchar_ptr_t; + typedef BOOST_RANGE_DEDUCED_TYPENAME boost::mpl::if_c< ::boost::range_detail::range_helper::is_wchar_t_ptr_, + boost::range_detail::wchar_t_ptr_, + const_wchar_ptr_t >::type wchar_ptr_t; + typedef BOOST_RANGE_DEDUCED_TYPENAME boost::mpl::if_c< ::boost::range_detail::range_helper::is_wchar_t_array_, + boost::range_detail::wchar_t_array_, + wchar_ptr_t >::type wchar_array_t; + typedef BOOST_RANGE_DEDUCED_TYPENAME boost::mpl::if_c< ::boost::range_detail::range_helper::is_char_array_, + boost::range_detail::char_array_, + wchar_array_t >::type char_array_t; + public: + typedef BOOST_RANGE_DEDUCED_TYPENAME boost::mpl::if_c< ::boost::is_void::value, + boost::range_detail::std_container_, + char_array_t >::type type; + }; // class 'range' + } +} + +#endif + diff --git a/realsense-file/3rd_party/boost/boost/range/detail/extract_optional_type.hpp b/realsense-file/3rd_party/boost/boost/range/detail/extract_optional_type.hpp new file mode 100644 index 0000000000..5142a31496 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/range/detail/extract_optional_type.hpp @@ -0,0 +1,48 @@ +// Boost.Range library +// +// Copyright Arno Schoedl & Neil Groves 2009. +// Use, modification and distribution is subject to 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) +// +// For more information, see http://www.boost.org/libs/range/ +// +#ifndef BOOST_RANGE_DETAIL_EXTRACT_OPTIONAL_TYPE_HPP_INCLUDED +#define BOOST_RANGE_DETAIL_EXTRACT_OPTIONAL_TYPE_HPP_INCLUDED + +#if defined(_MSC_VER) +# pragma once +#endif + +#include +#include +#include + +#if !defined(BOOST_MPL_CFG_NO_HAS_XXX) + +// Defines extract_some_typedef which exposes T::some_typedef as +// extract_some_typedef::type if T::some_typedef exists. Otherwise +// extract_some_typedef is empty. +#define BOOST_RANGE_EXTRACT_OPTIONAL_TYPE( a_typedef ) \ + BOOST_MPL_HAS_XXX_TRAIT_DEF(a_typedef) \ + template< typename C, bool B = BOOST_PP_CAT(has_, a_typedef)::value > \ + struct BOOST_PP_CAT(extract_, a_typedef) \ + {}; \ + template< typename C > \ + struct BOOST_PP_CAT(extract_, a_typedef)< C, true > \ + { \ + typedef BOOST_DEDUCED_TYPENAME C::a_typedef type; \ + }; + +#else + +#define BOOST_RANGE_EXTRACT_OPTIONAL_TYPE( a_typedef ) \ + template< typename C > \ + struct BOOST_PP_CAT(extract_, a_typedef) \ + { \ + typedef BOOST_DEDUCED_TYPENAME C::a_typedef type; \ + }; + +#endif + +#endif // include guard diff --git a/realsense-file/3rd_party/boost/boost/range/detail/implementation_help.hpp b/realsense-file/3rd_party/boost/boost/range/detail/implementation_help.hpp new file mode 100644 index 0000000000..48de625bbc --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/range/detail/implementation_help.hpp @@ -0,0 +1,114 @@ +// Boost.Range library +// +// Copyright Thorsten Ottosen 2003-2004. Use, modification and +// distribution is subject to 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) +// +// For more information, see http://www.boost.org/libs/range/ +// + +#ifndef BOOST_RANGE_DETAIL_IMPLEMENTATION_HELP_HPP +#define BOOST_RANGE_DETAIL_IMPLEMENTATION_HELP_HPP + +#include +#include +#include +#include +#include + +#ifndef BOOST_NO_CWCHAR +#include +#endif + +namespace boost +{ + namespace range_detail + { + template + inline void boost_range_silence_warning( const T& ) { } + + ///////////////////////////////////////////////////////////////////// + // end() help + ///////////////////////////////////////////////////////////////////// + + inline const char* str_end( const char* s, const char* ) + { + return s + strlen( s ); + } + +#ifndef BOOST_NO_CWCHAR + inline const wchar_t* str_end( const wchar_t* s, const wchar_t* ) + { + return s + wcslen( s ); + } +#else + inline const wchar_t* str_end( const wchar_t* s, const wchar_t* ) + { + if( s == 0 || s[0] == 0 ) + return s; + while( *++s != 0 ) + ; + return s; + } +#endif + + template< class Char > + inline Char* str_end( Char* s ) + { + return const_cast( str_end( s, s ) ); + } + + template< class T, std::size_t sz > + inline T* array_end( T BOOST_RANGE_ARRAY_REF()[sz] ) + { + return boost_range_array + sz; + } + + template< class T, std::size_t sz > + inline const T* array_end( const T BOOST_RANGE_ARRAY_REF()[sz] ) + { + return boost_range_array + sz; + } + + ///////////////////////////////////////////////////////////////////// + // size() help + ///////////////////////////////////////////////////////////////////// + + template< class Char > + inline std::size_t str_size( const Char* const& s ) + { + return str_end( s ) - s; + } + + template< class T, std::size_t sz > + inline std::size_t array_size( T BOOST_RANGE_ARRAY_REF()[sz] ) + { + boost_range_silence_warning( boost_range_array ); + return sz; + } + + template< class T, std::size_t sz > + inline std::size_t array_size( const T BOOST_RANGE_ARRAY_REF()[sz] ) + { + boost_range_silence_warning( boost_range_array ); + return sz; + } + + inline bool is_same_address(const void* l, const void* r) + { + return l == r; + } + + template + inline bool is_same_object(const T1& l, const T2& r) + { + return range_detail::is_same_address(&l, &r); + } + + } // namespace 'range_detail' + +} // namespace 'boost' + + +#endif diff --git a/realsense-file/3rd_party/boost/boost/range/detail/msvc_has_iterator_workaround.hpp b/realsense-file/3rd_party/boost/boost/range/detail/msvc_has_iterator_workaround.hpp new file mode 100644 index 0000000000..75ba4a359d --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/range/detail/msvc_has_iterator_workaround.hpp @@ -0,0 +1,132 @@ +// Boost.Range library +// +// Copyright Eric Niebler 2014. Use, modification and +// distribution is subject to 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) +// +// For more information, see http://www.boost.org/libs/range/ +// + +#ifndef BOOST_RANGE_DETAIL_MSVC_HAS_ITERATOR_WORKAROUND_HPP +#define BOOST_RANGE_DETAIL_MSVC_HAS_ITERATOR_WORKAROUND_HPP + +#if defined(_MSC_VER) +# pragma once +#endif + +#ifndef BOOST_RANGE_MUTABLE_ITERATOR_HPP +# error This file should only be included from +#endif + +#if BOOST_WORKAROUND(BOOST_MSVC, <= 1600) +namespace boost +{ +namespace cb_details +{ + template + struct iterator; +} + +namespace python +{ + template + struct iterator; +} + +namespace type_erasure +{ + template< + class Traversal, + class T /*= _self*/, + class Reference /*= ::boost::use_default*/, + class DifferenceType /*= ::std::ptrdiff_t*/, + class ValueType /*= typename deduced >::type*/ + > + struct iterator; +} + +namespace unordered { namespace iterator_detail +{ + template + struct iterator; +}} + +namespace container { namespace container_detail +{ + template + class iterator; +}} + +namespace spirit { namespace lex { namespace lexertl +{ + template + class iterator; +}}} + +namespace range_detail +{ + template + struct has_iterator< ::boost::cb_details::iterator > + : mpl::false_ + {}; + + template + struct has_iterator< ::boost::cb_details::iterator const> + : mpl::false_ + {}; + + template + struct has_iterator< ::boost::python::iterator > + : mpl::false_ + {}; + + template + struct has_iterator< ::boost::python::iterator const> + : mpl::false_ + {}; + + template + struct has_iterator< ::boost::type_erasure::iterator > + : mpl::false_ + {}; + + template + struct has_iterator< ::boost::type_erasure::iterator const> + : mpl::false_ + {}; + + template + struct has_iterator< ::boost::unordered::iterator_detail::iterator > + : mpl::false_ + {}; + + template + struct has_iterator< ::boost::unordered::iterator_detail::iterator const> + : mpl::false_ + {}; + + template + struct has_iterator< ::boost::container::container_detail::iterator > + : mpl::false_ + {}; + + template + struct has_iterator< ::boost::container::container_detail::iterator const> + : mpl::false_ + {}; + + template + struct has_iterator< ::boost::spirit::lex::lexertl::iterator > + : mpl::false_ + {}; + + template + struct has_iterator< ::boost::spirit::lex::lexertl::iterator const> + : mpl::false_ + {}; +} +} +#endif +#endif diff --git a/realsense-file/3rd_party/boost/boost/range/detail/sfinae.hpp b/realsense-file/3rd_party/boost/boost/range/detail/sfinae.hpp new file mode 100644 index 0000000000..28937e7e61 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/range/detail/sfinae.hpp @@ -0,0 +1,77 @@ +// Boost.Range library +// +// Copyright Thorsten Ottosen 2003-2004. Use, modification and +// distribution is subject to 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) +// +// For more information, see http://www.boost.org/libs/range/ +// + +#ifndef BOOST_RANGE_DETAIL_SFINAE_HPP +#define BOOST_RANGE_DETAIL_SFINAE_HPP + +#include +#include +#include +#include + + +namespace boost +{ + namespace range_detail + { + using type_traits::yes_type; + using type_traits::no_type; + + ////////////////////////////////////////////////////////////////////// + // string + ////////////////////////////////////////////////////////////////////// + + yes_type is_string_impl( const char* const ); + yes_type is_string_impl( const wchar_t* const ); + no_type is_string_impl( ... ); + + template< std::size_t sz > + yes_type is_char_array_impl( char BOOST_RANGE_ARRAY_REF()[sz] ); + template< std::size_t sz > + yes_type is_char_array_impl( const char BOOST_RANGE_ARRAY_REF()[sz] ); + no_type is_char_array_impl( ... ); + + template< std::size_t sz > + yes_type is_wchar_t_array_impl( wchar_t BOOST_RANGE_ARRAY_REF()[sz] ); + template< std::size_t sz > + yes_type is_wchar_t_array_impl( const wchar_t BOOST_RANGE_ARRAY_REF()[sz] ); + no_type is_wchar_t_array_impl( ... ); + + yes_type is_char_ptr_impl( char* const ); + no_type is_char_ptr_impl( ... ); + + yes_type is_const_char_ptr_impl( const char* const ); + no_type is_const_char_ptr_impl( ... ); + + yes_type is_wchar_t_ptr_impl( wchar_t* const ); + no_type is_wchar_t_ptr_impl( ... ); + + yes_type is_const_wchar_t_ptr_impl( const wchar_t* const ); + no_type is_const_wchar_t_ptr_impl( ... ); + + ////////////////////////////////////////////////////////////////////// + // pair + ////////////////////////////////////////////////////////////////////// + + template< typename Iterator > + yes_type is_pair_impl( const std::pair* ); + no_type is_pair_impl( ... ); + + ////////////////////////////////////////////////////////////////////// + // tags + ////////////////////////////////////////////////////////////////////// + + struct char_or_wchar_t_array_tag {}; + + } // namespace 'range_detail' + +} // namespace 'boost' + +#endif diff --git a/realsense-file/3rd_party/boost/boost/range/end.hpp b/realsense-file/3rd_party/boost/boost/range/end.hpp new file mode 100644 index 0000000000..89a338f81f --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/range/end.hpp @@ -0,0 +1,128 @@ +// Boost.Range library +// +// Copyright Thorsten Ottosen 2003-2004. Use, modification and +// distribution is subject to 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) +// +// For more information, see http://www.boost.org/libs/range/ +// + +#ifndef BOOST_RANGE_END_HPP +#define BOOST_RANGE_END_HPP + +#if defined(_MSC_VER) +# pragma once +#endif + +#include + +#ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING +#include +#else + +#include +#include +#include + +namespace boost +{ + +#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) +namespace range_detail +{ +#endif + + ////////////////////////////////////////////////////////////////////// + // primary template + ////////////////////////////////////////////////////////////////////// + template< typename C > + inline BOOST_DEDUCED_TYPENAME range_iterator::type + range_end( C& c ) + { + // + // If you get a compile-error here, it is most likely because + // you have not implemented range_begin() properly in + // the namespace of C + // + return c.end(); + } + + ////////////////////////////////////////////////////////////////////// + // pair + ////////////////////////////////////////////////////////////////////// + + template< typename Iterator > + inline Iterator range_end( const std::pair& p ) + { + return p.second; + } + + template< typename Iterator > + inline Iterator range_end( std::pair& p ) + { + return p.second; + } + + ////////////////////////////////////////////////////////////////////// + // array + ////////////////////////////////////////////////////////////////////// + + template< typename T, std::size_t sz > + inline const T* range_end( const T (&a)[sz] ) + { + return range_detail::array_end( a ); + } + + template< typename T, std::size_t sz > + inline T* range_end( T (&a)[sz] ) + { + return range_detail::array_end( a ); + } + +#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) +} // namespace 'range_detail' +#endif + +namespace range_adl_barrier +{ + +template< class T > +inline BOOST_DEDUCED_TYPENAME range_iterator::type end( T& r ) +{ +#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) + using namespace range_detail; +#endif + return range_end( r ); +} + +template< class T > +inline BOOST_DEDUCED_TYPENAME range_iterator::type end( const T& r ) +{ +#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) + using namespace range_detail; +#endif + return range_end( r ); +} + + } // namespace range_adl_barrier +} // namespace 'boost' + +#endif // BOOST_NO_FUNCTION_TEMPLATE_ORDERING + +namespace boost +{ + namespace range_adl_barrier + { + template< class T > + inline BOOST_DEDUCED_TYPENAME range_iterator::type + const_end( const T& r ) + { + return boost::range_adl_barrier::end( r ); + } + } // namespace range_adl_barrier + using namespace range_adl_barrier; +} // namespace boost + +#endif + diff --git a/realsense-file/3rd_party/boost/boost/range/iterator.hpp b/realsense-file/3rd_party/boost/boost/range/iterator.hpp new file mode 100644 index 0000000000..5b36014d0e --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/range/iterator.hpp @@ -0,0 +1,76 @@ +// Boost.Range library +// +// Copyright Thorsten Ottosen 2003-2004. Use, modification and +// distribution is subject to 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) +// +// For more information, see http://www.boost.org/libs/range/ +// + +#ifndef BOOST_RANGE_ITERATOR_HPP +#define BOOST_RANGE_ITERATOR_HPP + +#if defined(_MSC_VER) +# pragma once +#endif + +#include +#include +#include +#include +#include +#include +#include + +namespace boost +{ + +#if BOOST_WORKAROUND(BOOST_MSVC, == 1310) + + namespace range_detail_vc7_1 + { + template< typename C, typename Sig = void(C) > + struct range_iterator + { + typedef BOOST_RANGE_DEDUCED_TYPENAME + mpl::eval_if_c< is_const::value, + range_const_iterator< typename remove_const::type >, + range_mutable_iterator >::type type; + }; + + template< typename C, typename T > + struct range_iterator< C, void(T[]) > + { + typedef T* type; + }; + } + +#endif + + template< typename C, typename Enabler=void > + struct range_iterator + { +#if BOOST_WORKAROUND(BOOST_MSVC, == 1310) + + typedef BOOST_RANGE_DEDUCED_TYPENAME + range_detail_vc7_1::range_iterator::type type; + +#else + + private: + typedef typename remove_reference::type param_t; + + public: + typedef typename mpl::eval_if_c< + is_const::value, + range_const_iterator::type>, + range_mutable_iterator + >::type type; + +#endif + }; + +} // namespace boost + +#endif diff --git a/realsense-file/3rd_party/boost/boost/range/mutable_iterator.hpp b/realsense-file/3rd_party/boost/boost/range/mutable_iterator.hpp new file mode 100644 index 0000000000..71a9ad76b7 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/range/mutable_iterator.hpp @@ -0,0 +1,79 @@ +// Boost.Range library +// +// Copyright Thorsten Ottosen 2003-2004. Use, modification and +// distribution is subject to 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) +// +// For more information, see http://www.boost.org/libs/range/ +// + +#ifndef BOOST_RANGE_MUTABLE_ITERATOR_HPP +#define BOOST_RANGE_MUTABLE_ITERATOR_HPP + +#if defined(_MSC_VER) +# pragma once +#endif + +#include + +#include +#include +#include +#include +#include +#include + +namespace boost +{ + + ////////////////////////////////////////////////////////////////////////// + // default + ////////////////////////////////////////////////////////////////////////// + + namespace range_detail + { + +BOOST_RANGE_EXTRACT_OPTIONAL_TYPE( iterator ) + +template< typename C > +struct range_mutable_iterator + : range_detail::extract_iterator< + BOOST_DEDUCED_TYPENAME remove_reference::type> +{}; + +////////////////////////////////////////////////////////////////////////// +// pair +////////////////////////////////////////////////////////////////////////// + +template< typename Iterator > +struct range_mutable_iterator< std::pair > +{ + typedef Iterator type; +}; + +////////////////////////////////////////////////////////////////////////// +// array +////////////////////////////////////////////////////////////////////////// + +template< typename T, std::size_t sz > +struct range_mutable_iterator< T[sz] > +{ + typedef T* type; +}; + + } // namespace range_detail + +template +struct range_mutable_iterator + : range_detail::range_mutable_iterator< + BOOST_DEDUCED_TYPENAME remove_reference::type + > +{ +}; + +} // namespace boost + +#include + +#endif diff --git a/realsense-file/3rd_party/boost/boost/range/range_fwd.hpp b/realsense-file/3rd_party/boost/boost/range/range_fwd.hpp new file mode 100644 index 0000000000..683efb6c3e --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/range/range_fwd.hpp @@ -0,0 +1,63 @@ +// Boost.Range library +// +// Copyright Neil Groves 2003-2004. +// Use, modification and distribution is subject to 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) +// +// For more information, see http://www.boost.org/libs/range/ +// +#ifndef BOOST_RANGE_RANGE_FWD_HPP_INCLUDED +#define BOOST_RANGE_RANGE_FWD_HPP_INCLUDED + +namespace boost +{ + +// Extension points + template + struct range_iterator; + + template + struct range_mutable_iterator; + + template + struct range_const_iterator; + +// Core classes + template + class iterator_range; + + template + class sub_range; + +// Meta-functions + template + struct range_category; + + template + struct range_difference; + + template + struct range_pointer; + + template + struct range_reference; + + template + struct range_reverse_iterator; + + template + struct range_size; + + template + struct range_value; + + template + struct has_range_iterator; + + template + struct has_range_const_iterator; + +} // namespace boost + +#endif // include guard diff --git a/realsense-file/3rd_party/boost/boost/range/rbegin.hpp b/realsense-file/3rd_party/boost/boost/range/rbegin.hpp new file mode 100644 index 0000000000..1809e8a4ad --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/range/rbegin.hpp @@ -0,0 +1,65 @@ +// Boost.Range library +// +// Copyright Thorsten Ottosen 2003-2004. Use, modification and +// distribution is subject to 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) +// +// For more information, see http://www.boost.org/libs/range/ +// + +#ifndef BOOST_RANGE_RBEGIN_HPP +#define BOOST_RANGE_RBEGIN_HPP + +#if defined(_MSC_VER) +# pragma once +#endif + +#include +#include + +namespace boost +{ + +#ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING + +template< class C > +inline BOOST_DEDUCED_TYPENAME range_reverse_iterator::type +rbegin( C& c ) +{ + return BOOST_DEDUCED_TYPENAME range_reverse_iterator::type( boost::end( c ) ); +} + +#else + +template< class C > +inline BOOST_DEDUCED_TYPENAME range_reverse_iterator::type +rbegin( C& c ) +{ + typedef BOOST_DEDUCED_TYPENAME range_reverse_iterator::type + iter_type; + return iter_type( boost::end( c ) ); +} + +template< class C > +inline BOOST_DEDUCED_TYPENAME range_reverse_iterator::type +rbegin( const C& c ) +{ + typedef BOOST_DEDUCED_TYPENAME range_reverse_iterator::type + iter_type; + return iter_type( boost::end( c ) ); +} + +#endif // BOOST_NO_FUNCTION_TEMPLATE_ORDERING + +template< class T > +inline BOOST_DEDUCED_TYPENAME range_reverse_iterator::type +const_rbegin( const T& r ) +{ + return boost::rbegin( r ); +} + +} // namespace 'boost' + +#endif + diff --git a/realsense-file/3rd_party/boost/boost/range/rend.hpp b/realsense-file/3rd_party/boost/boost/range/rend.hpp new file mode 100644 index 0000000000..56896f2046 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/range/rend.hpp @@ -0,0 +1,65 @@ +// Boost.Range library +// +// Copyright Thorsten Ottosen 2003-2004. Use, modification and +// distribution is subject to 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) +// +// For more information, see http://www.boost.org/libs/range/ +// + +#ifndef BOOST_RANGE_REND_HPP +#define BOOST_RANGE_REND_HPP + +#if defined(_MSC_VER) +# pragma once +#endif + +#include +#include + +namespace boost +{ + +#ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING + +template< class C > +inline BOOST_DEDUCED_TYPENAME range_reverse_iterator::type +rend( C& c ) +{ + return BOOST_DEDUCED_TYPENAME range_reverse_iterator::type( boost::begin( c ) ); +} + +#else + +template< class C > +inline BOOST_DEDUCED_TYPENAME range_reverse_iterator::type +rend( C& c ) +{ + typedef BOOST_DEDUCED_TYPENAME range_reverse_iterator::type + iter_type; + return iter_type( boost::begin( c ) ); +} + +template< class C > +inline BOOST_DEDUCED_TYPENAME range_reverse_iterator::type +rend( const C& c ) +{ + typedef BOOST_DEDUCED_TYPENAME range_reverse_iterator::type + iter_type; + return iter_type( boost::begin( c ) ); +} + +#endif + +template< class T > +inline BOOST_DEDUCED_TYPENAME range_reverse_iterator::type +const_rend( const T& r ) +{ + return boost::rend( r ); +} + +} // namespace 'boost' + +#endif + diff --git a/realsense-file/3rd_party/boost/boost/range/reverse_iterator.hpp b/realsense-file/3rd_party/boost/boost/range/reverse_iterator.hpp new file mode 100644 index 0000000000..8792c4d71e --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/range/reverse_iterator.hpp @@ -0,0 +1,42 @@ +// Boost.Range library +// +// Copyright Thorsten Ottosen 2003-2004. Use, modification and +// distribution is subject to 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) +// +// For more information, see http://www.boost.org/libs/range/ +// + +#ifndef BOOST_RANGE_REVERSE_ITERATOR_HPP +#define BOOST_RANGE_REVERSE_ITERATOR_HPP + +#if defined(_MSC_VER) +# pragma once +#endif + +#include +#include +#include +#include + + +namespace boost +{ + ////////////////////////////////////////////////////////////////////////// + // default + ////////////////////////////////////////////////////////////////////////// + + template< typename T > + struct range_reverse_iterator + { + typedef reverse_iterator< + BOOST_DEDUCED_TYPENAME range_iterator< + BOOST_DEDUCED_TYPENAME remove_reference::type>::type > type; + }; + + +} // namespace boost + + +#endif diff --git a/realsense-file/3rd_party/boost/boost/ref.hpp b/realsense-file/3rd_party/boost/boost/ref.hpp new file mode 100644 index 0000000000..df7d045b76 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/ref.hpp @@ -0,0 +1,17 @@ +/* + * Copyright (c) 2014 Glen Fernandes + * + * 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_REF_HPP +#define BOOST_REF_HPP + +// The header file at this path is deprecated; +// use boost/core/ref.hpp instead. + +#include + +#endif diff --git a/realsense-file/3rd_party/boost/boost/static_assert.hpp b/realsense-file/3rd_party/boost/boost/static_assert.hpp new file mode 100644 index 0000000000..00fb912270 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/static_assert.hpp @@ -0,0 +1,195 @@ +// (C) Copyright John Maddock 2000. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org/libs/static_assert for documentation. + +/* + Revision history: + 02 August 2000 + Initial version. +*/ + +#ifndef BOOST_STATIC_ASSERT_HPP +#define BOOST_STATIC_ASSERT_HPP + +#include +#include + +#if defined(__GNUC__) && !defined(__GXX_EXPERIMENTAL_CXX0X__) +// +// This is horrible, but it seems to be the only we can shut up the +// "anonymous variadic macros were introduced in C99 [-Wvariadic-macros]" +// warning that get spewed out otherwise in non-C++11 mode. +// +#pragma GCC system_header +#endif + +#ifndef BOOST_NO_CXX11_STATIC_ASSERT +# ifndef BOOST_NO_CXX11_VARIADIC_MACROS +# define BOOST_STATIC_ASSERT_MSG( ... ) static_assert(__VA_ARGS__) +# else +# define BOOST_STATIC_ASSERT_MSG( B, Msg ) BOOST_STATIC_ASSERT( B ) +# endif +#else +# define BOOST_STATIC_ASSERT_MSG( B, Msg ) BOOST_STATIC_ASSERT( B ) +#endif + +#ifdef __BORLANDC__ +// +// workaround for buggy integral-constant expression support: +#define BOOST_BUGGY_INTEGRAL_CONSTANT_EXPRESSIONS +#endif + +#if defined(__GNUC__) && (__GNUC__ == 3) && ((__GNUC_MINOR__ == 3) || (__GNUC_MINOR__ == 4)) +// gcc 3.3 and 3.4 don't produce good error messages with the default version: +# define BOOST_SA_GCC_WORKAROUND +#endif + +// +// If the compiler issues warnings about old C style casts, +// then enable this: +// +#if defined(__GNUC__) && ((__GNUC__ > 3) || ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 4))) +# ifndef BOOST_NO_CXX11_VARIADIC_MACROS +# define BOOST_STATIC_ASSERT_BOOL_CAST( ... ) ((__VA_ARGS__) == 0 ? false : true) +# else +# define BOOST_STATIC_ASSERT_BOOL_CAST( x ) ((x) == 0 ? false : true) +# endif +#else +# ifndef BOOST_NO_CXX11_VARIADIC_MACROS +# define BOOST_STATIC_ASSERT_BOOL_CAST( ... ) (bool)(__VA_ARGS__) +# else +# define BOOST_STATIC_ASSERT_BOOL_CAST(x) (bool)(x) +# endif +#endif +// +// If the compiler warns about unused typedefs then enable this: +// +#if defined(__GNUC__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7))) +# define BOOST_STATIC_ASSERT_UNUSED_ATTRIBUTE __attribute__((unused)) +#else +# define BOOST_STATIC_ASSERT_UNUSED_ATTRIBUTE +#endif + +#ifndef BOOST_NO_CXX11_STATIC_ASSERT +# ifndef BOOST_NO_CXX11_VARIADIC_MACROS +# define BOOST_STATIC_ASSERT( ... ) static_assert(__VA_ARGS__, #__VA_ARGS__) +# else +# define BOOST_STATIC_ASSERT( B ) static_assert(B, #B) +# endif +#else + +namespace boost{ + +// HP aCC cannot deal with missing names for template value parameters +template struct STATIC_ASSERTION_FAILURE; + +template <> struct STATIC_ASSERTION_FAILURE { enum { value = 1 }; }; + +// HP aCC cannot deal with missing names for template value parameters +template struct static_assert_test{}; + +} + +// +// Implicit instantiation requires that all member declarations be +// instantiated, but that the definitions are *not* instantiated. +// +// It's not particularly clear how this applies to enum's or typedefs; +// both are described as declarations [7.1.3] and [7.2] in the standard, +// however some compilers use "delayed evaluation" of one or more of +// these when implicitly instantiating templates. We use typedef declarations +// by default, but try defining BOOST_USE_ENUM_STATIC_ASSERT if the enum +// version gets better results from your compiler... +// +// Implementation: +// Both of these versions rely on sizeof(incomplete_type) generating an error +// message containing the name of the incomplete type. We use +// "STATIC_ASSERTION_FAILURE" as the type name here to generate +// an eye catching error message. The result of the sizeof expression is either +// used as an enum initialiser, or as a template argument depending which version +// is in use... +// Note that the argument to the assert is explicitly cast to bool using old- +// style casts: too many compilers currently have problems with static_cast +// when used inside integral constant expressions. +// +#if !defined(BOOST_BUGGY_INTEGRAL_CONSTANT_EXPRESSIONS) + +#if defined(BOOST_MSVC) && (BOOST_MSVC < 1300) +// __LINE__ macro broken when -ZI is used see Q199057 +// fortunately MSVC ignores duplicate typedef's. +#define BOOST_STATIC_ASSERT( B ) \ + typedef ::boost::static_assert_test<\ + sizeof(::boost::STATIC_ASSERTION_FAILURE< (bool)( B ) >)\ + > boost_static_assert_typedef_ +#elif defined(BOOST_MSVC) && defined(BOOST_NO_CXX11_VARIADIC_MACROS) +#define BOOST_STATIC_ASSERT( B ) \ + typedef ::boost::static_assert_test<\ + sizeof(::boost::STATIC_ASSERTION_FAILURE< BOOST_STATIC_ASSERT_BOOL_CAST ( B ) >)>\ + BOOST_JOIN(boost_static_assert_typedef_, __COUNTER__) +#elif defined(BOOST_MSVC) +#define BOOST_STATIC_ASSERT(...) \ + typedef ::boost::static_assert_test<\ + sizeof(::boost::STATIC_ASSERTION_FAILURE< BOOST_STATIC_ASSERT_BOOL_CAST (__VA_ARGS__) >)>\ + BOOST_JOIN(boost_static_assert_typedef_, __COUNTER__) +#elif (defined(BOOST_INTEL_CXX_VERSION) || defined(BOOST_SA_GCC_WORKAROUND)) && defined(BOOST_NO_CXX11_VARIADIC_MACROS) +// agurt 15/sep/02: a special care is needed to force Intel C++ issue an error +// instead of warning in case of failure +# define BOOST_STATIC_ASSERT( B ) \ + typedef char BOOST_JOIN(boost_static_assert_typedef_, __LINE__) \ + [ ::boost::STATIC_ASSERTION_FAILURE< BOOST_STATIC_ASSERT_BOOL_CAST( B ) >::value ] +#elif (defined(BOOST_INTEL_CXX_VERSION) || defined(BOOST_SA_GCC_WORKAROUND)) && !defined(BOOST_NO_CXX11_VARIADIC_MACROS) +// agurt 15/sep/02: a special care is needed to force Intel C++ issue an error +// instead of warning in case of failure +# define BOOST_STATIC_ASSERT(...) \ + typedef char BOOST_JOIN(boost_static_assert_typedef_, __LINE__) \ + [ ::boost::STATIC_ASSERTION_FAILURE< BOOST_STATIC_ASSERT_BOOL_CAST( __VA_ARGS__ ) >::value ] +#elif defined(__sgi) +// special version for SGI MIPSpro compiler +#define BOOST_STATIC_ASSERT( B ) \ + BOOST_STATIC_CONSTANT(bool, \ + BOOST_JOIN(boost_static_assert_test_, __LINE__) = ( B )); \ + typedef ::boost::static_assert_test<\ + sizeof(::boost::STATIC_ASSERTION_FAILURE< \ + BOOST_JOIN(boost_static_assert_test_, __LINE__) >)>\ + BOOST_JOIN(boost_static_assert_typedef_, __LINE__) +#elif BOOST_WORKAROUND(__MWERKS__, <= 0x3003) +// special version for CodeWarrior <= 8.x +#define BOOST_STATIC_ASSERT( B ) \ + BOOST_STATIC_CONSTANT(int, \ + BOOST_JOIN(boost_static_assert_test_, __LINE__) = \ + sizeof(::boost::STATIC_ASSERTION_FAILURE< BOOST_STATIC_ASSERT_BOOL_CAST( B ) >) ) +#else +// generic version +# ifndef BOOST_NO_CXX11_VARIADIC_MACROS +# define BOOST_STATIC_ASSERT( ... ) \ + typedef ::boost::static_assert_test<\ + sizeof(::boost::STATIC_ASSERTION_FAILURE< BOOST_STATIC_ASSERT_BOOL_CAST( __VA_ARGS__ ) >)>\ + BOOST_JOIN(boost_static_assert_typedef_, __LINE__) BOOST_STATIC_ASSERT_UNUSED_ATTRIBUTE +# else +# define BOOST_STATIC_ASSERT( B ) \ + typedef ::boost::static_assert_test<\ + sizeof(::boost::STATIC_ASSERTION_FAILURE< BOOST_STATIC_ASSERT_BOOL_CAST( B ) >)>\ + BOOST_JOIN(boost_static_assert_typedef_, __LINE__) BOOST_STATIC_ASSERT_UNUSED_ATTRIBUTE +# endif +#endif + +#else +// alternative enum based implementation: +# ifndef BOOST_NO_CXX11_VARIADIC_MACROS +# define BOOST_STATIC_ASSERT( ... ) \ + enum { BOOST_JOIN(boost_static_assert_enum_, __LINE__) \ + = sizeof(::boost::STATIC_ASSERTION_FAILURE< (bool)( __VA_ARGS__ ) >) } +# else +# define BOOST_STATIC_ASSERT(B) \ + enum { BOOST_JOIN(boost_static_assert_enum_, __LINE__) \ + = sizeof(::boost::STATIC_ASSERTION_FAILURE< (bool)( B ) >) } +# endif +#endif +#endif // defined(BOOST_NO_CXX11_STATIC_ASSERT) + +#endif // BOOST_STATIC_ASSERT_HPP + + diff --git a/realsense-file/3rd_party/boost/boost/throw_exception.hpp b/realsense-file/3rd_party/boost/boost/throw_exception.hpp new file mode 100644 index 0000000000..386ee70d90 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/throw_exception.hpp @@ -0,0 +1,102 @@ +#ifndef UUID_AA15E74A856F11E08B8D93F24824019B +#define UUID_AA15E74A856F11E08B8D93F24824019B +#if (__GNUC__*100+__GNUC_MINOR__>301) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS) +#pragma GCC system_header +#endif +#if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS) +#pragma warning(push,1) +#endif + +// MS compatible compilers support #pragma once + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma once +#endif + +// +// boost/throw_exception.hpp +// +// Copyright (c) 2002 Peter Dimov and Multi Media Ltd. +// Copyright (c) 2008-2009 Emil Dotchevski and Reverge Studios, Inc. +// +// 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) +// +// http://www.boost.org/libs/utility/throw_exception.html +// + +#include +#include +#include + +#if !defined( BOOST_EXCEPTION_DISABLE ) && defined( __BORLANDC__ ) && BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT(0x593) ) +# define BOOST_EXCEPTION_DISABLE +#endif + +#if !defined( BOOST_EXCEPTION_DISABLE ) && defined( BOOST_MSVC ) && BOOST_WORKAROUND( BOOST_MSVC, < 1310 ) +# define BOOST_EXCEPTION_DISABLE +#endif + +#if !defined( BOOST_EXCEPTION_DISABLE ) +# include +#if !defined(BOOST_THROW_EXCEPTION_CURRENT_FUNCTION) +# include +# define BOOST_THROW_EXCEPTION_CURRENT_FUNCTION BOOST_CURRENT_FUNCTION +#endif +# define BOOST_THROW_EXCEPTION(x) ::boost::exception_detail::throw_exception_(x,BOOST_THROW_EXCEPTION_CURRENT_FUNCTION,__FILE__,__LINE__) +#else +# define BOOST_THROW_EXCEPTION(x) ::boost::throw_exception(x) +#endif + +namespace boost +{ +#ifdef BOOST_NO_EXCEPTIONS + +void throw_exception( std::exception const & e ); // user defined + +#else + +inline void throw_exception_assert_compatibility( std::exception const & ) { } + +template BOOST_NORETURN inline void throw_exception( E const & e ) +{ + //All boost exceptions are required to derive from std::exception, + //to ensure compatibility with BOOST_NO_EXCEPTIONS. + throw_exception_assert_compatibility(e); + +#ifndef BOOST_EXCEPTION_DISABLE + throw enable_current_exception(enable_error_info(e)); +#else + throw e; +#endif +} + +#endif + +#if !defined( BOOST_EXCEPTION_DISABLE ) + namespace + exception_detail + { + template + BOOST_NORETURN + void + throw_exception_( E const & x, char const * current_function, char const * file, int line ) + { + boost::throw_exception( + set_info( + set_info( + set_info( + enable_error_info(x), + throw_function(current_function)), + throw_file(file)), + throw_line(line))); + } + } +#endif +} // namespace boost + +#if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS) +#pragma warning(pop) +#endif +#endif diff --git a/realsense-file/3rd_party/boost/boost/type.hpp b/realsense-file/3rd_party/boost/boost/type.hpp new file mode 100644 index 0000000000..4a1f75002e --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/type.hpp @@ -0,0 +1,18 @@ +// (C) Copyright David Abrahams 2001. +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#ifndef BOOST_TYPE_DWA20010120_HPP +# define BOOST_TYPE_DWA20010120_HPP + +namespace boost { + + // Just a simple "type envelope". Useful in various contexts, mostly to work + // around some MSVC deficiencies. + template + struct type {}; + +} + +#endif // BOOST_TYPE_DWA20010120_HPP diff --git a/realsense-file/3rd_party/boost/boost/type_traits/add_const.hpp b/realsense-file/3rd_party/boost/boost/type_traits/add_const.hpp new file mode 100644 index 0000000000..a4352fba94 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/type_traits/add_const.hpp @@ -0,0 +1,45 @@ + +// (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, Howard +// Hinnant & John Maddock 2000. +// Use, modification and distribution are subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_ADD_CONST_HPP_INCLUDED +#define BOOST_TT_ADD_CONST_HPP_INCLUDED + +#include "config.hpp" + +// should be the last #include +#include + +namespace boost { + +// * convert a type T to const type - add_const +// this is not required since the result is always +// the same as "T const", but it does suppress warnings +// from some compilers: + +#if defined(BOOST_MSVC) +// This bogus warning will appear when add_const is applied to a +// const volatile reference because we can't detect const volatile +// references with MSVC6. +# pragma warning(push) +# pragma warning(disable:4181) // warning C4181: qualifier applied to reference type ignored +#endif + +BOOST_TT_AUX_TYPE_TRAIT_DEF1(add_const,T,T const) + +#if defined(BOOST_MSVC) +# pragma warning(pop) +#endif + +BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,add_const,T&,T&) + +} // namespace boost + +#include + +#endif // BOOST_TT_ADD_CONST_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/type_traits/add_pointer.hpp b/realsense-file/3rd_party/boost/boost/type_traits/add_pointer.hpp new file mode 100644 index 0000000000..009966089d --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/type_traits/add_pointer.hpp @@ -0,0 +1,72 @@ + +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// Use, modification and distribution are subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_ADD_POINTER_HPP_INCLUDED +#define BOOST_TT_ADD_POINTER_HPP_INCLUDED + +#include + +// should be the last #include +#include + +namespace boost { + +namespace detail { + +#if defined(__BORLANDC__) && (__BORLANDC__ < 0x5A0) +// +// For some reason this implementation stops Borlands compiler +// from dropping cv-qualifiers, it still fails with references +// to arrays for some reason though (shrug...) (JM 20021104) +// +template +struct add_pointer_impl +{ + typedef T* type; +}; +template +struct add_pointer_impl +{ + typedef T* type; +}; +template +struct add_pointer_impl +{ + typedef T* type; +}; +template +struct add_pointer_impl +{ + typedef T* type; +}; +template +struct add_pointer_impl +{ + typedef T* type; +}; + +#else + +template +struct add_pointer_impl +{ + typedef typename remove_reference::type no_ref_type; + typedef no_ref_type* type; +}; + +#endif + +} // namespace detail + +BOOST_TT_AUX_TYPE_TRAIT_DEF1(add_pointer,T,typename boost::detail::add_pointer_impl::type) + +} // namespace boost + +#include + +#endif // BOOST_TT_ADD_POINTER_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/type_traits/add_reference.hpp b/realsense-file/3rd_party/boost/boost/type_traits/add_reference.hpp new file mode 100644 index 0000000000..1835d9898b --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/type_traits/add_reference.hpp @@ -0,0 +1,72 @@ + +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// Use, modification and distribution are subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_ADD_REFERENCE_HPP_INCLUDED +#define BOOST_TT_ADD_REFERENCE_HPP_INCLUDED + +#include +#include +#include + +// should be the last #include +#include + +namespace boost { + +namespace detail { + +// +// We can't filter out rvalue_references at the same level as +// references or we get ambiguities from msvc: +// + +template +struct add_reference_rvalue_layer +{ + typedef T& type; +}; + +#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES +template +struct add_reference_rvalue_layer +{ + typedef T&& type; +}; +#endif + +template +struct add_reference_impl +{ + typedef typename add_reference_rvalue_layer::type type; +}; + +BOOST_TT_AUX_TYPE_TRAIT_IMPL_PARTIAL_SPEC1_1(typename T,add_reference,T&,T&) + +// these full specialisations are always required: +BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1(add_reference,void,void) +#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS +BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1(add_reference,void const,void const) +BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1(add_reference,void volatile,void volatile) +BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1(add_reference,void const volatile,void const volatile) +#endif + +} // namespace detail + +BOOST_TT_AUX_TYPE_TRAIT_DEF1(add_reference,T,typename boost::detail::add_reference_impl::type) + +// agurt, 07/mar/03: workaround Borland's ill-formed sensitivity to an additional +// level of indirection, here +#if BOOST_WORKAROUND(__BORLANDC__, < 0x600) +BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,add_reference,T&,T&) +#endif + +} // namespace boost + +#include + +#endif // BOOST_TT_ADD_REFERENCE_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/type_traits/add_rvalue_reference.hpp b/realsense-file/3rd_party/boost/boost/type_traits/add_rvalue_reference.hpp new file mode 100644 index 0000000000..c2620211d3 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/type_traits/add_rvalue_reference.hpp @@ -0,0 +1,66 @@ +// add_rvalue_reference.hpp ---------------------------------------------------------// + +// Copyright 2010 Vicente J. Botet Escriba + +// Distributed under the Boost Software License, Version 1.0. +// See http://www.boost.org/LICENSE_1_0.txt + +#ifndef BOOST_TYPE_TRAITS_EXT_ADD_RVALUE_REFERENCE__HPP +#define BOOST_TYPE_TRAITS_EXT_ADD_RVALUE_REFERENCE__HPP + +#include + +//----------------------------------------------------------------------------// + +#include +#include + +// should be the last #include +#include + +//----------------------------------------------------------------------------// +// // +// C++03 implementation of // +// 20.9.7.2 Reference modifications [meta.trans.ref] // +// Written by Vicente J. Botet Escriba // +// // +// If T names an object or function type then the member typedef type +// shall name T&&; otherwise, type shall name T. [ Note: This rule reflects +// the semantics of reference collapsing. For example, when a type T names +// a type T1&, the type add_rvalue_reference::type is not an rvalue +// reference. -end note ] +//----------------------------------------------------------------------------// + +namespace boost { + +namespace type_traits_detail { + + template + struct add_rvalue_reference_helper + { typedef T type; }; + +#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) + template + struct add_rvalue_reference_helper + { + typedef T&& type; + }; +#endif + + template + struct add_rvalue_reference_imp + { + typedef typename boost::type_traits_detail::add_rvalue_reference_helper + ::value == false && is_reference::value == false) >::type type; + }; + +} + +BOOST_TT_AUX_TYPE_TRAIT_DEF1(add_rvalue_reference,T,typename boost::type_traits_detail::add_rvalue_reference_imp::type) + +} // namespace boost + +#include + +#endif // BOOST_TYPE_TRAITS_EXT_ADD_RVALUE_REFERENCE__HPP + diff --git a/realsense-file/3rd_party/boost/boost/type_traits/add_volatile.hpp b/realsense-file/3rd_party/boost/boost/type_traits/add_volatile.hpp new file mode 100644 index 0000000000..d821e14794 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/type_traits/add_volatile.hpp @@ -0,0 +1,45 @@ + +// (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, Howard +// Hinnant & John Maddock 2000. +// Use, modification and distribution are subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_ADD_VOLATILE_HPP_INCLUDED +#define BOOST_TT_ADD_VOLATILE_HPP_INCLUDED + +#include + +// should be the last #include +#include + +namespace boost { + +// * convert a type T to volatile type - add_volatile +// this is not required since the result is always +// the same as "T volatile", but it does suppress warnings +// from some compilers: + +#if defined(BOOST_MSVC) +// This bogus warning will appear when add_volatile is applied to a +// const volatile reference because we can't detect const volatile +// references with MSVC6. +# pragma warning(push) +# pragma warning(disable:4181) // warning C4181: qualifier applied to reference type ignored +#endif + +BOOST_TT_AUX_TYPE_TRAIT_DEF1(add_volatile,T,T volatile) + +#if defined(BOOST_MSVC) +# pragma warning(pop) +#endif + +BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,add_volatile,T&,T&) + +} // namespace boost + +#include + +#endif // BOOST_TT_ADD_VOLATILE_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/type_traits/alignment_of.hpp b/realsense-file/3rd_party/boost/boost/type_traits/alignment_of.hpp new file mode 100644 index 0000000000..9d14ed1e4e --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/type_traits/alignment_of.hpp @@ -0,0 +1,126 @@ + +// (C) Copyright John Maddock 2000. +// Use, modification and distribution are subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_ALIGNMENT_OF_HPP_INCLUDED +#define BOOST_TT_ALIGNMENT_OF_HPP_INCLUDED + +#include +#include + +#include +// should be the last #include +#include + +#ifdef BOOST_MSVC +# pragma warning(push) +# pragma warning(disable: 4121 4512) // alignment is sensitive to packing +#endif +#if defined(__BORLANDC__) && (__BORLANDC__ < 0x600) +#pragma option push -Vx- -Ve- +#endif + +namespace boost { + +template struct alignment_of; + +// get the alignment of some arbitrary type: +namespace detail { + +#ifdef BOOST_MSVC +#pragma warning(push) +#pragma warning(disable:4324) // structure was padded due to __declspec(align()) +#endif +template +struct alignment_of_hack +{ + char c; + T t; + alignment_of_hack(); +}; +#ifdef BOOST_MSVC +#pragma warning(pop) +#endif + +template +struct alignment_logic +{ + BOOST_STATIC_CONSTANT(std::size_t, value = A < S ? A : S); +}; + + +template< typename T > +struct alignment_of_impl +{ +#if defined(BOOST_MSVC) && (BOOST_MSVC >= 1400) + // + // With MSVC both the native __alignof operator + // and our own logic gets things wrong from time to time :-( + // Using a combination of the two seems to make the most of a bad job: + // + BOOST_STATIC_CONSTANT(std::size_t, value = + (::boost::detail::alignment_logic< + sizeof(::boost::detail::alignment_of_hack) - sizeof(T), + __alignof(T) + >::value)); +#elif !defined(BOOST_ALIGNMENT_OF) + BOOST_STATIC_CONSTANT(std::size_t, value = + (::boost::detail::alignment_logic< + sizeof(::boost::detail::alignment_of_hack) - sizeof(T), + sizeof(T) + >::value)); +#else + // + // We put this here, rather than in the definition of + // alignment_of below, because MSVC's __alignof doesn't + // always work in that context for some unexplained reason. + // (See type_with_alignment tests for test cases). + // + BOOST_STATIC_CONSTANT(std::size_t, value = BOOST_ALIGNMENT_OF(T)); +#endif +}; + +} // namespace detail + +BOOST_TT_AUX_SIZE_T_TRAIT_DEF1(alignment_of,T,::boost::detail::alignment_of_impl::value) + +// references have to be treated specially, assume +// that a reference is just a special pointer: +template +struct alignment_of + : public alignment_of +{ +}; +#ifdef __BORLANDC__ +// long double gives an incorrect value of 10 (!) +// unless we do this... +struct long_double_wrapper{ long double ld; }; +template<> struct alignment_of + : public alignment_of{}; +#endif + +// void has to be treated specially: +BOOST_TT_AUX_SIZE_T_TRAIT_SPEC1(alignment_of,void,0) +#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS +BOOST_TT_AUX_SIZE_T_TRAIT_SPEC1(alignment_of,void const,0) +BOOST_TT_AUX_SIZE_T_TRAIT_SPEC1(alignment_of,void volatile,0) +BOOST_TT_AUX_SIZE_T_TRAIT_SPEC1(alignment_of,void const volatile,0) +#endif + +} // namespace boost + +#if defined(__BORLANDC__) && (__BORLANDC__ < 0x600) +#pragma option pop +#endif +#ifdef BOOST_MSVC +# pragma warning(pop) +#endif + +#include + +#endif // BOOST_TT_ALIGNMENT_OF_HPP_INCLUDED + diff --git a/realsense-file/3rd_party/boost/boost/type_traits/composite_traits.hpp b/realsense-file/3rd_party/boost/boost/type_traits/composite_traits.hpp new file mode 100644 index 0000000000..8c256eea0c --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/type_traits/composite_traits.hpp @@ -0,0 +1,29 @@ +// (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, Howard +// Hinnant & John Maddock 2000. +// Use, modification and distribution are subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. +// +// defines traits classes for composite types: +// is_array, is_pointer, is_reference, is_member_pointer, is_enum, is_union. +// + +#ifndef BOOST_TT_COMPOSITE_TRAITS_HPP_INCLUDED +#define BOOST_TT_COMPOSITE_TRAITS_HPP_INCLUDED + +#include +#include +#include +#include +#include +#include +#include + +#endif // BOOST_TT_COMPOSITE_TRAITS_HPP_INCLUDED + + + + + diff --git a/realsense-file/3rd_party/boost/boost/type_traits/config.hpp b/realsense-file/3rd_party/boost/boost/type_traits/config.hpp new file mode 100644 index 0000000000..c413b280fc --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/type_traits/config.hpp @@ -0,0 +1,72 @@ + +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// Use, modification and distribution are subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_CONFIG_HPP_INCLUDED +#define BOOST_TT_CONFIG_HPP_INCLUDED + +#ifndef BOOST_CONFIG_HPP +#include +#endif + +#include "../detail/workaround.hpp" + +// +// whenever we have a conversion function with ellipses +// it needs to be declared __cdecl to suppress compiler +// warnings from MS and Borland compilers (this *must* +// appear before we include is_same.hpp below): +#if defined(BOOST_MSVC) || (defined(__BORLANDC__) && !defined(BOOST_DISABLE_WIN32)) +# define BOOST_TT_DECL __cdecl +#else +# define BOOST_TT_DECL /**/ +#endif + +# if (BOOST_WORKAROUND(__MWERKS__, < 0x3000) \ + || BOOST_WORKAROUND(__IBMCPP__, < 600 ) \ + || BOOST_WORKAROUND(__BORLANDC__, < 0x5A0) \ + || defined(__ghs) \ + || BOOST_WORKAROUND(__HP_aCC, < 60700) \ + || BOOST_WORKAROUND(MPW_CPLUS, BOOST_TESTED_AT(0x890)) \ + || BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x580))) \ + && defined(BOOST_NO_IS_ABSTRACT) + +# define BOOST_TT_NO_CONFORMING_IS_CLASS_IMPLEMENTATION 1 + +#endif + +#ifndef BOOST_TT_NO_CONFORMING_IS_CLASS_IMPLEMENTATION +# define BOOST_TT_HAS_CONFORMING_IS_CLASS_IMPLEMENTATION 1 +#endif + +// +// define BOOST_TT_TEST_MS_FUNC_SIGS +// when we want to test __stdcall etc function types with is_function etc +// (Note, does not work with Borland, even though it does support __stdcall etc): +// +#if defined(_MSC_EXTENSIONS) && !defined(__BORLANDC__) +# define BOOST_TT_TEST_MS_FUNC_SIGS +#endif + +// +// define BOOST_TT_NO_CV_FUNC_TEST +// if tests for cv-qualified member functions don't +// work in is_member_function_pointer +// +#if BOOST_WORKAROUND(__MWERKS__, < 0x3000) || BOOST_WORKAROUND(__IBMCPP__, <= 600) +# define BOOST_TT_NO_CV_FUNC_TEST +#endif + +// +// Macros that have been deprecated, defined here for backwards compatibility: +// +#define BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION(x) +#define BOOST_TT_BROKEN_COMPILER_SPEC(x) + +#endif // BOOST_TT_CONFIG_HPP_INCLUDED + + diff --git a/realsense-file/3rd_party/boost/boost/type_traits/decay.hpp b/realsense-file/3rd_party/boost/boost/type_traits/decay.hpp new file mode 100644 index 0000000000..58dbb4697c --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/type_traits/decay.hpp @@ -0,0 +1,44 @@ +// (C) Copyright John Maddock & Thorsten Ottosen 2005. +// Use, modification and distribution are subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + + +#ifndef BOOST_TT_DECAY_HPP_INCLUDED +#define BOOST_TT_DECAY_HPP_INCLUDED + +#include +#include +#include +#include +#include +#include +#include +#include + +namespace boost +{ + + template< class T > + struct decay + { + private: + typedef BOOST_DEDUCED_TYPENAME remove_reference::type Ty; + public: + typedef BOOST_DEDUCED_TYPENAME mpl::eval_if< + is_array, + mpl::identity::type*>, + BOOST_DEDUCED_TYPENAME mpl::eval_if< + is_function, + add_pointer, + mpl::identity + > + >::type type; + }; + +} // namespace boost + + +#endif // BOOST_TT_DECAY_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/type_traits/detail/bool_trait_def.hpp b/realsense-file/3rd_party/boost/boost/type_traits/detail/bool_trait_def.hpp new file mode 100644 index 0000000000..62079b0f2f --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/type_traits/detail/bool_trait_def.hpp @@ -0,0 +1,188 @@ + +// NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION + +// Copyright Aleksey Gurtovoy 2002-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// $Source$ +// $Date$ +// $Revision$ + +#include "template_arity_spec.hpp" +#include "../integral_constant.hpp" +#include "boost/mpl/bool.hpp" +#include "boost/mpl/aux_/lambda_support.hpp" +#include "boost/config.hpp" + +// +// Unfortunately some libraries have started using this header without +// cleaning up afterwards: so we'd better undef the macros just in case +// they've been defined already.... +// +#ifdef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL +#undef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL +#undef BOOST_TT_AUX_BOOL_C_BASE +#undef BOOST_TT_AUX_BOOL_TRAIT_DEF1 +#undef BOOST_TT_AUX_BOOL_TRAIT_DEF2 +#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC1 +#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC2 +#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1 +#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2 +#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1 +#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2 +#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1 +#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2 +#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1 +#undef BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1 +#endif + +#if defined(__SUNPRO_CC) && (__SUNPRO_CC < 0x570) +# define BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) \ + typedef ::boost::integral_constant type; \ + enum { value = type::value }; \ + /**/ +# define BOOST_TT_AUX_BOOL_C_BASE(C) +#endif + +#ifndef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL +# define BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) /**/ +#endif + +#ifndef BOOST_TT_AUX_BOOL_C_BASE +# define BOOST_TT_AUX_BOOL_C_BASE(C) : public ::boost::integral_constant +#endif + + +#define BOOST_TT_AUX_BOOL_TRAIT_DEF1(trait,T,C) \ +template< typename T > struct trait \ + BOOST_TT_AUX_BOOL_C_BASE(C) \ +{ \ +public:\ + BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) \ + BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) \ +}; \ +\ +BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait) \ +/**/ + + +#define BOOST_TT_AUX_BOOL_TRAIT_DEF2(trait,T1,T2,C) \ +template< typename T1, typename T2 > struct trait \ + BOOST_TT_AUX_BOOL_C_BASE(C) \ +{ \ +public:\ + BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) \ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2,trait,(T1,T2)) \ +}; \ +\ +BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(2,trait) \ +/**/ + +#define BOOST_TT_AUX_BOOL_TRAIT_DEF3(trait,T1,T2,T3,C) \ +template< typename T1, typename T2, typename T3 > struct trait \ + BOOST_TT_AUX_BOOL_C_BASE(C) \ +{ \ +public:\ + BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) \ + BOOST_MPL_AUX_LAMBDA_SUPPORT(3,trait,(T1,T2,T3)) \ +}; \ +\ +BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(3,trait) \ +/**/ + +#define BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,C) \ +template<> struct trait< sp > \ + BOOST_TT_AUX_BOOL_C_BASE(C) \ +{ \ +public:\ + BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) \ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(sp)) \ +}; \ +/**/ + +#define BOOST_TT_AUX_BOOL_TRAIT_SPEC2(trait,sp1,sp2,C) \ +template<> struct trait< sp1,sp2 > \ + BOOST_TT_AUX_BOOL_C_BASE(C) \ +{ \ +public:\ + BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) \ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) \ +}; \ +/**/ + +#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(trait,sp,C) \ +template<> struct trait##_impl< sp > \ +{ \ +public:\ + BOOST_STATIC_CONSTANT(bool, value = (C)); \ +}; \ +/**/ + +#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,sp1,sp2,C) \ +template<> struct trait##_impl< sp1,sp2 > \ +{ \ +public:\ + BOOST_STATIC_CONSTANT(bool, value = (C)); \ +}; \ +/**/ + +#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(param,trait,sp,C) \ +template< param > struct trait< sp > \ + BOOST_TT_AUX_BOOL_C_BASE(C) \ +{ \ +public:\ + BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) \ +}; \ +/**/ + +#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,sp,C) \ +template< param1, param2 > struct trait< sp > \ + BOOST_TT_AUX_BOOL_C_BASE(C) \ +{ \ +public:\ + BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) \ +}; \ +/**/ + +#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) \ +template< param > struct trait< sp1,sp2 > \ + BOOST_TT_AUX_BOOL_C_BASE(C) \ +{ \ +public:\ + BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) \ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) \ +}; \ +/**/ + +#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(param1,param2,trait,sp1,sp2,C) \ +template< param1, param2 > struct trait< sp1,sp2 > \ + BOOST_TT_AUX_BOOL_C_BASE(C) \ +{ \ +public:\ + BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) \ +}; \ +/**/ + +#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) \ +template< param > struct trait##_impl< sp1,sp2 > \ +{ \ +public:\ + BOOST_STATIC_CONSTANT(bool, value = (C)); \ +}; \ +/**/ + +#ifndef BOOST_NO_CV_SPECIALIZATIONS +# define BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(trait,sp,value) \ + BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,value) \ + BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const,value) \ + BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp volatile,value) \ + BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const volatile,value) \ + /**/ +#else +# define BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(trait,sp,value) \ + BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,value) \ + /**/ +#endif diff --git a/realsense-file/3rd_party/boost/boost/type_traits/detail/bool_trait_undef.hpp b/realsense-file/3rd_party/boost/boost/type_traits/detail/bool_trait_undef.hpp new file mode 100644 index 0000000000..727ad9acfa --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/type_traits/detail/bool_trait_undef.hpp @@ -0,0 +1,28 @@ + +// NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION + +// Copyright Aleksey Gurtovoy 2002-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// $Source$ +// $Date$ +// $Revision$ + +#undef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL +#undef BOOST_TT_AUX_BOOL_C_BASE +#undef BOOST_TT_AUX_BOOL_TRAIT_DEF1 +#undef BOOST_TT_AUX_BOOL_TRAIT_DEF2 +#undef BOOST_TT_AUX_BOOL_TRAIT_DEF3 +#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC1 +#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC2 +#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1 +#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2 +#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1 +#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2 +#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1 +#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2 +#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1 +#undef BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1 diff --git a/realsense-file/3rd_party/boost/boost/type_traits/detail/cv_traits_impl.hpp b/realsense-file/3rd_party/boost/boost/type_traits/detail/cv_traits_impl.hpp new file mode 100644 index 0000000000..3a6caa2798 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/type_traits/detail/cv_traits_impl.hpp @@ -0,0 +1,140 @@ + +// (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, Howard +// Hinnant & John Maddock 2000. +// Use, modification and distribution are subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + + +#ifndef BOOST_TT_DETAIL_CV_TRAITS_IMPL_HPP_INCLUDED +#define BOOST_TT_DETAIL_CV_TRAITS_IMPL_HPP_INCLUDED + +#include +#include "../config.hpp" +#include "../../detail/workaround.hpp" + + +// implementation helper: + + +namespace boost { +namespace detail { + +#if BOOST_WORKAROUND(BOOST_MSVC, == 1700) +#define BOOST_TT_AUX_CV_TRAITS_IMPL_PARAM(X) X + template + struct cv_traits_imp + { + BOOST_STATIC_CONSTANT(bool, is_const = false); + BOOST_STATIC_CONSTANT(bool, is_volatile = false); + typedef T unqualified_type; + }; + + template + struct cv_traits_imp + { + BOOST_STATIC_CONSTANT(bool, is_const = false); + BOOST_STATIC_CONSTANT(bool, is_volatile = false); + typedef T unqualified_type[]; + }; + + template + struct cv_traits_imp + { + BOOST_STATIC_CONSTANT(bool, is_const = true); + BOOST_STATIC_CONSTANT(bool, is_volatile = false); + typedef T unqualified_type[]; + }; + + template + struct cv_traits_imp + { + BOOST_STATIC_CONSTANT(bool, is_const = false); + BOOST_STATIC_CONSTANT(bool, is_volatile = true); + typedef T unqualified_type[]; + }; + + template + struct cv_traits_imp + { + BOOST_STATIC_CONSTANT(bool, is_const = true); + BOOST_STATIC_CONSTANT(bool, is_volatile = true); + typedef T unqualified_type[]; + }; + + template + struct cv_traits_imp + { + BOOST_STATIC_CONSTANT(bool, is_const = false); + BOOST_STATIC_CONSTANT(bool, is_volatile = false); + typedef T unqualified_type[N]; + }; + + template + struct cv_traits_imp + { + BOOST_STATIC_CONSTANT(bool, is_const = true); + BOOST_STATIC_CONSTANT(bool, is_volatile = false); + typedef T unqualified_type[N]; + }; + + template + struct cv_traits_imp + { + BOOST_STATIC_CONSTANT(bool, is_const = false); + BOOST_STATIC_CONSTANT(bool, is_volatile = true); + typedef T unqualified_type[N]; + }; + + template + struct cv_traits_imp + { + BOOST_STATIC_CONSTANT(bool, is_const = true); + BOOST_STATIC_CONSTANT(bool, is_volatile = true); + typedef T unqualified_type[N]; + }; + +#else +#define BOOST_TT_AUX_CV_TRAITS_IMPL_PARAM(X) X * +template struct cv_traits_imp {}; + +template +struct cv_traits_imp +{ + BOOST_STATIC_CONSTANT(bool, is_const = false); + BOOST_STATIC_CONSTANT(bool, is_volatile = false); + typedef T unqualified_type; +}; +#endif + +template +struct cv_traits_imp +{ + BOOST_STATIC_CONSTANT(bool, is_const = true); + BOOST_STATIC_CONSTANT(bool, is_volatile = false); + typedef T unqualified_type; +}; + +template +struct cv_traits_imp +{ + BOOST_STATIC_CONSTANT(bool, is_const = false); + BOOST_STATIC_CONSTANT(bool, is_volatile = true); + typedef T unqualified_type; +}; + +template +struct cv_traits_imp +{ + BOOST_STATIC_CONSTANT(bool, is_const = true); + BOOST_STATIC_CONSTANT(bool, is_volatile = true); + typedef T unqualified_type; +}; + +} // namespace detail +} // namespace boost + + +#endif // BOOST_TT_DETAIL_CV_TRAITS_IMPL_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/type_traits/detail/false_result.hpp b/realsense-file/3rd_party/boost/boost/type_traits/detail/false_result.hpp new file mode 100644 index 0000000000..6031e53876 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/type_traits/detail/false_result.hpp @@ -0,0 +1,28 @@ +// Copyright David Abrahams 2002. +// Use, modification and distribution are subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + + +#ifndef BOOST_TT_DETAIL_FALSE_RESULT_HPP_INCLUDED +#define BOOST_TT_DETAIL_FALSE_RESULT_HPP_INCLUDED + +#include "../config.hpp" + +namespace boost { +namespace type_traits { + +// Utility class which always "returns" false +struct false_result +{ + template struct result_ + { + BOOST_STATIC_CONSTANT(bool, value = false); + }; +}; + +}} // namespace boost::type_traits + +#endif // BOOST_TT_DETAIL_FALSE_RESULT_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/type_traits/detail/has_binary_operator.hpp b/realsense-file/3rd_party/boost/boost/type_traits/detail/has_binary_operator.hpp new file mode 100644 index 0000000000..0cf8d507f6 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/type_traits/detail/has_binary_operator.hpp @@ -0,0 +1,229 @@ +// (C) Copyright 2009-2011 Frederic Bron, Robert Stewart, Steven Watanabe & Roman Perepelitsa. +// +// Use, modification and distribution are subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// should be the last #include +#include + +// cannot include this header without getting warnings of the kind: +// gcc: +// warning: value computed is not used +// warning: comparison between signed and unsigned integer expressions +// msvc: +// warning C4018: '<' : signed/unsigned mismatch +// warning C4244: '+=' : conversion from 'double' to 'char', possible loss of data +// warning C4547: '*' : operator before comma has no effect; expected operator with side-effect +// warning C4800: 'int' : forcing value to bool 'true' or 'false' (performance warning) +// warning C4804: '<' : unsafe use of type 'bool' in operation +// warning C4805: '==' : unsafe mix of type 'bool' and type 'char' in operation +// cannot find another implementation -> declared as system header to suppress these warnings. +#if defined(__GNUC__) +# pragma GCC system_header +#elif defined(BOOST_MSVC) +# pragma warning ( push ) +# pragma warning ( disable : 4018 4244 4547 4800 4804 4805 4913 ) +#endif + +namespace boost { +namespace detail { + +// This namespace ensures that argument-dependent name lookup does not mess things up. +namespace BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl) { + +// 1. a function to have an instance of type T without requiring T to be default +// constructible +template T &make(); + + +// 2. we provide our operator definition for types that do not have one already + +// a type returned from operator BOOST_TT_TRAIT_OP when no such operator is +// found in the type's own namespace (our own operator is used) so that we have +// a means to know that our operator was used +struct no_operator { }; + +// this class allows implicit conversions and makes the following operator +// definition less-preferred than any other such operators that might be found +// via argument-dependent name lookup +struct any { template any(T const&); }; + +// when operator BOOST_TT_TRAIT_OP is not available, this one is used +no_operator operator BOOST_TT_TRAIT_OP (const any&, const any&); + + +// 3. checks if the operator returns void or not +// conditions: Lhs!=void and Rhs!=void + +// we first redefine "operator," so that we have no compilation error if +// operator BOOST_TT_TRAIT_OP returns void and we can use the return type of +// (lhs BOOST_TT_TRAIT_OP rhs, returns_void_t()) to deduce if +// operator BOOST_TT_TRAIT_OP returns void or not: +// - operator BOOST_TT_TRAIT_OP returns void -> (lhs BOOST_TT_TRAIT_OP rhs, returns_void_t()) returns returns_void_t +// - operator BOOST_TT_TRAIT_OP returns !=void -> (lhs BOOST_TT_TRAIT_OP rhs, returns_void_t()) returns int +struct returns_void_t { }; +template int operator,(const T&, returns_void_t); +template int operator,(const volatile T&, returns_void_t); + +// this intermediate trait has member value of type bool: +// - value==true -> operator BOOST_TT_TRAIT_OP returns void +// - value==false -> operator BOOST_TT_TRAIT_OP does not return void +template < typename Lhs, typename Rhs > +struct operator_returns_void { + // overloads of function returns_void make the difference + // yes_type and no_type have different size by construction + static ::boost::type_traits::yes_type returns_void(returns_void_t); + static ::boost::type_traits::no_type returns_void(int); + BOOST_STATIC_CONSTANT(bool, value = (sizeof(::boost::type_traits::yes_type)==sizeof(returns_void((make() BOOST_TT_TRAIT_OP make(),returns_void_t()))))); +}; + + +// 4. checks if the return type is Ret or Ret==dont_care +// conditions: Lhs!=void and Rhs!=void + +struct dont_care { }; + +template < typename Lhs, typename Rhs, typename Ret, bool Returns_void > +struct operator_returns_Ret; + +template < typename Lhs, typename Rhs > +struct operator_returns_Ret < Lhs, Rhs, dont_care, true > { + BOOST_STATIC_CONSTANT(bool, value = true); +}; + +template < typename Lhs, typename Rhs > +struct operator_returns_Ret < Lhs, Rhs, dont_care, false > { + BOOST_STATIC_CONSTANT(bool, value = true); +}; + +template < typename Lhs, typename Rhs > +struct operator_returns_Ret < Lhs, Rhs, void, true > { + BOOST_STATIC_CONSTANT(bool, value = true); +}; + +template < typename Lhs, typename Rhs > +struct operator_returns_Ret < Lhs, Rhs, void, false > { + BOOST_STATIC_CONSTANT(bool, value = false); +}; + +template < typename Lhs, typename Rhs, typename Ret > +struct operator_returns_Ret < Lhs, Rhs, Ret, true > { + BOOST_STATIC_CONSTANT(bool, value = false); +}; + +// otherwise checks if it is convertible to Ret using the sizeof trick +// based on overload resolution +// condition: Ret!=void and Ret!=dont_care and the operator does not return void +template < typename Lhs, typename Rhs, typename Ret > +struct operator_returns_Ret < Lhs, Rhs, Ret, false > { + static ::boost::type_traits::yes_type is_convertible_to_Ret(Ret); // this version is preferred for types convertible to Ret + static ::boost::type_traits::no_type is_convertible_to_Ret(...); // this version is used otherwise + + BOOST_STATIC_CONSTANT(bool, value = (sizeof(is_convertible_to_Ret(make() BOOST_TT_TRAIT_OP make()))==sizeof(::boost::type_traits::yes_type))); +}; + + +// 5. checks for operator existence +// condition: Lhs!=void and Rhs!=void + +// checks if our definition of operator BOOST_TT_TRAIT_OP is used or an other +// existing one; +// this is done with redefinition of "operator," that returns no_operator or has_operator +struct has_operator { }; +no_operator operator,(no_operator, has_operator); + +template < typename Lhs, typename Rhs > +struct operator_exists { + static ::boost::type_traits::yes_type s_check(has_operator); // this version is preferred when operator exists + static ::boost::type_traits::no_type s_check(no_operator); // this version is used otherwise + + BOOST_STATIC_CONSTANT(bool, value = (sizeof(s_check(((make() BOOST_TT_TRAIT_OP make()),make())))==sizeof(::boost::type_traits::yes_type))); +}; + + +// 6. main trait: to avoid any compilation error, this class behaves +// differently when operator BOOST_TT_TRAIT_OP(Lhs, Rhs) is forbidden by the +// standard. +// Forbidden_if is a bool that is: +// - true when the operator BOOST_TT_TRAIT_OP(Lhs, Rhs) is forbidden by the standard +// (would yield compilation error if used) +// - false otherwise +template < typename Lhs, typename Rhs, typename Ret, bool Forbidden_if > +struct trait_impl1; + +template < typename Lhs, typename Rhs, typename Ret > +struct trait_impl1 < Lhs, Rhs, Ret, true > { + BOOST_STATIC_CONSTANT(bool, value = false); +}; + +template < typename Lhs, typename Rhs, typename Ret > +struct trait_impl1 < Lhs, Rhs, Ret, false > { + BOOST_STATIC_CONSTANT(bool, + value = ( + ::boost::type_traits::ice_and< + operator_exists < Lhs, Rhs >::value, + operator_returns_Ret < Lhs, Rhs, Ret, operator_returns_void < Lhs, Rhs >::value >::value + >::value + ) + ); +}; + +// some specializations needs to be declared for the special void case +template < typename Rhs, typename Ret > +struct trait_impl1 < void, Rhs, Ret, false > { + BOOST_STATIC_CONSTANT(bool, value = false); +}; + +template < typename Lhs, typename Ret > +struct trait_impl1 < Lhs, void, Ret, false > { + BOOST_STATIC_CONSTANT(bool, value = false); +}; + +template < typename Ret > +struct trait_impl1 < void, void, Ret, false > { + BOOST_STATIC_CONSTANT(bool, value = false); +}; + +// defines some typedef for convenience +template < typename Lhs, typename Rhs, typename Ret > +struct trait_impl { + typedef typename ::boost::remove_reference::type Lhs_noref; + typedef typename ::boost::remove_reference::type Rhs_noref; + typedef typename ::boost::remove_cv::type Lhs_nocv; + typedef typename ::boost::remove_cv::type Rhs_nocv; + typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer::type >::type >::type Lhs_noptr; + typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer::type >::type >::type Rhs_noptr; + BOOST_STATIC_CONSTANT(bool, value = (trait_impl1 < Lhs_noref, Rhs_noref, Ret, BOOST_TT_FORBIDDEN_IF >::value)); +}; + +} // namespace impl +} // namespace detail + +// this is the accessible definition of the trait to end user +BOOST_TT_AUX_BOOL_TRAIT_DEF3(BOOST_TT_TRAIT_NAME, Lhs, Rhs=Lhs, Ret=::boost::detail::BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl)::dont_care, (::boost::detail::BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl)::trait_impl < Lhs, Rhs, Ret >::value)) + +} // namespace boost + +#if defined(BOOST_MSVC) +# pragma warning ( pop ) +#endif + +#include diff --git a/realsense-file/3rd_party/boost/boost/type_traits/detail/ice_and.hpp b/realsense-file/3rd_party/boost/boost/type_traits/detail/ice_and.hpp new file mode 100644 index 0000000000..0e34477485 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/type_traits/detail/ice_and.hpp @@ -0,0 +1,35 @@ +// (C) Copyright John Maddock and Steve Cleary 2000. +// +// Use, modification and distribution are subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_DETAIL_ICE_AND_HPP_INCLUDED +#define BOOST_TT_DETAIL_ICE_AND_HPP_INCLUDED + +#include "../config.hpp" + +namespace boost { +namespace type_traits { + +template +struct ice_and; + +template +struct ice_and +{ + BOOST_STATIC_CONSTANT(bool, value = false); +}; + +template <> +struct ice_and +{ + BOOST_STATIC_CONSTANT(bool, value = true); +}; + +} // namespace type_traits +} // namespace boost + +#endif // BOOST_TT_DETAIL_ICE_AND_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/type_traits/detail/ice_eq.hpp b/realsense-file/3rd_party/boost/boost/type_traits/detail/ice_eq.hpp new file mode 100644 index 0000000000..d872c8fc91 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/type_traits/detail/ice_eq.hpp @@ -0,0 +1,36 @@ +// (C) Copyright John Maddock and Steve Cleary 2000. +// Use, modification and distribution are subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_DETAIL_ICE_EQ_HPP_INCLUDED +#define BOOST_TT_DETAIL_ICE_EQ_HPP_INCLUDED + +#include "../config.hpp" + +namespace boost { +namespace type_traits { + +template +struct ice_eq +{ + BOOST_STATIC_CONSTANT(bool, value = (b1 == b2)); +}; + +template +struct ice_ne +{ + BOOST_STATIC_CONSTANT(bool, value = (b1 != b2)); +}; + +#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION +template bool const ice_eq::value; +template bool const ice_ne::value; +#endif + +} // namespace type_traits +} // namespace boost + +#endif // BOOST_TT_DETAIL_ICE_EQ_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/type_traits/detail/ice_not.hpp b/realsense-file/3rd_party/boost/boost/type_traits/detail/ice_not.hpp new file mode 100644 index 0000000000..53131745d8 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/type_traits/detail/ice_not.hpp @@ -0,0 +1,31 @@ +// (C) Copyright John Maddock and Steve Cleary 2000. +// Use, modification and distribution are subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_DETAIL_ICE_NOT_HPP_INCLUDED +#define BOOST_TT_DETAIL_ICE_NOT_HPP_INCLUDED + +#include "../config.hpp" + +namespace boost { +namespace type_traits { + +template +struct ice_not +{ + BOOST_STATIC_CONSTANT(bool, value = true); +}; + +template <> +struct ice_not +{ + BOOST_STATIC_CONSTANT(bool, value = false); +}; + +} // namespace type_traits +} // namespace boost + +#endif // BOOST_TT_DETAIL_ICE_NOT_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/type_traits/detail/ice_or.hpp b/realsense-file/3rd_party/boost/boost/type_traits/detail/ice_or.hpp new file mode 100644 index 0000000000..4d14c60fa7 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/type_traits/detail/ice_or.hpp @@ -0,0 +1,34 @@ +// (C) Copyright John Maddock and Steve Cleary 2000. +// Use, modification and distribution are subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_DETAIL_ICE_OR_HPP_INCLUDED +#define BOOST_TT_DETAIL_ICE_OR_HPP_INCLUDED + +#include "../config.hpp" + +namespace boost { +namespace type_traits { + +template +struct ice_or; + +template +struct ice_or +{ + BOOST_STATIC_CONSTANT(bool, value = true); +}; + +template <> +struct ice_or +{ + BOOST_STATIC_CONSTANT(bool, value = false); +}; + +} // namespace type_traits +} // namespace boost + +#endif // BOOST_TT_DETAIL_ICE_OR_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/type_traits/detail/is_function_ptr_tester.hpp b/realsense-file/3rd_party/boost/boost/type_traits/detail/is_function_ptr_tester.hpp new file mode 100644 index 0000000000..de68663b70 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/type_traits/detail/is_function_ptr_tester.hpp @@ -0,0 +1,440 @@ + +// (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, +// Aleksey Gurtovoy, Howard Hinnant & John Maddock 2000. +// Use, modification and distribution are subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#if !defined(BOOST_PP_IS_ITERATING) + +///// header body + +#ifndef BOOST_TT_DETAIL_IS_FUNCTION_PTR_TESTER_HPP_INCLUDED +#define BOOST_TT_DETAIL_IS_FUNCTION_PTR_TESTER_HPP_INCLUDED + +#include +#include + +#if defined(BOOST_TT_PREPROCESSING_MODE) +# include +# include +# include +#endif + +namespace boost { +namespace type_traits { + +// Note it is acceptable to use ellipsis here, since the argument will +// always be a pointer type of some sort (JM 2005/06/04): +no_type BOOST_TT_DECL is_function_ptr_tester(...); + +#if !defined(BOOST_TT_PREPROCESSING_MODE) +// pre-processed code, don't edit, try GNU cpp with +// cpp -I../../../ -DBOOST_TT_PREPROCESSING_MODE -x c++ -P filename + +template +yes_type is_function_ptr_tester(R (*)()); +template +yes_type is_function_ptr_tester(R (*)( ...)); +#ifdef BOOST_TT_TEST_MS_FUNC_SIGS +template +yes_type is_function_ptr_tester(R (__stdcall*)()); +#ifndef _MANAGED +template +yes_type is_function_ptr_tester(R (__fastcall*)()); +#endif +template +yes_type is_function_ptr_tester(R (__cdecl*)()); +#endif +template +yes_type is_function_ptr_tester(R (*)( T0)); +template +yes_type is_function_ptr_tester(R (*)( T0 ...)); +#ifdef BOOST_TT_TEST_MS_FUNC_SIGS +template +yes_type is_function_ptr_tester(R (__stdcall*)( T0)); +#ifndef _MANAGED +template +yes_type is_function_ptr_tester(R (__fastcall*)( T0)); +#endif +template +yes_type is_function_ptr_tester(R (__cdecl*)( T0)); +#endif +template +yes_type is_function_ptr_tester(R (*)( T0 , T1)); +template +yes_type is_function_ptr_tester(R (*)( T0 , T1 ...)); +#ifdef BOOST_TT_TEST_MS_FUNC_SIGS +template +yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1)); +#ifndef _MANAGED +template +yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1)); +#endif +template +yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1)); +#endif +template +yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2)); +template +yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 ...)); +#ifdef BOOST_TT_TEST_MS_FUNC_SIGS +template +yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2)); +#ifndef _MANAGED +template +yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2)); +#endif +template +yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2)); +#endif +template +yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3)); +template +yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 ...)); +#ifdef BOOST_TT_TEST_MS_FUNC_SIGS +template +yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3)); +#ifndef _MANAGED +template +yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3)); +#endif +template +yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3)); +#endif +template +yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4)); +template +yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 ...)); +#ifdef BOOST_TT_TEST_MS_FUNC_SIGS +template +yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4)); +#ifndef _MANAGED +template +yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4)); +#endif +template +yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4)); +#endif +template +yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5)); +template +yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 ...)); +#ifdef BOOST_TT_TEST_MS_FUNC_SIGS +template +yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5)); +#ifndef _MANAGED +template +yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5)); +#endif +template +yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5)); +#endif +template +yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6)); +template +yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...)); +#ifdef BOOST_TT_TEST_MS_FUNC_SIGS +template +yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6)); +#ifndef _MANAGED +template +yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6)); +#endif +template +yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6)); +#endif +template +yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7)); +template +yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...)); +#ifdef BOOST_TT_TEST_MS_FUNC_SIGS +template +yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7)); +#ifndef _MANAGED +template +yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7)); +#endif +template +yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7)); +#endif +template +yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8)); +template +yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...)); +#ifdef BOOST_TT_TEST_MS_FUNC_SIGS +template +yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8)); +#ifndef _MANAGED +template +yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8)); +#endif +template +yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8)); +#endif +template +yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9)); +template +yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...)); +#ifdef BOOST_TT_TEST_MS_FUNC_SIGS +template +yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9)); +#ifndef _MANAGED +template +yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9)); +#endif +template +yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9)); +#endif +template +yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10)); +template +yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...)); +#ifdef BOOST_TT_TEST_MS_FUNC_SIGS +template +yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10)); +#ifndef _MANAGED +template +yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10)); +#endif +template +yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10)); +#endif +template +yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11)); +template +yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...)); +#ifdef BOOST_TT_TEST_MS_FUNC_SIGS +template +yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11)); +#ifndef _MANAGED +template +yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11)); +#endif +template +yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11)); +#endif +template +yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12)); +template +yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...)); +#ifdef BOOST_TT_TEST_MS_FUNC_SIGS +template +yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12)); +#ifndef _MANAGED +template +yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12)); +#endif +template +yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12)); +#endif +template +yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13)); +template +yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...)); +#ifdef BOOST_TT_TEST_MS_FUNC_SIGS +template +yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13)); +#ifndef _MANAGED +template +yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13)); +#endif +template +yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13)); +#endif +template +yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14)); +template +yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...)); +#ifdef BOOST_TT_TEST_MS_FUNC_SIGS +template +yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14)); +#ifndef _MANAGED +template +yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14)); +#endif +template +yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14)); +#endif +template +yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15)); +template +yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...)); +#ifdef BOOST_TT_TEST_MS_FUNC_SIGS +template +yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15)); +#ifndef _MANAGED +template +yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15)); +#endif +template +yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15)); +#endif +template +yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16)); +template +yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...)); +#ifdef BOOST_TT_TEST_MS_FUNC_SIGS +template +yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16)); +#ifndef _MANAGED +template +yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16)); +#endif +template +yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16)); +#endif +template +yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17)); +template +yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...)); +#ifdef BOOST_TT_TEST_MS_FUNC_SIGS +template +yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17)); +#ifndef _MANAGED +template +yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17)); +#endif +template +yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17)); +#endif +template +yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18)); +template +yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...)); +#ifdef BOOST_TT_TEST_MS_FUNC_SIGS +template +yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18)); +#ifndef _MANAGED +template +yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18)); +#endif +template +yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18)); +#endif +template +yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19)); +template +yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...)); +#ifdef BOOST_TT_TEST_MS_FUNC_SIGS +template +yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19)); +#ifndef _MANAGED +template +yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19)); +#endif +template +yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19)); +#endif +template +yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20)); +template +yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...)); +#ifdef BOOST_TT_TEST_MS_FUNC_SIGS +template +yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20)); +#ifndef _MANAGED +template +yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20)); +#endif +template +yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20)); +#endif +template +yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21)); +template +yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...)); +#ifdef BOOST_TT_TEST_MS_FUNC_SIGS +template +yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21)); +#ifndef _MANAGED +template +yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21)); +#endif +template +yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21)); +#endif +template +yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22)); +template +yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...)); +#ifdef BOOST_TT_TEST_MS_FUNC_SIGS +template +yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22)); +#ifndef _MANAGED +template +yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22)); +#endif +template +yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22)); +#endif +template +yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23)); +template +yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...)); +#ifdef BOOST_TT_TEST_MS_FUNC_SIGS +template +yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23)); +#ifndef _MANAGED +template +yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23)); +#endif +template +yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23)); +#endif +template +yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24)); +template +yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...)); +#ifdef BOOST_TT_TEST_MS_FUNC_SIGS +template +yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24)); +#ifndef _MANAGED +template +yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24)); +#endif +template +yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24)); +#endif +#else + +#define BOOST_PP_ITERATION_PARAMS_1 \ + (3, (0, 25, "boost/type_traits/detail/is_function_ptr_tester.hpp")) +#include BOOST_PP_ITERATE() + +#endif // BOOST_TT_PREPROCESSING_MODE + +} // namespace type_traits +} // namespace boost + +#endif // BOOST_TT_DETAIL_IS_FUNCTION_PTR_TESTER_HPP_INCLUDED + +///// iteration + +#else +#define BOOST_PP_COUNTER BOOST_PP_FRAME_ITERATION(1) +#undef __stdcall +#undef __fastcall +#undef __cdecl + +template +yes_type is_function_ptr_tester(R (*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T))); +@#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +yes_type is_function_ptr_tester(R (*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T) ...)); +@#endif +@#ifdef BOOST_TT_TEST_MS_FUNC_SIGS +template +yes_type is_function_ptr_tester(R (__stdcall*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T))); +@#ifndef _MANAGED +template +yes_type is_function_ptr_tester(R (__fastcall*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T))); +@#endif +template +yes_type is_function_ptr_tester(R (__cdecl*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T))); +@#endif + +#undef BOOST_PP_COUNTER +#endif // BOOST_PP_IS_ITERATING diff --git a/realsense-file/3rd_party/boost/boost/type_traits/detail/is_mem_fun_pointer_tester.hpp b/realsense-file/3rd_party/boost/boost/type_traits/detail/is_mem_fun_pointer_tester.hpp new file mode 100644 index 0000000000..8c5ef6e437 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/type_traits/detail/is_mem_fun_pointer_tester.hpp @@ -0,0 +1,1790 @@ + +// (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, +// Aleksey Gurtovoy, Howard Hinnant & John Maddock 2000. +// Use, modification and distribution are subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#if !defined(BOOST_PP_IS_ITERATING) + +///// header body + +#ifndef BOOST_TT_DETAIL_IS_MEM_FUN_POINTER_TESTER_HPP_INCLUDED +#define BOOST_TT_DETAIL_IS_MEM_FUN_POINTER_TESTER_HPP_INCLUDED + +#include +#include + +#if defined(BOOST_TT_PREPROCESSING_MODE) +# include +# include +# include +#endif + +namespace boost { +namespace type_traits { + +no_type BOOST_TT_DECL is_mem_fun_pointer_tester(...); + +#if !defined(BOOST_TT_PREPROCESSING_MODE) +// pre-processed code, don't edit, try GNU cpp with +// cpp -I../../../ -DBOOST_TT_PREPROCESSING_MODE -x c++ -P filename + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)()); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)() const); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)() volatile); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)() const volatile); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( ...)); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( ...) const); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( ...) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( ...) const volatile); +#ifdef BOOST_TT_TEST_MS_FUNC_SIGS +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)()); + +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)() const); + +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)() volatile); + +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)() const volatile); + +#ifndef _MANAGED +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)()); + +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)() const); + +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)() volatile); + +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)() const volatile); + +#endif + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)()); + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)() const); + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)() volatile); + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)() const volatile); + +#endif +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0)); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0) const); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0) const volatile); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 ...)); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 ...) const); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 ...) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 ...) const volatile); +#ifdef BOOST_TT_TEST_MS_FUNC_SIGS +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0)); + +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0) const); + +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0) const volatile); + +#ifndef _MANAGED +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0)); + +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0) const); + +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0) const volatile); + +#endif + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0)); + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0) const); + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0) const volatile); + +#endif +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1)); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1) const); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1) const volatile); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 ...)); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 ...) const); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 ...) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 ...) const volatile); +#ifdef BOOST_TT_TEST_MS_FUNC_SIGS +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1)); + +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1) const); + +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1) const volatile); + +#ifndef _MANAGED +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1)); + +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1) const); + +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1) const volatile); + +#endif + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1)); + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1) const); + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1) const volatile); + +#endif +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2)); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2) const); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2) const volatile); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 ...)); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 ...) const); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 ...) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 ...) const volatile); +#ifdef BOOST_TT_TEST_MS_FUNC_SIGS +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2)); + +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2) const); + +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2) const volatile); + +#ifndef _MANAGED +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2)); + +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2) const); + +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2) const volatile); + +#endif + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2)); + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2) const); + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2) const volatile); + +#endif +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3)); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3) const); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3) const volatile); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 ...)); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 ...) const); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 ...) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 ...) const volatile); +#ifdef BOOST_TT_TEST_MS_FUNC_SIGS +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3)); + +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3) const); + +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3) const volatile); + +#ifndef _MANAGED +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3)); + +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3) const); + +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3) const volatile); + +#endif + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3)); + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3) const); + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3) const volatile); + +#endif +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4)); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4) const); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4) const volatile); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 ...)); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 ...) const); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 ...) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 ...) const volatile); +#ifdef BOOST_TT_TEST_MS_FUNC_SIGS +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4)); + +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4) const); + +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4) const volatile); + +#ifndef _MANAGED +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4)); + +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4) const); + +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4) const volatile); + +#endif + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4)); + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4) const); + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4) const volatile); + +#endif +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5)); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5) const); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5) const volatile); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 ...)); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 ...) const); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 ...) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 ...) const volatile); +#ifdef BOOST_TT_TEST_MS_FUNC_SIGS +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5)); + +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5) const); + +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5) const volatile); + +#ifndef _MANAGED +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5)); + +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5) const); + +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5) const volatile); + +#endif + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5)); + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5) const); + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5) const volatile); + +#endif +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6)); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) const); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) const volatile); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...)); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) const); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) const volatile); + +#ifdef BOOST_TT_TEST_MS_FUNC_SIGS +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6)); + +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) const); + +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) const volatile); + +#ifndef _MANAGED +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6)); + +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) const); + +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) const volatile); + +#endif + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6)); + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) const); + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) const volatile); + +#endif +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7)); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) const); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) const volatile); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...)); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) const); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) const volatile); +#ifdef BOOST_TT_TEST_MS_FUNC_SIGS +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7)); + +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) const); + +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) const volatile); + +#ifndef _MANAGED +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7)); + +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) const); + +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) const volatile); + +#endif + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7)); + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) const); + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) const volatile); + +#endif +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8)); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) const); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) const volatile); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...)); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) const); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) const volatile); +#ifdef BOOST_TT_TEST_MS_FUNC_SIGS +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8)); + +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) const); + +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) const volatile); + +#ifndef _MANAGED +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8)); + +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) const); + +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) const volatile); + +#endif + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8)); + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) const); + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) const volatile); + +#endif +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9)); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) const); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) const volatile); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...)); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) const); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) const volatile); +#ifdef BOOST_TT_TEST_MS_FUNC_SIGS +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9)); + +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) const); + +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) const volatile); + +#ifndef _MANAGED +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9)); + +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) const); + +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) const volatile); + +#endif + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9)); + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) const); + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) const volatile); + +#endif +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10)); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) const); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) const volatile); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...)); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) const); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) const volatile); +#ifdef BOOST_TT_TEST_MS_FUNC_SIGS +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10)); + +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) const); + +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) const volatile); + +#ifndef _MANAGED +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10)); + +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) const); + +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) const volatile); + +#endif + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10)); + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) const); + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) const volatile); + +#endif +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11)); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) const); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) const volatile); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...)); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) const); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) const volatile); +#ifdef BOOST_TT_TEST_MS_FUNC_SIGS +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11)); + +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) const); + +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) const volatile); + +#ifndef _MANAGED +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11)); + +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) const); + +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) const volatile); + +#endif + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11)); + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) const); + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) const volatile); + +#endif +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12)); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) const); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) const volatile); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...)); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) const); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) const volatile); +#ifdef BOOST_TT_TEST_MS_FUNC_SIGS +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12)); + +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) const); + +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) const volatile); + +#ifndef _MANAGED +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12)); + +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) const); + +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) const volatile); + +#endif + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12)); + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) const); + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) const volatile); + +#endif +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13)); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) const); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) const volatile); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...)); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) const); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) const volatile); +#ifdef BOOST_TT_TEST_MS_FUNC_SIGS +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13)); + +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) const); + +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) const volatile); + +#ifndef _MANAGED +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13)); + +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) const); + +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) const volatile); + +#endif + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13)); + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) const); + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) const volatile); + +#endif +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14)); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) const); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) const volatile); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...)); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) const); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) const volatile); +#ifdef BOOST_TT_TEST_MS_FUNC_SIGS +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14)); + +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) const); + +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) const volatile); + +#ifndef _MANAGED +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14)); + +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) const); + +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) const volatile); + +#endif + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14)); + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) const); + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) const volatile); + +#endif +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15)); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) const); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) const volatile); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...)); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) const); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) const volatile); +#ifdef BOOST_TT_TEST_MS_FUNC_SIGS +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15)); + +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) const); + +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) const volatile); + +#ifndef _MANAGED +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15)); + +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) const); + +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) const volatile); + +#endif + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15)); + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) const); + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) const volatile); + +#endif +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16)); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) const); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) const volatile); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...)); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) const); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) const volatile); +#ifdef BOOST_TT_TEST_MS_FUNC_SIGS +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16)); + +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) const); + +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) const volatile); + +#ifndef _MANAGED +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16)); + +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) const); + +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) const volatile); + +#endif + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16)); + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) const); + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) const volatile); + +#endif +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17)); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) const); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) const volatile); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...)); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) const); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) const volatile); +#ifdef BOOST_TT_TEST_MS_FUNC_SIGS +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17)); + +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) const); + +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) const volatile); + +#ifndef _MANAGED +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17)); + +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) const); + +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) const volatile); + +#endif + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17)); + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) const); + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) const volatile); + +#endif +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18)); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) const); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) const volatile); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...)); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) const); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) const volatile); +#ifdef BOOST_TT_TEST_MS_FUNC_SIGS +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18)); + +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) const); + +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) const volatile); + +#ifndef _MANAGED +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18)); + +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) const); + +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) const volatile); + +#endif + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18)); + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) const); + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) const volatile); + +#endif +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19)); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) const); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) const volatile); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...)); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) const); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) const volatile); +#ifdef BOOST_TT_TEST_MS_FUNC_SIGS +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19)); + +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) const); + +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) const volatile); + +#ifndef _MANAGED +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19)); + +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) const); + +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) const volatile); + +#endif + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19)); + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) const); + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) const volatile); + +#endif +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20)); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) const); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) const volatile); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...)); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) const); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) const volatile); +#ifdef BOOST_TT_TEST_MS_FUNC_SIGS +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20)); + +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) const); + +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) const volatile); + +#ifndef _MANAGED +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20)); + +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) const); + +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) const volatile); + +#endif + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20)); + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) const); + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) const volatile); + +#endif +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21)); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) const); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) const volatile); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...)); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) const); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) const volatile); +#ifdef BOOST_TT_TEST_MS_FUNC_SIGS +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21)); + +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) const); + +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) const volatile); + +#ifndef _MANAGED +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21)); + +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) const); + +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) const volatile); + +#endif + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21)); + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) const); + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) const volatile); + +#endif +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22)); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) const); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) const volatile); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...)); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) const); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) const volatile); +#ifdef BOOST_TT_TEST_MS_FUNC_SIGS +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22)); + +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) const); + +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) const volatile); + +#ifndef _MANAGED +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22)); + +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) const); + +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) const volatile); + +#endif + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22)); + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) const); + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) const volatile); + +#endif +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23)); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) const); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) const volatile); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...)); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) const); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) const volatile); +#ifdef BOOST_TT_TEST_MS_FUNC_SIGS +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23)); + +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) const); + +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) const volatile); + +#ifndef _MANAGED +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23)); + +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) const); + +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) const volatile); + +#endif + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23)); + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) const); + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) const volatile); + +#endif +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24)); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) const); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) const volatile); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...)); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) const); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) const volatile); +#ifdef BOOST_TT_TEST_MS_FUNC_SIGS +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24)); + +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) const); + +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) const volatile); + +#ifndef _MANAGED +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24)); + +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) const); + +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) const volatile); + +#endif + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24)); + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) const); + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) const volatile); + +#endif + +#else + +#define BOOST_PP_ITERATION_PARAMS_1 \ + (3, (0, 25, "boost/type_traits/detail/is_mem_fun_pointer_tester.hpp")) +#include BOOST_PP_ITERATE() + +#endif // BOOST_TT_PREPROCESSING_MODE + +} // namespace type_traits +} // namespace boost + +#endif // BOOST_TT_DETAIL_IS_MEM_FUN_POINTER_TESTER_HPP_INCLUDED + +///// iteration + +#else +#define BOOST_PP_COUNTER BOOST_PP_FRAME_ITERATION(1) +#undef __stdcall +#undef __fastcall +#undef __cdecl + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T))); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T)) const); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T)) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T)) const volatile); + +@#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T) ...)); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T) ...) const); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T) ...) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T) ...) const volatile); +@#endif +@#ifdef BOOST_TT_TEST_MS_FUNC_SIGS // Other calling conventions used by MS compatible compilers: +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T))); + +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T)) const); + +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T)) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T)) const volatile); + +@#ifndef _MANAGED +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T))); + +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T)) const); + +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T)) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T)) const volatile); + +@#endif + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T))); + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T)) const); + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T)) volatile); + +template +yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T)) const volatile); + +@#endif + +#undef BOOST_PP_COUNTER +#endif // BOOST_PP_IS_ITERATING diff --git a/realsense-file/3rd_party/boost/boost/type_traits/detail/size_t_trait_def.hpp b/realsense-file/3rd_party/boost/boost/type_traits/detail/size_t_trait_def.hpp new file mode 100644 index 0000000000..1dfd05943c --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/type_traits/detail/size_t_trait_def.hpp @@ -0,0 +1,51 @@ + +// NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION + +// Copyright Aleksey Gurtovoy 2002-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// $Source$ +// $Date$ +// $Revision$ + +#include +#include +#include +#include + +#include + +// Obsolete. Remove. +#define BOOST_TT_AUX_SIZE_T_BASE(C) public ::boost::integral_constant +#define BOOST_TT_AUX_SIZE_T_TRAIT_VALUE_DECL(C) /**/ + + +#define BOOST_TT_AUX_SIZE_T_TRAIT_DEF1(trait,T,C) \ +template< typename T > struct trait \ + : public ::boost::integral_constant \ +{ \ +public:\ + BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) \ +}; \ +\ +BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait) \ +/**/ + +#define BOOST_TT_AUX_SIZE_T_TRAIT_SPEC1(trait,spec,C) \ +template<> struct trait \ + : public ::boost::integral_constant \ +{ \ +public:\ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(spec)) \ +}; \ +/**/ + +#define BOOST_TT_AUX_SIZE_T_TRAIT_PARTIAL_SPEC1_1(param,trait,spec,C) \ +template< param > struct trait \ + : public ::boost::integral_constant \ +{ \ +}; \ +/**/ diff --git a/realsense-file/3rd_party/boost/boost/type_traits/detail/size_t_trait_undef.hpp b/realsense-file/3rd_party/boost/boost/type_traits/detail/size_t_trait_undef.hpp new file mode 100644 index 0000000000..81873410bc --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/type_traits/detail/size_t_trait_undef.hpp @@ -0,0 +1,16 @@ + +// NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION + +// Copyright Aleksey Gurtovoy 2002-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// $Source$ +// $Date$ +// $Revision$ + +#undef BOOST_TT_AUX_SIZE_T_TRAIT_DEF1 +#undef BOOST_TT_AUX_SIZE_T_TRAIT_SPEC1 +#undef BOOST_TT_AUX_SIZE_T_TRAIT_PARTIAL_SPEC1_1 diff --git a/realsense-file/3rd_party/boost/boost/type_traits/detail/template_arity_spec.hpp b/realsense-file/3rd_party/boost/boost/type_traits/detail/template_arity_spec.hpp new file mode 100644 index 0000000000..01adfe2723 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/type_traits/detail/template_arity_spec.hpp @@ -0,0 +1,31 @@ + +// NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION + +// Copyright Aleksey Gurtovoy 2002-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include "boost/mpl/int.hpp" +#include "boost/mpl/aux_/template_arity_fwd.hpp" +#include "boost/mpl/aux_/preprocessor/params.hpp" +#include "boost/mpl/aux_/config/lambda.hpp" +#include "boost/mpl/aux_/config/overload_resolution.hpp" + +#if defined(BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT) \ + && defined(BOOST_MPL_CFG_BROKEN_OVERLOAD_RESOLUTION) +# define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i, name) \ +namespace mpl { namespace aux { \ +template< BOOST_MPL_PP_PARAMS(i, typename T) > \ +struct template_arity< \ + name< BOOST_MPL_PP_PARAMS(i, T) > \ + > \ + : int_ \ +{ \ +}; \ +}} \ +/**/ +#else +# define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i, name) /**/ +#endif diff --git a/realsense-file/3rd_party/boost/boost/type_traits/detail/type_trait_def.hpp b/realsense-file/3rd_party/boost/boost/type_traits/detail/type_trait_def.hpp new file mode 100644 index 0000000000..f99eb8daac --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/type_traits/detail/type_trait_def.hpp @@ -0,0 +1,68 @@ + +// NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION + +// Copyright Aleksey Gurtovoy 2002-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// $Source$ +// $Date$ +// $Revision$ + +#include +#include "boost/type_traits/detail/template_arity_spec.hpp" +#include "boost/mpl/aux_/lambda_support.hpp" + +#define BOOST_TT_AUX_TYPE_TRAIT_DEF1(trait,T,result) \ +template< typename T > struct trait \ +{ \ +public:\ + typedef result type; \ + BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) \ +}; \ +\ +BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait) \ +/**/ + +#define BOOST_TT_AUX_TYPE_TRAIT_SPEC1(trait,spec,result) \ +template<> struct trait \ +{ \ +public:\ + typedef result type; \ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(spec)) \ +}; \ +/**/ + +#define BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1(trait,spec,result) \ +template<> struct trait##_impl \ +{ \ +public:\ + typedef result type; \ +}; \ +/**/ + +#define BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(param,trait,spec,result) \ +template< param > struct trait \ +{ \ +public:\ + typedef result type; \ +}; \ +/**/ + +#define BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,spec,result) \ +template< param1, param2 > struct trait \ +{ \ +public:\ + typedef result; \ +}; \ +/**/ + +#define BOOST_TT_AUX_TYPE_TRAIT_IMPL_PARTIAL_SPEC1_1(param,trait,spec,result) \ +template< param > struct trait##_impl \ +{ \ +public:\ + typedef result type; \ +}; \ +/**/ diff --git a/realsense-file/3rd_party/boost/boost/type_traits/detail/type_trait_undef.hpp b/realsense-file/3rd_party/boost/boost/type_traits/detail/type_trait_undef.hpp new file mode 100644 index 0000000000..840fc079cf --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/type_traits/detail/type_trait_undef.hpp @@ -0,0 +1,19 @@ + +// NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION + +// Copyright Aleksey Gurtovoy 2002-2004 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// $Source$ +// $Date$ +// $Revision$ + +#undef BOOST_TT_AUX_TYPE_TRAIT_DEF1 +#undef BOOST_TT_AUX_TYPE_TRAIT_SPEC1 +#undef BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1 +#undef BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1 +#undef BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2 +#undef BOOST_TT_AUX_TYPE_TRAIT_IMPL_PARTIAL_SPEC1_1 diff --git a/realsense-file/3rd_party/boost/boost/type_traits/detail/yes_no_type.hpp b/realsense-file/3rd_party/boost/boost/type_traits/detail/yes_no_type.hpp new file mode 100644 index 0000000000..f62087fe66 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/type_traits/detail/yes_no_type.hpp @@ -0,0 +1,26 @@ + +// (C) Copyright John Maddock and Steve Cleary 2000. +// Use, modification and distribution are subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. +// +// macros and helpers for working with integral-constant-expressions. + +#ifndef BOOST_TT_DETAIL_YES_NO_TYPE_HPP_INCLUDED +#define BOOST_TT_DETAIL_YES_NO_TYPE_HPP_INCLUDED + +namespace boost { +namespace type_traits { + +typedef char yes_type; +struct no_type +{ + char padding[8]; +}; + +} // namespace type_traits +} // namespace boost + +#endif // BOOST_TT_DETAIL_YES_NO_TYPE_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/type_traits/has_minus.hpp b/realsense-file/3rd_party/boost/boost/type_traits/has_minus.hpp new file mode 100644 index 0000000000..2975fd36f5 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/type_traits/has_minus.hpp @@ -0,0 +1,60 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// +// Use, modification and distribution are subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_HAS_MINUS_HPP_INCLUDED +#define BOOST_TT_HAS_MINUS_HPP_INCLUDED + +#define BOOST_TT_TRAIT_NAME has_minus +#define BOOST_TT_TRAIT_OP - +#define BOOST_TT_FORBIDDEN_IF\ + ::boost::type_traits::ice_or<\ + /* Lhs==pointer and Rhs==fundamental and Rhs!=integral */\ + ::boost::type_traits::ice_and<\ + ::boost::is_pointer< Lhs_noref >::value,\ + ::boost::is_fundamental< Rhs_nocv >::value,\ + ::boost::type_traits::ice_not< ::boost::is_integral< Rhs_noref >::value >::value\ + >::value,\ + /* Lhs==void* and (Rhs==fundamental or Rhs==pointer) */\ + ::boost::type_traits::ice_and<\ + ::boost::is_pointer< Lhs_noref >::value,\ + ::boost::is_void< Lhs_noptr >::value,\ + ::boost::type_traits::ice_or<\ + ::boost::is_fundamental< Rhs_nocv >::value,\ + ::boost::is_pointer< Rhs_noref >::value\ + >::value\ + >::value,\ + /* Rhs==void* and (Lhs==fundamental or Lhs==pointer) */\ + ::boost::type_traits::ice_and<\ + ::boost::is_pointer< Rhs_noref >::value,\ + ::boost::is_void< Rhs_noptr >::value,\ + ::boost::type_traits::ice_or<\ + ::boost::is_fundamental< Lhs_nocv >::value,\ + ::boost::is_pointer< Lhs_noref >::value\ + >::value\ + >::value,\ + /* Lhs=fundamental and Rhs=pointer */\ + ::boost::type_traits::ice_and<\ + ::boost::is_fundamental< Lhs_nocv >::value,\ + ::boost::is_pointer< Rhs_noref >::value\ + >::value,\ + /* two different pointers */\ + ::boost::type_traits::ice_and<\ + ::boost::is_pointer< Lhs_noref >::value,\ + ::boost::is_pointer< Rhs_noref >::value,\ + ::boost::type_traits::ice_not< ::boost::is_same< Lhs_nocv, Rhs_nocv >::value >::value\ + >::value\ + >::value + + +#include + +#undef BOOST_TT_TRAIT_NAME +#undef BOOST_TT_TRAIT_OP +#undef BOOST_TT_FORBIDDEN_IF + +#endif diff --git a/realsense-file/3rd_party/boost/boost/type_traits/has_minus_assign.hpp b/realsense-file/3rd_party/boost/boost/type_traits/has_minus_assign.hpp new file mode 100644 index 0000000000..9644278412 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/type_traits/has_minus_assign.hpp @@ -0,0 +1,65 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// +// Use, modification and distribution are subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_HAS_MINUS_ASSIGN_HPP_INCLUDED +#define BOOST_TT_HAS_MINUS_ASSIGN_HPP_INCLUDED + +#define BOOST_TT_TRAIT_NAME has_minus_assign +#define BOOST_TT_TRAIT_OP -= +#define BOOST_TT_FORBIDDEN_IF\ + ::boost::type_traits::ice_or<\ + /* Lhs==pointer and Rhs==fundamental and Rhs!=integral */\ + ::boost::type_traits::ice_and<\ + ::boost::is_pointer< Lhs_noref >::value,\ + ::boost::is_fundamental< Rhs_nocv >::value,\ + ::boost::type_traits::ice_not< ::boost::is_integral< Rhs_noref >::value >::value\ + >::value,\ + /* Lhs==void* and Rhs==fundamental */\ + ::boost::type_traits::ice_and<\ + ::boost::is_pointer< Lhs_noref >::value,\ + ::boost::is_void< Lhs_noptr >::value,\ + ::boost::is_fundamental< Rhs_nocv >::value\ + >::value,\ + /* Rhs==void* and Lhs==fundamental */\ + ::boost::type_traits::ice_and<\ + ::boost::is_pointer< Rhs_noref >::value,\ + ::boost::is_void< Rhs_noptr >::value,\ + ::boost::is_fundamental< Lhs_nocv >::value\ + >::value,\ + /* Lhs=fundamental and Rhs=pointer */\ + ::boost::type_traits::ice_and<\ + ::boost::is_fundamental< Lhs_nocv >::value,\ + ::boost::is_pointer< Rhs_noref >::value\ + >::value,\ + /* Lhs==pointer and Rhs==pointer */\ + ::boost::type_traits::ice_and<\ + ::boost::is_pointer< Lhs_noref >::value,\ + ::boost::is_pointer< Rhs_noref >::value\ + >::value,\ + /* (Lhs==fundamental or Lhs==pointer) and (Rhs==fundamental or Rhs==pointer) and (Lhs==const) */\ + ::boost::type_traits::ice_and<\ + ::boost::type_traits::ice_or<\ + ::boost::is_fundamental< Lhs_nocv >::value,\ + ::boost::is_pointer< Lhs_noref >::value\ + >::value,\ + ::boost::type_traits::ice_or<\ + ::boost::is_fundamental< Rhs_nocv >::value,\ + ::boost::is_pointer< Rhs_noref >::value\ + >::value,\ + ::boost::is_const< Lhs_noref >::value\ + >::value\ + >::value + + +#include + +#undef BOOST_TT_TRAIT_NAME +#undef BOOST_TT_TRAIT_OP +#undef BOOST_TT_FORBIDDEN_IF + +#endif diff --git a/realsense-file/3rd_party/boost/boost/type_traits/has_nothrow_assign.hpp b/realsense-file/3rd_party/boost/boost/type_traits/has_nothrow_assign.hpp new file mode 100644 index 0000000000..75b01027b3 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/type_traits/has_nothrow_assign.hpp @@ -0,0 +1,44 @@ + +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// Use, modification and distribution are subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_HAS_NOTHROW_ASSIGN_HPP_INCLUDED +#define BOOST_TT_HAS_NOTHROW_ASSIGN_HPP_INCLUDED + +#include + +// should be the last #include +#include + +namespace boost { + +namespace detail{ + +template +struct has_nothrow_assign_imp{ +#ifndef BOOST_HAS_NOTHROW_ASSIGN + BOOST_STATIC_CONSTANT(bool, value = ::boost::has_trivial_assign::value); +#else + BOOST_STATIC_CONSTANT(bool, value = BOOST_HAS_NOTHROW_ASSIGN(T)); +#endif +}; + +} + +BOOST_TT_AUX_BOOL_TRAIT_DEF1(has_nothrow_assign,T,::boost::detail::has_nothrow_assign_imp::value) +BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_nothrow_assign,void,false) +#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS +BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_nothrow_assign,void const,false) +BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_nothrow_assign,void const volatile,false) +BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_nothrow_assign,void volatile,false) +#endif + +} // namespace boost + +#include + +#endif // BOOST_TT_HAS_NOTHROW_ASSIGN_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/type_traits/has_nothrow_constructor.hpp b/realsense-file/3rd_party/boost/boost/type_traits/has_nothrow_constructor.hpp new file mode 100644 index 0000000000..e71b1bdc35 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/type_traits/has_nothrow_constructor.hpp @@ -0,0 +1,53 @@ + +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// Use, modification and distribution are subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_HAS_NOTHROW_CONSTRUCTOR_HPP_INCLUDED +#define BOOST_TT_HAS_NOTHROW_CONSTRUCTOR_HPP_INCLUDED + +#include + +// should be the last #include +#include + +namespace boost { + +namespace detail{ + +template +struct has_nothrow_constructor_imp{ +#ifdef BOOST_HAS_NOTHROW_CONSTRUCTOR + BOOST_STATIC_CONSTANT(bool, value = BOOST_HAS_NOTHROW_CONSTRUCTOR(T)); +#else + BOOST_STATIC_CONSTANT(bool, value = ::boost::has_trivial_constructor::value); +#endif +}; + +} + +BOOST_TT_AUX_BOOL_TRAIT_DEF1(has_nothrow_constructor,T,::boost::detail::has_nothrow_constructor_imp::value) +BOOST_TT_AUX_BOOL_TRAIT_DEF1(has_nothrow_default_constructor,T,::boost::detail::has_nothrow_constructor_imp::value) + +BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_nothrow_constructor,void,false) +#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS +BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_nothrow_constructor,void const,false) +BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_nothrow_constructor,void const volatile,false) +BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_nothrow_constructor,void volatile,false) +#endif + +BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_nothrow_default_constructor,void,false) +#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS +BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_nothrow_default_constructor,void const,false) +BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_nothrow_default_constructor,void const volatile,false) +BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_nothrow_default_constructor,void volatile,false) +#endif + +} // namespace boost + +#include + +#endif // BOOST_TT_HAS_NOTHROW_CONSTRUCTOR_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/type_traits/has_nothrow_copy.hpp b/realsense-file/3rd_party/boost/boost/type_traits/has_nothrow_copy.hpp new file mode 100644 index 0000000000..10b9dfac26 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/type_traits/has_nothrow_copy.hpp @@ -0,0 +1,53 @@ + +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// Use, modification and distribution are subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_HAS_NOTHROW_COPY_HPP_INCLUDED +#define BOOST_TT_HAS_NOTHROW_COPY_HPP_INCLUDED + +#include + +// should be the last #include +#include + +namespace boost { + +namespace detail{ + +template +struct has_nothrow_copy_imp{ +#ifdef BOOST_HAS_NOTHROW_COPY + BOOST_STATIC_CONSTANT(bool, value = BOOST_HAS_NOTHROW_COPY(T)); +#else + BOOST_STATIC_CONSTANT(bool, value = ::boost::has_trivial_copy::value); +#endif +}; + +} + +BOOST_TT_AUX_BOOL_TRAIT_DEF1(has_nothrow_copy,T,::boost::detail::has_nothrow_copy_imp::value) +BOOST_TT_AUX_BOOL_TRAIT_DEF1(has_nothrow_copy_constructor,T,::boost::detail::has_nothrow_copy_imp::value) + +BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_nothrow_copy,void,false) +#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS +BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_nothrow_copy,void const,false) +BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_nothrow_copy,void const volatile,false) +BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_nothrow_copy,void volatile,false) +#endif + +BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_nothrow_copy_constructor,void,false) +#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS +BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_nothrow_copy_constructor,void const,false) +BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_nothrow_copy_constructor,void const volatile,false) +BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_nothrow_copy_constructor,void volatile,false) +#endif + +} // namespace boost + +#include + +#endif // BOOST_TT_HAS_NOTHROW_COPY_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/type_traits/has_plus.hpp b/realsense-file/3rd_party/boost/boost/type_traits/has_plus.hpp new file mode 100644 index 0000000000..ca85dd028f --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/type_traits/has_plus.hpp @@ -0,0 +1,54 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// +// Use, modification and distribution are subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_HAS_PLUS_HPP_INCLUDED +#define BOOST_TT_HAS_PLUS_HPP_INCLUDED + +#define BOOST_TT_TRAIT_NAME has_plus +#define BOOST_TT_TRAIT_OP + +#define BOOST_TT_FORBIDDEN_IF\ + ::boost::type_traits::ice_or<\ + /* Lhs==pointer and Rhs==pointer */\ + ::boost::type_traits::ice_and<\ + ::boost::is_pointer< Lhs_noref >::value,\ + ::boost::is_pointer< Rhs_noref >::value\ + >::value,\ + /* Lhs==void* and Rhs==fundamental */\ + ::boost::type_traits::ice_and<\ + ::boost::is_pointer< Lhs_noref >::value,\ + ::boost::is_void< Lhs_noptr >::value,\ + ::boost::is_fundamental< Rhs_nocv >::value\ + >::value,\ + /* Rhs==void* and Lhs==fundamental */\ + ::boost::type_traits::ice_and<\ + ::boost::is_pointer< Rhs_noref >::value,\ + ::boost::is_void< Rhs_noptr >::value,\ + ::boost::is_fundamental< Lhs_nocv >::value\ + >::value,\ + /* Lhs==pointer and Rhs==fundamental and Rhs!=integral */\ + ::boost::type_traits::ice_and<\ + ::boost::is_pointer< Lhs_noref >::value,\ + ::boost::is_fundamental< Rhs_nocv >::value,\ + ::boost::type_traits::ice_not< ::boost::is_integral< Rhs_noref >::value >::value\ + >::value,\ + /* Rhs==pointer and Lhs==fundamental and Lhs!=integral */\ + ::boost::type_traits::ice_and<\ + ::boost::is_pointer< Rhs_noref >::value,\ + ::boost::is_fundamental< Lhs_nocv >::value,\ + ::boost::type_traits::ice_not< ::boost::is_integral< Lhs_noref >::value >::value\ + >::value\ + >::value + + +#include + +#undef BOOST_TT_TRAIT_NAME +#undef BOOST_TT_TRAIT_OP +#undef BOOST_TT_FORBIDDEN_IF + +#endif diff --git a/realsense-file/3rd_party/boost/boost/type_traits/has_plus_assign.hpp b/realsense-file/3rd_party/boost/boost/type_traits/has_plus_assign.hpp new file mode 100644 index 0000000000..7a1400c14b --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/type_traits/has_plus_assign.hpp @@ -0,0 +1,66 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// +// Use, modification and distribution are subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_HAS_PLUS_ASSIGN_HPP_INCLUDED +#define BOOST_TT_HAS_PLUS_ASSIGN_HPP_INCLUDED + +#define BOOST_TT_TRAIT_NAME has_plus_assign +#define BOOST_TT_TRAIT_OP += +#define BOOST_TT_FORBIDDEN_IF\ + ::boost::type_traits::ice_or<\ + /* Lhs==pointer and Rhs==pointer */\ + ::boost::type_traits::ice_and<\ + ::boost::is_pointer< Lhs_noref >::value,\ + ::boost::is_pointer< Rhs_noref >::value\ + >::value,\ + /* Lhs==void* and Rhs==fundamental */\ + ::boost::type_traits::ice_and<\ + ::boost::is_pointer< Lhs_noref >::value,\ + ::boost::is_void< Lhs_noptr >::value,\ + ::boost::is_fundamental< Rhs_nocv >::value\ + >::value,\ + /* Rhs==void* and Lhs==fundamental */\ + ::boost::type_traits::ice_and<\ + ::boost::is_pointer< Rhs_noref >::value,\ + ::boost::is_void< Rhs_noptr >::value,\ + ::boost::is_fundamental< Lhs_nocv >::value\ + >::value,\ + /* Lhs==pointer and Rhs==fundamental and Rhs!=integral */\ + ::boost::type_traits::ice_and<\ + ::boost::is_pointer< Lhs_noref >::value,\ + ::boost::is_fundamental< Rhs_nocv >::value,\ + ::boost::type_traits::ice_not< ::boost::is_integral< Rhs_noref >::value >::value\ + >::value,\ + /* Rhs==pointer and Lhs==fundamental and Lhs!=bool */\ + ::boost::type_traits::ice_and<\ + ::boost::is_pointer< Rhs_noref >::value,\ + ::boost::is_fundamental< Lhs_nocv >::value,\ + ::boost::type_traits::ice_not< ::boost::is_same< Lhs_nocv, bool >::value >::value\ + >::value,\ + /* (Lhs==fundamental or Lhs==pointer) and (Rhs==fundamental or Rhs==pointer) and (Lhs==const) */\ + ::boost::type_traits::ice_and<\ + ::boost::type_traits::ice_or<\ + ::boost::is_fundamental< Lhs_nocv >::value,\ + ::boost::is_pointer< Lhs_noref >::value\ + >::value,\ + ::boost::type_traits::ice_or<\ + ::boost::is_fundamental< Rhs_nocv >::value,\ + ::boost::is_pointer< Rhs_noref >::value\ + >::value,\ + ::boost::is_const< Lhs_noref >::value\ + >::value\ + >::value + + +#include + +#undef BOOST_TT_TRAIT_NAME +#undef BOOST_TT_TRAIT_OP +#undef BOOST_TT_FORBIDDEN_IF + +#endif diff --git a/realsense-file/3rd_party/boost/boost/type_traits/has_trivial_assign.hpp b/realsense-file/3rd_party/boost/boost/type_traits/has_trivial_assign.hpp new file mode 100644 index 0000000000..e47b804eaf --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/type_traits/has_trivial_assign.hpp @@ -0,0 +1,57 @@ + +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// Use, modification and distribution are subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_HAS_TRIVIAL_ASSIGN_HPP_INCLUDED +#define BOOST_TT_HAS_TRIVIAL_ASSIGN_HPP_INCLUDED + +#include +#include +#include +#include +#include +#include +#include +#include + +// should be the last #include +#include + +namespace boost { + +namespace detail { + +template +struct has_trivial_assign_impl +{ +#ifdef BOOST_HAS_TRIVIAL_ASSIGN + BOOST_STATIC_CONSTANT(bool, value = BOOST_HAS_TRIVIAL_ASSIGN(T)); +#else + BOOST_STATIC_CONSTANT(bool, value = + (::boost::type_traits::ice_and< + ::boost::is_pod::value, + ::boost::type_traits::ice_not< ::boost::is_const::value >::value, + ::boost::type_traits::ice_not< ::boost::is_volatile::value >::value + >::value)); +#endif +}; + +} // namespace detail + +BOOST_TT_AUX_BOOL_TRAIT_DEF1(has_trivial_assign,T,::boost::detail::has_trivial_assign_impl::value) +BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_trivial_assign,void,false) +#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS +BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_trivial_assign,void const,false) +BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_trivial_assign,void const volatile,false) +BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_trivial_assign,void volatile,false) +#endif + +} // namespace boost + +#include + +#endif // BOOST_TT_HAS_TRIVIAL_ASSIGN_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/type_traits/has_trivial_constructor.hpp b/realsense-file/3rd_party/boost/boost/type_traits/has_trivial_constructor.hpp new file mode 100644 index 0000000000..df6f9a0cf5 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/type_traits/has_trivial_constructor.hpp @@ -0,0 +1,51 @@ + +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// Use, modification and distribution are subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_HAS_TRIVIAL_CONSTRUCTOR_HPP_INCLUDED +#define BOOST_TT_HAS_TRIVIAL_CONSTRUCTOR_HPP_INCLUDED + +#include +#include +#include +#include + +// should be the last #include +#include + +namespace boost { + +namespace detail { + +template +struct has_trivial_ctor_impl +{ +#ifdef BOOST_HAS_TRIVIAL_CONSTRUCTOR + BOOST_STATIC_CONSTANT(bool, value = + (::boost::type_traits::ice_or< + ::boost::is_pod::value, + BOOST_HAS_TRIVIAL_CONSTRUCTOR(T) + >::value)); +#else + BOOST_STATIC_CONSTANT(bool, value = + (::boost::type_traits::ice_or< + ::boost::is_pod::value, + false + >::value)); +#endif +}; + +} // namespace detail + +BOOST_TT_AUX_BOOL_TRAIT_DEF1(has_trivial_constructor,T,::boost::detail::has_trivial_ctor_impl::value) +BOOST_TT_AUX_BOOL_TRAIT_DEF1(has_trivial_default_constructor,T,::boost::detail::has_trivial_ctor_impl::value) + +} // namespace boost + +#include + +#endif // BOOST_TT_HAS_TRIVIAL_CONSTRUCTOR_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/type_traits/has_trivial_copy.hpp b/realsense-file/3rd_party/boost/boost/type_traits/has_trivial_copy.hpp new file mode 100644 index 0000000000..509bac8219 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/type_traits/has_trivial_copy.hpp @@ -0,0 +1,82 @@ + +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// Use, modification and distribution are subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_HAS_TRIVIAL_COPY_HPP_INCLUDED +#define BOOST_TT_HAS_TRIVIAL_COPY_HPP_INCLUDED + +#include +#include +#include +#include +#include +#include +#include + +#ifdef __clang__ +#include +#endif + +// should be the last #include +#include + +namespace boost { + +namespace detail { + +template +struct has_trivial_copy_impl +{ +#ifdef BOOST_HAS_TRIVIAL_COPY +# ifdef __clang__ + BOOST_STATIC_CONSTANT(bool, value = BOOST_HAS_TRIVIAL_COPY(T) && boost::is_copy_constructible::value); +# else + BOOST_STATIC_CONSTANT(bool, value = BOOST_HAS_TRIVIAL_COPY(T)); +# endif +#else + BOOST_STATIC_CONSTANT(bool, value = + (::boost::type_traits::ice_and< + ::boost::is_pod::value, + ::boost::type_traits::ice_not< ::boost::is_volatile::value >::value + >::value)); +#endif +}; + +#ifdef __clang__ + +template +struct has_trivial_copy_impl +{ + static const bool value = has_trivial_copy_impl::value; +}; + +#endif + +} // namespace detail + +BOOST_TT_AUX_BOOL_TRAIT_DEF1(has_trivial_copy,T,::boost::detail::has_trivial_copy_impl::value) +BOOST_TT_AUX_BOOL_TRAIT_DEF1(has_trivial_copy_constructor,T,::boost::detail::has_trivial_copy_impl::value) + +BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_trivial_copy,void,false) +#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS +BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_trivial_copy,void const,false) +BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_trivial_copy,void const volatile,false) +BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_trivial_copy,void volatile,false) +#endif + +BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_trivial_copy_constructor,void,false) +#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS +BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_trivial_copy_constructor,void const,false) +BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_trivial_copy_constructor,void const volatile,false) +BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_trivial_copy_constructor,void volatile,false) +#endif + +} // namespace boost + +#include + +#endif // BOOST_TT_HAS_TRIVIAL_COPY_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/type_traits/has_trivial_destructor.hpp b/realsense-file/3rd_party/boost/boost/type_traits/has_trivial_destructor.hpp new file mode 100644 index 0000000000..f91eadebff --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/type_traits/has_trivial_destructor.hpp @@ -0,0 +1,49 @@ + +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// Use, modification and distribution are subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_HAS_TRIVIAL_DESTRUCTOR_HPP_INCLUDED +#define BOOST_TT_HAS_TRIVIAL_DESTRUCTOR_HPP_INCLUDED + +#include +#include +#include +#include + +// should be the last #include +#include + +namespace boost { + +namespace detail { + +template +struct has_trivial_dtor_impl +{ +#ifdef BOOST_HAS_TRIVIAL_DESTRUCTOR + BOOST_STATIC_CONSTANT(bool, value = BOOST_HAS_TRIVIAL_DESTRUCTOR(T)); +#else + BOOST_STATIC_CONSTANT(bool, value = ::boost::is_pod::value); +#endif +}; + +} // namespace detail + +BOOST_TT_AUX_BOOL_TRAIT_DEF1(has_trivial_destructor,T,::boost::detail::has_trivial_dtor_impl::value) + +BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_trivial_destructor,void,false) +#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS +BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_trivial_destructor,void const,false) +BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_trivial_destructor,void const volatile,false) +BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_trivial_destructor,void volatile,false) +#endif + +} // namespace boost + +#include + +#endif // BOOST_TT_HAS_TRIVIAL_DESTRUCTOR_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/type_traits/has_trivial_move_assign.hpp b/realsense-file/3rd_party/boost/boost/type_traits/has_trivial_move_assign.hpp new file mode 100644 index 0000000000..f79835adcf --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/type_traits/has_trivial_move_assign.hpp @@ -0,0 +1,57 @@ + +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// (C) Copyright Eric Friedman 2002-2003. +// (C) Copyright Antony Polukhin 2013. +// Use, modification and distribution are subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_HAS_TRIVIAL_MOVE_ASSIGN_HPP_INCLUDED +#define BOOST_TT_HAS_TRIVIAL_MOVE_ASSIGN_HPP_INCLUDED + +#include +#include +#include +#include +#include +#include + +// should be the last #include +#include + +namespace boost { + +namespace detail { + +template +struct has_trivial_move_assign_impl +{ +#ifdef BOOST_HAS_TRIVIAL_MOVE_ASSIGN + BOOST_STATIC_CONSTANT(bool, value = (BOOST_HAS_TRIVIAL_MOVE_ASSIGN(T))); +#else + BOOST_STATIC_CONSTANT(bool, value = + (::boost::type_traits::ice_and< + ::boost::is_pod::value, + ::boost::type_traits::ice_not< ::boost::is_const::value >::value, + ::boost::type_traits::ice_not< ::boost::is_volatile::value >::value + >::value)); +#endif +}; + +} // namespace detail + +BOOST_TT_AUX_BOOL_TRAIT_DEF1(has_trivial_move_assign,T,::boost::detail::has_trivial_move_assign_impl::value) +BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_trivial_move_assign,void,false) +#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS +BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_trivial_move_assign,void const,false) +BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_trivial_move_assign,void const volatile,false) +BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_trivial_move_assign,void volatile,false) +#endif + +} // namespace boost + +#include + +#endif // BOOST_TT_HAS_TRIVIAL_MOVE_ASSIGN_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/type_traits/has_trivial_move_constructor.hpp b/realsense-file/3rd_party/boost/boost/type_traits/has_trivial_move_constructor.hpp new file mode 100644 index 0000000000..89f685711a --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/type_traits/has_trivial_move_constructor.hpp @@ -0,0 +1,57 @@ + +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// (C) Copyright Eric Friedman 2002-2003. +// (C) Copyright Antony Polukhin 2013. +// Use, modification and distribution are subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_HAS_TRIVIAL_MOVE_CONSTRUCTOR_HPP_INCLUDED +#define BOOST_TT_HAS_TRIVIAL_MOVE_CONSTRUCTOR_HPP_INCLUDED + +#include +#include +#include +#include +#include +#include + +// should be the last #include +#include + +namespace boost { + +namespace detail { + +template +struct has_trivial_move_ctor_impl +{ +#ifdef BOOST_HAS_TRIVIAL_MOVE_CONSTRUCTOR + BOOST_STATIC_CONSTANT(bool, value = (BOOST_HAS_TRIVIAL_MOVE_CONSTRUCTOR(T))); +#else + BOOST_STATIC_CONSTANT(bool, value = + (::boost::type_traits::ice_and< + ::boost::is_pod::value, + ::boost::type_traits::ice_not< ::boost::is_volatile::value >::value + >::value)); +#endif +}; + +} // namespace detail + +BOOST_TT_AUX_BOOL_TRAIT_DEF1(has_trivial_move_constructor,T,::boost::detail::has_trivial_move_ctor_impl::value) + +BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_trivial_move_constructor,void,false) +#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS +BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_trivial_move_constructor,void const,false) +BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_trivial_move_constructor,void const volatile,false) +BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_trivial_move_constructor,void volatile,false) +#endif + +} // namespace boost + +#include + +#endif // BOOST_TT_HAS_TRIVIAL_MOVE_CONSTRUCTOR_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/type_traits/ice.hpp b/realsense-file/3rd_party/boost/boost/type_traits/ice.hpp new file mode 100644 index 0000000000..03909df8e0 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/type_traits/ice.hpp @@ -0,0 +1,20 @@ + +// (C) Copyright John Maddock and Steve Cleary 2000. +// Use, modification and distribution are subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. +// +// macros and helpers for working with integral-constant-expressions. + +#ifndef BOOST_TT_ICE_HPP_INCLUDED +#define BOOST_TT_ICE_HPP_INCLUDED + +#include +#include +#include +#include +#include + +#endif // BOOST_TT_ICE_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/type_traits/integral_constant.hpp b/realsense-file/3rd_party/boost/boost/type_traits/integral_constant.hpp new file mode 100644 index 0000000000..9a547c023c --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/type_traits/integral_constant.hpp @@ -0,0 +1,39 @@ +// (C) Copyright John Maddock 2005. +// Use, modification and distribution are subject to 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_TYPE_TRAITS_INTEGRAL_CONSTANT_HPP +#define BOOST_TYPE_TRAITS_INTEGRAL_CONSTANT_HPP + +#include "config.hpp" +#include "boost/mpl/bool.hpp" +#include "boost/mpl/integral_c.hpp" + +namespace boost{ + +#if defined(BOOST_NO_DEPENDENT_TYPES_IN_TEMPLATE_VALUE_PARAMETERS) || defined(__BORLANDC__) +template +#else +template +#endif +struct integral_constant : public mpl::integral_c +{ + typedef integral_constant type; +}; + +template<> struct integral_constant : public mpl::true_ +{ + typedef integral_constant type; +}; +template<> struct integral_constant : public mpl::false_ +{ + typedef integral_constant type; +}; + +typedef integral_constant true_type; +typedef integral_constant false_type; + +} + +#endif diff --git a/realsense-file/3rd_party/boost/boost/type_traits/integral_promotion.hpp b/realsense-file/3rd_party/boost/boost/type_traits/integral_promotion.hpp new file mode 100644 index 0000000000..a3a324e649 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/type_traits/integral_promotion.hpp @@ -0,0 +1,194 @@ +// Copyright 2005 Alexander Nasonov. +// 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 FILE_boost_type_traits_integral_promotion_hpp_INCLUDED +#define FILE_boost_type_traits_integral_promotion_hpp_INCLUDED + +#include + +#include +#include +#include +#include +#include +#include +#include + +// Should be the last #include +#include + +namespace boost { + +namespace type_traits { namespace detail { + +// 4.5/2 +template struct need_promotion : public boost::is_enum {}; + +// 4.5/1 +template<> struct need_promotion : public true_type {}; +template<> struct need_promotion : public true_type {}; +template<> struct need_promotion : public true_type {}; +template<> struct need_promotion : public true_type {}; +template<> struct need_promotion : public true_type {}; + + +// Specializations for non-standard types. +// Type is promoted if it's smaller then int. + +#define BOOST_TT_AUX_PROMOTE_NONSTANDARD_TYPE(T) \ + template<> struct need_promotion \ + : public integral_constant {}; + +// Same set of integral types as in boost/type_traits/is_integral.hpp. +// Please, keep in sync. +#if (defined(BOOST_INTEL_CXX_VERSION) && defined(_MSC_VER) && (BOOST_INTEL_CXX_VERSION <= 600)) \ + || (defined(__BORLANDC__) && (__BORLANDC__ == 0x600) && (_MSC_VER < 1300)) +// TODO: common macro for this #if. Or better yet, PP SEQ of non-standard types. +BOOST_TT_AUX_PROMOTE_NONSTANDARD_TYPE(__int8 ) +BOOST_TT_AUX_PROMOTE_NONSTANDARD_TYPE(unsigned __int8 ) +BOOST_TT_AUX_PROMOTE_NONSTANDARD_TYPE(__int16 ) +BOOST_TT_AUX_PROMOTE_NONSTANDARD_TYPE(unsigned __int16) +BOOST_TT_AUX_PROMOTE_NONSTANDARD_TYPE(__int32 ) +BOOST_TT_AUX_PROMOTE_NONSTANDARD_TYPE(unsigned __int32) +#ifdef __BORLANDC__ +BOOST_TT_AUX_PROMOTE_NONSTANDARD_TYPE(unsigned __int64) +BOOST_TT_AUX_PROMOTE_NONSTANDARD_TYPE( __int64) +#endif +#endif + +#if defined(BOOST_HAS_LONG_LONG) +BOOST_TT_AUX_PROMOTE_NONSTANDARD_TYPE(boost::ulong_long_type) +BOOST_TT_AUX_PROMOTE_NONSTANDARD_TYPE(boost::long_long_type ) +#elif defined(BOOST_HAS_MS_INT64) +BOOST_TT_AUX_PROMOTE_NONSTANDARD_TYPE(unsigned __int64) +BOOST_TT_AUX_PROMOTE_NONSTANDARD_TYPE( __int64) +#endif + +#undef BOOST_TT_AUX_PROMOTE_NONSTANDARD_TYPE + + +#ifndef BOOST_NO_INTRINSIC_WCHAR_T +// 4.5/2 +template<> struct need_promotion : public true_type {}; +#endif + +// 4.5/3 (integral bit-field) is not supported. + +// 4.5/4 +template<> struct need_promotion : public true_type {}; + + +// Get promoted type by index and cv qualifiers. + +template struct promote_from_index; + +#define BOOST_TT_AUX_PROMOTE_FROM_INDEX(N,T) \ + template<> struct promote_from_index { typedef T type; }; \ + template<> struct promote_from_index { typedef T volatile type; }; \ + template<> struct promote_from_index { typedef T const type; }; \ + template<> struct promote_from_index { typedef T const volatile type; }; + + +BOOST_TT_AUX_PROMOTE_FROM_INDEX(1, int ) +BOOST_TT_AUX_PROMOTE_FROM_INDEX(2, unsigned int ) +BOOST_TT_AUX_PROMOTE_FROM_INDEX(3, long ) +BOOST_TT_AUX_PROMOTE_FROM_INDEX(4, unsigned long) + + +// WARNING: integral promotions to non-standard types +// long long and __int64 are not defined by the standard. +// Additional specialisations and overloads shouldn't +// introduce ambiguity, though. + +#if defined(BOOST_HAS_LONG_LONG) +BOOST_TT_AUX_PROMOTE_FROM_INDEX(5, boost::long_long_type ) +BOOST_TT_AUX_PROMOTE_FROM_INDEX(6, boost::ulong_long_type) +#elif defined(BOOST_HAS_MS_INT64) +BOOST_TT_AUX_PROMOTE_FROM_INDEX(7, __int64 ) +BOOST_TT_AUX_PROMOTE_FROM_INDEX(8, unsigned __int64) +#endif + +#undef BOOST_TT_AUX_PROMOTE_FROM_INDEX + + +// Define BOOST_TT_AUX_PROMOTED_INDEX_TESTER: +#if !defined(BOOST_MSVC) + +template +struct sized_type_for_promotion +{ + typedef char (&type)[N]; +}; + +#define BOOST_TT_AUX_PROMOTED_INDEX_TESTER(I,T) \ + sized_type_for_promotion::type promoted_index_tester(T); + +#else + +#define BOOST_TT_AUX_PROMOTED_INDEX_TESTER(I,T) \ + char (&promoted_index_tester(T))[I]; + +#endif + +BOOST_TT_AUX_PROMOTED_INDEX_TESTER(1, int ) +BOOST_TT_AUX_PROMOTED_INDEX_TESTER(2, unsigned int ) +BOOST_TT_AUX_PROMOTED_INDEX_TESTER(3, long ) +BOOST_TT_AUX_PROMOTED_INDEX_TESTER(4, unsigned long) + +#if defined(BOOST_HAS_LONG_LONG) +BOOST_TT_AUX_PROMOTED_INDEX_TESTER(5, boost::long_long_type ) +BOOST_TT_AUX_PROMOTED_INDEX_TESTER(6, boost::ulong_long_type) +#elif defined(BOOST_HAS_MS_INT64) +BOOST_TT_AUX_PROMOTED_INDEX_TESTER(7, __int64 ) +BOOST_TT_AUX_PROMOTED_INDEX_TESTER(8, unsigned __int64) +#endif + +#undef BOOST_TT_AUX_PROMOTED_INDEX_TESTER + + +// Get an index of promoted type for type T. +// Precondition: need_promotion +template +struct promoted_index +{ + static T testee; // undefined + BOOST_STATIC_CONSTANT(int, value = sizeof(promoted_index_tester(+testee)) ); + // Unary plus promotes testee LOOK HERE ---> ^ +}; + +template +struct integral_promotion_impl +{ + typedef BOOST_DEDUCED_TYPENAME promote_from_index< + (boost::type_traits::detail::promoted_index::value) + , (boost::is_const::value) + , (boost::is_volatile::value) + >::type type; +}; + +template +struct integral_promotion + : public boost::mpl::eval_if< + need_promotion::type> + , integral_promotion_impl + , boost::mpl::identity + > +{ +}; + +} } + +BOOST_TT_AUX_TYPE_TRAIT_DEF1( + integral_promotion + , T + , BOOST_DEDUCED_TYPENAME + boost::type_traits::detail::integral_promotion::type + ) +} + +#include + +#endif // #ifndef FILE_boost_type_traits_integral_promotion_hpp_INCLUDED + diff --git a/realsense-file/3rd_party/boost/boost/type_traits/intrinsics.hpp b/realsense-file/3rd_party/boost/boost/type_traits/intrinsics.hpp new file mode 100644 index 0000000000..971f142da9 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/type_traits/intrinsics.hpp @@ -0,0 +1,348 @@ +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// Use, modification and distribution are subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_INTRINSICS_HPP_INCLUDED +#define BOOST_TT_INTRINSICS_HPP_INCLUDED + +#ifndef BOOST_TT_CONFIG_HPP_INCLUDED +#include +#endif + +// +// Helper macros for builtin compiler support. +// If your compiler has builtin support for any of the following +// traits concepts, then redefine the appropriate macros to pick +// up on the compiler support: +// +// (these should largely ignore cv-qualifiers) +// BOOST_IS_UNION(T) should evaluate to true if T is a union type +// BOOST_IS_POD(T) should evaluate to true if T is a POD type +// BOOST_IS_EMPTY(T) should evaluate to true if T is an empty class type (and not a union) +// BOOST_HAS_TRIVIAL_CONSTRUCTOR(T) should evaluate to true if "T x;" has no effect +// BOOST_HAS_TRIVIAL_COPY(T) should evaluate to true if T(t) <==> memcpy +// BOOST_HAS_TRIVIAL_MOVE_CONSTRUCTOR(T) should evaluate to true if T(boost::move(t)) <==> memcpy +// BOOST_HAS_TRIVIAL_ASSIGN(T) should evaluate to true if t = u <==> memcpy +// BOOST_HAS_TRIVIAL_MOVE_ASSIGN(T) should evaluate to true if t = boost::move(u) <==> memcpy +// BOOST_HAS_TRIVIAL_DESTRUCTOR(T) should evaluate to true if ~T() has no effect +// BOOST_HAS_NOTHROW_CONSTRUCTOR(T) should evaluate to true if "T x;" can not throw +// BOOST_HAS_NOTHROW_COPY(T) should evaluate to true if T(t) can not throw +// BOOST_HAS_NOTHROW_ASSIGN(T) should evaluate to true if t = u can not throw +// BOOST_HAS_VIRTUAL_DESTRUCTOR(T) should evaluate to true T has a virtual destructor +// BOOST_IS_NOTHROW_MOVE_CONSTRUCT(T) should evaluate to true if T has a non-throwing move constructor. +// BOOST_IS_NOTHROW_MOVE_ASSIGN(T) should evaluate to true if T has a non-throwing move assignment operator. +// +// The following can also be defined: when detected our implementation is greatly simplified. +// +// BOOST_IS_ABSTRACT(T) true if T is an abstract type +// BOOST_IS_BASE_OF(T,U) true if T is a base class of U +// BOOST_IS_CLASS(T) true if T is a class type (and not a union) +// BOOST_IS_CONVERTIBLE(T,U) true if T is convertible to U +// BOOST_IS_ENUM(T) true is T is an enum +// BOOST_IS_POLYMORPHIC(T) true if T is a polymorphic type +// BOOST_ALIGNMENT_OF(T) should evaluate to the alignment requirements of type T. + +#ifdef BOOST_HAS_SGI_TYPE_TRAITS + // Hook into SGI's __type_traits class, this will pick up user supplied + // specializations as well as SGI - compiler supplied specializations. +# include +# ifdef __NetBSD__ + // There are two different versions of type_traits.h on NetBSD on Spark + // use an implicit include via algorithm instead, to make sure we get + // the same version as the std lib: +# include +# else +# include +# endif +# define BOOST_IS_POD(T) ::boost::is_same< typename ::__type_traits::is_POD_type, ::__true_type>::value +# define BOOST_HAS_TRIVIAL_CONSTRUCTOR(T) ::boost::is_same< typename ::__type_traits::has_trivial_default_constructor, ::__true_type>::value +# define BOOST_HAS_TRIVIAL_COPY(T) ::boost::is_same< typename ::__type_traits::has_trivial_copy_constructor, ::__true_type>::value +# define BOOST_HAS_TRIVIAL_ASSIGN(T) ::boost::is_same< typename ::__type_traits::has_trivial_assignment_operator, ::__true_type>::value +# define BOOST_HAS_TRIVIAL_DESTRUCTOR(T) ::boost::is_same< typename ::__type_traits::has_trivial_destructor, ::__true_type>::value + +# ifdef __sgi +# define BOOST_HAS_TYPE_TRAITS_INTRINSICS +# endif +#endif + +#if defined(__MSL_CPP__) && (__MSL_CPP__ >= 0x8000) + // Metrowerks compiler is acquiring intrinsic type traits support + // post version 8. We hook into the published interface to pick up + // user defined specializations as well as compiler intrinsics as + // and when they become available: +# include +# define BOOST_IS_UNION(T) BOOST_STD_EXTENSION_NAMESPACE::is_union::value +# define BOOST_IS_POD(T) BOOST_STD_EXTENSION_NAMESPACE::is_POD::value +# define BOOST_HAS_TRIVIAL_CONSTRUCTOR(T) BOOST_STD_EXTENSION_NAMESPACE::has_trivial_default_ctor::value +# define BOOST_HAS_TRIVIAL_COPY(T) BOOST_STD_EXTENSION_NAMESPACE::has_trivial_copy_ctor::value +# define BOOST_HAS_TRIVIAL_ASSIGN(T) BOOST_STD_EXTENSION_NAMESPACE::has_trivial_assignment::value +# define BOOST_HAS_TRIVIAL_DESTRUCTOR(T) BOOST_STD_EXTENSION_NAMESPACE::has_trivial_dtor::value +# define BOOST_HAS_TYPE_TRAITS_INTRINSICS +#endif + +#if (defined(BOOST_MSVC) && defined(BOOST_MSVC_FULL_VER) && (BOOST_MSVC_FULL_VER >=140050215))\ + || (defined(BOOST_INTEL) && defined(_MSC_VER) && (_MSC_VER >= 1500)) +# include +# include + +# define BOOST_IS_UNION(T) __is_union(T) +# define BOOST_IS_POD(T) (__is_pod(T) && __has_trivial_constructor(T)) +# define BOOST_IS_EMPTY(T) __is_empty(T) +# define BOOST_HAS_TRIVIAL_CONSTRUCTOR(T) __has_trivial_constructor(T) +# define BOOST_HAS_TRIVIAL_COPY(T) (__has_trivial_copy(T)|| ( ::boost::is_pod::value && !::boost::is_volatile::value)) +# define BOOST_HAS_TRIVIAL_ASSIGN(T) (__has_trivial_assign(T) || ( ::boost::is_pod::value && ! ::boost::is_const::value && !::boost::is_volatile::value)) +# define BOOST_HAS_TRIVIAL_DESTRUCTOR(T) (__has_trivial_destructor(T) || ::boost::is_pod::value) +# define BOOST_HAS_NOTHROW_CONSTRUCTOR(T) (__has_nothrow_constructor(T) || ::boost::has_trivial_constructor::value) +# define BOOST_HAS_NOTHROW_COPY(T) (__has_nothrow_copy(T) || ::boost::has_trivial_copy::value) +# define BOOST_HAS_NOTHROW_ASSIGN(T) (__has_nothrow_assign(T) || ::boost::has_trivial_assign::value) +# define BOOST_HAS_VIRTUAL_DESTRUCTOR(T) __has_virtual_destructor(T) + +# define BOOST_IS_ABSTRACT(T) __is_abstract(T) +# define BOOST_IS_BASE_OF(T,U) (__is_base_of(T,U) && !is_same::value) +# define BOOST_IS_CLASS(T) __is_class(T) +# define BOOST_IS_CONVERTIBLE(T,U) ((__is_convertible_to(T,U) || (is_same::value && !is_function::value)) && !__is_abstract(U)) +# define BOOST_IS_ENUM(T) __is_enum(T) +// This one doesn't quite always do the right thing: +// # define BOOST_IS_POLYMORPHIC(T) __is_polymorphic(T) +// This one fails if the default alignment has been changed with /Zp: +// # define BOOST_ALIGNMENT_OF(T) __alignof(T) + +# if defined(_MSC_VER) && (_MSC_VER >= 1700) +# define BOOST_HAS_TRIVIAL_MOVE_CONSTRUCTOR(T) ((__has_trivial_move_constructor(T) || __is_pod(T)) && !::boost::is_volatile::value && !::boost::is_reference::value) +# define BOOST_HAS_TRIVIAL_MOVE_ASSIGN(T) ((__has_trivial_move_assign(T) || __is_pod(T)) && ! ::boost::is_const::value && !::boost::is_volatile::value && !::boost::is_reference::value) +# endif +#if _MSC_FULL_VER >= 180020827 +# define BOOST_IS_NOTHROW_MOVE_ASSIGN(T) (__is_nothrow_assignable(T&, T&&)) +# define BOOST_IS_NOTHROW_MOVE_CONSTRUCT(T) (__is_nothrow_constructible(T, T&&)) +#endif +# define BOOST_HAS_TYPE_TRAITS_INTRINSICS +#endif + +#if defined(__DMC__) && (__DMC__ >= 0x848) +// For Digital Mars C++, www.digitalmars.com +# define BOOST_IS_UNION(T) (__typeinfo(T) & 0x400) +# define BOOST_IS_POD(T) (__typeinfo(T) & 0x800) +# define BOOST_IS_EMPTY(T) (__typeinfo(T) & 0x1000) +# define BOOST_HAS_TRIVIAL_CONSTRUCTOR(T) (__typeinfo(T) & 0x10) +# define BOOST_HAS_TRIVIAL_COPY(T) (__typeinfo(T) & 0x20) +# define BOOST_HAS_TRIVIAL_ASSIGN(T) (__typeinfo(T) & 0x40) +# define BOOST_HAS_TRIVIAL_DESTRUCTOR(T) (__typeinfo(T) & 0x8) +# define BOOST_HAS_NOTHROW_CONSTRUCTOR(T) (__typeinfo(T) & 0x80) +# define BOOST_HAS_NOTHROW_COPY(T) (__typeinfo(T) & 0x100) +# define BOOST_HAS_NOTHROW_ASSIGN(T) (__typeinfo(T) & 0x200) +# define BOOST_HAS_VIRTUAL_DESTRUCTOR(T) (__typeinfo(T) & 0x4) +# define BOOST_HAS_TYPE_TRAITS_INTRINSICS +#endif + +#if defined(BOOST_CLANG) && defined(__has_feature) && !defined(__CUDACC__) +// +// Note that these intrinsics are disabled for the CUDA meta-compiler as it appears +// to not support them, even though the underlying clang compiler does so. +// This is a rubbish fix as it basically stops type traits from working correctly, +// but maybe the best we can do for now. See https://svn.boost.org/trac/boost/ticket/10694 +// +# include +# include +# include +# include + +# if __has_feature(is_union) +# define BOOST_IS_UNION(T) __is_union(T) +# endif +# if (!defined(__GLIBCXX__) || (__GLIBCXX__ >= 20080306 && __GLIBCXX__ != 20080519)) && __has_feature(is_pod) +# define BOOST_IS_POD(T) __is_pod(T) +# endif +# if (!defined(__GLIBCXX__) || (__GLIBCXX__ >= 20080306 && __GLIBCXX__ != 20080519)) && __has_feature(is_empty) +# define BOOST_IS_EMPTY(T) __is_empty(T) +# endif +# if __has_feature(has_trivial_constructor) +# define BOOST_HAS_TRIVIAL_CONSTRUCTOR(T) __has_trivial_constructor(T) +# endif +# if __has_feature(has_trivial_copy) +# define BOOST_HAS_TRIVIAL_COPY(T) (__has_trivial_copy(T) && !is_reference::value && !is_volatile::value) +# endif +# if __has_feature(has_trivial_assign) +# define BOOST_HAS_TRIVIAL_ASSIGN(T) (__has_trivial_assign(T) && !is_volatile::value) +# endif +# if __has_feature(has_trivial_destructor) +# define BOOST_HAS_TRIVIAL_DESTRUCTOR(T) __has_trivial_destructor(T) +# endif +# if __has_feature(has_nothrow_constructor) +# define BOOST_HAS_NOTHROW_CONSTRUCTOR(T) __has_nothrow_constructor(T) +# endif +# if __has_feature(has_nothrow_copy) +# define BOOST_HAS_NOTHROW_COPY(T) (__has_nothrow_copy(T) && !is_volatile::value && !is_reference::value) +# endif +# if __has_feature(has_nothrow_assign) +# define BOOST_HAS_NOTHROW_ASSIGN(T) (__has_nothrow_assign(T) && !is_volatile::value) +# endif +# if __has_feature(has_virtual_destructor) +# define BOOST_HAS_VIRTUAL_DESTRUCTOR(T) __has_virtual_destructor(T) +# endif +# if __has_feature(is_abstract) +# define BOOST_IS_ABSTRACT(T) __is_abstract(T) +# endif +# if __has_feature(is_base_of) +# define BOOST_IS_BASE_OF(T,U) (__is_base_of(T,U) && !is_same::value) +# endif +# if __has_feature(is_class) +# define BOOST_IS_CLASS(T) __is_class(T) +# endif +# if __has_feature(is_convertible_to) +# define BOOST_IS_CONVERTIBLE(T,U) __is_convertible_to(T,U) +# endif +# if __has_feature(is_enum) +# define BOOST_IS_ENUM(T) __is_enum(T) +# endif +# if __has_feature(is_polymorphic) +# define BOOST_IS_POLYMORPHIC(T) __is_polymorphic(T) +# endif +# if __has_feature(has_trivial_move_constructor) +# define BOOST_HAS_TRIVIAL_MOVE_CONSTRUCTOR(T) __has_trivial_move_constructor(T) +# endif +# if __has_feature(has_trivial_move_assign) +# define BOOST_HAS_TRIVIAL_MOVE_ASSIGN(T) __has_trivial_move_assign(T) +# endif +# define BOOST_ALIGNMENT_OF(T) __alignof(T) +# if __has_feature(is_final) +# define BOOST_IS_FINAL(T) __is_final(T) +# endif + +# define BOOST_HAS_TYPE_TRAITS_INTRINSICS +#endif + +#if defined(__GNUC__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 3) && !defined(__GCCXML__))) && !defined(BOOST_CLANG) +# include +# include +# include + +#ifdef BOOST_INTEL +# define BOOST_INTEL_TT_OPTS || is_pod::value +#else +# define BOOST_INTEL_TT_OPTS +#endif + +# define BOOST_IS_UNION(T) __is_union(T) +# define BOOST_IS_POD(T) __is_pod(T) +# define BOOST_IS_EMPTY(T) __is_empty(T) +# define BOOST_HAS_TRIVIAL_CONSTRUCTOR(T) ((__has_trivial_constructor(T) BOOST_INTEL_TT_OPTS) && ! ::boost::is_volatile::value) +# define BOOST_HAS_TRIVIAL_COPY(T) ((__has_trivial_copy(T) BOOST_INTEL_TT_OPTS) && !is_reference::value && ! ::boost::is_volatile::value) +# define BOOST_HAS_TRIVIAL_ASSIGN(T) ((__has_trivial_assign(T) BOOST_INTEL_TT_OPTS) && ! ::boost::is_volatile::value && ! ::boost::is_const::value) +# define BOOST_HAS_TRIVIAL_DESTRUCTOR(T) (__has_trivial_destructor(T) BOOST_INTEL_TT_OPTS) +# define BOOST_HAS_NOTHROW_CONSTRUCTOR(T) (__has_nothrow_constructor(T) BOOST_INTEL_TT_OPTS) +# define BOOST_HAS_NOTHROW_COPY(T) ((__has_nothrow_copy(T) BOOST_INTEL_TT_OPTS) && !is_volatile::value && !is_reference::value) +# define BOOST_HAS_NOTHROW_ASSIGN(T) ((__has_nothrow_assign(T) BOOST_INTEL_TT_OPTS) && !is_volatile::value && !is_const::value) +# define BOOST_HAS_VIRTUAL_DESTRUCTOR(T) __has_virtual_destructor(T) + +# define BOOST_IS_ABSTRACT(T) __is_abstract(T) +# define BOOST_IS_BASE_OF(T,U) (__is_base_of(T,U) && !is_same::value) +# define BOOST_IS_CLASS(T) __is_class(T) +# define BOOST_IS_ENUM(T) __is_enum(T) +# define BOOST_IS_POLYMORPHIC(T) __is_polymorphic(T) +# if (!defined(unix) && !defined(__unix__)) || defined(__LP64__) + // GCC sometimes lies about alignment requirements + // of type double on 32-bit unix platforms, use the + // old implementation instead in that case: +# define BOOST_ALIGNMENT_OF(T) __alignof__(T) +# endif +# if (__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)) +# define BOOST_IS_FINAL(T) __is_final(T) +# endif + +# define BOOST_HAS_TYPE_TRAITS_INTRINSICS +#endif + +#if defined(__SUNPRO_CC) && (__SUNPRO_CC >= 0x5130) +# include +# include +# include + +# define BOOST_IS_UNION(T) __oracle_is_union(T) +# define BOOST_IS_POD(T) __oracle_is_pod(T) +# define BOOST_IS_EMPTY(T) __oracle_is_empty(T) +# define BOOST_HAS_TRIVIAL_CONSTRUCTOR(T) (__oracle_has_trivial_constructor(T) && ! ::boost::is_volatile::value) +# define BOOST_HAS_TRIVIAL_COPY(T) (__oracle_has_trivial_copy(T) && !is_reference::value && ! ::boost::is_volatile::value) +# define BOOST_HAS_TRIVIAL_ASSIGN(T) ((__oracle_has_trivial_assign(T) || __oracle_is_trivial(T)) && ! ::boost::is_volatile::value && ! ::boost::is_const::value) +# define BOOST_HAS_TRIVIAL_DESTRUCTOR(T) __oracle_has_trivial_destructor(T) +# define BOOST_HAS_NOTHROW_CONSTRUCTOR(T) (__oracle_has_nothrow_constructor(T) || __oracle_has_trivial_constructor(T) || __oracle_is_trivial(T)) +# define BOOST_HAS_NOTHROW_COPY(T) ((__oracle_has_nothrow_copy(T) || __oracle_has_trivial_copy(T) || __oracle_is_trivial(T)) && !is_volatile::value && !is_reference::value) +# define BOOST_HAS_NOTHROW_ASSIGN(T) ((__oracle_has_nothrow_assign(T) || __oracle_has_trivial_assign(T) || __oracle_is_trivial(T)) && !is_volatile::value && !is_const::value) +# define BOOST_HAS_VIRTUAL_DESTRUCTOR(T) __oracle_has_virtual_destructor(T) + +# define BOOST_IS_ABSTRACT(T) __oracle_is_abstract(T) +//# define BOOST_IS_BASE_OF(T,U) (__is_base_of(T,U) && !is_same::value) +# define BOOST_IS_CLASS(T) __oracle_is_class(T) +# define BOOST_IS_ENUM(T) __oracle_is_enum(T) +# define BOOST_IS_POLYMORPHIC(T) __oracle_is_polymorphic(T) +# define BOOST_ALIGNMENT_OF(T) __alignof__(T) +# define BOOST_IS_FINAL(T) __oracle_is_final(T) + +# define BOOST_HAS_TYPE_TRAITS_INTRINSICS +#endif + +#if defined(__ghs__) && (__GHS_VERSION_NUMBER >= 600) +# include +# include +# include + +# define BOOST_IS_UNION(T) __is_union(T) +# define BOOST_IS_POD(T) __is_pod(T) +# define BOOST_IS_EMPTY(T) __is_empty(T) +# define BOOST_HAS_TRIVIAL_CONSTRUCTOR(T) __has_trivial_constructor(T) +# define BOOST_HAS_TRIVIAL_COPY(T) (__has_trivial_copy(T) && !is_reference::value && !is_volatile::value) +# define BOOST_HAS_TRIVIAL_ASSIGN(T) (__has_trivial_assign(T) && !is_volatile::value) +# define BOOST_HAS_TRIVIAL_DESTRUCTOR(T) __has_trivial_destructor(T) +# define BOOST_HAS_NOTHROW_CONSTRUCTOR(T) __has_nothrow_constructor(T) +# define BOOST_HAS_NOTHROW_COPY(T) (__has_nothrow_copy(T) && !is_volatile::value && !is_reference::value) +# define BOOST_HAS_NOTHROW_ASSIGN(T) (__has_nothrow_assign(T) && !is_volatile::value) +# define BOOST_HAS_VIRTUAL_DESTRUCTOR(T) __has_virtual_destructor(T) + +# define BOOST_IS_ABSTRACT(T) __is_abstract(T) +# define BOOST_IS_BASE_OF(T,U) (__is_base_of(T,U) && !is_same::value) +# define BOOST_IS_CLASS(T) __is_class(T) +# define BOOST_IS_ENUM(T) __is_enum(T) +# define BOOST_IS_POLYMORPHIC(T) __is_polymorphic(T) +# define BOOST_ALIGNMENT_OF(T) __alignof__(T) +# define BOOST_HAS_TYPE_TRAITS_INTRINSICS +#endif + +# if defined(__CODEGEARC__) +# include +# include +# include +# include + +# define BOOST_IS_UNION(T) __is_union(T) +# define BOOST_IS_POD(T) __is_pod(T) +# define BOOST_IS_EMPTY(T) __is_empty(T) +# define BOOST_HAS_TRIVIAL_CONSTRUCTOR(T) (__has_trivial_default_constructor(T)) +# define BOOST_HAS_TRIVIAL_COPY(T) (__has_trivial_copy_constructor(T) && !is_volatile::value && !is_reference::value) +# define BOOST_HAS_TRIVIAL_ASSIGN(T) (__has_trivial_assign(T) && !is_volatile::value) +# define BOOST_HAS_TRIVIAL_DESTRUCTOR(T) (__has_trivial_destructor(T)) +# define BOOST_HAS_NOTHROW_CONSTRUCTOR(T) (__has_nothrow_default_constructor(T)) +# define BOOST_HAS_NOTHROW_COPY(T) (__has_nothrow_copy_constructor(T) && !is_volatile::value && !is_reference::value) +# define BOOST_HAS_NOTHROW_ASSIGN(T) (__has_nothrow_assign(T) && !is_volatile::value) +# define BOOST_HAS_VIRTUAL_DESTRUCTOR(T) __has_virtual_destructor(T) + +# define BOOST_IS_ABSTRACT(T) __is_abstract(T) +# define BOOST_IS_BASE_OF(T,U) (__is_base_of(T,U) && !is_void::value && !is_void::value) +# define BOOST_IS_CLASS(T) __is_class(T) +# define BOOST_IS_CONVERTIBLE(T,U) (__is_convertible(T,U) || is_void::value) +# define BOOST_IS_ENUM(T) __is_enum(T) +# define BOOST_IS_POLYMORPHIC(T) __is_polymorphic(T) +# define BOOST_ALIGNMENT_OF(T) alignof(T) + +# define BOOST_HAS_TYPE_TRAITS_INTRINSICS +#endif + +#endif // BOOST_TT_INTRINSICS_HPP_INCLUDED + + + + + + + diff --git a/realsense-file/3rd_party/boost/boost/type_traits/is_abstract.hpp b/realsense-file/3rd_party/boost/boost/type_traits/is_abstract.hpp new file mode 100644 index 0000000000..386d6562b2 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/type_traits/is_abstract.hpp @@ -0,0 +1,153 @@ +#ifndef BOOST_TT_IS_ABSTRACT_CLASS_HPP +#define BOOST_TT_IS_ABSTRACT_CLASS_HPP + +#if defined(_MSC_VER) +# pragma once +#endif + +/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 +// is_abstract_class.hpp: +// +// (C) Copyright 2002 Rani Sharoni (rani_sharoni@hotmail.com) and Robert Ramey +// Use, modification and distribution is subject to the Boost Software +// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org for updates, documentation, and revision history. +// + +// Compile type discovery whether given type is abstract class or not. +// +// Requires DR 337 to be supported by compiler +// (http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#337). +// +// +// Believed (Jan 2004) to work on: +// - GCC 3.4 +// - VC++ 7.1 +// - compilers with new EDG frontend (Intel C++ 7, Comeau 4.3.2) +// +// Doesn't work on: +// - VC++6, VC++7.0 and less +// - GCC 3.3.X and less +// - Borland C++ 6 and less +// +// +// History: +// - Originally written by Rani Sharoni, see +// http://groups.google.com/groups?selm=df893da6.0207110613.75b2fe90%40posting.google.com +// At this time supported by EDG (Intel C++ 7, Comeau 4.3.2) and VC7.1. +// - Adapted and added into Boost.Serialization library by Robert Ramey +// (starting with submission #10). +// - Jan 2004: GCC 3.4 fixed to support DR337 (Giovanni Bajo). +// - Jan 2004: modified to be part of Boost.TypeTraits (Pavel Vozenilek). +// - Nov 2004: Christoph Ludwig found that the implementation did not work with +// template types and gcc-3.4 or VC7.1, fix due to Christoph Ludwig +// and John Maddock. +// - Dec 2004: Added new config macro BOOST_NO_IS_ABSTRACT which causes the template +// to degrade gracefully, rather than trash the compiler (John Maddock). +// + +#include +#ifndef BOOST_IS_ABSTRACT +#include +#include +#include +#include +#ifdef BOOST_NO_IS_ABSTRACT +#include +#endif +#endif +// should be the last #include +#include + + +namespace boost { +namespace detail{ + +#ifdef BOOST_IS_ABSTRACT +template +struct is_abstract_imp +{ + BOOST_STATIC_CONSTANT(bool, value = BOOST_IS_ABSTRACT(T)); +}; +#elif !defined(BOOST_NO_IS_ABSTRACT) +template +struct is_abstract_imp2 +{ + // Deduction fails if T is void, function type, + // reference type (14.8.2/2)or an abstract class type + // according to review status issue #337 + // + template + static type_traits::no_type check_sig(U (*)[1]); + template + static type_traits::yes_type check_sig(...); + // + // T must be a complete type, further if T is a template then + // it must be instantiated in order for us to get the right answer: + // + BOOST_STATIC_ASSERT(sizeof(T) != 0); + + // GCC2 won't even parse this template if we embed the computation + // of s1 in the computation of value. +#ifdef __GNUC__ + BOOST_STATIC_CONSTANT(std::size_t, s1 = sizeof(is_abstract_imp2::template check_sig(0))); +#else +#if BOOST_WORKAROUND(BOOST_MSVC_FULL_VER, >= 140050000) +#pragma warning(push) +#pragma warning(disable:6334) +#endif + BOOST_STATIC_CONSTANT(std::size_t, s1 = sizeof(check_sig(0))); +#if BOOST_WORKAROUND(BOOST_MSVC_FULL_VER, >= 140050000) +#pragma warning(pop) +#endif +#endif + + BOOST_STATIC_CONSTANT(bool, value = + (s1 == sizeof(type_traits::yes_type))); +}; + +template +struct is_abstract_select +{ + template + struct rebind + { + typedef is_abstract_imp2 type; + }; +}; +template <> +struct is_abstract_select +{ + template + struct rebind + { + typedef false_type type; + }; +}; + +template +struct is_abstract_imp +{ + typedef is_abstract_select< ::boost::is_class::value> selector; + typedef typename selector::template rebind binder; + typedef typename binder::type type; + + BOOST_STATIC_CONSTANT(bool, value = type::value); +}; + +#endif +} + +#ifndef BOOST_NO_IS_ABSTRACT +BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_abstract,T,::boost::detail::is_abstract_imp::value) +#else +BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_abstract,T,::boost::detail::is_polymorphic_imp::value) +#endif + +} // namespace boost + +#include + +#endif //BOOST_TT_IS_ABSTRACT_CLASS_HPP diff --git a/realsense-file/3rd_party/boost/boost/type_traits/is_arithmetic.hpp b/realsense-file/3rd_party/boost/boost/type_traits/is_arithmetic.hpp new file mode 100644 index 0000000000..7b4e751969 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/type_traits/is_arithmetic.hpp @@ -0,0 +1,51 @@ + +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// Use, modification and distribution are subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_IS_ARITHMETIC_HPP_INCLUDED +#define BOOST_TT_IS_ARITHMETIC_HPP_INCLUDED + +#if !defined( __CODEGEARC__ ) +#include +#include +#include +#include +#endif + +// should be the last #include +#include + +namespace boost { + +#if !defined(__CODEGEARC__) +namespace detail { + +template< typename T > +struct is_arithmetic_impl +{ + BOOST_STATIC_CONSTANT(bool, value = + (::boost::type_traits::ice_or< + ::boost::is_integral::value, + ::boost::is_float::value + >::value)); +}; + +} // namespace detail +#endif + +//* is a type T an arithmetic type described in the standard (3.9.1p8) +#if defined(__CODEGEARC__) +BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_arithmetic,T,__is_arithmetic(T)) +#else +BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_arithmetic,T,::boost::detail::is_arithmetic_impl::value) +#endif + +} // namespace boost + +#include + +#endif // BOOST_TT_IS_ARITHMETIC_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/type_traits/is_array.hpp b/realsense-file/3rd_party/boost/boost/type_traits/is_array.hpp new file mode 100644 index 0000000000..a5b3f803fb --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/type_traits/is_array.hpp @@ -0,0 +1,50 @@ + +// (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, Howard +// Hinnant & John Maddock 2000. +// Use, modification and distribution are subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + + +// Some fixes for is_array are based on a newsgroup posting by Jonathan Lundquist. + + +#ifndef BOOST_TT_IS_ARRAY_HPP_INCLUDED +#define BOOST_TT_IS_ARRAY_HPP_INCLUDED + +#include + + +#include + +// should be the last #include +#include + +namespace boost { + +#if defined( __CODEGEARC__ ) +BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_array,T,__is_array(T)) +#else +BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_array,T,false) +#if !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS) +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,is_array,T[N],true) +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,is_array,T const[N],true) +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,is_array,T volatile[N],true) +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,is_array,T const volatile[N],true) +#if !BOOST_WORKAROUND(__BORLANDC__, < 0x600) && !defined(__IBMCPP__) && !BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840)) +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_array,T[],true) +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_array,T const[],true) +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_array,T volatile[],true) +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_array,T const volatile[],true) +#endif +#endif + +#endif + +} // namespace boost + +#include + +#endif // BOOST_TT_IS_ARRAY_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/type_traits/is_base_and_derived.hpp b/realsense-file/3rd_party/boost/boost/type_traits/is_base_and_derived.hpp new file mode 100644 index 0000000000..031548aa86 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/type_traits/is_base_and_derived.hpp @@ -0,0 +1,252 @@ + +// (C) Copyright Rani Sharoni 2003. +// Use, modification and distribution are subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_IS_BASE_AND_DERIVED_HPP_INCLUDED +#define BOOST_TT_IS_BASE_AND_DERIVED_HPP_INCLUDED + +#include +#ifndef BOOST_IS_BASE_OF +#include +#include +#include +#include +#include +#include +#endif +#include + +// should be the last #include +#include + +namespace boost { + +namespace detail { + +#ifndef BOOST_IS_BASE_OF +#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x581)) \ + && !BOOST_WORKAROUND(__SUNPRO_CC , <= 0x540) \ + && !BOOST_WORKAROUND(__EDG_VERSION__, <= 243) \ + && !BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840)) + + // The EDG version number is a lower estimate. + // It is not currently known which EDG version + // exactly fixes the problem. + +/************************************************************************* + +This version detects ambiguous base classes and private base classes +correctly, and was devised by Rani Sharoni. + +Explanation by Terje Slettebo and Rani Sharoni. + +Let's take the multiple base class below as an example, and the following +will also show why there's not a problem with private or ambiguous base +class: + +struct B {}; +struct B1 : B {}; +struct B2 : B {}; +struct D : private B1, private B2 {}; + +is_base_and_derived::value; + +First, some terminology: + +SC - Standard conversion +UDC - User-defined conversion + +A user-defined conversion sequence consists of an SC, followed by an UDC, +followed by another SC. Either SC may be the identity conversion. + +When passing the default-constructed Host object to the overloaded check_sig() +functions (initialization 8.5/14/4/3), we have several viable implicit +conversion sequences: + +For "static no_type check_sig(B const volatile *, int)" we have the conversion +sequences: + +C -> C const (SC - Qualification Adjustment) -> B const volatile* (UDC) +C -> D const volatile* (UDC) -> B1 const volatile* / B2 const volatile* -> + B const volatile* (SC - Conversion) + +For "static yes_type check_sig(D const volatile *, T)" we have the conversion +sequence: + +C -> D const volatile* (UDC) + +According to 13.3.3.1/4, in context of user-defined conversion only the +standard conversion sequence is considered when selecting the best viable +function, so it only considers up to the user-defined conversion. For the +first function this means choosing between C -> C const and C -> C, and it +chooses the latter, because it's a proper subset (13.3.3.2/3/2) of the +former. Therefore, we have: + +C -> D const volatile* (UDC) -> B1 const volatile* / B2 const volatile* -> + B const volatile* (SC - Conversion) +C -> D const volatile* (UDC) + +Here, the principle of the "shortest subsequence" applies again, and it +chooses C -> D const volatile*. This shows that it doesn't even need to +consider the multiple paths to B, or accessibility, as that possibility is +eliminated before it could possibly cause ambiguity or access violation. + +If D is not derived from B, it has to choose between C -> C const -> B const +volatile* for the first function, and C -> D const volatile* for the second +function, which are just as good (both requires a UDC, 13.3.3.2), had it not +been for the fact that "static no_type check_sig(B const volatile *, int)" is +not templated, which makes C -> C const -> B const volatile* the best choice +(13.3.3/1/4), resulting in "no". + +Also, if Host::operator B const volatile* hadn't been const, the two +conversion sequences for "static no_type check_sig(B const volatile *, int)", in +the case where D is derived from B, would have been ambiguous. + +See also +http://groups.google.com/groups?selm=df893da6.0301280859.522081f7%40posting. +google.com and links therein. + +*************************************************************************/ + +template +struct bd_helper +{ + // + // This VC7.1 specific workaround stops the compiler from generating + // an internal compiler error when compiling with /vmg (thanks to + // Aleksey Gurtovoy for figuring out the workaround). + // +#if !BOOST_WORKAROUND(BOOST_MSVC, == 1310) + template + static type_traits::yes_type check_sig(D const volatile *, T); + static type_traits::no_type check_sig(B const volatile *, int); +#else + static type_traits::yes_type check_sig(D const volatile *, long); + static type_traits::no_type check_sig(B const volatile * const&, int); +#endif +}; + +template +struct is_base_and_derived_impl2 +{ +#if BOOST_WORKAROUND(BOOST_MSVC_FULL_VER, >= 140050000) +#pragma warning(push) +#pragma warning(disable:6334) +#endif + // + // May silently do the wrong thing with incomplete types + // unless we trap them here: + // + BOOST_STATIC_ASSERT(sizeof(B) != 0); + BOOST_STATIC_ASSERT(sizeof(D) != 0); + + struct Host + { +#if !BOOST_WORKAROUND(BOOST_MSVC, == 1310) + operator B const volatile *() const; +#else + operator B const volatile * const&() const; +#endif + operator D const volatile *(); + }; + + BOOST_STATIC_CONSTANT(bool, value = + sizeof(bd_helper::check_sig(Host(), 0)) == sizeof(type_traits::yes_type)); +#if BOOST_WORKAROUND(BOOST_MSVC_FULL_VER, >= 140050000) +#pragma warning(pop) +#endif +}; + +#else + +// +// broken version: +// +template +struct is_base_and_derived_impl2 +{ + BOOST_STATIC_CONSTANT(bool, value = + (::boost::is_convertible::value)); +}; + +#define BOOST_BROKEN_IS_BASE_AND_DERIVED + +#endif + +template +struct is_base_and_derived_impl3 +{ + BOOST_STATIC_CONSTANT(bool, value = false); +}; + +template +struct is_base_and_derived_select +{ + template + struct rebind + { + typedef is_base_and_derived_impl3 type; + }; +}; + +template <> +struct is_base_and_derived_select +{ + template + struct rebind + { + typedef is_base_and_derived_impl2 type; + }; +}; + +template +struct is_base_and_derived_impl +{ + typedef typename remove_cv::type ncvB; + typedef typename remove_cv::type ncvD; + + typedef is_base_and_derived_select< + ::boost::is_class::value, + ::boost::is_class::value, + ::boost::is_same::value> selector; + typedef typename selector::template rebind binder; + typedef typename binder::type bound_type; + + BOOST_STATIC_CONSTANT(bool, value = bound_type::value); +}; +#else +template +struct is_base_and_derived_impl +{ + typedef typename remove_cv::type ncvB; + typedef typename remove_cv::type ncvD; + + BOOST_STATIC_CONSTANT(bool, value = (BOOST_IS_BASE_OF(B,D) && ! ::boost::is_same::value)); +}; +#endif +} // namespace detail + +BOOST_TT_AUX_BOOL_TRAIT_DEF2( + is_base_and_derived + , Base + , Derived + , (::boost::detail::is_base_and_derived_impl::value) + ) + +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(typename Base,typename Derived,is_base_and_derived,Base&,Derived,false) +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(typename Base,typename Derived,is_base_and_derived,Base,Derived&,false) +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(typename Base,typename Derived,is_base_and_derived,Base&,Derived&,false) + +#if BOOST_WORKAROUND(__CODEGEARC__, BOOST_TESTED_AT(0x610)) +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(typename Base,is_base_and_derived,Base,Base,false) +#endif + +} // namespace boost + +#include + +#endif // BOOST_TT_IS_BASE_AND_DERIVED_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/type_traits/is_base_of.hpp b/realsense-file/3rd_party/boost/boost/type_traits/is_base_of.hpp new file mode 100644 index 0000000000..081144f411 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/type_traits/is_base_of.hpp @@ -0,0 +1,49 @@ + +// (C) Copyright Rani Sharoni 2003-2005. +// Use, modification and distribution are subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_IS_BASE_OF_HPP_INCLUDED +#define BOOST_TT_IS_BASE_OF_HPP_INCLUDED + +#include +#include +#include +#include +#include + +// should be the last #include +#include + +namespace boost { + + namespace detail{ + template + struct is_base_of_imp + { + typedef typename remove_cv::type ncvB; + typedef typename remove_cv::type ncvD; + BOOST_STATIC_CONSTANT(bool, value = (::boost::type_traits::ice_or< + (::boost::detail::is_base_and_derived_impl::value), + (::boost::type_traits::ice_and< ::boost::is_same::value, ::boost::is_class::value>::value)>::value)); + }; + } + +BOOST_TT_AUX_BOOL_TRAIT_DEF2( + is_base_of + , Base + , Derived + , (::boost::detail::is_base_of_imp::value)) + +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(typename Base,typename Derived,is_base_of,Base&,Derived,false) +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(typename Base,typename Derived,is_base_of,Base,Derived&,false) +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(typename Base,typename Derived,is_base_of,Base&,Derived&,false) + +} // namespace boost + +#include + +#endif // BOOST_TT_IS_BASE_AND_DERIVED_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/type_traits/is_class.hpp b/realsense-file/3rd_party/boost/boost/type_traits/is_class.hpp new file mode 100644 index 0000000000..995c260cf1 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/type_traits/is_class.hpp @@ -0,0 +1,129 @@ +// (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, Howard +// Hinnant & John Maddock 2000-2003. +// Use, modification and distribution are subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + + +#ifndef BOOST_TT_IS_CLASS_HPP_INCLUDED +#define BOOST_TT_IS_CLASS_HPP_INCLUDED + +#include +#include +#ifndef BOOST_IS_CLASS +# include +# include +# include + +#ifdef BOOST_TT_HAS_CONFORMING_IS_CLASS_IMPLEMENTATION +# include +#else +# include +# include +# include +# include +# include +#endif + +#endif // BOOST_IS_CLASS + +#ifdef __EDG_VERSION__ +# include +#endif + +// should be the last #include +#include + +namespace boost { + +namespace detail { + +#ifndef BOOST_IS_CLASS +#ifdef BOOST_TT_HAS_CONFORMING_IS_CLASS_IMPLEMENTATION + +// This is actually the conforming implementation which works with +// abstract classes. However, enough compilers have trouble with +// it that most will use the one in +// boost/type_traits/object_traits.hpp. This implementation +// actually works with VC7.0, but other interactions seem to fail +// when we use it. + +// is_class<> metafunction due to Paul Mensonides +// (leavings@attbi.com). For more details: +// http://groups.google.com/groups?hl=en&selm=000001c1cc83%24e154d5e0%247772e50c%40c161550a&rnum=1 +#if defined(__GNUC__) && !defined(__EDG_VERSION__) + +template ::boost::type_traits::yes_type is_class_tester(void(U::*)(void)); +template ::boost::type_traits::no_type is_class_tester(...); + +template +struct is_class_impl +{ + + BOOST_STATIC_CONSTANT(bool, value = + (::boost::type_traits::ice_and< + sizeof(is_class_tester(0)) == sizeof(::boost::type_traits::yes_type), + ::boost::type_traits::ice_not< ::boost::is_union::value >::value + >::value) + ); +}; + +#else + +template +struct is_class_impl +{ + template static ::boost::type_traits::yes_type is_class_tester(void(U::*)(void)); + template static ::boost::type_traits::no_type is_class_tester(...); + + BOOST_STATIC_CONSTANT(bool, value = + (::boost::type_traits::ice_and< + sizeof(is_class_tester(0)) == sizeof(::boost::type_traits::yes_type), + ::boost::type_traits::ice_not< ::boost::is_union::value >::value + >::value) + ); +}; + +#endif + +#else + +template +struct is_class_impl +{ + BOOST_STATIC_CONSTANT(bool, value = + (::boost::type_traits::ice_and< + ::boost::type_traits::ice_not< ::boost::is_union::value >::value, + ::boost::type_traits::ice_not< ::boost::is_scalar::value >::value, + ::boost::type_traits::ice_not< ::boost::is_array::value >::value, + ::boost::type_traits::ice_not< ::boost::is_reference::value>::value, + ::boost::type_traits::ice_not< ::boost::is_void::value >::value, + ::boost::type_traits::ice_not< ::boost::is_function::value >::value + >::value)); +}; + +# endif // BOOST_TT_HAS_CONFORMING_IS_CLASS_IMPLEMENTATION +# else // BOOST_IS_CLASS +template +struct is_class_impl +{ + BOOST_STATIC_CONSTANT(bool, value = BOOST_IS_CLASS(T)); +}; +# endif // BOOST_IS_CLASS + +} // namespace detail + +# ifdef __EDG_VERSION__ +BOOST_TT_AUX_BOOL_TRAIT_DEF1( + is_class,T, boost::detail::is_class_impl::type>::value) +# else +BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_class,T,::boost::detail::is_class_impl::value) +# endif + +} // namespace boost + +#include + +#endif // BOOST_TT_IS_CLASS_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/type_traits/is_const.hpp b/realsense-file/3rd_party/boost/boost/type_traits/is_const.hpp new file mode 100644 index 0000000000..a3d43eb6eb --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/type_traits/is_const.hpp @@ -0,0 +1,90 @@ + +// (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, +// Howard Hinnant and John Maddock 2000. +// (C) Copyright Mat Marcus, Jesse Jones and Adobe Systems Inc 2001 + +// Use, modification and distribution are subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +// Fixed is_pointer, is_reference, is_const, is_volatile, is_same, +// is_member_pointer based on the Simulated Partial Specialization work +// of Mat Marcus and Jesse Jones. See http://opensource.adobe.com or +// http://groups.yahoo.com/group/boost/message/5441 +// Some workarounds in here use ideas suggested from "Generic: +// Mappings between Types and Values" +// by Andrei Alexandrescu (see http://www.cuj.com/experts/1810/alexandr.html). + + +#ifndef BOOST_TT_IS_CONST_HPP_INCLUDED +#define BOOST_TT_IS_CONST_HPP_INCLUDED + +#include "config.hpp" +#include + +# include +# ifdef __GNUC__ +# include +# endif +# if BOOST_WORKAROUND(BOOST_MSVC, < 1400) +# include +# endif + +// should be the last #include +#include + +namespace boost { + +#if defined( __CODEGEARC__ ) + +BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_const,T,__is_const(T)) + +#else + +namespace detail{ +// +// We can't filter out rvalue_references at the same level as +// references or we get ambiguities from msvc: +// +template +struct is_const_rvalue_filter +{ +#if BOOST_WORKAROUND(BOOST_MSVC, < 1400) + BOOST_STATIC_CONSTANT(bool, value = ::boost::detail::cv_traits_imp::type*>::is_const); +#else + BOOST_STATIC_CONSTANT(bool, value = ::boost::detail::cv_traits_imp::is_const); +#endif +}; +#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES +template +struct is_const_rvalue_filter +{ + BOOST_STATIC_CONSTANT(bool, value = false); +}; +#endif +} + +//* is a type T declared const - is_const +BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_const,T,::boost::detail::is_const_rvalue_filter::value) +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_const,T&,false) + +#if defined(BOOST_ILLEGAL_CV_REFERENCES) +// these are illegal specialisations; cv-qualifies applied to +// references have no effect according to [8.3.2p1], +// C++ Builder requires them though as it treats cv-qualified +// references as distinct types... +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_const,T& const,false) +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_const,T& volatile,false) +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_const,T& const volatile,false) +#endif + +#endif + +} // namespace boost + +#include + +#endif // BOOST_TT_IS_CONST_HPP_INCLUDED + diff --git a/realsense-file/3rd_party/boost/boost/type_traits/is_convertible.hpp b/realsense-file/3rd_party/boost/boost/type_traits/is_convertible.hpp new file mode 100644 index 0000000000..2bc40626bf --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/type_traits/is_convertible.hpp @@ -0,0 +1,494 @@ + +// Copyright 2000 John Maddock (john@johnmaddock.co.uk) +// Copyright 2000 Jeremy Siek (jsiek@lsc.nd.edu) +// Copyright 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi) +// +// Use, modification and distribution are subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_IS_CONVERTIBLE_HPP_INCLUDED +#define BOOST_TT_IS_CONVERTIBLE_HPP_INCLUDED + +#include +#ifndef BOOST_IS_CONVERTIBLE +#include +#include +#include +#include +#include +#include +#ifndef BOOST_NO_IS_ABSTRACT +#include +#endif +#include +#include +#include + +#if defined(__MWERKS__) +#include +#endif +#if !defined(BOOST_NO_SFINAE_EXPR) && !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) +# include +#endif +#endif // BOOST_IS_CONVERTIBLE + +// should be always the last #include directive +#include + +namespace boost { + +#ifndef BOOST_IS_CONVERTIBLE + +// is one type convertible to another? +// +// there are multiple versions of the is_convertible +// template, almost every compiler seems to require its +// own version. +// +// Thanks to Andrei Alexandrescu for the original version of the +// conversion detection technique! +// + +namespace detail { + +#if !defined(BOOST_NO_SFINAE_EXPR) && !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) + + // This is a C++11 conforming version, place this first and use it wherever possible: + +# define BOOST_TT_CXX11_IS_CONVERTIBLE + + template + struct or_helper + { + static const bool value = (A::value || B::value || C::value); + }; + + template, boost::is_function, boost::is_array >::value> + struct is_convertible_basic_impl + { + // Nothing converts to function or array, but void converts to void: + static const bool value = is_void::value; + }; + + template + class is_convertible_basic_impl + { + typedef char one; + typedef int two; + + template + static void test_aux(To1); + + template + static decltype(test_aux(boost::declval()), one()) test(int); + + template + static two test(...); + + public: + static const bool value = sizeof(test(0)) == 1; + }; + +#elif defined(__BORLANDC__) && (__BORLANDC__ < 0x560) +// +// special version for Borland compilers +// this version breaks when used for some +// UDT conversions: +// +template +struct is_convertible_impl +{ +#pragma option push -w-8074 + // This workaround for Borland breaks the EDG C++ frontend, + // so we only use it for Borland. + template struct checker + { + static ::boost::type_traits::no_type BOOST_TT_DECL _m_check(...); + static ::boost::type_traits::yes_type BOOST_TT_DECL _m_check(T); + }; + + static typename add_lvalue_reference::type _m_from; + static bool const value = sizeof( checker::_m_check(_m_from) ) + == sizeof(::boost::type_traits::yes_type); +#pragma option pop +}; + +#elif defined(__GNUC__) || defined(__BORLANDC__) && (__BORLANDC__ < 0x600) +// special version for gcc compiler + recent Borland versions +// note that this does not pass UDT's through (...) + +struct any_conversion +{ + template any_conversion(const volatile T&); + template any_conversion(const T&); + template any_conversion(volatile T&); + template any_conversion(T&); +}; + +template struct checker +{ + static boost::type_traits::no_type _m_check(any_conversion ...); + static boost::type_traits::yes_type _m_check(T, int); +}; + +template +struct is_convertible_basic_impl +{ + typedef typename add_lvalue_reference::type lvalue_type; + typedef typename add_rvalue_reference::type rvalue_type; + static lvalue_type _m_from; +#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 6))) + static bool const value = + sizeof( boost::detail::checker::_m_check(static_cast(_m_from), 0) ) + == sizeof(::boost::type_traits::yes_type); +#else + static bool const value = + sizeof( boost::detail::checker::_m_check(_m_from, 0) ) + == sizeof(::boost::type_traits::yes_type); +#endif +}; + +#elif (defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 245) && !defined(__ICL)) \ + || defined(__IBMCPP__) || defined(__HP_aCC) +// +// This is *almost* an ideal world implementation as it doesn't rely +// on undefined behaviour by passing UDT's through (...). +// Unfortunately it doesn't quite pass all the tests for most compilers (sigh...) +// Enable this for your compiler if is_convertible_test.cpp will compile it... +// +// Note we do not enable this for VC7.1, because even though it passes all the +// type_traits tests it is known to cause problems when instantiation occurs +// deep within the instantiation tree :-( +// +struct any_conversion +{ + template any_conversion(const volatile T&); + template any_conversion(const T&); + template any_conversion(volatile T&); + // we need this constructor to catch references to functions + // (which can not be cv-qualified): + template any_conversion(T&); +}; + +template +struct is_convertible_basic_impl +{ + static ::boost::type_traits::no_type BOOST_TT_DECL _m_check(any_conversion ...); + static ::boost::type_traits::yes_type BOOST_TT_DECL _m_check(To, int); + typedef typename add_lvalue_reference::type lvalue_type; + typedef typename add_rvalue_reference::type rvalue_type; + static lvalue_type _m_from; + +#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES + BOOST_STATIC_CONSTANT(bool, value = + sizeof( _m_check(static_cast(_m_from), 0) ) == sizeof(::boost::type_traits::yes_type) + ); +#else + BOOST_STATIC_CONSTANT(bool, value = + sizeof( _m_check(_m_from, 0) ) == sizeof(::boost::type_traits::yes_type) + ); +#endif +}; + +#elif defined(__DMC__) + +struct any_conversion +{ + template any_conversion(const volatile T&); + template any_conversion(const T&); + template any_conversion(volatile T&); + // we need this constructor to catch references to functions + // (which can not be cv-qualified): + template any_conversion(T&); +}; + +template +struct is_convertible_basic_impl +{ + // Using '...' doesn't always work on Digital Mars. This version seems to. + template + static ::boost::type_traits::no_type BOOST_TT_DECL _m_check(any_conversion, float, T); + static ::boost::type_traits::yes_type BOOST_TT_DECL _m_check(To, int, int); + typedef typename add_lvalue_reference::type lvalue_type; + typedef typename add_rvalue_reference::type rvalue_type; + static lvalue_type _m_from; + + // Static constants sometime cause the conversion of _m_from to To to be + // called. This doesn't happen with an enum. +#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES + enum { value = + sizeof( _m_check(static_cast(_m_from), 0, 0) ) == sizeof(::boost::type_traits::yes_type) + }; +#else + enum { value = + sizeof( _m_check(_m_from, 0, 0) ) == sizeof(::boost::type_traits::yes_type) + }; +#endif +}; + +#elif defined(__MWERKS__) +// +// CW works with the technique implemented above for EDG, except when From +// is a function type (or a reference to such a type), in which case +// any_conversion won't be accepted as a valid conversion. We detect this +// exceptional situation and channel it through an alternative algorithm. +// + +template +struct is_convertible_basic_impl_aux; + +struct any_conversion +{ + template any_conversion(const volatile T&); + template any_conversion(const T&); + template any_conversion(volatile T&); + template any_conversion(T&); +}; + +template +struct is_convertible_basic_impl_aux +{ + static ::boost::type_traits::no_type BOOST_TT_DECL _m_check(any_conversion ...); + static ::boost::type_traits::yes_type BOOST_TT_DECL _m_check(To, int); + typedef typename add_lvalue_reference::type lvalue_type; + typedef typename add_rvalue_reference::type rvalue_type; + static lvalue_type _m_from; + +#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES + BOOST_STATIC_CONSTANT(bool, value = + sizeof( _m_check(static_cast(_m_from), 0) ) == sizeof(::boost::type_traits::yes_type) + ); +#else + BOOST_STATIC_CONSTANT(bool, value = + sizeof( _m_check(_m_from, 0) ) == sizeof(::boost::type_traits::yes_type) + ); +#endif +}; + +template +struct is_convertible_basic_impl_aux +{ + static ::boost::type_traits::no_type BOOST_TT_DECL _m_check(...); + static ::boost::type_traits::yes_type BOOST_TT_DECL _m_check(To); + typedef typename add_lvalue_reference::type lvalue_type; + typedef typename add_rvalue_reference::type rvalue_type; + static lvalue_type _m_from; +#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES + BOOST_STATIC_CONSTANT(bool, value = + sizeof( _m_check(static_cast(_m_from)) ) == sizeof(::boost::type_traits::yes_type) + ); +#else + BOOST_STATIC_CONSTANT(bool, value = + sizeof( _m_check(_m_from) ) == sizeof(::boost::type_traits::yes_type) + ); +#endif +}; + +template +struct is_convertible_basic_impl: + is_convertible_basic_impl_aux< + From,To, + ::boost::is_function::type>::value + > +{}; + +#else +// +// This version seems to work pretty well for a wide spectrum of compilers, +// however it does rely on undefined behaviour by passing UDT's through (...). +// +template +struct is_convertible_basic_impl +{ + static ::boost::type_traits::no_type BOOST_TT_DECL _m_check(...); + static ::boost::type_traits::yes_type BOOST_TT_DECL _m_check(To); + typedef typename add_lvalue_reference::type lvalue_type; + typedef typename add_rvalue_reference::type rvalue_type; + static lvalue_type _m_from; +#ifdef BOOST_MSVC +#pragma warning(push) +#pragma warning(disable:4244) +#if BOOST_WORKAROUND(BOOST_MSVC_FULL_VER, >= 140050000) +#pragma warning(disable:6334) +#endif +#endif +#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES + BOOST_STATIC_CONSTANT(bool, value = + sizeof( _m_check(static_cast(_m_from)) ) == sizeof(::boost::type_traits::yes_type) + ); +#else + BOOST_STATIC_CONSTANT(bool, value = + sizeof( _m_check(_m_from) ) == sizeof(::boost::type_traits::yes_type) + ); +#endif +#ifdef BOOST_MSVC +#pragma warning(pop) +#endif +}; + +#endif // is_convertible_impl + +#if defined(__DMC__) +// As before, a static constant sometimes causes errors on Digital Mars. +template +struct is_convertible_impl +{ + enum { value = + (::boost::type_traits::ice_and< + ::boost::type_traits::ice_or< + ::boost::detail::is_convertible_basic_impl::value, + ::boost::is_void::value + >::value, + ::boost::type_traits::ice_not< + ::boost::is_array::value + >::value, + ::boost::type_traits::ice_not< + ::boost::is_function::value + >::value + >::value) }; +}; +#elif !defined(__BORLANDC__) || __BORLANDC__ > 0x551 +template +struct is_convertible_impl +{ + BOOST_STATIC_CONSTANT(bool, value = + (::boost::type_traits::ice_and< + ::boost::type_traits::ice_or< + ::boost::detail::is_convertible_basic_impl::value, + ::boost::is_void::value + >::value, + ::boost::type_traits::ice_not< + ::boost::is_array::value + >::value, + ::boost::type_traits::ice_not< + ::boost::is_function::value + >::value + >::value) + ); +}; +#endif + +template +struct is_convertible_impl_select +{ + template + struct rebind + { + typedef is_convertible_impl type; + }; +}; + +template <> +struct is_convertible_impl_select +{ + template + struct rebind + { + typedef true_type type; + }; +}; + +template <> +struct is_convertible_impl_select +{ + template + struct rebind + { + typedef false_type type; + }; +}; + +template <> +struct is_convertible_impl_select +{ + template + struct rebind + { + typedef false_type type; + }; +}; + +template +struct is_convertible_impl_dispatch_base +{ +#if !BOOST_WORKAROUND(__HP_aCC, < 60700) + typedef is_convertible_impl_select< + ::boost::is_arithmetic::value, + ::boost::is_arithmetic::value, +#if !defined(BOOST_NO_IS_ABSTRACT) && !defined(BOOST_TT_CXX11_IS_CONVERTIBLE) + // We need to filter out abstract types, only if we don't have a strictly conforming C++11 version: + ::boost::is_abstract::value +#else + false +#endif + > selector; +#else + typedef is_convertible_impl_select selector; +#endif + typedef typename selector::template rebind isc_binder; + typedef typename isc_binder::type type; +}; + +template +struct is_convertible_impl_dispatch + : public is_convertible_impl_dispatch_base::type +{}; + +// +// Now add the full and partial specialisations +// for void types, these are common to all the +// implementation above: +// +#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS +# define TT_AUX_BOOL_CV_VOID_TRAIT_SPEC2_PART1(trait,spec1,spec2,value) \ + BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,spec1,spec2,value) \ + BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,spec1,spec2 const,value) \ + BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,spec1,spec2 volatile,value) \ + BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,spec1,spec2 const volatile,value) \ + /**/ + +# define TT_AUX_BOOL_CV_VOID_TRAIT_SPEC2(trait,spec1,spec2,value) \ + TT_AUX_BOOL_CV_VOID_TRAIT_SPEC2_PART1(trait,spec1,spec2,value) \ + TT_AUX_BOOL_CV_VOID_TRAIT_SPEC2_PART1(trait,spec1 const,spec2,value) \ + TT_AUX_BOOL_CV_VOID_TRAIT_SPEC2_PART1(trait,spec1 volatile,spec2,value) \ + TT_AUX_BOOL_CV_VOID_TRAIT_SPEC2_PART1(trait,spec1 const volatile,spec2,value) \ + /**/ + + TT_AUX_BOOL_CV_VOID_TRAIT_SPEC2(is_convertible,void,void,true) + +# undef TT_AUX_BOOL_CV_VOID_TRAIT_SPEC2 +# undef TT_AUX_BOOL_CV_VOID_TRAIT_SPEC2_PART1 + +#else + BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(is_convertible,void,void,true) +#endif // BOOST_NO_CV_VOID_SPECIALIZATIONS + +BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(typename To,is_convertible,void,To,false) +BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(typename From,is_convertible,From,void,false) +#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS +BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(typename To,is_convertible,void const,To,false) +BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(typename To,is_convertible,void volatile,To,false) +BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(typename To,is_convertible,void const volatile,To,false) +BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(typename From,is_convertible,From,void const,false) +BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(typename From,is_convertible,From,void volatile,false) +BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(typename From,is_convertible,From,void const volatile,false) +#endif + +} // namespace detail + +BOOST_TT_AUX_BOOL_TRAIT_DEF2(is_convertible,From,To,(::boost::detail::is_convertible_impl_dispatch::value)) + +#else + +BOOST_TT_AUX_BOOL_TRAIT_DEF2(is_convertible,From,To,BOOST_IS_CONVERTIBLE(From,To)) + +#endif + +} // namespace boost + +#include + +#endif // BOOST_TT_IS_CONVERTIBLE_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/type_traits/is_enum.hpp b/realsense-file/3rd_party/boost/boost/type_traits/is_enum.hpp new file mode 100644 index 0000000000..bf0dcede54 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/type_traits/is_enum.hpp @@ -0,0 +1,188 @@ + +// (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, Howard +// Hinnant & John Maddock 2000. +// Use, modification and distribution are subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + + +#ifndef BOOST_TT_IS_ENUM_HPP_INCLUDED +#define BOOST_TT_IS_ENUM_HPP_INCLUDED + +#include +#ifndef BOOST_IS_ENUM +#include +#include +#include +#include +#include +#ifdef __GNUC__ +#include +#endif +#include +#if defined(BOOST_TT_HAS_CONFORMING_IS_CLASS_IMPLEMENTATION) +# include +# include +#endif +#endif + +// should be the last #include +#include + +namespace boost { + +#ifndef BOOST_IS_ENUM +#if !(defined(__BORLANDC__) && (__BORLANDC__ <= 0x551)) + +namespace detail { + +#if defined(BOOST_TT_HAS_CONFORMING_IS_CLASS_IMPLEMENTATION) + +template +struct is_class_or_union +{ + BOOST_STATIC_CONSTANT(bool, value = + (::boost::type_traits::ice_or< + ::boost::is_class::value + , ::boost::is_union::value + >::value)); +}; + +#else + +template +struct is_class_or_union +{ +# if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x581))// we simply can't detect it this way. + BOOST_STATIC_CONSTANT(bool, value = false); +# else + template static ::boost::type_traits::yes_type is_class_or_union_tester(void(U::*)(void)); + +# if BOOST_WORKAROUND(__MWERKS__, <= 0x3000) // no SFINAE + static ::boost::type_traits::no_type is_class_or_union_tester(...); + BOOST_STATIC_CONSTANT( + bool, value = sizeof(is_class_or_union_tester(0)) == sizeof(::boost::type_traits::yes_type)); +# else + template + static ::boost::type_traits::no_type is_class_or_union_tester(...); + BOOST_STATIC_CONSTANT( + bool, value = sizeof(is_class_or_union_tester(0)) == sizeof(::boost::type_traits::yes_type)); +# endif +# endif +}; +#endif + +struct int_convertible +{ + int_convertible(int); +}; + +// Don't evaluate convertibility to int_convertible unless the type +// is non-arithmetic. This suppresses warnings with GCC. +template +struct is_enum_helper +{ + template struct type + { + BOOST_STATIC_CONSTANT(bool, value = false); + }; +}; + +template <> +struct is_enum_helper +{ + template struct type + : public ::boost::is_convertible::type,::boost::detail::int_convertible> + { + }; +}; + +template struct is_enum_impl +{ + //typedef ::boost::add_reference ar_t; + //typedef typename ar_t::type r_type; + +#if defined(__GNUC__) + +#ifdef BOOST_TT_HAS_CONFORMING_IS_CLASS_IMPLEMENTATION + + // We MUST check for is_class_or_union on conforming compilers in + // order to correctly deduce that noncopyable types are not enums + // (dwa 2002/04/15)... + BOOST_STATIC_CONSTANT(bool, selector = + (::boost::type_traits::ice_or< + ::boost::is_arithmetic::value + , ::boost::is_reference::value + , ::boost::is_function::value + , is_class_or_union::value + , is_array::value + >::value)); +#else + // ...however, not checking is_class_or_union on non-conforming + // compilers prevents a dependency recursion. + BOOST_STATIC_CONSTANT(bool, selector = + (::boost::type_traits::ice_or< + ::boost::is_arithmetic::value + , ::boost::is_reference::value + , ::boost::is_function::value + , is_array::value + >::value)); +#endif // BOOST_TT_HAS_CONFORMING_IS_CLASS_IMPLEMENTATION + +#else // !defined(__GNUC__): + + BOOST_STATIC_CONSTANT(bool, selector = + (::boost::type_traits::ice_or< + ::boost::is_arithmetic::value + , ::boost::is_reference::value + , is_class_or_union::value + , is_array::value + >::value)); + +#endif + +#if BOOST_WORKAROUND(__BORLANDC__, < 0x600) + typedef ::boost::detail::is_enum_helper< + ::boost::detail::is_enum_impl::selector + > se_t; +#else + typedef ::boost::detail::is_enum_helper se_t; +#endif + + typedef typename se_t::template type helper; + BOOST_STATIC_CONSTANT(bool, value = helper::value); +}; + +// these help on compilers with no partial specialization support: +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_enum,void,false) +#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_enum,void const,false) +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_enum,void volatile,false) +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_enum,void const volatile,false) +#endif + +} // namespace detail + +BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_enum,T,::boost::detail::is_enum_impl::value) + +#else // __BORLANDC__ +// +// buggy is_convertible prevents working +// implementation of is_enum: +BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_enum,T,false) + +#endif + +#else // BOOST_IS_ENUM + +BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_enum,T,BOOST_IS_ENUM(T)) + +#endif + +} // namespace boost + +#include + +#endif // BOOST_TT_IS_ENUM_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/type_traits/is_float.hpp b/realsense-file/3rd_party/boost/boost/type_traits/is_float.hpp new file mode 100644 index 0000000000..fff12128ae --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/type_traits/is_float.hpp @@ -0,0 +1,27 @@ + +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// Use, modification and distribution are subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TYPE_TRAITS_IS_FLOAT_HPP_INCLUDED +#define BOOST_TYPE_TRAITS_IS_FLOAT_HPP_INCLUDED + +// should be the last #include +#include + +namespace boost { + +//* is a type T a floating-point type described in the standard (3.9.1p8) +BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_float,T,false) +BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_float,float,true) +BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_float,double,true) +BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_float,long double,true) + +} // namespace boost + +#include + +#endif // BOOST_TYPE_TRAITS_IS_FLOAT_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/type_traits/is_function.hpp b/realsense-file/3rd_party/boost/boost/type_traits/is_function.hpp new file mode 100644 index 0000000000..8ebaa60b21 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/type_traits/is_function.hpp @@ -0,0 +1,109 @@ + +// Copyright 2000 John Maddock (john@johnmaddock.co.uk) +// Copyright 2002 Aleksey Gurtovoy (agurtovoy@meta-comm.com) +// +// Use, modification and distribution are subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_IS_FUNCTION_HPP_INCLUDED +#define BOOST_TT_IS_FUNCTION_HPP_INCLUDED + +#include +#include +#include "config.hpp" + +#if !defined(BOOST_TT_TEST_MS_FUNC_SIGS) +# include +#else +# include +# include +#endif + +// should be the last #include +#include + +// is a type a function? +// Please note that this implementation is unnecessarily complex: +// we could just use !is_convertible::value, +// except that some compilers erroneously allow conversions from +// function pointers to void*. + +namespace boost { + +#if !defined( __CODEGEARC__ ) + +namespace detail { + +#if !defined(BOOST_TT_TEST_MS_FUNC_SIGS) +template +struct is_function_chooser + : public ::boost::type_traits::false_result +{ +}; + +template <> +struct is_function_chooser +{ + template< typename T > struct result_ + : public ::boost::type_traits::is_function_ptr_helper + { + }; +}; + +template +struct is_function_impl + : public is_function_chooser< ::boost::is_reference::value > + ::BOOST_NESTED_TEMPLATE result_ +{ +}; + +#else + +template +struct is_function_impl +{ +#if BOOST_WORKAROUND(BOOST_MSVC_FULL_VER, >= 140050000) +#pragma warning(push) +#pragma warning(disable:6334) +#endif + static T* t; + BOOST_STATIC_CONSTANT( + bool, value = sizeof(::boost::type_traits::is_function_ptr_tester(t)) + == sizeof(::boost::type_traits::yes_type) + ); +#if BOOST_WORKAROUND(BOOST_MSVC_FULL_VER, >= 140050000) +#pragma warning(pop) +#endif +}; + +template +struct is_function_impl : public false_type +{}; +#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES +template +struct is_function_impl : public false_type +{}; +#endif + +#endif + +} // namespace detail + +#endif // !defined( __CODEGEARC__ ) + +#if defined( __CODEGEARC__ ) +BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_function,T,__is_function(T)) +#else +BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_function,T,::boost::detail::is_function_impl::value) +#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_function,T&&,false) +#endif +#endif +} // namespace boost + +#include + +#endif // BOOST_TT_IS_FUNCTION_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/type_traits/is_fundamental.hpp b/realsense-file/3rd_party/boost/boost/type_traits/is_fundamental.hpp new file mode 100644 index 0000000000..95db282a9e --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/type_traits/is_fundamental.hpp @@ -0,0 +1,45 @@ + +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// Use, modification and distribution are subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_IS_FUNDAMENTAL_HPP_INCLUDED +#define BOOST_TT_IS_FUNDAMENTAL_HPP_INCLUDED + +#include +#include +#include + +// should be the last #include +#include + +namespace boost { + +namespace detail { + +template +struct is_fundamental_impl + : public ::boost::type_traits::ice_or< + ::boost::is_arithmetic::value + , ::boost::is_void::value + > +{ +}; + +} // namespace detail + +//* is a type T a fundamental type described in the standard (3.9.1) +#if defined( __CODEGEARC__ ) +BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_fundamental,T,__is_fundamental(T)) +#else +BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_fundamental,T,::boost::detail::is_fundamental_impl::value) +#endif + +} // namespace boost + +#include + +#endif // BOOST_TT_IS_FUNDAMENTAL_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/type_traits/is_integral.hpp b/realsense-file/3rd_party/boost/boost/type_traits/is_integral.hpp new file mode 100644 index 0000000000..1917ae2340 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/type_traits/is_integral.hpp @@ -0,0 +1,88 @@ + +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// Use, modification and distribution are subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_IS_INTEGRAL_HPP_INCLUDED +#define BOOST_TT_IS_INTEGRAL_HPP_INCLUDED + +#include + +// should be the last #include +#include + +namespace boost { + +//* is a type T an [cv-qualified-] integral type described in the standard (3.9.1p3) +// as an extension we include long long, as this is likely to be added to the +// standard at a later date +#if defined( __CODEGEARC__ ) +BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_integral,T,__is_integral(T)) +#else +BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_integral,T,false) + +BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_integral,unsigned char,true) +BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_integral,unsigned short,true) +BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_integral,unsigned int,true) +BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_integral,unsigned long,true) + +BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_integral,signed char,true) +BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_integral,signed short,true) +BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_integral,signed int,true) +BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_integral,signed long,true) + +BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_integral,bool,true) +BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_integral,char,true) + +#ifndef BOOST_NO_INTRINSIC_WCHAR_T +// If the following line fails to compile and you're using the Intel +// compiler, see http://lists.boost.org/MailArchives/boost-users/msg06567.php, +// and define BOOST_NO_INTRINSIC_WCHAR_T on the command line. +BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_integral,wchar_t,true) +#endif + +// Same set of integral types as in boost/type_traits/integral_promotion.hpp. +// Please, keep in sync. -- Alexander Nasonov +#if (defined(BOOST_INTEL_CXX_VERSION) && defined(_MSC_VER) && (BOOST_INTEL_CXX_VERSION <= 600)) \ + || (defined(__BORLANDC__) && (__BORLANDC__ == 0x600) && (_MSC_VER < 1300)) +BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_integral,unsigned __int8,true) +BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_integral,__int8,true) +BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_integral,unsigned __int16,true) +BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_integral,__int16,true) +BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_integral,unsigned __int32,true) +BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_integral,__int32,true) +#ifdef __BORLANDC__ +BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_integral,unsigned __int64,true) +BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_integral,__int64,true) +#endif +#endif + +# if defined(BOOST_HAS_LONG_LONG) +BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_integral, ::boost::ulong_long_type,true) +BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_integral, ::boost::long_long_type,true) +#elif defined(BOOST_HAS_MS_INT64) +BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_integral,unsigned __int64,true) +BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_integral,__int64,true) +#endif + +#ifdef BOOST_HAS_INT128 +BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_integral,boost::int128_type,true) +BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_integral,boost::uint128_type,true) +#endif +#ifndef BOOST_NO_CXX11_CHAR16_T +BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_integral,char16_t,true) +#endif +#ifndef BOOST_NO_CXX11_CHAR32_T +BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_integral,char32_t,true) +#endif + +#endif // non-CodeGear implementation + +} // namespace boost + +#include + +#endif // BOOST_TT_IS_INTEGRAL_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/type_traits/is_lvalue_reference.hpp b/realsense-file/3rd_party/boost/boost/type_traits/is_lvalue_reference.hpp new file mode 100644 index 0000000000..94565b241a --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/type_traits/is_lvalue_reference.hpp @@ -0,0 +1,56 @@ + +// (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, +// Howard Hinnant and John Maddock 2000. +// (C) Copyright Mat Marcus, Jesse Jones and Adobe Systems Inc 2001 + +// Use, modification and distribution are subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +// Fixed is_pointer, is_lvalue_reference, is_const, is_volatile, is_same, +// is_member_pointer based on the Simulated Partial Specialization work +// of Mat Marcus and Jesse Jones. See http://opensource.adobe.com or +// http://groups.yahoo.com/group/boost/message/5441 +// Some workarounds in here use ideas suggested from "Generic: +// Mappings between Types and Values" +// by Andrei Alexandrescu (see http://www.cuj.com/experts/1810/alexandr.html). + + +#ifndef BOOST_TT_IS_LVALUE_REFERENCE_HPP_INCLUDED +#define BOOST_TT_IS_LVALUE_REFERENCE_HPP_INCLUDED + +#include + + +// should be the last #include +#include + +namespace boost { + +#if defined( __CODEGEARC__ ) +BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_lvalue_reference,T,__is_reference(T)) +#else + +BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_lvalue_reference,T,false) +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_lvalue_reference,T&,true) + +#if defined(BOOST_ILLEGAL_CV_REFERENCES) +// these are illegal specialisations; cv-qualifies applied to +// references have no effect according to [8.3.2p1], +// C++ Builder requires them though as it treats cv-qualified +// references as distinct types... +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_lvalue_reference,T& const,true) +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_lvalue_reference,T& volatile,true) +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_lvalue_reference,T& const volatile,true) +#endif + +#endif + +} // namespace boost + +#include + +#endif // BOOST_TT_IS_REFERENCE_HPP_INCLUDED + diff --git a/realsense-file/3rd_party/boost/boost/type_traits/is_member_function_pointer.hpp b/realsense-file/3rd_party/boost/boost/type_traits/is_member_function_pointer.hpp new file mode 100644 index 0000000000..3160a472cd --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/type_traits/is_member_function_pointer.hpp @@ -0,0 +1,133 @@ + +// (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, Howard +// Hinnant & John Maddock 2000. +// Use, modification and distribution are subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + + +#ifndef BOOST_TT_IS_MEMBER_FUNCTION_POINTER_HPP_INCLUDED +#define BOOST_TT_IS_MEMBER_FUNCTION_POINTER_HPP_INCLUDED + +#include +#include + +#if !BOOST_WORKAROUND(__BORLANDC__, < 0x600) && !defined(BOOST_TT_TEST_MS_FUNC_SIGS) + // + // Note: we use the "workaround" version for MSVC because it works for + // __stdcall etc function types, where as the partial specialisation + // version does not do so. + // +# include +# include +#else +# include +# include +# include +# include +# include +# include +#endif + +// should be the last #include +#include + +namespace boost { + +#if defined( __CODEGEARC__ ) +BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_member_function_pointer,T,__is_member_function_pointer( T )) +#elif !BOOST_WORKAROUND(__BORLANDC__, < 0x600) && !defined(BOOST_TT_TEST_MS_FUNC_SIGS) + +BOOST_TT_AUX_BOOL_TRAIT_DEF1( + is_member_function_pointer + , T + , ::boost::type_traits::is_mem_fun_pointer_impl::type>::value + ) + +#else + +namespace detail { + +#ifndef __BORLANDC__ + +template +struct is_mem_fun_pointer_select + : public ::boost::type_traits::false_result +{ +}; + +template <> +struct is_mem_fun_pointer_select +{ + template struct result_ + { +#if BOOST_WORKAROUND(BOOST_MSVC_FULL_VER, >= 140050000) +#pragma warning(push) +#pragma warning(disable:6334) +#endif + static T* make_t; + typedef result_ self_type; + + BOOST_STATIC_CONSTANT( + bool, value = ( + 1 == sizeof(::boost::type_traits::is_mem_fun_pointer_tester(self_type::make_t)) + )); +#if BOOST_WORKAROUND(BOOST_MSVC_FULL_VER, >= 140050000) +#pragma warning(pop) +#endif + }; +}; + +template +struct is_member_function_pointer_impl + : public is_mem_fun_pointer_select< + ::boost::type_traits::ice_or< + ::boost::is_reference::value + , ::boost::is_array::value + >::value + >::template result_ +{ +}; + +template +struct is_member_function_pointer_impl : public false_type{}; + +#else // Borland C++ + +template +struct is_member_function_pointer_impl +{ + static T* m_t; + BOOST_STATIC_CONSTANT( + bool, value = + (1 == sizeof(type_traits::is_mem_fun_pointer_tester(m_t))) ); +}; + +template +struct is_member_function_pointer_impl +{ + BOOST_STATIC_CONSTANT(bool, value = false); +}; + +#endif + +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_member_function_pointer,void,false) +#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_member_function_pointer,void const,false) +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_member_function_pointer,void volatile,false) +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_member_function_pointer,void const volatile,false) +#endif + +} // namespace detail + +BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_member_function_pointer,T,::boost::detail::is_member_function_pointer_impl::value) + +#endif + +} // namespace boost + +#include + +#endif // BOOST_TT_IS_MEMBER_FUNCTION_POINTER_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/type_traits/is_member_pointer.hpp b/realsense-file/3rd_party/boost/boost/type_traits/is_member_pointer.hpp new file mode 100644 index 0000000000..c1dcd60ddf --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/type_traits/is_member_pointer.hpp @@ -0,0 +1,65 @@ + +// (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, +// Howard Hinnant and John Maddock 2000. +// (C) Copyright Mat Marcus, Jesse Jones and Adobe Systems Inc 2001 + +// Use, modification and distribution are subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +// Fixed is_pointer, is_reference, is_const, is_volatile, is_same, +// is_member_pointer based on the Simulated Partial Specialization work +// of Mat Marcus and Jesse Jones. See http://opensource.adobe.com or +// http://groups.yahoo.com/group/boost/message/5441 +// Some workarounds in here use ideas suggested from "Generic: +// Mappings between Types and Values" +// by Andrei Alexandrescu (see http://www.cuj.com/experts/1810/alexandr.html). + + +#ifndef BOOST_TT_IS_MEMBER_POINTER_HPP_INCLUDED +#define BOOST_TT_IS_MEMBER_POINTER_HPP_INCLUDED + +#include +#include + +#if !BOOST_WORKAROUND(__BORLANDC__, < 0x600) +# include +#else +# include +# include +# include +# include +# include +# include +#endif + +// should be the last #include +#include + +namespace boost { + +#if defined( __CODEGEARC__ ) +BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_member_pointer,T,__is_member_pointer(T)) +#elif BOOST_WORKAROUND(__BORLANDC__, < 0x600) +BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_member_pointer,T,false) +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(typename T,typename U,is_member_pointer,U T::*,true) + +#else +BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_member_pointer,T,::boost::is_member_function_pointer::value) +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(typename T,typename U,is_member_pointer,U T::*,true) + +#if !BOOST_WORKAROUND(__MWERKS__,<=0x3003) && !BOOST_WORKAROUND(__IBMCPP__, <=600) +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(typename T,typename U,is_member_pointer,U T::*const,true) +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(typename T,typename U,is_member_pointer,U T::*volatile,true) +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(typename T,typename U,is_member_pointer,U T::*const volatile,true) +#endif + +#endif + +} // namespace boost + +#include + +#endif // BOOST_TT_IS_MEMBER_POINTER_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/type_traits/is_nothrow_move_assignable.hpp b/realsense-file/3rd_party/boost/boost/type_traits/is_nothrow_move_assignable.hpp new file mode 100644 index 0000000000..910c0f60d7 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/type_traits/is_nothrow_move_assignable.hpp @@ -0,0 +1,108 @@ + +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// (C) Copyright Eric Friedman 2002-2003. +// (C) Copyright Antony Polukhin 2013. +// Use, modification and distribution are subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_IS_NOTHROW_MOVE_ASSIGNABLE_HPP_INCLUDED +#define BOOST_TT_IS_NOTHROW_MOVE_ASSIGNABLE_HPP_INCLUDED + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// should be the last #include +#include + +namespace boost { + +namespace detail{ + +#ifdef BOOST_IS_NOTHROW_MOVE_ASSIGN + +template +struct is_nothrow_move_assignable_imp{ BOOST_STATIC_CONSTANT(bool, value = BOOST_IS_NOTHROW_MOVE_ASSIGN(T)); }; +template +struct is_nothrow_move_assignable_imp{ BOOST_STATIC_CONSTANT(bool, value = false); }; +template +struct is_nothrow_move_assignable_imp{ BOOST_STATIC_CONSTANT(bool, value = false); }; +template +struct is_nothrow_move_assignable_imp{ BOOST_STATIC_CONSTANT(bool, value = false); }; +template +struct is_nothrow_move_assignable_imp{ BOOST_STATIC_CONSTANT(bool, value = false); }; +template +struct is_nothrow_move_assignable_imp{ BOOST_STATIC_CONSTANT(bool, value = false); }; + + +#elif !defined(BOOST_NO_CXX11_NOEXCEPT) && !defined(BOOST_NO_SFINAE_EXPR) + +template +struct false_or_cpp11_noexcept_move_assignable: public ::boost::false_type {}; + +template +struct false_or_cpp11_noexcept_move_assignable < + T, + typename ::boost::enable_if_c() = ::boost::declval())>::type + > : public ::boost::integral_constant() = ::boost::declval())> +{}; + +template +struct is_nothrow_move_assignable_imp{ + BOOST_STATIC_CONSTANT(bool, value = ::boost::detail::false_or_cpp11_noexcept_move_assignable::value); +}; + +template +struct is_nothrow_move_assignable_imp : public ::boost::false_type {}; +template +struct is_nothrow_move_assignable_imp : public ::boost::false_type{}; +template +struct is_nothrow_move_assignable_imp : public ::boost::false_type{}; +template +struct is_nothrow_move_assignable_imp : public ::boost::false_type{}; +#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES +template +struct is_nothrow_move_assignable_imp : public ::boost::false_type{}; +#endif + +#else + +template +struct is_nothrow_move_assignable_imp{ + BOOST_STATIC_CONSTANT(bool, value = ( + ::boost::type_traits::ice_and< + ::boost::type_traits::ice_or< + ::boost::has_trivial_move_assign::value, + ::boost::has_nothrow_assign::value + >::value, + ::boost::type_traits::ice_not< ::boost::is_array::value >::value + >::value)); +}; + +#endif + +} + +BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_nothrow_move_assignable,T,::boost::detail::is_nothrow_move_assignable_imp::value) +BOOST_TT_AUX_BOOL_TRAIT_SPEC1(is_nothrow_move_assignable,void,false) +#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS +BOOST_TT_AUX_BOOL_TRAIT_SPEC1(is_nothrow_move_assignable,void const,false) +BOOST_TT_AUX_BOOL_TRAIT_SPEC1(is_nothrow_move_assignable,void const volatile,false) +BOOST_TT_AUX_BOOL_TRAIT_SPEC1(is_nothrow_move_assignable,void volatile,false) +#endif + +} // namespace boost + +#include + +#endif // BOOST_TT_IS_NOTHROW_MOVE_ASSIGNABLE_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/type_traits/is_nothrow_move_constructible.hpp b/realsense-file/3rd_party/boost/boost/type_traits/is_nothrow_move_constructible.hpp new file mode 100644 index 0000000000..f16c6014e2 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/type_traits/is_nothrow_move_constructible.hpp @@ -0,0 +1,109 @@ + +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// (C) Copyright Eric Friedman 2002-2003. +// (C) Copyright Antony Polukhin 2013. +// Use, modification and distribution are subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_IS_NOTHROW_MOVE_CONSTRUCTIBLE_HPP_INCLUDED +#define BOOST_TT_IS_NOTHROW_MOVE_CONSTRUCTIBLE_HPP_INCLUDED + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// should be the last #include +#include + +namespace boost { + +namespace detail{ + +#ifdef BOOST_IS_NOTHROW_MOVE_CONSTRUCT + +template +struct is_nothrow_move_constructible_imp{ + BOOST_STATIC_CONSTANT(bool, value = BOOST_IS_NOTHROW_MOVE_CONSTRUCT(T)); +}; + +template +struct is_nothrow_move_constructible_imp : public ::boost::false_type {}; +template +struct is_nothrow_move_constructible_imp : public ::boost::false_type{}; +template +struct is_nothrow_move_constructible_imp : public ::boost::false_type{}; +#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES +template +struct is_nothrow_move_constructible_imp : public ::boost::false_type{}; +#endif + +#elif !defined(BOOST_NO_CXX11_NOEXCEPT) && !defined(BOOST_NO_SFINAE_EXPR) + +template +struct false_or_cpp11_noexcept_move_constructible: public ::boost::false_type {}; + +template +struct false_or_cpp11_noexcept_move_constructible < + T, + typename ::boost::enable_if_c()))>::type + > : public ::boost::integral_constant()))> +{}; + +template +struct is_nothrow_move_constructible_imp{ + BOOST_STATIC_CONSTANT(bool, value = ::boost::detail::false_or_cpp11_noexcept_move_constructible::value); +}; + +template +struct is_nothrow_move_constructible_imp : public ::boost::false_type {}; +template +struct is_nothrow_move_constructible_imp : public ::boost::false_type{}; +template +struct is_nothrow_move_constructible_imp : public ::boost::false_type{}; +#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES +template +struct is_nothrow_move_constructible_imp : public ::boost::false_type{}; +#endif + +#else + +template +struct is_nothrow_move_constructible_imp{ + BOOST_STATIC_CONSTANT(bool, value =( + ::boost::type_traits::ice_and< + ::boost::type_traits::ice_or< + ::boost::has_trivial_move_constructor::value, + ::boost::has_nothrow_copy::value + >::value, + ::boost::type_traits::ice_not< ::boost::is_array::value >::value + >::value)); +}; + +#endif + +} + +BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_nothrow_move_constructible,T,::boost::detail::is_nothrow_move_constructible_imp::value) + +BOOST_TT_AUX_BOOL_TRAIT_SPEC1(is_nothrow_move_constructible,void,false) +#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS +BOOST_TT_AUX_BOOL_TRAIT_SPEC1(is_nothrow_move_constructible,void const,false) +BOOST_TT_AUX_BOOL_TRAIT_SPEC1(is_nothrow_move_constructible,void const volatile,false) +BOOST_TT_AUX_BOOL_TRAIT_SPEC1(is_nothrow_move_constructible,void volatile,false) +#endif + +} // namespace boost + +#include + +#endif // BOOST_TT_IS_NOTHROW_MOVE_CONSTRUCTIBLE_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/type_traits/is_pod.hpp b/realsense-file/3rd_party/boost/boost/type_traits/is_pod.hpp new file mode 100644 index 0000000000..6b7e911227 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/type_traits/is_pod.hpp @@ -0,0 +1,79 @@ + +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// Use, modification and distribution are subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_IS_POD_HPP_INCLUDED +#define BOOST_TT_IS_POD_HPP_INCLUDED + +#include +#include +#include +#include +#include + +#include + +// should be the last #include +#include + +#ifndef BOOST_IS_POD +#define BOOST_INTERNAL_IS_POD(T) false +#else +#define BOOST_INTERNAL_IS_POD(T) BOOST_IS_POD(T) +#endif + +namespace boost { + +// forward declaration, needed by 'is_pod_array_helper' template below +template< typename T > struct is_POD; + +namespace detail { + + +template struct is_pod_impl +{ + BOOST_STATIC_CONSTANT( + bool, value = + (::boost::type_traits::ice_or< + ::boost::is_scalar::value, + ::boost::is_void::value, + BOOST_INTERNAL_IS_POD(T) + >::value)); +}; + +#if !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS) +template +struct is_pod_impl + : public is_pod_impl +{ +}; +#endif + + +// the following help compilers without partial specialization support: +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,void,true) + +#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,void const,true) +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,void volatile,true) +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,void const volatile,true) +#endif + +} // namespace detail + +BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_pod,T,::boost::detail::is_pod_impl::value) +// is_POD is the old depricated name for this trait, do not use this as it may +// be removed in future without warning!! +BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_POD,T,::boost::is_pod::value) + +} // namespace boost + +#include + +#undef BOOST_INTERNAL_IS_POD + +#endif // BOOST_TT_IS_POD_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/type_traits/is_pointer.hpp b/realsense-file/3rd_party/boost/boost/type_traits/is_pointer.hpp new file mode 100644 index 0000000000..f5c0204a9d --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/type_traits/is_pointer.hpp @@ -0,0 +1,88 @@ + +// (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, +// Howard Hinnant and John Maddock 2000. +// (C) Copyright Mat Marcus, Jesse Jones and Adobe Systems Inc 2001 + +// Use, modification and distribution are subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +// Fixed is_pointer, is_reference, is_const, is_volatile, is_same, +// is_member_pointer based on the Simulated Partial Specialization work +// of Mat Marcus and Jesse Jones. See http://opensource.adobe.com or +// http://groups.yahoo.com/group/boost/message/5441 +// Some workarounds in here use ideas suggested from "Generic: +// Mappings between Types and Values" +// by Andrei Alexandrescu (see http://www.cuj.com/experts/1810/alexandr.html). + + +#ifndef BOOST_TT_IS_POINTER_HPP_INCLUDED +#define BOOST_TT_IS_POINTER_HPP_INCLUDED + +#include +#include +#include +#include +#include + + +// should be the last #include +#include + +namespace boost { + +#if defined( __CODEGEARC__ ) +BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_pointer,T,__is_pointer(T)) +#else + +namespace detail { + +template< typename T > struct is_pointer_helper +{ + BOOST_STATIC_CONSTANT(bool, value = false); +}; + +# define TT_AUX_BOOL_TRAIT_HELPER_PARTIAL_SPEC(helper,sp,result) \ +template< typename T > struct helper \ +{ \ + BOOST_STATIC_CONSTANT(bool, value = result); \ +}; \ +/**/ + +TT_AUX_BOOL_TRAIT_HELPER_PARTIAL_SPEC(is_pointer_helper,T*,true) + +# undef TT_AUX_BOOL_TRAIT_HELPER_PARTIAL_SPEC + +template< typename T > +struct is_pointer_impl +{ + BOOST_STATIC_CONSTANT(bool, value = + (::boost::type_traits::ice_and< + ::boost::detail::is_pointer_helper::type>::value + , ::boost::type_traits::ice_not< + ::boost::is_member_pointer::value + >::value + >::value) + ); +}; + +} // namespace detail + +BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_pointer,T,::boost::detail::is_pointer_impl::value) + +#if defined(__BORLANDC__) && !defined(__COMO__) && (__BORLANDC__ < 0x600) +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_pointer,T&,false) +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_pointer,T& const,false) +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_pointer,T& volatile,false) +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_pointer,T& const volatile,false) +#endif + +#endif + +} // namespace boost + +#include + +#endif // BOOST_TT_IS_POINTER_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/type_traits/is_reference.hpp b/realsense-file/3rd_party/boost/boost/type_traits/is_reference.hpp new file mode 100644 index 0000000000..9bb0e6131a --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/type_traits/is_reference.hpp @@ -0,0 +1,45 @@ + +// (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, +// Howard Hinnant and John Maddock 2000, 2010. +// (C) Copyright Mat Marcus, Jesse Jones and Adobe Systems Inc 2001 + +// Use, modification and distribution are subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_IS_REFERENCE_HPP_INCLUDED +#define BOOST_TT_IS_REFERENCE_HPP_INCLUDED + +#include +#include +#include +#include + +// should be the last #include +#include + +namespace boost { + +namespace detail { + +template +struct is_reference_impl +{ + BOOST_STATIC_CONSTANT(bool, value = + (::boost::type_traits::ice_or< + ::boost::is_lvalue_reference::value, ::boost::is_rvalue_reference::value + >::value)); +}; + +} // namespace detail + +BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_reference,T,::boost::detail::is_reference_impl::value) + +} // namespace boost + +#include + +#endif // BOOST_TT_IS_REFERENCE_HPP_INCLUDED + diff --git a/realsense-file/3rd_party/boost/boost/type_traits/is_rvalue_reference.hpp b/realsense-file/3rd_party/boost/boost/type_traits/is_rvalue_reference.hpp new file mode 100644 index 0000000000..289f27faf8 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/type_traits/is_rvalue_reference.hpp @@ -0,0 +1,29 @@ + +// (C) John Maddock 2010. +// Use, modification and distribution are subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_IS_RVALUE_REFERENCE_HPP_INCLUDED +#define BOOST_TT_IS_RVALUE_REFERENCE_HPP_INCLUDED + +#include + +// should be the last #include +#include + +namespace boost { + +BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_rvalue_reference,T,false) +#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_rvalue_reference,T&&,true) +#endif + +} // namespace boost + +#include + +#endif // BOOST_TT_IS_REFERENCE_HPP_INCLUDED + diff --git a/realsense-file/3rd_party/boost/boost/type_traits/is_same.hpp b/realsense-file/3rd_party/boost/boost/type_traits/is_same.hpp new file mode 100644 index 0000000000..5aefacd2b6 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/type_traits/is_same.hpp @@ -0,0 +1,45 @@ + +// (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, +// Howard Hinnant and John Maddock 2000. +// (C) Copyright Mat Marcus, Jesse Jones and Adobe Systems Inc 2001 + +// Use, modification and distribution are subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +// Fixed is_pointer, is_reference, is_const, is_volatile, is_same, +// is_member_pointer based on the Simulated Partial Specialization work +// of Mat Marcus and Jesse Jones. See http://opensource.adobe.com or +// http://groups.yahoo.com/group/boost/message/5441 +// Some workarounds in here use ideas suggested from "Generic: +// Mappings between Types and Values" +// by Andrei Alexandrescu (see http://www.cuj.com/experts/1810/alexandr.html). + + +#ifndef BOOST_TT_IS_SAME_HPP_INCLUDED +#define BOOST_TT_IS_SAME_HPP_INCLUDED + +#include +// should be the last #include +#include + +namespace boost { + + +BOOST_TT_AUX_BOOL_TRAIT_DEF2(is_same,T,U,false) +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(typename T,is_same,T,T,true) +#if BOOST_WORKAROUND(__BORLANDC__, < 0x600) +// without this, Borland's compiler gives the wrong answer for +// references to arrays: +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(typename T,is_same,T&,T&,true) +#endif + + +} // namespace boost + +#include + +#endif // BOOST_TT_IS_SAME_HPP_INCLUDED + diff --git a/realsense-file/3rd_party/boost/boost/type_traits/is_scalar.hpp b/realsense-file/3rd_party/boost/boost/type_traits/is_scalar.hpp new file mode 100644 index 0000000000..618f981365 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/type_traits/is_scalar.hpp @@ -0,0 +1,55 @@ + +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// Use, modification and distribution are subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_IS_SCALAR_HPP_INCLUDED +#define BOOST_TT_IS_SCALAR_HPP_INCLUDED + +#include +#include +#include +#include +#include +#include + +// should be the last #include +#include + +namespace boost { + +namespace detail { + +template +struct is_scalar_impl +{ + BOOST_STATIC_CONSTANT(bool, value = + (::boost::type_traits::ice_or< + ::boost::is_arithmetic::value, + ::boost::is_enum::value, + ::boost::is_pointer::value, + ::boost::is_member_pointer::value + >::value)); +}; + +// these specializations are only really needed for compilers +// without partial specialization support: +template <> struct is_scalar_impl{ BOOST_STATIC_CONSTANT(bool, value = false ); }; +#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS +template <> struct is_scalar_impl{ BOOST_STATIC_CONSTANT(bool, value = false ); }; +template <> struct is_scalar_impl{ BOOST_STATIC_CONSTANT(bool, value = false ); }; +template <> struct is_scalar_impl{ BOOST_STATIC_CONSTANT(bool, value = false ); }; +#endif + +} // namespace detail + +BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_scalar,T,::boost::detail::is_scalar_impl::value) + +} // namespace boost + +#include + +#endif // BOOST_TT_IS_SCALAR_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/type_traits/is_signed.hpp b/realsense-file/3rd_party/boost/boost/type_traits/is_signed.hpp new file mode 100644 index 0000000000..831ef27e4a --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/type_traits/is_signed.hpp @@ -0,0 +1,136 @@ + +// (C) Copyright John Maddock 2005. +// Use, modification and distribution are subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + + +#ifndef BOOST_TT_IS_SIGNED_HPP_INCLUDED +#define BOOST_TT_IS_SIGNED_HPP_INCLUDED + +#include +#include +#include +#include + +// should be the last #include +#include + +namespace boost { + +#if !defined( __CODEGEARC__ ) + +namespace detail{ + +#if !(defined(__EDG_VERSION__) && __EDG_VERSION__ <= 238) && !defined(BOOST_NO_INCLASS_MEMBER_INITIALIZATION) + +template +struct is_signed_values +{ + // + // Note that we cannot use BOOST_STATIC_CONSTANT here, using enum's + // rather than "real" static constants simply doesn't work or give + // the correct answer. + // + typedef typename remove_cv::type no_cv_t; + static const no_cv_t minus_one = (static_cast(-1)); + static const no_cv_t zero = (static_cast(0)); +}; + +template +struct is_signed_helper +{ + typedef typename remove_cv::type no_cv_t; + BOOST_STATIC_CONSTANT(bool, value = (!(::boost::detail::is_signed_values::minus_one > boost::detail::is_signed_values::zero))); +}; + +template +struct is_signed_select_helper +{ + template + struct rebind + { + typedef is_signed_helper type; + }; +}; + +template <> +struct is_signed_select_helper +{ + template + struct rebind + { + typedef false_type type; + }; +}; + +template +struct is_signed_imp +{ + typedef is_signed_select_helper< + ::boost::type_traits::ice_or< + ::boost::is_integral::value, + ::boost::is_enum::value>::value + > selector; + typedef typename selector::template rebind binder; + typedef typename binder::type type; + BOOST_STATIC_CONSTANT(bool, value = type::value); +}; + +#else + +template struct is_signed_imp : public false_type{}; +template <> struct is_signed_imp : public true_type{}; +template <> struct is_signed_imp : public true_type{}; +template <> struct is_signed_imp : public true_type{}; +template <> struct is_signed_imp : public true_type{}; +template <> struct is_signed_imp : public true_type{}; +template <> struct is_signed_imp : public true_type{}; +template <> struct is_signed_imp : public true_type{}; +template <> struct is_signed_imp : public true_type{}; +template <> struct is_signed_imp : public true_type{}; +template <> struct is_signed_imp : public true_type{}; +template <> struct is_signed_imp : public true_type{}; +template <> struct is_signed_imp : public true_type{}; +template <> struct is_signed_imp : public true_type{}; +template <> struct is_signed_imp : public true_type{}; +template <> struct is_signed_imp : public true_type{}; +template <> struct is_signed_imp : public true_type{}; +#ifdef BOOST_HAS_LONG_LONG +template <> struct is_signed_imp : public true_type{}; +template <> struct is_signed_imp : public true_type{}; +template <> struct is_signed_imp : public true_type{}; +template <> struct is_signed_imp : public true_type{}; +#endif +#if defined(CHAR_MIN) && (CHAR_MIN != 0) +template <> struct is_signed_imp : public true_type{}; +template <> struct is_signed_imp : public true_type{}; +template <> struct is_signed_imp : public true_type{}; +template <> struct is_signed_imp : public true_type{}; +#endif +#if defined(WCHAR_MIN) && (WCHAR_MIN != 0) +template <> struct is_signed_imp : public true_type{}; +template <> struct is_signed_imp : public true_type{}; +template <> struct is_signed_imp : public true_type{}; +template <> struct is_signed_imp : public true_type{}; +#endif + +#endif + +} + +#endif // !defined( __CODEGEARC__ ) + +#if defined( __CODEGEARC__ ) +BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_signed,T,__is_signed(T)) +#else +BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_signed,T,::boost::detail::is_signed_imp::value) +#endif + +} // namespace boost + +#include + +#endif // BOOST_TT_IS_MEMBER_FUNCTION_POINTER_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/type_traits/is_union.hpp b/realsense-file/3rd_party/boost/boost/type_traits/is_union.hpp new file mode 100644 index 0000000000..2ed4274f57 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/type_traits/is_union.hpp @@ -0,0 +1,57 @@ + +// (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, Howard +// Hinnant & John Maddock 2000. +// Use, modification and distribution are subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + + +#ifndef BOOST_TT_IS_UNION_HPP_INCLUDED +#define BOOST_TT_IS_UNION_HPP_INCLUDED + +#include +#include +#include + +// should be the last #include +#include + +namespace boost { + +namespace detail { +#ifndef __GNUC__ +template struct is_union_impl +{ + typedef typename remove_cv::type cvt; +#ifdef BOOST_IS_UNION + BOOST_STATIC_CONSTANT(bool, value = BOOST_IS_UNION(cvt)); +#else + BOOST_STATIC_CONSTANT(bool, value = false); +#endif +}; +#else +// +// using remove_cv here generates a whole load of needless +// warnings with gcc, since it doesn't do any good with gcc +// in any case (at least at present), just remove it: +// +template struct is_union_impl +{ +#ifdef BOOST_IS_UNION + BOOST_STATIC_CONSTANT(bool, value = BOOST_IS_UNION(T)); +#else + BOOST_STATIC_CONSTANT(bool, value = false); +#endif +}; +#endif +} // namespace detail + +BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_union,T,::boost::detail::is_union_impl::value) + +} // namespace boost + +#include + +#endif // BOOST_TT_IS_UNION_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/type_traits/is_unsigned.hpp b/realsense-file/3rd_party/boost/boost/type_traits/is_unsigned.hpp new file mode 100644 index 0000000000..509d898f57 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/type_traits/is_unsigned.hpp @@ -0,0 +1,135 @@ + +// (C) Copyright John Maddock 2005. +// Use, modification and distribution are subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + + +#ifndef BOOST_TT_IS_UNSIGNED_HPP_INCLUDED +#define BOOST_TT_IS_UNSIGNED_HPP_INCLUDED + +#include +#include +#include +#include + +// should be the last #include +#include + +namespace boost { + +#if !defined( __CODEGEARC__ ) + +namespace detail{ + +#if !(defined(__EDG_VERSION__) && __EDG_VERSION__ <= 238) && !defined(BOOST_NO_INCLASS_MEMBER_INITIALIZATION) + +template +struct is_unsigned_values +{ + // + // Note that we cannot use BOOST_STATIC_CONSTANT here, using enum's + // rather than "real" static constants simply doesn't work or give + // the correct answer. + // + typedef typename remove_cv::type no_cv_t; + static const no_cv_t minus_one = (static_cast(-1)); + static const no_cv_t zero = (static_cast(0)); +}; + +template +struct is_ununsigned_helper +{ + BOOST_STATIC_CONSTANT(bool, value = (::boost::detail::is_unsigned_values::minus_one > ::boost::detail::is_unsigned_values::zero)); +}; + +template +struct is_ununsigned_select_helper +{ + template + struct rebind + { + typedef is_ununsigned_helper type; + }; +}; + +template <> +struct is_ununsigned_select_helper +{ + template + struct rebind + { + typedef false_type type; + }; +}; + +template +struct is_unsigned_imp +{ + typedef is_ununsigned_select_helper< + ::boost::type_traits::ice_or< + ::boost::is_integral::value, + ::boost::is_enum::value>::value + > selector; + typedef typename selector::template rebind binder; + typedef typename binder::type type; + BOOST_STATIC_CONSTANT(bool, value = type::value); +}; + +#else + +template struct is_unsigned_imp : public false_type{}; +template <> struct is_unsigned_imp : public true_type{}; +template <> struct is_unsigned_imp : public true_type{}; +template <> struct is_unsigned_imp : public true_type{}; +template <> struct is_unsigned_imp : public true_type{}; +template <> struct is_unsigned_imp : public true_type{}; +template <> struct is_unsigned_imp : public true_type{}; +template <> struct is_unsigned_imp : public true_type{}; +template <> struct is_unsigned_imp : public true_type{}; +template <> struct is_unsigned_imp : public true_type{}; +template <> struct is_unsigned_imp : public true_type{}; +template <> struct is_unsigned_imp : public true_type{}; +template <> struct is_unsigned_imp : public true_type{}; +template <> struct is_unsigned_imp : public true_type{}; +template <> struct is_unsigned_imp : public true_type{}; +template <> struct is_unsigned_imp : public true_type{}; +template <> struct is_unsigned_imp : public true_type{}; +#ifdef BOOST_HAS_LONG_LONG +template <> struct is_unsigned_imp : public true_type{}; +template <> struct is_unsigned_imp : public true_type{}; +template <> struct is_unsigned_imp : public true_type{}; +template <> struct is_unsigned_imp : public true_type{}; +#endif +#if defined(CHAR_MIN) && (CHAR_MIN == 0) +template <> struct is_unsigned_imp : public true_type{}; +template <> struct is_unsigned_imp : public true_type{}; +template <> struct is_unsigned_imp : public true_type{}; +template <> struct is_unsigned_imp : public true_type{}; +#endif +#if defined(WCHAR_MIN) && (WCHAR_MIN == 0) && !defined(BOOST_NO_INTRINSIC_WCHAR_T) +template <> struct is_unsigned_imp : public true_type{}; +template <> struct is_unsigned_imp : public true_type{}; +template <> struct is_unsigned_imp : public true_type{}; +template <> struct is_unsigned_imp : public true_type{}; +#endif + +#endif + +} + +#endif // !defined( __CODEGEARC__ ) + +#if defined( __CODEGEARC__ ) +BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_unsigned,T,__is_unsigned(T)) +#else +BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_unsigned,T,::boost::detail::is_unsigned_imp::value) +#endif + +} // namespace boost + +#include + +#endif // BOOST_TT_IS_MEMBER_FUNCTION_POINTER_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/type_traits/is_void.hpp b/realsense-file/3rd_party/boost/boost/type_traits/is_void.hpp new file mode 100644 index 0000000000..f55522a9b2 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/type_traits/is_void.hpp @@ -0,0 +1,38 @@ + +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// Use, modification and distribution are subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_IS_VOID_HPP_INCLUDED +#define BOOST_TT_IS_VOID_HPP_INCLUDED + +#include "config.hpp" + +// should be the last #include +#include "boost/type_traits/detail/bool_trait_def.hpp" + +namespace boost { + +//* is a type T void - is_void +#if defined( __CODEGEARC__ ) +BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_void,T,__is_void(T)) +#else +BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_void,T,false) +BOOST_TT_AUX_BOOL_TRAIT_SPEC1(is_void,void,true) + +#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS +BOOST_TT_AUX_BOOL_TRAIT_SPEC1(is_void,void const,true) +BOOST_TT_AUX_BOOL_TRAIT_SPEC1(is_void,void volatile,true) +BOOST_TT_AUX_BOOL_TRAIT_SPEC1(is_void,void const volatile,true) +#endif + +#endif // non-CodeGear implementation + +} // namespace boost + +#include + +#endif // BOOST_TT_IS_VOID_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/type_traits/is_volatile.hpp b/realsense-file/3rd_party/boost/boost/type_traits/is_volatile.hpp new file mode 100644 index 0000000000..dbaf9b24a4 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/type_traits/is_volatile.hpp @@ -0,0 +1,84 @@ + +// (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, +// Howard Hinnant and John Maddock 2000. +// (C) Copyright Mat Marcus, Jesse Jones and Adobe Systems Inc 2001 + +// Use, modification and distribution are subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +// Fixed is_pointer, is_reference, is_const, is_volatile, is_same, +// is_member_pointer based on the Simulated Partial Specialization work +// of Mat Marcus and Jesse Jones. See http://opensource.adobe.com or +// http://groups.yahoo.com/group/boost/message/5441 +// Some workarounds in here use ideas suggested from "Generic: +// Mappings between Types and Values" +// by Andrei Alexandrescu (see http://www.cuj.com/experts/1810/alexandr.html). + + +#ifndef BOOST_TT_IS_VOLATILE_HPP_INCLUDED +#define BOOST_TT_IS_VOLATILE_HPP_INCLUDED + +#include "config.hpp" +#include "../detail/workaround.hpp" + +# include "detail/cv_traits_impl.hpp" +# if BOOST_WORKAROUND(BOOST_MSVC, < 1400) +# include +# endif + +// should be the last #include +#include "detail/bool_trait_def.hpp" + +namespace boost { + +namespace detail{ +template +struct is_volatile_rval_filter +{ +#if BOOST_WORKAROUND(BOOST_MSVC, < 1400) + BOOST_STATIC_CONSTANT(bool, value = ::boost::detail::cv_traits_imp::type*>::is_volatile); +#else + BOOST_STATIC_CONSTANT(bool, value = ::boost::detail::cv_traits_imp::is_volatile); +#endif +}; +#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES +// +// We can't filter out rvalue_references at the same level as +// references or we get ambiguities from msvc: +// +template +struct is_volatile_rval_filter +{ + BOOST_STATIC_CONSTANT(bool, value = false); +}; +#endif +} + +#if defined( __CODEGEARC__ ) +BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_volatile,T,__is_volatile(T)) +#else + +//* is a type T declared volatile - is_volatile +BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_volatile,T,::boost::detail::is_volatile_rval_filter::value) +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_volatile,T&,false) + +#if defined(BOOST_ILLEGAL_CV_REFERENCES) +// these are illegal specialisations; cv-qualifies applied to +// references have no effect according to [8.3.2p1], +// C++ Builder requires them though as it treats cv-qualified +// references as distinct types... +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_volatile,T& const,false) +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_volatile,T& volatile,false) +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_volatile,T& const volatile,false) +#endif + +#endif + +} // namespace boost + +#include "boost/type_traits/detail/bool_trait_undef.hpp" + +#endif // BOOST_TT_IS_VOLATILE_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/type_traits/make_signed.hpp b/realsense-file/3rd_party/boost/boost/type_traits/make_signed.hpp new file mode 100644 index 0000000000..ea0e8d6aca --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/type_traits/make_signed.hpp @@ -0,0 +1,151 @@ + +// (C) Copyright John Maddock 2007. +// Use, modification and distribution are subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_MAKE_SIGNED_HPP_INCLUDED +#define BOOST_TT_MAKE_SIGNED_HPP_INCLUDED + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// should be the last #include +#include + +namespace boost { + +namespace detail { + +template +struct make_signed_imp +{ + BOOST_STATIC_ASSERT( + (::boost::type_traits::ice_or< ::boost::is_integral::value, ::boost::is_enum::value>::value)); + BOOST_STATIC_ASSERT( + (::boost::type_traits::ice_not< ::boost::is_same< + typename remove_cv::type, bool>::value>::value)); + + typedef typename remove_cv::type t_no_cv; + typedef typename mpl::if_c< + (::boost::type_traits::ice_and< + ::boost::is_signed::value, + ::boost::is_integral::value, + ::boost::type_traits::ice_not< ::boost::is_same::value>::value, + ::boost::type_traits::ice_not< ::boost::is_same::value>::value, + ::boost::type_traits::ice_not< ::boost::is_same::value>::value >::value), + T, + typename mpl::if_c< + (::boost::type_traits::ice_and< + ::boost::is_integral::value, + ::boost::type_traits::ice_not< ::boost::is_same::value>::value, + ::boost::type_traits::ice_not< ::boost::is_same::value>::value, + ::boost::type_traits::ice_not< ::boost::is_same::value>::value> + ::value), + typename mpl::if_< + is_same, + signed char, + typename mpl::if_< + is_same, + signed short, + typename mpl::if_< + is_same, + int, + typename mpl::if_< + is_same, + long, +#if defined(BOOST_HAS_LONG_LONG) +#ifdef BOOST_HAS_INT128 + typename mpl::if_c< + sizeof(t_no_cv) == sizeof(boost::long_long_type), + boost::long_long_type, + boost::int128_type + >::type +#else + boost::long_long_type +#endif +#elif defined(BOOST_HAS_MS_INT64) + __int64 +#else + long +#endif + >::type + >::type + >::type + >::type, + // Not a regular integer type: + typename mpl::if_c< + sizeof(t_no_cv) == sizeof(unsigned char), + signed char, + typename mpl::if_c< + sizeof(t_no_cv) == sizeof(unsigned short), + signed short, + typename mpl::if_c< + sizeof(t_no_cv) == sizeof(unsigned int), + int, + typename mpl::if_c< + sizeof(t_no_cv) == sizeof(unsigned long), + long, +#if defined(BOOST_HAS_LONG_LONG) +#ifdef BOOST_HAS_INT128 + typename mpl::if_c< + sizeof(t_no_cv) == sizeof(boost::long_long_type), + boost::long_long_type, + boost::int128_type + >::type +#else + boost::long_long_type +#endif +#elif defined(BOOST_HAS_MS_INT64) + __int64 +#else + long +#endif + >::type + >::type + >::type + >::type + >::type + >::type base_integer_type; + + // Add back any const qualifier: + typedef typename mpl::if_< + is_const, + typename add_const::type, + base_integer_type + >::type const_base_integer_type; + + // Add back any volatile qualifier: + typedef typename mpl::if_< + is_volatile, + typename add_volatile::type, + const_base_integer_type + >::type type; +}; + + +} // namespace detail + +BOOST_TT_AUX_TYPE_TRAIT_DEF1(make_signed,T,typename boost::detail::make_signed_imp::type) + +} // namespace boost + +#include + +#endif // BOOST_TT_ADD_REFERENCE_HPP_INCLUDED + diff --git a/realsense-file/3rd_party/boost/boost/type_traits/remove_bounds.hpp b/realsense-file/3rd_party/boost/boost/type_traits/remove_bounds.hpp new file mode 100644 index 0000000000..79f94bce0d --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/type_traits/remove_bounds.hpp @@ -0,0 +1,40 @@ + +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// Use, modification and distribution are subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_REMOVE_BOUNDS_HPP_INCLUDED +#define BOOST_TT_REMOVE_BOUNDS_HPP_INCLUDED + +#include +#include +#include + +// should be the last #include +#include + +namespace boost { + +BOOST_TT_AUX_TYPE_TRAIT_DEF1(remove_bounds,T,T) + +#if !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS) +BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,remove_bounds,T[N],T type) +BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,remove_bounds,T const[N],T const type) +BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,remove_bounds,T volatile[N],T volatile type) +BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,remove_bounds,T const volatile[N],T const volatile type) +#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x610)) && !defined(__IBMCPP__) && !BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840)) +BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,remove_bounds,T[],T) +BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,remove_bounds,T const[],T const) +BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,remove_bounds,T volatile[],T volatile) +BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,remove_bounds,T const volatile[],T const volatile) +#endif +#endif + +} // namespace boost + +#include + +#endif // BOOST_TT_REMOVE_BOUNDS_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/type_traits/remove_const.hpp b/realsense-file/3rd_party/boost/boost/type_traits/remove_const.hpp new file mode 100644 index 0000000000..0850c1a8cf --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/type_traits/remove_const.hpp @@ -0,0 +1,79 @@ + +// (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, Howard +// Hinnant & John Maddock 2000. +// Use, modification and distribution are subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + + +#ifndef BOOST_TT_REMOVE_CONST_HPP_INCLUDED +#define BOOST_TT_REMOVE_CONST_HPP_INCLUDED + +#include "is_volatile.hpp" +#include "detail/cv_traits_impl.hpp" +#include "config.hpp" +#include "../detail/workaround.hpp" + +#include + +// should be the last #include +#include "boost/type_traits/detail/type_trait_def.hpp" + +namespace boost { + + +namespace detail { + +template +struct remove_const_helper +{ + typedef T type; +}; + +template +struct remove_const_helper +{ + typedef T volatile type; +}; + + +template +struct remove_const_impl +{ + typedef typename remove_const_helper< + typename cv_traits_imp::unqualified_type + , ::boost::is_volatile::value + >::type type; +}; + +#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES +// +// We can't filter out rvalue_references at the same level as +// references or we get ambiguities from msvc: +// +template +struct remove_const_impl +{ + typedef T&& type; +}; +#endif + +} // namespace detail + +// * convert a type T to non-const type - remove_const + +BOOST_TT_AUX_TYPE_TRAIT_DEF1(remove_const,T,typename boost::detail::remove_const_impl::type) +BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,remove_const,T&,T&) +#if !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS) +BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,remove_const,T const[N],T type[N]) +BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,remove_const,T const volatile[N],T volatile type[N]) +#endif + + +} // namespace boost + +#include "boost/type_traits/detail/type_trait_undef.hpp" + +#endif // BOOST_TT_REMOVE_CONST_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/type_traits/remove_cv.hpp b/realsense-file/3rd_party/boost/boost/type_traits/remove_cv.hpp new file mode 100644 index 0000000000..8933fbc7a8 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/type_traits/remove_cv.hpp @@ -0,0 +1,63 @@ + +// (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, Howard +// Hinnant & John Maddock 2000. +// Use, modification and distribution are subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + + +#ifndef BOOST_TT_REMOVE_CV_HPP_INCLUDED +#define BOOST_TT_REMOVE_CV_HPP_INCLUDED + +#include +#include "config.hpp" +#include + +#include + +// should be the last #include +#include + +namespace boost { + + +namespace detail{ + +template +struct rvalue_ref_filter_rem_cv +{ + typedef typename boost::detail::cv_traits_imp::unqualified_type type; +}; + +#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES +// +// We can't filter out rvalue_references at the same level as +// references or we get ambiguities from msvc: +// +template +struct rvalue_ref_filter_rem_cv +{ + typedef T&& type; +}; +#endif + +} + + +// convert a type T to a non-cv-qualified type - remove_cv +BOOST_TT_AUX_TYPE_TRAIT_DEF1(remove_cv,T,typename boost::detail::rvalue_ref_filter_rem_cv::type) +BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,remove_cv,T&,T&) +#if !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS) +BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,remove_cv,T const[N],T type[N]) +BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,remove_cv,T volatile[N],T type[N]) +BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,remove_cv,T const volatile[N],T type[N]) +#endif + + +} // namespace boost + +#include + +#endif // BOOST_TT_REMOVE_CV_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/type_traits/remove_pointer.hpp b/realsense-file/3rd_party/boost/boost/type_traits/remove_pointer.hpp new file mode 100644 index 0000000000..a694316c98 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/type_traits/remove_pointer.hpp @@ -0,0 +1,83 @@ + +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// Use, modification and distribution are subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_REMOVE_POINTER_HPP_INCLUDED +#define BOOST_TT_REMOVE_POINTER_HPP_INCLUDED + +#include +#include + +#if defined(BOOST_MSVC) +#include +#include +#endif + +// should be the last #include +#include + +namespace boost { + +#ifdef BOOST_MSVC + +namespace detail{ + + // + // We need all this crazy indirection because a type such as: + // + // T (*const)(U) + // + // Does not bind to a or partial specialization with VC10 and earlier + // + template + struct remove_pointer_imp + { + typedef T type; + }; + + template + struct remove_pointer_imp + { + typedef T type; + }; + + template + struct remove_pointer_imp3 + { + typedef typename remove_pointer_imp::type>::type type; + }; + + template + struct remove_pointer_imp3 + { + typedef T type; + }; + + template + struct remove_pointer_imp2 + { + typedef typename remove_pointer_imp3::value>::type type; + }; +} + +BOOST_TT_AUX_TYPE_TRAIT_DEF1(remove_pointer,T,typename boost::detail::remove_pointer_imp2::type) + +#else + +BOOST_TT_AUX_TYPE_TRAIT_DEF1(remove_pointer,T,T) +BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,remove_pointer,T*,T) +BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,remove_pointer,T* const,T) +BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,remove_pointer,T* volatile,T) +BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,remove_pointer,T* const volatile,T) + +#endif + +} // namespace boost + +#include + +#endif // BOOST_TT_REMOVE_POINTER_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/type_traits/remove_reference.hpp b/realsense-file/3rd_party/boost/boost/type_traits/remove_reference.hpp new file mode 100644 index 0000000000..3e78d5cb0d --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/type_traits/remove_reference.hpp @@ -0,0 +1,59 @@ + +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// Use, modification and distribution are subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_REMOVE_REFERENCE_HPP_INCLUDED +#define BOOST_TT_REMOVE_REFERENCE_HPP_INCLUDED + +#include +#include + +// should be the last #include +#include + +namespace boost { + + +namespace detail{ +// +// We can't filter out rvalue_references at the same level as +// references or we get ambiguities from msvc: +// +template +struct remove_rvalue_ref +{ + typedef T type; +}; +#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES +template +struct remove_rvalue_ref +{ + typedef T type; +}; +#endif + +} // namespace detail + +BOOST_TT_AUX_TYPE_TRAIT_DEF1(remove_reference,T,typename boost::detail::remove_rvalue_ref::type) +BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,remove_reference,T&,T) + +#if defined(BOOST_ILLEGAL_CV_REFERENCES) +// these are illegal specialisations; cv-qualifies applied to +// references have no effect according to [8.3.2p1], +// C++ Builder requires them though as it treats cv-qualified +// references as distinct types... +BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,remove_reference,T& const,T) +BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,remove_reference,T& volatile,T) +BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,remove_reference,T& const volatile,T) +#endif + + +} // namespace boost + +#include + +#endif // BOOST_TT_REMOVE_REFERENCE_HPP_INCLUDED diff --git a/realsense-file/3rd_party/boost/boost/type_traits/type_with_alignment.hpp b/realsense-file/3rd_party/boost/boost/type_traits/type_with_alignment.hpp new file mode 100644 index 0000000000..5318fbd060 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/type_traits/type_with_alignment.hpp @@ -0,0 +1,357 @@ +// (C) Copyright John Maddock 2000. +// Use, modification and distribution are subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_TYPE_WITH_ALIGNMENT_INCLUDED +#define BOOST_TT_TYPE_WITH_ALIGNMENT_INCLUDED + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// should be the last #include +#include + +#include + +#ifdef BOOST_MSVC +# pragma warning(push) +# pragma warning(disable: 4121) // alignment is sensitive to packing +#endif + +namespace boost { + +#ifndef __BORLANDC__ + +namespace detail { + +class alignment_dummy; +typedef void (*function_ptr)(); +typedef int (alignment_dummy::*member_ptr); +typedef int (alignment_dummy::*member_function_ptr)(); + +#ifdef BOOST_HAS_LONG_LONG +#define BOOST_TT_ALIGNMENT_BASE_TYPES BOOST_PP_TUPLE_TO_LIST( \ + 12, ( \ + char, short, int, long, ::boost::long_long_type, float, double, long double \ + , void*, function_ptr, member_ptr, member_function_ptr)) +#else +#define BOOST_TT_ALIGNMENT_BASE_TYPES BOOST_PP_TUPLE_TO_LIST( \ + 11, ( \ + char, short, int, long, float, double, long double \ + , void*, function_ptr, member_ptr, member_function_ptr)) +#endif + +#define BOOST_TT_HAS_ONE_T(D,Data,T) boost::detail::has_one_T< T > + +#define BOOST_TT_ALIGNMENT_STRUCT_TYPES \ + BOOST_PP_LIST_TRANSFORM(BOOST_TT_HAS_ONE_T, \ + X, \ + BOOST_TT_ALIGNMENT_BASE_TYPES) + +#define BOOST_TT_ALIGNMENT_TYPES \ + BOOST_PP_LIST_APPEND(BOOST_TT_ALIGNMENT_BASE_TYPES, \ + BOOST_TT_ALIGNMENT_STRUCT_TYPES) + +// +// lower_alignment_helper -- +// +// This template gets instantiated a lot, so use partial +// specialization when available to reduce the compiler burden. +// +template +struct lower_alignment_helper +{ + typedef char type; + enum { value = true }; +}; + +template +struct lower_alignment_helper +{ + enum { value = (alignment_of::value == target) }; + typedef typename mpl::if_c::type type; +}; + +#define BOOST_TT_CHOOSE_MIN_ALIGNMENT(R,P,I,T) \ + typename lower_alignment_helper< \ + BOOST_PP_CAT(found,I),target,T \ + >::type BOOST_PP_CAT(t,I); \ + enum { \ + BOOST_PP_CAT(found,BOOST_PP_INC(I)) \ + = lower_alignment_helper::value \ + }; + +#define BOOST_TT_CHOOSE_T(R,P,I,T) T BOOST_PP_CAT(t,I); + +template +struct has_one_T +{ + T data; +}; + +template +union lower_alignment +{ + enum { found0 = false }; + + BOOST_PP_LIST_FOR_EACH_I( + BOOST_TT_CHOOSE_MIN_ALIGNMENT + , ignored + , BOOST_TT_ALIGNMENT_TYPES + ) +}; + +union max_align +{ + BOOST_PP_LIST_FOR_EACH_I( + BOOST_TT_CHOOSE_T + , ignored + , BOOST_TT_ALIGNMENT_TYPES + ) +}; + +#undef BOOST_TT_ALIGNMENT_BASE_TYPES +#undef BOOST_TT_HAS_ONE_T +#undef BOOST_TT_ALIGNMENT_STRUCT_TYPES +#undef BOOST_TT_ALIGNMENT_TYPES +#undef BOOST_TT_CHOOSE_MIN_ALIGNMENT +#undef BOOST_TT_CHOOSE_T + +template +struct is_aligned +{ + BOOST_STATIC_CONSTANT(bool, + value = (TAlign >= Align) & (TAlign % Align == 0) + ); +}; + + +} // namespace detail + +template +struct is_pod< ::boost::detail::lower_alignment > +{ + BOOST_STATIC_CONSTANT(std::size_t, value = true); +}; + +// This alignment method originally due to Brian Parker, implemented by David +// Abrahams, and then ported here by Doug Gregor. +namespace detail{ + +template +class type_with_alignment_imp +{ + typedef ::boost::detail::lower_alignment t1; + typedef typename mpl::if_c< + ::boost::detail::is_aligned< ::boost::alignment_of::value,Align >::value + , t1 + , ::boost::detail::max_align + >::type align_t; + + BOOST_STATIC_CONSTANT(std::size_t, found = alignment_of::value); + + BOOST_STATIC_ASSERT(found >= Align); + BOOST_STATIC_ASSERT(found % Align == 0); + + public: + typedef align_t type; +}; + +} + +template +class type_with_alignment + : public ::boost::detail::type_with_alignment_imp +{ +}; + +#if defined(__GNUC__) || (defined (__SUNPRO_CC) && (__SUNPRO_CC >= 0x5130)) +namespace tt_align_ns { +struct __attribute__((__aligned__(2))) a2 {}; +struct __attribute__((__aligned__(4))) a4 {}; +struct __attribute__((__aligned__(8))) a8 {}; +struct __attribute__((__aligned__(16))) a16 {}; +struct __attribute__((__aligned__(32))) a32 {}; +struct __attribute__((__aligned__(64))) a64 {}; +struct __attribute__((__aligned__(128))) a128 {}; +} + +template<> class type_with_alignment<1> { public: typedef char type; }; +template<> class type_with_alignment<2> { public: typedef tt_align_ns::a2 type; }; +template<> class type_with_alignment<4> { public: typedef tt_align_ns::a4 type; }; +template<> class type_with_alignment<8> { public: typedef tt_align_ns::a8 type; }; +template<> class type_with_alignment<16> { public: typedef tt_align_ns::a16 type; }; +template<> class type_with_alignment<32> { public: typedef tt_align_ns::a32 type; }; +template<> class type_with_alignment<64> { public: typedef tt_align_ns::a64 type; }; +template<> class type_with_alignment<128> { public: typedef tt_align_ns::a128 type; }; + +namespace detail { +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::tt_align_ns::a2,true) +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::tt_align_ns::a4,true) +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::tt_align_ns::a8,true) +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::tt_align_ns::a16,true) +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::tt_align_ns::a32,true) +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::tt_align_ns::a64,true) +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::tt_align_ns::a128,true) +} +#endif +#if defined(BOOST_MSVC) || (defined(BOOST_INTEL) && defined(_MSC_VER)) +// +// MSVC supports types which have alignments greater than the normal +// maximum: these are used for example in the types __m64 and __m128 +// to provide types with alignment requirements which match the SSE +// registers. Therefore we extend type_with_alignment<> to support +// such types, however, we have to be careful to use a builtin type +// whenever possible otherwise we break previously working code: +// see http://article.gmane.org/gmane.comp.lib.boost.devel/173011 +// for an example and test case. Thus types like a8 below will +// be used *only* if the existing implementation can't provide a type +// with suitable alignment. This does mean however, that type_with_alignment<> +// may return a type which cannot be passed through a function call +// by value (and neither can any type containing such a type like +// Boost.Optional). However, this only happens when we have no choice +// in the matter because no other "ordinary" type is available. +// +namespace tt_align_ns { +struct __declspec(align(8)) a8 { + char m[8]; + typedef a8 type; +}; +struct __declspec(align(16)) a16 { + char m[16]; + typedef a16 type; +}; +struct __declspec(align(32)) a32 { + char m[32]; + typedef a32 type; +}; +struct __declspec(align(64)) a64 +{ + char m[64]; + typedef a64 type; +}; +struct __declspec(align(128)) a128 { + char m[128]; + typedef a128 type; +}; +} + +template<> class type_with_alignment<8> +{ + typedef mpl::if_c< + ::boost::alignment_of::value < 8, + tt_align_ns::a8, + boost::detail::type_with_alignment_imp<8> >::type t1; +public: + typedef t1::type type; +}; +template<> class type_with_alignment<16> +{ + typedef mpl::if_c< + ::boost::alignment_of::value < 16, + tt_align_ns::a16, + boost::detail::type_with_alignment_imp<16> >::type t1; +public: + typedef t1::type type; +}; +template<> class type_with_alignment<32> +{ + typedef mpl::if_c< + ::boost::alignment_of::value < 32, + tt_align_ns::a32, + boost::detail::type_with_alignment_imp<32> >::type t1; +public: + typedef t1::type type; +}; +template<> class type_with_alignment<64> { + typedef mpl::if_c< + ::boost::alignment_of::value < 64, + tt_align_ns::a64, + boost::detail::type_with_alignment_imp<64> >::type t1; +public: + typedef t1::type type; +}; +template<> class type_with_alignment<128> { + typedef mpl::if_c< + ::boost::alignment_of::value < 128, + tt_align_ns::a128, + boost::detail::type_with_alignment_imp<128> >::type t1; +public: + typedef t1::type type; +}; + +namespace detail { +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::tt_align_ns::a8,true) +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::tt_align_ns::a16,true) +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::tt_align_ns::a32,true) +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::tt_align_ns::a64,true) +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::tt_align_ns::a128,true) +} +#endif + +#else + +// +// Borland specific version, we have this for two reasons: +// 1) The version above doesn't always compile (with the new test cases for example) +// 2) Because of Borlands #pragma option we can create types with alignments that are +// greater that the largest aligned builtin type. + +namespace tt_align_ns{ +#pragma option push -a16 +struct a2{ short s; }; +struct a4{ int s; }; +struct a8{ double s; }; +struct a16{ long double s; }; +#pragma option pop +} + +namespace detail { + +typedef ::boost::tt_align_ns::a16 max_align; + +//#if ! BOOST_WORKAROUND(__CODEGEARC__, BOOST_TESTED_AT(0x610)) +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::tt_align_ns::a2,true) +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::tt_align_ns::a4,true) +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::tt_align_ns::a8,true) +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::tt_align_ns::a16,true) +//#endif +} + +template struct type_with_alignment +{ + // We should never get to here, but if we do use the maximally + // aligned type: + // BOOST_STATIC_ASSERT(0); + typedef tt_align_ns::a16 type; +}; +template <> struct type_with_alignment<1>{ typedef char type; }; +template <> struct type_with_alignment<2>{ typedef tt_align_ns::a2 type; }; +template <> struct type_with_alignment<4>{ typedef tt_align_ns::a4 type; }; +template <> struct type_with_alignment<8>{ typedef tt_align_ns::a8 type; }; +template <> struct type_with_alignment<16>{ typedef tt_align_ns::a16 type; }; + +#endif + +} // namespace boost + +#ifdef BOOST_MSVC +# pragma warning(pop) +#endif + +#include + +#endif // BOOST_TT_TYPE_WITH_ALIGNMENT_INCLUDED + + diff --git a/realsense-file/3rd_party/boost/boost/utility/addressof.hpp b/realsense-file/3rd_party/boost/boost/utility/addressof.hpp new file mode 100644 index 0000000000..eb4ab2db9d --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/utility/addressof.hpp @@ -0,0 +1,17 @@ +/* + * Copyright (c) 2014 Glen Fernandes + * + * 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_UTILITY_ADDRESSOF_HPP +#define BOOST_UTILITY_ADDRESSOF_HPP + +// The header file at this path is deprecated; +// use boost/core/addressof.hpp instead. + +#include + +#endif diff --git a/realsense-file/3rd_party/boost/boost/utility/base_from_member.hpp b/realsense-file/3rd_party/boost/boost/utility/base_from_member.hpp new file mode 100644 index 0000000000..47682a9ca6 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/utility/base_from_member.hpp @@ -0,0 +1,171 @@ +// boost utility/base_from_member.hpp header file --------------------------// + +// Copyright 2001, 2003, 2004, 2012 Daryle Walker. Use, modification, and +// distribution are subject to the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or a copy at +// .) + +// See for the library's home page. + +#ifndef BOOST_UTILITY_BASE_FROM_MEMBER_HPP +#define BOOST_UTILITY_BASE_FROM_MEMBER_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +// Base-from-member arity configuration macro ------------------------------// + +// The following macro determines how many arguments will be in the largest +// constructor template of base_from_member. Constructor templates will be +// generated from one argument to this maximum. Code from other files can read +// this number if they need to always match the exact maximum base_from_member +// uses. The maximum constructor length can be changed by overriding the +// #defined constant. Make sure to apply the override, if any, for all source +// files during project compiling for consistency. + +// Contributed by Jonathan Turkanis + +#ifndef BOOST_BASE_FROM_MEMBER_MAX_ARITY +#define BOOST_BASE_FROM_MEMBER_MAX_ARITY 10 +#endif + + +// An iteration of a constructor template for base_from_member -------------// + +// A macro that should expand to: +// template < typename T1, ..., typename Tn > +// base_from_member( T1 x1, ..., Tn xn ) +// : member( x1, ..., xn ) +// {} +// This macro should only persist within this file. + +#define BOOST_PRIVATE_CTR_DEF( z, n, data ) \ + template < BOOST_PP_ENUM_PARAMS(n, typename T) > \ + explicit base_from_member( BOOST_PP_ENUM_BINARY_PARAMS(n, T, x) ) \ + : member( BOOST_PP_ENUM_PARAMS(n, x) ) \ + {} \ + /**/ + + +namespace boost +{ + +namespace detail +{ + +// Type-unmarking class template -------------------------------------------// + +// Type-trait to get the raw type, i.e. the type without top-level reference nor +// cv-qualification, from a type expression. Mainly for function arguments, any +// reference part is stripped first. + +// Contributed by Daryle Walker + +template < typename T > +struct remove_cv_ref +{ + typedef typename ::boost::remove_cv::type>::type type; + +}; // boost::detail::remove_cv_ref + +// Unmarked-type comparison class template ---------------------------------// + +// Type-trait to check if two type expressions have the same raw type. + +// Contributed by Daryle Walker, based on a work-around by Luc Danton + +template < typename T, typename U > +struct is_related + : public ::boost::is_same< + typename ::boost::detail::remove_cv_ref::type, + typename ::boost::detail::remove_cv_ref::type > +{}; + +// Enable-if-on-unidentical-unmarked-type class template -------------------// + +// Enable-if on the first two type expressions NOT having the same raw type. + +// Contributed by Daryle Walker, based on a work-around by Luc Danton + +#ifndef BOOST_NO_CXX11_VARIADIC_TEMPLATES +template +struct enable_if_unrelated + : public ::boost::enable_if_c +{}; + +template +struct enable_if_unrelated + : public ::boost::disable_if< ::boost::detail::is_related > +{}; +#endif + +} // namespace boost::detail + + +// Base-from-member class template -----------------------------------------// + +// Helper to initialize a base object so a derived class can use this +// object in the initialization of another base class. Used by +// Dietmar Kuehl from ideas by Ron Klatcho to solve the problem of a +// base class needing to be initialized by a member. + +// Contributed by Daryle Walker + +template < typename MemberType, int UniqueID = 0 > +class base_from_member +{ +protected: + MemberType member; + +#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && \ + !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && \ + !defined(BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS) && \ + !(defined(__GNUC__) && (__GNUC__ == 4) && (__GNUC_MINOR__ < 4)) + template ::type> + explicit BOOST_CONSTEXPR base_from_member( T&& ...x ) + BOOST_NOEXCEPT_IF( BOOST_NOEXCEPT_EXPR(::new ((void*) 0) MemberType( + static_cast(x)... )) ) // no std::is_nothrow_constructible... + : member( static_cast(x)... ) // ...nor std::forward needed + {} +#else + base_from_member() + : member() + {} + + BOOST_PP_REPEAT_FROM_TO( 1, BOOST_PP_INC(BOOST_BASE_FROM_MEMBER_MAX_ARITY), + BOOST_PRIVATE_CTR_DEF, _ ) +#endif + +}; // boost::base_from_member + +template < typename MemberType, int UniqueID > +class base_from_member +{ +protected: + MemberType& member; + + explicit BOOST_CONSTEXPR base_from_member( MemberType& x ) + BOOST_NOEXCEPT + : member( x ) + {} + +}; // boost::base_from_member + +} // namespace boost + + +// Undo any private macros +#undef BOOST_PRIVATE_CTR_DEF + + +#endif // BOOST_UTILITY_BASE_FROM_MEMBER_HPP diff --git a/realsense-file/3rd_party/boost/boost/utility/compare_pointees.hpp b/realsense-file/3rd_party/boost/boost/utility/compare_pointees.hpp new file mode 100644 index 0000000000..136c058e19 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/utility/compare_pointees.hpp @@ -0,0 +1,68 @@ +// Copyright (C) 2003, Fernando Luis Cacciola Carballal. +// +// Use, modification, and distribution is subject to the Boost Software +// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/optional for documentation. +// +// You are welcome to contact the author at: +// fernando_cacciola@hotmail.com +// +#ifndef BOOST_UTILITY_COMPARE_POINTEES_25AGO2003_HPP +#define BOOST_UTILITY_COMPARE_POINTEES_25AGO2003_HPP + +#include + +namespace boost { + +// template bool equal_pointees(OP const& x, OP const& y); +// template struct equal_pointees_t; +// +// Being OP a model of OptionalPointee (either a pointer or an optional): +// +// If both x and y have valid pointees, returns the result of (*x == *y) +// If only one has a valid pointee, returns false. +// If none have valid pointees, returns true. +// No-throw +template +inline +bool equal_pointees ( OptionalPointee const& x, OptionalPointee const& y ) +{ + return (!x) != (!y) ? false : ( !x ? true : (*x) == (*y) ) ; +} + +template +struct equal_pointees_t : std::binary_function +{ + bool operator() ( OptionalPointee const& x, OptionalPointee const& y ) const + { return equal_pointees(x,y) ; } +} ; + +// template bool less_pointees(OP const& x, OP const& y); +// template struct less_pointees_t; +// +// Being OP a model of OptionalPointee (either a pointer or an optional): +// +// If y has not a valid pointee, returns false. +// ElseIf x has not a valid pointee, returns true. +// ElseIf both x and y have valid pointees, returns the result of (*x < *y) +// No-throw +template +inline +bool less_pointees ( OptionalPointee const& x, OptionalPointee const& y ) +{ + return !y ? false : ( !x ? true : (*x) < (*y) ) ; +} + +template +struct less_pointees_t : std::binary_function +{ + bool operator() ( OptionalPointee const& x, OptionalPointee const& y ) const + { return less_pointees(x,y) ; } +} ; + +} // namespace boost + +#endif + diff --git a/realsense-file/3rd_party/boost/boost/utility/declval.hpp b/realsense-file/3rd_party/boost/boost/utility/declval.hpp new file mode 100644 index 0000000000..42050cb4de --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/utility/declval.hpp @@ -0,0 +1,44 @@ +// declval.hpp -------------------------------------------------------------// + +// Copyright 2010 Vicente J. Botet Escriba + +// Distributed under the Boost Software License, Version 1.0. +// See http://www.boost.org/LICENSE_1_0.txt + +#ifndef BOOST_UTILITY_DECLVAL_HPP +#define BOOST_UTILITY_DECLVAL_HPP + +#include + +//----------------------------------------------------------------------------// + +#include + +//----------------------------------------------------------------------------// +// // +// C++03 implementation of // +// 20.2.4 Function template declval [declval] // +// Written by Vicente J. Botet Escriba // +// // +// 1 The library provides the function template declval to simplify the +// definition of expressions which occur as unevaluated operands. +// 2 Remarks: If this function is used, the program is ill-formed. +// 3 Remarks: The template parameter T of declval may be an incomplete type. +// [ Example: +// +// template +// decltype(static_cast(declval())) convert(From&&); +// +// declares a function template convert which only participates in overloading +// if the type From can be explicitly converted to type To. For another example +// see class template common_type (20.9.7.6). -end example ] +//----------------------------------------------------------------------------// + +namespace boost { + + template + typename add_rvalue_reference::type declval() BOOST_NOEXCEPT; // as unevaluated operand + +} // namespace boost + +#endif // BOOST_UTILITY_DECLVAL_HPP diff --git a/realsense-file/3rd_party/boost/boost/utility/detail/in_place_factory_prefix.hpp b/realsense-file/3rd_party/boost/boost/utility/detail/in_place_factory_prefix.hpp new file mode 100644 index 0000000000..ee38c67003 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/utility/detail/in_place_factory_prefix.hpp @@ -0,0 +1,36 @@ +// Copyright (C) 2003, Fernando Luis Cacciola Carballal. +// Copyright (C) 2007, Tobias Schwinger. +// +// Use, modification, and distribution is subject to the Boost Software +// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/optional for documentation. +// +// You are welcome to contact the author at: +// fernando_cacciola@hotmail.com +// +#ifndef BOOST_UTILITY_DETAIL_INPLACE_FACTORY_PREFIX_04APR2007_HPP +#define BOOST_UTILITY_DETAIL_INPLACE_FACTORY_PREFIX_04APR2007_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define BOOST_DEFINE_INPLACE_FACTORY_CLASS_MEMBER_INIT(z,n,_) BOOST_PP_CAT(m_a,n) BOOST_PP_LPAREN() BOOST_PP_CAT(a,n) BOOST_PP_RPAREN() +#define BOOST_DEFINE_INPLACE_FACTORY_CLASS_MEMBER_DECL(z,n,_) BOOST_PP_CAT(A,n) const& BOOST_PP_CAT(m_a,n); + +#define BOOST_MAX_INPLACE_FACTORY_ARITY 10 + +#undef BOOST_UTILITY_DETAIL_INPLACE_FACTORY_SUFFIX_04APR2007_HPP + +#endif + diff --git a/realsense-file/3rd_party/boost/boost/utility/detail/in_place_factory_suffix.hpp b/realsense-file/3rd_party/boost/boost/utility/detail/in_place_factory_suffix.hpp new file mode 100644 index 0000000000..009d64c5d5 --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/utility/detail/in_place_factory_suffix.hpp @@ -0,0 +1,23 @@ +// Copyright (C) 2003, Fernando Luis Cacciola Carballal. +// Copyright (C) 2007, Tobias Schwinger. +// +// Use, modification, and distribution is subject to the Boost Software +// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/optional for documentation. +// +// You are welcome to contact the author at: +// fernando_cacciola@hotmail.com +// +#ifndef BOOST_UTILITY_DETAIL_INPLACE_FACTORY_SUFFIX_04APR2007_HPP +#define BOOST_UTILITY_DETAIL_INPLACE_FACTORY_SUFFIX_04APR2007_HPP + +#undef BOOST_DEFINE_INPLACE_FACTORY_CLASS_MEMBER_INIT +#undef BOOST_DEFINE_INPLACE_FACTORY_CLASS_MEMBER_DECL +#undef BOOST_MAX_INPLACE_FACTORY_ARITY + +#undef BOOST_UTILITY_DETAIL_INPLACE_FACTORY_PREFIX_04APR2007_HPP + +#endif + diff --git a/realsense-file/3rd_party/boost/boost/utility/enable_if.hpp b/realsense-file/3rd_party/boost/boost/utility/enable_if.hpp new file mode 100644 index 0000000000..3aa2f6df7a --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/utility/enable_if.hpp @@ -0,0 +1,17 @@ +/* + * Copyright (c) 2014 Glen Fernandes + * + * 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_UTILITY_ENABLE_IF_HPP +#define BOOST_UTILITY_ENABLE_IF_HPP + +// The header file at this path is deprecated; +// use boost/core/enable_if.hpp instead. + +#include "boost/core/enable_if.hpp" + +#endif diff --git a/realsense-file/3rd_party/boost/boost/utility/in_place_factory.hpp b/realsense-file/3rd_party/boost/boost/utility/in_place_factory.hpp new file mode 100644 index 0000000000..c25cbb21fd --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/utility/in_place_factory.hpp @@ -0,0 +1,86 @@ +// Copyright (C) 2003, Fernando Luis Cacciola Carballal. +// Copyright (C) 2007, Tobias Schwinger. +// +// Use, modification, and distribution is subject to the Boost Software +// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/optional for documentation. +// +// You are welcome to contact the author at: +// fernando_cacciola@hotmail.com +// +#ifndef BOOST_UTILITY_INPLACE_FACTORY_04APR2007_HPP +#ifndef BOOST_PP_IS_ITERATING + +#include + +namespace boost { + +class in_place_factory_base {} ; + +#define BOOST_PP_ITERATION_LIMITS (0, BOOST_MAX_INPLACE_FACTORY_ARITY) +#define BOOST_PP_FILENAME_1 +#include BOOST_PP_ITERATE() + +} // namespace boost + +#include + +#define BOOST_UTILITY_INPLACE_FACTORY_04APR2007_HPP +#else +#define N BOOST_PP_ITERATION() + +#if N +template< BOOST_PP_ENUM_PARAMS(N, class A) > +#endif +class BOOST_PP_CAT(in_place_factory,N) + : + public in_place_factory_base +{ +public: + + explicit BOOST_PP_CAT(in_place_factory,N) + ( BOOST_PP_ENUM_BINARY_PARAMS(N,A,const& a) ) +#if N > 0 + : BOOST_PP_ENUM(N, BOOST_DEFINE_INPLACE_FACTORY_CLASS_MEMBER_INIT, _) +#endif + {} + + template + void* apply(void* address) const + { + return new(address) T( BOOST_PP_ENUM_PARAMS(N, m_a) ); + } + + template + void* apply(void* address, std::size_t n) const + { + for(char* next = address = this->BOOST_NESTED_TEMPLATE apply(address); + !! --n;) + this->BOOST_NESTED_TEMPLATE apply(next = next+sizeof(T)); + return address; + } + + BOOST_PP_REPEAT(N, BOOST_DEFINE_INPLACE_FACTORY_CLASS_MEMBER_DECL, _) +}; + +#if N > 0 +template< BOOST_PP_ENUM_PARAMS(N, class A) > +inline BOOST_PP_CAT(in_place_factory,N)< BOOST_PP_ENUM_PARAMS(N, A) > +in_place( BOOST_PP_ENUM_BINARY_PARAMS(N, A, const& a) ) +{ + return BOOST_PP_CAT(in_place_factory,N)< BOOST_PP_ENUM_PARAMS(N, A) > + ( BOOST_PP_ENUM_PARAMS(N, a) ); +} +#else +inline in_place_factory0 in_place() +{ + return in_place_factory0(); +} +#endif + +#undef N +#endif +#endif + diff --git a/realsense-file/3rd_party/boost/boost/utility/swap.hpp b/realsense-file/3rd_party/boost/boost/utility/swap.hpp new file mode 100644 index 0000000000..b0866d770e --- /dev/null +++ b/realsense-file/3rd_party/boost/boost/utility/swap.hpp @@ -0,0 +1,17 @@ +/* + * Copyright (c) 2014 Glen Fernandes + * + * 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_UTILITY_SWAP_HPP +#define BOOST_UTILITY_SWAP_HPP + +// The header file at this path is deprecated; +// use boost/core/swap.hpp instead. + +#include + +#endif diff --git a/realsense-file/3rd_party/rosbag/console_bridge/include/console_bridge/console.h b/realsense-file/3rd_party/rosbag/console_bridge/include/console_bridge/console.h new file mode 100644 index 0000000000..9eb998851f --- /dev/null +++ b/realsense-file/3rd_party/rosbag/console_bridge/include/console_bridge/console.h @@ -0,0 +1,206 @@ +/********************************************************************* +* Software License Agreement (BSD License) +* +* Copyright (c) 2008, Willow Garage, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions +* are met: +* +* * Redistributions of source code must retain the above copyright +* notice, this list of conditions and the following disclaimer. +* * Redistributions in binary form must reproduce the above +* copyright notice, this list of conditions and the following +* disclaimer in the documentation and/or other materials provided +* with the distribution. +* * Neither the name of the Willow Garage nor the names of its +* contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*********************************************************************/ + +/* Author: Ryan Luna, Ioan Sucan */ + +#ifndef CONSOLE_BRIDGE_CONSOLE_ +#define CONSOLE_BRIDGE_CONSOLE_ + +#include + +#include "exportdecl.h" +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" +#ifdef __GNUC__ +#define CONSOLE_BRIDGE_DEPRECATED __attribute__ ((deprecated)) +#elif defined(_MSC_VER) +#define CONSOLE_BRIDGE_DEPRECATED __declspec(deprecated) +#else +#pragma message("WARNING: You need to implement DEPRECATED for this compiler") +#define CONSOLE_BRIDGE_DEPRECATED +#endif + +static inline void CONSOLE_BRIDGE_DEPRECATED console_bridge_deprecated() {} + +/** \file console.h + \defgroup logging Logging Macros + \{ + + \def logError(fmt, ...) + \brief Log a formatted error string. + \remarks This macro takes the same arguments as printf. + + \def logWarn(fmt, ...) + \brief Log a formatted warning string. + \remarks This macro takes the same arguments as printf. + + \def logInform(fmt, ...) + \brief Log a formatted information string. + \remarks This macro takes the same arguments as printf. + + \def logDebug(fmt, ...) + \brief Log a formatted debugging string. + \remarks This macro takes the same arguments as printf. + + \} +*/ +#define CONSOLE_BRIDGE_logError(fmt, ...) \ + console_bridge::log(__FILE__, __LINE__, console_bridge::CONSOLE_BRIDGE_LOG_ERROR, fmt, ##__VA_ARGS__) + +#define CONSOLE_BRIDGE_logWarn(fmt, ...) \ + console_bridge::log(__FILE__, __LINE__, console_bridge::CONSOLE_BRIDGE_LOG_WARN, fmt, ##__VA_ARGS__) + +#define CONSOLE_BRIDGE_logInform(fmt, ...) \ + console_bridge::log(__FILE__, __LINE__, console_bridge::CONSOLE_BRIDGE_LOG_INFO, fmt, ##__VA_ARGS__) + +#define CONSOLE_BRIDGE_logDebug(fmt, ...) \ + console_bridge::log(__FILE__, __LINE__, console_bridge::CONSOLE_BRIDGE_LOG_DEBUG, fmt, ##__VA_ARGS__) + +#define logError(fmt, ...) \ + console_bridge::log_deprecated(__FILE__, __LINE__, console_bridge::CONSOLE_BRIDGE_LOG_ERROR, fmt, ##__VA_ARGS__) + +#define logWarn(fmt, ...) \ + console_bridge::log_deprecated(__FILE__, __LINE__, console_bridge::CONSOLE_BRIDGE_LOG_WARN, fmt, ##__VA_ARGS__) + +#define logInform(fmt, ...) \ + console_bridge::log_deprecated(__FILE__, __LINE__, console_bridge::CONSOLE_BRIDGE_LOG_INFO, fmt, ##__VA_ARGS__) + +#define logDebug(fmt, ...) \ + console_bridge::log_deprecated(__FILE__, __LINE__, console_bridge::CONSOLE_BRIDGE_LOG_DEBUG, fmt, ##__VA_ARGS__) + + +/** \brief Message namespace. This contains classes needed to + output error messages (or logging) from within the library. + Message logging can be performed with \ref logging "logging macros" */ +namespace console_bridge +{ +/** \brief The set of priorities for message logging */ +enum LogLevel + { + CONSOLE_BRIDGE_LOG_DEBUG = 0, + CONSOLE_BRIDGE_LOG_INFO, + CONSOLE_BRIDGE_LOG_WARN, + CONSOLE_BRIDGE_LOG_ERROR, + CONSOLE_BRIDGE_LOG_NONE + }; + +/** \brief Generic class to handle output from a piece of + code. + + In order to handle output from the library in different + ways, an implementation of this class needs to be + provided. This instance can be set with the useOutputHandler + function. */ +class OutputHandler +{ +public: + + OutputHandler(void) + { + } + + virtual ~OutputHandler(void) + { + } + + /** \brief log a message to the output handler with the given text + and logging level from a specific file and line number */ + virtual void log(const std::string &text, LogLevel level, const char *filename, int line) = 0; +}; + +/** \brief Default implementation of OutputHandler. This sends + the information to the console. */ +class OutputHandlerSTD : public OutputHandler +{ +public: + + OutputHandlerSTD(void) : OutputHandler() + { + } + + virtual void log(const std::string &text, LogLevel level, const char *filename, int line); + +}; + +/** \brief Implementation of OutputHandler that saves messages in a file. */ +class OutputHandlerFile : public OutputHandler +{ +public: + + /** \brief The name of the file in which to save the message data */ + OutputHandlerFile(const char *filename); + + virtual ~OutputHandlerFile(void); + + virtual void log(const std::string &text, LogLevel level, const char *filename, int line); + +private: + + /** \brief The file to save to */ + FILE *file_; + +}; + +/** \brief This function instructs ompl that no messages should be outputted. Equivalent to useOutputHandler(NULL) */ +void noOutputHandler(void); + +/** \brief Restore the output handler that was previously in use (if any) */ +void restorePreviousOutputHandler(void); + +/** \brief Specify the instance of the OutputHandler to use. By default, this is OutputHandlerSTD */ +void useOutputHandler(OutputHandler *oh); + +/** \brief Get the instance of the OutputHandler currently used. This is NULL in case there is no output handler. */ +OutputHandler* getOutputHandler(void); + +/** \brief Set the minimum level of logging data to output. Messages + with lower logging levels will not be recorded. */ +void setLogLevel(LogLevel level); + +/** \brief Retrieve the current level of logging data. Messages + with lower logging levels will not be recorded. */ +LogLevel getLogLevel(void); + +/** \brief Root level logging function. This should not be invoked directly, + but rather used via a \ref logging "logging macro". Formats the message + string given the arguments and forwards the string to the output handler */ +void log(const char *file, int line, LogLevel level, const char* m, ...); + +/** \brief Root level logging function. This should not be invoked directly, + but rather used via a \ref logging "logging macro". Formats the message + string given the arguments and forwards the string to the output handler */ +CONSOLE_BRIDGE_DEPRECATED void log_deprecated(const char *file, int line, LogLevel level, const char* m, ...); +} + + +#endif diff --git a/realsense-file/3rd_party/rosbag/console_bridge/include/console_bridge/exportdecl.h b/realsense-file/3rd_party/rosbag/console_bridge/include/console_bridge/exportdecl.h new file mode 100644 index 0000000000..57d5b0bcb7 --- /dev/null +++ b/realsense-file/3rd_party/rosbag/console_bridge/include/console_bridge/exportdecl.h @@ -0,0 +1,84 @@ +/********************************************************************* +* Software License Agreement (BSD License) +* +* Copyright (c) 2008, Willow Garage, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions +* are met: +* +* * Redistributions of source code must retain the above copyright +* notice, this list of conditions and the following disclaimer. +* * Redistributions in binary form must reproduce the above +* copyright notice, this list of conditions and the following +* disclaimer in the documentation and/or other materials provided +* with the distribution. +* * Neither the name of the Willow Garage nor the names of its +* contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*********************************************************************/ + +/* Author: Thomas Moulard */ + +#ifndef CONSOLE_BRIDGE_EXPORTDECL_H +# define CONSOLE_BRIDGE_EXPORTDECL_H + +// Handle portable symbol export. +// Defining manually which symbol should be exported is required +// under Windows whether MinGW or MSVC is used. +// +// The headers then have to be able to work in two different modes: +// - dllexport when one is building the library, +// - dllimport for clients using the library. +// +// On Linux, set the visibility accordingly. If C++ symbol visibility +// is handled by the compiler, see: http://gcc.gnu.org/wiki/Visibility +# if defined _WIN32 || defined __CYGWIN__ +// On Microsoft Windows, use dllimport and dllexport to tag symbols. +//# define CONSOLE_BRIDGE_DLLIMPORT __declspec(dllimport) +//# define CONSOLE_BRIDGE_DLLEXPORT __declspec(dllexport) +//# define CONSOLE_BRIDGE_DLLLOCAL +# else +// On Linux, for GCC >= 4, tag symbols using GCC extension. +# if __GNUC__ >= 4 +# define CONSOLE_BRIDGE_DLLIMPORT __attribute__ ((visibility("default"))) +# define CONSOLE_BRIDGE_DLLEXPORT __attribute__ ((visibility("default"))) +# define CONSOLE_BRIDGE_DLLLOCAL __attribute__ ((visibility("hidden"))) +# else +// Otherwise (GCC < 4 or another compiler is used), export everything. +# define CONSOLE_BRIDGE_DLLIMPORT +# define CONSOLE_BRIDGE_DLLEXPORT +# define CONSOLE_BRIDGE_DLLLOCAL +# endif // __GNUC__ >= 4 +# endif // defined _WIN32 || defined __CYGWIN__ + +# ifdef CONSOLE_BRIDGE_STATIC +// If one is using the library statically, get rid of +// extra information. +# define CONSOLE_BRIDGE_DLLAPI +# define CONSOLE_BRIDGE_LOCAL +# else +// Depending on whether one is building or using the +// library define DLLAPI to import or export. +# ifdef console_bridge_EXPORTS +# define CONSOLE_BRIDGE_DLLAPI CONSOLE_BRIDGE_DLLEXPORT +# else +# define CONSOLE_BRIDGE_DLLAPI CONSOLE_BRIDGE_DLLIMPORT +# endif // CONSOLE_BRIDGE_EXPORTS +# define CONSOLE_BRIDGE_LOCAL CONSOLE_BRIDGE_DLLLOCAL +# endif // CONSOLE_BRIDGE_STATIC +#endif //! CONSOLE_BRIDGE_EXPORTDECL_H diff --git a/realsense-file/3rd_party/rosbag/console_bridge/src/console.cpp b/realsense-file/3rd_party/rosbag/console_bridge/src/console.cpp new file mode 100644 index 0000000000..36f8ec9eff --- /dev/null +++ b/realsense-file/3rd_party/rosbag/console_bridge/src/console.cpp @@ -0,0 +1,209 @@ +/********************************************************************* +* Software License Agreement (BSD License) +* +* Copyright (c) 2008, Willow Garage, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions +* are met: +* +* * Redistributions of source code must retain the above copyright +* notice, this list of conditions and the following disclaimer. +* * Redistributions in binary form must reproduce the above +* copyright notice, this list of conditions and the following +* disclaimer in the documentation and/or other materials provided +* with the distribution. +* * Neither the name of the Willow Garage nor the names of its +* contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*********************************************************************/ + +/* Author: Ryan Luna, Ioan Sucan */ + +#include "console_bridge/console.h" + +#include +#include + +#include +#include + +/// @cond IGNORE + +struct DefaultOutputHandler +{ + DefaultOutputHandler(void) + { + output_handler_ = static_cast(&std_output_handler_); + previous_output_handler_ = output_handler_; + logLevel_ = console_bridge::CONSOLE_BRIDGE_LOG_WARN; + } + + console_bridge::OutputHandlerSTD std_output_handler_; + console_bridge::OutputHandler *output_handler_; + console_bridge::OutputHandler *previous_output_handler_; + console_bridge::LogLevel logLevel_; + std::mutex lock_; // it is likely the outputhandler does some I/O, so we serialize it +}; + +// we use this function because we want to handle static initialization correctly +// however, the first run of this function is not thread safe, due to the use of a static +// variable inside the function. For this reason, we ensure the first call happens during +// static initialization using a proxy class +static DefaultOutputHandler* getDOH(void) +{ + static DefaultOutputHandler DOH; + return &DOH; +} + +#define USE_DOH \ + DefaultOutputHandler *doh = getDOH(); \ + std::lock_guard lock_guard(doh->lock_) + +#define MAX_BUFFER_SIZE 1024 + +/// @endcond + +void console_bridge::noOutputHandler(void) +{ + USE_DOH; + doh->previous_output_handler_ = doh->output_handler_; + doh->output_handler_ = NULL; +} + +void console_bridge::restorePreviousOutputHandler(void) +{ + USE_DOH; + std::swap(doh->previous_output_handler_, doh->output_handler_); +} + +void console_bridge::useOutputHandler(OutputHandler *oh) +{ + USE_DOH; + doh->previous_output_handler_ = doh->output_handler_; + doh->output_handler_ = oh; +} + +console_bridge::OutputHandler* console_bridge::getOutputHandler(void) +{ + return getDOH()->output_handler_; +} + +void console_bridge::log_deprecated(const char *file, int line, + LogLevel level, const char* m, ...) +{ + /* + * Workaround: see bug ros/console 30 + * Exact copy of console_bridge::log, please remove it once the + * deprecation time expires. + */ + USE_DOH; + if (doh->output_handler_ && level >= doh->logLevel_) + { + va_list __ap; + va_start(__ap, m); + char buf[MAX_BUFFER_SIZE]; +#ifdef _MSC_VER + vsnprintf_s(buf, sizeof(buf), _TRUNCATE, m, __ap); +#else + vsnprintf(buf, sizeof(buf), m, __ap); +#endif + va_end(__ap); + buf[MAX_BUFFER_SIZE - 1] = '\0'; + + doh->output_handler_->log(buf, level, file, line); + } +} + +void console_bridge::log(const char *file, int line, LogLevel level, const char* m, ...) +{ + USE_DOH; + if (doh->output_handler_ && level >= doh->logLevel_) + { + va_list __ap; + va_start(__ap, m); + char buf[MAX_BUFFER_SIZE]; +#ifdef _MSC_VER + vsnprintf_s(buf, sizeof(buf), _TRUNCATE, m, __ap); +#else + vsnprintf(buf, sizeof(buf), m, __ap); +#endif + va_end(__ap); + buf[MAX_BUFFER_SIZE - 1] = '\0'; + + doh->output_handler_->log(buf, level, file, line); + } +} + +void console_bridge::setLogLevel(LogLevel level) +{ + USE_DOH; + doh->logLevel_ = level; +} + +console_bridge::LogLevel console_bridge::getLogLevel(void) +{ + USE_DOH; + return doh->logLevel_; +} + +static const char* LogLevelString[4] = {"Debug: ", "Info: ", "Warning: ", "Error: "}; + +void console_bridge::OutputHandlerSTD::log(const std::string &text, LogLevel level, const char *filename, int line) +{ + if (level >= CONSOLE_BRIDGE_LOG_WARN) + { + std::cerr << LogLevelString[level] << text << std::endl; + std::cerr << " at line " << line << " in " << filename << std::endl; + std::cerr.flush(); + } + else + { + std::cout << LogLevelString[level] << text << std::endl; + std::cout.flush(); + } +} + +console_bridge::OutputHandlerFile::OutputHandlerFile(const char *filename) : OutputHandler() +{ +#ifdef _MSC_VER + errno_t err = fopen_s(&file_, filename, "a"); + if (err != 0 || !file_) +#else + file_ = fopen(filename, "a"); + if (!file_) +#endif + std::cerr << "Unable to open log file: '" << filename << "'" << std::endl; +} + +console_bridge::OutputHandlerFile::~OutputHandlerFile(void) +{ + if (file_) + if (fclose(file_) != 0) + std::cerr << "Error closing logfile" << std::endl; +} + +void console_bridge::OutputHandlerFile::log(const std::string &text, LogLevel level, const char *filename, int line) +{ + if (file_) + { + fprintf(file_, "%s%s\n", LogLevelString[level], text.c_str()); + if(level >= CONSOLE_BRIDGE_LOG_WARN) + fprintf(file_, " at line %d in %s\n", line, filename); + fflush(file_); + } +} diff --git a/realsense-file/3rd_party/rosbag/cpp_common/include/ros/cpp_common_decl.h b/realsense-file/3rd_party/rosbag/cpp_common/include/ros/cpp_common_decl.h new file mode 100644 index 0000000000..a3b89798a6 --- /dev/null +++ b/realsense-file/3rd_party/rosbag/cpp_common/include/ros/cpp_common_decl.h @@ -0,0 +1,42 @@ +/* + * Copyright (C) 2009, Willow Garage, Inc. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the names of Stanford University or Willow Garage, Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ +#ifndef ROS_CPP_COMMON_DECL_H_INCLUDED +#define ROS_CPP_COMMON_DECL_H_INCLUDED + +#include "../../../rosbag_storage/include/rosbag/macros.h" + +#ifdef ROS_BUILD_SHARED_LIBS // ros is being built around shared libraries + #ifdef cpp_common_EXPORTS // we are building a shared lib/dll + #define CPP_COMMON_DECL ROS_HELPER_EXPORT + #else // we are using shared lib/dll + #define CPP_COMMON_DECL ROS_HELPER_IMPORT + #endif +#else // ros is being built around static libraries + #define CPP_COMMON_DECL +#endif + +#endif diff --git a/realsense-file/3rd_party/rosbag/cpp_common/include/ros/datatypes.h b/realsense-file/3rd_party/rosbag/cpp_common/include/ros/datatypes.h new file mode 100644 index 0000000000..42ce56ef92 --- /dev/null +++ b/realsense-file/3rd_party/rosbag/cpp_common/include/ros/datatypes.h @@ -0,0 +1,52 @@ +/* + * Copyright (C) 2008, Morgan Quigley and Willow Garage, Inc. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the names of Stanford University or Willow Garage, Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef CPP_CORE_TYPES_H +#define CPP_CORE_TYPES_H + +#include +#include +#include +#include +#include +#include +//#include + + +namespace ros { + +typedef std::vector > VP_string; +typedef std::vector V_string; +typedef std::set S_string; +typedef std::map M_string; +typedef std::pair StringPair; + +typedef std::shared_ptr M_stringPtr; + +} + +#endif // CPP_CORE_TYPES_H diff --git a/realsense-file/3rd_party/rosbag/cpp_common/include/ros/debug.h b/realsense-file/3rd_party/rosbag/cpp_common/include/ros/debug.h new file mode 100644 index 0000000000..e0c182ca87 --- /dev/null +++ b/realsense-file/3rd_party/rosbag/cpp_common/include/ros/debug.h @@ -0,0 +1,54 @@ +/* + * Copyright (C) 2009, Willow Garage, Inc. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the names of Stanford University or Willow Garage, Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef ROSLIB_DEBUG_H +#define ROSLIB_DEBUG_H + +#include +#include +#include "cpp_common_decl.h" + +namespace ros +{ + +namespace debug +{ +typedef std::vector V_void; +typedef std::vector V_string; + +CPP_COMMON_DECL std::string getBacktrace(); +CPP_COMMON_DECL std::string backtraceToString(const V_void& addresses); +CPP_COMMON_DECL void getBacktrace(V_void& addresses); +CPP_COMMON_DECL void translateAddresses(const V_void& addresses, V_string& lines); +CPP_COMMON_DECL void demangleBacktrace(const V_string& names, V_string& demangled); +CPP_COMMON_DECL std::string demangleBacktrace(const V_string& names); +CPP_COMMON_DECL std::string demangleName(const std::string& name); +} + +} + +#endif diff --git a/realsense-file/3rd_party/rosbag/cpp_common/include/ros/exception.h b/realsense-file/3rd_party/rosbag/cpp_common/include/ros/exception.h new file mode 100644 index 0000000000..623c4b2b4c --- /dev/null +++ b/realsense-file/3rd_party/rosbag/cpp_common/include/ros/exception.h @@ -0,0 +1,50 @@ +/* + * Copyright (C) 2009, Willow Garage, Inc. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the names of Stanford University or Willow Garage, Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef ROSLIB_EXCEPTION_H +#define ROSLIB_EXCEPTION_H + +#include + +namespace ros +{ + +/** + * \brief Base class for all exceptions thrown by ROS + */ +class Exception : public std::runtime_error +{ +public: + Exception(const std::string& what) + : std::runtime_error(what) + {} +}; + +} // namespace ros + +#endif + diff --git a/realsense-file/3rd_party/rosbag/cpp_common/include/ros/header.h b/realsense-file/3rd_party/rosbag/cpp_common/include/ros/header.h new file mode 100644 index 0000000000..080dc8a8d0 --- /dev/null +++ b/realsense-file/3rd_party/rosbag/cpp_common/include/ros/header.h @@ -0,0 +1,89 @@ +/* + * Software License Agreement (BSD License) + * + * Copyright (c) 2008, Willow Garage, Inc. + * Copyright (c) 2013, Open Source Robotics Foundation + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials provided + * with the distribution. + * * Neither the name of Willow Garage, Inc. nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN + * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef CPP_CORE_HEADER_H +#define CPP_CORE_HEADER_H + +#include + +//#include + +#include "../../../cpp_common/include/ros/datatypes.h" +#include "cpp_common_decl.h" + +namespace ros +{ + +/** + * \brief Provides functionality to parse a connection header and retrieve values from it + */ +class CPP_COMMON_DECL Header +{ +public: + Header(); + ~Header(); + + /** + * \brief Get a value from a parsed header + * \param key Key value + * \param value OUT -- value corresponding to the key if there is one + * \return Returns true if the header had the specified key in it + */ + bool getValue(const std::string& key, std::string& value) const; + /** + * \brief Returns a shared pointer to the internal map used + */ + M_stringPtr getValues() { return read_map_; } + + /** + * \brief Parse a header out of a buffer of data + */ + bool parse(const std::shared_ptr>& buffer, uint32_t size, std::string& error_msg); + + /** + * \brief Parse a header out of a buffer of data + */ + bool parse(uint8_t* buffer, uint32_t size, std::string& error_msg); + + static void write(const M_string& key_vals, std::shared_ptr>& buffer, uint32_t& size); + +private: + + M_stringPtr read_map_; +}; + +} + +#endif // ROSCPP_HEADER_H diff --git a/realsense-file/3rd_party/rosbag/cpp_common/include/ros/macros.h b/realsense-file/3rd_party/rosbag/cpp_common/include/ros/macros.h new file mode 100644 index 0000000000..1dda4b14fb --- /dev/null +++ b/realsense-file/3rd_party/rosbag/cpp_common/include/ros/macros.h @@ -0,0 +1,67 @@ +/* + * Copyright (C) 2010, Willow Garage, Inc. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the names of Willow Garage, Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef ROSLIB_MACROS_H_INCLUDED +#define ROSLIB_MACROS_H_INCLUDED + +#if defined(__GNUC__) +#define ROS_DEPRECATED __attribute__((deprecated)) +#define ROS_FORCE_INLINE __attribute__((always_inline)) +#elif defined(_MSC_VER) +#define ROS_DEPRECATED +#define ROS_FORCE_INLINE __forceinline +#else +#define ROS_DEPRECATED +#define ROS_FORCE_INLINE inline +#endif + +/* + Windows import/export and gnu http://gcc.gnu.org/wiki/Visibility + macros. + */ +#if defined(_MSC_VER) + #define ROS_HELPER_IMPORT __declspec(dllimport) + #define ROS_HELPER_EXPORT __declspec(dllexport) + #define ROS_HELPER_LOCAL +#elif __GNUC__ >= 4 + #define ROS_HELPER_IMPORT __attribute__ ((visibility("default"))) + #define ROS_HELPER_EXPORT __attribute__ ((visibility("default"))) + #define ROS_HELPER_LOCAL __attribute__ ((visibility("hidden"))) +#else + #define ROS_HELPER_IMPORT + #define ROS_HELPER_EXPORT + #define ROS_HELPER_LOCAL +#endif + +// Ignore warnings about import/exports when deriving from std classes. +#ifdef _MSC_VER + #pragma warning(disable: 4251) + #pragma warning(disable: 4275) +#endif + +#endif + diff --git a/realsense-file/3rd_party/rosbag/cpp_common/include/ros/platform.h b/realsense-file/3rd_party/rosbag/cpp_common/include/ros/platform.h new file mode 100644 index 0000000000..32a24d80ec --- /dev/null +++ b/realsense-file/3rd_party/rosbag/cpp_common/include/ros/platform.h @@ -0,0 +1,84 @@ +/* + * Copyright (C) 2010, Willow Garage, Inc. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the names of Willow Garage, Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ +/* + * Some common cross platform utilities. + */ +#ifndef CPP_COMMON_PLATFORM_H_ +#define CPP_COMMON_PLATFORM_H_ + +/****************************************************************************** +* Includes +******************************************************************************/ + +#ifdef WIN32 + #ifdef _MSC_VER + #define WIN32_LEAN_AND_MEAN // slimmer compile times + #define _WINSOCKAPI_ // stops windows.h from including winsock.h (and lets us include winsock2.h) + #define NOMINMAX // windows c++ pollutes the environment like any factory + #endif + #include +#endif + + + +/****************************************************************************** +* Cross Platform Functions +******************************************************************************/ + +#ifndef _MSC_VER + #include // getenv +#endif +#include + +namespace ros { + +/** + * Convenient cross platform function for returning a std::string of an + * environment variable. + */ +inline bool get_environment_variable(std::string &str, const char* environment_variable) { + char* env_var_cstr = NULL; + #ifdef _MSC_VER + _dupenv_s(&env_var_cstr, NULL,environment_variable); + #else + env_var_cstr = getenv(environment_variable); + #endif + if ( env_var_cstr ) { + str = std::string(env_var_cstr); + #ifdef _MSC_VER + free(env_var_cstr); + #endif + return true; + } else { + str = std::string(""); + return false; + } +} + +} // namespace ros + +#endif /* CPP_COMMON_PLATFORM_H_ */ diff --git a/realsense-file/3rd_party/rosbag/cpp_common/include/ros/types.h b/realsense-file/3rd_party/rosbag/cpp_common/include/ros/types.h new file mode 100644 index 0000000000..826492dafb --- /dev/null +++ b/realsense-file/3rd_party/rosbag/cpp_common/include/ros/types.h @@ -0,0 +1,48 @@ +/* + * Copyright (C) 2008, Morgan Quigley and Willow Garage, Inc. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the names of Stanford University or Willow Garage, Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef ROSCPP_TYPES_H +#define ROSCPP_TYPES_H + +// this is just for interoperability with visual studio, where the standard +// integer types are not defined. + +#if defined(_MSC_VER) && (_MSC_VER < 1600 ) // MS express/studio 2008 or earlier + typedef __int64 int64_t; + typedef unsigned __int64 uint64_t; + typedef __int32 int32_t; + typedef unsigned __int32 uint32_t; + typedef __int16 int16_t; + typedef unsigned __int16 uint16_t; + typedef __int8 int8_t; + typedef unsigned __int8 uint8_t; +#else + #include +#endif + + +#endif // ROSCPP_TYPES_H diff --git a/realsense-file/3rd_party/rosbag/cpp_common/src/debug.cpp b/realsense-file/3rd_party/rosbag/cpp_common/src/debug.cpp new file mode 100644 index 0000000000..756c1faab4 --- /dev/null +++ b/realsense-file/3rd_party/rosbag/cpp_common/src/debug.cpp @@ -0,0 +1,154 @@ +/* + * Copyright (C) 2009, Willow Garage, Inc. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the names of Stanford University or Willow Garage, Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +#include "ros/debug.h" + +#if defined(HAVE_EXECINFO_H) +#include +#endif + +#if defined(HAVE_CXXABI_H) +#include +#endif + +#include +#include +#include + +namespace ros +{ +namespace debug +{ + +void getBacktrace(V_void& addresses) +{ +#if HAVE_GLIBC_BACKTRACE + void *array[64]; + + size_t size = backtrace(array, 64); + for (size_t i = 1; i < size; i++) + { + addresses.push_back(array[i]); + } +#endif +} + +void translateAddresses(const V_void& addresses, V_string& lines) +{ +#if HAVE_GLIBC_BACKTRACE + if (addresses.empty()) + { + return; + } + + size_t size = addresses.size(); + char **strings = backtrace_symbols(&addresses.front(), size); + + for (size_t i = 0; i < size; ++i) + { + lines.push_back(strings[i]); + } + + free(strings); +#endif +} + +std::string demangleName(const std::string& name) +{ +#if HAVE_CXXABI_H + int status; + char* demangled = abi::__cxa_demangle(name, 0, 0, &status); + std::string out; + if (demangled) + { + out = demangled; + free(demangled); + } + else + { + out = name; + } + + return out; +#else + return name; +#endif +} + +std::string demangleBacktraceLine(const std::string& line) +{ + // backtrace_symbols outputs in the form: + // executable(function+offset) [address] + // We want everything between ( and + to send to demangleName() + size_t paren_pos = line.find('('); + size_t plus_pos = line.find('+'); + if (paren_pos == std::string::npos || plus_pos == std::string::npos) + { + return line; + } + + std::string name(line, paren_pos + 1, plus_pos - paren_pos - 1); + return line.substr(0, paren_pos + 1) + demangleName(name) + line.substr(plus_pos); +} + +void demangleBacktrace(const V_string& lines, V_string& demangled) +{ + V_string::const_iterator it = lines.begin(); + V_string::const_iterator end = lines.end(); + for (; it != end; ++it) + { + demangled.push_back(demangleBacktraceLine(*it)); + } +} + +std::string backtraceToString(const V_void& addresses) +{ + V_string lines, demangled; + translateAddresses(addresses, lines); + demangleBacktrace(lines, demangled); + + std::stringstream ss; + V_string::const_iterator it = demangled.begin(); + V_string::const_iterator end = demangled.end(); + for (; it != end; ++it) + { + ss << *it << std::endl; + } + + return ss.str(); +} + +std::string getBacktrace() +{ + V_void addresses; + getBacktrace(addresses); + return backtraceToString(addresses); +} + +} + +} diff --git a/realsense-file/3rd_party/rosbag/cpp_common/src/header.cpp b/realsense-file/3rd_party/rosbag/cpp_common/src/header.cpp new file mode 100644 index 0000000000..14d060210e --- /dev/null +++ b/realsense-file/3rd_party/rosbag/cpp_common/src/header.cpp @@ -0,0 +1,174 @@ +/* + * Software License Agreement (BSD License) + * + * Copyright (c) 2008, Willow Garage, Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials provided + * with the distribution. + * * Neither the name of Willow Garage, Inc. nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN + * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +#include "ros/header.h" + +#include "console_bridge/console.h" + +#include + +#include +#include +#include +#include +#include + +#define SROS_SERIALIZE_PRIMITIVE(ptr, data) { memcpy(ptr, &data, sizeof(data)); ptr += sizeof(data); } +#define SROS_SERIALIZE_BUFFER(ptr, data, data_size) { if (data_size > 0) { memcpy(ptr, data, data_size); ptr += data_size; } } +#define SROS_DESERIALIZE_PRIMITIVE(ptr, data) { memcpy(&data, ptr, sizeof(data)); ptr += sizeof(data); } +#define SROS_DESERIALIZE_BUFFER(ptr, data, data_size) { if (data_size > 0) { memcpy(data, ptr, data_size); ptr += data_size; } } + + +using namespace std; + +namespace ros +{ + +Header::Header() +: read_map_(new M_string()) +{ + +} + +Header::~Header() +{ + +} + +bool Header::parse(const std::shared_ptr>& buffer, uint32_t size, std::string& error_msg) +{ + return parse(buffer->data(), size, error_msg); +} + +bool Header::parse(uint8_t* buffer, uint32_t size, std::string& error_msg) +{ + uint8_t* buf = buffer; + while (buf < buffer + size) + { + uint32_t len; + SROS_DESERIALIZE_PRIMITIVE(buf, len); + + if (len > 1000000) + { + error_msg = "Received an invalid TCPROS header. Each element must be prepended by a 4-byte length."; + logError("%s", error_msg); + + return false; + } + + std::string line((char*)buf, len); + + buf += len; + + //printf(":%s:\n", line); + size_t eqpos = line.find_first_of("=", 0); + if (eqpos == string::npos) + { + error_msg = "Received an invalid TCPROS header. Each line must have an equals sign."; + logError("%s", error_msg); + + return false; + } + string key = line.substr(0, eqpos); + string value = line.substr(eqpos+1); + + (*read_map_)[key] = value; + } + + return true; +} + +bool Header::getValue(const std::string& key, std::string& value) const +{ + M_string::const_iterator it = read_map_->find(key); + if (it == read_map_->end()) + { + return false; + } + + value = it->second; + + return true; +} + +void Header::write(const M_string& key_vals, std::shared_ptr>& buffer, uint32_t& size) +{ + // Calculate the necessary size + size = 0; + { + M_string::const_iterator it = key_vals.begin(); + M_string::const_iterator end = key_vals.end(); + for (; it != end; ++it) + { + const std::string& key = it->first; + const std::string& value = it->second; + + size += static_cast(key.length()); + size += static_cast(value.length()); + size += 1; // = sign + size += 4; // 4-byte length + } + } + + if (size == 0) + { + return; + } + + std::vector v(0, size); + buffer.reset(new std::vector (0, size)); + char* ptr = (char*)buffer.get(); + + // Write the data + { + M_string::const_iterator it = key_vals.begin(); + M_string::const_iterator end = key_vals.end(); + for (; it != end; ++it) + { + const std::string& key = it->first; + const std::string& value = it->second; + + uint32_t len = static_cast(key.length() + value.length() + 1); + SROS_SERIALIZE_PRIMITIVE(ptr, len); + SROS_SERIALIZE_BUFFER(ptr, key.data(), key.length()); + static const char equals = '='; + SROS_SERIALIZE_PRIMITIVE(ptr, equals); + SROS_SERIALIZE_BUFFER(ptr, value.data(), value.length()); + } + } + + assert(ptr == (char*)buffer.get() + size); +} + +} diff --git a/realsense-file/3rd_party/rosbag/rosbag_storage/config.cmake b/realsense-file/3rd_party/rosbag/rosbag_storage/config.cmake new file mode 100644 index 0000000000..136c6f3234 --- /dev/null +++ b/realsense-file/3rd_party/rosbag/rosbag_storage/config.cmake @@ -0,0 +1,29 @@ +cmake_minimum_required(VERSION 2.8.3) + +set(HEADER_FILES_ROSBAG_STORAGE + rosbag/rosbag_storage/include/rosbag/bag.h + rosbag/rosbag_storage/include/rosbag/bag_player.h + rosbag/rosbag_storage/include/rosbag/buffer.h + rosbag/rosbag_storage/include/rosbag/chunked_file.h + rosbag/rosbag_storage/include/rosbag/constants.h + rosbag/rosbag_storage/include/rosbag/exceptions.h + rosbag/rosbag_storage/include/rosbag/macros.h + rosbag/rosbag_storage/include/rosbag/message_instance.h + rosbag/rosbag_storage/include/rosbag/query.h + rosbag/rosbag_storage/include/rosbag/stream.h + rosbag/rosbag_storage/include/rosbag/structures.h + rosbag/rosbag_storage/include/rosbag/view.h +) + +set(SOURCE_FILES_ROSBAG_STORAGE + rosbag/rosbag_storage/src/bag.cpp + rosbag/rosbag_storage/src/bag_player.cpp + rosbag/rosbag_storage/src/buffer.cpp + rosbag/rosbag_storage/src/chunked_file.cpp + rosbag/rosbag_storage/src/message_instance.cpp + rosbag/rosbag_storage/src/query.cpp + rosbag/rosbag_storage/src/stream.cpp + rosbag/rosbag_storage/src/uncompressed_stream.cpp + rosbag/rosbag_storage/src/view.cpp + rosbag/rosbag_storage/src/lz4_stream.cpp +) diff --git a/realsense-file/3rd_party/rosbag/rosbag_storage/include/rosbag/bag.h b/realsense-file/3rd_party/rosbag/rosbag_storage/include/rosbag/bag.h new file mode 100644 index 0000000000..39adaad422 --- /dev/null +++ b/realsense-file/3rd_party/rosbag/rosbag_storage/include/rosbag/bag.h @@ -0,0 +1,627 @@ +/********************************************************************* +* Software License Agreement (BSD License) +* +* Copyright (c) 2008, Willow Garage, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions +* are met: +* +* * Redistributions of source code must retain the above copyright +* notice, this list of conditions and the following disclaimer. +* * Redistributions in binary form must reproduce the above +* copyright notice, this list of conditions and the following +* disclaimer in the documentation and/or other materials provided +* with the distribution. +* * Neither the name of Willow Garage, Inc. nor the names of its +* contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*********************************************************************/ + +#ifndef ROSBAG_BAG_H +#define ROSBAG_BAG_H + + +#include "macros.h" + +#include "buffer.h" +#include "chunked_file.h" +#include "constants.h" +#include "exceptions.h" +#include "structures.h" + +#include "../../../cpp_common/include/ros/header.h" +//#include "../../../rostime/include/ros/time.h" +#include "../../../roscpp_traits/include/ros/message_traits.h" +#include "../../../roscpp_traits/include/ros/message_event.h" +#include "../../../roscpp_serialization/include/ros/serialization.h" + +//#include "ros/subscription_callback_helper.h" + +#include +#include +#include +#include +#include + +#include +//#include + +#include "../../../console_bridge/include/console_bridge/console.h" + +namespace rosbag { + +namespace bagmode +{ + //! The possible modes to open a bag in + enum BagMode + { + Write = 1, + Read = 2, + Append = 4 + }; +} +typedef bagmode::BagMode BagMode; + +class MessageInstance; +class View; +class Query; + +class ROSBAG_DECL Bag +{ + friend class MessageInstance; + friend class View; + +public: + Bag(); + + //! Open a bag file + /*! + * \param filename The bag file to open + * \param mode The mode to use (either read, write or append) + * + * Can throw BagException + */ + explicit Bag(std::string const& filename, uint32_t mode = bagmode::Read); + + ~Bag(); + + //! Open a bag file. + /*! + * \param filename The bag file to open + * \param mode The mode to use (either read, write or append) + * + * Can throw BagException + */ + void open(std::string const& filename, uint32_t mode = bagmode::Read); + + //! Close the bag file + void close(); + + std::string getFileName() const; //!< Get the filename of the bag + BagMode getMode() const; //!< Get the mode the bag is in + uint32_t getMajorVersion() const; //!< Get the major-version of the open bag file + uint32_t getMinorVersion() const; //!< Get the minor-version of the open bag file + uint64_t getSize() const; //!< Get the current size of the bag file (a lower bound) + + void setCompression(CompressionType compression); //!< Set the compression method to use for writing chunks + CompressionType getCompression() const; //!< Get the compression method to use for writing chunks + void setChunkThreshold(uint32_t chunk_threshold); //!< Set the threshold for creating new chunks + uint32_t getChunkThreshold() const; //!< Get the threshold for creating new chunks + + //! Write a message into the bag file + /*! + * \param topic The topic name + * \param event The message event to be added + * + * Can throw BagIOException + */ + template + void write(std::string const& topic, ros::MessageEvent const& event); + + //! Write a message into the bag file + /*! + * \param topic The topic name + * \param time Timestamp of the message + * \param msg The message to be added + * \param connection_header A connection header. + * + * Can throw BagIOException + */ + template + void write(std::string const& topic, ros::Time const& time, T const& msg, + std::shared_ptr connection_header = std::shared_ptr()); + + //! Write a message into the bag file + /*! + * \param topic The topic name + * \param time Timestamp of the message + * \param msg The message to be added + * \param connection_header A connection header. + * + * Can throw BagIOException + */ + template + void write(std::string const& topic, ros::Time const& time, std::shared_ptr const& msg, + std::shared_ptr connection_header = std::shared_ptr()); + + //! Write a message into the bag file + /*! + * \param topic The topic name + * \param time Timestamp of the message + * \param msg The message to be added + * \param connection_header A connection header. + * + * Can throw BagIOException + */ + template + void write(std::string const& topic, ros::Time const& time, std::shared_ptr const& msg, + std::shared_ptr connection_header = std::shared_ptr()); + +private: + // This helper function actually does the write with an arbitrary serializable message + template + void doWrite(std::string const& topic, ros::Time const& time, T const& msg, std::shared_ptr const& connection_header); + + void openRead (std::string const& filename); + void openWrite (std::string const& filename); + void openAppend(std::string const& filename); + + void closeWrite(); + + template + std::shared_ptr instantiateBuffer(IndexEntry const& index_entry) const; //!< deserializes the message held in record_buffer_ + + void startWriting(); + void stopWriting(); + + void startReadingVersion102(); + void startReadingVersion200(); + + // Writing + + void writeVersion(); + void writeFileHeaderRecord(); + void writeConnectionRecord(ConnectionInfo const* connection_info); + void appendConnectionRecordToBuffer(Buffer& buf, ConnectionInfo const* connection_info); + template + void writeMessageDataRecord(uint32_t conn_id, ros::Time const& time, T const& msg); + void writeIndexRecords(); + void writeConnectionRecords(); + void writeChunkInfoRecords(); + void startWritingChunk(ros::Time time); + void writeChunkHeader(CompressionType compression, uint32_t compressed_size, uint32_t uncompressed_size); + void stopWritingChunk(); + + // Reading + + void readVersion(); + void readFileHeaderRecord(); + void readConnectionRecord(); + void readChunkHeader(ChunkHeader& chunk_header) const; + void readChunkInfoRecord(); + void readConnectionIndexRecord200(); + + void readTopicIndexRecord102(); + void readMessageDefinitionRecord102(); + void readMessageDataRecord102(uint64_t offset, ros::Header& header) const; + + ros::Header readMessageDataHeader(IndexEntry const& index_entry); + uint32_t readMessageDataSize(IndexEntry const& index_entry) const; + + template + void readMessageDataIntoStream(IndexEntry const& index_entry, Stream& stream) const; + + void decompressChunk(uint64_t chunk_pos) const; + void decompressRawChunk(ChunkHeader const& chunk_header) const; + void decompressBz2Chunk(ChunkHeader const& chunk_header) const; + void decompressLz4Chunk(ChunkHeader const& chunk_header) const; + uint32_t getChunkOffset() const; + + // Record header I/O + + void writeHeader(ros::M_string const& fields); + void writeDataLength(uint32_t data_len); + void appendHeaderToBuffer(Buffer& buf, ros::M_string const& fields); + void appendDataLengthToBuffer(Buffer& buf, uint32_t data_len); + + void readHeaderFromBuffer(Buffer& buffer, uint32_t offset, ros::Header& header, uint32_t& data_size, uint32_t& bytes_read) const; + void readMessageDataHeaderFromBuffer(Buffer& buffer, uint32_t offset, ros::Header& header, uint32_t& data_size, uint32_t& bytes_read) const; + bool readHeader(ros::Header& header) const; + bool readDataLength(uint32_t& data_size) const; + bool isOp(ros::M_string& fields, uint8_t reqOp) const; + + // Header fields + + template + std::string toHeaderString(T const* field) const; + + std::string toHeaderString(ros::Time const* field) const; + + template + bool readField(ros::M_string const& fields, std::string const& field_name, bool required, T* data) const; + + bool readField(ros::M_string const& fields, std::string const& field_name, unsigned int min_len, unsigned int max_len, bool required, std::string& data) const; + bool readField(ros::M_string const& fields, std::string const& field_name, bool required, std::string& data) const; + + bool readField(ros::M_string const& fields, std::string const& field_name, bool required, ros::Time& data) const; + + ros::M_string::const_iterator checkField(ros::M_string const& fields, std::string const& field, + unsigned int min_len, unsigned int max_len, bool required) const; + + // Low-level I/O + + void write(char const* s, std::streamsize n); + void write(std::string const& s); + void read(char* b, std::streamsize n) const; + void seek(uint64_t pos, int origin = std::ios_base::beg) const; + +private: + BagMode mode_; + mutable ChunkedFile file_; + int version_; + CompressionType compression_; + uint32_t chunk_threshold_; + uint32_t bag_revision_; + + uint64_t file_size_; + uint64_t file_header_pos_; + uint64_t index_data_pos_; + uint32_t connection_count_; + uint32_t chunk_count_; + + // Current chunk + bool chunk_open_; + ChunkInfo curr_chunk_info_; + uint64_t curr_chunk_data_pos_; + + std::map topic_connection_ids_; + std::map header_connection_ids_; + std::map connections_; + + std::vector chunks_; + + std::map > connection_indexes_; + std::map > curr_chunk_connection_indexes_; + + mutable Buffer header_buffer_; //!< reusable buffer in which to assemble the record header before writing to file + mutable Buffer record_buffer_; //!< reusable buffer in which to assemble the record data before writing to file + + mutable Buffer chunk_buffer_; //!< reusable buffer to read chunk into + mutable Buffer decompress_buffer_; //!< reusable buffer to decompress chunks into + + mutable Buffer outgoing_chunk_buffer_; //!< reusable buffer to read chunk into + + mutable Buffer* current_buffer_; + + mutable uint64_t decompressed_chunk_; //!< position of decompressed chunk +}; + +} // namespace rosbag + +#include "rosbag/message_instance.h" + +namespace rosbag { + +// Templated method definitions + +template +void Bag::write(std::string const& topic, ros::MessageEvent const& event) { + doWrite(topic, event.getReceiptTime(), *event.getMessage(), event.getConnectionHeaderPtr()); +} + +template +void Bag::write(std::string const& topic, ros::Time const& time, T const& msg, std::shared_ptr connection_header) { + doWrite(topic, time, msg, connection_header); +} + +template +void Bag::write(std::string const& topic, ros::Time const& time, std::shared_ptr const& msg, std::shared_ptr connection_header) { + doWrite(topic, time, *msg, connection_header); +} + +template +void Bag::write(std::string const& topic, ros::Time const& time, std::shared_ptr const& msg, std::shared_ptr connection_header) { + doWrite(topic, time, *msg, connection_header); +} + +template +std::string Bag::toHeaderString(T const* field) const { + return std::string((char*) field, sizeof(T)); +} + +template +bool Bag::readField(ros::M_string const& fields, std::string const& field_name, bool required, T* data) const { + ros::M_string::const_iterator i = checkField(fields, field_name, sizeof(T), sizeof(T), required); + if (i == fields.end()) + return false; + memcpy(data, i->second.data(), sizeof(T)); + return true; +} + +template +void Bag::readMessageDataIntoStream(IndexEntry const& index_entry, Stream& stream) const { + ros::Header header; + uint32_t data_size; + uint32_t bytes_read; + switch (version_) + { + case 200: + { + decompressChunk(index_entry.chunk_pos); + readMessageDataHeaderFromBuffer(*current_buffer_, index_entry.offset, header, data_size, bytes_read); + if (data_size > 0) + memcpy(stream.advance(data_size), current_buffer_->getData() + index_entry.offset + bytes_read, data_size); + break; + } + case 102: + { + readMessageDataRecord102(index_entry.chunk_pos, header); + data_size = record_buffer_.getSize(); + if (data_size > 0) + memcpy(stream.advance(data_size), record_buffer_.getData(), data_size); + break; + } + default: + throw BagFormatException((boost::format("Unhandled version: %1%") % version_).str()); + } +} + +template +std::shared_ptr Bag::instantiateBuffer(IndexEntry const& index_entry) const { + switch (version_) + { + case 200: + { + decompressChunk(index_entry.chunk_pos); + + // Read the message header + ros::Header header; + uint32_t data_size; + uint32_t bytes_read; + readMessageDataHeaderFromBuffer(*current_buffer_, index_entry.offset, header, data_size, bytes_read); + + // Read the connection id from the header + uint32_t connection_id; + readField(*header.getValues(), CONNECTION_FIELD_NAME, true, &connection_id); + + std::map::const_iterator connection_iter = connections_.find(connection_id); + if (connection_iter == connections_.end()) + throw BagFormatException((boost::format("Unknown connection ID: %1%") % connection_id).str()); + ConnectionInfo* connection_info = connection_iter->second; + + std::shared_ptr p = std::make_shared(); + + ros::serialization::PreDeserializeParams predes_params; + predes_params.message = p; + predes_params.connection_header = connection_info->header; + ros::serialization::PreDeserialize::notify(predes_params); + + // Deserialize the message + ros::serialization::IStream s(current_buffer_->getData() + index_entry.offset + bytes_read, data_size); + ros::serialization::deserialize(s, *p); + + return p; + } + case 102: + { + // Read the message record + ros::Header header; + readMessageDataRecord102(index_entry.chunk_pos, header); + + ros::M_string& fields = *header.getValues(); + + // Read the connection id from the header + std::string topic, latching("0"), callerid; + readField(fields, TOPIC_FIELD_NAME, true, topic); + readField(fields, LATCHING_FIELD_NAME, false, latching); + readField(fields, CALLERID_FIELD_NAME, false, callerid); + + std::map::const_iterator topic_conn_id_iter = topic_connection_ids_.find(topic); + if (topic_conn_id_iter == topic_connection_ids_.end()) + throw BagFormatException((boost::format("Unknown topic: %1%") % topic).str()); + uint32_t connection_id = topic_conn_id_iter->second; + + std::map::const_iterator connection_iter = connections_.find(connection_id); + if (connection_iter == connections_.end()) + throw BagFormatException((boost::format("Unknown connection ID: %1%") % connection_id).str()); + ConnectionInfo* connection_info = connection_iter->second; + + std::shared_ptr p = std::make_shared(); + + // Create a new connection header, updated with the latching and callerid values + std::shared_ptr message_header(std::make_shared()); + for (ros::M_string::const_iterator i = connection_info->header->begin(); i != connection_info->header->end(); i++) + (*message_header)[i->first] = i->second; + (*message_header)["latching"] = latching; + (*message_header)["callerid"] = callerid; + + ros::serialization::PreDeserializeParams predes_params; + predes_params.message = p; + predes_params.connection_header = message_header; + ros::serialization::PreDeserialize::notify(predes_params); + + // Deserialize the message + ros::serialization::IStream s(record_buffer_.getData(), record_buffer_.getSize()); + ros::serialization::deserialize(s, *p); + + return p; + } + default: + throw BagFormatException((boost::format("Unhandled version: %1%") % version_).str()); + } +} + +template +void Bag::doWrite(std::string const& topic, ros::Time const& time, T const& msg, std::shared_ptr const& connection_header) { + + if (time < ros::TIME_MIN) + { + throw BagException("Tried to insert a message with time less than ros::TIME_MIN"); + } + + // Whenever we write we increment our revision + bag_revision_++; + + // Get ID for connection header + ConnectionInfo* connection_info = NULL; + uint32_t conn_id = 0; + if (!connection_header) { + // No connection header: we'll manufacture one, and store by topic + + std::map::iterator topic_connection_ids_iter = topic_connection_ids_.find(topic); + if (topic_connection_ids_iter == topic_connection_ids_.end()) { + conn_id = static_cast(connections_.size()); + topic_connection_ids_[topic] = conn_id; + } + else { + conn_id = topic_connection_ids_iter->second; + connection_info = connections_[conn_id]; + } + } + else { + // Store the connection info by the address of the connection header + + // Add the topic name to the connection header, so that when we later search by + // connection header, we can disambiguate connections that differ only by topic name (i.e., + // same callerid, same message type), #3755. This modified connection header is only used + // for our bookkeeping, and will not appear in the resulting .bag. + ros::M_string connection_header_copy(*connection_header); + connection_header_copy["topic"] = topic; + + std::map::iterator header_connection_ids_iter = header_connection_ids_.find(connection_header_copy); + if (header_connection_ids_iter == header_connection_ids_.end()) { + conn_id = static_cast(connections_.size()); + header_connection_ids_[connection_header_copy] = conn_id; + } + else { + conn_id = header_connection_ids_iter->second; + connection_info = connections_[conn_id]; + } + } + + { + // Seek to the end of the file (needed in case previous operation was a read) + seek(0, std::ios::end); + file_size_ = file_.getOffset(); + + // Write the chunk header if we're starting a new chunk + if (!chunk_open_) + startWritingChunk(time); + + // Write connection info record, if necessary + if (connection_info == NULL) { + connection_info = new ConnectionInfo(); + connection_info->id = conn_id; + connection_info->topic = topic; + connection_info->datatype = std::string(ros::message_traits::datatype(msg)); + connection_info->md5sum = std::string(ros::message_traits::md5sum(msg)); + connection_info->msg_def = std::string(ros::message_traits::definition(msg)); + if (connection_header != NULL) { + connection_info->header = connection_header; + } + else { + connection_info->header = std::make_shared(); + (*connection_info->header)["type"] = connection_info->datatype; + (*connection_info->header)["md5sum"] = connection_info->md5sum; + (*connection_info->header)["message_definition"] = connection_info->msg_def; + } + connections_[conn_id] = connection_info; + + writeConnectionRecord(connection_info); + appendConnectionRecordToBuffer(outgoing_chunk_buffer_, connection_info); + } + + // Add to topic indexes + IndexEntry index_entry; + index_entry.time = time; + index_entry.chunk_pos = curr_chunk_info_.pos; + index_entry.offset = getChunkOffset(); + + std::multiset& chunk_connection_index = curr_chunk_connection_indexes_[connection_info->id]; + chunk_connection_index.insert(chunk_connection_index.end(), index_entry); + std::multiset& connection_index = connection_indexes_[connection_info->id]; + connection_index.insert(connection_index.end(), index_entry); + + // Increment the connection count + curr_chunk_info_.connection_counts[connection_info->id]++; + + // Write the message data + writeMessageDataRecord(conn_id, time, msg); + + // Check if we want to stop this chunk + uint32_t chunk_size = getChunkOffset(); + logDebug(" curr_chunk_size=%d (threshold=%d)", chunk_size, chunk_threshold_); + if (chunk_size > chunk_threshold_) { + // Empty the outgoing chunk + stopWritingChunk(); + outgoing_chunk_buffer_.setSize(0); + + // We no longer have a valid curr_chunk_info + curr_chunk_info_.pos = -1; + } + } +} + +template +void Bag::writeMessageDataRecord(uint32_t conn_id, ros::Time const& time, T const& msg) { + ros::M_string header; + header[OP_FIELD_NAME] = toHeaderString(&OP_MSG_DATA); + header[CONNECTION_FIELD_NAME] = toHeaderString(&conn_id); + header[TIME_FIELD_NAME] = toHeaderString(&time); + + // Assemble message in memory first, because we need to write its length + uint32_t msg_ser_len = ros::serialization::serializationLength(msg); + + record_buffer_.setSize(msg_ser_len); + + ros::serialization::OStream s(record_buffer_.getData(), msg_ser_len); + + // todo: serialize into the outgoing_chunk_buffer & remove record_buffer_ + ros::serialization::serialize(s, msg); + + // We do an extra seek here since writing our data record may + // have indirectly moved our file-pointer if it was a + // MessageInstance for our own bag + seek(0, std::ios::end); + file_size_ = file_.getOffset(); + + logDebug("Writing MSG_DATA [%llu:%d]: conn=%d sec=%d nsec=%d data_len=%d", + (unsigned long long) file_.getOffset(), getChunkOffset(), conn_id, time.sec, time.nsec, msg_ser_len); + + writeHeader(header); + writeDataLength(msg_ser_len); + write((char*) record_buffer_.getData(), msg_ser_len); + + // todo: use better abstraction than appendHeaderToBuffer + appendHeaderToBuffer(outgoing_chunk_buffer_, header); + appendDataLengthToBuffer(outgoing_chunk_buffer_, msg_ser_len); + + uint32_t offset = outgoing_chunk_buffer_.getSize(); + outgoing_chunk_buffer_.setSize(outgoing_chunk_buffer_.getSize() + msg_ser_len); + memcpy(outgoing_chunk_buffer_.getData() + offset, record_buffer_.getData(), msg_ser_len); + + // Update the current chunk time range + if (time > curr_chunk_info_.end_time) + curr_chunk_info_.end_time = time; + else if (time < curr_chunk_info_.start_time) + curr_chunk_info_.start_time = time; +} + +} // namespace rosbag + +#endif diff --git a/realsense-file/3rd_party/rosbag/rosbag_storage/include/rosbag/bag_player.h b/realsense-file/3rd_party/rosbag/rosbag_storage/include/rosbag/bag_player.h new file mode 100644 index 0000000000..4296d42d13 --- /dev/null +++ b/realsense-file/3rd_party/rosbag/rosbag_storage/include/rosbag/bag_player.h @@ -0,0 +1,135 @@ +/********************************************************************* +* Software License Agreement (BSD License) +* +* Copyright (c) 2013, Open Source Robotics Foundation +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions +* are met: +* +* * Redistributions of source code must retain the above copyright +* notice, this list of conditions and the following disclaimer. +* * Redistributions in binary form must reproduce the above +* copyright notice, this list of conditions and the following +* disclaimer in the documentation and/or other materials provided +* with the distribution. +* * Neither the name of Willow Garage, Inc. nor the names of its +* contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*********************************************************************/ + +#ifndef ROSBAG_BAG_PLAYER_H +#define ROSBAG_BAG_PLAYER_H + +#include + +#include "rosbag/bag.h" +#include "rosbag/view.h" + +namespace rosbag +{ + + +// A helper struct +struct BagCallback +{ + virtual ~BagCallback() {}; + virtual void call(MessageInstance m) = 0; +}; + +// A helper class for the callbacks +template +class BagCallbackT : public BagCallback +{ +public: + typedef boost::function&)> Callback; + + BagCallbackT(Callback cb) : + cb_(cb) + {} + + void call(MessageInstance m) { + cb_(m.instantiate()); + } + +private: + Callback cb_; +}; + + +/* A class for playing back bag files at an API level. It supports + relatime, as well as accelerated and slowed playback. */ +class BagPlayer +{ +public: + /* Constructor expecting the filename of a bag */ + BagPlayer(const std::string &filename) throw(BagException); + + /* Register a callback for a specific topic and type */ + template + void register_callback(const std::string &topic, + typename BagCallbackT::Callback f); + + /* Unregister a callback for a topic already registered */ + void unregister_callback(const std::string &topic); + + /* Set the time in the bag to start. + * Default is the first message */ + void set_start(const ros::Time &start); + + /* Set the time in the bag to stop. + * Default is the last message */ + void set_end(const ros::Time &end); + + /* Set the speed to playback. 1.0 is the default. + * 2.0 would be twice as fast, 0.5 is half realtime. */ + void set_playback_speed(double scale); + + /* Start playback of the bag file using the parameters previously + set */ + void start_play(); + + /* Get the current time of the playback */ + ros::Time get_time(); + + // Destructor + virtual ~BagPlayer(); + + + // The bag file interface loaded in the constructor. + Bag bag; + +private: + ros::Time real_time(const ros::Time &msg_time); + + std::map cbs_; + ros::Time bag_start_; + ros::Time bag_end_; + ros::Time last_message_time_; + double playback_speed_; + ros::Time play_start_; +}; + +template +void BagPlayer::register_callback(const std::string &topic, + typename BagCallbackT::Callback cb) { + cbs_[topic] = new BagCallbackT(cb); +} + +} + +#endif diff --git a/realsense-file/3rd_party/rosbag/rosbag_storage/include/rosbag/buffer.h b/realsense-file/3rd_party/rosbag/rosbag_storage/include/rosbag/buffer.h new file mode 100644 index 0000000000..5f9cf1a784 --- /dev/null +++ b/realsense-file/3rd_party/rosbag/rosbag_storage/include/rosbag/buffer.h @@ -0,0 +1,66 @@ +/********************************************************************* +* Software License Agreement (BSD License) +* +* Copyright (c) 2008, Willow Garage, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions +* are met: +* +* * Redistributions of source code must retain the above copyright +* notice, this list of conditions and the following disclaimer. +* * Redistributions in binary form must reproduce the above +* copyright notice, this list of conditions and the following +* disclaimer in the documentation and/or other materials provided +* with the distribution. +* * Neither the name of Willow Garage, Inc. nor the names of its +* contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +********************************************************************/ + +#ifndef ROSBAG_BUFFER_H +#define ROSBAG_BUFFER_H + +#include +#include "macros.h" + +namespace rosbag { + +class ROSBAG_DECL Buffer +{ +public: + Buffer(); + ~Buffer(); + + uint8_t* getData(); + uint32_t getCapacity() const; + uint32_t getSize() const; + + void setSize(uint32_t size); + +private: + void ensureCapacity(uint32_t capacity); + +private: + uint8_t* buffer_; + uint32_t capacity_; + uint32_t size_; +}; + +} // namespace rosbag + +#endif diff --git a/realsense-file/3rd_party/rosbag/rosbag_storage/include/rosbag/chunked_file.h b/realsense-file/3rd_party/rosbag/rosbag_storage/include/rosbag/chunked_file.h new file mode 100644 index 0000000000..49df9ab150 --- /dev/null +++ b/realsense-file/3rd_party/rosbag/rosbag_storage/include/rosbag/chunked_file.h @@ -0,0 +1,101 @@ +/********************************************************************* +* Software License Agreement (BSD License) +* +* Copyright (c) 2008, Willow Garage, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions +* are met: +* +* * Redistributions of source code must retain the above copyright +* notice, this list of conditions and the following disclaimer. +* * Redistributions in binary form must reproduce the above +* copyright notice, this list of conditions and the following +* disclaimer in the documentation and/or other materials provided +* with the distribution. +* * Neither the name of Willow Garage, Inc. nor the names of its +* contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +********************************************************************/ + +#ifndef ROSBAG_CHUNKED_FILE_H +#define ROSBAG_CHUNKED_FILE_H + +#include +#include +#include +#include "macros.h" +//#include + +#include "../../../rosbag_storage/include/rosbag/stream.h" + +namespace rosbag { + +//! ChunkedFile reads and writes files which contain interleaved chunks of compressed and uncompressed data. +class ROSBAG_DECL ChunkedFile +{ + friend class Stream; + +public: + ChunkedFile(); + ~ChunkedFile(); + + void openWrite (std::string const& filename); //!< open file for writing + void openRead (std::string const& filename); //!< open file for reading + void openReadWrite(std::string const& filename); //!< open file for reading & writing + + void close(); //!< close the file + + std::string getFileName() const; //!< return path of currently open file + uint64_t getOffset() const; //!< return current offset from the beginning of the file + uint32_t getCompressedBytesIn() const; //!< return the number of bytes written to current compressed stream + bool isOpen() const; //!< return true if file is open for reading or writing + bool good() const; //!< return true if hasn't reached end-of-file and no error + + void setReadMode(CompressionType type); + void setWriteMode(CompressionType type); + + // File I/O + void write(std::string const& s); + void write(void* ptr, size_t size); //!< write size bytes from ptr to the file + void read(void* ptr, size_t size); //!< read size bytes from the file into ptr + std::string getline(); + bool truncate(uint64_t length); + void seek(uint64_t offset, int origin = std::ios_base::beg); //!< seek to given offset from origin + void decompress(CompressionType compression, uint8_t* dest, unsigned int dest_len, uint8_t* source, unsigned int source_len); + +private: + void open(std::string const& filename, std::string const& mode); + void clearUnused(); + +private: + std::string filename_; //!< path to file + FILE* file_; //!< file pointer + uint64_t offset_; //!< current position in the file + uint64_t compressed_in_; //!< number of bytes written to current compressed stream + char* unused_; //!< extra data read by compressed stream + int nUnused_; //!< number of bytes of extra data read by compressed stream + + std::shared_ptr stream_factory_; + + std::shared_ptr read_stream_; + std::shared_ptr write_stream_; +}; + +} // namespace rosbag + +#endif diff --git a/realsense-file/3rd_party/rosbag/rosbag_storage/include/rosbag/constants.h b/realsense-file/3rd_party/rosbag/rosbag_storage/include/rosbag/constants.h new file mode 100644 index 0000000000..60f4998f61 --- /dev/null +++ b/realsense-file/3rd_party/rosbag/rosbag_storage/include/rosbag/constants.h @@ -0,0 +1,101 @@ +/********************************************************************* +* Software License Agreement (BSD License) +* +* Copyright (c) 2008, Willow Garage, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions +* are met: +* +* * Redistributions of source code must retain the above copyright +* notice, this list of conditions and the following disclaimer. +* * Redistributions in binary form must reproduce the above +* copyright notice, this list of conditions and the following +* disclaimer in the documentation and/or other materials provided +* with the distribution. +* * Neither the name of Willow Garage, Inc. nor the names of its +* contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*********************************************************************/ + +#ifndef ROSBAG_CONSTANTS_H +#define ROSBAG_CONSTANTS_H + +#include +#include + +namespace rosbag { + +// Bag file version to write +static const std::string VERSION = "2.0"; + +// Header field delimiter +static const unsigned char FIELD_DELIM = '='; + +// Current header fields +static const std::string OP_FIELD_NAME = "op"; +static const std::string TOPIC_FIELD_NAME = "topic"; +static const std::string VER_FIELD_NAME = "ver"; +static const std::string COUNT_FIELD_NAME = "count"; +static const std::string INDEX_POS_FIELD_NAME = "index_pos"; // 1.2+ +static const std::string CONNECTION_COUNT_FIELD_NAME = "conn_count"; // 2.0+ +static const std::string CHUNK_COUNT_FIELD_NAME = "chunk_count"; // 2.0+ +static const std::string CONNECTION_FIELD_NAME = "conn"; // 2.0+ +static const std::string COMPRESSION_FIELD_NAME = "compression"; // 2.0+ +static const std::string SIZE_FIELD_NAME = "size"; // 2.0+ +static const std::string TIME_FIELD_NAME = "time"; // 2.0+ +static const std::string START_TIME_FIELD_NAME = "start_time"; // 2.0+ +static const std::string END_TIME_FIELD_NAME = "end_time"; // 2.0+ +static const std::string CHUNK_POS_FIELD_NAME = "chunk_pos"; // 2.0+ + +// Legacy header fields +static const std::string MD5_FIELD_NAME = "md5"; // <2.0 +static const std::string TYPE_FIELD_NAME = "type"; // <2.0 +static const std::string DEF_FIELD_NAME = "def"; // <2.0 +static const std::string SEC_FIELD_NAME = "sec"; // <2.0 +static const std::string NSEC_FIELD_NAME = "nsec"; // <2.0 +static const std::string LATCHING_FIELD_NAME = "latching"; // <2.0 +static const std::string CALLERID_FIELD_NAME = "callerid"; // <2.0 + +// Current "op" field values +static const unsigned char OP_MSG_DATA = 0x02; +static const unsigned char OP_FILE_HEADER = 0x03; +static const unsigned char OP_INDEX_DATA = 0x04; +static const unsigned char OP_CHUNK = 0x05; +static const unsigned char OP_CHUNK_INFO = 0x06; +static const unsigned char OP_CONNECTION = 0x07; + +// Legacy "op" field values +static const unsigned char OP_MSG_DEF = 0x01; + +// Bytes reserved for file header record (4KB) +static const uint32_t FILE_HEADER_LENGTH = 4 * 1024; + +// Index data record version to write +static const uint32_t INDEX_VERSION = 1; + +// Chunk info record version to write +static const uint32_t CHUNK_INFO_VERSION = 1; + +// Compression types +static const std::string COMPRESSION_NONE = "none"; +static const std::string COMPRESSION_BZ2 = "bz2"; +static const std::string COMPRESSION_LZ4 = "lz4"; + +} // namespace rosbag + +#endif diff --git a/realsense-file/3rd_party/rosbag/rosbag_storage/include/rosbag/exceptions.h b/realsense-file/3rd_party/rosbag/rosbag_storage/include/rosbag/exceptions.h new file mode 100644 index 0000000000..e45c85f06a --- /dev/null +++ b/realsense-file/3rd_party/rosbag/rosbag_storage/include/rosbag/exceptions.h @@ -0,0 +1,72 @@ +/********************************************************************* +* Software License Agreement (BSD License) +* +* Copyright (c) 2008, Willow Garage, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions +* are met: +* +* * Redistributions of source code must retain the above copyright +* notice, this list of conditions and the following disclaimer. +* * Redistributions in binary form must reproduce the above +* copyright notice, this list of conditions and the following +* disclaimer in the documentation and/or other materials provided +* with the distribution. +* * Neither the name of Willow Garage, Inc. nor the names of its +* contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*********************************************************************/ + +#ifndef ROSBAG_EXCEPTIONS_H +#define ROSBAG_EXCEPTIONS_H + +#include "../../../cpp_common/include/ros/exception.h" + +namespace rosbag { + +//! Base class for rosbag exceptions +class BagException : public ros::Exception +{ +public: + BagException(std::string const& msg) : ros::Exception(msg) { } +}; + +//! Exception thrown when on IO problems +class BagIOException : public BagException +{ +public: + BagIOException(std::string const& msg) : BagException(msg) { } +}; + +//! Exception thrown on problems reading the bag format +class BagFormatException : public BagException +{ +public: + BagFormatException(std::string const& msg) : BagException(msg) { } +}; + +//! Exception thrown on problems reading the bag index +class BagUnindexedException : public BagException +{ +public: + BagUnindexedException() : BagException("Bag unindexed") { } +}; + +} // namespace rosbag + +#endif diff --git a/realsense-file/3rd_party/rosbag/rosbag_storage/include/rosbag/macros.h b/realsense-file/3rd_party/rosbag/rosbag_storage/include/rosbag/macros.h new file mode 100644 index 0000000000..ae58732b56 --- /dev/null +++ b/realsense-file/3rd_party/rosbag/rosbag_storage/include/rosbag/macros.h @@ -0,0 +1,46 @@ +/* + * Copyright (C) 2008, Willow Garage, Inc. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the names of Stanford University or Willow Garage, Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef ROSBAG_MACROS_H_ +#define ROSBAG_MACROS_H_ +#include +#include "../../../cpp_common/include/ros/macros.h" +///#include // for the DECL's + +// Import/export for windows dll's and visibility for gcc shared libraries. + +#ifdef ROS_BUILD_SHARED_LIBS // ros is being built around shared libraries + #ifdef rosbag_EXPORTS // we are building a shared lib/dll + #define ROSBAG_DECL ROS_HELPER_EXPORT + #else // we are using shared lib/dll + #define ROSBAG_DECL ROS_HELPER_IMPORT + #endif +#else // ros is being built around static libraries + #define ROSBAG_DECL +#endif + +#endif /* ROSBAG_MACROS_H_ */ diff --git a/realsense-file/3rd_party/rosbag/rosbag_storage/include/rosbag/message_instance.h b/realsense-file/3rd_party/rosbag/rosbag_storage/include/rosbag/message_instance.h new file mode 100644 index 0000000000..bd7b77cfa1 --- /dev/null +++ b/realsense-file/3rd_party/rosbag/rosbag_storage/include/rosbag/message_instance.h @@ -0,0 +1,175 @@ +/********************************************************************* +* Software License Agreement (BSD License) +* +* Copyright (c) 2008, Willow Garage, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions +* are met: +* +* * Redistributions of source code must retain the above copyright +* notice, this list of conditions and the following disclaimer. +* * Redistributions in binary form must reproduce the above +* copyright notice, this list of conditions and the following +* disclaimer in the documentation and/or other materials provided +* with the distribution. +* * Neither the name of Willow Garage, Inc. nor the names of its +* contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*********************************************************************/ + +#ifndef ROSBAG_MESSAGE_INSTANCE_H +#define ROSBAG_MESSAGE_INSTANCE_H + +#include +#include +//#include +#include +#include +#include "rosbag/structures.h" +#include "rosbag/macros.h" + +namespace rosbag { + +class Bag; + +//! A class pointing into a bag file +/*! + * The MessageInstance class itself is fairly light weight. It + * simply contains a pointer to a bag-file and the index_entry + * necessary to get access to the corresponding data. + * + * It adheres to the necessary ros::message_traits to be directly + * serializable. + */ +class ROSBAG_DECL MessageInstance +{ + friend class View; + +public: + ros::Time const& getTime() const; + std::string const& getTopic() const; + std::string const& getDataType() const; + std::string const& getMD5Sum() const; + std::string const& getMessageDefinition() const; + + std::shared_ptr getConnectionHeader() const; + + std::string getCallerId() const; + bool isLatching() const; + + //! Test whether the underlying message of the specified type. + /*! + * returns true iff the message is of the template type + */ + template + bool isType() const; + + //! Templated call to instantiate a message + /*! + * returns NULL pointer if incompatible + */ + template + std::shared_ptr instantiate() const; + + //! Write serialized message contents out to a stream + template + void write(Stream& stream) const; + + //! Size of serialized message + uint32_t size() const; + +private: + MessageInstance(ConnectionInfo const* connection_info, IndexEntry const& index, Bag const& bag); + + ConnectionInfo const* connection_info_; + IndexEntry const index_entry_; + Bag const* bag_; +}; + + +} // namespace rosbag + +namespace ros { +namespace message_traits { + +template<> +struct MD5Sum +{ + static const char* value(const rosbag::MessageInstance& m) { return m.getMD5Sum().c_str(); } +}; + +template<> +struct DataType +{ + static const char* value(const rosbag::MessageInstance& m) { return m.getDataType().c_str(); } +}; + +template<> +struct Definition +{ + static const char* value(const rosbag::MessageInstance& m) { return m.getMessageDefinition().c_str(); } +}; + +} // namespace message_traits + +namespace serialization +{ + +template<> +struct Serializer +{ + template + inline static void write(Stream& stream, const rosbag::MessageInstance& m) { + m.write(stream); + } + + inline static uint32_t serializedLength(const rosbag::MessageInstance& m) { + return m.size(); + } +}; + +} // namespace serialization + +} // namespace ros + +#include "rosbag/bag.h" + +namespace rosbag { + +template +bool MessageInstance::isType() const { + char const* md5sum = ros::message_traits::MD5Sum::value(); + return md5sum == std::string("*") || md5sum == getMD5Sum(); +} + +template +std::shared_ptr MessageInstance::instantiate() const { + if (!isType()) + return std::shared_ptr(); + + return bag_->instantiateBuffer(index_entry_); +} + +template +void MessageInstance::write(Stream& stream) const { + bag_->readMessageDataIntoStream(index_entry_, stream); +} + +} // namespace rosbag + +#endif diff --git a/realsense-file/3rd_party/rosbag/rosbag_storage/include/rosbag/query.h b/realsense-file/3rd_party/rosbag/rosbag_storage/include/rosbag/query.h new file mode 100644 index 0000000000..fd43214c2f --- /dev/null +++ b/realsense-file/3rd_party/rosbag/rosbag_storage/include/rosbag/query.h @@ -0,0 +1,138 @@ +/********************************************************************* +* Software License Agreement (BSD License) +* +* Copyright (c) 2008, Willow Garage, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions +* are met: +* +* * Redistributions of source code must retain the above copyright +* notice, this list of conditions and the following disclaimer. +* * Redistributions in binary form must reproduce the above +* copyright notice, this list of conditions and the following +* disclaimer in the documentation and/or other materials provided +* with the distribution. +* * Neither the name of Willow Garage, Inc. nor the names of its +* contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*********************************************************************/ + +#ifndef ROSBAG_QUERY_H +#define ROSBAG_QUERY_H + +#include "ros/time.h" + +#include +#include +#include + +#include +#include "rosbag/macros.h" +#include "rosbag/structures.h" + +namespace rosbag { + +class Bag; + +class ROSBAG_DECL Query +{ +public: + //! The base query takes an optional time-range + /*! + * param start_time the beginning of the time_range for the query + * param end_time the end of the time_range for the query + */ + Query(boost::function& query, + ros::Time const& start_time = ros::TIME_MIN, + ros::Time const& end_time = ros::TIME_MAX); + + boost::function const& getQuery() const; //!< Get the query functor + + ros::Time const& getStartTime() const; //!< Get the start-time + ros::Time const& getEndTime() const; //!< Get the end-time + +private: + boost::function query_; + ros::Time start_time_; + ros::Time end_time_; +}; + +class ROSBAG_DECL TopicQuery +{ +public: + TopicQuery(std::string const& topic); + TopicQuery(std::vector const& topics); + + bool operator()(ConnectionInfo const*) const; + +private: + std::vector topics_; +}; + +class ROSBAG_DECL TypeQuery +{ +public: + TypeQuery(std::string const& type); + TypeQuery(std::vector const& types); + + bool operator()(ConnectionInfo const*) const; + +private: + std::vector types_; +}; + +//! Pairs of queries and the bags they come from (used internally by View) +struct ROSBAG_DECL BagQuery +{ + BagQuery(Bag const* _bag, Query const& _query, uint32_t _bag_revision); + + Bag const* bag; + Query query; + uint32_t bag_revision; +}; + +struct ROSBAG_DECL MessageRange +{ + MessageRange(std::multiset::const_iterator const& _begin, + std::multiset::const_iterator const& _end, + ConnectionInfo const* _connection_info, + BagQuery const* _bag_query); + + std::multiset::const_iterator begin; + std::multiset::const_iterator end; + ConnectionInfo const* connection_info; + BagQuery const* bag_query; //!< pointer to vector of queries in View +}; + +//! The actual iterator data structure +struct ROSBAG_DECL ViewIterHelper +{ + ViewIterHelper(std::multiset::const_iterator _iter, MessageRange const* _range); + + std::multiset::const_iterator iter; + MessageRange const* range; //!< pointer to vector of ranges in View +}; + +struct ROSBAG_DECL ViewIterHelperCompare +{ + bool operator()(ViewIterHelper const& a, ViewIterHelper const& b); +}; + +} // namespace rosbag + +#endif diff --git a/realsense-file/3rd_party/rosbag/rosbag_storage/include/rosbag/stream.h b/realsense-file/3rd_party/rosbag/rosbag_storage/include/rosbag/stream.h new file mode 100644 index 0000000000..2236f9f5ba --- /dev/null +++ b/realsense-file/3rd_party/rosbag/rosbag_storage/include/rosbag/stream.h @@ -0,0 +1,156 @@ +/********************************************************************* +* Software License Agreement (BSD License) +* +* Copyright (c) 2008, Willow Garage, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions +* are met: +* +* * Redistributions of source code must retain the above copyright +* notice, this list of conditions and the following disclaimer. +* * Redistributions in binary form must reproduce the above +* copyright notice, this list of conditions and the following +* disclaimer in the documentation and/or other materials provided +* with the distribution. +* * Neither the name of Willow Garage, Inc. nor the names of its +* contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +********************************************************************/ + +#ifndef ROSBAG_STREAM_H +#define ROSBAG_STREAM_H + +#include +#include +#include + +//#include +#include +#include "../../../roslz4/include/roslz4/lz4s.h" + +#include "../../../rosbag_storage/include/rosbag/exceptions.h" +#include "../../../rosbag_storage/include/rosbag/macros.h" + +namespace rosbag { + +namespace compression +{ + enum CompressionType + { + Uncompressed = 0, + BZ2 = 1, + LZ4 = 2, + }; +} +typedef compression::CompressionType CompressionType; + +class ChunkedFile; + +class ROSBAG_DECL Stream +{ +public: + Stream(ChunkedFile* file); + virtual ~Stream(); + + virtual CompressionType getCompressionType() const = 0; + + virtual void write(void* ptr, size_t size) = 0; + virtual void read (void* ptr, size_t size) = 0; + + virtual void decompress(uint8_t* dest, unsigned int dest_len, uint8_t* source, unsigned int source_len) = 0; + + virtual void startWrite(); + virtual void stopWrite(); + + virtual void startRead(); + virtual void stopRead(); + +protected: + FILE* getFilePointer(); + uint64_t getCompressedIn(); + void setCompressedIn(uint64_t nbytes); + void advanceOffset(uint64_t nbytes); + char* getUnused(); + int getUnusedLength(); + void setUnused(char* unused); + void setUnusedLength(int nUnused); + void clearUnused(); + +protected: + ChunkedFile* file_; +}; + +class ROSBAG_DECL StreamFactory +{ +public: + StreamFactory(ChunkedFile* file); + + std::shared_ptr getStream(CompressionType type) const; + +private: + std::shared_ptr uncompressed_stream_; + std::shared_ptr lz4_stream_; +}; + +class ROSBAG_DECL UncompressedStream : public Stream +{ +public: + UncompressedStream(ChunkedFile* file); + + CompressionType getCompressionType() const; + + void write(void* ptr, size_t size); + void read(void* ptr, size_t size); + + void decompress(uint8_t* dest, unsigned int dest_len, uint8_t* source, unsigned int source_len); +}; + +// LZ4Stream reads/writes compressed datat in the LZ4 format +// https://code.google.com/p/lz4/ +class ROSBAG_DECL LZ4Stream : public Stream +{ +public: + LZ4Stream(ChunkedFile* file); + ~LZ4Stream(); + + CompressionType getCompressionType() const; + + void startWrite(); + void write(void* ptr, size_t size); + void stopWrite(); + + void startRead(); + void read(void* ptr, size_t size); + void stopRead(); + + void decompress(uint8_t* dest, unsigned int dest_len, uint8_t* source, unsigned int source_len); + +private: + void writeStream(int action); + + char *buff_; + int buff_size_; + int block_size_id_; + roslz4_stream lz4s_; +}; + + + +} // namespace rosbag + +#endif diff --git a/realsense-file/3rd_party/rosbag/rosbag_storage/include/rosbag/structures.h b/realsense-file/3rd_party/rosbag/rosbag_storage/include/rosbag/structures.h new file mode 100644 index 0000000000..b515a2deaa --- /dev/null +++ b/realsense-file/3rd_party/rosbag/rosbag_storage/include/rosbag/structures.h @@ -0,0 +1,94 @@ +/********************************************************************* + * Software License Agreement (BSD License) + * + * Copyright (c) 2008, Willow Garage, Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials provided + * with the distribution. + * * Neither the name of Willow Garage, Inc. nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN + * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + *********************************************************************/ + +#ifndef ROSBAG_STRUCTURES_H +#define ROSBAG_STRUCTURES_H + +#include +#include + +#include "../../../rostime/include/ros/time.h" +#include "../../../cpp_common/include/ros/datatypes.h" +#include "../../../rosbag_storage/include/rosbag/macros.h" + + +namespace rosbag { + +struct ROSBAG_DECL ConnectionInfo +{ + ConnectionInfo() : id(-1) { } + + uint32_t id; + std::string topic; + std::string datatype; + std::string md5sum; + std::string msg_def; + + std::shared_ptr header; +}; + +struct ChunkInfo +{ + ros::Time start_time; //! earliest timestamp of a message in the chunk + ros::Time end_time; //! latest timestamp of a message in the chunk + uint64_t pos; //! absolute byte offset of chunk record in bag file + + std::map connection_counts; //! number of messages in each connection stored in the chunk +}; + +struct ROSBAG_DECL ChunkHeader +{ + std::string compression; //! chunk compression type, e.g. "none" or "bz2" (see constants.h) + uint32_t compressed_size; //! compressed size of the chunk in bytes + uint32_t uncompressed_size; //! uncompressed size of the chunk in bytes +}; + +struct ROSBAG_DECL IndexEntry +{ + ros::Time time; //! timestamp of the message + uint64_t chunk_pos; //! absolute byte offset of the chunk record containing the message + uint32_t offset; //! relative byte offset of the message record (either definition or data) in the chunk + + bool operator<(IndexEntry const& b) const { return time < b.time; } +}; + +struct ROSBAG_DECL IndexEntryCompare +{ + bool operator()(ros::Time const& a, IndexEntry const& b) const { return a < b.time; } + bool operator()(IndexEntry const& a, ros::Time const& b) const { return a.time < b; } +}; + +} // namespace rosbag + +#endif diff --git a/realsense-file/3rd_party/rosbag/rosbag_storage/include/rosbag/view.h b/realsense-file/3rd_party/rosbag/rosbag_storage/include/rosbag/view.h new file mode 100644 index 0000000000..ea94b2388b --- /dev/null +++ b/realsense-file/3rd_party/rosbag/rosbag_storage/include/rosbag/view.h @@ -0,0 +1,179 @@ +/********************************************************************* +* Software License Agreement (BSD License) +* +* Copyright (c) 2008, Willow Garage, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions +* are met: +* +* * Redistributions of source code must retain the above copyright +* notice, this list of conditions and the following disclaimer. +* * Redistributions in binary form must reproduce the above +* copyright notice, this list of conditions and the following +* disclaimer in the documentation and/or other materials provided +* with the distribution. +* * Neither the name of Willow Garage, Inc. nor the names of its +* contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*********************************************************************/ + +#ifndef ROSBAG_VIEW_H +#define ROSBAG_VIEW_H + +#include +#include "boost/iterator/iterator_facade.hpp" + +#include "rosbag/message_instance.h" +#include "rosbag/query.h" +#include "rosbag/macros.h" +#include "rosbag/structures.h" + +namespace rosbag { + +class ROSBAG_DECL View +{ + friend class Bag; + +public: + //! An iterator that points to a MessageInstance from a bag + /*! + * This iterator stores the MessageInstance that it is returning a + * reference to. If you increment the iterator that + * MessageInstance is destroyed. You should never store the + * pointer to this reference. + */ + class iterator : public boost::iterator_facade + { + public: + iterator(iterator const& i); + iterator &operator=(iterator const& i); + iterator(); + ~iterator(); + + protected: + iterator(View* view, bool end = false); + + private: + friend class View; + friend class boost::iterator_core_access; + + void populate(); + void populateSeek(std::multiset::const_iterator iter); + + bool equal(iterator const& other) const; + + void increment(); + + MessageInstance& dereference() const; + + private: + View* view_; + std::vector iters_; + uint32_t view_revision_; + mutable MessageInstance* message_instance_; + }; + + typedef iterator const_iterator; + + struct TrueQuery { + bool operator()(ConnectionInfo const*) const { return true; }; + }; + + //! Create a view on a bag + /*! + * param reduce_overlap If multiple views return the same messages, reduce them to a single message + */ + View(bool const& reduce_overlap = false); + + //! Create a view on a bag + /*! + * param bag The bag file on which to run this query + * param start_time The beginning of the time range for the query + * param end_time The end of the time range for the query + * param reduce_overlap If multiple views return the same messages, reduce them to a single message + */ + View(Bag const& bag, ros::Time const& start_time = ros::TIME_MIN, ros::Time const& end_time = ros::TIME_MAX, bool const& reduce_overlap = false); + + //! Create a view and add a query + /*! + * param bag The bag file on which to run this query + * param query The actual query to evaluate which connections to include + * param start_time The beginning of the time range for the query + * param end_time The end of the time range for the query + * param reduce_overlap If multiple views return the same messages, reduce them to a single message + */ + View(Bag const& bag, boost::function query, + ros::Time const& start_time = ros::TIME_MIN, ros::Time const& end_time = ros::TIME_MAX, bool const& reduce_overlap = false); + + ~View(); + + iterator begin(); + iterator end(); + uint32_t size(); + + //! Add a query to a view + /*! + * param bag The bag file on which to run this query + * param start_time The beginning of the time range for the query + * param end_time The end of the time range for the query + */ + void addQuery(Bag const& bag, ros::Time const& start_time = ros::TIME_MIN, ros::Time const& end_time = ros::TIME_MAX); + + //! Add a query to a view + /*! + * param bag The bag file on which to run this query + * param query The actual query to evaluate which connections to include + * param start_time The beginning of the time range for the query + * param end_time The end of the time range for the query + */ + void addQuery(Bag const& bag, boost::function query, + ros::Time const& start_time = ros::TIME_MIN, ros::Time const& end_time = ros::TIME_MAX); + + std::vector getConnections(); + + ros::Time getBeginTime(); + ros::Time getEndTime(); + +protected: + friend class iterator; + + void updateQueries(BagQuery* q); + void update(); + + MessageInstance* newMessageInstance(ConnectionInfo const* connection_info, IndexEntry const& index, Bag const& bag); + +private: + View(View const& view); + View& operator=(View const& view); + +protected: + std::vector ranges_; + std::vector queries_; + uint32_t view_revision_; + + uint32_t size_cache_; + uint32_t size_revision_; + + bool reduce_overlap_; +}; + +} // namespace rosbag + +#endif diff --git a/realsense-file/3rd_party/rosbag/rosbag_storage/src/bag.cpp b/realsense-file/3rd_party/rosbag/rosbag_storage/src/bag.cpp new file mode 100644 index 0000000000..a7259e13d2 --- /dev/null +++ b/realsense-file/3rd_party/rosbag/rosbag_storage/src/bag.cpp @@ -0,0 +1,1120 @@ +// Copyright (c) 2009, Willow Garage, Inc. +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// * Neither the name of Willow Garage, Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE +// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +// POSSIBILITY OF SUCH DAMAGE. + +#include "rosbag/bag.h" +#include "rosbag/message_instance.h" +#include "rosbag/query.h" +#include "rosbag/view.h" + +#if defined(_MSC_VER) + #include // only on v2010 and later -> is this enough for msvc and linux? +#else + #include +#endif +#include +#include +#include + +#include + +#include "console_bridge/console.h" +#include + +#define foreach BOOST_FOREACH + +using std::map; +using std::priority_queue; +using std::string; +using std::vector; +using std::multiset; +using boost::format; +using std::shared_ptr; +using ros::M_string; +using ros::Time; + +namespace rosbag { + +Bag::Bag() : + mode_(bagmode::Write), + version_(0), + compression_(compression::Uncompressed), + chunk_threshold_(768 * 1024), // 768KB chunks + bag_revision_(0), + file_size_(0), + file_header_pos_(0), + index_data_pos_(0), + connection_count_(0), + chunk_count_(0), + chunk_open_(false), + curr_chunk_data_pos_(0), + current_buffer_(0), + decompressed_chunk_(0) +{ +} + +Bag::Bag(string const& filename, uint32_t mode) : + compression_(compression::Uncompressed), + chunk_threshold_(768 * 1024), // 768KB chunks + bag_revision_(0), + file_size_(0), + file_header_pos_(0), + index_data_pos_(0), + connection_count_(0), + chunk_count_(0), + chunk_open_(false), + curr_chunk_data_pos_(0), + current_buffer_(0), + decompressed_chunk_(0) +{ + open(filename, mode); +} + +Bag::~Bag() { + close(); +} + +void Bag::open(string const& filename, uint32_t mode) { + mode_ = (BagMode) mode; + + if (mode_ & bagmode::Append) + openAppend(filename); + else if (mode_ & bagmode::Write) + openWrite(filename); + else if (mode_ & bagmode::Read) + openRead(filename); + else + throw BagException((format("Unknown mode: %1%") % (int) mode).str()); + + // Determine file size + uint64_t offset = file_.getOffset(); + seek(0, std::ios::end); + file_size_ = file_.getOffset(); + seek(offset); +} + +void Bag::openRead(string const& filename) { + file_.openRead(filename); + + readVersion(); + + switch (version_) { + case 102: startReadingVersion102(); break; + case 200: startReadingVersion200(); break; + default: + throw BagException((format("Unsupported bag file version: %1%.%2%") % getMajorVersion() % getMinorVersion()).str()); + } +} + +void Bag::openWrite(string const& filename) { + file_.openWrite(filename); + + startWriting(); +} + +void Bag::openAppend(string const& filename) { + file_.openReadWrite(filename); + + readVersion(); + + if (version_ != 200) + throw BagException((format("Bag file version %1%.%2% is unsupported for appending") % getMajorVersion() % getMinorVersion()).str()); + + startReadingVersion200(); + + // Truncate the file to chop off the index + file_.truncate(index_data_pos_); + index_data_pos_ = 0; + + // Rewrite the file header, clearing the index position (so we know if the index is invalid) + seek(file_header_pos_); + writeFileHeaderRecord(); + + // Seek to the end of the file + seek(0, std::ios::end); +} + +void Bag::close() { + if (!file_.isOpen()) + return; + + if (mode_ & bagmode::Write || mode_ & bagmode::Append) + closeWrite(); + + file_.close(); + + topic_connection_ids_.clear(); + header_connection_ids_.clear(); + for (map::iterator i = connections_.begin(); i != connections_.end(); i++) + delete i->second; + connections_.clear(); + chunks_.clear(); + connection_indexes_.clear(); + curr_chunk_connection_indexes_.clear(); +} + +void Bag::closeWrite() { + stopWriting(); +} + +string Bag::getFileName() const { return file_.getFileName(); } +BagMode Bag::getMode() const { return mode_; } +uint64_t Bag::getSize() const { return file_size_; } + +uint32_t Bag::getChunkThreshold() const { return chunk_threshold_; } + +void Bag::setChunkThreshold(uint32_t chunk_threshold) { + if (file_.isOpen() && chunk_open_) + stopWritingChunk(); + + chunk_threshold_ = chunk_threshold; +} + +CompressionType Bag::getCompression() const { return compression_; } + +void Bag::setCompression(CompressionType compression) { + if (file_.isOpen() && chunk_open_) + stopWritingChunk(); + + if (!(compression == compression::Uncompressed || + compression == compression::BZ2 || + compression == compression::LZ4)) { + throw BagException( + (format("Unknown compression type: %i") % compression).str()); + } + + compression_ = compression; +} + +// Version + +void Bag::writeVersion() { + string version = string("#ROSBAG V") + VERSION + string("\n"); + + logDebug("Writing VERSION [%llu]: %s", (unsigned long long) file_.getOffset(), version.c_str()); + + version_ = 200; + + write(version); +} + +void Bag::readVersion() { + string version_line = file_.getline(); + + file_header_pos_ = file_.getOffset(); + + char logtypename[100]; + int version_major, version_minor; +#if defined(_MSC_VER) + if (sscanf_s(version_line.c_str(), "#ROS%s V%d.%d", logtypename, sizeof(logtypename), &version_major, &version_minor) != 3) +#else + if (sscanf(version_line.c_str(), "#ROS%s V%d.%d", logtypename, &version_major, &version_minor) != 3) +#endif + throw BagIOException("Error reading version line"); + + version_ = version_major * 100 + version_minor; + + logDebug("Read VERSION: version=%d", version_); +} + +uint32_t Bag::getMajorVersion() const { return version_ / 100; } +uint32_t Bag::getMinorVersion() const { return version_ % 100; } + +// + +void Bag::startWriting() { + writeVersion(); + file_header_pos_ = file_.getOffset(); + writeFileHeaderRecord(); +} + +void Bag::stopWriting() { + if (chunk_open_) + stopWritingChunk(); + + seek(0, std::ios::end); + + index_data_pos_ = file_.getOffset(); + writeConnectionRecords(); + writeChunkInfoRecords(); + + seek(file_header_pos_); + writeFileHeaderRecord(); +} + +void Bag::startReadingVersion200() { + // Read the file header record, which points to the end of the chunks + readFileHeaderRecord(); + + // Seek to the end of the chunks + seek(index_data_pos_); + + // Read the connection records (one for each connection) + for (uint32_t i = 0; i < connection_count_; i++) + readConnectionRecord(); + + // Read the chunk info records + for (uint32_t i = 0; i < chunk_count_; i++) + readChunkInfoRecord(); + + // Read the connection indexes for each chunk + foreach(ChunkInfo const& chunk_info, chunks_) { + curr_chunk_info_ = chunk_info; + + seek(curr_chunk_info_.pos); + + // Skip over the chunk data + ChunkHeader chunk_header; + readChunkHeader(chunk_header); + seek(chunk_header.compressed_size, std::ios::cur); + + // Read the index records after the chunk + for (unsigned int i = 0; i < chunk_info.connection_counts.size(); i++) + readConnectionIndexRecord200(); + } + + // At this point we don't have a curr_chunk_info anymore so we reset it + curr_chunk_info_ = ChunkInfo(); +} + +void Bag::startReadingVersion102() { + try + { + // Read the file header record, which points to the start of the topic indexes + readFileHeaderRecord(); + } + catch (BagFormatException ex) { + throw BagUnindexedException(); + } + + // Get the length of the file + seek(0, std::ios::end); + uint64_t filelength = file_.getOffset(); + + // Seek to the beginning of the topic index records + seek(index_data_pos_); + + // Read the topic index records, which point to the offsets of each message in the file + while (file_.getOffset() < filelength) + readTopicIndexRecord102(); + + // Read the message definition records (which are the first entry in the topic indexes) + for (map >::const_iterator i = connection_indexes_.begin(); i != connection_indexes_.end(); i++) { + multiset const& index = i->second; + IndexEntry const& first_entry = *index.begin(); + + logDebug("Reading message definition for connection %d at %llu", i->first, (unsigned long long) first_entry.chunk_pos); + + seek(first_entry.chunk_pos); + + readMessageDefinitionRecord102(); + } +} + +// File header record + +void Bag::writeFileHeaderRecord() { + connection_count_ = static_cast(connections_.size()); + chunk_count_ = static_cast(chunks_.size()); + + logDebug("Writing FILE_HEADER [%llu]: index_pos=%llu connection_count=%d chunk_count=%d", + (unsigned long long) file_.getOffset(), (unsigned long long) index_data_pos_, connection_count_, chunk_count_); + + // Write file header record + M_string header; + header[OP_FIELD_NAME] = toHeaderString(&OP_FILE_HEADER); + header[INDEX_POS_FIELD_NAME] = toHeaderString(&index_data_pos_); + header[CONNECTION_COUNT_FIELD_NAME] = toHeaderString(&connection_count_); + header[CHUNK_COUNT_FIELD_NAME] = toHeaderString(&chunk_count_); + + std::shared_ptr> header_buffer; + uint32_t header_len; + ros::Header::write(header, header_buffer, header_len); + uint32_t data_len = 0; + if (header_len < FILE_HEADER_LENGTH) + data_len = FILE_HEADER_LENGTH - header_len; + write((char*) &header_len, 4); + write((char*) header_buffer.get(), header_len); + write((char*) &data_len, 4); + + // Pad the file header record out + if (data_len > 0) { + string padding; + padding.resize(data_len, ' '); + write(padding); + } +} + +void Bag::readFileHeaderRecord() { + ros::Header header; + uint32_t data_size; + if (!readHeader(header) || !readDataLength(data_size)) + throw BagFormatException("Error reading FILE_HEADER record"); + + M_string& fields = *header.getValues(); + + if (!isOp(fields, OP_FILE_HEADER)) + throw BagFormatException("Expected FILE_HEADER op not found"); + + // Read index position + readField(fields, INDEX_POS_FIELD_NAME, true, (uint64_t*) &index_data_pos_); + + if (index_data_pos_ == 0) + throw BagUnindexedException(); + + // Read topic and chunks count + if (version_ >= 200) { + readField(fields, CONNECTION_COUNT_FIELD_NAME, true, &connection_count_); + readField(fields, CHUNK_COUNT_FIELD_NAME, true, &chunk_count_); + } + + logDebug("Read FILE_HEADER: index_pos=%llu connection_count=%d chunk_count=%d", + (unsigned long long) index_data_pos_, connection_count_, chunk_count_); + + // Skip the data section (just padding) + seek(data_size, std::ios::cur); +} + +uint32_t Bag::getChunkOffset() const { + if (compression_ == compression::Uncompressed) + return static_cast(file_.getOffset() - curr_chunk_data_pos_); + else + return file_.getCompressedBytesIn(); +} + +void Bag::startWritingChunk(Time time) { + // Initialize chunk info + curr_chunk_info_.pos = file_.getOffset(); + curr_chunk_info_.start_time = time; + curr_chunk_info_.end_time = time; + + // Write the chunk header, with a place-holder for the data sizes (we'll fill in when the chunk is finished) + writeChunkHeader(compression_, 0, 0); + + // Turn on compressed writing + file_.setWriteMode(compression_); + + // Record where the data section of this chunk started + curr_chunk_data_pos_ = file_.getOffset(); + + chunk_open_ = true; +} + +void Bag::stopWritingChunk() { + // Add this chunk to the index + chunks_.push_back(curr_chunk_info_); + + // Get the uncompressed and compressed sizes + uint32_t uncompressed_size = getChunkOffset(); + file_.setWriteMode(compression::Uncompressed); + uint32_t compressed_size = static_cast(file_.getOffset() - curr_chunk_data_pos_); + + // Rewrite the chunk header with the size of the chunk (remembering current offset) + uint64_t end_of_chunk_pos = file_.getOffset(); + + seek(curr_chunk_info_.pos); + writeChunkHeader(compression_, compressed_size, uncompressed_size); + + // Write out the indexes and clear them + seek(end_of_chunk_pos); + writeIndexRecords(); + curr_chunk_connection_indexes_.clear(); + + // Clear the connection counts + curr_chunk_info_.connection_counts.clear(); + + // Flag that we're starting a new chunk + chunk_open_ = false; +} + +void Bag::writeChunkHeader(CompressionType compression, uint32_t compressed_size, uint32_t uncompressed_size) { + ChunkHeader chunk_header; + switch (compression) { + case compression::Uncompressed: chunk_header.compression = COMPRESSION_NONE; break; + case compression::BZ2: chunk_header.compression = COMPRESSION_BZ2; break; + case compression::LZ4: chunk_header.compression = COMPRESSION_LZ4; + //case compression::ZLIB: chunk_header.compression = COMPRESSION_ZLIB; break; + } + chunk_header.compressed_size = compressed_size; + chunk_header.uncompressed_size = uncompressed_size; + + logDebug("Writing CHUNK [%llu]: compression=%s compressed=%d uncompressed=%d", + (unsigned long long) file_.getOffset(), chunk_header.compression.c_str(), chunk_header.compressed_size, chunk_header.uncompressed_size); + + M_string header; + header[OP_FIELD_NAME] = toHeaderString(&OP_CHUNK); + header[COMPRESSION_FIELD_NAME] = chunk_header.compression; + header[SIZE_FIELD_NAME] = toHeaderString(&chunk_header.uncompressed_size); + writeHeader(header); + + writeDataLength(chunk_header.compressed_size); +} + +void Bag::readChunkHeader(ChunkHeader& chunk_header) const { + ros::Header header; + if (!readHeader(header) || !readDataLength(chunk_header.compressed_size)) + throw BagFormatException("Error reading CHUNK record"); + + M_string& fields = *header.getValues(); + + if (!isOp(fields, OP_CHUNK)) + throw BagFormatException("Expected CHUNK op not found"); + + readField(fields, COMPRESSION_FIELD_NAME, true, chunk_header.compression); + readField(fields, SIZE_FIELD_NAME, true, &chunk_header.uncompressed_size); + + logDebug("Read CHUNK: compression=%s size=%d uncompressed=%d (%f)", chunk_header.compression.c_str(), chunk_header.compressed_size, chunk_header.uncompressed_size, 100 * ((double) chunk_header.compressed_size) / chunk_header.uncompressed_size); +} + +// Index records + +void Bag::writeIndexRecords() { + for (map >::const_iterator i = curr_chunk_connection_indexes_.begin(); i != curr_chunk_connection_indexes_.end(); i++) { + uint32_t connection_id = i->first; + multiset const& index = i->second; + + // Write the index record header + uint32_t index_size = static_cast(index.size()); + M_string header; + header[OP_FIELD_NAME] = toHeaderString(&OP_INDEX_DATA); + header[CONNECTION_FIELD_NAME] = toHeaderString(&connection_id); + header[VER_FIELD_NAME] = toHeaderString(&INDEX_VERSION); + header[COUNT_FIELD_NAME] = toHeaderString(&index_size); + writeHeader(header); + + writeDataLength(index_size * 12); + + logDebug("Writing INDEX_DATA: connection=%d ver=%d count=%d", connection_id, INDEX_VERSION, index_size); + + // Write the index record data (pairs of timestamp and position in file) + foreach(IndexEntry const& e, index) { + write((char*) &e.time.sec, 4); + write((char*) &e.time.nsec, 4); + write((char*) &e.offset, 4); + + logDebug(" - %d.%d: %d", e.time.sec, e.time.nsec, e.offset); + } + } +} + +void Bag::readTopicIndexRecord102() { + ros::Header header; + uint32_t data_size; + if (!readHeader(header) || !readDataLength(data_size)) + throw BagFormatException("Error reading INDEX_DATA header"); + M_string& fields = *header.getValues(); + + if (!isOp(fields, OP_INDEX_DATA)) + throw BagFormatException("Expected INDEX_DATA record"); + + uint32_t index_version; + string topic; + uint32_t count = 0; + readField(fields, VER_FIELD_NAME, true, &index_version); + readField(fields, TOPIC_FIELD_NAME, true, topic); + readField(fields, COUNT_FIELD_NAME, true, &count); + + logDebug("Read INDEX_DATA: ver=%d topic=%s count=%d", index_version, topic.c_str(), count); + + if (index_version != 0) + throw BagFormatException((format("Unsupported INDEX_DATA version: %1%") % index_version).str()); + + uint32_t connection_id; + map::const_iterator topic_conn_id_iter = topic_connection_ids_.find(topic); + if (topic_conn_id_iter == topic_connection_ids_.end()) { + connection_id = static_cast(connections_.size()); + + logDebug("Creating connection: id=%d topic=%s", connection_id, topic.c_str()); + ConnectionInfo* connection_info = new ConnectionInfo(); + connection_info->id = connection_id; + connection_info->topic = topic; + connections_[connection_id] = connection_info; + + topic_connection_ids_[topic] = connection_id; + } + else + connection_id = topic_conn_id_iter->second; + + multiset& connection_index = connection_indexes_[connection_id]; + + for (uint32_t i = 0; i < count; i++) { + IndexEntry index_entry; + uint32_t sec; + uint32_t nsec; + read((char*) &sec, 4); + read((char*) &nsec, 4); + read((char*) &index_entry.chunk_pos, 8); // ros::TIME_MAX) + { + logError("Index entry for topic %s contains invalid time.", topic.c_str()); + } else + { + connection_index.insert(connection_index.end(), index_entry); + } + } +} + +void Bag::readConnectionIndexRecord200() { + ros::Header header; + uint32_t data_size; + if (!readHeader(header) || !readDataLength(data_size)) + throw BagFormatException("Error reading INDEX_DATA header"); + M_string& fields = *header.getValues(); + + if (!isOp(fields, OP_INDEX_DATA)) + throw BagFormatException("Expected INDEX_DATA record"); + + uint32_t index_version; + uint32_t connection_id; + uint32_t count = 0; + readField(fields, VER_FIELD_NAME, true, &index_version); + readField(fields, CONNECTION_FIELD_NAME, true, &connection_id); + readField(fields, COUNT_FIELD_NAME, true, &count); + + logDebug("Read INDEX_DATA: ver=%d connection=%d count=%d", index_version, connection_id, count); + + if (index_version != 1) + throw BagFormatException((format("Unsupported INDEX_DATA version: %1%") % index_version).str()); + + uint64_t chunk_pos = curr_chunk_info_.pos; + + multiset& connection_index = connection_indexes_[connection_id]; + + for (uint32_t i = 0; i < count; i++) { + IndexEntry index_entry; + index_entry.chunk_pos = chunk_pos; + uint32_t sec; + uint32_t nsec; + read((char*) &sec, 4); + read((char*) &nsec, 4); + read((char*) &index_entry.offset, 4); + index_entry.time = Time(sec, nsec); + + logDebug(" - %d.%d: %llu+%d", sec, nsec, (unsigned long long) index_entry.chunk_pos, index_entry.offset); + + if (index_entry.time < ros::TIME_MIN || index_entry.time > ros::TIME_MAX) + { + logError("Index entry for topic %s contains invalid time. This message will not be loaded.", connections_[connection_id]->topic.c_str()); + } else + { + connection_index.insert(connection_index.end(), index_entry); + } + } +} + +// Connection records + +void Bag::writeConnectionRecords() { + for (map::const_iterator i = connections_.begin(); i != connections_.end(); i++) { + ConnectionInfo const* connection_info = i->second; + writeConnectionRecord(connection_info); + } +} + +void Bag::writeConnectionRecord(ConnectionInfo const* connection_info) { + logDebug("Writing CONNECTION [%llu:%d]: topic=%s id=%d", + (unsigned long long) file_.getOffset(), getChunkOffset(), connection_info->topic.c_str(), connection_info->id); + + M_string header; + header[OP_FIELD_NAME] = toHeaderString(&OP_CONNECTION); + header[TOPIC_FIELD_NAME] = connection_info->topic; + header[CONNECTION_FIELD_NAME] = toHeaderString(&connection_info->id); + writeHeader(header); + + writeHeader(*connection_info->header); +} + +void Bag::appendConnectionRecordToBuffer(Buffer& buf, ConnectionInfo const* connection_info) { + M_string header; + header[OP_FIELD_NAME] = toHeaderString(&OP_CONNECTION); + header[TOPIC_FIELD_NAME] = connection_info->topic; + header[CONNECTION_FIELD_NAME] = toHeaderString(&connection_info->id); + appendHeaderToBuffer(buf, header); + + appendHeaderToBuffer(buf, *connection_info->header); +} + +void Bag::readConnectionRecord() { + ros::Header header; + if (!readHeader(header)) + throw BagFormatException("Error reading CONNECTION header"); + M_string& fields = *header.getValues(); + + if (!isOp(fields, OP_CONNECTION)) + throw BagFormatException("Expected CONNECTION op not found"); + + uint32_t id; + readField(fields, CONNECTION_FIELD_NAME, true, &id); + string topic; + readField(fields, TOPIC_FIELD_NAME, true, topic); + + ros::Header connection_header; + if (!readHeader(connection_header)) + throw BagFormatException("Error reading connection header"); + + // If this is a new connection, update connections + map::iterator key = connections_.find(id); + if (key == connections_.end()) { + ConnectionInfo* connection_info = new ConnectionInfo(); + connection_info->id = id; + connection_info->topic = topic; + connection_info->header = std::make_shared(); + for (M_string::const_iterator i = connection_header.getValues()->begin(); i != connection_header.getValues()->end(); i++) + (*connection_info->header)[i->first] = i->second; + connection_info->msg_def = (*connection_info->header)["message_definition"]; + connection_info->datatype = (*connection_info->header)["type"]; + connection_info->md5sum = (*connection_info->header)["md5sum"]; + connections_[id] = connection_info; + + logDebug("Read CONNECTION: topic=%s id=%d", topic.c_str(), id); + } +} + +void Bag::readMessageDefinitionRecord102() { + ros::Header header; + uint32_t data_size; + if (!readHeader(header) || !readDataLength(data_size)) + throw BagFormatException("Error reading message definition header"); + M_string& fields = *header.getValues(); + + if (!isOp(fields, OP_MSG_DEF)) + throw BagFormatException("Expected MSG_DEF op not found"); + + string topic, md5sum, datatype, message_definition; + readField(fields, TOPIC_FIELD_NAME, true, topic); + readField(fields, MD5_FIELD_NAME, 32, 32, true, md5sum); + readField(fields, TYPE_FIELD_NAME, true, datatype); + readField(fields, DEF_FIELD_NAME, 0, UINT_MAX, true, message_definition); + + ConnectionInfo* connection_info; + + map::const_iterator topic_conn_id_iter = topic_connection_ids_.find(topic); + if (topic_conn_id_iter == topic_connection_ids_.end()) { + uint32_t id = static_cast(connections_.size()); + + logDebug("Creating connection: topic=%s md5sum=%s datatype=%s", topic.c_str(), md5sum.c_str(), datatype.c_str()); + connection_info = new ConnectionInfo(); + connection_info->id = id; + connection_info->topic = topic; + + connections_[id] = connection_info; + topic_connection_ids_[topic] = id; + } + else + connection_info = connections_[topic_conn_id_iter->second]; + + connection_info->msg_def = message_definition; + connection_info->datatype = datatype; + connection_info->md5sum = md5sum; + connection_info->header = std::make_shared(); + (*connection_info->header)["type"] = connection_info->datatype; + (*connection_info->header)["md5sum"] = connection_info->md5sum; + (*connection_info->header)["message_definition"] = connection_info->msg_def; + + logDebug("Read MSG_DEF: topic=%s md5sum=%s datatype=%s", topic.c_str(), md5sum.c_str(), datatype.c_str()); +} + +void Bag::decompressChunk(uint64_t chunk_pos) const { + if (curr_chunk_info_.pos == chunk_pos) { + current_buffer_ = &outgoing_chunk_buffer_; + return; + } + + current_buffer_ = &decompress_buffer_; + + if (decompressed_chunk_ == chunk_pos) + return; + + // Seek to the start of the chunk + seek(chunk_pos); + + // Read the chunk header + ChunkHeader chunk_header; + readChunkHeader(chunk_header); + + // Read and decompress the chunk. These assume we are at the right place in the stream already + if (chunk_header.compression == COMPRESSION_NONE) + decompressRawChunk(chunk_header); + else if (chunk_header.compression == COMPRESSION_BZ2) + decompressBz2Chunk(chunk_header); + else if (chunk_header.compression == COMPRESSION_LZ4) + decompressLz4Chunk(chunk_header); + else + throw BagFormatException("Unknown compression: " + chunk_header.compression); + + decompressed_chunk_ = chunk_pos; +} + +void Bag::readMessageDataRecord102(uint64_t offset, ros::Header& header) const { + logDebug("readMessageDataRecord: offset=%llu", (unsigned long long) offset); + + seek(offset); + + uint32_t data_size; + uint8_t op; + do { + if (!readHeader(header) || !readDataLength(data_size)) + throw BagFormatException("Error reading header"); + + readField(*header.getValues(), OP_FIELD_NAME, true, &op); + } + while (op == OP_MSG_DEF); + + if (op != OP_MSG_DATA) + throw BagFormatException((format("Expected MSG_DATA op, got %d") % op).str()); + + record_buffer_.setSize(data_size); + file_.read((char*) record_buffer_.getData(), data_size); +} + +// Reading this into a buffer isn't completely necessary, but we do it anyways for now +void Bag::decompressRawChunk(ChunkHeader const& chunk_header) const { + assert(chunk_header.compression == COMPRESSION_NONE); + assert(chunk_header.compressed_size == chunk_header.uncompressed_size); + + logDebug("compressed_size: %d uncompressed_size: %d", chunk_header.compressed_size, chunk_header.uncompressed_size); + + decompress_buffer_.setSize(chunk_header.compressed_size); + file_.read((char*) decompress_buffer_.getData(), chunk_header.compressed_size); + + // todo check read was successful +} + +void Bag::decompressBz2Chunk(ChunkHeader const& chunk_header) const { + assert(chunk_header.compression == COMPRESSION_BZ2); + + CompressionType compression = compression::BZ2; + + logDebug("compressed_size: %d uncompressed_size: %d", chunk_header.compressed_size, chunk_header.uncompressed_size); + + chunk_buffer_.setSize(chunk_header.compressed_size); + file_.read((char*) chunk_buffer_.getData(), chunk_header.compressed_size); + + decompress_buffer_.setSize(chunk_header.uncompressed_size); + file_.decompress(compression, decompress_buffer_.getData(), decompress_buffer_.getSize(), chunk_buffer_.getData(), chunk_buffer_.getSize()); + + // todo check read was successful +} + +void Bag::decompressLz4Chunk(ChunkHeader const& chunk_header) const { + assert(chunk_header.compression == COMPRESSION_LZ4); + + CompressionType compression = compression::LZ4; + + logDebug("lz4 compressed_size: %d uncompressed_size: %d", + chunk_header.compressed_size, chunk_header.uncompressed_size); + + chunk_buffer_.setSize(chunk_header.compressed_size); + file_.read((char*) chunk_buffer_.getData(), chunk_header.compressed_size); + + decompress_buffer_.setSize(chunk_header.uncompressed_size); + file_.decompress(compression, decompress_buffer_.getData(), decompress_buffer_.getSize(), chunk_buffer_.getData(), chunk_buffer_.getSize()); + + // todo check read was successful +} + +ros::Header Bag::readMessageDataHeader(IndexEntry const& index_entry) { + ros::Header header; + uint32_t data_size; + uint32_t bytes_read; + switch (version_) + { + case 200: + decompressChunk(index_entry.chunk_pos); + readMessageDataHeaderFromBuffer(*current_buffer_, index_entry.offset, header, data_size, bytes_read); + return header; + case 102: + readMessageDataRecord102(index_entry.chunk_pos, header); + return header; + default: + throw BagFormatException((format("Unhandled version: %1%") % version_).str()); + } +} + +// NOTE: this loads the header, which is unnecessary +uint32_t Bag::readMessageDataSize(IndexEntry const& index_entry) const { + ros::Header header; + uint32_t data_size; + uint32_t bytes_read; + switch (version_) + { + case 200: + decompressChunk(index_entry.chunk_pos); + readMessageDataHeaderFromBuffer(*current_buffer_, index_entry.offset, header, data_size, bytes_read); + return data_size; + case 102: + readMessageDataRecord102(index_entry.chunk_pos, header); + return record_buffer_.getSize(); + default: + throw BagFormatException((format("Unhandled version: %1%") % version_).str()); + } +} + +void Bag::writeChunkInfoRecords() { + foreach(ChunkInfo const& chunk_info, chunks_) { + // Write the chunk info header + M_string header; + uint32_t chunk_connection_count = static_cast(chunk_info.connection_counts.size()); + header[OP_FIELD_NAME] = toHeaderString(&OP_CHUNK_INFO); + header[VER_FIELD_NAME] = toHeaderString(&CHUNK_INFO_VERSION); + header[CHUNK_POS_FIELD_NAME] = toHeaderString(&chunk_info.pos); + header[START_TIME_FIELD_NAME] = toHeaderString(&chunk_info.start_time); + header[END_TIME_FIELD_NAME] = toHeaderString(&chunk_info.end_time); + header[COUNT_FIELD_NAME] = toHeaderString(&chunk_connection_count); + + logDebug("Writing CHUNK_INFO [%llu]: ver=%d pos=%llu start=%d.%d end=%d.%d", + (unsigned long long) file_.getOffset(), CHUNK_INFO_VERSION, (unsigned long long) chunk_info.pos, + chunk_info.start_time.sec, chunk_info.start_time.nsec, + chunk_info.end_time.sec, chunk_info.end_time.nsec); + + writeHeader(header); + + writeDataLength(8 * chunk_connection_count); + // Write the topic names and counts + for (map::const_iterator i = chunk_info.connection_counts.begin(); i != chunk_info.connection_counts.end(); i++) { + uint32_t connection_id = i->first; + uint32_t count = i->second; + + write((char*) &connection_id, 4); + write((char*) &count, 4); + + logDebug(" - %d: %d", connection_id, count); + } + } +} + +void Bag::readChunkInfoRecord() { + // Read a CHUNK_INFO header + ros::Header header; + uint32_t data_size; + if (!readHeader(header) || !readDataLength(data_size)) + throw BagFormatException("Error reading CHUNK_INFO record header"); + M_string& fields = *header.getValues(); + if (!isOp(fields, OP_CHUNK_INFO)) + throw BagFormatException("Expected CHUNK_INFO op not found"); + + // Check that the chunk info version is current + uint32_t chunk_info_version; + readField(fields, VER_FIELD_NAME, true, &chunk_info_version); + if (chunk_info_version != CHUNK_INFO_VERSION) + throw BagFormatException((format("Expected CHUNK_INFO version %1%, read %2%") % CHUNK_INFO_VERSION % chunk_info_version).str()); + + // Read the chunk position, timestamp, and topic count fieldsstd_msgs::Float32 + ChunkInfo chunk_info; + readField(fields, CHUNK_POS_FIELD_NAME, true, &chunk_info.pos); + readField(fields, START_TIME_FIELD_NAME, true, chunk_info.start_time); + readField(fields, END_TIME_FIELD_NAME, true, chunk_info.end_time); + uint32_t chunk_connection_count = 0; + readField(fields, COUNT_FIELD_NAME, true, &chunk_connection_count); + + logDebug("Read CHUNK_INFO: chunk_pos=%llu connection_count=%d start=%d.%d end=%d.%d", + (unsigned long long) chunk_info.pos, chunk_connection_count, + chunk_info.start_time.sec, chunk_info.start_time.nsec, + chunk_info.end_time.sec, chunk_info.end_time.nsec); + + // Read the topic count entries + for (uint32_t i = 0; i < chunk_connection_count; i ++) { + uint32_t connection_id, connection_count; + read((char*) &connection_id, 4); + read((char*) &connection_count, 4); + + logDebug(" %d: %d messages", connection_id, connection_count); + + chunk_info.connection_counts[connection_id] = connection_count; + } + + chunks_.push_back(chunk_info); +} + +// Record I/O + +bool Bag::isOp(M_string& fields, uint8_t reqOp) const { + uint8_t op = 0xFF; // nonexistent op + readField(fields, OP_FIELD_NAME, true, &op); + return op == reqOp; +} + +void Bag::writeHeader(M_string const& fields) { + std::shared_ptr> header_buffer; + uint32_t header_len; + ros::Header::write(fields, header_buffer, header_len); + write((char*) &header_len, 4); + write((char*) header_buffer.get(), header_len); +} + +void Bag::writeDataLength(uint32_t data_len) { + write((char*) &data_len, 4); +} + +void Bag::appendHeaderToBuffer(Buffer& buf, M_string const& fields) { + std::shared_ptr> header_buffer; + uint32_t header_len; + ros::Header::write(fields, header_buffer, header_len); + + uint32_t offset = buf.getSize(); + + buf.setSize(buf.getSize() + 4 + header_len); + + memcpy(buf.getData() + offset, &header_len, 4); + offset += 4; + memcpy(buf.getData() + offset, header_buffer.get(), header_len); +} + +void Bag::appendDataLengthToBuffer(Buffer& buf, uint32_t data_len) { + uint32_t offset = buf.getSize(); + + buf.setSize(buf.getSize() + 4); + + memcpy(buf.getData() + offset, &data_len, 4); +} + +//! \todo clean this up +void Bag::readHeaderFromBuffer(Buffer& buffer, uint32_t offset, ros::Header& header, uint32_t& data_size, uint32_t& bytes_read) const { + assert(buffer.getSize() > 8); + + uint8_t* start = (uint8_t*) buffer.getData() + offset; + + uint8_t* ptr = start; + + // Read the header length + uint32_t header_len; + memcpy(&header_len, ptr, 4); + ptr += 4; + + // Parse the header + string error_msg; + bool parsed = header.parse(ptr, header_len, error_msg); + if (!parsed) + throw BagFormatException("Error parsing header"); + ptr += header_len; + + // Read the data size + memcpy(&data_size, ptr, 4); + ptr += 4; + + bytes_read = static_cast(ptr - start); +} + +void Bag::readMessageDataHeaderFromBuffer(Buffer& buffer, uint32_t offset, ros::Header& header, uint32_t& data_size, uint32_t& total_bytes_read) const { + (void)buffer; + total_bytes_read = 0; + uint8_t op = 0xFF; + do { + logDebug("reading header from buffer: offset=%d", offset); + uint32_t bytes_read; + readHeaderFromBuffer(*current_buffer_, offset, header, data_size, bytes_read); + + offset += bytes_read; + total_bytes_read += bytes_read; + + readField(*header.getValues(), OP_FIELD_NAME, true, &op); + } + while (op == OP_MSG_DEF || op == OP_CONNECTION); + + if (op != OP_MSG_DATA) + throw BagFormatException("Expected MSG_DATA op not found"); +} + +bool Bag::readHeader(ros::Header& header) const { + // Read the header length + uint32_t header_len; + read((char*) &header_len, 4); + + // Read the header + header_buffer_.setSize(header_len); + read((char*) header_buffer_.getData(), header_len); + + // Parse the header + string error_msg; + bool parsed = header.parse(header_buffer_.getData(), header_len, error_msg); + if (!parsed) + return false; + + return true; +} + +bool Bag::readDataLength(uint32_t& data_size) const { + read((char*) &data_size, 4); + return true; +} + +M_string::const_iterator Bag::checkField(M_string const& fields, string const& field, unsigned int min_len, unsigned int max_len, bool required) const { + M_string::const_iterator fitr = fields.find(field); + if (fitr == fields.end()) { + if (required) + throw BagFormatException("Required '" + field + "' field missing"); + } + else if ((fitr->second.size() < min_len) || (fitr->second.size() > max_len)) + throw BagFormatException((format("Field '%1%' is wrong size (%2% bytes)") % field % (uint32_t) fitr->second.size()).str()); + + return fitr; +} + +bool Bag::readField(M_string const& fields, string const& field_name, bool required, string& data) const { + return readField(fields, field_name, 1, UINT_MAX, required, data); +} + +bool Bag::readField(M_string const& fields, string const& field_name, unsigned int min_len, unsigned int max_len, bool required, string& data) const { + M_string::const_iterator fitr = checkField(fields, field_name, min_len, max_len, required); + if (fitr == fields.end()) + return false; + + data = fitr->second; + return true; +} + +bool Bag::readField(M_string const& fields, string const& field_name, bool required, Time& data) const { + uint64_t packed_time; + if (!readField(fields, field_name, required, &packed_time)) + return false; + + uint64_t bitmask = (1LL << 33) - 1; + data.sec = (uint32_t) (packed_time & bitmask); + data.nsec = (uint32_t) (packed_time >> 32); + + return true; +} + +std::string Bag::toHeaderString(Time const* field) const { + uint64_t packed_time = (((uint64_t) field->nsec) << 32) + field->sec; + return toHeaderString(&packed_time); +} + + +// Low-level I/O + +void Bag::write(string const& s) { write(s.c_str(), s.length()); } +void Bag::write(char const* s, std::streamsize n) { file_.write((char*) s, n); } + +void Bag::read(char* b, std::streamsize n) const { file_.read(b, n); } +void Bag::seek(uint64_t pos, int origin) const { file_.seek(pos, origin); } + +} // namespace rosbag diff --git a/realsense-file/3rd_party/rosbag/rosbag_storage/src/bag_player.cpp b/realsense-file/3rd_party/rosbag/rosbag_storage/src/bag_player.cpp new file mode 100644 index 0000000000..ae87e6a8e4 --- /dev/null +++ b/realsense-file/3rd_party/rosbag/rosbag_storage/src/bag_player.cpp @@ -0,0 +1,71 @@ +#include "rosbag/bag_player.h" + +#define foreach BOOST_FOREACH + +namespace rosbag +{ + +BagPlayer::BagPlayer(const std::string &fname) throw(BagException) { + bag.open(fname, rosbag::bagmode::Read); + ros::Time::init(); + View v(bag); + bag_start_ = v.getBeginTime(); + bag_end_ = v.getEndTime(); + last_message_time_ = ros::Time(0); + playback_speed_ = 1.0; +} + +BagPlayer::~BagPlayer() { + bag.close(); +} + +ros::Time BagPlayer::get_time() { + return last_message_time_; +} + +void BagPlayer::set_start(const ros::Time &start) { + bag_start_ = start; +} + +void BagPlayer::set_end(const ros::Time &end) { + bag_end_ = end; +} + +void BagPlayer::set_playback_speed(double scale) { + if (scale > 0.0) + playback_speed_ = scale; +} + +ros::Time BagPlayer::real_time(const ros::Time &msg_time) { + return play_start_ + (msg_time - bag_start_) * (1 / playback_speed_); +} + +void BagPlayer::start_play() { + + std::vector topics; + std::pair cb; + foreach(cb, cbs_) + topics.push_back(cb.first); + + View view(bag, TopicQuery(topics), bag_start_, bag_end_); + play_start_ = ros::Time::now(); + + foreach(MessageInstance const m, view) + { + if (cbs_.find(m.getTopic()) == cbs_.end()) + continue; + + ros::Time::sleepUntil(real_time(m.getTime())); + + last_message_time_ = m.getTime(); /* this is the recorded time */ + cbs_[m.getTopic()]->call(m); + } +} + +void BagPlayer::unregister_callback(const std::string &topic) { + delete cbs_[topic]; + cbs_.erase(topic); +} + +} + diff --git a/realsense-file/3rd_party/rosbag/rosbag_storage/src/buffer.cpp b/realsense-file/3rd_party/rosbag/rosbag_storage/src/buffer.cpp new file mode 100644 index 0000000000..b3d217a8fc --- /dev/null +++ b/realsense-file/3rd_party/rosbag/rosbag_storage/src/buffer.cpp @@ -0,0 +1,74 @@ +/********************************************************************* +* Software License Agreement (BSD License) +* +* Copyright (c) 2008, Willow Garage, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions +* are met: +* +* * Redistributions of source code must retain the above copyright +* notice, this list of conditions and the following disclaimer. +* * Redistributions in binary form must reproduce the above +* copyright notice, this list of conditions and the following +* disclaimer in the documentation and/or other materials provided +* with the distribution. +* * Neither the name of Willow Garage, Inc. nor the names of its +* contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +********************************************************************/ + +#include +#include + +#include "rosbag/buffer.h" + +//#include + +namespace rosbag { + +Buffer::Buffer() : buffer_(NULL), capacity_(0), size_(0) { } + +Buffer::~Buffer() { + free(buffer_); +} + +uint8_t* Buffer::getData() { return buffer_; } +uint32_t Buffer::getCapacity() const { return capacity_; } +uint32_t Buffer::getSize() const { return size_; } + +void Buffer::setSize(uint32_t size) { + size_ = size; + ensureCapacity(size); +} + +void Buffer::ensureCapacity(uint32_t capacity) { + if (capacity <= capacity_) + return; + + if (capacity_ == 0) + capacity_ = capacity; + else { + while (capacity_ < capacity) + capacity_ *= 2; + } + + buffer_ = (uint8_t*) realloc(buffer_, capacity_); + assert(buffer_); +} + +} // namespace rosbag diff --git a/realsense-file/3rd_party/rosbag/rosbag_storage/src/chunked_file.cpp b/realsense-file/3rd_party/rosbag/rosbag_storage/src/chunked_file.cpp new file mode 100644 index 0000000000..31b7fb08e5 --- /dev/null +++ b/realsense-file/3rd_party/rosbag/rosbag_storage/src/chunked_file.cpp @@ -0,0 +1,226 @@ +/********************************************************************* +* Software License Agreement (BSD License) +* +* Copyright (c) 2008, Willow Garage, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions +* are met: +* +* * Redistributions of source code must retain the above copyright +* notice, this list of conditions and the following disclaimer. +* * Redistributions in binary form must reproduce the above +* copyright notice, this list of conditions and the following +* disclaimer in the documentation and/or other materials provided +* with the distribution. +* * Neither the name of Willow Garage, Inc. nor the names of its +* contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +********************************************************************/ + +#include "rosbag/chunked_file.h" + +#include + +#include "boost/format.hpp" +//#include "boost/make_shared.hpp" + +//#include +#ifdef _WIN32 +# ifdef __MINGW32__ +# define fseeko fseeko64 +# define ftello ftello64 +// not sure if we need a ftruncate here yet or not +# else +# include +# define fseeko _fseeki64 +# define ftello _ftelli64 +# define fileno _fileno +# define ftruncate _chsize +# endif +#endif + +using std::string; +using boost::format; +using std::shared_ptr; +using ros::Exception; + +namespace rosbag { + +ChunkedFile::ChunkedFile() : + file_(NULL), + offset_(0), + compressed_in_(0), + unused_(NULL), + nUnused_(0) +{ + stream_factory_ = std::make_shared(this); +} + +ChunkedFile::~ChunkedFile() { + close(); +} + +void ChunkedFile::openReadWrite(string const& filename) { open(filename, "r+b"); } +void ChunkedFile::openWrite (string const& filename) { open(filename, "w+b"); } +void ChunkedFile::openRead (string const& filename) { open(filename, "rb"); } + +void ChunkedFile::open(string const& filename, string const& mode) { + // Check if file is already open + if (file_) + throw BagIOException((format("File already open: %1%") % filename_.c_str()).str()); + + // Open the file + if (mode == "r+b") { + // check if file already exists + #if defined(_MSC_VER) && (_MSC_VER >= 1400 ) + fopen_s( &file_, filename.c_str(), "r" ); + #else + file_ = fopen(filename.c_str(), "r"); + #endif + if (file_ == NULL) + // create an empty file and open it for update + #if defined(_MSC_VER) && (_MSC_VER >= 1400 ) + fopen_s( &file_, filename.c_str(), "w+b" ); + #else + file_ = fopen(filename.c_str(), "w+b"); + #endif + else { + fclose(file_); + // open existing file for update + #if defined(_MSC_VER) && (_MSC_VER >= 1400 ) + fopen_s( &file_, filename.c_str(), "r+b" ); + #else + file_ = fopen(filename.c_str(), "r+b"); + #endif + } + } + else + #if defined(_MSC_VER) && (_MSC_VER >= 1400 ) + fopen_s( &file_, filename.c_str(), mode.c_str() ); + #else + file_ = fopen(filename.c_str(), mode.c_str()); + #endif + + if (!file_) + throw BagIOException((format("Error opening file: %1%") % filename.c_str()).str()); + + read_stream_ = std::make_shared(this); + write_stream_ = std::make_shared(this); + filename_ = filename; + offset_ = ftello(file_); +} + +bool ChunkedFile::good() const { + return feof(file_) == 0 && ferror(file_) == 0; +} + +bool ChunkedFile::isOpen() const { return file_ != NULL; } +string ChunkedFile::getFileName() const { return filename_; } + +void ChunkedFile::close() { + if (!file_) + return; + + // Close any compressed stream by changing to uncompressed mode + setWriteMode(compression::Uncompressed); + + // Close the file + int success = fclose(file_); + if (success != 0) + throw BagIOException((format("Error closing file: %1%") % filename_.c_str()).str()); + + file_ = NULL; + filename_.clear(); + + clearUnused(); +} + +// Read/write modes + +void ChunkedFile::setWriteMode(CompressionType type) { + if (!file_) + throw BagIOException("Can't set compression mode before opening a file"); + + if (type != write_stream_->getCompressionType()) { + write_stream_->stopWrite(); + shared_ptr stream = stream_factory_->getStream(type); + stream->startWrite(); + write_stream_ = stream; + } +} + +void ChunkedFile::setReadMode(CompressionType type) { + if (!file_) + throw BagIOException("Can't set compression mode before opening a file"); + + if (type != read_stream_->getCompressionType()) { + read_stream_->stopRead(); + shared_ptr stream = stream_factory_->getStream(type); + stream->startRead(); + read_stream_ = stream; + } +} + +void ChunkedFile::seek(uint64_t offset, int origin) { + if (!file_) + throw BagIOException("Can't seek - file not open"); + + setReadMode(compression::Uncompressed); + + int success = fseeko(file_, offset, origin); + if (success != 0) + throw BagIOException("Error seeking"); + + offset_ = ftello(file_); +} + +uint64_t ChunkedFile::getOffset() const { return offset_; } +uint32_t ChunkedFile::getCompressedBytesIn() const { return static_cast(compressed_in_); } + +void ChunkedFile::write(string const& s) { write((void*) s.c_str(), s.size()); } +void ChunkedFile::write(void* ptr, size_t size) { write_stream_->write(ptr, size); } +void ChunkedFile::read(void* ptr, size_t size) { read_stream_->read(ptr, size); } + +bool ChunkedFile::truncate(uint64_t length) { + int fd = fileno(file_); + return ftruncate(fd, length) == 0; +} + +//! \todo add error handling +string ChunkedFile::getline() { + char buffer[1024]; + if(fgets(buffer, 1024, file_)) + { + string s(buffer); + offset_ += s.size(); + return s; + } + else + return string(""); +} + +void ChunkedFile::decompress(CompressionType compression, uint8_t* dest, unsigned int dest_len, uint8_t* source, unsigned int source_len) { + stream_factory_->getStream(compression)->decompress(dest, dest_len, source, source_len); +} + +void ChunkedFile::clearUnused() { + unused_ = NULL; + nUnused_ = 0; +} + +} // namespace rosbag diff --git a/realsense-file/3rd_party/rosbag/rosbag_storage/src/lz4_stream.cpp b/realsense-file/3rd_party/rosbag/rosbag_storage/src/lz4_stream.cpp new file mode 100644 index 0000000000..ef7c2d0b73 --- /dev/null +++ b/realsense-file/3rd_party/rosbag/rosbag_storage/src/lz4_stream.cpp @@ -0,0 +1,204 @@ +/********************************************************************* +* Software License Agreement (BSD License) +* +* Copyright (c) 2014, Ben Charrow +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions +* are met: +* +* * Redistributions of source code must retain the above copyright +* notice, this list of conditions and the following disclaimer. +* * Redistributions in binary form must reproduce the above +* copyright notice, this list of conditions and the following +* disclaimer in the documentation and/or other materials provided +* with the distribution. +* * Neither the name of Willow Garage, Inc. nor the names of its +* contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +********************************************************************/ + +#include "rosbag/chunked_file.h" + +#include +#include +#include "console_bridge/console.h" + +using std::string; + +namespace rosbag { + +LZ4Stream::LZ4Stream(ChunkedFile* file) + : Stream(file), block_size_id_(6) { + buff_size_ = roslz4_blockSizeFromIndex(block_size_id_) + 64; + buff_ = new char[buff_size_]; +} + +LZ4Stream::~LZ4Stream() { + delete[] buff_; +} + +CompressionType LZ4Stream::getCompressionType() const { + return compression::LZ4; +} + +void LZ4Stream::startWrite() { + setCompressedIn(0); + + int ret = roslz4_compressStart(&lz4s_, block_size_id_); + switch(ret) { + case ROSLZ4_OK: break; + case ROSLZ4_MEMORY_ERROR: throw BagIOException("ROSLZ4_MEMORY_ERROR: insufficient memory available"); break; + case ROSLZ4_PARAM_ERROR: throw BagIOException("ROSLZ4_PARAM_ERROR: bad block size"); break; + default: throw BagException("Unhandled return code"); + } + lz4s_.output_next = buff_; + lz4s_.output_left = buff_size_; +} + +void LZ4Stream::write(void* ptr, size_t size) { + lz4s_.input_left = static_cast(size); + lz4s_.input_next = (char*) ptr; + + writeStream(ROSLZ4_RUN); + setCompressedIn(getCompressedIn() + size); +} + +void LZ4Stream::writeStream(int action) { + int ret = ROSLZ4_OK; + while (lz4s_.input_left > 0 || + (action == ROSLZ4_FINISH && ret != ROSLZ4_STREAM_END)) { + ret = roslz4_compress(&lz4s_, action); + switch(ret) { + case ROSLZ4_OK: break; + case ROSLZ4_OUTPUT_SMALL: + if (lz4s_.output_next - buff_ == buff_size_) { + throw BagIOException("ROSLZ4_OUTPUT_SMALL: output buffer is too small"); + } else { + // There's data to be written in buff_; this will free up space + break; + } + case ROSLZ4_STREAM_END: break; + case ROSLZ4_PARAM_ERROR: throw BagIOException("ROSLZ4_PARAM_ERROR: bad block size"); break; + case ROSLZ4_ERROR: throw BagIOException("ROSLZ4_ERROR: compression error"); break; + default: throw BagException("Unhandled return code"); + } + + // If output data is ready, write to disk + int to_write = static_cast(lz4s_.output_next - buff_); + if (to_write > 0) { + if (fwrite(buff_, 1, to_write, getFilePointer()) != static_cast(to_write)) { + throw BagException("Problem writing data to disk"); + } + advanceOffset(to_write); + lz4s_.output_next = buff_; + lz4s_.output_left = buff_size_; + } + } +} + +void LZ4Stream::stopWrite() { + writeStream(ROSLZ4_FINISH); + setCompressedIn(0); + roslz4_compressEnd(&lz4s_); +} + +void LZ4Stream::startRead() { + int ret = static_cast(roslz4_decompressStart(&lz4s_)); + switch(ret) { + case ROSLZ4_OK: break; + case ROSLZ4_MEMORY_ERROR: throw BagException("ROSLZ4_MEMORY_ERROR: insufficient memory available"); break; + default: throw BagException("Unhandled return code"); + } + + if (getUnusedLength() > buff_size_) { + throw BagException("Too many unused bytes to decompress"); + } + + // getUnused() could be pointing to part of buff_, so don't use memcpy + memmove(buff_, getUnused(), getUnusedLength()); + lz4s_.input_next = buff_; + lz4s_.input_left = getUnusedLength(); + clearUnused(); +} + +void LZ4Stream::read(void* ptr, size_t size) { + // Setup stream by filling buffer with data from file + int to_read = buff_size_ - lz4s_.input_left; + char *input_start = buff_ + lz4s_.input_left; + int nread = static_cast(fread(input_start, 1, to_read, getFilePointer())); + if (ferror(getFilePointer())) { + throw BagIOException("Problem reading from file"); + } + lz4s_.input_next = buff_; + lz4s_.input_left += nread; + lz4s_.output_next = (char*) ptr; + lz4s_.output_left = static_cast(size); + + // Decompress. If reach end of stream, store unused data + int ret = roslz4_decompress(&lz4s_); + switch (ret) { + case ROSLZ4_OK: break; + case ROSLZ4_STREAM_END: + if (getUnused() || getUnusedLength() > 0) + logError("unused data already available"); + else { + setUnused(lz4s_.input_next); + setUnusedLength(lz4s_.input_left); + } + return; + case ROSLZ4_ERROR: throw BagException("ROSLZ4_ERROR: decompression error"); break; + case ROSLZ4_MEMORY_ERROR: throw BagException("ROSLZ4_MEMORY_ERROR: insufficient memory available"); break; + case ROSLZ4_OUTPUT_SMALL: throw BagException("ROSLZ4_OUTPUT_SMALL: output buffer is too small"); break; + case ROSLZ4_DATA_ERROR: throw BagException("ROSLZ4_DATA_ERROR: malformed data to decompress"); break; + default: throw BagException("Unhandled return code"); + } + if (feof(getFilePointer())) { + throw BagIOException("Reached end of file before reaching end of stream"); + } + + size_t total_out = lz4s_.output_next - (char*)ptr; + advanceOffset(total_out); + + // Shift input buffer if there's unconsumed data + if (lz4s_.input_left > 0) { + memmove(buff_, lz4s_.input_next, lz4s_.input_left); + } +} + +void LZ4Stream::stopRead() { + roslz4_decompressEnd(&lz4s_); +} + +void LZ4Stream::decompress(uint8_t* dest, unsigned int dest_len, uint8_t* source, unsigned int source_len) { + unsigned int actual_dest_len = dest_len; + int ret = roslz4_buffToBuffDecompress((char*)source, source_len, + (char*)dest, &actual_dest_len); + switch(ret) { + case ROSLZ4_OK: break; + case ROSLZ4_ERROR: throw BagException("ROSLZ4_ERROR: decompression error"); break; + case ROSLZ4_MEMORY_ERROR: throw BagException("ROSLZ4_MEMORY_ERROR: insufficient memory available"); break; + case ROSLZ4_OUTPUT_SMALL: throw BagException("ROSLZ4_OUTPUT_SMALL: output buffer is too small"); break; + case ROSLZ4_DATA_ERROR: throw BagException("ROSLZ4_DATA_ERROR: malformed data to decompress"); break; + default: throw BagException("Unhandled return code"); + } + if (actual_dest_len != dest_len) { + throw BagException("Decompression size mismatch in LZ4 chunk"); + } +} + +} // namespace rosbag diff --git a/realsense-file/3rd_party/rosbag/rosbag_storage/src/message_instance.cpp b/realsense-file/3rd_party/rosbag/rosbag_storage/src/message_instance.cpp new file mode 100644 index 0000000000..0ebe53aa7e --- /dev/null +++ b/realsense-file/3rd_party/rosbag/rosbag_storage/src/message_instance.cpp @@ -0,0 +1,65 @@ +// Copyright (c) 2009, Willow Garage, Inc. +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// * Neither the name of Willow Garage, Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE +// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +// POSSIBILITY OF SUCH DAMAGE. + +#include "rosbag/message_instance.h" + +#include "ros/message_event.h" + +using std::string; +using ros::Time; +using std::shared_ptr; + +namespace rosbag { + +MessageInstance::MessageInstance(ConnectionInfo const* connection_info, IndexEntry const& index_entry, Bag const& bag) : + connection_info_(connection_info), index_entry_(index_entry), bag_(&bag) +{ +} + +Time const& MessageInstance::getTime() const { return index_entry_.time; } +string const& MessageInstance::getTopic() const { return connection_info_->topic; } +string const& MessageInstance::getDataType() const { return connection_info_->datatype; } +string const& MessageInstance::getMD5Sum() const { return connection_info_->md5sum; } +string const& MessageInstance::getMessageDefinition() const { return connection_info_->msg_def; } + +shared_ptr MessageInstance::getConnectionHeader() const { return connection_info_->header; } + +string MessageInstance::getCallerId() const { + ros::M_string::const_iterator header_iter = connection_info_->header->find("callerid"); + return header_iter != connection_info_->header->end() ? header_iter->second : string(""); +} + +bool MessageInstance::isLatching() const { + ros::M_string::const_iterator header_iter = connection_info_->header->find("latching"); + return header_iter != connection_info_->header->end() && header_iter->second == "1"; +} + +uint32_t MessageInstance::size() const { + return bag_->readMessageDataSize(index_entry_); +} + +} // namespace rosbag diff --git a/realsense-file/3rd_party/rosbag/rosbag_storage/src/query.cpp b/realsense-file/3rd_party/rosbag/rosbag_storage/src/query.cpp new file mode 100644 index 0000000000..6cd037d843 --- /dev/null +++ b/realsense-file/3rd_party/rosbag/rosbag_storage/src/query.cpp @@ -0,0 +1,114 @@ +// Copyright (c) 2009, Willow Garage, Inc. +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// * Neither the name of Willow Garage, Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE +// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +// POSSIBILITY OF SUCH DAMAGE. + +#include "rosbag/query.h" +#include "rosbag/bag.h" + +#include + +#define foreach BOOST_FOREACH + +using std::map; +using std::string; +using std::vector; +using std::multiset; + +namespace rosbag { + +// Query + +Query::Query(boost::function& query, ros::Time const& start_time, ros::Time const& end_time) + : query_(query), start_time_(start_time), end_time_(end_time) +{ +} + +boost::function const& Query::getQuery() const { + return query_; +} + +ros::Time const& Query::getStartTime() const { return start_time_; } +ros::Time const& Query::getEndTime() const { return end_time_; } + +// TopicQuery + +TopicQuery::TopicQuery(std::string const& topic) { + topics_.push_back(topic); +} + +TopicQuery::TopicQuery(std::vector const& topics) : topics_(topics) { } + +bool TopicQuery::operator()(ConnectionInfo const* info) const { + foreach(string const& topic, topics_) + if (topic == info->topic) + return true; + + return false; +} + +// TypeQuery + +TypeQuery::TypeQuery(std::string const& type) { + types_.push_back(type); +} + +TypeQuery::TypeQuery(std::vector const& types) : types_(types) { } + +bool TypeQuery::operator()(ConnectionInfo const* info) const { + foreach(string const& type, types_) + if (type == info->datatype) + return true; + + return false; +} + +// BagQuery + +BagQuery::BagQuery(Bag const* _bag, Query const& _query, uint32_t _bag_revision) : bag(_bag), query(_query), bag_revision(_bag_revision) { +} + +// MessageRange + +MessageRange::MessageRange(std::multiset::const_iterator const& _begin, + std::multiset::const_iterator const& _end, + ConnectionInfo const* _connection_info, + BagQuery const* _bag_query) + : begin(_begin), end(_end), connection_info(_connection_info), bag_query(_bag_query) +{ +} + +// ViewIterHelper + +ViewIterHelper::ViewIterHelper(std::multiset::const_iterator _iter, MessageRange const* _range) + : iter(_iter), range(_range) +{ +} + +bool ViewIterHelperCompare::operator()(ViewIterHelper const& a, ViewIterHelper const& b) { + return (a.iter)->time > (b.iter)->time; +} + +} // namespace rosbag diff --git a/realsense-file/3rd_party/rosbag/rosbag_storage/src/stream.cpp b/realsense-file/3rd_party/rosbag/rosbag_storage/src/stream.cpp new file mode 100644 index 0000000000..bb07022cd7 --- /dev/null +++ b/realsense-file/3rd_party/rosbag/rosbag_storage/src/stream.cpp @@ -0,0 +1,81 @@ +/********************************************************************* +* Software License Agreement (BSD License) +* +* Copyright (c) 2008, Willow Garage, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions +* are met: +* +* * Redistributions of source code must retain the above copyright +* notice, this list of conditions and the following disclaimer. +* * Redistributions in binary form must reproduce the above +* copyright notice, this list of conditions and the following +* disclaimer in the documentation and/or other materials provided +* with the distribution. +* * Neither the name of Willow Garage, Inc. nor the names of its +* contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +********************************************************************/ + +#include "rosbag/stream.h" +#include "rosbag/chunked_file.h" + +//#include + +using std::shared_ptr; + +namespace rosbag { + +// StreamFactory + +StreamFactory::StreamFactory(ChunkedFile* file) : + uncompressed_stream_(new UncompressedStream(file)), + lz4_stream_ (new LZ4Stream(file)) +{ +} + +shared_ptr StreamFactory::getStream(CompressionType type) const { + switch (type) { + case compression::Uncompressed: return uncompressed_stream_; + case compression::LZ4: return lz4_stream_; + default: return shared_ptr(); + } +} + +// Stream + +Stream::Stream(ChunkedFile* file) : file_(file) { } + +Stream::~Stream() { } + +void Stream::startWrite() { } +void Stream::stopWrite() { } +void Stream::startRead() { } +void Stream::stopRead() { } + +FILE* Stream::getFilePointer() { return file_->file_; } +uint64_t Stream::getCompressedIn() { return file_->compressed_in_; } +void Stream::setCompressedIn(uint64_t nbytes) { file_->compressed_in_ = nbytes; } +void Stream::advanceOffset(uint64_t nbytes) { file_->offset_ += nbytes; } +char* Stream::getUnused() { return file_->unused_; } +int Stream::getUnusedLength() { return file_->nUnused_; } +void Stream::setUnused(char* unused) { file_->unused_ = unused; } +void Stream::setUnusedLength(int nUnused) { file_->nUnused_ = nUnused; } +void Stream::clearUnused() { file_->clearUnused(); } + +} // namespace rosbag diff --git a/realsense-file/3rd_party/rosbag/rosbag_storage/src/uncompressed_stream.cpp b/realsense-file/3rd_party/rosbag/rosbag_storage/src/uncompressed_stream.cpp new file mode 100644 index 0000000000..013ff63a1e --- /dev/null +++ b/realsense-file/3rd_party/rosbag/rosbag_storage/src/uncompressed_stream.cpp @@ -0,0 +1,114 @@ +/********************************************************************* +* Software License Agreement (BSD License) +* +* Copyright (c) 2008, Willow Garage, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions +* are met: +* +* * Redistributions of source code must retain the above copyright +* notice, this list of conditions and the following disclaimer. +* * Redistributions in binary form must reproduce the above +* copyright notice, this list of conditions and the following +* disclaimer in the documentation and/or other materials provided +* with the distribution. +* * Neither the name of Willow Garage, Inc. nor the names of its +* contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +********************************************************************/ + +#include "rosbag/chunked_file.h" + +#include +#include + +#include + +using std::string; +using boost::format; +using ros::Exception; + +namespace rosbag { + +UncompressedStream::UncompressedStream(ChunkedFile* file) : Stream(file) { } + +CompressionType UncompressedStream::getCompressionType() const { + return compression::Uncompressed; +} + +void UncompressedStream::write(void* ptr, size_t size) { + size_t result = fwrite(ptr, 1, size, getFilePointer()); + if (result != size) + throw BagIOException((format("Error writing to file: writing %1% bytes, wrote %2% bytes") % size % result).str()); + + advanceOffset(size); +} + +void UncompressedStream::read(void* ptr, size_t size) { + size_t nUnused = (size_t) getUnusedLength(); + char* unused = getUnused(); + + if (nUnused > 0) { + // We have unused data from the last compressed read + if (nUnused == size) { + // Copy the unused data into the buffer + memcpy(ptr, unused, nUnused); + + clearUnused(); + } + else if (nUnused < size) { + // Copy the unused data into the buffer + memcpy(ptr, unused, nUnused); + + // Still have data to read + size -= nUnused; + + // Read the remaining data from the file + int result = static_cast(fread((char*) ptr + static_cast(nUnused), 1, static_cast(size), getFilePointer())); + if ((size_t) result != size) + throw BagIOException((format("Error reading from file + unused: wanted %1% bytes, read %2% bytes") % size % result).str()); + + advanceOffset(size); + + clearUnused(); + } + else { + // nUnused_ > size + memcpy(ptr, unused, size); + + setUnused(unused + size); + setUnusedLength(static_cast(nUnused - size)); + } + } + + // No unused data - read from stream + int result = static_cast(fread( ptr, 1, static_cast(size), getFilePointer())); + if ((size_t) result != size) + throw BagIOException((format("Error reading from file: wanted %1% bytes, read %2% bytes") % size % result).str()); + + advanceOffset(size); +} + +void UncompressedStream::decompress(uint8_t* dest, unsigned int dest_len, uint8_t* source, unsigned int source_len) { + if (dest_len < source_len) + throw BagException("dest_len not large enough"); + + memcpy(dest, source, source_len); +} + +} // namespace rosbag diff --git a/realsense-file/3rd_party/rosbag/rosbag_storage/src/view.cpp b/realsense-file/3rd_party/rosbag/rosbag_storage/src/view.cpp new file mode 100644 index 0000000000..fc969e383e --- /dev/null +++ b/realsense-file/3rd_party/rosbag/rosbag_storage/src/view.cpp @@ -0,0 +1,352 @@ +// Copyright (c) 2009, Willow Garage, Inc. +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// * Neither the name of Willow Garage, Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE +// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +// POSSIBILITY OF SUCH DAMAGE. + +#include "rosbag/view.h" +#include "rosbag/bag.h" +#include "rosbag/message_instance.h" + +#include +#include +#include + +#define foreach BOOST_FOREACH + +using std::map; +using std::string; +using std::vector; +using std::multiset; + +namespace rosbag { + +// View::iterator + +View::iterator::iterator() : view_(NULL), view_revision_(0), message_instance_(NULL) { } + +View::iterator::~iterator() +{ + if (message_instance_ != NULL) + delete message_instance_; +} + +View::iterator::iterator(View* view, bool end) : view_(view), view_revision_(0), message_instance_(NULL) { + if (view != NULL && !end) + populate(); +} + +View::iterator::iterator(const iterator& i) : view_(i.view_), iters_(i.iters_), view_revision_(i.view_revision_), message_instance_(NULL) { } + +View::iterator &View::iterator::operator=(iterator const& i) { + if (this != &i) { + view_ = i.view_; + iters_ = i.iters_; + view_revision_ = i.view_revision_; + if (message_instance_ != NULL) { + delete message_instance_; + message_instance_ = NULL; + } + } + return *this; +} + +void View::iterator::populate() { + assert(view_ != NULL); + + iters_.clear(); + foreach(MessageRange const* range, view_->ranges_) + if (range->begin != range->end) + iters_.push_back(ViewIterHelper(range->begin, range)); + + std::sort(iters_.begin(), iters_.end(), ViewIterHelperCompare()); + view_revision_ = view_->view_revision_; +} + +void View::iterator::populateSeek(multiset::const_iterator iter) { + assert(view_ != NULL); + + iters_.clear(); + foreach(MessageRange const* range, view_->ranges_) { + multiset::const_iterator start = std::lower_bound(range->begin, range->end, iter->time, IndexEntryCompare()); + if (start != range->end) + iters_.push_back(ViewIterHelper(start, range)); + } + + std::sort(iters_.begin(), iters_.end(), ViewIterHelperCompare()); + while (iter != iters_.back().iter) + increment(); + + view_revision_ = view_->view_revision_; +} + +bool View::iterator::equal(View::iterator const& other) const { + // We need some way of verifying these are actually talking about + // the same merge_queue data since we shouldn't be able to compare + // iterators from different Views. + + if (iters_.empty()) + return other.iters_.empty(); + if (other.iters_.empty()) + return false; + + return iters_.back().iter == other.iters_.back().iter; +} + +void View::iterator::increment() { + assert(view_ != NULL); + + // Our message instance is no longer valid + if (message_instance_ != NULL) + { + delete message_instance_; + message_instance_ = NULL; + } + + view_->update(); + + // Note, updating may have blown away our message-ranges and + // replaced them in general the ViewIterHelpers are no longer + // valid, but the iterator it stores should still be good. + if (view_revision_ != view_->view_revision_) + populateSeek(iters_.back().iter); + + if (view_->reduce_overlap_) + { + std::multiset::const_iterator last_iter = iters_.back().iter; + + while (iters_.back().iter == last_iter) + { + iters_.back().iter++; + if (iters_.back().iter == iters_.back().range->end) + iters_.pop_back(); + + std::sort(iters_.begin(), iters_.end(), ViewIterHelperCompare()); + } + + } else { + + iters_.back().iter++; + if (iters_.back().iter == iters_.back().range->end) + iters_.pop_back(); + + std::sort(iters_.begin(), iters_.end(), ViewIterHelperCompare()); + } +} + +MessageInstance& View::iterator::dereference() const { + ViewIterHelper const& i = iters_.back(); + + if (message_instance_ == NULL) + message_instance_ = view_->newMessageInstance(i.range->connection_info, *(i.iter), *(i.range->bag_query->bag)); + + return *message_instance_; +} + +// View + +View::View(bool const& reduce_overlap) : view_revision_(0), size_cache_(0), size_revision_(0), reduce_overlap_(reduce_overlap) { } + +View::View(Bag const& bag, ros::Time const& start_time, ros::Time const& end_time, bool const& reduce_overlap) : view_revision_(0), size_cache_(0), size_revision_(0), reduce_overlap_(reduce_overlap) { + addQuery(bag, start_time, end_time); +} + +View::View(Bag const& bag, boost::function query, ros::Time const& start_time, ros::Time const& end_time, bool const& reduce_overlap) : view_revision_(0), size_cache_(0), size_revision_(0), reduce_overlap_(reduce_overlap) { + addQuery(bag, query, start_time, end_time); +} + +View::~View() { + foreach(MessageRange* range, ranges_) + delete range; + foreach(BagQuery* query, queries_) + delete query; +} + + +ros::Time View::getBeginTime() +{ + update(); + + ros::Time begin = ros::TIME_MAX; + + foreach (rosbag::MessageRange* range, ranges_) + { + if (range->begin->time < begin) + begin = range->begin->time; + } + + return begin; +} + +ros::Time View::getEndTime() +{ + update(); + + ros::Time end = ros::TIME_MIN; + + foreach (rosbag::MessageRange* range, ranges_) + { + std::multiset::const_iterator e = range->end; + e--; + + if (e->time > end) + end = e->time; + } + + return end; +} + +//! Simply copy the merge_queue state into the iterator +View::iterator View::begin() { + update(); + return iterator(this); +} + +//! Default constructed iterator signifies end +View::iterator View::end() { return iterator(this, true); } + +uint32_t View::size() { + + update(); + + if (size_revision_ != view_revision_) + { + size_cache_ = 0; + + foreach (MessageRange* range, ranges_) + { + size_cache_ += static_cast(std::distance(range->begin, range->end)); + } + + size_revision_ = view_revision_; + } + + return size_cache_; +} + +void View::addQuery(Bag const& bag, ros::Time const& start_time, ros::Time const& end_time) { + if ((bag.getMode() & bagmode::Read) != bagmode::Read) + throw BagException("Bag not opened for reading"); + + boost::function query = TrueQuery(); + + queries_.push_back(new BagQuery(&bag, Query(query, start_time, end_time), bag.bag_revision_)); + + updateQueries(queries_.back()); +} + +void View::addQuery(Bag const& bag, boost::function query, ros::Time const& start_time, ros::Time const& end_time) { + if ((bag.getMode() & bagmode::Read) != bagmode::Read) + throw BagException("Bag not opened for reading"); + + queries_.push_back(new BagQuery(&bag, Query(query, start_time, end_time), bag.bag_revision_)); + + updateQueries(queries_.back()); +} + +void View::updateQueries(BagQuery* q) { + for (map::const_iterator i = q->bag->connections_.begin(); i != q->bag->connections_.end(); i++) { + ConnectionInfo const* connection = i->second; + + // Skip if the query doesn't evaluate to true + if (!q->query.getQuery()(connection)) + continue; + + map >::const_iterator j = q->bag->connection_indexes_.find(connection->id); + + // Skip if the bag doesn't have the corresponding index + if (j == q->bag->connection_indexes_.end()) + continue; + multiset const& index = j->second; + + // lower_bound/upper_bound do a binary search to find the appropriate range of Index Entries given our time range + + std::multiset::const_iterator begin = std::lower_bound(index.begin(), index.end(), q->query.getStartTime(), IndexEntryCompare()); + std::multiset::const_iterator end = std::upper_bound(index.begin(), index.end(), q->query.getEndTime(), IndexEntryCompare()); + + // Make sure we are at the right beginning + while (begin != index.begin()) + { + if (begin != index.end() && begin->time >= q->query.getStartTime()) + break; + + begin--; + if (begin->time < q->query.getStartTime()) + { + begin++; + break; + } + } + + if (begin != end) + { + // todo: make faster with a map of maps + bool found = false; + for (vector::iterator k = ranges_.begin(); k != ranges_.end(); k++) { + MessageRange* r = *k; + + // If the topic and query are already in our ranges, we update + if (r->bag_query == q && r->connection_info->id == connection->id) { + r->begin = begin; + r->end = end; + found = true; + break; + } + } + if (!found) + ranges_.push_back(new MessageRange(begin, end, connection, q)); + } + } + + view_revision_++; +} + +void View::update() { + foreach(BagQuery* query, queries_) { + if (query->bag->bag_revision_ != query->bag_revision) { + updateQueries(query); + query->bag_revision = query->bag->bag_revision_; + } + } +} + +std::vector View::getConnections() +{ + std::vector connections; + + foreach(MessageRange* range, ranges_) + { + connections.push_back(range->connection_info); + } + + return connections; +} + +MessageInstance* View::newMessageInstance(ConnectionInfo const* connection_info, IndexEntry const& index, Bag const& bag) +{ + return new MessageInstance(connection_info, index, bag); +} + + +} // namespace rosbag diff --git a/realsense-file/3rd_party/rosbag/roscpp_serialization/config.cmake b/realsense-file/3rd_party/rosbag/roscpp_serialization/config.cmake new file mode 100644 index 0000000000..d824b95700 --- /dev/null +++ b/realsense-file/3rd_party/rosbag/roscpp_serialization/config.cmake @@ -0,0 +1,13 @@ +cmake_minimum_required(VERSION 2.8.3) + +set(HEADER_FILES_ROSCPP_SERIALIZATION + rosbag/roscpp_serialization/include/ros/roscpp_serialization_macros.h + rosbag/roscpp_serialization/include/ros/serialization.h + rosbag/roscpp_serialization/include/ros/serialized_message.h +) + +set(SOURCE_FILES_ROSCPP_SERIALIZATION + rosbag/roscpp_serialization/src/serialization.cpp +) + + diff --git a/realsense-file/3rd_party/rosbag/roscpp_serialization/include/ros/roscpp_serialization_macros.h b/realsense-file/3rd_party/rosbag/roscpp_serialization/include/ros/roscpp_serialization_macros.h new file mode 100644 index 0000000000..271bc241fb --- /dev/null +++ b/realsense-file/3rd_party/rosbag/roscpp_serialization/include/ros/roscpp_serialization_macros.h @@ -0,0 +1,55 @@ +/********************************************************************* +* +* Software License Agreement (BSD License) +* +* Copyright (c) 2009, Willow Garage, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions +* are met: +* +* * Redistributions of source code must retain the above copyright +* notice, this list of conditions and the following disclaimer. +* * Redistributions in binary form must reproduce the above +* copyright notice, this list of conditions and the following +* disclaimer in the documentation and/or other materials provided +* with the distribution. +* * Neither the name of the Willow Garage nor the names of its +* contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +* +*********************************************************************/ +/* + * Cross platform macros. + * + */ +#ifndef ROSCPP_SERIALIZATION_MACROS_HPP_ +#define ROSCPP_SERIALIZATION_MACROS_HPP_ + +#include + +#ifdef ROS_BUILD_SHARED_LIBS // ros is being built around shared libraries + #ifdef roscpp_serialization_EXPORTS // we are building a shared lib/dll + #define ROSCPP_SERIALIZATION_DECL ROS_HELPER_EXPORT + #else // we are using shared lib/dll + #define ROSCPP_SERIALIZATION_DECL ROS_HELPER_IMPORT + #endif +#else // ros is being built around static libraries + #define ROSCPP_SERIALIZATION_DECL +#endif + +#endif /* ROSCPP_SERIALIZATION_MACROS_HPP_ */ diff --git a/realsense-file/3rd_party/rosbag/roscpp_serialization/include/ros/serialization.h b/realsense-file/3rd_party/rosbag/roscpp_serialization/include/ros/serialization.h new file mode 100644 index 0000000000..cdf16dcf06 --- /dev/null +++ b/realsense-file/3rd_party/rosbag/roscpp_serialization/include/ros/serialization.h @@ -0,0 +1,926 @@ +/* + * Copyright (C) 2009, Willow Garage, Inc. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the names of Willow Garage, Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef ROSCPP_SERIALIZATION_H +#define ROSCPP_SERIALIZATION_H + +#include "roscpp_serialization_macros.h" + +#include +#include + +#include "serialized_message.h" +#include "ros/message_traits.h" +#include "ros/builtin_message_traits.h" +#include "ros/exception.h" +#include "ros/datatypes.h" + +#include +#include + +#include +#include +#include +#include +#include + +#include + +#define ROS_NEW_SERIALIZATION_API 1 + +/** + * \brief Declare your serializer to use an allInOne member instead of requiring 3 different serialization + * functions. + * + * The allinone method has the form: +\verbatim +template +inline static void allInOne(Stream& stream, T t) +{ + stream.next(t.a); + stream.next(t.b); + ... +} +\endverbatim + * + * The only guarantee given is that Stream::next(T) is defined. + */ +#define ROS_DECLARE_ALLINONE_SERIALIZER \ + template \ + inline static void write(Stream& stream, const T& t) \ + { \ + allInOne(stream, t); \ + } \ + \ + template \ + inline static void read(Stream& stream, T& t) \ + { \ + allInOne(stream, t); \ + } \ + \ + template \ + inline static uint32_t serializedLength(const T& t) \ + { \ + LStream stream; \ + allInOne(stream, t); \ + return stream.getLength(); \ + } + +namespace ros +{ +namespace serialization +{ +namespace mt = message_traits; +namespace mpl = boost::mpl; + +class ROSCPP_SERIALIZATION_DECL StreamOverrunException : public ros::Exception +{ +public: + StreamOverrunException(const std::string& what) + : Exception(what) + {} +}; + +ROSCPP_SERIALIZATION_DECL void throwStreamOverrun(); + +/** + * \brief Templated serialization class. Default implementation provides backwards compatibility with + * old message types. + * + * Specializing the Serializer class is the only thing you need to do to get the ROS serialization system + * to work with a type. + */ +template +struct Serializer +{ + /** + * \brief Write an object to the stream. Normally the stream passed in here will be a ros::serialization::OStream + */ + template + inline static void write(Stream& stream, typename boost::call_traits::param_type t) + { + t.serialize(stream.getData(), 0); + } + + /** + * \brief Read an object from the stream. Normally the stream passed in here will be a ros::serialization::IStream + */ + template + inline static void read(Stream& stream, typename boost::call_traits::reference t) + { + t.deserialize(stream.getData()); + } + + /** + * \brief Determine the serialized length of an object. + */ + inline static uint32_t serializedLength(typename boost::call_traits::param_type t) + { + return t.serializationLength(); + } +}; + +/** + * \brief Serialize an object. Stream here should normally be a ros::serialization::OStream + */ +template +inline void serialize(Stream& stream, const T& t) +{ + Serializer::write(stream, t); +} + +/** + * \brief Deserialize an object. Stream here should normally be a ros::serialization::IStream + */ +template +inline void deserialize(Stream& stream, T& t) +{ + Serializer::read(stream, t); +} + +/** + * \brief Determine the serialized length of an object + */ +template +inline uint32_t serializationLength(const T& t) +{ + return Serializer::serializedLength(t); +} + +#define ROS_CREATE_SIMPLE_SERIALIZER(Type) \ + template<> struct Serializer \ + { \ + template inline static void write(Stream& stream, const Type v) \ + { \ + *reinterpret_cast(stream.advance(sizeof(v))) = v; \ + } \ + \ + template inline static void read(Stream& stream, Type& v) \ + { \ + v = *reinterpret_cast(stream.advance(sizeof(v))); \ + } \ + \ + inline static uint32_t serializedLength(const Type&) \ + { \ + return sizeof(Type); \ + } \ + }; + +#define ROS_CREATE_SIMPLE_SERIALIZER_ARM(Type) \ + template<> struct Serializer \ + { \ + template inline static void write(Stream& stream, const Type v) \ + { \ + memcpy(stream.advance(sizeof(v)), &v, sizeof(v) ); \ + } \ + \ + template inline static void read(Stream& stream, Type& v) \ + { \ + memcpy(&v, stream.advance(sizeof(v)), sizeof(v) ); \ + } \ + \ + inline static uint32_t serializedLength(const Type&) \ + { \ + return sizeof(Type); \ + } \ +}; + +#if defined(__arm__) || defined(__arm) + ROS_CREATE_SIMPLE_SERIALIZER_ARM(uint8_t) + ROS_CREATE_SIMPLE_SERIALIZER_ARM(int8_t) + ROS_CREATE_SIMPLE_SERIALIZER_ARM(uint16_t) + ROS_CREATE_SIMPLE_SERIALIZER_ARM(int16_t) + ROS_CREATE_SIMPLE_SERIALIZER_ARM(uint32_t) + ROS_CREATE_SIMPLE_SERIALIZER_ARM(int32_t) + ROS_CREATE_SIMPLE_SERIALIZER_ARM(uint64_t) + ROS_CREATE_SIMPLE_SERIALIZER_ARM(int64_t) + ROS_CREATE_SIMPLE_SERIALIZER_ARM(float) + ROS_CREATE_SIMPLE_SERIALIZER_ARM(double) +#else + ROS_CREATE_SIMPLE_SERIALIZER(uint8_t) + ROS_CREATE_SIMPLE_SERIALIZER(int8_t) + ROS_CREATE_SIMPLE_SERIALIZER(uint16_t) + ROS_CREATE_SIMPLE_SERIALIZER(int16_t) + ROS_CREATE_SIMPLE_SERIALIZER(uint32_t) + ROS_CREATE_SIMPLE_SERIALIZER(int32_t) + ROS_CREATE_SIMPLE_SERIALIZER(uint64_t) + ROS_CREATE_SIMPLE_SERIALIZER(int64_t) + ROS_CREATE_SIMPLE_SERIALIZER(float) + ROS_CREATE_SIMPLE_SERIALIZER(double) +#endif + +/** + * \brief Serializer specialized for bool (serialized as uint8) + */ +template<> struct Serializer +{ + template inline static void write(Stream& stream, const bool v) + { + uint8_t b = (uint8_t)v; +#if defined(__arm__) || defined(__arm) + memcpy(stream.advance(1), &b, 1 ); +#else + *reinterpret_cast(stream.advance(1)) = b; +#endif + } + + template inline static void read(Stream& stream, bool& v) + { + uint8_t b; +#if defined(__arm__) || defined(__arm) + memcpy(&b, stream.advance(1), 1 ); +#else + b = *reinterpret_cast(stream.advance(1)); +#endif + v = (bool)b; + } + + inline static uint32_t serializedLength(bool) + { + return 1; + } +}; + +/** + * \brief Serializer specialized for std::string + */ +template +struct Serializer, ContainerAllocator> > +{ + typedef std::basic_string, ContainerAllocator> StringType; + + template + inline static void write(Stream& stream, const StringType& str) + { + size_t len = str.size(); + stream.next((uint32_t)len); + + if (len > 0) + { + memcpy(stream.advance((uint32_t)len), str.data(), len); + } + } + + template + inline static void read(Stream& stream, StringType& str) + { + uint32_t len; + stream.next(len); + if (len > 0) + { + str = StringType((char*)stream.advance(len), len); + } + else + { + str.clear(); + } + } + + inline static uint32_t serializedLength(const StringType& str) + { + return 4 + (uint32_t)str.size(); + } +}; + +/** + * \brief Serializer specialized for ros::Time + */ +template<> +struct Serializer +{ + template + inline static void write(Stream& stream, const ros::Time& v) + { + stream.next(v.sec); + stream.next(v.nsec); + } + + template + inline static void read(Stream& stream, ros::Time& v) + { + stream.next(v.sec); + stream.next(v.nsec); + } + + inline static uint32_t serializedLength(const ros::Time&) + { + return 8; + } +}; + +/** + * \brief Serializer specialized for ros::Duration + */ +template<> +struct Serializer +{ + template + inline static void write(Stream& stream, const ros::Duration& v) + { + stream.next(v.sec); + stream.next(v.nsec); + } + + template + inline static void read(Stream& stream, ros::Duration& v) + { + stream.next(v.sec); + stream.next(v.nsec); + } + + inline static uint32_t serializedLength(const ros::Duration&) + { + return 8; + } +}; + +/** + * \brief Vector serializer. Default implementation does nothing + */ +template +struct VectorSerializer +{}; + +/** + * \brief Vector serializer, specialized for non-fixed-size, non-simple types + */ +template +struct VectorSerializer >::type > +{ + typedef std::vector::other> VecType; + typedef typename VecType::iterator IteratorType; + typedef typename VecType::const_iterator ConstIteratorType; + + template + inline static void write(Stream& stream, const VecType& v) + { + stream.next((uint32_t)v.size()); + ConstIteratorType it = v.begin(); + ConstIteratorType end = v.end(); + for (; it != end; ++it) + { + stream.next(*it); + } + } + + template + inline static void read(Stream& stream, VecType& v) + { + uint32_t len; + stream.next(len); + v.resize(len); + IteratorType it = v.begin(); + IteratorType end = v.end(); + for (; it != end; ++it) + { + stream.next(*it); + } + } + + inline static uint32_t serializedLength(const VecType& v) + { + uint32_t size = 4; + ConstIteratorType it = v.begin(); + ConstIteratorType end = v.end(); + for (; it != end; ++it) + { + size += serializationLength(*it); + } + + return size; + } +}; + +/** + * \brief Vector serializer, specialized for fixed-size simple types + */ +template +struct VectorSerializer >::type > +{ + typedef std::vector::other> VecType; + typedef typename VecType::iterator IteratorType; + typedef typename VecType::const_iterator ConstIteratorType; + + template + inline static void write(Stream& stream, const VecType& v) + { + uint32_t len = (uint32_t)v.size(); + stream.next(len); + if (!v.empty()) + { + const uint32_t data_len = len * (uint32_t)sizeof(T); + memcpy(stream.advance(data_len), &v.front(), data_len); + } + } + + template + inline static void read(Stream& stream, VecType& v) + { + uint32_t len; + stream.next(len); + v.resize(len); + + if (len > 0) + { + const uint32_t data_len = (uint32_t)sizeof(T) * len; + memcpy(&v.front(), stream.advance(data_len), data_len); + } + } + + inline static uint32_t serializedLength(const VecType& v) + { + return 4 + (uint32_t)v.size() * (uint32_t)sizeof(T); + } +}; + +/** + * \brief Vector serializer, specialized for fixed-size non-simple types + */ +template +struct VectorSerializer, mpl::not_ > > >::type > +{ + typedef std::vector::other> VecType; + typedef typename VecType::iterator IteratorType; + typedef typename VecType::const_iterator ConstIteratorType; + + template + inline static void write(Stream& stream, const VecType& v) + { + stream.next((uint32_t)v.size()); + ConstIteratorType it = v.begin(); + ConstIteratorType end = v.end(); + for (; it != end; ++it) + { + stream.next(*it); + } + } + + template + inline static void read(Stream& stream, VecType& v) + { + uint32_t len; + stream.next(len); + v.resize(len); + IteratorType it = v.begin(); + IteratorType end = v.end(); + for (; it != end; ++it) + { + stream.next(*it); + } + } + + inline static uint32_t serializedLength(const VecType& v) + { + uint32_t size = 4; + if (!v.empty()) + { + uint32_t len_each = serializationLength(v.front()); + size += len_each * (uint32_t)v.size(); + } + + return size; + } +}; + +/** + * \brief serialize version for std::vector + */ +template +inline void serialize(Stream& stream, const std::vector& t) +{ + VectorSerializer::write(stream, t); +} + +/** + * \brief deserialize version for std::vector + */ +template +inline void deserialize(Stream& stream, std::vector& t) +{ + VectorSerializer::read(stream, t); +} + +/** + * \brief serializationLength version for std::vector + */ +template +inline uint32_t serializationLength(const std::vector& t) +{ + return VectorSerializer::serializedLength(t); +} + +/** + * \brief Array serializer, default implementation does nothing + */ +template +struct ArraySerializer +{}; + +/** + * \brief Array serializer, specialized for non-fixed-size, non-simple types + */ +template +struct ArraySerializer >::type> +{ + typedef std::array ArrayType; + typedef typename ArrayType::iterator IteratorType; + typedef typename ArrayType::const_iterator ConstIteratorType; + + template + inline static void write(Stream& stream, const ArrayType& v) + { + ConstIteratorType it = v.begin(); + ConstIteratorType end = v.end(); + for (; it != end; ++it) + { + stream.next(*it); + } + } + + template + inline static void read(Stream& stream, ArrayType& v) + { + IteratorType it = v.begin(); + IteratorType end = v.end(); + for (; it != end; ++it) + { + stream.next(*it); + } + } + + inline static uint32_t serializedLength(const ArrayType& v) + { + uint32_t size = 0; + ConstIteratorType it = v.begin(); + ConstIteratorType end = v.end(); + for (; it != end; ++it) + { + size += serializationLength(*it); + } + + return size; + } +}; + +/** + * \brief Array serializer, specialized for fixed-size, simple types + */ +template +struct ArraySerializer >::type> +{ + typedef std::array ArrayType; + typedef typename ArrayType::iterator IteratorType; + typedef typename ArrayType::const_iterator ConstIteratorType; + + template + inline static void write(Stream& stream, const ArrayType& v) + { + const uint32_t data_len = N * sizeof(T); + memcpy(stream.advance(data_len), &v.front(), data_len); + } + + template + inline static void read(Stream& stream, ArrayType& v) + { + const uint32_t data_len = N * sizeof(T); + memcpy(&v.front(), stream.advance(data_len), data_len); + } + + inline static uint32_t serializedLength(const ArrayType&) + { + return N * sizeof(T); + } +}; + +/** + * \brief Array serializer, specialized for fixed-size, non-simple types + */ +template +struct ArraySerializer, mpl::not_ > > >::type> +{ + typedef std::array ArrayType; + typedef typename ArrayType::iterator IteratorType; + typedef typename ArrayType::const_iterator ConstIteratorType; + + template + inline static void write(Stream& stream, const ArrayType& v) + { + ConstIteratorType it = v.begin(); + ConstIteratorType end = v.end(); + for (; it != end; ++it) + { + stream.next(*it); + } + } + + template + inline static void read(Stream& stream, ArrayType& v) + { + IteratorType it = v.begin(); + IteratorType end = v.end(); + for (; it != end; ++it) + { + stream.next(*it); + } + } + + inline static uint32_t serializedLength(const ArrayType& v) + { + return serializationLength(v.front()) * N; + } +}; + +/** + * \brief serialize version for std::array + */ +template +inline void serialize(Stream& stream, const std::array& t) +{ + ArraySerializer::write(stream, t); +} + +/** + * \brief deserialize version for std::array + */ +template +inline void deserialize(Stream& stream, std::array& t) +{ + ArraySerializer::read(stream, t); +} + +/** + * \brief serializationLength version for std::array + */ +template +inline uint32_t serializationLength(const std::array& t) +{ + return ArraySerializer::serializedLength(t); +} + +/** + * \brief Enum + */ +namespace stream_types +{ +enum StreamType +{ + Input, + Output, + Length +}; +} +typedef stream_types::StreamType StreamType; + +/** + * \brief Stream base-class, provides common functionality for IStream and OStream + */ +struct ROSCPP_SERIALIZATION_DECL Stream +{ + /* + * \brief Returns a pointer to the current position of the stream + */ + inline uint8_t* getData() { return data_; } + /** + * \brief Advances the stream, checking bounds, and returns a pointer to the position before it + * was advanced. + * \throws StreamOverrunException if len would take this stream past the end of its buffer + */ + ROS_FORCE_INLINE uint8_t* advance(uint32_t len) + { + uint8_t* old_data = data_; + data_ += len; + if (data_ > end_) + { + // Throwing directly here causes a significant speed hit due to the extra code generated + // for the throw statement + throwStreamOverrun(); + } + return old_data; + } + + /** + * \brief Returns the amount of space left in the stream + */ + inline uint32_t getLength() { return (uint32_t)(end_ - data_); } + +protected: + Stream(uint8_t* _data, uint32_t _count) + : data_(_data) + , end_(_data + _count) + {} + +private: + uint8_t* data_; + uint8_t* end_; +}; + +/** + * \brief Input stream + */ +struct ROSCPP_SERIALIZATION_DECL IStream : public Stream +{ + static const StreamType stream_type = stream_types::Input; + + IStream(uint8_t* data, uint32_t count) + : Stream(data, count) + {} + + /** + * \brief Deserialize an item from this input stream + */ + template + ROS_FORCE_INLINE void next(T& t) + { + deserialize(*this, t); + } + + template + ROS_FORCE_INLINE IStream& operator>>(T& t) + { + deserialize(*this, t); + return *this; + } +}; + +/** + * \brief Output stream + */ +struct ROSCPP_SERIALIZATION_DECL OStream : public Stream +{ + static const StreamType stream_type = stream_types::Output; + + OStream(uint8_t* data, uint32_t count) + : Stream(data, count) + {} + + /** + * \brief Serialize an item to this output stream + */ + template + ROS_FORCE_INLINE void next(const T& t) + { + serialize(*this, t); + } + + template + ROS_FORCE_INLINE OStream& operator<<(const T& t) + { + serialize(*this, t); + return *this; + } +}; + + +/** + * \brief Length stream + * + * LStream is not what you would normally think of as a stream, but it is used in order to support + * allinone serializers. + */ +struct ROSCPP_SERIALIZATION_DECL LStream +{ + static const StreamType stream_type = stream_types::Length; + + LStream() + : count_(0) + {} + + /** + * \brief Add the length of an item to this length stream + */ + template + ROS_FORCE_INLINE void next(const T& t) + { + count_ += serializationLength(t); + } + + /** + * \brief increment the length by len + */ + ROS_FORCE_INLINE uint32_t advance(uint32_t len) + { + uint32_t old = count_; + count_ += len; + return old; + } + + /** + * \brief Get the total length of this tream + */ + inline uint32_t getLength() { return count_; } + +private: + uint32_t count_; +}; + +/** + * \brief Serialize a message + */ +template +inline SerializedMessage serializeMessage(const M& message) +{ + SerializedMessage m; + uint32_t len = serializationLength(message); + m.num_bytes = len + 4; + m.buf.reset(new uint8_t[m.num_bytes]); + + OStream s(m.buf.get(), (uint32_t)m.num_bytes); + serialize(s, (uint32_t)m.num_bytes - 4); + m.message_start = s.getData(); + serialize(s, message); + + return m; +} + +/** + * \brief Serialize a service response + */ +template +inline SerializedMessage serializeServiceResponse(bool ok, const M& message) +{ + SerializedMessage m; + + if (ok) + { + uint32_t len = serializationLength(message); + m.num_bytes = len + 5; + m.buf.reset(new uint8_t[m.num_bytes]); + + OStream s(m.buf.get(), (uint32_t)m.num_bytes); + serialize(s, (uint8_t)ok); + serialize(s, (uint32_t)m.num_bytes - 5); + serialize(s, message); + } + else + { + uint32_t len = serializationLength(message); + m.num_bytes = len + 1; + m.buf.reset(new uint8_t[m.num_bytes]); + + OStream s(m.buf.get(), (uint32_t)m.num_bytes); + serialize(s, (uint8_t)ok); + serialize(s, message); + } + + return m; +} + +/** + * \brief Deserialize a message. If includes_length is true, skips the first 4 bytes + */ +template +inline void deserializeMessage(const SerializedMessage& m, M& message) +{ + IStream s(m.message_start, m.num_bytes - (m.message_start - m.buf->data())); + deserialize(s, message); +} + + +// Additional serialization traits + +template +struct PreDeserializeParams +{ + std::shared_ptr message; + std::shared_ptr > connection_header; +}; + +/** + * \brief called by the SubscriptionCallbackHelper after a message is + * instantiated but before that message is deserialized + */ +template +struct PreDeserialize +{ + static void notify(const PreDeserializeParams&) { } +}; + +} // namespace serialization + +} // namespace ros + +#endif // ROSCPP_SERIALIZATION_H diff --git a/realsense-file/3rd_party/rosbag/roscpp_serialization/include/ros/serialized_message.h b/realsense-file/3rd_party/rosbag/roscpp_serialization/include/ros/serialized_message.h new file mode 100644 index 0000000000..88fdf3ff00 --- /dev/null +++ b/realsense-file/3rd_party/rosbag/roscpp_serialization/include/ros/serialized_message.h @@ -0,0 +1,65 @@ +/* + * Copyright (C) 2009, Willow Garage, Inc. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the names of Willow Garage, Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef ROSLIB_SERIALIZED_MESSAGE_H +#define ROSLIB_SERIALIZED_MESSAGE_H + +#include "roscpp_serialization_macros.h" +#include +#include + +namespace ros +{ + +class ROSCPP_SERIALIZATION_DECL SerializedMessage +{ +public: + std::shared_ptr> buf; + size_t num_bytes; + uint8_t* message_start; + + std::shared_ptr message; + const std::type_info* type_info; + + SerializedMessage() + : buf(std::shared_ptr>()) + , num_bytes(0) + , message_start(0) + , type_info(0) + {} + + SerializedMessage(std::shared_ptr> buf, size_t num_bytes) + : buf(buf) + , num_bytes(num_bytes) + , message_start(buf ? buf->data() :0) + , type_info(0) + {} +}; + +} // namespace ros + +#endif // ROSLIB_SERIALIZED_MESSAGE_H diff --git a/realsense-file/3rd_party/rosbag/roscpp_serialization/src/serialization.cpp b/realsense-file/3rd_party/rosbag/roscpp_serialization/src/serialization.cpp new file mode 100644 index 0000000000..72a16c41fd --- /dev/null +++ b/realsense-file/3rd_party/rosbag/roscpp_serialization/src/serialization.cpp @@ -0,0 +1,39 @@ +/* + * Copyright (C) 2009, Willow Garage, Inc. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the names of Stanford University or Willow Garage, Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +#include + +namespace ros +{ +namespace serialization +{ +void throwStreamOverrun() +{ + throw StreamOverrunException("Buffer Overrun"); +} +} +} diff --git a/realsense-file/3rd_party/rosbag/roscpp_traits/config.cmake b/realsense-file/3rd_party/rosbag/roscpp_traits/config.cmake new file mode 100644 index 0000000000..e32019a21d --- /dev/null +++ b/realsense-file/3rd_party/rosbag/roscpp_traits/config.cmake @@ -0,0 +1,12 @@ +cmake_minimum_required(VERSION 2.8.3) + +set(HEADER_FILES_ROSCPP_TRAITS + rosbag/roscpp_traits/include/ros/builtin_message_traits.h + rosbag/roscpp_traits/include/ros/message_event.h + rosbag/roscpp_traits/include/ros/message_forward.h + rosbag/roscpp_traits/include/ros/message_operations.h + rosbag/roscpp_traits/include/ros/message_traits.h + rosbag/roscpp_traits/include/ros/service_traits.h +) + + diff --git a/realsense-file/3rd_party/rosbag/roscpp_traits/include/ros/builtin_message_traits.h b/realsense-file/3rd_party/rosbag/roscpp_traits/include/ros/builtin_message_traits.h new file mode 100644 index 0000000000..c9496e21ae --- /dev/null +++ b/realsense-file/3rd_party/rosbag/roscpp_traits/include/ros/builtin_message_traits.h @@ -0,0 +1,63 @@ +/* + * Copyright (C) 2009, Willow Garage, Inc. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the names of Willow Garage, Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef ROSLIB_BUILTIN_MESSAGE_TRAITS_H +#define ROSLIB_BUILTIN_MESSAGE_TRAITS_H + +#include "message_traits.h" +#include "ros/time.h" + +namespace ros +{ +namespace message_traits +{ + +#define ROSLIB_CREATE_SIMPLE_TRAITS(Type) \ + template<> struct IsSimple : public TrueType {}; \ + template<> struct IsFixedSize : public TrueType {}; + +ROSLIB_CREATE_SIMPLE_TRAITS(uint8_t) +ROSLIB_CREATE_SIMPLE_TRAITS(int8_t) +ROSLIB_CREATE_SIMPLE_TRAITS(uint16_t) +ROSLIB_CREATE_SIMPLE_TRAITS(int16_t) +ROSLIB_CREATE_SIMPLE_TRAITS(uint32_t) +ROSLIB_CREATE_SIMPLE_TRAITS(int32_t) +ROSLIB_CREATE_SIMPLE_TRAITS(uint64_t) +ROSLIB_CREATE_SIMPLE_TRAITS(int64_t) +ROSLIB_CREATE_SIMPLE_TRAITS(float) +ROSLIB_CREATE_SIMPLE_TRAITS(double) +ROSLIB_CREATE_SIMPLE_TRAITS(Time) +ROSLIB_CREATE_SIMPLE_TRAITS(Duration) + +// because std::vector is not a true vector, bool is not a simple type +template<> struct IsFixedSize : public TrueType {}; + +} // namespace message_traits +} // namespace ros + +#endif // ROSLIB_BUILTIN_MESSAGE_TRAITS_H + diff --git a/realsense-file/3rd_party/rosbag/roscpp_traits/include/ros/message_event.h b/realsense-file/3rd_party/rosbag/roscpp_traits/include/ros/message_event.h new file mode 100644 index 0000000000..cc50d558dc --- /dev/null +++ b/realsense-file/3rd_party/rosbag/roscpp_traits/include/ros/message_event.h @@ -0,0 +1,256 @@ + +/* + * Copyright (C) 2010, Willow Garage, Inc. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the names of Stanford University or Willow Garage, Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef ROSCPP_MESSAGE_EVENT_H +#define ROSCPP_MESSAGE_EVENT_H + +#include "ros/time.h" +#include "ros/datatypes.h" +#include "ros/message_traits.h" + +#include "boost/type_traits/is_void.hpp" +#include "boost/type_traits/is_base_of.hpp" +#include "boost/type_traits/is_const.hpp" +#include "boost/type_traits/add_const.hpp" +#include "boost/type_traits/remove_const.hpp" +#include "boost/utility/enable_if.hpp" +#include "boost/function.hpp" + + +namespace ros +{ + +template +struct DefaultMessageCreator +{ + std::shared_ptr operator()() + { + return std::make_shared(); + } +}; + +template +ROS_DEPRECATED inline std::shared_ptr defaultMessageCreateFunction() +{ + return DefaultMessageCreator()(); +} + +/** + * \brief Event type for subscriptions, const ros::MessageEvent& can be used in your callback instead of const std::shared_ptr& + * + * Useful if you need to retrieve meta-data about the message, such as the full connection header, or the publisher's node name + */ +template +class MessageEvent +{ +public: + typedef typename boost::add_const::type ConstMessage; + typedef typename boost::remove_const::type Message; + typedef std::shared_ptr MessagePtr; + typedef std::shared_ptr ConstMessagePtr; + typedef boost::function CreateFunction; + + MessageEvent() + : nonconst_need_copy_(true) + {} + + MessageEvent(const MessageEvent& rhs) + { + *this = rhs; + } + + MessageEvent(const MessageEvent& rhs) + { + *this = rhs; + } + + MessageEvent(const MessageEvent& rhs, bool nonconst_need_copy) + { + *this = rhs; + nonconst_need_copy_ = nonconst_need_copy; + } + + MessageEvent(const MessageEvent& rhs, bool nonconst_need_copy) + { + *this = rhs; + nonconst_need_copy_ = nonconst_need_copy; + } + + MessageEvent(const MessageEvent& rhs, const CreateFunction& create) + { + init(std::const_pointer_cast(std::static_pointer_cast(rhs.getMessage())), rhs.getConnectionHeaderPtr(), rhs.getReceiptTime(), rhs.nonConstWillCopy(), create); + } + + /** + * \todo Make this explicit in ROS 2.0. Keep as auto-converting for now to maintain backwards compatibility in some places (message_filters) + */ + MessageEvent(const ConstMessagePtr& message) + { + init(message, std::shared_ptr(), ros::Time::now(), true, ros::DefaultMessageCreator()); + } + + MessageEvent(const ConstMessagePtr& message, const std::shared_ptr& connection_header, ros::Time receipt_time) + { + init(message, connection_header, receipt_time, true, ros::DefaultMessageCreator()); + } + + MessageEvent(const ConstMessagePtr& message, ros::Time receipt_time) + { + init(message, std::shared_ptr(), receipt_time, true, ros::DefaultMessageCreator()); + } + + MessageEvent(const ConstMessagePtr& message, const std::shared_ptr& connection_header, ros::Time receipt_time, bool nonconst_need_copy, const CreateFunction& create) + { + init(message, connection_header, receipt_time, nonconst_need_copy, create); + } + + void init(const ConstMessagePtr& message, const std::shared_ptr& connection_header, ros::Time receipt_time, bool nonconst_need_copy, const CreateFunction& create) + { + message_ = message; + connection_header_ = connection_header; + receipt_time_ = receipt_time; + nonconst_need_copy_ = nonconst_need_copy; + create_ = create; + } + + void operator=(const MessageEvent& rhs) + { + init(std::static_pointer_cast(rhs.getMessage()), rhs.getConnectionHeaderPtr(), rhs.getReceiptTime(), rhs.nonConstWillCopy(), rhs.getMessageFactory()); + message_copy_.reset(); + } + + void operator=(const MessageEvent& rhs) + { + init(std::const_pointer_cast(std::static_pointer_cast(rhs.getMessage())), rhs.getConnectionHeaderPtr(), rhs.getReceiptTime(), rhs.nonConstWillCopy(), rhs.getMessageFactory()); + message_copy_.reset(); + } + + /** + * \brief Retrieve the message. If M is const, this returns a reference to it. If M is non const + * and this event requires it, returns a copy. Note that it caches this copy for later use, so it will + * only every make the copy once + */ + std::shared_ptr getMessage() const + { + return copyMessageIfNecessary(); + } + + /** + * \brief Retrieve a const version of the message + */ + const std::shared_ptr& getConstMessage() const { return message_; } + /** + * \brief Retrieve the connection header + */ + M_string& getConnectionHeader() const { return *connection_header_; } + const std::shared_ptr& getConnectionHeaderPtr() const { return connection_header_; } + + /** + * \brief Returns the name of the node which published this message + */ + const std::string& getPublisherName() const { return connection_header_ ? (*connection_header_)["callerid"] : s_unknown_publisher_string_; } + + /** + * \brief Returns the time at which this message was received + */ + ros::Time getReceiptTime() const { return receipt_time_; } + + bool nonConstWillCopy() const { return nonconst_need_copy_; } + bool getMessageWillCopy() const { return !boost::is_const::value && nonconst_need_copy_; } + + bool operator<(const MessageEvent& rhs) + { + if (message_ != rhs.message_) + { + return message_ < rhs.message_; + } + + if (receipt_time_ != rhs.receipt_time_) + { + return receipt_time_ < rhs.receipt_time_; + } + + return nonconst_need_copy_ < rhs.nonconst_need_copy_; + } + + bool operator==(const MessageEvent& rhs) + { + return message_ = rhs.message_ && receipt_time_ == rhs.receipt_time_ && nonconst_need_copy_ == rhs.nonconst_need_copy_; + } + + bool operator!=(const MessageEvent& rhs) + { + return !(*this == rhs); + } + + const CreateFunction& getMessageFactory() const { return create_; } + +private: + template + typename boost::disable_if, std::shared_ptr >::type copyMessageIfNecessary() const + { + if (boost::is_const::value || !nonconst_need_copy_) + { + return std::const_pointer_cast(message_); + } + + if (message_copy_) + { + return message_copy_; + } + + assert(create_); + message_copy_ = create_(); + *message_copy_ = *message_; + + return message_copy_; + } + + template + typename boost::enable_if, std::shared_ptr >::type copyMessageIfNecessary() const + { + return std::const_pointer_cast(message_); + } + + ConstMessagePtr message_; + // Kind of ugly to make this mutable, but it means we can pass a const MessageEvent to a callback and not worry about other things being modified + mutable MessagePtr message_copy_; + std::shared_ptr connection_header_; + ros::Time receipt_time_; + bool nonconst_need_copy_; + CreateFunction create_; + + static const std::string s_unknown_publisher_string_; +}; + +template const std::string MessageEvent::s_unknown_publisher_string_("unknown_publisher"); + + +} + +#endif // ROSCPP_MESSAGE_EVENT_H diff --git a/realsense-file/3rd_party/rosbag/roscpp_traits/include/ros/message_forward.h b/realsense-file/3rd_party/rosbag/roscpp_traits/include/ros/message_forward.h new file mode 100644 index 0000000000..7ce6ce7b57 --- /dev/null +++ b/realsense-file/3rd_party/rosbag/roscpp_traits/include/ros/message_forward.h @@ -0,0 +1,76 @@ +/* + * Copyright (C) 2009, Willow Garage, Inc. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the names of Willow Garage, Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef ROSLIB_MESSAGE_FORWARD_H +#define ROSLIB_MESSAGE_FORWARD_H + +// Make sure that either __GLIBCXX__ or _LIBCPP_VERSION is defined. +#include + +// C++ standard section 17.4.3.1/1 states that forward declarations of STL types +// that aren't specializations involving user defined types results in undefined +// behavior. Apparently only libc++ has a problem with this and won't compile it. +#ifndef _LIBCPP_VERSION +namespace std +{ +template class allocator; +template class shared_ptr; +} +#else +#include +#endif + +// +//namespace boost +//{ +//template class std::shared_ptr; +//} + +/** + * \brief Forward-declare a message, including Ptr and ConstPtr types, with an allocator + * + * \param ns The namespace the message should be declared inside + * \param m The "base" message type, i.e. the name of the .msg file + * \param new_name The name you'd like the message to have + * \param alloc The allocator to use, e.g. std::allocator + */ + +#include + +#define ROS_DECLARE_MESSAGE_WITH_ALLOCATOR(msg, new_name, alloc) \ + template struct msg##_; \ + typedef msg##_ > new_name; \ + typedef std::shared_ptr new_name##Ptr; \ + typedef std::shared_ptr new_name##ConstPtr; + +/** + * \brief Forward-declare a message, including Ptr and ConstPtr types, using std::allocator + * \param msg The "base" message type, i.e. the name of the .msg file + */ +#define ROS_DECLARE_MESSAGE(msg) ROS_DECLARE_MESSAGE_WITH_ALLOCATOR(msg, msg, std::allocator) + +#endif // ROSLIB_MESSAGE_FORWARD_H diff --git a/realsense-file/3rd_party/rosbag/roscpp_traits/include/ros/message_operations.h b/realsense-file/3rd_party/rosbag/roscpp_traits/include/ros/message_operations.h new file mode 100644 index 0000000000..f5b4079b66 --- /dev/null +++ b/realsense-file/3rd_party/rosbag/roscpp_traits/include/ros/message_operations.h @@ -0,0 +1,77 @@ +/* + * Copyright (C) 2010, Willow Garage, Inc. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the names of Willow Garage, Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef ROSLIB_MESSAGE_OPERATIONS_H +#define ROSLIB_MESSAGE_OPERATIONS_H + +#include + +namespace ros +{ +namespace message_operations +{ + +template +struct Printer +{ + template + static void stream(Stream& s, const std::string& indent, const M& value) + { + (void)indent; + s << value << "\n"; + } +}; + +// Explicitly specialize for uint8_t/int8_t because otherwise it thinks it's a char, and treats +// the value as a character code +template<> +struct Printer +{ + template + static void stream(Stream& s, const std::string& indent, int8_t value) + { + (void)indent; + s << static_cast(value) << "\n"; + } +}; + +template<> +struct Printer +{ + template + static void stream(Stream& s, const std::string& indent, uint8_t value) + { + (void)indent; + s << static_cast(value) << "\n"; + } +}; + +} // namespace message_operations +} // namespace ros + +#endif // ROSLIB_MESSAGE_OPERATIONS_H + diff --git a/realsense-file/3rd_party/rosbag/roscpp_traits/include/ros/message_traits.h b/realsense-file/3rd_party/rosbag/roscpp_traits/include/ros/message_traits.h new file mode 100644 index 0000000000..c595edfdeb --- /dev/null +++ b/realsense-file/3rd_party/rosbag/roscpp_traits/include/ros/message_traits.h @@ -0,0 +1,361 @@ +/* + * Copyright (C) 2009, Willow Garage, Inc. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the names of Willow Garage, Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef ROSLIB_MESSAGE_TRAITS_H +#define ROSLIB_MESSAGE_TRAITS_H + +#include "message_forward.h" + +#include "ros/time.h" + +#include +#include "boost/enable_if.hpp" +#include "boost/type_traits/remove_const.hpp" +#include +#include + +namespace std_msgs +{ + ROS_DECLARE_MESSAGE(Header) +} + +#define ROS_IMPLEMENT_SIMPLE_TOPIC_TRAITS(msg, md5sum, datatype, definition) \ + namespace ros \ + { \ + namespace message_traits \ + { \ + template<> struct MD5Sum \ + { \ + static const char* value() { return md5sum; } \ + static const char* value(const msg&) { return value(); } \ + }; \ + template<> struct DataType \ + { \ + static const char* value() { return datatype; } \ + static const char* value(const msg&) { return value(); } \ + }; \ + template<> struct Definition \ + { \ + static const char* value() { return definition; } \ + static const char* value(const msg&) { return value(); } \ + }; \ + } \ + } + + +namespace ros +{ +namespace message_traits +{ + +/** + * \brief Base type for compile-type true/false tests. Compatible with Boost.MPL. classes inheriting from this type + * are \b true values. + */ +struct TrueType +{ + static const bool value = true; + typedef TrueType type; +}; + +/** + * \brief Base type for compile-type true/false tests. Compatible with Boost.MPL. classes inheriting from this type + * are \b false values. + */ +struct FalseType +{ + static const bool value = false; + typedef FalseType type; +}; + +/** + * \brief A simple datatype is one that can be memcpy'd directly in array form, i.e. it's a POD, fixed-size type and + * sizeof(M) == sum(serializationLength(M:a...)) + */ +template struct IsSimple : public FalseType {}; +/** + * \brief A fixed-size datatype is one whose size is constant, i.e. it has no variable-length arrays or strings + */ +template struct IsFixedSize : public FalseType {}; +/** + * \brief HasHeader informs whether or not there is a header that gets serialized as the first thing in the message + */ +template struct HasHeader : public FalseType {}; + +/** + * \brief Am I message or not + */ +template struct IsMessage : public FalseType {}; + +/** + * \brief Specialize to provide the md5sum for a message + */ +template +struct MD5Sum +{ + static const char* value() + { + return M::__s_getMD5Sum(); + } + + static const char* value(const M& m) + { + return m.__getMD5Sum(); + } +}; + +/** + * \brief Specialize to provide the datatype for a message + */ +template +struct DataType +{ + static const char* value() + { + return M::__s_getDataType(); + } + + static const char* value(const M& m) + { + return m.__getDataType(); + } +}; + +/** + * \brief Specialize to provide the definition for a message + */ +template +struct Definition +{ + static const char* value() + { + return M::__s_getMessageDefinition(); + } + + static const char* value(const M& m) + { + return m.__getMessageDefinition(); + } +}; + +/** + * \brief Header trait. In the default implementation pointer() + * returns &m.header if HasHeader::value is true, otherwise returns NULL + */ +template +struct Header +{ + static std_msgs::Header* pointer(M& m) { (void)m; return 0; } + static std_msgs::Header const* pointer(const M& m) { (void)m; return 0; } +}; + +template +struct Header >::type > +{ + static std_msgs::Header* pointer(M& m) { return &m.header; } + static std_msgs::Header const* pointer(const M& m) { return &m.header; } +}; + +/** + * \brief FrameId trait. In the default implementation pointer() + * returns &m.header.frame_id if HasHeader::value is true, otherwise returns NULL. value() + * does not exist, and causes a compile error + */ +template +struct FrameId +{ + static std::string* pointer(M& m) { (void)m; return 0; } + static std::string const* pointer(const M& m) { (void)m; return 0; } +}; + +template +struct FrameId >::type > +{ + static std::string* pointer(M& m) { return &m.header.frame_id; } + static std::string const* pointer(const M& m) { return &m.header.frame_id; } + static std::string value(const M& m) { return m.header.frame_id; } +}; + +/** + * \brief TimeStamp trait. In the default implementation pointer() + * returns &m.header.stamp if HasHeader::value is true, otherwise returns NULL. value() + * does not exist, and causes a compile error + */ +template +struct TimeStamp +{ + static ros::Time* pointer(M& m) { (void)m; return 0; } + static ros::Time const* pointer(const M& m) { (void)m; return 0; } +}; + +template +struct TimeStamp >::type > +{ + static ros::Time* pointer(typename std::remove_const::type &m) { return &m.header.stamp; } + static ros::Time const* pointer(const M& m) { return &m.header.stamp; } + static ros::Time value(const M& m) { return m.header.stamp; } +}; + +/** + * \brief returns MD5Sum::value(); + */ +template +inline const char* md5sum() +{ + return MD5Sum::type>::type>::value(); +} + +/** + * \brief returns DataType::value(); + */ +template +inline const char* datatype() +{ + return DataType::type>::type>::value(); +} + +/** + * \brief returns Definition::value(); + */ +template +inline const char* definition() +{ + return Definition::type>::type>::value(); +} + +/** + * \brief returns MD5Sum::value(m); + */ +template +inline const char* md5sum(const M& m) +{ + return MD5Sum::type>::type>::value(m); +} + +/** + * \brief returns DataType::value(m); + */ +template +inline const char* datatype(const M& m) +{ + return DataType::type>::type>::value(m); +} + +/** + * \brief returns Definition::value(m); + */ +template +inline const char* definition(const M& m) +{ + return Definition::type>::type>::value(m); +} + +/** + * \brief returns Header::pointer(m); + */ +template +inline std_msgs::Header* header(M& m) +{ + return Header::type>::type>::pointer(m); +} + +/** + * \brief returns Header::pointer(m); + */ +template +inline std_msgs::Header const* header(const M& m) +{ + return Header::type>::type>::pointer(m); +} + +/** + * \brief returns FrameId::pointer(m); + */ +template +inline std::string* frameId(M& m) +{ + return FrameId::type>::type>::pointer(m); +} + +/** + * \brief returns FrameId::pointer(m); + */ +template +inline std::string const* frameId(const M& m) +{ + return FrameId::type>::type>::pointer(m); +} + +/** + * \brief returns TimeStamp::pointer(m); + */ +template +inline ros::Time* timeStamp(M& m) +{ + return TimeStamp::type>::type>::pointer(m); +} + +/** + * \brief returns TimeStamp::pointer(m); + */ +template +inline ros::Time const* timeStamp(const M& m) +{ + return TimeStamp::type>::type>::pointer(m); +} + +/** + * \brief returns IsSimple::value; + */ +template +inline bool isSimple() +{ + return IsSimple::type>::type>::value; +} + +/** + * \brief returns IsFixedSize::value; + */ +template +inline bool isFixedSize() +{ + return IsFixedSize::type>::type>::value; +} + +/** + * \brief returns HasHeader::value; + */ +template +inline bool hasHeader() +{ + return HasHeader::type>::type>::value; +} + +} // namespace message_traits +} // namespace ros + +#endif // ROSLIB_MESSAGE_TRAITS_H diff --git a/realsense-file/3rd_party/rosbag/roscpp_traits/include/ros/service_traits.h b/realsense-file/3rd_party/rosbag/roscpp_traits/include/ros/service_traits.h new file mode 100644 index 0000000000..cb88e150d1 --- /dev/null +++ b/realsense-file/3rd_party/rosbag/roscpp_traits/include/ros/service_traits.h @@ -0,0 +1,112 @@ +/* + * Copyright (C) 2009, Willow Garage, Inc. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the names of Willow Garage, Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef ROSCPP_SERVICE_TRAITS_H +#define ROSCPP_SERVICE_TRAITS_H + +#include +#include + +namespace ros +{ +namespace service_traits +{ + +/** + * \brief Specialize to provide the md5sum for a service + */ +template +struct MD5Sum +{ + static const char* value() + { + return M::__s_getServerMD5Sum(); + } + + static const char* value(const M& m) + { + return m.__getServerMD5Sum(); + } +}; + +/** + * \brief Specialize to provide the datatype for a service + */ +template +struct DataType +{ + static const char* value() + { + return M::__s_getServiceDataType(); + } + + static const char* value(const M& m) + { + return m.__getServiceDataType(); + } +}; + +/** + * \brief return MD5Sum::value(); + */ +template +inline const char* md5sum() +{ + return MD5Sum::type>::type>::value(); +} + +/** + * \brief return DataType::value(); + */ +template +inline const char* datatype() +{ + return DataType::type>::type>::value(); +} + +/** + * \brief return MD5Sum::value(m); + */ +template +inline const char* md5sum(const M& m) +{ + return MD5Sum::type>::type>::value(m); +} + +/** + * \brief return DataType::value(); + */ +template +inline const char* datatype(const M& m) +{ + return DataType::type>::type>::value(m); +} + +} // namespace service_traits +} // namespace ros + +#endif // ROSCPP_SERVICE_TRAITS_H diff --git a/realsense-file/3rd_party/rosbag/roslz4/config.cmake b/realsense-file/3rd_party/rosbag/roslz4/config.cmake new file mode 100644 index 0000000000..8ac806bd38 --- /dev/null +++ b/realsense-file/3rd_party/rosbag/roslz4/config.cmake @@ -0,0 +1,12 @@ +cmake_minimum_required(VERSION 2.8.3) + +set(HEADER_FILES_ROSLZ4 + rosbag/roslz4/include/roslz4/lz4s.h +) + +set(SOURCE_FILES_ROSLZ4 + rosbag/roslz4/src/lz4s.c +# rosbag/roslz4/src/_roslz4module.c + rosbag/roslz4/src/xxhash.c + rosbag/roslz4/src/xxhash.h +) diff --git a/realsense-file/3rd_party/rosbag/roslz4/include/roslz4/lz4s.h b/realsense-file/3rd_party/rosbag/roslz4/include/roslz4/lz4s.h new file mode 100644 index 0000000000..21262a4cfd --- /dev/null +++ b/realsense-file/3rd_party/rosbag/roslz4/include/roslz4/lz4s.h @@ -0,0 +1,95 @@ +/********************************************************************* +* Software License Agreement (BSD License) +* +* Copyright (c) 2014, Ben Charrow +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions +* are met: +* +* * Redistributions of source code must retain the above copyright +* notice, this list of conditions and the following disclaimer. +* * Redistributions in binary form must reproduce the above +* copyright notice, this list of conditions and the following +* disclaimer in the documentation and/or other materials provided +* with the distribution. +* * Neither the name of Willow Garage, Inc. nor the names of its +* contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +********************************************************************/ + +#ifndef ROSLZ4_LZ4S_H +#define ROSLZ4_LZ4S_H + +#include "../../../../lz4/lib/lz4.h" + +#ifdef __cplusplus +extern "C" { +#endif + +// Return codes +const int ROSLZ4_MEMORY_ERROR = -5; +const int ROSLZ4_PARAM_ERROR = -4; +const int ROSLZ4_DATA_ERROR = -3; +const int ROSLZ4_OUTPUT_SMALL = -2; +const int ROSLZ4_ERROR = -1; +const int ROSLZ4_OK = 0; +const int ROSLZ4_STREAM_END = 2; + +// Actions +const int ROSLZ4_RUN = 0; +const int ROSLZ4_FINISH = 1; + +typedef struct { + char *input_next; + int input_left; + + char *output_next; + int output_left; + + int total_in; + int total_out; + + int block_size_id; + + // Internal use + void *state; +} roslz4_stream; + +// Low level functions +int roslz4_blockSizeFromIndex(int block_id); + +int roslz4_compressStart(roslz4_stream *stream, int block_size_id); +int roslz4_compress(roslz4_stream *stream, int action); +void roslz4_compressEnd(roslz4_stream *stream); + +int roslz4_decompressStart(roslz4_stream *stream); +int roslz4_decompress(roslz4_stream *stream); +void roslz4_decompressEnd(roslz4_stream *str); + +// Oneshot compression / decompression +int roslz4_buffToBuffCompress(char *input, unsigned int input_size, + char *output, unsigned int *output_size, + int block_size_id); +int roslz4_buffToBuffDecompress(char *input, unsigned int input_size, + char *output, unsigned int *output_size); + +#ifdef __cplusplus +} +#endif + +#endif // ROSLZ4_LZ4S_H diff --git a/realsense-file/3rd_party/rosbag/roslz4/src/_roslz4module.c b/realsense-file/3rd_party/rosbag/roslz4/src/_roslz4module.c new file mode 100644 index 0000000000..e000acb001 --- /dev/null +++ b/realsense-file/3rd_party/rosbag/roslz4/src/_roslz4module.c @@ -0,0 +1,452 @@ +///********************************************************************* +//* Software License Agreement (BSD License) +//* +//* Copyright (c) 2014, Ben Charrow +//* All rights reserved. +//* +//* Redistribution and use in source and binary forms, with or without +//* modification, are permitted provided that the following conditions +//* are met: +//* +//* * Redistributions of source code must retain the above copyright +//* notice, this list of conditions and the following disclaimer. +//* * Redistributions in binary form must reproduce the above +//* copyright notice, this list of conditions and the following +//* disclaimer in the documentation and/or other materials provided +//* with the distribution. +//* * Neither the name of Willow Garage, Inc. nor the names of its +//* contributors may be used to endorse or promote products derived +//* from this software without specific prior written permission. +//* +//* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +//* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +//* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +//* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +//* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +//* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +//* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +//* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +//* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +//* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +//* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +//* POSSIBILITY OF SUCH DAMAGE. +//********************************************************************/ +// +//#include "Python.h" +// +//#include "roslz4/lz4s.h" +// +//struct module_state { +// PyObject *error; +//}; +// +//#if PY_MAJOR_VERSION >= 3 +//#define GETSTATE(m) ((struct module_state*)PyModule_GetState(m)) +//#else +//#define GETSTATE(m) (&_state) +//static struct module_state _state; +//#endif +// +///* Taken from Python's _bz2module.c */ +//static int +//grow_buffer(PyObject **buf) +//{ +// /* Expand the buffer by an amount proportional to the current size, +// giving us amortized linear-time behavior. Use a less-than-double +// growth factor to avoid excessive allocation. */ +// size_t size = PyBytes_GET_SIZE(*buf); +// size_t new_size = size + (size >> 3) + 6; +// if (new_size > size) { +// return _PyBytes_Resize(buf, new_size); +// } else { /* overflow */ +// PyErr_SetString(PyExc_OverflowError, +// "Unable to allocate buffer - output too large"); +// return -1; +// } +//} +// +///*============================== LZ4Compressor ==============================*/ +// +//typedef struct { +// PyObject_HEAD +// roslz4_stream stream; +//} LZ4Compressor; +// +//static void +//LZ4Compressor_dealloc(LZ4Compressor *self) +//{ +// roslz4_compressEnd(&self->stream); +// Py_TYPE(self)->tp_free((PyObject*)self); +//} +// +//static int +//LZ4Compressor_init(LZ4Compressor *self, PyObject *args, PyObject *kwds) +//{ +// (void)kwds; +// if (!PyArg_ParseTuple(args, ":__init__")) { +// return -1; +// } +// +// int ret = roslz4_compressStart(&self->stream, 6); +// if (ret != ROSLZ4_OK) { +// PyErr_SetString(PyExc_RuntimeError, "error initializing roslz4 stream"); +// return -1; +// } +// return 0; +//} +// +//static PyObject * +//compress_impl(LZ4Compressor *self, Py_buffer *input, PyObject *output) +//{ +// /* Allocate output string */ +// int initial_size = roslz4_blockSizeFromIndex(self->stream.block_size_id) + 64; +// output = PyBytes_FromStringAndSize(NULL, initial_size); +// if (!output) { +// if (input != NULL) { PyBuffer_Release(input); } +// return NULL; +// } +// +// /* Setup stream */ +// int action; +// if (input != NULL) { +// action = ROSLZ4_RUN; +// self->stream.input_next = input->buf; +// self->stream.input_left = input->len; +// } else { +// action = ROSLZ4_FINISH; +// self->stream.input_next = NULL; +// self->stream.input_left = 0; +// } +// self->stream.output_next = PyBytes_AS_STRING(output); +// self->stream.output_left = PyBytes_GET_SIZE(output); +// +// /* Compress data */ +// int status; +// int output_written = 0; +// while ((action == ROSLZ4_FINISH) || +// (action == ROSLZ4_RUN && self->stream.input_left > 0)) { +// int out_start = self->stream.total_out; +// status = roslz4_compress(&self->stream, action); +// output_written += self->stream.total_out - out_start; +// if (status == ROSLZ4_OK) { +// continue; +// } else if (status == ROSLZ4_STREAM_END) { +// break; +// } else if (status == ROSLZ4_OUTPUT_SMALL) { +// if (grow_buffer(&output) < 0) { +// goto error; +// } +// self->stream.output_next = PyBytes_AS_STRING(output) + output_written; +// self->stream.output_left = PyBytes_GET_SIZE(output) - output_written; +// } else if (status == ROSLZ4_PARAM_ERROR) { +// PyErr_SetString(PyExc_IOError, "bad block size parameter"); +// goto error; +// } else if (status == ROSLZ4_ERROR) { +// PyErr_SetString(PyExc_IOError, "error compressing"); +// goto error; +// } else { +// PyErr_Format(PyExc_RuntimeError, "unhandled return code %i", status); +// goto error; +// } +// } +// +// /* Shrink return buffer */ +// if (output_written != PyBytes_GET_SIZE(output)) { +// _PyBytes_Resize(&output, output_written); +// } +// +// if (input != NULL) { PyBuffer_Release(input); } +// return output; +// +//error: +// if (input != NULL) { PyBuffer_Release(input); } +// Py_XDECREF(output); +// return NULL; +//} +// +//static PyObject * +//LZ4Compressor_compress(LZ4Compressor *self, PyObject *args) +//{ +// Py_buffer input; +// PyObject *output = NULL; +// +// /* TODO: Keyword argument */ +// if (!PyArg_ParseTuple(args, "s*:compress", &input)) { +// return NULL; +// } +// +// return compress_impl(self, &input, output); +//} +// +//static PyObject * +//LZ4Compressor_flush(LZ4Compressor *self, PyObject *args) +//{ +// PyObject *output = NULL; +// +// if (!PyArg_ParseTuple(args, ":flush")) { +// return NULL; +// } +// +// return compress_impl(self, NULL, output); +//} +// +// +//static PyMethodDef LZ4Compressor_methods[] = { +// {"compress", (PyCFunction)LZ4Compressor_compress, METH_VARARGS, "method doc"}, +// {"flush", (PyCFunction)LZ4Compressor_flush, METH_VARARGS, "method doc"}, +// {NULL} /* Sentinel */ +//}; +// +//static PyTypeObject LZ4Compressor_Type = { +// PyVarObject_HEAD_INIT(NULL, 0) +// "_roslz4.LZ4Compressor", /* tp_name */ +// sizeof(LZ4Compressor), /* tp_basicsize */ +// 0, /* tp_itemsize */ +// (destructor)LZ4Compressor_dealloc, /* tp_dealloc */ +// 0, /* tp_print */ +// 0, /* tp_getattr */ +// 0, /* tp_setattr */ +// 0, /* tp_compare */ +// 0, /* tp_repr */ +// 0, /* tp_as_number */ +// 0, /* tp_as_sequence */ +// 0, /* tp_as_mapping */ +// 0, /* tp_hash */ +// 0, /* tp_call */ +// 0, /* tp_str */ +// 0, /* tp_getattro */ +// 0, /* tp_setattro */ +// 0, /* tp_as_buffer */ +// Py_TPFLAGS_DEFAULT, /* tp_flags */ +// "LZ4Compressor objects", /* tp_doc */ +// 0, /* tp_traverse */ +// 0, /* tp_clear */ +// 0, /* tp_richcompare */ +// 0, /* tp_weaklistoffset */ +// 0, /* tp_iter */ +// 0, /* tp_iternext */ +// LZ4Compressor_methods, /* tp_methods */ +// 0, /* tp_members */ +// 0, /* tp_getset */ +// 0, /* tp_base */ +// 0, /* tp_dict */ +// 0, /* tp_descr_get */ +// 0, /* tp_descr_set */ +// 0, /* tp_dictoffset */ +// (initproc)LZ4Compressor_init /* tp_init */ +//}; +// +///*============================= LZ4Decompressor =============================*/ +// +//typedef struct { +// PyObject_HEAD +// roslz4_stream stream; +//} LZ4Decompressor; +// +//static void +//LZ4Decompressor_dealloc(LZ4Decompressor *self) +//{ +// roslz4_decompressEnd(&self->stream); +// Py_TYPE(self)->tp_free((PyObject*)self); +//} +// +//static int +//LZ4Decompressor_init(LZ4Decompressor *self, PyObject *args, PyObject *kwds) +//{ +// (void)kwds; +// if (!PyArg_ParseTuple(args, ":__init__")) { +// return -1; +// } +// +// int ret = roslz4_decompressStart(&self->stream); +// if (ret != ROSLZ4_OK) { +// PyErr_SetString(PyExc_RuntimeError, "error initializing roslz4 stream"); +// return -1; +// } +// return 0; +//} +// +//static PyObject * +//LZ4Decompressor_decompress(LZ4Decompressor *self, PyObject *args) +//{ +// Py_buffer input; +// PyObject *output = NULL; +// +// /* TODO: Keyword argument */ +// if (!PyArg_ParseTuple(args, "s*:decompress", &input)) { +// return NULL; +// } +// +// /* Allocate 1 output block. If header not read, use compression block size */ +// int block_size; +// if (self->stream.block_size_id == -1 ) { +// block_size = roslz4_blockSizeFromIndex(6); +// } else { +// block_size = roslz4_blockSizeFromIndex(self->stream.block_size_id); +// } +// +// output = PyBytes_FromStringAndSize(NULL, block_size); +// if (!output) { +// PyBuffer_Release(&input); +// return NULL; +// } +// +// /* Setup stream */ +// self->stream.input_next = input.buf; +// self->stream.input_left = input.len; +// self->stream.output_next = PyBytes_AS_STRING(output); +// self->stream.output_left = PyBytes_GET_SIZE(output); +// +// int output_written = 0; +// while (self->stream.input_left > 0) { +// int out_start = self->stream.total_out; +// int status = roslz4_decompress(&self->stream); +// output_written += self->stream.total_out - out_start; +// if (status == ROSLZ4_OK) { +// continue; +// } else if (status == ROSLZ4_STREAM_END) { +// break; +// } else if (status == ROSLZ4_OUTPUT_SMALL) { +// if (grow_buffer(&output) < 0) { +// goto error; +// } +// self->stream.output_next = PyBytes_AS_STRING(output) + output_written; +// self->stream.output_left = PyBytes_GET_SIZE(output) - output_written; +// } else if (status == ROSLZ4_ERROR) { +// PyErr_SetString(PyExc_IOError, "error decompressing"); +// goto error; +// } else if (status == ROSLZ4_DATA_ERROR) { +// PyErr_SetString(PyExc_IOError, "malformed data to decompress"); +// goto error; +// } else { +// PyErr_Format(PyExc_RuntimeError, "unhandled return code %i", status); +// goto error; +// } +// } +// +// if (output_written != PyBytes_GET_SIZE(output)) { +// _PyBytes_Resize(&output, output_written); +// } +// +// PyBuffer_Release(&input); +// return output; +// +//error: +// PyBuffer_Release(&input); +// Py_XDECREF(output); +// return NULL; +//} +// +//static PyMethodDef LZ4Decompressor_methods[] = { +// {"decompress", (PyCFunction)LZ4Decompressor_decompress, METH_VARARGS, "method doc"}, +// {NULL} /* Sentinel */ +//}; +// +//static PyTypeObject LZ4Decompressor_Type = { +// PyVarObject_HEAD_INIT(NULL, 0) +// "_roslz4.LZ4Decompressor", /* tp_name */ +// sizeof(LZ4Decompressor), /* tp_basicsize */ +// 0, /* tp_itemsize */ +// (destructor)LZ4Decompressor_dealloc, /* tp_dealloc */ +// 0, /* tp_print */ +// 0, /* tp_getattr */ +// 0, /* tp_setattr */ +// 0, /* tp_compare */ +// 0, /* tp_repr */ +// 0, /* tp_as_number */ +// 0, /* tp_as_sequence */ +// 0, /* tp_as_mapping */ +// 0, /* tp_hash */ +// 0, /* tp_call */ +// 0, /* tp_str */ +// 0, /* tp_getattro */ +// 0, /* tp_setattro */ +// 0, /* tp_as_buffer */ +// Py_TPFLAGS_DEFAULT, /* tp_flags */ +// "LZ4Decompressor objects", /* tp_doc */ +// 0, /* tp_traverse */ +// 0, /* tp_clear */ +// 0, /* tp_richcompare */ +// 0, /* tp_weaklistoffset */ +// 0, /* tp_iter */ +// 0, /* tp_iternext */ +// LZ4Decompressor_methods, /* tp_methods */ +// 0, /* tp_members */ +// 0, /* tp_getset */ +// 0, /* tp_base */ +// 0, /* tp_dict */ +// 0, /* tp_descr_get */ +// 0, /* tp_descr_set */ +// 0, /* tp_dictoffset */ +// (initproc)LZ4Decompressor_init /* tp_init */ +//}; +// +// +///*========================== Module initialization ==========================*/ +// +//#if PY_MAJOR_VERSION >= 3 +// +//static int roslz4_traverse(PyObject *m, visitproc visit, void *arg) { +// Py_VISIT(GETSTATE(m)->error); +// return 0; +//} +// +//static int roslz4_clear(PyObject *m) { +// Py_CLEAR(GETSTATE(m)->error); +// return 0; +//} +// +//static struct PyModuleDef moduledef = { +// PyModuleDef_HEAD_INIT, +// "_roslz4", +// NULL, +// sizeof(struct module_state), +// NULL, +// NULL, +// roslz4_traverse, +// roslz4_clear, +// NULL +//}; +//#define INITERROR return NULL +// +//PyObject * +//PyInit__roslz4(void) +// +//#else +//#define INITERROR return +// +//void +//init_roslz4(void) +//#endif +//{ +// PyObject *m; +// +// LZ4Compressor_Type.tp_new = PyType_GenericNew; +// if (PyType_Ready(&LZ4Compressor_Type) < 0) { +// INITERROR; +// } +// +// LZ4Decompressor_Type.tp_new = PyType_GenericNew; +// if (PyType_Ready(&LZ4Decompressor_Type) < 0) { +// INITERROR; +// } +// +//#if PY_MAJOR_VERSION >= 3 +// m = PyModule_Create(&moduledef); +//#else +// m = Py_InitModule("_roslz4", NULL); +//#endif +// +// if (m == NULL) { +// INITERROR; +// } +// +// Py_INCREF(&LZ4Compressor_Type); +// PyModule_AddObject(m, "LZ4Compressor", (PyObject *)&LZ4Compressor_Type); +// Py_INCREF(&LZ4Decompressor_Type); +// PyModule_AddObject(m, "LZ4Decompressor", (PyObject *)&LZ4Decompressor_Type); +// +//#if PY_MAJOR_VERSION >= 3 +// return m; +//#endif +//} diff --git a/realsense-file/3rd_party/rosbag/roslz4/src/lz4s.c b/realsense-file/3rd_party/rosbag/roslz4/src/lz4s.c new file mode 100644 index 0000000000..32fb1fc8fc --- /dev/null +++ b/realsense-file/3rd_party/rosbag/roslz4/src/lz4s.c @@ -0,0 +1,624 @@ +/********************************************************************* +* Software License Agreement (BSD License) +* +* Copyright (c) 2014, Ben Charrow +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions +* are met: +* +* * Redistributions of source code must retain the above copyright +* notice, this list of conditions and the following disclaimer. +* * Redistributions in binary form must reproduce the above +* copyright notice, this list of conditions and the following +* disclaimer in the documentation and/or other materials provided +* with the distribution. +* * Neither the name of Willow Garage, Inc. nor the names of its +* contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +********************************************************************/ + +#include "roslz4/lz4s.h" + +#include "xxhash.h" + +#include +#include +#include +#include + +#if 0 +#define DEBUG(...) fprintf(stderr, __VA_ARGS__) +#else +#define DEBUG(...) +#endif + +// magic numbers +const uint32_t kMagicNumber = 0x184D2204; +const uint32_t kEndOfStream = 0x00000000; + +// Bitmasks +const uint8_t k1Bits = 0x01; +const uint8_t k2Bits = 0x03; +const uint8_t k3Bits = 0x07; +const uint8_t k4Bits = 0x0F; +const uint8_t k8Bits = 0xFF; + +uint32_t readUInt32(unsigned char *buffer) { + return ((buffer[0] << 0) | (buffer[1] << 8) | + (buffer[2] << 16) | (buffer[3] << 24)); +} + +void writeUInt32(unsigned char *buffer, uint32_t val) { + buffer[0] = val & 0xFF; + buffer[1] = (val >> 8) & 0xFF; + buffer[2] = (val >> 16) & 0xFF; + buffer[3] = (val >> 24) & 0xFF; +} +#undef min +int min(int a, int b) { + return a < b ? a : b; +} + +/*========================== Low level compression ==========================*/ + +typedef struct { + int block_independence_flag; + int block_checksum_flag; + int stream_checksum_flag; + + char *buffer; + int buffer_size; + int buffer_offset; + + int finished; // 1 if done compressing/decompressing; 0 otherwise + + void* xxh32_state; + + // Compression state + int wrote_header; + + // Decompression state + char header[10]; + uint32_t block_size; // Size of current block + int block_size_read; // # of bytes read for current block_size + int block_uncompressed; // 1 if block is uncompressed, 0 otherwise + uint32_t stream_checksum; // Storage for checksum + int stream_checksum_read; // # of bytes read for stream_checksum +} stream_state; + +void advanceInput(roslz4_stream *str, int nbytes) { + str->input_next += nbytes; + str->input_left -= nbytes; + str->total_in += nbytes; +} + +void advanceOutput(roslz4_stream *str, int nbytes) { + str->output_next += nbytes; + str->output_left -= nbytes; + str->total_out += nbytes; +} + +void fillUInt32(roslz4_stream *str, uint32_t *dest_val, int *offset) { + char *dest = (char*) dest_val; + int to_copy = min(4 - *offset, str->input_left); + memcpy(dest + *offset, str->input_next, to_copy); + advanceInput(str, to_copy); + *offset += to_copy; +} + +int writeHeader(roslz4_stream *str) { + if (str->output_left < 7) { + return ROSLZ4_OUTPUT_SMALL; // Output must have 7 bytes + } + + stream_state *state = str->state; + writeUInt32((unsigned char*) str->output_next, kMagicNumber); + int version = 1; + char *out = str->output_next; + *(out+4) = ((unsigned)version & k2Bits) << 6; + *(out+4) |= ((unsigned)state->block_independence_flag & k1Bits) << 5; + *(out+4) |= ((unsigned)state->block_checksum_flag & k1Bits) << 4; + *(out+4) |= ((unsigned)state->stream_checksum_flag & k1Bits) << 2; + *(out+5) = ((unsigned)str->block_size_id & k3Bits) << 4; + + // Checksum: 2nd byte of hash of header flags + unsigned char checksum = (XXH32(str->output_next + 4, 2, 0) >> 8) & k8Bits; + *(str->output_next+6) = checksum; + + advanceOutput(str, 7); + DEBUG("writeHeader() Put 7 bytes in output\n"); + + return ROSLZ4_OK; +} + +int writeEOS(roslz4_stream *str) { + if (str->output_left < 8) { + return ROSLZ4_OUTPUT_SMALL; + } + + stream_state *state = str->state; + state->finished = 1; + writeUInt32((unsigned char*) str->output_next, kEndOfStream); + advanceOutput(str, 4); + + uint32_t stream_checksum = XXH32_digest(state->xxh32_state); + writeUInt32((unsigned char*) str->output_next, stream_checksum); + advanceOutput(str, 4); + state->xxh32_state = NULL; + + DEBUG("writeEOS() Wrote 8 bytes to output %i\n", str->output_left); + return ROSLZ4_STREAM_END; +} + +// If successfull, number of bytes written to output +// If error, LZ4 return code +int bufferToOutput(roslz4_stream *str) { + stream_state *state = str->state; + uint32_t uncomp_size = state->buffer_offset; + if (state->buffer_offset == 0) { + return 0; // No data to flush + } else if (str->output_left - 4 < uncomp_size) { + DEBUG("bufferToOutput() Not enough space left in output\n"); + return ROSLZ4_OUTPUT_SMALL; + } + + DEBUG("bufferToOutput() Flushing %i bytes, %i left in output\n", + state->buffer_offset, str->output_left); + + // Shrink output by 1 to detect if data is not compressible + uint32_t comp_size = LZ4_compress_limitedOutput(state->buffer, + str->output_next + 4, + (int) state->buffer_offset, + (int) uncomp_size - 1); + uint32_t wrote; + if (comp_size > 0) { + DEBUG("bufferToOutput() Compressed to %i bytes\n", comp_size); + // Write compressed data size + wrote = 4 + comp_size; + writeUInt32((unsigned char*)str->output_next, comp_size); + } else { + // Write uncompressed data + DEBUG("bufferToOutput() Can't compress, copying input\n"); + memcpy(str->output_next + 4, state->buffer, uncomp_size); + // Write uncompressed data size. Signal data is uncompressed with high + // order bit; won't confuse decompression because max block size is < 2GB + wrote = 4 + uncomp_size; + writeUInt32((unsigned char*) str->output_next, uncomp_size | 0x80000000); + } + + advanceOutput(str, wrote); + state->buffer_offset -= uncomp_size; + + DEBUG("bufferToOutput() Ate %i from buffer, wrote %i to output (%i)\n", + uncomp_size, wrote, str->output_left); + return wrote; +} + +// Copy as much data as possible from input to internal buffer +// Return number of bytes written if successful, LZ4 error code on error +int inputToBuffer(roslz4_stream *str) { + stream_state *state = str->state; + if (str->input_left == 0 || + state->buffer_size == state->buffer_offset) { + return 0; + } + int buffer_left = state->buffer_size - state->buffer_offset; + int to_copy = min(str->input_left, buffer_left); + + int ret = XXH32_update(state->xxh32_state, str->input_next, to_copy); + if (ret == XXH_ERROR) { return ROSLZ4_ERROR; } + + memcpy(state->buffer + state->buffer_offset, str->input_next, to_copy); + advanceInput(str, to_copy); + state->buffer_offset += to_copy; + + DEBUG("inputToBuffer() Wrote % 5i bytes to buffer (size=% 5i)\n", + to_copy, state->buffer_offset); + return to_copy; +} + +int streamStateAlloc(roslz4_stream *str) { + stream_state *state = (stream_state*) malloc(sizeof(stream_state)); + if (state == NULL) { + return ROSLZ4_MEMORY_ERROR; // Allocation of state failed + } + str->state = state; + + str->block_size_id = -1; + state->block_independence_flag = 1; + state->block_checksum_flag = 0; + state->stream_checksum_flag = 1; + + state->finished = 0; + + state->xxh32_state = XXH32_init(0); + state->stream_checksum = 0; + state->stream_checksum_read = 0; + + state->wrote_header = 0; + + state->buffer_offset = 0; + state->buffer_size = 0; + state->buffer = NULL; + + state->block_size = 0; + state->block_size_read = 0; + state->block_uncompressed = 0; + + str->total_in = 0; + str->total_out = 0; + + return ROSLZ4_OK; +} + +int streamResizeBuffer(roslz4_stream *str, int block_size_id) { + stream_state *state = str->state; + if (!(4 <= block_size_id && block_size_id <= 7)) { + return ROSLZ4_PARAM_ERROR; // Invalid block size + } + + str->block_size_id = block_size_id; + state->buffer_offset = 0; + state->buffer_size = roslz4_blockSizeFromIndex(str->block_size_id); + state->buffer = (char*) malloc(sizeof(char) * state->buffer_size); + if (state->buffer == NULL) { + return ROSLZ4_MEMORY_ERROR; // Allocation of buffer failed + } + return ROSLZ4_OK; +} + +void streamStateFree(roslz4_stream *str) { + stream_state *state = str->state; + if (state != NULL) { + if (state->buffer != NULL) { + free(state->buffer); + } + if (state->xxh32_state != NULL) { + XXH32_digest(state->xxh32_state); + } + free(state); + str->state = NULL; + } +} + +int roslz4_blockSizeFromIndex(int block_id) { + return (1 << (8 + (2 * block_id))); +} + +int roslz4_compressStart(roslz4_stream *str, int block_size_id) { + int ret = streamStateAlloc(str); + if (ret < 0) { return ret; } + return streamResizeBuffer(str, block_size_id); +} + +int roslz4_compress(roslz4_stream *str, int action) { + int ret; + stream_state *state = str->state; + if (action != ROSLZ4_RUN && action != ROSLZ4_FINISH) { + return ROSLZ4_PARAM_ERROR; // Unrecognized compression action + } else if (state->finished) { + return ROSLZ4_ERROR; // Cannot call action on finished stream + } + + if (!state->wrote_header) { + ret = writeHeader(str); + if (ret < 0) { return ret; } + state->wrote_header = 1; + } + + // Copy input to internal buffer, compressing when full or finishing stream + int read = 0, wrote = 0; + do { + read = inputToBuffer(str); + if (read < 0) { return read; } + + wrote = 0; + if (action == ROSLZ4_FINISH || state->buffer_offset == state->buffer_size) { + wrote = bufferToOutput(str); + if (wrote < 0) { return wrote; } + } + } while (read > 0 || wrote > 0); + + // Signal end of stream if finishing up, otherwise done + if (action == ROSLZ4_FINISH) { + return writeEOS(str); + } else { + return ROSLZ4_OK; + } +} + +void roslz4_compressEnd(roslz4_stream *str) { + streamStateFree(str); +} + +/*========================= Low level decompression =========================*/ + +int roslz4_decompressStart(roslz4_stream *str) { + return streamStateAlloc(str); + // Can't allocate internal buffer, block size is unknown until header is read +} + +// Return 1 if header is present, 0 if more data is needed, +// LZ4 error code (< 0) if error +int processHeader(roslz4_stream *str) { + stream_state *state = str->state; + if (str->total_in >= 7) { + return 1; + } + // Populate header buffer + int to_copy = min(7 - str->total_in, str->input_left); + memcpy(state->header + str->total_in, str->input_next, to_copy); + advanceInput(str, to_copy); + if (str->total_in < 7) { + return 0; + } + + // Parse header buffer + unsigned char *header = (unsigned char*) state->header; + uint32_t magic_number = readUInt32(header); + if (magic_number != kMagicNumber) { + return ROSLZ4_DATA_ERROR; // Stream does not start with magic number + } + // Check descriptor flags + int version = (header[4] >> 6) & k2Bits; + int block_independence_flag = (header[4] >> 5) & k1Bits; + int block_checksum_flag = (header[4] >> 4) & k1Bits; + int stream_size_flag = (header[4] >> 3) & k1Bits; + int stream_checksum_flag = (header[4] >> 2) & k1Bits; + int reserved1 = (header[4] >> 1) & k1Bits; + int preset_dictionary_flag = (header[4] >> 0) & k1Bits; + + int reserved2 = (header[5] >> 7) & k1Bits; + int block_max_id = (header[5] >> 4) & k3Bits; + int reserved3 = (header[5] >> 0) & k4Bits; + + // LZ4 standard requirements + if (version != 1) { + return ROSLZ4_DATA_ERROR; // Wrong version number + } + if (reserved1 != 0 || reserved2 != 0 || reserved3 != 0) { + return ROSLZ4_DATA_ERROR; // Reserved bits must be 0 + } + if (!(4 <= block_max_id && block_max_id <= 7)) { + return ROSLZ4_DATA_ERROR; // Invalid block size + } + + // Implementation requirements + if (stream_size_flag != 0) { + return ROSLZ4_DATA_ERROR; // Stream size not supported + } + if (preset_dictionary_flag != 0) { + return ROSLZ4_DATA_ERROR; // Dictionary not supported + } + if (block_independence_flag != 1) { + return ROSLZ4_DATA_ERROR; // Block dependence not supported + } + if (block_checksum_flag != 0) { + return ROSLZ4_DATA_ERROR; // Block checksums not supported + } + if (stream_checksum_flag != 1) { + return ROSLZ4_DATA_ERROR; // Must have stream checksum + } + + int header_checksum = (XXH32(header + 4, 2, 0) >> 8) & k8Bits; + int stored_header_checksum = (header[6] >> 0) & k8Bits; + if (header_checksum != stored_header_checksum) { + return ROSLZ4_DATA_ERROR; // Header checksum doesn't match + } + + int ret = streamResizeBuffer(str, block_max_id); + if (ret == ROSLZ4_OK) { + return 1; + } else { + return ret; + } +} + +// Read block size, return 1 if value is stored in state->block_size 0 otherwise +int readBlockSize(roslz4_stream *str) { + stream_state *state = str->state; + if (state->block_size_read < 4) { + fillUInt32(str, &state->block_size, &state->block_size_read); + if (state->block_size_read == 4) { + state->block_size = readUInt32((unsigned char*)&state->block_size); + state->block_uncompressed = ((unsigned)state->block_size >> 31) & k1Bits; + state->block_size &= 0x7FFFFFFF; + DEBUG("readBlockSize() Block size = %i uncompressed = %i\n", + state->block_size, state->block_uncompressed); + return 1; + } else { + return 0; + } + } + return 1; +} + +// Copy at most one blocks worth of data from input to internal buffer. +// Return 1 if whole block has been read, 0 if not, LZ4 error otherwise +int readBlock(roslz4_stream *str) { + stream_state *state = str->state; + if (state->block_size_read != 4 || state->block_size == kEndOfStream) { + return ROSLZ4_ERROR; + } + + int block_left = state->block_size - state->buffer_offset; + int to_copy = min(str->input_left, block_left); + memcpy(state->buffer + state->buffer_offset, str->input_next, to_copy); + advanceInput(str, to_copy); + state->buffer_offset += to_copy; + DEBUG("readBlock() Read %i bytes from input (block = %i/%i)\n", + to_copy, state->buffer_offset, state->block_size); + return state->buffer_offset == state->block_size; +} + +int decompressBlock(roslz4_stream *str) { + stream_state *state = str->state; + if (state->block_size_read != 4 || state->block_size != state->buffer_offset) { + // Internal error: Can't decompress block, it's not in buffer + return ROSLZ4_ERROR; + } + + if (state->block_uncompressed) { + if (str->output_left >= state->block_size) { + memcpy(str->output_next, state->buffer, state->block_size); + int ret = XXH32_update(state->xxh32_state, str->output_next, + state->block_size); + if (ret == XXH_ERROR) { return ROSLZ4_ERROR; } + advanceOutput(str, state->block_size); + state->block_size_read = 0; + state->buffer_offset = 0; + return ROSLZ4_OK; + } else { + return ROSLZ4_OUTPUT_SMALL; + } + } else { + int decomp_size; + decomp_size = LZ4_decompress_safe(state->buffer, str->output_next, + state->block_size, str->output_left); + if (decomp_size < 0) { + if (str->output_left >= state->buffer_size) { + return ROSLZ4_DATA_ERROR; // Must be a problem with the data stream + } else { + // Data error or output is small; increase output to disambiguate + return ROSLZ4_OUTPUT_SMALL; + } + } else { + int ret = XXH32_update(state->xxh32_state, str->output_next, decomp_size); + if (ret == XXH_ERROR) { return ROSLZ4_ERROR; } + advanceOutput(str, decomp_size); + state->block_size_read = 0; + state->buffer_offset = 0; + return ROSLZ4_OK; + } + } +} + +int readChecksum(roslz4_stream *str) { + stream_state *state = str->state; + fillUInt32(str, &state->stream_checksum, &state->stream_checksum_read); + if (state->stream_checksum_read == 4) { + state->finished = 1; + state->stream_checksum = readUInt32((unsigned char*)&state->stream_checksum); + uint32_t checksum = XXH32_digest(state->xxh32_state); + state->xxh32_state = NULL; + if (checksum == state->stream_checksum) { + return ROSLZ4_STREAM_END; + } else { + return ROSLZ4_DATA_ERROR; + } + } + return ROSLZ4_OK; +} + +int roslz4_decompress(roslz4_stream *str) { + stream_state *state = str->state; + if (state->finished) { + return ROSLZ4_ERROR; // Already reached end of stream + } + + // Return if header isn't present or error was encountered + int ret = processHeader(str); + if (ret <= 0) { + return ret; + } + + // Read in blocks and decompress them as long as there's data to be processed + while (str->input_left > 0) { + ret = readBlockSize(str); + if (ret == 0) { return ROSLZ4_OK; } + + if (state->block_size == kEndOfStream) { + return readChecksum(str); + } + + ret = readBlock(str); + if (ret == 0) { return ROSLZ4_OK; } + else if (ret < 0) { return ret; } + + ret = decompressBlock(str); + if (ret < 0) { return ret; } + } + return ROSLZ4_OK; +} + +void roslz4_decompressEnd(roslz4_stream *str) { + streamStateFree(str); +} + +/*=================== Oneshot compression / decompression ===================*/ + +int roslz4_buffToBuffCompress(char *input, unsigned int input_size, + char *output, unsigned int *output_size, + int block_size_id) { + roslz4_stream stream; + stream.input_next = input; + stream.input_left = input_size; + stream.output_next = output; + stream.output_left = *output_size; + + int ret; + ret = roslz4_compressStart(&stream, block_size_id); + if (ret != ROSLZ4_OK) { return ret; } + + while (stream.input_left > 0 && ret != ROSLZ4_STREAM_END) { + ret = roslz4_compress(&stream, ROSLZ4_FINISH); + if (ret == ROSLZ4_ERROR || ret == ROSLZ4_OUTPUT_SMALL) { + roslz4_compressEnd(&stream); + return ret; + } + } + + *output_size = *output_size - stream.output_left; + roslz4_compressEnd(&stream); + + if (stream.input_left == 0 && ret == ROSLZ4_STREAM_END) { + return ROSLZ4_OK; // Success + } else { + return ROSLZ4_ERROR; // User did not provide exact buffer + } +} + +int roslz4_buffToBuffDecompress(char *input, unsigned int input_size, + char *output, unsigned int *output_size) { + roslz4_stream stream; + stream.input_next = input; + stream.input_left = input_size; + stream.output_next = output; + stream.output_left = *output_size; + + int ret; + ret = roslz4_decompressStart(&stream); + if (ret != ROSLZ4_OK) { return ret; } + + while (stream.input_left > 0 && ret != ROSLZ4_STREAM_END) { + ret = roslz4_decompress(&stream); + if (ret < 0) { + roslz4_decompressEnd(&stream); + return ret; + } + } + + *output_size = *output_size - stream.output_left; + roslz4_decompressEnd(&stream); + + if (stream.input_left == 0 && ret == ROSLZ4_STREAM_END) { + return ROSLZ4_OK; // Success + } else { + return ROSLZ4_ERROR; // User did not provide exact buffer + } +} diff --git a/realsense-file/3rd_party/rosbag/roslz4/src/xxhash.c b/realsense-file/3rd_party/rosbag/roslz4/src/xxhash.c new file mode 100644 index 0000000000..8304ec21c0 --- /dev/null +++ b/realsense-file/3rd_party/rosbag/roslz4/src/xxhash.c @@ -0,0 +1,475 @@ +/* +xxHash - Fast Hash algorithm +Copyright (C) 2012-2014, Yann Collet. +BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php) + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + +* Redistributions of source code must retain the above copyright +notice, this list of conditions and the following disclaimer. +* Redistributions in binary form must reproduce the above +copyright notice, this list of conditions and the following disclaimer +in the documentation and/or other materials provided with the +distribution. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +You can contact the author at : +- xxHash source repository : http://code.google.com/p/xxhash/ +*/ + + +//************************************** +// Tuning parameters +//************************************** +// Unaligned memory access is automatically enabled for "common" CPU, such as x86. +// For others CPU, the compiler will be more cautious, and insert extra code to ensure aligned access is respected. +// If you know your target CPU supports unaligned memory access, you want to force this option manually to improve performance. +// You can also enable this parameter if you know your input data will always be aligned (boundaries of 4, for U32). +#if defined(__ARM_FEATURE_UNALIGNED) || defined(__i386) || defined(_M_IX86) || defined(__x86_64__) || defined(_M_X64) +# define XXH_USE_UNALIGNED_ACCESS 1 +#endif + +// XXH_ACCEPT_NULL_INPUT_POINTER : +// If the input pointer is a null pointer, xxHash default behavior is to trigger a memory access error, since it is a bad pointer. +// When this option is enabled, xxHash output for null input pointers will be the same as a null-length input. +// This option has a very small performance cost (only measurable on small inputs). +// By default, this option is disabled. To enable it, uncomment below define : +//#define XXH_ACCEPT_NULL_INPUT_POINTER 1 + +// XXH_FORCE_NATIVE_FORMAT : +// By default, xxHash library provides endian-independant Hash values, based on little-endian convention. +// Results are therefore identical for little-endian and big-endian CPU. +// This comes at a performance cost for big-endian CPU, since some swapping is required to emulate little-endian format. +// Should endian-independance be of no importance for your application, you may set the #define below to 1. +// It will improve speed for Big-endian CPU. +// This option has no impact on Little_Endian CPU. +#define XXH_FORCE_NATIVE_FORMAT 0 + + +//************************************** +// Compiler Specific Options +//************************************** +// Disable some Visual warning messages +#ifdef _MSC_VER // Visual Studio +# pragma warning(disable : 4127) // disable: C4127: conditional expression is constant +#endif + +#ifdef _MSC_VER // Visual Studio +# define FORCE_INLINE static __forceinline +#else +# ifdef __GNUC__ +# define FORCE_INLINE static inline __attribute__((always_inline)) +# else +# define FORCE_INLINE static inline +# endif +#endif + + +//************************************** +// Includes & Memory related functions +//************************************** +#include "xxhash.h" +// Modify the local functions below should you wish to use some other memory related routines +// for malloc(), free() +#include +FORCE_INLINE void* XXH_malloc(size_t s) { return malloc(s); } +FORCE_INLINE void XXH_free (void* p) { free(p); } +// for memcpy() +#include +FORCE_INLINE void* XXH_memcpy(void* dest, const void* src, size_t size) { return memcpy(dest,src,size); } + + +//************************************** +// Basic Types +//************************************** +#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L // C99 +# include + typedef uint8_t BYTE; + typedef uint16_t U16; + typedef uint32_t U32; + typedef int32_t S32; + typedef uint64_t U64; +#else + typedef unsigned char BYTE; + typedef unsigned short U16; + typedef unsigned int U32; + typedef signed int S32; + typedef unsigned long long U64; +#endif + +#if defined(__GNUC__) && !defined(XXH_USE_UNALIGNED_ACCESS) +# define _PACKED __attribute__ ((packed)) +#else +# define _PACKED +#endif + +#if !defined(XXH_USE_UNALIGNED_ACCESS) && !defined(__GNUC__) +# ifdef __IBMC__ +# pragma pack(1) +# else +# pragma pack(push, 1) +# endif +#endif + +typedef struct _U32_S { U32 v; } _PACKED U32_S; + +#if !defined(XXH_USE_UNALIGNED_ACCESS) && !defined(__GNUC__) +# pragma pack(pop) +#endif + +#define A32(x) (((U32_S *)(x))->v) + + +//*************************************** +// Compiler-specific Functions and Macros +//*************************************** +#define GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__) + +// Note : although _rotl exists for minGW (GCC under windows), performance seems poor +#if defined(_MSC_VER) +# define XXH_rotl32(x,r) _rotl(x,r) +#else +# define XXH_rotl32(x,r) ((x << r) | (x >> (32 - r))) +#endif + +#if defined(_MSC_VER) // Visual Studio +# define XXH_swap32 _byteswap_ulong +#elif GCC_VERSION >= 403 +# define XXH_swap32 __builtin_bswap32 +#else +static inline U32 XXH_swap32 (U32 x) { + return ((x << 24) & 0xff000000 ) | + ((x << 8) & 0x00ff0000 ) | + ((x >> 8) & 0x0000ff00 ) | + ((x >> 24) & 0x000000ff );} +#endif + + +//************************************** +// Constants +//************************************** +#define PRIME32_1 2654435761U +#define PRIME32_2 2246822519U +#define PRIME32_3 3266489917U +#define PRIME32_4 668265263U +#define PRIME32_5 374761393U + + +//************************************** +// Architecture Macros +//************************************** +typedef enum { XXH_bigEndian=0, XXH_littleEndian=1 } XXH_endianess; +#ifndef XXH_CPU_LITTLE_ENDIAN // It is possible to define XXH_CPU_LITTLE_ENDIAN externally, for example using a compiler switch + static const int one = 1; +# define XXH_CPU_LITTLE_ENDIAN (*(char*)(&one)) +#endif + + +//************************************** +// Macros +//************************************** +#define XXH_STATIC_ASSERT(c) { enum { XXH_static_assert = 1/(!!(c)) }; } // use only *after* variable declarations + + +//**************************** +// Memory reads +//**************************** +typedef enum { XXH_aligned, XXH_unaligned } XXH_alignment; + +FORCE_INLINE U32 XXH_readLE32_align(const U32* ptr, XXH_endianess endian, XXH_alignment align) +{ + if (align==XXH_unaligned) + return endian==XXH_littleEndian ? A32(ptr) : XXH_swap32(A32(ptr)); + else + return endian==XXH_littleEndian ? *ptr : XXH_swap32(*ptr); +} + +FORCE_INLINE U32 XXH_readLE32(const U32* ptr, XXH_endianess endian) { return XXH_readLE32_align(ptr, endian, XXH_unaligned); } + + +//**************************** +// Simple Hash Functions +//**************************** +FORCE_INLINE U32 XXH32_endian_align(const void* input, int len, U32 seed, XXH_endianess endian, XXH_alignment align) +{ + const BYTE* p = (const BYTE*)input; + const BYTE* const bEnd = p + len; + U32 h32; + +#ifdef XXH_ACCEPT_NULL_INPUT_POINTER + if (p==NULL) { len=0; p=(const BYTE*)(size_t)16; } +#endif + + if (len>=16) + { + const BYTE* const limit = bEnd - 16; + U32 v1 = seed + PRIME32_1 + PRIME32_2; + U32 v2 = seed + PRIME32_2; + U32 v3 = seed + 0; + U32 v4 = seed - PRIME32_1; + + do + { + v1 += XXH_readLE32_align((const U32*)p, endian, align) * PRIME32_2; v1 = XXH_rotl32(v1, 13); v1 *= PRIME32_1; p+=4; + v2 += XXH_readLE32_align((const U32*)p, endian, align) * PRIME32_2; v2 = XXH_rotl32(v2, 13); v2 *= PRIME32_1; p+=4; + v3 += XXH_readLE32_align((const U32*)p, endian, align) * PRIME32_2; v3 = XXH_rotl32(v3, 13); v3 *= PRIME32_1; p+=4; + v4 += XXH_readLE32_align((const U32*)p, endian, align) * PRIME32_2; v4 = XXH_rotl32(v4, 13); v4 *= PRIME32_1; p+=4; + } while (p<=limit); + + h32 = XXH_rotl32(v1, 1) + XXH_rotl32(v2, 7) + XXH_rotl32(v3, 12) + XXH_rotl32(v4, 18); + } + else + { + h32 = seed + PRIME32_5; + } + + h32 += (U32) len; + + while (p<=bEnd-4) + { + h32 += XXH_readLE32_align((const U32*)p, endian, align) * PRIME32_3; + h32 = XXH_rotl32(h32, 17) * PRIME32_4 ; + p+=4; + } + + while (p> 15; + h32 *= PRIME32_2; + h32 ^= h32 >> 13; + h32 *= PRIME32_3; + h32 ^= h32 >> 16; + + return h32; +} + + +U32 XXH32(const void* input, int len, U32 seed) +{ +#if 0 + // Simple version, good for code maintenance, but unfortunately slow for small inputs + void* state = XXH32_init(seed); + XXH32_update(state, input, len); + return XXH32_digest(state); +#else + XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN; + +# if !defined(XXH_USE_UNALIGNED_ACCESS) + if ((((size_t)input) & 3)) // Input is aligned, let's leverage the speed advantage + { + if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT) + return XXH32_endian_align(input, len, seed, XXH_littleEndian, XXH_aligned); + else + return XXH32_endian_align(input, len, seed, XXH_bigEndian, XXH_aligned); + } +# endif + + if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT) + return XXH32_endian_align(input, len, seed, XXH_littleEndian, XXH_unaligned); + else + return XXH32_endian_align(input, len, seed, XXH_bigEndian, XXH_unaligned); +#endif +} + + +//**************************** +// Advanced Hash Functions +//**************************** + +struct XXH_state32_t +{ + U64 total_len; + U32 seed; + U32 v1; + U32 v2; + U32 v3; + U32 v4; + int memsize; + char memory[16]; +}; + + +int XXH32_sizeofState() +{ + XXH_STATIC_ASSERT(XXH32_SIZEOFSTATE >= sizeof(struct XXH_state32_t)); // A compilation error here means XXH32_SIZEOFSTATE is not large enough + return sizeof(struct XXH_state32_t); +} + + +XXH_errorcode XXH32_resetState(void* state_in, U32 seed) +{ + struct XXH_state32_t * state = (struct XXH_state32_t *) state_in; + state->seed = seed; + state->v1 = seed + PRIME32_1 + PRIME32_2; + state->v2 = seed + PRIME32_2; + state->v3 = seed + 0; + state->v4 = seed - PRIME32_1; + state->total_len = 0; + state->memsize = 0; + return XXH_OK; +} + + +void* XXH32_init (U32 seed) +{ + void* state = XXH_malloc (sizeof(struct XXH_state32_t)); + XXH32_resetState(state, seed); + return state; +} + + +FORCE_INLINE XXH_errorcode XXH32_update_endian (void* state_in, const void* input, int len, XXH_endianess endian) +{ + struct XXH_state32_t * state = (struct XXH_state32_t *) state_in; + const BYTE* p = (const BYTE*)input; + const BYTE* const bEnd = p + len; + +#ifdef XXH_ACCEPT_NULL_INPUT_POINTER + if (input==NULL) return XXH_ERROR; +#endif + + state->total_len += len; + + if (state->memsize + len < 16) // fill in tmp buffer + { + XXH_memcpy(state->memory + state->memsize, input, len); + state->memsize += len; + return XXH_OK; + } + + if (state->memsize) // some data left from previous update + { + XXH_memcpy(state->memory + state->memsize, input, 16-state->memsize); + { + const U32* p32 = (const U32*)state->memory; + state->v1 += XXH_readLE32(p32, endian) * PRIME32_2; state->v1 = XXH_rotl32(state->v1, 13); state->v1 *= PRIME32_1; p32++; + state->v2 += XXH_readLE32(p32, endian) * PRIME32_2; state->v2 = XXH_rotl32(state->v2, 13); state->v2 *= PRIME32_1; p32++; + state->v3 += XXH_readLE32(p32, endian) * PRIME32_2; state->v3 = XXH_rotl32(state->v3, 13); state->v3 *= PRIME32_1; p32++; + state->v4 += XXH_readLE32(p32, endian) * PRIME32_2; state->v4 = XXH_rotl32(state->v4, 13); state->v4 *= PRIME32_1; p32++; + } + p += 16-state->memsize; + state->memsize = 0; + } + + if (p <= bEnd-16) + { + const BYTE* const limit = bEnd - 16; + U32 v1 = state->v1; + U32 v2 = state->v2; + U32 v3 = state->v3; + U32 v4 = state->v4; + + do + { + v1 += XXH_readLE32((const U32*)p, endian) * PRIME32_2; v1 = XXH_rotl32(v1, 13); v1 *= PRIME32_1; p+=4; + v2 += XXH_readLE32((const U32*)p, endian) * PRIME32_2; v2 = XXH_rotl32(v2, 13); v2 *= PRIME32_1; p+=4; + v3 += XXH_readLE32((const U32*)p, endian) * PRIME32_2; v3 = XXH_rotl32(v3, 13); v3 *= PRIME32_1; p+=4; + v4 += XXH_readLE32((const U32*)p, endian) * PRIME32_2; v4 = XXH_rotl32(v4, 13); v4 *= PRIME32_1; p+=4; + } while (p<=limit); + + state->v1 = v1; + state->v2 = v2; + state->v3 = v3; + state->v4 = v4; + } + + if (p < bEnd) + { + XXH_memcpy(state->memory, p, bEnd-p); + state->memsize = (int)(bEnd-p); + } + + return XXH_OK; +} + +XXH_errorcode XXH32_update (void* state_in, const void* input, int len) +{ + XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN; + + if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT) + return XXH32_update_endian(state_in, input, len, XXH_littleEndian); + else + return XXH32_update_endian(state_in, input, len, XXH_bigEndian); +} + + + +FORCE_INLINE U32 XXH32_intermediateDigest_endian (void* state_in, XXH_endianess endian) +{ + struct XXH_state32_t * state = (struct XXH_state32_t *) state_in; + const BYTE * p = (const BYTE*)state->memory; + BYTE* bEnd = (BYTE*)state->memory + state->memsize; + U32 h32; + + if (state->total_len >= 16) + { + h32 = XXH_rotl32(state->v1, 1) + XXH_rotl32(state->v2, 7) + XXH_rotl32(state->v3, 12) + XXH_rotl32(state->v4, 18); + } + else + { + h32 = state->seed + PRIME32_5; + } + + h32 += (U32) state->total_len; + + while (p<=bEnd-4) + { + h32 += XXH_readLE32((const U32*)p, endian) * PRIME32_3; + h32 = XXH_rotl32(h32, 17) * PRIME32_4; + p+=4; + } + + while (p> 15; + h32 *= PRIME32_2; + h32 ^= h32 >> 13; + h32 *= PRIME32_3; + h32 ^= h32 >> 16; + + return h32; +} + + +U32 XXH32_intermediateDigest (void* state_in) +{ + XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN; + + if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT) + return XXH32_intermediateDigest_endian(state_in, XXH_littleEndian); + else + return XXH32_intermediateDigest_endian(state_in, XXH_bigEndian); +} + + +U32 XXH32_digest (void* state_in) +{ + U32 h32 = XXH32_intermediateDigest(state_in); + + XXH_free(state_in); + + return h32; +} diff --git a/realsense-file/3rd_party/rosbag/roslz4/src/xxhash.h b/realsense-file/3rd_party/rosbag/roslz4/src/xxhash.h new file mode 100644 index 0000000000..a319bcc9b3 --- /dev/null +++ b/realsense-file/3rd_party/rosbag/roslz4/src/xxhash.h @@ -0,0 +1,164 @@ +/* + xxHash - Fast Hash algorithm + Header File + Copyright (C) 2012-2014, Yann Collet. + BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php) + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are + met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following disclaimer + in the documentation and/or other materials provided with the + distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + You can contact the author at : + - xxHash source repository : http://code.google.com/p/xxhash/ +*/ + +/* Notice extracted from xxHash homepage : + +xxHash is an extremely fast Hash algorithm, running at RAM speed limits. +It also successfully passes all tests from the SMHasher suite. + +Comparison (single thread, Windows Seven 32 bits, using SMHasher on a Core 2 Duo @3GHz) + +Name Speed Q.Score Author +xxHash 5.4 GB/s 10 +CrapWow 3.2 GB/s 2 Andrew +MumurHash 3a 2.7 GB/s 10 Austin Appleby +SpookyHash 2.0 GB/s 10 Bob Jenkins +SBox 1.4 GB/s 9 Bret Mulvey +Lookup3 1.2 GB/s 9 Bob Jenkins +SuperFastHash 1.2 GB/s 1 Paul Hsieh +CityHash64 1.05 GB/s 10 Pike & Alakuijala +FNV 0.55 GB/s 5 Fowler, Noll, Vo +CRC32 0.43 GB/s 9 +MD5-32 0.33 GB/s 10 Ronald L. Rivest +SHA1-32 0.28 GB/s 10 + +Q.Score is a measure of quality of the hash function. +It depends on successfully passing SMHasher test set. +10 is a perfect score. +*/ + +#pragma once + +#if defined (__cplusplus) +extern "C" { +#endif + + +//**************************** +// Type +//**************************** +typedef enum { XXH_OK=0, XXH_ERROR } XXH_errorcode; + + + +//**************************** +// Simple Hash Functions +//**************************** + +unsigned int XXH32 (const void* input, int len, unsigned int seed); + +/* +XXH32() : + Calculate the 32-bits hash of sequence of length "len" stored at memory address "input". + The memory between input & input+len must be valid (allocated and read-accessible). + "seed" can be used to alter the result predictably. + This function successfully passes all SMHasher tests. + Speed on Core 2 Duo @ 3 GHz (single thread, SMHasher benchmark) : 5.4 GB/s + Note that "len" is type "int", which means it is limited to 2^31-1. + If your data is larger, use the advanced functions below. +*/ + + + +//**************************** +// Advanced Hash Functions +//**************************** + +void* XXH32_init (unsigned int seed); +XXH_errorcode XXH32_update (void* state, const void* input, int len); +unsigned int XXH32_digest (void* state); + +/* +These functions calculate the xxhash of an input provided in several small packets, +as opposed to an input provided as a single block. + +It must be started with : +void* XXH32_init() +The function returns a pointer which holds the state of calculation. + +This pointer must be provided as "void* state" parameter for XXH32_update(). +XXH32_update() can be called as many times as necessary. +The user must provide a valid (allocated) input. +The function returns an error code, with 0 meaning OK, and any other value meaning there is an error. +Note that "len" is type "int", which means it is limited to 2^31-1. +If your data is larger, it is recommended to chunk your data into blocks +of size for example 2^30 (1GB) to avoid any "int" overflow issue. + +Finally, you can end the calculation anytime, by using XXH32_digest(). +This function returns the final 32-bits hash. +You must provide the same "void* state" parameter created by XXH32_init(). +Memory will be freed by XXH32_digest(). +*/ + + +int XXH32_sizeofState(); +XXH_errorcode XXH32_resetState(void* state, unsigned int seed); + +#define XXH32_SIZEOFSTATE 48 +typedef struct { long long ll[(XXH32_SIZEOFSTATE+(sizeof(long long)-1))/sizeof(long long)]; } XXH32_stateSpace_t; +/* +These functions allow user application to make its own allocation for state. + +XXH32_sizeofState() is used to know how much space must be allocated for the xxHash 32-bits state. +Note that the state must be aligned to access 'long long' fields. Memory must be allocated and referenced by a pointer. +This pointer must then be provided as 'state' into XXH32_resetState(), which initializes the state. + +For static allocation purposes (such as allocation on stack, or freestanding systems without malloc()), +use the structure XXH32_stateSpace_t, which will ensure that memory space is large enough and correctly aligned to access 'long long' fields. +*/ + + +unsigned int XXH32_intermediateDigest (void* state); +/* +This function does the same as XXH32_digest(), generating a 32-bit hash, +but preserve memory context. +This way, it becomes possible to generate intermediate hashes, and then continue feeding data with XXH32_update(). +To free memory context, use XXH32_digest(), or free(). +*/ + + + +//**************************** +// Deprecated function names +//**************************** +// The following translations are provided to ease code transition +// You are encouraged to no longer this function names +#define XXH32_feed XXH32_update +#define XXH32_result XXH32_digest +#define XXH32_getIntermediateResult XXH32_intermediateDigest + + + +#if defined (__cplusplus) +} +#endif diff --git a/realsense-file/3rd_party/rosbag/rostime/config.cmake b/realsense-file/3rd_party/rosbag/rostime/config.cmake new file mode 100644 index 0000000000..9489ee3918 --- /dev/null +++ b/realsense-file/3rd_party/rosbag/rostime/config.cmake @@ -0,0 +1,17 @@ +cmake_minimum_required(VERSION 2.8.3) + +set(HEADER_FILES_ROSTIME + rosbag/rostime/include/ros/duration.h + rosbag/rostime/include/ros/impl + rosbag/rostime/include/ros/rate.h + rosbag/rostime/include/ros/rostime_decl.h + rosbag/rostime/include/ros/time.h + rosbag/rostime/include/ros/impl/time.h + rosbag/rostime/include/ros/impl/duration.h +) + +set(SOURCE_FILES_ROSTIME + rosbag/rostime/src/duration.cpp + rosbag/rostime/src/rate.cpp + rosbag/rostime/src/time.cpp +) diff --git a/realsense-file/3rd_party/rosbag/rostime/include/ros/duration.h b/realsense-file/3rd_party/rosbag/rostime/include/ros/duration.h new file mode 100644 index 0000000000..094d9c716f --- /dev/null +++ b/realsense-file/3rd_party/rosbag/rostime/include/ros/duration.h @@ -0,0 +1,164 @@ +/********************************************************************* +* Software License Agreement (BSD License) +* +* Copyright (c) 2008, Willow Garage, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions +* are met: +* +* * Redistributions of source code must retain the above copyright +* notice, this list of conditions and the following disclaimer. +* * Redistributions in binary form must reproduce the above +* copyright notice, this list of conditions and the following +* disclaimer in the documentation and/or other materials provided +* with the distribution. +* * Neither the name of Willow Garage, Inc. nor the names of its +* contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*********************************************************************/ + +#ifndef ROS_DURATION_H +#define ROS_DURATION_H + +/********************************************************************* + ** Pragmas + *********************************************************************/ + +#ifdef _MSC_VER + // Rostime has some magic interface that doesn't directly include + // its implementation, this just disbales those warnings. + #pragma warning(disable: 4244) + #pragma warning(disable: 4661) +#endif + +#include +#include +#include +#include +#include +#include "rostime_decl.h" + +namespace boost { + namespace posix_time { + class time_duration; + } +} + +namespace ros +{ +ROSTIME_DECL void normalizeSecNSecSigned(int64_t& sec, int64_t& nsec); +ROSTIME_DECL void normalizeSecNSecSigned(int32_t& sec, int32_t& nsec); + +/** + * \brief Base class for Duration implementations. Provides storage, common functions and operator overloads. + * This should not need to be used directly. + */ +template +class DurationBase +{ +public: + int32_t sec, nsec; + DurationBase() : sec(0), nsec(0) { } + DurationBase(int32_t _sec, int32_t _nsec); + explicit DurationBase(double t){fromSec(t);}; + ~DurationBase() {} + T operator+(const T &rhs) const; + T operator-(const T &rhs) const; + T operator-() const; + T operator*(double scale) const; + T& operator+=(const T &rhs); + T& operator-=(const T &rhs); + T& operator*=(double scale); + bool operator==(const T &rhs) const; + inline bool operator!=(const T &rhs) const { return !(*static_cast(this) == rhs); } + bool operator>(const T &rhs) const; + bool operator<(const T &rhs) const; + bool operator>=(const T &rhs) const; + bool operator<=(const T &rhs) const; + double toSec() const { return (double)sec + 1e-9*(double)nsec; }; + int64_t toNSec() const {return (int64_t)sec*1000000000ll + (int64_t)nsec; }; + T& fromSec(double t); + T& fromNSec(int64_t t); + bool isZero() const; + //boost::posix_time::time_duration toBoost() const; +}; + +class Rate; + +/** + * \brief Duration representation for use with the Time class. + * + * ros::DurationBase provides most of its functionality. + */ +class ROSTIME_DECL Duration : public DurationBase +{ +public: + Duration() + : DurationBase() + { } + + Duration(int32_t _sec, int32_t _nsec) + : DurationBase(_sec, _nsec) + {} + + explicit Duration(double t) { fromSec(t); } + explicit Duration(const Rate&); + /** + * \brief sleep for the amount of time specified by this Duration. If a signal interrupts the sleep, resleeps for the time remaining. + * @return True if the desired sleep duration was met, false otherwise. + */ + bool sleep() const; +}; + +extern ROSTIME_DECL const Duration DURATION_MAX; +extern ROSTIME_DECL const Duration DURATION_MIN; + +/** + * \brief Duration representation for use with the WallTime class. + * + * ros::DurationBase provides most of its functionality. + */ +class ROSTIME_DECL WallDuration : public DurationBase +{ +public: + WallDuration() + : DurationBase() + { } + + WallDuration(int32_t _sec, int32_t _nsec) + : DurationBase(_sec, _nsec) + {} + + explicit WallDuration(double t) { fromSec(t); } + explicit WallDuration(const Rate&); + /** + * \brief sleep for the amount of time specified by this Duration. If a signal interrupts the sleep, resleeps for the time remaining. + * @return True if the desired sleep duration was met, false otherwise. + */ + bool sleep() const; +}; + +std::ostream &operator <<(std::ostream &os, const Duration &rhs); +std::ostream &operator <<(std::ostream &os, const WallDuration &rhs); + + +} + +#endif // ROS_DURATION_H + + diff --git a/realsense-file/3rd_party/rosbag/rostime/include/ros/impl/duration.h b/realsense-file/3rd_party/rosbag/rostime/include/ros/impl/duration.h new file mode 100644 index 0000000000..347eb14f15 --- /dev/null +++ b/realsense-file/3rd_party/rosbag/rostime/include/ros/impl/duration.h @@ -0,0 +1,180 @@ +/********************************************************************* + * Software License Agreement (BSD License) + * + * Copyright (c) 2010, Willow Garage, Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials provided + * with the distribution. + * * Neither the name of Willow Garage, Inc. nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN + * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + *********************************************************************/ +#ifndef ROSTIME_IMPL_DURATION_H_INCLUDED +#define ROSTIME_IMPL_DURATION_H_INCLUDED + +#include +#include +//#include + +namespace ros { + // + // DurationBase template member function implementation + // + template + DurationBase::DurationBase(int32_t _sec, int32_t _nsec) + : sec(_sec), nsec(_nsec) + { + normalizeSecNSecSigned(sec, nsec); + } + + template + T& DurationBase::fromSec(double d) + { + sec = (int32_t)floor(d); + nsec = (int32_t)((d - (double)sec)*1000000000); + return *static_cast(this); + } + + template + T& DurationBase::fromNSec(int64_t t) + { + sec = (int32_t)(t / 1000000000); + nsec = (int32_t)(t % 1000000000); + + normalizeSecNSecSigned(sec, nsec); + + return *static_cast(this); + } + + template + T DurationBase::operator+(const T &rhs) const + { + return T(sec + rhs.sec, nsec + rhs.nsec); + } + + template + T DurationBase::operator*(double scale) const + { + return T(toSec() * scale); + } + + template + T DurationBase::operator-(const T &rhs) const + { + return T(sec - rhs.sec, nsec - rhs.nsec); + } + + template + T DurationBase::operator-() const + { + return T(-sec , -nsec); + } + + template + T& DurationBase::operator+=(const T &rhs) + { + *this = *this + rhs; + return *static_cast(this); + } + + template + T& DurationBase::operator-=(const T &rhs) + { + *this += (-rhs); + return *static_cast(this); + } + + template + T& DurationBase::operator*=(double scale) + { + fromSec(toSec() * scale); + return *static_cast(this); + } + + template + bool DurationBase::operator<(const T &rhs) const + { + if (sec < rhs.sec) + return true; + else if (sec == rhs.sec && nsec < rhs.nsec) + return true; + return false; + } + + template + bool DurationBase::operator>(const T &rhs) const + { + if (sec > rhs.sec) + return true; + else if (sec == rhs.sec && nsec > rhs.nsec) + return true; + return false; + } + + template + bool DurationBase::operator<=(const T &rhs) const + { + if (sec < rhs.sec) + return true; + else if (sec == rhs.sec && nsec <= rhs.nsec) + return true; + return false; + } + + template + bool DurationBase::operator>=(const T &rhs) const + { + if (sec > rhs.sec) + return true; + else if (sec == rhs.sec && nsec >= rhs.nsec) + return true; + return false; + } + + template + bool DurationBase::operator==(const T &rhs) const + { + return sec == rhs.sec && nsec == rhs.nsec; + } + + template + bool DurationBase::isZero() const + { + return sec == 0 && nsec == 0; + } + + /* template + boost::posix_time::time_duration*/ + /* DurationBase::toBoost() const + { + namespace bt = boost::posix_time; +#if defined(BOOST_DATE_TIME_HAS_NANOSECONDS) + return bt::seconds(sec) + bt::nanoseconds(nsec); +#else + return bt::seconds(static_cast(sec)) + bt::microseconds(static_cast(nsec/1000.0)); +#endif + }*/ +} +#endif diff --git a/realsense-file/3rd_party/rosbag/rostime/include/ros/impl/time.h b/realsense-file/3rd_party/rosbag/rostime/include/ros/impl/time.h new file mode 100644 index 0000000000..dd7101e06e --- /dev/null +++ b/realsense-file/3rd_party/rosbag/rostime/include/ros/impl/time.h @@ -0,0 +1,178 @@ +/********************************************************************* +* Software License Agreement (BSD License) +* +* Copyright (c) 2008, Willow Garage, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions +* are met: +* +* * Redistributions of source code must retain the above copyright +* notice, this list of conditions and the following disclaimer. +* * Redistributions in binary form must reproduce the above +* copyright notice, this list of conditions and the following +* disclaimer in the documentation and/or other materials provided +* with the distribution. +* * Neither the name of Willow Garage, Inc. nor the names of its +* contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*********************************************************************/ + +#ifndef ROS_TIME_IMPL_H_INCLUDED +#define ROS_TIME_IMPL_H_INCLUDED + +/********************************************************************* +** Headers +*********************************************************************/ + +#include +#include +#include +#include +#include +//#include + +/********************************************************************* +** Cross Platform Headers +*********************************************************************/ + +#ifdef WIN32 + #include +#else + #include +#endif + +namespace ros +{ + + template + T& TimeBase::fromNSec(uint64_t t) + { + uint64_t sec64 = 0; + uint64_t nsec64 = t; + + normalizeSecNSec(sec64, nsec64); + + sec = (uint32_t)sec64; + nsec = (uint32_t)nsec64; + + return *static_cast(this); + } + + template + D TimeBase::operator-(const T &rhs) const + { + return D((int32_t)sec - (int32_t)rhs.sec, + (int32_t)nsec - (int32_t)rhs.nsec); // carry handled in ctor + } + + template + T TimeBase::operator-(const D &rhs) const + { + return *static_cast(this) + ( -rhs); + } + + template + T TimeBase::operator+(const D &rhs) const + { + int64_t sec_sum = (int64_t)sec + (int64_t)rhs.sec; + int64_t nsec_sum = (int64_t)nsec + (int64_t)rhs.nsec; + + // Throws an exception if we go out of 32-bit range + normalizeSecNSecUnsigned(sec_sum, nsec_sum); + + // now, it's safe to downcast back to uint32 bits + return T((uint32_t)sec_sum, (uint32_t)nsec_sum); + } + + template + T& TimeBase::operator+=(const D &rhs) + { + *this = *this + rhs; + return *static_cast(this); + } + + template + T& TimeBase::operator-=(const D &rhs) + { + *this += (-rhs); + return *static_cast(this); + } + + template + bool TimeBase::operator==(const T &rhs) const + { + return sec == rhs.sec && nsec == rhs.nsec; + } + + template + bool TimeBase::operator<(const T &rhs) const + { + if (sec < rhs.sec) + return true; + else if (sec == rhs.sec && nsec < rhs.nsec) + return true; + return false; + } + + template + bool TimeBase::operator>(const T &rhs) const + { + if (sec > rhs.sec) + return true; + else if (sec == rhs.sec && nsec > rhs.nsec) + return true; + return false; + } + + template + bool TimeBase::operator<=(const T &rhs) const + { + if (sec < rhs.sec) + return true; + else if (sec == rhs.sec && nsec <= rhs.nsec) + return true; + return false; + } + + template + bool TimeBase::operator>=(const T &rhs) const + { + if (sec > rhs.sec) + return true; + else if (sec == rhs.sec && nsec >= rhs.nsec) + return true; + return false; + } + + /* template + boost::posix_time::ptime*/ + /*TimeBase::toBoost() const + { + namespace pt = boost::posix_time; +#if defined(BOOST_DATE_TIME_HAS_NANOSECONDS) + return pt::from_time_t(sec) + pt::nanoseconds(nsec); +#else + return pt::from_time_t(static_cast(sec)) + pt::microseconds(static_cast(nsec/1000.0)); +#endif + }*/ + + +} + +#endif // ROS_IMPL_TIME_H_INCLUDED + diff --git a/realsense-file/3rd_party/rosbag/rostime/include/ros/rate.h b/realsense-file/3rd_party/rosbag/rostime/include/ros/rate.h new file mode 100644 index 0000000000..ddee3a710f --- /dev/null +++ b/realsense-file/3rd_party/rosbag/rostime/include/ros/rate.h @@ -0,0 +1,131 @@ +/********************************************************************* +* +* Software License Agreement (BSD License) +* +* Copyright (c) 2009, Willow Garage, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions +* are met: +* +* * Redistributions of source code must retain the above copyright +* notice, this list of conditions and the following disclaimer. +* * Redistributions in binary form must reproduce the above +* copyright notice, this list of conditions and the following +* disclaimer in the documentation and/or other materials provided +* with the distribution. +* * Neither the name of the Willow Garage nor the names of its +* contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +* +* Author: Eitan Marder-Eppstein +*********************************************************************/ +#ifndef ROSLIB_RATE_H +#define ROSLIB_RATE_H + +#include "ros/time.h" +#include "rostime_decl.h" + +namespace ros +{ +class Duration; + +/** + * @class Rate + * @brief Class to help run loops at a desired frequency + */ +class ROSTIME_DECL Rate +{ +public: + /** + * @brief Constructor, creates a Rate + * @param frequency The desired rate to run at in Hz + */ + Rate(double frequency); + explicit Rate(const Duration&); + + /** + * @brief Sleeps for any leftover time in a cycle. Calculated from the last time sleep, reset, or the constructor was called. + * @return True if the desired rate was met for the cycle, false otherwise. + */ + bool sleep(); + + /** + * @brief Sets the start time for the rate to now + */ + void reset(); + + /** + * @brief Get the actual run time of a cycle from start to sleep + * @return The runtime of the cycle + */ + Duration cycleTime() const; + + /** + * @brief Get the expected cycle time -- one over the frequency passed in to the constructor + */ + Duration expectedCycleTime() const { return expected_cycle_time_; } + +private: + Time start_; + Duration expected_cycle_time_, actual_cycle_time_; +}; + +/** + * @class WallRate + * @brief Class to help run loops at a desired frequency. This version always uses wall-clock time. + */ +class ROSTIME_DECL WallRate +{ +public: + /** + * @brief Constructor, creates a Rate + * @param frequency The desired rate to run at in Hz + */ + WallRate(double frequency); + explicit WallRate(const Duration&); + + /** + * @brief Sleeps for any leftover time in a cycle. Calculated from the last time sleep, reset, or the constructor was called. + * @return Passes through the return value from WallDuration::sleep() if it slept, false otherwise. + */ + bool sleep(); + + /** + * @brief Sets the start time for the rate to now + */ + void reset(); + + /** + * @brief Get the actual run time of a cycle from start to sleep + * @return The runtime of the cycle + */ + WallDuration cycleTime() const; + + /** + * @brief Get the expected cycle time -- one over the frequency passed in to the constructor + */ + WallDuration expectedCycleTime() const { return expected_cycle_time_; } + +private: + WallTime start_; + WallDuration expected_cycle_time_, actual_cycle_time_; +}; + +} + +#endif diff --git a/realsense-file/3rd_party/rosbag/rostime/include/ros/rostime_decl.h b/realsense-file/3rd_party/rosbag/rostime/include/ros/rostime_decl.h new file mode 100644 index 0000000000..c7f79f1e8a --- /dev/null +++ b/realsense-file/3rd_party/rosbag/rostime/include/ros/rostime_decl.h @@ -0,0 +1,55 @@ +/********************************************************************* +* +* Software License Agreement (BSD License)ros/macros.h +* +* Copyright (c) 2009, Willow Garage, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions +* are met: +* +* * Redistributions of source code must retain the above copyright +* notice, this list of conditions and the following disclaimer. +* * Redistributions in binary form must reproduce the above +* copyright notice, this list of conditions and the following +* disclaimer in the documentation and/or other materials provided +* with the distribution. +* * Neither the name of the Willow Garage nor the names of its +* contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +* +*********************************************************************/ +/* + * Cross platform macros. + * + */ +#ifndef ROSTIME_DECL_HPP_INCLUDED +#define ROSTIME_DECL_HPP_INCLUDED + +#include "../../../rosbag_storage/include/rosbag/macros.h" + +#ifdef ROS_BUILD_SHARED_LIBS // ros is being built around shared libraries + #ifdef rostime_EXPORTS // we are building a shared lib/dll + #define ROSTIME_DECL ROS_HELPER_EXPORT + #else // we are using shared lib/dll + #define ROSTIME_DECL ROS_HELPER_IMPORT + #endif +#else // ros is being built around static libraries + #define ROSTIME_DECL +#endif + +#endif /* ROSTIME_DECL_HPP_INCLUDED */ diff --git a/realsense-file/3rd_party/rosbag/rostime/include/ros/time.h b/realsense-file/3rd_party/rosbag/rostime/include/ros/time.h new file mode 100644 index 0000000000..e4f6e4d62c --- /dev/null +++ b/realsense-file/3rd_party/rosbag/rostime/include/ros/time.h @@ -0,0 +1,265 @@ +/********************************************************************* + * Software License Agreement (BSD License) + * + * Copyright (c) 2010, Willow Garage, Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials provided + * with the distribution. + * * Neither the name of Willow Garage, Inc. nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN + * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + *********************************************************************/ + +#ifndef ROS_TIME_H_INCLUDED +#define ROS_TIME_H_INCLUDED + +/********************************************************************* + ** Pragmas + *********************************************************************/ + +#ifdef _MSC_VER + // Rostime has some magic interface that doesn't directly include + // its implementation, this just disables those warnings. + #pragma warning(disable: 4244) + #pragma warning(disable: 4661) +#endif + +/********************************************************************* + ** Headers + *********************************************************************/ +#include "../../../cpp_common/include/ros/platform.h" +#include +#include +#include "../../../cpp_common/include/ros/exception.h" +#include "duration.h" +//#include +#include "rostime_decl.h" + +/********************************************************************* + ** Cross Platform Headers + *********************************************************************/ + +#ifdef WIN32 + #include +#else + #include +#endif + +#include "math.h" + +//namespace boost { +// namespace posix_time { +// class ptime; +// class time_duration; +// } +//} + +namespace ros +{ + + /********************************************************************* + ** Exceptions + *********************************************************************/ + + /** + * @brief Thrown if the ros subsystem hasn't been initialised before use. + */ + class ROSTIME_DECL TimeNotInitializedException : public Exception + { + public: + TimeNotInitializedException() + : Exception("Cannot use ros::Time::now() before the first NodeHandle has been created or ros::start() has been called. " + "If this is a standalone app or test that just uses ros::Time and does not communicate over ROS, you may also call ros::Time::init()") + {} + }; + + /** + * @brief Thrown if windoze high perf. timestamping is unavailable. + * + * @sa getWallTime + */ + class ROSTIME_DECL NoHighPerformanceTimersException : public Exception + { + public: + NoHighPerformanceTimersException() + : Exception("This windows platform does not " + "support the high-performance timing api.") + {} + }; + + /********************************************************************* + ** Functions + *********************************************************************/ + + ROSTIME_DECL void normalizeSecNSec(uint64_t& sec, uint64_t& nsec); + ROSTIME_DECL void normalizeSecNSec(uint32_t& sec, uint32_t& nsec); + ROSTIME_DECL void normalizeSecNSecUnsigned(int64_t& sec, int64_t& nsec); + + /********************************************************************* + ** Time Classes + *********************************************************************/ + + /** + * \brief Base class for Time implementations. Provides storage, common functions and operator overloads. + * This should not need to be used directly. + */ + template + class TimeBase + { + public: + uint32_t sec, nsec; + + TimeBase() : sec(0), nsec(0) { } + TimeBase(uint32_t _sec, uint32_t _nsec) : sec(_sec), nsec(_nsec) + { + normalizeSecNSec(sec, nsec); + } + explicit TimeBase(double t) { fromSec(t); } + ~TimeBase() {} + D operator-(const T &rhs) const; + T operator+(const D &rhs) const; + T operator-(const D &rhs) const; + T& operator+=(const D &rhs); + T& operator-=(const D &rhs); + bool operator==(const T &rhs) const; + inline bool operator!=(const T &rhs) const { return !(*static_cast(this) == rhs); } + bool operator>(const T &rhs) const; + bool operator<(const T &rhs) const; + bool operator>=(const T &rhs) const; + bool operator<=(const T &rhs) const; + + double toSec() const { return (double)sec + 1e-9*(double)nsec; }; + T& fromSec(double t) { + sec = static_cast(floor(t)); + nsec = static_cast(round((t-sec) * 1e9)); + // avoid rounding errors + sec += static_cast((nsec / 1000000000ul)); + nsec %= 1000000000ul; + return *static_cast(this); + } + + uint64_t toNSec() const {return (uint64_t)sec*1000000000ull + (uint64_t)nsec; } + T& fromNSec(uint64_t t); + + inline bool isZero() const { return sec == 0 && nsec == 0; } + inline bool is_zero() const { return isZero(); } + // boost::posix_time::ptime toBoost() const; + + }; + + /** + * \brief Time representation. May either represent wall clock time or ROS clock time. + * + * ros::TimeBase provides most of its functionality. + */ + class ROSTIME_DECL Time : public TimeBase + { + public: + Time() + : TimeBase() + {} + + Time(uint32_t _sec, uint32_t _nsec) + : TimeBase(_sec, _nsec) + {} + + explicit Time(double t) { fromSec(t); } + + /** + * \brief Retrieve the current time. If ROS clock time is in use, this returns the time according to the + * ROS clock. Otherwise returns the current wall clock time. + */ + static Time now(); + /** + * \brief Sleep until a specific time has been reached. + * @return True if the desired sleep time was met, false otherwise. + */ + static bool sleepUntil(const Time& end); + + static void init(); + static void shutdown(); + static void setNow(const Time& new_now); + static bool useSystemTime(); + static bool isSimTime(); + static bool isSystemTime(); + + /** + * \brief Returns whether or not the current time is valid. Time is valid if it is non-zero. + */ + static bool isValid(); + /** + * \brief Wait for time to become valid + */ + static bool waitForValid(); + /** + * \brief Wait for time to become valid, with timeout + */ + static bool waitForValid(const ros::WallDuration& timeout); + + /*static Time fromBoost(const boost::posix_time::ptime& t); + static Time fromBoost(const boost::posix_time::time_duration& d);*/ + }; + + extern ROSTIME_DECL const Time TIME_MAX; + extern ROSTIME_DECL const Time TIME_MIN; + + /** + * \brief Time representation. Always wall-clock time. + * + * ros::TimeBase provides most of its functionality. + */ + class ROSTIME_DECL WallTime : public TimeBase + { + public: + WallTime() + : TimeBase() + {} + + WallTime(uint32_t _sec, uint32_t _nsec) + : TimeBase(_sec, _nsec) + {} + + explicit WallTime(double t) { fromSec(t); } + + /** + * \brief Returns the current wall clock time. + */ + static WallTime now(); + + /** + * \brief Sleep until a specific time has been reached. + * @return True if the desired sleep time was met, false otherwise. + */ + static bool sleepUntil(const WallTime& end); + + static bool isSystemTime() { return true; } + }; + + ROSTIME_DECL std::ostream &operator <<(std::ostream &os, const Time &rhs); + ROSTIME_DECL std::ostream &operator <<(std::ostream &os, const WallTime &rhs); +} + +#endif // ROS_TIME_H + diff --git a/realsense-file/3rd_party/rosbag/rostime/src/duration.cpp b/realsense-file/3rd_party/rosbag/rostime/src/duration.cpp new file mode 100644 index 0000000000..72857c6bb3 --- /dev/null +++ b/realsense-file/3rd_party/rosbag/rostime/src/duration.cpp @@ -0,0 +1,78 @@ +/********************************************************************* + * Software License Agreement (BSD License) + * + * Copyright (c) 2010, Willow Garage, Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials provided + * with the distribution. + * * Neither the name of Willow Garage, Inc. nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN + * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + *********************************************************************/ + #include +#include + +namespace ros { + + Duration::Duration(const Rate& rate) + : DurationBase(rate.expectedCycleTime().sec, rate.expectedCycleTime().nsec) + { } + + WallDuration::WallDuration(const Rate& rate) + : DurationBase(rate.expectedCycleTime().sec, rate.expectedCycleTime().nsec) + { } + + void normalizeSecNSecSigned(int64_t& sec, int64_t& nsec) + { + int64_t nsec_part = nsec % 1000000000L; + int64_t sec_part = sec + nsec / 1000000000L; + if (nsec_part < 0) + { + nsec_part += 1000000000L; + --sec_part; + } + + if (sec_part < INT_MIN || sec_part > INT_MAX) + throw std::runtime_error("Duration is out of dual 32-bit range"); + + sec = sec_part; + nsec = nsec_part; + } + + void normalizeSecNSecSigned(int32_t& sec, int32_t& nsec) + { + int64_t sec64 = sec; + int64_t nsec64 = nsec; + + normalizeSecNSecSigned(sec64, nsec64); + + sec = (int32_t)sec64; + nsec = (int32_t)nsec64; + } + + template class DurationBase; + template class DurationBase; +} + diff --git a/realsense-file/3rd_party/rosbag/rostime/src/rate.cpp b/realsense-file/3rd_party/rosbag/rostime/src/rate.cpp new file mode 100644 index 0000000000..cdd0313a3a --- /dev/null +++ b/realsense-file/3rd_party/rosbag/rostime/src/rate.cpp @@ -0,0 +1,162 @@ +/********************************************************************* + * + * Software License Agreement (BSD License) + * + * Copyright (c) 2009, Willow Garage, Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials provided + * with the distribution. + * * Neither the name of the Willow Garage nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN + * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + * Author: Eitan Marder-Eppstein + *********************************************************************/ +#include + +namespace ros +{ + +Rate::Rate(double frequency) +: start_(Time::now()) +, expected_cycle_time_(1.0 / frequency) +, actual_cycle_time_(0.0) +{ } + +Rate::Rate(const Duration& d) + : start_(Time::now()) + , expected_cycle_time_(d.sec, d.nsec) + , actual_cycle_time_(0.0) +{ } + + + +bool Rate::sleep() +{ + Time expected_end = start_ + expected_cycle_time_; + + Time actual_end = Time::now(); + + // detect backward jumps in time + if (actual_end < start_) + { + expected_end = actual_end + expected_cycle_time_; + } + + //calculate the time we'll sleep for + Duration sleep_time = expected_end - actual_end; + + //set the actual amount of time the loop took in case the user wants to know + actual_cycle_time_ = actual_end - start_; + + //make sure to reset our start time + start_ = expected_end; + + //if we've taken too much time we won't sleep + if(sleep_time <= Duration(0.0)) + { + // if we've jumped forward in time, or the loop has taken more than a full extra + // cycle, reset our cycle + if (actual_end > expected_end + expected_cycle_time_) + { + start_ = actual_end; + } + // return false to show that the desired rate was not met + return false; + } + + return sleep_time.sleep(); +} + +void Rate::reset() +{ + start_ = Time::now(); +} + +Duration Rate::cycleTime() const +{ + return actual_cycle_time_; +} + +WallRate::WallRate(double frequency) +: start_(WallTime::now()) +, expected_cycle_time_(1.0 / frequency) +, actual_cycle_time_(0.0) +{} + +WallRate::WallRate(const Duration& d) +: start_(WallTime::now()) +, expected_cycle_time_(d.sec, d.nsec) +, actual_cycle_time_(0.0) +{} + +bool WallRate::sleep() +{ + WallTime expected_end = start_ + expected_cycle_time_; + + WallTime actual_end = WallTime::now(); + + // detect backward jumps in time + if (actual_end < start_) + { + expected_end = actual_end + expected_cycle_time_; + } + + //calculate the time we'll sleep for + WallDuration sleep_time = expected_end - actual_end; + + //set the actual amount of time the loop took in case the user wants to know + actual_cycle_time_ = actual_end - start_; + + //make sure to reset our start time + start_ = expected_end; + + //if we've taken too much time we won't sleep + if(sleep_time <= WallDuration(0.0)) + { + // if we've jumped forward in time, or the loop has taken more than a full extra + // cycle, reset our cycle + if (actual_end > expected_end + expected_cycle_time_) + { + start_ = actual_end; + } + return false; + } + + return sleep_time.sleep(); +} + +void WallRate::reset() +{ + start_ = WallTime::now(); +} + +WallDuration WallRate::cycleTime() const +{ + return actual_cycle_time_; +} + + +} diff --git a/realsense-file/3rd_party/rosbag/rostime/src/time.cpp b/realsense-file/3rd_party/rosbag/rostime/src/time.cpp new file mode 100644 index 0000000000..015ded7e02 --- /dev/null +++ b/realsense-file/3rd_party/rosbag/rostime/src/time.cpp @@ -0,0 +1,511 @@ +/********************************************************************* + * Software License Agreement (BSD License) + * + * Copyright (c) 2010, Willow Garage, Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials provided + * with the distribution. + * * Neither the name of Willow Garage, Inc. nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN + * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + *********************************************************************/ +#ifdef _MSC_VER + #ifndef NOMINMAX + #define NOMINMAX + #endif +#endif + +#include "ros/time.h" +#include "ros/impl/time.h" +#include +#include +#include +#include +#include +#include +#include "math.h" +//#include +#include +//#include + +/********************************************************************* + ** Preprocessor + *********************************************************************/ + +// Could probably do some better and more elaborate checking +// and definition here. +#define HAS_CLOCK_GETTIME (_POSIX_C_SOURCE >= 199309L) + +/********************************************************************* + ** Namespaces + *********************************************************************/ + +namespace ros +{ + + /********************************************************************* + ** Variables + *********************************************************************/ + + const Duration DURATION_MAX(std::numeric_limits::max(), 999999999); + const Duration DURATION_MIN(std::numeric_limits::min(), 0); + + const Time TIME_MAX(std::numeric_limits::max(), 999999999); + const Time TIME_MIN(0, 1); + + // This is declared here because it's set from the Time class but read from + // the Duration class, and need not be exported to users of either. + static bool g_stopped(false); + + // I assume that this is declared here, instead of time.h, to keep users + // of time.h from including boost/thread/mutex.hpp + static std::mutex g_sim_time_mutex; + + static bool g_initialized(false); + static bool g_use_sim_time(true); + static Time g_sim_time(0, 0); + + /********************************************************************* + ** Cross Platform Functions + *********************************************************************/ + /* + * These have only internal linkage to this translation unit. + * (i.e. not exposed to users of the time classes) + */ + void ros_walltime(uint32_t& sec, uint32_t& nsec) +#ifndef WIN32 + throw(NoHighPerformanceTimersException) +#endif + { +#ifndef WIN32 +#if HAS_CLOCK_GETTIME + timespec start; + clock_gettime(CLOCK_REALTIME, &start); + sec = static_cast(start.tv_sec); + nsec = static_cast(start.tv_nsec); +#else + struct timeval timeofday; + gettimeofday(&timeofday,NULL); + sec = timeofday.tv_sec; + nsec = timeofday.tv_usec * 1000; +#endif +#else + // Win32 implementation + // unless I've missed something obvious, the only way to get high-precision + // time on Windows is via the QueryPerformanceCounter() call. However, + // this is somewhat problematic in Windows XP on some processors, especially + // AMD, because the Windows implementation can freak out when the CPU clocks + // down to save power. Time can jump or even go backwards. Microsoft has + // fixed this bug for most systems now, but it can still show up if you have + // not installed the latest CPU drivers (an oxymoron). They fixed all these + // problems in Windows Vista, and this API is by far the most accurate that + // I know of in Windows, so I'll use it here despite all these caveats + static LARGE_INTEGER cpu_freq, init_cpu_time; + static uint32_t start_sec = 0; + static uint32_t start_nsec = 0; + if ( ( start_sec == 0 ) && ( start_nsec == 0 ) ) + { + QueryPerformanceFrequency(&cpu_freq); + if (cpu_freq.QuadPart == 0) { + throw NoHighPerformanceTimersException(); + } + QueryPerformanceCounter(&init_cpu_time); + // compute an offset from the Epoch using the lower-performance timer API + FILETIME ft; + GetSystemTimeAsFileTime(&ft); + LARGE_INTEGER start_li; + start_li.LowPart = ft.dwLowDateTime; + start_li.HighPart = ft.dwHighDateTime; + // why did they choose 1601 as the time zero, instead of 1970? + // there were no outstanding hard rock bands in 1601. +#ifdef _MSC_VER + start_li.QuadPart -= 116444736000000000Ui64; +#else + start_li.QuadPart -= 116444736000000000ULL; +#endif + start_sec = (uint32_t)(start_li.QuadPart / 10000000); // 100-ns units. odd. + start_nsec = (start_li.LowPart % 10000000) * 100; + } + LARGE_INTEGER cur_time; + QueryPerformanceCounter(&cur_time); + LARGE_INTEGER delta_cpu_time; + delta_cpu_time.QuadPart = cur_time.QuadPart - init_cpu_time.QuadPart; + // todo: how to handle cpu clock drift. not sure it's a big deal for us. + // also, think about clock wraparound. seems extremely unlikey, but possible + double d_delta_cpu_time = delta_cpu_time.QuadPart / (double) cpu_freq.QuadPart; + uint32_t delta_sec = (uint32_t) floor(d_delta_cpu_time); + uint32_t delta_nsec = (uint32_t) round((d_delta_cpu_time-delta_sec) * 1e9); + + int64_t sec_sum = (int64_t)start_sec + (int64_t)delta_sec; + int64_t nsec_sum = (int64_t)start_nsec + (int64_t)delta_nsec; + + // Throws an exception if we go out of 32-bit range + normalizeSecNSecUnsigned(sec_sum, nsec_sum); + + sec = sec_sum; + nsec = nsec_sum; +#endif + } + /** + * @brief Simple representation of the rt library nanosleep function. + */ + int ros_nanosleep(const uint32_t &sec, const uint32_t &nsec) + { +#if defined(WIN32) + HANDLE timer = NULL; + LARGE_INTEGER sleepTime; + sleepTime.QuadPart = - + static_cast(sec)*10000000LL - + static_cast(nsec) / 100LL; + + timer = CreateWaitableTimer(NULL, TRUE, NULL); + if (timer == NULL) + { + return -1; + } + + if (!SetWaitableTimer (timer, &sleepTime, 0, NULL, NULL, 0)) + { + return -1; + } + + if (WaitForSingleObject (timer, INFINITE) != WAIT_OBJECT_0) + { + return -1; + } + return 0; +#else + timespec req = { sec, nsec }; + return nanosleep(&req, NULL); +#endif + } + + /** + * @brief Go to the wall! + * + * @todo Fully implement the win32 parts, currently just like a regular sleep. + */ + bool ros_wallsleep(uint32_t sec, uint32_t nsec) + { +#if defined(WIN32) + ros_nanosleep(sec,nsec); +#else + timespec req = { sec, nsec }; + timespec rem = {0, 0}; + while (nanosleep(&req, &rem) && !g_stopped) + { + req = rem; + } +#endif + return !g_stopped; + } + + /********************************************************************* + ** Class Methods + *********************************************************************/ + + bool Time::useSystemTime() + { + return !g_use_sim_time; + } + + bool Time::isSimTime() + { + return g_use_sim_time; + } + + bool Time::isSystemTime() + { + return !isSimTime(); + } + + Time Time::now() + { + if (!g_initialized) + { + throw TimeNotInitializedException(); + } + + if (g_use_sim_time) + { + std::lock_guard lock(g_sim_time_mutex); + Time t = g_sim_time; + return t; + } + + Time t; + ros_walltime(t.sec, t.nsec); + + return t; + } + + void Time::setNow(const Time& new_now) + { + std::lock_guard lock(g_sim_time_mutex); + + g_sim_time = new_now; + g_use_sim_time = true; + } + + void Time::init() + { + g_stopped = false; + g_use_sim_time = false; + g_initialized = true; + } + + void Time::shutdown() + { + g_stopped = true; + } + + bool Time::isValid() + { + return (!g_use_sim_time) || !g_sim_time.isZero(); + } + + bool Time::waitForValid() + { + return waitForValid(ros::WallDuration()); + } + + bool Time::waitForValid(const ros::WallDuration& timeout) + { + ros::WallTime start = ros::WallTime::now(); + while (!isValid() && !g_stopped) + { + ros::WallDuration(0.01).sleep(); + + if (timeout > ros::WallDuration(0, 0) && (ros::WallTime::now() - start > timeout)) + { + return false; + } + } + + if (g_stopped) + { + return false; + } + + return true; + } + + /* Time Time::fromBoost(const boost::posix_time::ptime& t) + { + boost::posix_time::time_duration diff = t - boost::posix_time::from_time_t(0); + return Time::fromBoost(diff); + } + + Time Time::fromBoost(const boost::posix_time::time_duration& d) + { + Time t; + t.sec = d.total_seconds(); +#if defined(BOOST_DATE_TIME_HAS_NANOSECONDS) + t.nsec = d.fractional_seconds(); +#else + t.nsec = static_cast(d.fractional_seconds()*1000); +#endif + return t; + }*/ + + std::ostream& operator<<(std::ostream& os, const Time &rhs) + { + boost::io::ios_all_saver s(os); + os << rhs.sec << "." << std::setw(9) << std::setfill('0') << rhs.nsec; + return os; + } + + std::ostream& operator<<(std::ostream& os, const Duration& rhs) + { + boost::io::ios_all_saver s(os); + if (rhs.sec >= 0 || rhs.nsec == 0) + { + os << rhs.sec << "." << std::setw(9) << std::setfill('0') << rhs.nsec; + } + else + { + os << (rhs.sec == -1 ? "-" : "") << (rhs.sec + 1) << "." << std::setw(9) << std::setfill('0') << (1000000000 - rhs.nsec); + } + return os; + } + + bool Time::sleepUntil(const Time& end) + { + if (Time::useSystemTime()) + { + Duration d(end - Time::now()); + if (d > Duration(0)) + { + return d.sleep(); + } + + return true; + } + else + { + Time start = Time::now(); + while (!g_stopped && (Time::now() < end)) + { + ros_nanosleep(0,1000000); + if (Time::now() < start) + { + return false; + } + } + + return true; + } + } + + bool WallTime::sleepUntil(const WallTime& end) + { + WallDuration d(end - WallTime::now()); + if (d > WallDuration(0)) + { + return d.sleep(); + } + + return true; + } + + bool Duration::sleep() const + { + if (Time::useSystemTime()) + { + return ros_wallsleep(sec, nsec); + } + else + { + Time start = Time::now(); + Time end = start + *this; + if (start.isZero()) + { + end = TIME_MAX; + } + + bool rc = false; + while (!g_stopped && (Time::now() < end)) + { + ros_wallsleep(0, 1000000); + rc = true; + + // If we started at time 0 wait for the first actual time to arrive before starting the timer on + // our sleep + if (start.isZero()) + { + start = Time::now(); + end = start + *this; + } + + // If time jumped backwards from when we started sleeping, return immediately + if (Time::now() < start) + { + return false; + } + } + + return rc && !g_stopped; + } + } + + std::ostream &operator<<(std::ostream& os, const WallTime &rhs) + { + boost::io::ios_all_saver s(os); + os << rhs.sec << "." << std::setw(9) << std::setfill('0') << rhs.nsec; + return os; + } + + WallTime WallTime::now() + { + WallTime t; + ros_walltime(t.sec, t.nsec); + + return t; + } + + std::ostream &operator<<(std::ostream& os, const WallDuration& rhs) + { + boost::io::ios_all_saver s(os); + if (rhs.sec >= 0 || rhs.nsec == 0) + { + os << rhs.sec << "." << std::setw(9) << std::setfill('0') << rhs.nsec; + } + else + { + os << (rhs.sec == -1 ? "-" : "") << (rhs.sec + 1) << "." << std::setw(9) << std::setfill('0') << (1000000000 - rhs.nsec); + } + return os; + } + + bool WallDuration::sleep() const + { + return ros_wallsleep(sec, nsec); + } + + void normalizeSecNSec(uint64_t& sec, uint64_t& nsec) + { + uint64_t nsec_part = nsec % 1000000000UL; + uint64_t sec_part = nsec / 1000000000UL; + + if (sec + sec_part > UINT_MAX) + throw std::runtime_error("Time is out of dual 32-bit range"); + + sec += sec_part; + nsec = nsec_part; + } + + void normalizeSecNSec(uint32_t& sec, uint32_t& nsec) + { + uint64_t sec64 = sec; + uint64_t nsec64 = nsec; + + normalizeSecNSec(sec64, nsec64); + + sec = (uint32_t)sec64; + nsec = (uint32_t)nsec64; + } + + void normalizeSecNSecUnsigned(int64_t& sec, int64_t& nsec) + { + int64_t nsec_part = nsec % 1000000000L; + int64_t sec_part = sec + nsec / 1000000000L; + if (nsec_part < 0) + { + nsec_part += 1000000000L; + --sec_part; + } + + if (sec_part < 0 || sec_part > UINT_MAX) + throw std::runtime_error("Time is out of dual 32-bit range"); + + sec = sec_part; + nsec = nsec_part; + } + + template class TimeBase; + template class TimeBase; +} + + diff --git a/realsense-file/CMakeFiles/3.5.1/CMakeCCompiler.cmake b/realsense-file/CMakeFiles/3.5.1/CMakeCCompiler.cmake new file mode 100644 index 0000000000..f40522e627 --- /dev/null +++ b/realsense-file/CMakeFiles/3.5.1/CMakeCCompiler.cmake @@ -0,0 +1,67 @@ +set(CMAKE_C_COMPILER "/usr/bin/cc") +set(CMAKE_C_COMPILER_ARG1 "") +set(CMAKE_C_COMPILER_ID "GNU") +set(CMAKE_C_COMPILER_VERSION "5.4.0") +set(CMAKE_C_COMPILER_WRAPPER "") +set(CMAKE_C_STANDARD_COMPUTED_DEFAULT "11") +set(CMAKE_C_COMPILE_FEATURES "c_function_prototypes;c_restrict;c_variadic_macros;c_static_assert") +set(CMAKE_C90_COMPILE_FEATURES "c_function_prototypes") +set(CMAKE_C99_COMPILE_FEATURES "c_restrict;c_variadic_macros") +set(CMAKE_C11_COMPILE_FEATURES "c_static_assert") + +set(CMAKE_C_PLATFORM_ID "Linux") +set(CMAKE_C_SIMULATE_ID "") +set(CMAKE_C_SIMULATE_VERSION "") + +set(CMAKE_AR "/usr/bin/ar") +set(CMAKE_RANLIB "/usr/bin/ranlib") +set(CMAKE_LINKER "/usr/bin/ld") +set(CMAKE_COMPILER_IS_GNUCC 1) +set(CMAKE_C_COMPILER_LOADED 1) +set(CMAKE_C_COMPILER_WORKS TRUE) +set(CMAKE_C_ABI_COMPILED TRUE) +set(CMAKE_COMPILER_IS_MINGW ) +set(CMAKE_COMPILER_IS_CYGWIN ) +if(CMAKE_COMPILER_IS_CYGWIN) + set(CYGWIN 1) + set(UNIX 1) +endif() + +set(CMAKE_C_COMPILER_ENV_VAR "CC") + +if(CMAKE_COMPILER_IS_MINGW) + set(MINGW 1) +endif() +set(CMAKE_C_COMPILER_ID_RUN 1) +set(CMAKE_C_SOURCE_FILE_EXTENSIONS c;m) +set(CMAKE_C_IGNORE_EXTENSIONS h;H;o;O;obj;OBJ;def;DEF;rc;RC) +set(CMAKE_C_LINKER_PREFERENCE 10) + +# Save compiler ABI information. +set(CMAKE_C_SIZEOF_DATA_PTR "8") +set(CMAKE_C_COMPILER_ABI "ELF") +set(CMAKE_C_LIBRARY_ARCHITECTURE "x86_64-linux-gnu") + +if(CMAKE_C_SIZEOF_DATA_PTR) + set(CMAKE_SIZEOF_VOID_P "${CMAKE_C_SIZEOF_DATA_PTR}") +endif() + +if(CMAKE_C_COMPILER_ABI) + set(CMAKE_INTERNAL_PLATFORM_ABI "${CMAKE_C_COMPILER_ABI}") +endif() + +if(CMAKE_C_LIBRARY_ARCHITECTURE) + set(CMAKE_LIBRARY_ARCHITECTURE "x86_64-linux-gnu") +endif() + +set(CMAKE_C_CL_SHOWINCLUDES_PREFIX "") +if(CMAKE_C_CL_SHOWINCLUDES_PREFIX) + set(CMAKE_CL_SHOWINCLUDES_PREFIX "${CMAKE_C_CL_SHOWINCLUDES_PREFIX}") +endif() + + + + +set(CMAKE_C_IMPLICIT_LINK_LIBRARIES "c") +set(CMAKE_C_IMPLICIT_LINK_DIRECTORIES "/usr/lib/gcc/x86_64-linux-gnu/5;/usr/lib/x86_64-linux-gnu;/usr/lib;/lib/x86_64-linux-gnu;/lib") +set(CMAKE_C_IMPLICIT_LINK_FRAMEWORK_DIRECTORIES "") diff --git a/realsense-file/CMakeFiles/3.5.1/CMakeCXXCompiler.cmake b/realsense-file/CMakeFiles/3.5.1/CMakeCXXCompiler.cmake new file mode 100644 index 0000000000..013ee9298f --- /dev/null +++ b/realsense-file/CMakeFiles/3.5.1/CMakeCXXCompiler.cmake @@ -0,0 +1,68 @@ +set(CMAKE_CXX_COMPILER "/usr/bin/c++") +set(CMAKE_CXX_COMPILER_ARG1 "") +set(CMAKE_CXX_COMPILER_ID "GNU") +set(CMAKE_CXX_COMPILER_VERSION "5.4.0") +set(CMAKE_CXX_COMPILER_WRAPPER "") +set(CMAKE_CXX_STANDARD_COMPUTED_DEFAULT "98") +set(CMAKE_CXX_COMPILE_FEATURES "cxx_template_template_parameters;cxx_alias_templates;cxx_alignas;cxx_alignof;cxx_attributes;cxx_auto_type;cxx_constexpr;cxx_decltype;cxx_decltype_incomplete_return_types;cxx_default_function_template_args;cxx_defaulted_functions;cxx_defaulted_move_initializers;cxx_delegating_constructors;cxx_deleted_functions;cxx_enum_forward_declarations;cxx_explicit_conversions;cxx_extended_friend_declarations;cxx_extern_templates;cxx_final;cxx_func_identifier;cxx_generalized_initializers;cxx_inheriting_constructors;cxx_inline_namespaces;cxx_lambdas;cxx_local_type_template_args;cxx_long_long_type;cxx_noexcept;cxx_nonstatic_member_init;cxx_nullptr;cxx_override;cxx_range_for;cxx_raw_string_literals;cxx_reference_qualified_functions;cxx_right_angle_brackets;cxx_rvalue_references;cxx_sizeof_member;cxx_static_assert;cxx_strong_enums;cxx_thread_local;cxx_trailing_return_types;cxx_unicode_literals;cxx_uniform_initialization;cxx_unrestricted_unions;cxx_user_literals;cxx_variadic_macros;cxx_variadic_templates;cxx_aggregate_default_initializers;cxx_attribute_deprecated;cxx_binary_literals;cxx_contextual_conversions;cxx_decltype_auto;cxx_digit_separators;cxx_generic_lambdas;cxx_lambda_init_captures;cxx_relaxed_constexpr;cxx_return_type_deduction;cxx_variable_templates") +set(CMAKE_CXX98_COMPILE_FEATURES "cxx_template_template_parameters") +set(CMAKE_CXX11_COMPILE_FEATURES "cxx_alias_templates;cxx_alignas;cxx_alignof;cxx_attributes;cxx_auto_type;cxx_constexpr;cxx_decltype;cxx_decltype_incomplete_return_types;cxx_default_function_template_args;cxx_defaulted_functions;cxx_defaulted_move_initializers;cxx_delegating_constructors;cxx_deleted_functions;cxx_enum_forward_declarations;cxx_explicit_conversions;cxx_extended_friend_declarations;cxx_extern_templates;cxx_final;cxx_func_identifier;cxx_generalized_initializers;cxx_inheriting_constructors;cxx_inline_namespaces;cxx_lambdas;cxx_local_type_template_args;cxx_long_long_type;cxx_noexcept;cxx_nonstatic_member_init;cxx_nullptr;cxx_override;cxx_range_for;cxx_raw_string_literals;cxx_reference_qualified_functions;cxx_right_angle_brackets;cxx_rvalue_references;cxx_sizeof_member;cxx_static_assert;cxx_strong_enums;cxx_thread_local;cxx_trailing_return_types;cxx_unicode_literals;cxx_uniform_initialization;cxx_unrestricted_unions;cxx_user_literals;cxx_variadic_macros;cxx_variadic_templates") +set(CMAKE_CXX14_COMPILE_FEATURES "cxx_aggregate_default_initializers;cxx_attribute_deprecated;cxx_binary_literals;cxx_contextual_conversions;cxx_decltype_auto;cxx_digit_separators;cxx_generic_lambdas;cxx_lambda_init_captures;cxx_relaxed_constexpr;cxx_return_type_deduction;cxx_variable_templates") + +set(CMAKE_CXX_PLATFORM_ID "Linux") +set(CMAKE_CXX_SIMULATE_ID "") +set(CMAKE_CXX_SIMULATE_VERSION "") + +set(CMAKE_AR "/usr/bin/ar") +set(CMAKE_RANLIB "/usr/bin/ranlib") +set(CMAKE_LINKER "/usr/bin/ld") +set(CMAKE_COMPILER_IS_GNUCXX 1) +set(CMAKE_CXX_COMPILER_LOADED 1) +set(CMAKE_CXX_COMPILER_WORKS TRUE) +set(CMAKE_CXX_ABI_COMPILED TRUE) +set(CMAKE_COMPILER_IS_MINGW ) +set(CMAKE_COMPILER_IS_CYGWIN ) +if(CMAKE_COMPILER_IS_CYGWIN) + set(CYGWIN 1) + set(UNIX 1) +endif() + +set(CMAKE_CXX_COMPILER_ENV_VAR "CXX") + +if(CMAKE_COMPILER_IS_MINGW) + set(MINGW 1) +endif() +set(CMAKE_CXX_COMPILER_ID_RUN 1) +set(CMAKE_CXX_IGNORE_EXTENSIONS inl;h;hpp;HPP;H;o;O;obj;OBJ;def;DEF;rc;RC) +set(CMAKE_CXX_SOURCE_FILE_EXTENSIONS C;M;c++;cc;cpp;cxx;mm;CPP) +set(CMAKE_CXX_LINKER_PREFERENCE 30) +set(CMAKE_CXX_LINKER_PREFERENCE_PROPAGATES 1) + +# Save compiler ABI information. +set(CMAKE_CXX_SIZEOF_DATA_PTR "8") +set(CMAKE_CXX_COMPILER_ABI "ELF") +set(CMAKE_CXX_LIBRARY_ARCHITECTURE "x86_64-linux-gnu") + +if(CMAKE_CXX_SIZEOF_DATA_PTR) + set(CMAKE_SIZEOF_VOID_P "${CMAKE_CXX_SIZEOF_DATA_PTR}") +endif() + +if(CMAKE_CXX_COMPILER_ABI) + set(CMAKE_INTERNAL_PLATFORM_ABI "${CMAKE_CXX_COMPILER_ABI}") +endif() + +if(CMAKE_CXX_LIBRARY_ARCHITECTURE) + set(CMAKE_LIBRARY_ARCHITECTURE "x86_64-linux-gnu") +endif() + +set(CMAKE_CXX_CL_SHOWINCLUDES_PREFIX "") +if(CMAKE_CXX_CL_SHOWINCLUDES_PREFIX) + set(CMAKE_CL_SHOWINCLUDES_PREFIX "${CMAKE_CXX_CL_SHOWINCLUDES_PREFIX}") +endif() + + + + +set(CMAKE_CXX_IMPLICIT_LINK_LIBRARIES "stdc++;m;c") +set(CMAKE_CXX_IMPLICIT_LINK_DIRECTORIES "/usr/lib/gcc/x86_64-linux-gnu/5;/usr/lib/x86_64-linux-gnu;/usr/lib;/lib/x86_64-linux-gnu;/lib") +set(CMAKE_CXX_IMPLICIT_LINK_FRAMEWORK_DIRECTORIES "") diff --git a/realsense-file/CMakeFiles/3.5.1/CMakeSystem.cmake b/realsense-file/CMakeFiles/3.5.1/CMakeSystem.cmake new file mode 100644 index 0000000000..6208f620e7 --- /dev/null +++ b/realsense-file/CMakeFiles/3.5.1/CMakeSystem.cmake @@ -0,0 +1,15 @@ +set(CMAKE_HOST_SYSTEM "Linux-4.4.0-81-generic") +set(CMAKE_HOST_SYSTEM_NAME "Linux") +set(CMAKE_HOST_SYSTEM_VERSION "4.4.0-81-generic") +set(CMAKE_HOST_SYSTEM_PROCESSOR "x86_64") + + + +set(CMAKE_SYSTEM "Linux-4.4.0-81-generic") +set(CMAKE_SYSTEM_NAME "Linux") +set(CMAKE_SYSTEM_VERSION "4.4.0-81-generic") +set(CMAKE_SYSTEM_PROCESSOR "x86_64") + +set(CMAKE_CROSSCOMPILING "FALSE") + +set(CMAKE_SYSTEM_LOADED 1) diff --git a/realsense-file/CMakeFiles/3.5.1/CompilerIdC/CMakeCCompilerId.c b/realsense-file/CMakeFiles/3.5.1/CompilerIdC/CMakeCCompilerId.c new file mode 100644 index 0000000000..570a15e994 --- /dev/null +++ b/realsense-file/CMakeFiles/3.5.1/CompilerIdC/CMakeCCompilerId.c @@ -0,0 +1,544 @@ +#ifdef __cplusplus +# error "A C++ compiler has been selected for C." +#endif + +#if defined(__18CXX) +# define ID_VOID_MAIN +#endif + + +/* Version number components: V=Version, R=Revision, P=Patch + Version date components: YYYY=Year, MM=Month, DD=Day */ + +#if defined(__INTEL_COMPILER) || defined(__ICC) +# define COMPILER_ID "Intel" +# if defined(_MSC_VER) +# define SIMULATE_ID "MSVC" +# endif + /* __INTEL_COMPILER = VRP */ +# define COMPILER_VERSION_MAJOR DEC(__INTEL_COMPILER/100) +# define COMPILER_VERSION_MINOR DEC(__INTEL_COMPILER/10 % 10) +# if defined(__INTEL_COMPILER_UPDATE) +# define COMPILER_VERSION_PATCH DEC(__INTEL_COMPILER_UPDATE) +# else +# define COMPILER_VERSION_PATCH DEC(__INTEL_COMPILER % 10) +# endif +# if defined(__INTEL_COMPILER_BUILD_DATE) + /* __INTEL_COMPILER_BUILD_DATE = YYYYMMDD */ +# define COMPILER_VERSION_TWEAK DEC(__INTEL_COMPILER_BUILD_DATE) +# endif +# if defined(_MSC_VER) + /* _MSC_VER = VVRR */ +# define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100) +# define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100) +# endif + +#elif defined(__PATHCC__) +# define COMPILER_ID "PathScale" +# define COMPILER_VERSION_MAJOR DEC(__PATHCC__) +# define COMPILER_VERSION_MINOR DEC(__PATHCC_MINOR__) +# if defined(__PATHCC_PATCHLEVEL__) +# define COMPILER_VERSION_PATCH DEC(__PATHCC_PATCHLEVEL__) +# endif + +#elif defined(__BORLANDC__) && defined(__CODEGEARC_VERSION__) +# define COMPILER_ID "Embarcadero" +# define COMPILER_VERSION_MAJOR HEX(__CODEGEARC_VERSION__>>24 & 0x00FF) +# define COMPILER_VERSION_MINOR HEX(__CODEGEARC_VERSION__>>16 & 0x00FF) +# define COMPILER_VERSION_PATCH DEC(__CODEGEARC_VERSION__ & 0xFFFF) + +#elif defined(__BORLANDC__) +# define COMPILER_ID "Borland" + /* __BORLANDC__ = 0xVRR */ +# define COMPILER_VERSION_MAJOR HEX(__BORLANDC__>>8) +# define COMPILER_VERSION_MINOR HEX(__BORLANDC__ & 0xFF) + +#elif defined(__WATCOMC__) && __WATCOMC__ < 1200 +# define COMPILER_ID "Watcom" + /* __WATCOMC__ = VVRR */ +# define COMPILER_VERSION_MAJOR DEC(__WATCOMC__ / 100) +# define COMPILER_VERSION_MINOR DEC((__WATCOMC__ / 10) % 10) +# if (__WATCOMC__ % 10) > 0 +# define COMPILER_VERSION_PATCH DEC(__WATCOMC__ % 10) +# endif + +#elif defined(__WATCOMC__) +# define COMPILER_ID "OpenWatcom" + /* __WATCOMC__ = VVRP + 1100 */ +# define COMPILER_VERSION_MAJOR DEC((__WATCOMC__ - 1100) / 100) +# define COMPILER_VERSION_MINOR DEC((__WATCOMC__ / 10) % 10) +# if (__WATCOMC__ % 10) > 0 +# define COMPILER_VERSION_PATCH DEC(__WATCOMC__ % 10) +# endif + +#elif defined(__SUNPRO_C) +# define COMPILER_ID "SunPro" +# if __SUNPRO_C >= 0x5100 + /* __SUNPRO_C = 0xVRRP */ +# define COMPILER_VERSION_MAJOR HEX(__SUNPRO_C>>12) +# define COMPILER_VERSION_MINOR HEX(__SUNPRO_C>>4 & 0xFF) +# define COMPILER_VERSION_PATCH HEX(__SUNPRO_C & 0xF) +# else + /* __SUNPRO_CC = 0xVRP */ +# define COMPILER_VERSION_MAJOR HEX(__SUNPRO_C>>8) +# define COMPILER_VERSION_MINOR HEX(__SUNPRO_C>>4 & 0xF) +# define COMPILER_VERSION_PATCH HEX(__SUNPRO_C & 0xF) +# endif + +#elif defined(__HP_cc) +# define COMPILER_ID "HP" + /* __HP_cc = VVRRPP */ +# define COMPILER_VERSION_MAJOR DEC(__HP_cc/10000) +# define COMPILER_VERSION_MINOR DEC(__HP_cc/100 % 100) +# define COMPILER_VERSION_PATCH DEC(__HP_cc % 100) + +#elif defined(__DECC) +# define COMPILER_ID "Compaq" + /* __DECC_VER = VVRRTPPPP */ +# define COMPILER_VERSION_MAJOR DEC(__DECC_VER/10000000) +# define COMPILER_VERSION_MINOR DEC(__DECC_VER/100000 % 100) +# define COMPILER_VERSION_PATCH DEC(__DECC_VER % 10000) + +#elif defined(__IBMC__) && defined(__COMPILER_VER__) +# define COMPILER_ID "zOS" + /* __IBMC__ = VRP */ +# define COMPILER_VERSION_MAJOR DEC(__IBMC__/100) +# define COMPILER_VERSION_MINOR DEC(__IBMC__/10 % 10) +# define COMPILER_VERSION_PATCH DEC(__IBMC__ % 10) + +#elif defined(__IBMC__) && !defined(__COMPILER_VER__) && __IBMC__ >= 800 +# define COMPILER_ID "XL" + /* __IBMC__ = VRP */ +# define COMPILER_VERSION_MAJOR DEC(__IBMC__/100) +# define COMPILER_VERSION_MINOR DEC(__IBMC__/10 % 10) +# define COMPILER_VERSION_PATCH DEC(__IBMC__ % 10) + +#elif defined(__IBMC__) && !defined(__COMPILER_VER__) && __IBMC__ < 800 +# define COMPILER_ID "VisualAge" + /* __IBMC__ = VRP */ +# define COMPILER_VERSION_MAJOR DEC(__IBMC__/100) +# define COMPILER_VERSION_MINOR DEC(__IBMC__/10 % 10) +# define COMPILER_VERSION_PATCH DEC(__IBMC__ % 10) + +#elif defined(__PGI) +# define COMPILER_ID "PGI" +# define COMPILER_VERSION_MAJOR DEC(__PGIC__) +# define COMPILER_VERSION_MINOR DEC(__PGIC_MINOR__) +# if defined(__PGIC_PATCHLEVEL__) +# define COMPILER_VERSION_PATCH DEC(__PGIC_PATCHLEVEL__) +# endif + +#elif defined(_CRAYC) +# define COMPILER_ID "Cray" +# define COMPILER_VERSION_MAJOR DEC(_RELEASE_MAJOR) +# define COMPILER_VERSION_MINOR DEC(_RELEASE_MINOR) + +#elif defined(__TI_COMPILER_VERSION__) +# define COMPILER_ID "TI" + /* __TI_COMPILER_VERSION__ = VVVRRRPPP */ +# define COMPILER_VERSION_MAJOR DEC(__TI_COMPILER_VERSION__/1000000) +# define COMPILER_VERSION_MINOR DEC(__TI_COMPILER_VERSION__/1000 % 1000) +# define COMPILER_VERSION_PATCH DEC(__TI_COMPILER_VERSION__ % 1000) + +#elif defined(__FUJITSU) || defined(__FCC_VERSION) || defined(__fcc_version) +# define COMPILER_ID "Fujitsu" + +#elif defined(__TINYC__) +# define COMPILER_ID "TinyCC" + +#elif defined(__SCO_VERSION__) +# define COMPILER_ID "SCO" + +#elif defined(__clang__) && defined(__apple_build_version__) +# define COMPILER_ID "AppleClang" +# if defined(_MSC_VER) +# define SIMULATE_ID "MSVC" +# endif +# define COMPILER_VERSION_MAJOR DEC(__clang_major__) +# define COMPILER_VERSION_MINOR DEC(__clang_minor__) +# define COMPILER_VERSION_PATCH DEC(__clang_patchlevel__) +# if defined(_MSC_VER) + /* _MSC_VER = VVRR */ +# define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100) +# define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100) +# endif +# define COMPILER_VERSION_TWEAK DEC(__apple_build_version__) + +#elif defined(__clang__) +# define COMPILER_ID "Clang" +# if defined(_MSC_VER) +# define SIMULATE_ID "MSVC" +# endif +# define COMPILER_VERSION_MAJOR DEC(__clang_major__) +# define COMPILER_VERSION_MINOR DEC(__clang_minor__) +# define COMPILER_VERSION_PATCH DEC(__clang_patchlevel__) +# if defined(_MSC_VER) + /* _MSC_VER = VVRR */ +# define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100) +# define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100) +# endif + +#elif defined(__GNUC__) +# define COMPILER_ID "GNU" +# define COMPILER_VERSION_MAJOR DEC(__GNUC__) +# if defined(__GNUC_MINOR__) +# define COMPILER_VERSION_MINOR DEC(__GNUC_MINOR__) +# endif +# if defined(__GNUC_PATCHLEVEL__) +# define COMPILER_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__) +# endif + +#elif defined(_MSC_VER) +# define COMPILER_ID "MSVC" + /* _MSC_VER = VVRR */ +# define COMPILER_VERSION_MAJOR DEC(_MSC_VER / 100) +# define COMPILER_VERSION_MINOR DEC(_MSC_VER % 100) +# if defined(_MSC_FULL_VER) +# if _MSC_VER >= 1400 + /* _MSC_FULL_VER = VVRRPPPPP */ +# define COMPILER_VERSION_PATCH DEC(_MSC_FULL_VER % 100000) +# else + /* _MSC_FULL_VER = VVRRPPPP */ +# define COMPILER_VERSION_PATCH DEC(_MSC_FULL_VER % 10000) +# endif +# endif +# if defined(_MSC_BUILD) +# define COMPILER_VERSION_TWEAK DEC(_MSC_BUILD) +# endif + +#elif defined(__VISUALDSPVERSION__) || defined(__ADSPBLACKFIN__) || defined(__ADSPTS__) || defined(__ADSP21000__) +# define COMPILER_ID "ADSP" +#if defined(__VISUALDSPVERSION__) + /* __VISUALDSPVERSION__ = 0xVVRRPP00 */ +# define COMPILER_VERSION_MAJOR HEX(__VISUALDSPVERSION__>>24) +# define COMPILER_VERSION_MINOR HEX(__VISUALDSPVERSION__>>16 & 0xFF) +# define COMPILER_VERSION_PATCH HEX(__VISUALDSPVERSION__>>8 & 0xFF) +#endif + +#elif defined(__IAR_SYSTEMS_ICC__ ) || defined(__IAR_SYSTEMS_ICC) +# define COMPILER_ID "IAR" + +#elif defined(__ARMCC_VERSION) +# define COMPILER_ID "ARMCC" +#if __ARMCC_VERSION >= 1000000 + /* __ARMCC_VERSION = VRRPPPP */ + # define COMPILER_VERSION_MAJOR DEC(__ARMCC_VERSION/1000000) + # define COMPILER_VERSION_MINOR DEC(__ARMCC_VERSION/10000 % 100) + # define COMPILER_VERSION_PATCH DEC(__ARMCC_VERSION % 10000) +#else + /* __ARMCC_VERSION = VRPPPP */ + # define COMPILER_VERSION_MAJOR DEC(__ARMCC_VERSION/100000) + # define COMPILER_VERSION_MINOR DEC(__ARMCC_VERSION/10000 % 10) + # define COMPILER_VERSION_PATCH DEC(__ARMCC_VERSION % 10000) +#endif + + +#elif defined(SDCC) +# define COMPILER_ID "SDCC" + /* SDCC = VRP */ +# define COMPILER_VERSION_MAJOR DEC(SDCC/100) +# define COMPILER_VERSION_MINOR DEC(SDCC/10 % 10) +# define COMPILER_VERSION_PATCH DEC(SDCC % 10) + +#elif defined(_SGI_COMPILER_VERSION) || defined(_COMPILER_VERSION) +# define COMPILER_ID "MIPSpro" +# if defined(_SGI_COMPILER_VERSION) + /* _SGI_COMPILER_VERSION = VRP */ +# define COMPILER_VERSION_MAJOR DEC(_SGI_COMPILER_VERSION/100) +# define COMPILER_VERSION_MINOR DEC(_SGI_COMPILER_VERSION/10 % 10) +# define COMPILER_VERSION_PATCH DEC(_SGI_COMPILER_VERSION % 10) +# else + /* _COMPILER_VERSION = VRP */ +# define COMPILER_VERSION_MAJOR DEC(_COMPILER_VERSION/100) +# define COMPILER_VERSION_MINOR DEC(_COMPILER_VERSION/10 % 10) +# define COMPILER_VERSION_PATCH DEC(_COMPILER_VERSION % 10) +# endif + + +/* These compilers are either not known or too old to define an + identification macro. Try to identify the platform and guess that + it is the native compiler. */ +#elif defined(__sgi) +# define COMPILER_ID "MIPSpro" + +#elif defined(__hpux) || defined(__hpua) +# define COMPILER_ID "HP" + +#else /* unknown compiler */ +# define COMPILER_ID "" +#endif + +/* Construct the string literal in pieces to prevent the source from + getting matched. Store it in a pointer rather than an array + because some compilers will just produce instructions to fill the + array rather than assigning a pointer to a static array. */ +char const* info_compiler = "INFO" ":" "compiler[" COMPILER_ID "]"; +#ifdef SIMULATE_ID +char const* info_simulate = "INFO" ":" "simulate[" SIMULATE_ID "]"; +#endif + +#ifdef __QNXNTO__ +char const* qnxnto = "INFO" ":" "qnxnto[]"; +#endif + +#if defined(__CRAYXE) || defined(__CRAYXC) +char const *info_cray = "INFO" ":" "compiler_wrapper[CrayPrgEnv]"; +#endif + +#define STRINGIFY_HELPER(X) #X +#define STRINGIFY(X) STRINGIFY_HELPER(X) + +/* Identify known platforms by name. */ +#if defined(__linux) || defined(__linux__) || defined(linux) +# define PLATFORM_ID "Linux" + +#elif defined(__CYGWIN__) +# define PLATFORM_ID "Cygwin" + +#elif defined(__MINGW32__) +# define PLATFORM_ID "MinGW" + +#elif defined(__APPLE__) +# define PLATFORM_ID "Darwin" + +#elif defined(_WIN32) || defined(__WIN32__) || defined(WIN32) +# define PLATFORM_ID "Windows" + +#elif defined(__FreeBSD__) || defined(__FreeBSD) +# define PLATFORM_ID "FreeBSD" + +#elif defined(__NetBSD__) || defined(__NetBSD) +# define PLATFORM_ID "NetBSD" + +#elif defined(__OpenBSD__) || defined(__OPENBSD) +# define PLATFORM_ID "OpenBSD" + +#elif defined(__sun) || defined(sun) +# define PLATFORM_ID "SunOS" + +#elif defined(_AIX) || defined(__AIX) || defined(__AIX__) || defined(__aix) || defined(__aix__) +# define PLATFORM_ID "AIX" + +#elif defined(__sgi) || defined(__sgi__) || defined(_SGI) +# define PLATFORM_ID "IRIX" + +#elif defined(__hpux) || defined(__hpux__) +# define PLATFORM_ID "HP-UX" + +#elif defined(__HAIKU__) +# define PLATFORM_ID "Haiku" + +#elif defined(__BeOS) || defined(__BEOS__) || defined(_BEOS) +# define PLATFORM_ID "BeOS" + +#elif defined(__QNX__) || defined(__QNXNTO__) +# define PLATFORM_ID "QNX" + +#elif defined(__tru64) || defined(_tru64) || defined(__TRU64__) +# define PLATFORM_ID "Tru64" + +#elif defined(__riscos) || defined(__riscos__) +# define PLATFORM_ID "RISCos" + +#elif defined(__sinix) || defined(__sinix__) || defined(__SINIX__) +# define PLATFORM_ID "SINIX" + +#elif defined(__UNIX_SV__) +# define PLATFORM_ID "UNIX_SV" + +#elif defined(__bsdos__) +# define PLATFORM_ID "BSDOS" + +#elif defined(_MPRAS) || defined(MPRAS) +# define PLATFORM_ID "MP-RAS" + +#elif defined(__osf) || defined(__osf__) +# define PLATFORM_ID "OSF1" + +#elif defined(_SCO_SV) || defined(SCO_SV) || defined(sco_sv) +# define PLATFORM_ID "SCO_SV" + +#elif defined(__ultrix) || defined(__ultrix__) || defined(_ULTRIX) +# define PLATFORM_ID "ULTRIX" + +#elif defined(__XENIX__) || defined(_XENIX) || defined(XENIX) +# define PLATFORM_ID "Xenix" + +#elif defined(__WATCOMC__) +# if defined(__LINUX__) +# define PLATFORM_ID "Linux" + +# elif defined(__DOS__) +# define PLATFORM_ID "DOS" + +# elif defined(__OS2__) +# define PLATFORM_ID "OS2" + +# elif defined(__WINDOWS__) +# define PLATFORM_ID "Windows3x" + +# else /* unknown platform */ +# define PLATFORM_ID "" +# endif + +#else /* unknown platform */ +# define PLATFORM_ID "" + +#endif + +/* For windows compilers MSVC and Intel we can determine + the architecture of the compiler being used. This is because + the compilers do not have flags that can change the architecture, + but rather depend on which compiler is being used +*/ +#if defined(_WIN32) && defined(_MSC_VER) +# if defined(_M_IA64) +# define ARCHITECTURE_ID "IA64" + +# elif defined(_M_X64) || defined(_M_AMD64) +# define ARCHITECTURE_ID "x64" + +# elif defined(_M_IX86) +# define ARCHITECTURE_ID "X86" + +# elif defined(_M_ARM) +# if _M_ARM == 4 +# define ARCHITECTURE_ID "ARMV4I" +# elif _M_ARM == 5 +# define ARCHITECTURE_ID "ARMV5I" +# else +# define ARCHITECTURE_ID "ARMV" STRINGIFY(_M_ARM) +# endif + +# elif defined(_M_MIPS) +# define ARCHITECTURE_ID "MIPS" + +# elif defined(_M_SH) +# define ARCHITECTURE_ID "SHx" + +# else /* unknown architecture */ +# define ARCHITECTURE_ID "" +# endif + +#elif defined(__WATCOMC__) +# if defined(_M_I86) +# define ARCHITECTURE_ID "I86" + +# elif defined(_M_IX86) +# define ARCHITECTURE_ID "X86" + +# else /* unknown architecture */ +# define ARCHITECTURE_ID "" +# endif + +#else +# define ARCHITECTURE_ID "" +#endif + +/* Convert integer to decimal digit literals. */ +#define DEC(n) \ + ('0' + (((n) / 10000000)%10)), \ + ('0' + (((n) / 1000000)%10)), \ + ('0' + (((n) / 100000)%10)), \ + ('0' + (((n) / 10000)%10)), \ + ('0' + (((n) / 1000)%10)), \ + ('0' + (((n) / 100)%10)), \ + ('0' + (((n) / 10)%10)), \ + ('0' + ((n) % 10)) + +/* Convert integer to hex digit literals. */ +#define HEX(n) \ + ('0' + ((n)>>28 & 0xF)), \ + ('0' + ((n)>>24 & 0xF)), \ + ('0' + ((n)>>20 & 0xF)), \ + ('0' + ((n)>>16 & 0xF)), \ + ('0' + ((n)>>12 & 0xF)), \ + ('0' + ((n)>>8 & 0xF)), \ + ('0' + ((n)>>4 & 0xF)), \ + ('0' + ((n) & 0xF)) + +/* Construct a string literal encoding the version number components. */ +#ifdef COMPILER_VERSION_MAJOR +char const info_version[] = { + 'I', 'N', 'F', 'O', ':', + 'c','o','m','p','i','l','e','r','_','v','e','r','s','i','o','n','[', + COMPILER_VERSION_MAJOR, +# ifdef COMPILER_VERSION_MINOR + '.', COMPILER_VERSION_MINOR, +# ifdef COMPILER_VERSION_PATCH + '.', COMPILER_VERSION_PATCH, +# ifdef COMPILER_VERSION_TWEAK + '.', COMPILER_VERSION_TWEAK, +# endif +# endif +# endif + ']','\0'}; +#endif + +/* Construct a string literal encoding the version number components. */ +#ifdef SIMULATE_VERSION_MAJOR +char const info_simulate_version[] = { + 'I', 'N', 'F', 'O', ':', + 's','i','m','u','l','a','t','e','_','v','e','r','s','i','o','n','[', + SIMULATE_VERSION_MAJOR, +# ifdef SIMULATE_VERSION_MINOR + '.', SIMULATE_VERSION_MINOR, +# ifdef SIMULATE_VERSION_PATCH + '.', SIMULATE_VERSION_PATCH, +# ifdef SIMULATE_VERSION_TWEAK + '.', SIMULATE_VERSION_TWEAK, +# endif +# endif +# endif + ']','\0'}; +#endif + +/* Construct the string literal in pieces to prevent the source from + getting matched. Store it in a pointer rather than an array + because some compilers will just produce instructions to fill the + array rather than assigning a pointer to a static array. */ +char const* info_platform = "INFO" ":" "platform[" PLATFORM_ID "]"; +char const* info_arch = "INFO" ":" "arch[" ARCHITECTURE_ID "]"; + + + + +const char* info_language_dialect_default = "INFO" ":" "dialect_default[" +#if !defined(__STDC_VERSION__) + "90" +#elif __STDC_VERSION__ >= 201000L + "11" +#elif __STDC_VERSION__ >= 199901L + "99" +#else +#endif +"]"; + +/*--------------------------------------------------------------------------*/ + +#ifdef ID_VOID_MAIN +void main() {} +#else +int main(int argc, char* argv[]) +{ + int require = 0; + require += info_compiler[argc]; + require += info_platform[argc]; + require += info_arch[argc]; +#ifdef COMPILER_VERSION_MAJOR + require += info_version[argc]; +#endif +#ifdef SIMULATE_ID + require += info_simulate[argc]; +#endif +#ifdef SIMULATE_VERSION_MAJOR + require += info_simulate_version[argc]; +#endif +#if defined(__CRAYXE) || defined(__CRAYXC) + require += info_cray[argc]; +#endif + require += info_language_dialect_default[argc]; + (void)argv; + return require; +} +#endif diff --git a/realsense-file/CMakeFiles/3.5.1/CompilerIdC/a.out b/realsense-file/CMakeFiles/3.5.1/CompilerIdC/a.out new file mode 100644 index 0000000000..fb72cd4054 Binary files /dev/null and b/realsense-file/CMakeFiles/3.5.1/CompilerIdC/a.out differ diff --git a/realsense-file/CMakeFiles/3.5.1/CompilerIdCXX/CMakeCXXCompilerId.cpp b/realsense-file/CMakeFiles/3.5.1/CompilerIdCXX/CMakeCXXCompilerId.cpp new file mode 100644 index 0000000000..e6d853637c --- /dev/null +++ b/realsense-file/CMakeFiles/3.5.1/CompilerIdCXX/CMakeCXXCompilerId.cpp @@ -0,0 +1,533 @@ +/* This source file must have a .cpp extension so that all C++ compilers + recognize the extension without flags. Borland does not know .cxx for + example. */ +#ifndef __cplusplus +# error "A C compiler has been selected for C++." +#endif + + +/* Version number components: V=Version, R=Revision, P=Patch + Version date components: YYYY=Year, MM=Month, DD=Day */ + +#if defined(__COMO__) +# define COMPILER_ID "Comeau" + /* __COMO_VERSION__ = VRR */ +# define COMPILER_VERSION_MAJOR DEC(__COMO_VERSION__ / 100) +# define COMPILER_VERSION_MINOR DEC(__COMO_VERSION__ % 100) + +#elif defined(__INTEL_COMPILER) || defined(__ICC) +# define COMPILER_ID "Intel" +# if defined(_MSC_VER) +# define SIMULATE_ID "MSVC" +# endif + /* __INTEL_COMPILER = VRP */ +# define COMPILER_VERSION_MAJOR DEC(__INTEL_COMPILER/100) +# define COMPILER_VERSION_MINOR DEC(__INTEL_COMPILER/10 % 10) +# if defined(__INTEL_COMPILER_UPDATE) +# define COMPILER_VERSION_PATCH DEC(__INTEL_COMPILER_UPDATE) +# else +# define COMPILER_VERSION_PATCH DEC(__INTEL_COMPILER % 10) +# endif +# if defined(__INTEL_COMPILER_BUILD_DATE) + /* __INTEL_COMPILER_BUILD_DATE = YYYYMMDD */ +# define COMPILER_VERSION_TWEAK DEC(__INTEL_COMPILER_BUILD_DATE) +# endif +# if defined(_MSC_VER) + /* _MSC_VER = VVRR */ +# define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100) +# define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100) +# endif + +#elif defined(__PATHCC__) +# define COMPILER_ID "PathScale" +# define COMPILER_VERSION_MAJOR DEC(__PATHCC__) +# define COMPILER_VERSION_MINOR DEC(__PATHCC_MINOR__) +# if defined(__PATHCC_PATCHLEVEL__) +# define COMPILER_VERSION_PATCH DEC(__PATHCC_PATCHLEVEL__) +# endif + +#elif defined(__BORLANDC__) && defined(__CODEGEARC_VERSION__) +# define COMPILER_ID "Embarcadero" +# define COMPILER_VERSION_MAJOR HEX(__CODEGEARC_VERSION__>>24 & 0x00FF) +# define COMPILER_VERSION_MINOR HEX(__CODEGEARC_VERSION__>>16 & 0x00FF) +# define COMPILER_VERSION_PATCH DEC(__CODEGEARC_VERSION__ & 0xFFFF) + +#elif defined(__BORLANDC__) +# define COMPILER_ID "Borland" + /* __BORLANDC__ = 0xVRR */ +# define COMPILER_VERSION_MAJOR HEX(__BORLANDC__>>8) +# define COMPILER_VERSION_MINOR HEX(__BORLANDC__ & 0xFF) + +#elif defined(__WATCOMC__) && __WATCOMC__ < 1200 +# define COMPILER_ID "Watcom" + /* __WATCOMC__ = VVRR */ +# define COMPILER_VERSION_MAJOR DEC(__WATCOMC__ / 100) +# define COMPILER_VERSION_MINOR DEC((__WATCOMC__ / 10) % 10) +# if (__WATCOMC__ % 10) > 0 +# define COMPILER_VERSION_PATCH DEC(__WATCOMC__ % 10) +# endif + +#elif defined(__WATCOMC__) +# define COMPILER_ID "OpenWatcom" + /* __WATCOMC__ = VVRP + 1100 */ +# define COMPILER_VERSION_MAJOR DEC((__WATCOMC__ - 1100) / 100) +# define COMPILER_VERSION_MINOR DEC((__WATCOMC__ / 10) % 10) +# if (__WATCOMC__ % 10) > 0 +# define COMPILER_VERSION_PATCH DEC(__WATCOMC__ % 10) +# endif + +#elif defined(__SUNPRO_CC) +# define COMPILER_ID "SunPro" +# if __SUNPRO_CC >= 0x5100 + /* __SUNPRO_CC = 0xVRRP */ +# define COMPILER_VERSION_MAJOR HEX(__SUNPRO_CC>>12) +# define COMPILER_VERSION_MINOR HEX(__SUNPRO_CC>>4 & 0xFF) +# define COMPILER_VERSION_PATCH HEX(__SUNPRO_CC & 0xF) +# else + /* __SUNPRO_CC = 0xVRP */ +# define COMPILER_VERSION_MAJOR HEX(__SUNPRO_CC>>8) +# define COMPILER_VERSION_MINOR HEX(__SUNPRO_CC>>4 & 0xF) +# define COMPILER_VERSION_PATCH HEX(__SUNPRO_CC & 0xF) +# endif + +#elif defined(__HP_aCC) +# define COMPILER_ID "HP" + /* __HP_aCC = VVRRPP */ +# define COMPILER_VERSION_MAJOR DEC(__HP_aCC/10000) +# define COMPILER_VERSION_MINOR DEC(__HP_aCC/100 % 100) +# define COMPILER_VERSION_PATCH DEC(__HP_aCC % 100) + +#elif defined(__DECCXX) +# define COMPILER_ID "Compaq" + /* __DECCXX_VER = VVRRTPPPP */ +# define COMPILER_VERSION_MAJOR DEC(__DECCXX_VER/10000000) +# define COMPILER_VERSION_MINOR DEC(__DECCXX_VER/100000 % 100) +# define COMPILER_VERSION_PATCH DEC(__DECCXX_VER % 10000) + +#elif defined(__IBMCPP__) && defined(__COMPILER_VER__) +# define COMPILER_ID "zOS" + /* __IBMCPP__ = VRP */ +# define COMPILER_VERSION_MAJOR DEC(__IBMCPP__/100) +# define COMPILER_VERSION_MINOR DEC(__IBMCPP__/10 % 10) +# define COMPILER_VERSION_PATCH DEC(__IBMCPP__ % 10) + +#elif defined(__IBMCPP__) && !defined(__COMPILER_VER__) && __IBMCPP__ >= 800 +# define COMPILER_ID "XL" + /* __IBMCPP__ = VRP */ +# define COMPILER_VERSION_MAJOR DEC(__IBMCPP__/100) +# define COMPILER_VERSION_MINOR DEC(__IBMCPP__/10 % 10) +# define COMPILER_VERSION_PATCH DEC(__IBMCPP__ % 10) + +#elif defined(__IBMCPP__) && !defined(__COMPILER_VER__) && __IBMCPP__ < 800 +# define COMPILER_ID "VisualAge" + /* __IBMCPP__ = VRP */ +# define COMPILER_VERSION_MAJOR DEC(__IBMCPP__/100) +# define COMPILER_VERSION_MINOR DEC(__IBMCPP__/10 % 10) +# define COMPILER_VERSION_PATCH DEC(__IBMCPP__ % 10) + +#elif defined(__PGI) +# define COMPILER_ID "PGI" +# define COMPILER_VERSION_MAJOR DEC(__PGIC__) +# define COMPILER_VERSION_MINOR DEC(__PGIC_MINOR__) +# if defined(__PGIC_PATCHLEVEL__) +# define COMPILER_VERSION_PATCH DEC(__PGIC_PATCHLEVEL__) +# endif + +#elif defined(_CRAYC) +# define COMPILER_ID "Cray" +# define COMPILER_VERSION_MAJOR DEC(_RELEASE_MAJOR) +# define COMPILER_VERSION_MINOR DEC(_RELEASE_MINOR) + +#elif defined(__TI_COMPILER_VERSION__) +# define COMPILER_ID "TI" + /* __TI_COMPILER_VERSION__ = VVVRRRPPP */ +# define COMPILER_VERSION_MAJOR DEC(__TI_COMPILER_VERSION__/1000000) +# define COMPILER_VERSION_MINOR DEC(__TI_COMPILER_VERSION__/1000 % 1000) +# define COMPILER_VERSION_PATCH DEC(__TI_COMPILER_VERSION__ % 1000) + +#elif defined(__FUJITSU) || defined(__FCC_VERSION) || defined(__fcc_version) +# define COMPILER_ID "Fujitsu" + +#elif defined(__SCO_VERSION__) +# define COMPILER_ID "SCO" + +#elif defined(__clang__) && defined(__apple_build_version__) +# define COMPILER_ID "AppleClang" +# if defined(_MSC_VER) +# define SIMULATE_ID "MSVC" +# endif +# define COMPILER_VERSION_MAJOR DEC(__clang_major__) +# define COMPILER_VERSION_MINOR DEC(__clang_minor__) +# define COMPILER_VERSION_PATCH DEC(__clang_patchlevel__) +# if defined(_MSC_VER) + /* _MSC_VER = VVRR */ +# define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100) +# define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100) +# endif +# define COMPILER_VERSION_TWEAK DEC(__apple_build_version__) + +#elif defined(__clang__) +# define COMPILER_ID "Clang" +# if defined(_MSC_VER) +# define SIMULATE_ID "MSVC" +# endif +# define COMPILER_VERSION_MAJOR DEC(__clang_major__) +# define COMPILER_VERSION_MINOR DEC(__clang_minor__) +# define COMPILER_VERSION_PATCH DEC(__clang_patchlevel__) +# if defined(_MSC_VER) + /* _MSC_VER = VVRR */ +# define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100) +# define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100) +# endif + +#elif defined(__GNUC__) +# define COMPILER_ID "GNU" +# define COMPILER_VERSION_MAJOR DEC(__GNUC__) +# if defined(__GNUC_MINOR__) +# define COMPILER_VERSION_MINOR DEC(__GNUC_MINOR__) +# endif +# if defined(__GNUC_PATCHLEVEL__) +# define COMPILER_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__) +# endif + +#elif defined(_MSC_VER) +# define COMPILER_ID "MSVC" + /* _MSC_VER = VVRR */ +# define COMPILER_VERSION_MAJOR DEC(_MSC_VER / 100) +# define COMPILER_VERSION_MINOR DEC(_MSC_VER % 100) +# if defined(_MSC_FULL_VER) +# if _MSC_VER >= 1400 + /* _MSC_FULL_VER = VVRRPPPPP */ +# define COMPILER_VERSION_PATCH DEC(_MSC_FULL_VER % 100000) +# else + /* _MSC_FULL_VER = VVRRPPPP */ +# define COMPILER_VERSION_PATCH DEC(_MSC_FULL_VER % 10000) +# endif +# endif +# if defined(_MSC_BUILD) +# define COMPILER_VERSION_TWEAK DEC(_MSC_BUILD) +# endif + +#elif defined(__VISUALDSPVERSION__) || defined(__ADSPBLACKFIN__) || defined(__ADSPTS__) || defined(__ADSP21000__) +# define COMPILER_ID "ADSP" +#if defined(__VISUALDSPVERSION__) + /* __VISUALDSPVERSION__ = 0xVVRRPP00 */ +# define COMPILER_VERSION_MAJOR HEX(__VISUALDSPVERSION__>>24) +# define COMPILER_VERSION_MINOR HEX(__VISUALDSPVERSION__>>16 & 0xFF) +# define COMPILER_VERSION_PATCH HEX(__VISUALDSPVERSION__>>8 & 0xFF) +#endif + +#elif defined(__IAR_SYSTEMS_ICC__ ) || defined(__IAR_SYSTEMS_ICC) +# define COMPILER_ID "IAR" + +#elif defined(__ARMCC_VERSION) +# define COMPILER_ID "ARMCC" +#if __ARMCC_VERSION >= 1000000 + /* __ARMCC_VERSION = VRRPPPP */ + # define COMPILER_VERSION_MAJOR DEC(__ARMCC_VERSION/1000000) + # define COMPILER_VERSION_MINOR DEC(__ARMCC_VERSION/10000 % 100) + # define COMPILER_VERSION_PATCH DEC(__ARMCC_VERSION % 10000) +#else + /* __ARMCC_VERSION = VRPPPP */ + # define COMPILER_VERSION_MAJOR DEC(__ARMCC_VERSION/100000) + # define COMPILER_VERSION_MINOR DEC(__ARMCC_VERSION/10000 % 10) + # define COMPILER_VERSION_PATCH DEC(__ARMCC_VERSION % 10000) +#endif + + +#elif defined(_SGI_COMPILER_VERSION) || defined(_COMPILER_VERSION) +# define COMPILER_ID "MIPSpro" +# if defined(_SGI_COMPILER_VERSION) + /* _SGI_COMPILER_VERSION = VRP */ +# define COMPILER_VERSION_MAJOR DEC(_SGI_COMPILER_VERSION/100) +# define COMPILER_VERSION_MINOR DEC(_SGI_COMPILER_VERSION/10 % 10) +# define COMPILER_VERSION_PATCH DEC(_SGI_COMPILER_VERSION % 10) +# else + /* _COMPILER_VERSION = VRP */ +# define COMPILER_VERSION_MAJOR DEC(_COMPILER_VERSION/100) +# define COMPILER_VERSION_MINOR DEC(_COMPILER_VERSION/10 % 10) +# define COMPILER_VERSION_PATCH DEC(_COMPILER_VERSION % 10) +# endif + + +/* These compilers are either not known or too old to define an + identification macro. Try to identify the platform and guess that + it is the native compiler. */ +#elif defined(__sgi) +# define COMPILER_ID "MIPSpro" + +#elif defined(__hpux) || defined(__hpua) +# define COMPILER_ID "HP" + +#else /* unknown compiler */ +# define COMPILER_ID "" +#endif + +/* Construct the string literal in pieces to prevent the source from + getting matched. Store it in a pointer rather than an array + because some compilers will just produce instructions to fill the + array rather than assigning a pointer to a static array. */ +char const* info_compiler = "INFO" ":" "compiler[" COMPILER_ID "]"; +#ifdef SIMULATE_ID +char const* info_simulate = "INFO" ":" "simulate[" SIMULATE_ID "]"; +#endif + +#ifdef __QNXNTO__ +char const* qnxnto = "INFO" ":" "qnxnto[]"; +#endif + +#if defined(__CRAYXE) || defined(__CRAYXC) +char const *info_cray = "INFO" ":" "compiler_wrapper[CrayPrgEnv]"; +#endif + +#define STRINGIFY_HELPER(X) #X +#define STRINGIFY(X) STRINGIFY_HELPER(X) + +/* Identify known platforms by name. */ +#if defined(__linux) || defined(__linux__) || defined(linux) +# define PLATFORM_ID "Linux" + +#elif defined(__CYGWIN__) +# define PLATFORM_ID "Cygwin" + +#elif defined(__MINGW32__) +# define PLATFORM_ID "MinGW" + +#elif defined(__APPLE__) +# define PLATFORM_ID "Darwin" + +#elif defined(_WIN32) || defined(__WIN32__) || defined(WIN32) +# define PLATFORM_ID "Windows" + +#elif defined(__FreeBSD__) || defined(__FreeBSD) +# define PLATFORM_ID "FreeBSD" + +#elif defined(__NetBSD__) || defined(__NetBSD) +# define PLATFORM_ID "NetBSD" + +#elif defined(__OpenBSD__) || defined(__OPENBSD) +# define PLATFORM_ID "OpenBSD" + +#elif defined(__sun) || defined(sun) +# define PLATFORM_ID "SunOS" + +#elif defined(_AIX) || defined(__AIX) || defined(__AIX__) || defined(__aix) || defined(__aix__) +# define PLATFORM_ID "AIX" + +#elif defined(__sgi) || defined(__sgi__) || defined(_SGI) +# define PLATFORM_ID "IRIX" + +#elif defined(__hpux) || defined(__hpux__) +# define PLATFORM_ID "HP-UX" + +#elif defined(__HAIKU__) +# define PLATFORM_ID "Haiku" + +#elif defined(__BeOS) || defined(__BEOS__) || defined(_BEOS) +# define PLATFORM_ID "BeOS" + +#elif defined(__QNX__) || defined(__QNXNTO__) +# define PLATFORM_ID "QNX" + +#elif defined(__tru64) || defined(_tru64) || defined(__TRU64__) +# define PLATFORM_ID "Tru64" + +#elif defined(__riscos) || defined(__riscos__) +# define PLATFORM_ID "RISCos" + +#elif defined(__sinix) || defined(__sinix__) || defined(__SINIX__) +# define PLATFORM_ID "SINIX" + +#elif defined(__UNIX_SV__) +# define PLATFORM_ID "UNIX_SV" + +#elif defined(__bsdos__) +# define PLATFORM_ID "BSDOS" + +#elif defined(_MPRAS) || defined(MPRAS) +# define PLATFORM_ID "MP-RAS" + +#elif defined(__osf) || defined(__osf__) +# define PLATFORM_ID "OSF1" + +#elif defined(_SCO_SV) || defined(SCO_SV) || defined(sco_sv) +# define PLATFORM_ID "SCO_SV" + +#elif defined(__ultrix) || defined(__ultrix__) || defined(_ULTRIX) +# define PLATFORM_ID "ULTRIX" + +#elif defined(__XENIX__) || defined(_XENIX) || defined(XENIX) +# define PLATFORM_ID "Xenix" + +#elif defined(__WATCOMC__) +# if defined(__LINUX__) +# define PLATFORM_ID "Linux" + +# elif defined(__DOS__) +# define PLATFORM_ID "DOS" + +# elif defined(__OS2__) +# define PLATFORM_ID "OS2" + +# elif defined(__WINDOWS__) +# define PLATFORM_ID "Windows3x" + +# else /* unknown platform */ +# define PLATFORM_ID "" +# endif + +#else /* unknown platform */ +# define PLATFORM_ID "" + +#endif + +/* For windows compilers MSVC and Intel we can determine + the architecture of the compiler being used. This is because + the compilers do not have flags that can change the architecture, + but rather depend on which compiler is being used +*/ +#if defined(_WIN32) && defined(_MSC_VER) +# if defined(_M_IA64) +# define ARCHITECTURE_ID "IA64" + +# elif defined(_M_X64) || defined(_M_AMD64) +# define ARCHITECTURE_ID "x64" + +# elif defined(_M_IX86) +# define ARCHITECTURE_ID "X86" + +# elif defined(_M_ARM) +# if _M_ARM == 4 +# define ARCHITECTURE_ID "ARMV4I" +# elif _M_ARM == 5 +# define ARCHITECTURE_ID "ARMV5I" +# else +# define ARCHITECTURE_ID "ARMV" STRINGIFY(_M_ARM) +# endif + +# elif defined(_M_MIPS) +# define ARCHITECTURE_ID "MIPS" + +# elif defined(_M_SH) +# define ARCHITECTURE_ID "SHx" + +# else /* unknown architecture */ +# define ARCHITECTURE_ID "" +# endif + +#elif defined(__WATCOMC__) +# if defined(_M_I86) +# define ARCHITECTURE_ID "I86" + +# elif defined(_M_IX86) +# define ARCHITECTURE_ID "X86" + +# else /* unknown architecture */ +# define ARCHITECTURE_ID "" +# endif + +#else +# define ARCHITECTURE_ID "" +#endif + +/* Convert integer to decimal digit literals. */ +#define DEC(n) \ + ('0' + (((n) / 10000000)%10)), \ + ('0' + (((n) / 1000000)%10)), \ + ('0' + (((n) / 100000)%10)), \ + ('0' + (((n) / 10000)%10)), \ + ('0' + (((n) / 1000)%10)), \ + ('0' + (((n) / 100)%10)), \ + ('0' + (((n) / 10)%10)), \ + ('0' + ((n) % 10)) + +/* Convert integer to hex digit literals. */ +#define HEX(n) \ + ('0' + ((n)>>28 & 0xF)), \ + ('0' + ((n)>>24 & 0xF)), \ + ('0' + ((n)>>20 & 0xF)), \ + ('0' + ((n)>>16 & 0xF)), \ + ('0' + ((n)>>12 & 0xF)), \ + ('0' + ((n)>>8 & 0xF)), \ + ('0' + ((n)>>4 & 0xF)), \ + ('0' + ((n) & 0xF)) + +/* Construct a string literal encoding the version number components. */ +#ifdef COMPILER_VERSION_MAJOR +char const info_version[] = { + 'I', 'N', 'F', 'O', ':', + 'c','o','m','p','i','l','e','r','_','v','e','r','s','i','o','n','[', + COMPILER_VERSION_MAJOR, +# ifdef COMPILER_VERSION_MINOR + '.', COMPILER_VERSION_MINOR, +# ifdef COMPILER_VERSION_PATCH + '.', COMPILER_VERSION_PATCH, +# ifdef COMPILER_VERSION_TWEAK + '.', COMPILER_VERSION_TWEAK, +# endif +# endif +# endif + ']','\0'}; +#endif + +/* Construct a string literal encoding the version number components. */ +#ifdef SIMULATE_VERSION_MAJOR +char const info_simulate_version[] = { + 'I', 'N', 'F', 'O', ':', + 's','i','m','u','l','a','t','e','_','v','e','r','s','i','o','n','[', + SIMULATE_VERSION_MAJOR, +# ifdef SIMULATE_VERSION_MINOR + '.', SIMULATE_VERSION_MINOR, +# ifdef SIMULATE_VERSION_PATCH + '.', SIMULATE_VERSION_PATCH, +# ifdef SIMULATE_VERSION_TWEAK + '.', SIMULATE_VERSION_TWEAK, +# endif +# endif +# endif + ']','\0'}; +#endif + +/* Construct the string literal in pieces to prevent the source from + getting matched. Store it in a pointer rather than an array + because some compilers will just produce instructions to fill the + array rather than assigning a pointer to a static array. */ +char const* info_platform = "INFO" ":" "platform[" PLATFORM_ID "]"; +char const* info_arch = "INFO" ":" "arch[" ARCHITECTURE_ID "]"; + + + + +const char* info_language_dialect_default = "INFO" ":" "dialect_default[" +#if __cplusplus >= 201402L + "14" +#elif __cplusplus >= 201103L + "11" +#else + "98" +#endif +"]"; + +/*--------------------------------------------------------------------------*/ + +int main(int argc, char* argv[]) +{ + int require = 0; + require += info_compiler[argc]; + require += info_platform[argc]; +#ifdef COMPILER_VERSION_MAJOR + require += info_version[argc]; +#endif +#ifdef SIMULATE_ID + require += info_simulate[argc]; +#endif +#ifdef SIMULATE_VERSION_MAJOR + require += info_simulate_version[argc]; +#endif +#if defined(__CRAYXE) || defined(__CRAYXC) + require += info_cray[argc]; +#endif + require += info_language_dialect_default[argc]; + (void)argv; + return require; +} diff --git a/realsense-file/CMakeFiles/3.5.1/CompilerIdCXX/a.out b/realsense-file/CMakeFiles/3.5.1/CompilerIdCXX/a.out new file mode 100644 index 0000000000..b9caff71e8 Binary files /dev/null and b/realsense-file/CMakeFiles/3.5.1/CompilerIdCXX/a.out differ diff --git a/realsense-file/CMakeFiles/CMakeDirectoryInformation.cmake b/realsense-file/CMakeFiles/CMakeDirectoryInformation.cmake new file mode 100644 index 0000000000..d636720ddb --- /dev/null +++ b/realsense-file/CMakeFiles/CMakeDirectoryInformation.cmake @@ -0,0 +1,16 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.5 + +# Relative path conversion top directories. +set(CMAKE_RELATIVE_PATH_TOP_SOURCE "/home/administrator/Desktop/realsense_file") +set(CMAKE_RELATIVE_PATH_TOP_BINARY "/home/administrator/Desktop/realsense_file") + +# Force unix paths in dependencies. +set(CMAKE_FORCE_UNIX_PATHS 1) + + +# The C and CXX include file regular expressions for this directory. +set(CMAKE_C_INCLUDE_REGEX_SCAN "^.*$") +set(CMAKE_C_INCLUDE_REGEX_COMPLAIN "^$") +set(CMAKE_CXX_INCLUDE_REGEX_SCAN ${CMAKE_C_INCLUDE_REGEX_SCAN}) +set(CMAKE_CXX_INCLUDE_REGEX_COMPLAIN ${CMAKE_C_INCLUDE_REGEX_COMPLAIN}) diff --git a/realsense-file/CMakeFiles/TargetDirectories.txt b/realsense-file/CMakeFiles/TargetDirectories.txt new file mode 100644 index 0000000000..65472eaeb5 --- /dev/null +++ b/realsense-file/CMakeFiles/TargetDirectories.txt @@ -0,0 +1,3 @@ +/home/administrator/Desktop/realsense_file/CMakeFiles/edit_cache.dir +/home/administrator/Desktop/realsense_file/CMakeFiles/rebuild_cache.dir +/home/administrator/Desktop/realsense_file/CMakeFiles/realsense_file.dir diff --git a/realsense-file/CMakeFiles/feature_tests.c b/realsense-file/CMakeFiles/feature_tests.c new file mode 100644 index 0000000000..6590dded23 --- /dev/null +++ b/realsense-file/CMakeFiles/feature_tests.c @@ -0,0 +1,34 @@ + + const char features[] = {"\n" +"C_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 404 +"1" +#else +"0" +#endif +"c_function_prototypes\n" +"C_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 404 && defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L +"1" +#else +"0" +#endif +"c_restrict\n" +"C_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 406 && defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201000L +"1" +#else +"0" +#endif +"c_static_assert\n" +"C_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 404 && defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L +"1" +#else +"0" +#endif +"c_variadic_macros\n" + +}; + +int main(int argc, char** argv) { (void)argv; return features[argc]; } diff --git a/realsense-file/CMakeFiles/feature_tests.cxx b/realsense-file/CMakeFiles/feature_tests.cxx new file mode 100644 index 0000000000..b93418c6ed --- /dev/null +++ b/realsense-file/CMakeFiles/feature_tests.cxx @@ -0,0 +1,405 @@ + + const char features[] = {"\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 500 && __cplusplus >= 201402L +"1" +#else +"0" +#endif +"cxx_aggregate_default_initializers\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 407 && __cplusplus >= 201103L +"1" +#else +"0" +#endif +"cxx_alias_templates\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 408 && __cplusplus >= 201103L +"1" +#else +"0" +#endif +"cxx_alignas\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 408 && __cplusplus >= 201103L +"1" +#else +"0" +#endif +"cxx_alignof\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 408 && __cplusplus >= 201103L +"1" +#else +"0" +#endif +"cxx_attributes\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 409 && __cplusplus > 201103L +"1" +#else +"0" +#endif +"cxx_attribute_deprecated\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 404 && (__cplusplus >= 201103L || (defined(__GXX_EXPERIMENTAL_CXX0X__) && __GXX_EXPERIMENTAL_CXX0X__)) +"1" +#else +"0" +#endif +"cxx_auto_type\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 409 && __cplusplus > 201103L +"1" +#else +"0" +#endif +"cxx_binary_literals\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 406 && (__cplusplus >= 201103L || (defined(__GXX_EXPERIMENTAL_CXX0X__) && __GXX_EXPERIMENTAL_CXX0X__)) +"1" +#else +"0" +#endif +"cxx_constexpr\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 409 && __cplusplus > 201103L +"1" +#else +"0" +#endif +"cxx_contextual_conversions\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 404 && (__cplusplus >= 201103L || (defined(__GXX_EXPERIMENTAL_CXX0X__) && __GXX_EXPERIMENTAL_CXX0X__)) +"1" +#else +"0" +#endif +"cxx_decltype\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 409 && __cplusplus > 201103L +"1" +#else +"0" +#endif +"cxx_decltype_auto\n" +"CXX_FEATURE:" +#if ((__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) >= 40801) && __cplusplus >= 201103L +"1" +#else +"0" +#endif +"cxx_decltype_incomplete_return_types\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 404 && (__cplusplus >= 201103L || (defined(__GXX_EXPERIMENTAL_CXX0X__) && __GXX_EXPERIMENTAL_CXX0X__)) +"1" +#else +"0" +#endif +"cxx_default_function_template_args\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 404 && (__cplusplus >= 201103L || (defined(__GXX_EXPERIMENTAL_CXX0X__) && __GXX_EXPERIMENTAL_CXX0X__)) +"1" +#else +"0" +#endif +"cxx_defaulted_functions\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 406 && (__cplusplus >= 201103L || (defined(__GXX_EXPERIMENTAL_CXX0X__) && __GXX_EXPERIMENTAL_CXX0X__)) +"1" +#else +"0" +#endif +"cxx_defaulted_move_initializers\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 407 && __cplusplus >= 201103L +"1" +#else +"0" +#endif +"cxx_delegating_constructors\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 404 && (__cplusplus >= 201103L || (defined(__GXX_EXPERIMENTAL_CXX0X__) && __GXX_EXPERIMENTAL_CXX0X__)) +"1" +#else +"0" +#endif +"cxx_deleted_functions\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 409 && __cplusplus > 201103L +"1" +#else +"0" +#endif +"cxx_digit_separators\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 406 && (__cplusplus >= 201103L || (defined(__GXX_EXPERIMENTAL_CXX0X__) && __GXX_EXPERIMENTAL_CXX0X__)) +"1" +#else +"0" +#endif +"cxx_enum_forward_declarations\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 405 && (__cplusplus >= 201103L || (defined(__GXX_EXPERIMENTAL_CXX0X__) && __GXX_EXPERIMENTAL_CXX0X__)) +"1" +#else +"0" +#endif +"cxx_explicit_conversions\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 407 && __cplusplus >= 201103L +"1" +#else +"0" +#endif +"cxx_extended_friend_declarations\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 404 && (__cplusplus >= 201103L || (defined(__GXX_EXPERIMENTAL_CXX0X__) && __GXX_EXPERIMENTAL_CXX0X__)) +"1" +#else +"0" +#endif +"cxx_extern_templates\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 407 && __cplusplus >= 201103L +"1" +#else +"0" +#endif +"cxx_final\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 404 && (__cplusplus >= 201103L || (defined(__GXX_EXPERIMENTAL_CXX0X__) && __GXX_EXPERIMENTAL_CXX0X__)) +"1" +#else +"0" +#endif +"cxx_func_identifier\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 404 && (__cplusplus >= 201103L || (defined(__GXX_EXPERIMENTAL_CXX0X__) && __GXX_EXPERIMENTAL_CXX0X__)) +"1" +#else +"0" +#endif +"cxx_generalized_initializers\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 409 && __cplusplus > 201103L +"1" +#else +"0" +#endif +"cxx_generic_lambdas\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 408 && __cplusplus >= 201103L +"1" +#else +"0" +#endif +"cxx_inheriting_constructors\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 404 && (__cplusplus >= 201103L || (defined(__GXX_EXPERIMENTAL_CXX0X__) && __GXX_EXPERIMENTAL_CXX0X__)) +"1" +#else +"0" +#endif +"cxx_inline_namespaces\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 405 && (__cplusplus >= 201103L || (defined(__GXX_EXPERIMENTAL_CXX0X__) && __GXX_EXPERIMENTAL_CXX0X__)) +"1" +#else +"0" +#endif +"cxx_lambdas\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 409 && __cplusplus > 201103L +"1" +#else +"0" +#endif +"cxx_lambda_init_captures\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 405 && (__cplusplus >= 201103L || (defined(__GXX_EXPERIMENTAL_CXX0X__) && __GXX_EXPERIMENTAL_CXX0X__)) +"1" +#else +"0" +#endif +"cxx_local_type_template_args\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 404 && (__cplusplus >= 201103L || (defined(__GXX_EXPERIMENTAL_CXX0X__) && __GXX_EXPERIMENTAL_CXX0X__)) +"1" +#else +"0" +#endif +"cxx_long_long_type\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 406 && (__cplusplus >= 201103L || (defined(__GXX_EXPERIMENTAL_CXX0X__) && __GXX_EXPERIMENTAL_CXX0X__)) +"1" +#else +"0" +#endif +"cxx_noexcept\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 407 && __cplusplus >= 201103L +"1" +#else +"0" +#endif +"cxx_nonstatic_member_init\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 406 && (__cplusplus >= 201103L || (defined(__GXX_EXPERIMENTAL_CXX0X__) && __GXX_EXPERIMENTAL_CXX0X__)) +"1" +#else +"0" +#endif +"cxx_nullptr\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 407 && __cplusplus >= 201103L +"1" +#else +"0" +#endif +"cxx_override\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 406 && (__cplusplus >= 201103L || (defined(__GXX_EXPERIMENTAL_CXX0X__) && __GXX_EXPERIMENTAL_CXX0X__)) +"1" +#else +"0" +#endif +"cxx_range_for\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 405 && (__cplusplus >= 201103L || (defined(__GXX_EXPERIMENTAL_CXX0X__) && __GXX_EXPERIMENTAL_CXX0X__)) +"1" +#else +"0" +#endif +"cxx_raw_string_literals\n" +"CXX_FEATURE:" +#if ((__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) >= 40801) && __cplusplus >= 201103L +"1" +#else +"0" +#endif +"cxx_reference_qualified_functions\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 500 && __cplusplus >= 201402L +"1" +#else +"0" +#endif +"cxx_relaxed_constexpr\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 409 && __cplusplus > 201103L +"1" +#else +"0" +#endif +"cxx_return_type_deduction\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 404 && (__cplusplus >= 201103L || (defined(__GXX_EXPERIMENTAL_CXX0X__) && __GXX_EXPERIMENTAL_CXX0X__)) +"1" +#else +"0" +#endif +"cxx_right_angle_brackets\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 404 && (__cplusplus >= 201103L || (defined(__GXX_EXPERIMENTAL_CXX0X__) && __GXX_EXPERIMENTAL_CXX0X__)) +"1" +#else +"0" +#endif +"cxx_rvalue_references\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 404 && (__cplusplus >= 201103L || (defined(__GXX_EXPERIMENTAL_CXX0X__) && __GXX_EXPERIMENTAL_CXX0X__)) +"1" +#else +"0" +#endif +"cxx_sizeof_member\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 404 && (__cplusplus >= 201103L || (defined(__GXX_EXPERIMENTAL_CXX0X__) && __GXX_EXPERIMENTAL_CXX0X__)) +"1" +#else +"0" +#endif +"cxx_static_assert\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 404 && (__cplusplus >= 201103L || (defined(__GXX_EXPERIMENTAL_CXX0X__) && __GXX_EXPERIMENTAL_CXX0X__)) +"1" +#else +"0" +#endif +"cxx_strong_enums\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 404 && __cplusplus +"1" +#else +"0" +#endif +"cxx_template_template_parameters\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 408 && __cplusplus >= 201103L +"1" +#else +"0" +#endif +"cxx_thread_local\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 404 && (__cplusplus >= 201103L || (defined(__GXX_EXPERIMENTAL_CXX0X__) && __GXX_EXPERIMENTAL_CXX0X__)) +"1" +#else +"0" +#endif +"cxx_trailing_return_types\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 404 && (__cplusplus >= 201103L || (defined(__GXX_EXPERIMENTAL_CXX0X__) && __GXX_EXPERIMENTAL_CXX0X__)) +"1" +#else +"0" +#endif +"cxx_unicode_literals\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 404 && (__cplusplus >= 201103L || (defined(__GXX_EXPERIMENTAL_CXX0X__) && __GXX_EXPERIMENTAL_CXX0X__)) +"1" +#else +"0" +#endif +"cxx_uniform_initialization\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 406 && (__cplusplus >= 201103L || (defined(__GXX_EXPERIMENTAL_CXX0X__) && __GXX_EXPERIMENTAL_CXX0X__)) +"1" +#else +"0" +#endif +"cxx_unrestricted_unions\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 407 && __cplusplus >= 201103L +"1" +#else +"0" +#endif +"cxx_user_literals\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 500 && __cplusplus >= 201402L +"1" +#else +"0" +#endif +"cxx_variable_templates\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 404 && (__cplusplus >= 201103L || (defined(__GXX_EXPERIMENTAL_CXX0X__) && __GXX_EXPERIMENTAL_CXX0X__)) +"1" +#else +"0" +#endif +"cxx_variadic_macros\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 404 && (__cplusplus >= 201103L || (defined(__GXX_EXPERIMENTAL_CXX0X__) && __GXX_EXPERIMENTAL_CXX0X__)) +"1" +#else +"0" +#endif +"cxx_variadic_templates\n" + +}; + +int main(int argc, char** argv) { (void)argv; return features[argc]; } diff --git a/realsense-file/CMakeFiles/progress.marks b/realsense-file/CMakeFiles/progress.marks new file mode 100644 index 0000000000..81b5c5d06c --- /dev/null +++ b/realsense-file/CMakeFiles/progress.marks @@ -0,0 +1 @@ +37 diff --git a/realsense-file/CMakeFiles/realsense_file.dir/DependInfo.cmake b/realsense-file/CMakeFiles/realsense_file.dir/DependInfo.cmake new file mode 100644 index 0000000000..5147c405af --- /dev/null +++ b/realsense-file/CMakeFiles/realsense_file.dir/DependInfo.cmake @@ -0,0 +1,93 @@ +# The set of languages for which implicit dependencies are needed: +set(CMAKE_DEPENDS_LANGUAGES + "C" + "CXX" + ) +# The set of files for implicit dependencies of each language: +set(CMAKE_DEPENDS_CHECK_C + "/home/administrator/Desktop/realsense_file/3rd_party/lz4/lib/lz4.c" "/home/administrator/Desktop/realsense_file/CMakeFiles/realsense_file.dir/3rd_party/lz4/lib/lz4.c.o" + "/home/administrator/Desktop/realsense_file/3rd_party/rosbag/roslz4/src/_roslz4module.c" "/home/administrator/Desktop/realsense_file/CMakeFiles/realsense_file.dir/3rd_party/rosbag/roslz4/src/_roslz4module.c.o" + "/home/administrator/Desktop/realsense_file/3rd_party/rosbag/roslz4/src/lz4s.c" "/home/administrator/Desktop/realsense_file/CMakeFiles/realsense_file.dir/3rd_party/rosbag/roslz4/src/lz4s.c.o" + "/home/administrator/Desktop/realsense_file/3rd_party/rosbag/roslz4/src/xxhash.c" "/home/administrator/Desktop/realsense_file/CMakeFiles/realsense_file.dir/3rd_party/rosbag/roslz4/src/xxhash.c.o" + ) +set(CMAKE_C_COMPILER_ID "GNU") + +# The include file search paths: +set(CMAKE_C_TARGET_INCLUDE_PATH + "include" + "src/storage/realsense_file/include/msgs" + "3rd_party/boost" + "3rd_party/rosbag/console_bridge/include" + "3rd_party/rosbag/cpp_common/include" + "3rd_party/rosbag/rosbag_storage/include" + "3rd_party/rosbag/roscpp_serialization/include" + "3rd_party/rosbag/rostime/include" + "3rd_party/rosbag/roscpp_traits/include" + "3rd_party/rosbag/roslz4/include" + "3rd_party/lz4/lib" + "src/storage/realsense_file" + ) +set(CMAKE_DEPENDS_CHECK_CXX + "/home/administrator/Desktop/realsense_file/3rd_party/rosbag/console_bridge/src/console.cpp" "/home/administrator/Desktop/realsense_file/CMakeFiles/realsense_file.dir/3rd_party/rosbag/console_bridge/src/console.cpp.o" + "/home/administrator/Desktop/realsense_file/3rd_party/rosbag/cpp_common/src/debug.cpp" "/home/administrator/Desktop/realsense_file/CMakeFiles/realsense_file.dir/3rd_party/rosbag/cpp_common/src/debug.cpp.o" + "/home/administrator/Desktop/realsense_file/3rd_party/rosbag/cpp_common/src/header.cpp" "/home/administrator/Desktop/realsense_file/CMakeFiles/realsense_file.dir/3rd_party/rosbag/cpp_common/src/header.cpp.o" + "/home/administrator/Desktop/realsense_file/3rd_party/rosbag/rosbag_storage/src/bag.cpp" "/home/administrator/Desktop/realsense_file/CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/bag.cpp.o" + "/home/administrator/Desktop/realsense_file/3rd_party/rosbag/rosbag_storage/src/bag_player.cpp" "/home/administrator/Desktop/realsense_file/CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/bag_player.cpp.o" + "/home/administrator/Desktop/realsense_file/3rd_party/rosbag/rosbag_storage/src/buffer.cpp" "/home/administrator/Desktop/realsense_file/CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/buffer.cpp.o" + "/home/administrator/Desktop/realsense_file/3rd_party/rosbag/rosbag_storage/src/chunked_file.cpp" "/home/administrator/Desktop/realsense_file/CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/chunked_file.cpp.o" + "/home/administrator/Desktop/realsense_file/3rd_party/rosbag/rosbag_storage/src/lz4_stream.cpp" "/home/administrator/Desktop/realsense_file/CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/lz4_stream.cpp.o" + "/home/administrator/Desktop/realsense_file/3rd_party/rosbag/rosbag_storage/src/message_instance.cpp" "/home/administrator/Desktop/realsense_file/CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/message_instance.cpp.o" + "/home/administrator/Desktop/realsense_file/3rd_party/rosbag/rosbag_storage/src/query.cpp" "/home/administrator/Desktop/realsense_file/CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/query.cpp.o" + "/home/administrator/Desktop/realsense_file/3rd_party/rosbag/rosbag_storage/src/stream.cpp" "/home/administrator/Desktop/realsense_file/CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/stream.cpp.o" + "/home/administrator/Desktop/realsense_file/3rd_party/rosbag/rosbag_storage/src/uncompressed_stream.cpp" "/home/administrator/Desktop/realsense_file/CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/uncompressed_stream.cpp.o" + "/home/administrator/Desktop/realsense_file/3rd_party/rosbag/rosbag_storage/src/view.cpp" "/home/administrator/Desktop/realsense_file/CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/view.cpp.o" + "/home/administrator/Desktop/realsense_file/3rd_party/rosbag/roscpp_serialization/src/serialization.cpp" "/home/administrator/Desktop/realsense_file/CMakeFiles/realsense_file.dir/3rd_party/rosbag/roscpp_serialization/src/serialization.cpp.o" + "/home/administrator/Desktop/realsense_file/3rd_party/rosbag/rostime/src/duration.cpp" "/home/administrator/Desktop/realsense_file/CMakeFiles/realsense_file.dir/3rd_party/rosbag/rostime/src/duration.cpp.o" + "/home/administrator/Desktop/realsense_file/3rd_party/rosbag/rostime/src/rate.cpp" "/home/administrator/Desktop/realsense_file/CMakeFiles/realsense_file.dir/3rd_party/rosbag/rostime/src/rate.cpp.o" + "/home/administrator/Desktop/realsense_file/3rd_party/rosbag/rostime/src/time.cpp" "/home/administrator/Desktop/realsense_file/CMakeFiles/realsense_file.dir/3rd_party/rosbag/rostime/src/time.cpp.o" + "/home/administrator/Desktop/realsense_file/src/storage/realsense_file/file_stream/conversions.cpp" "/home/administrator/Desktop/realsense_file/CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/conversions.cpp.o" + "/home/administrator/Desktop/realsense_file/src/storage/realsense_file/file_stream/data_objects/compressed_image_impl.cpp" "/home/administrator/Desktop/realsense_file/CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/compressed_image_impl.cpp.o" + "/home/administrator/Desktop/realsense_file/src/storage/realsense_file/file_stream/data_objects/image_impl.cpp" "/home/administrator/Desktop/realsense_file/CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/image_impl.cpp.o" + "/home/administrator/Desktop/realsense_file/src/storage/realsense_file/file_stream/data_objects/image_stream_info_impl.cpp" "/home/administrator/Desktop/realsense_file/CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/image_stream_info_impl.cpp.o" + "/home/administrator/Desktop/realsense_file/src/storage/realsense_file/file_stream/data_objects/log_impl.cpp" "/home/administrator/Desktop/realsense_file/CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/log_impl.cpp.o" + "/home/administrator/Desktop/realsense_file/src/storage/realsense_file/file_stream/data_objects/motion_sample_impl.cpp" "/home/administrator/Desktop/realsense_file/CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/motion_sample_impl.cpp.o" + "/home/administrator/Desktop/realsense_file/src/storage/realsense_file/file_stream/data_objects/motion_stream_info_impl.cpp" "/home/administrator/Desktop/realsense_file/CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/motion_stream_info_impl.cpp.o" + "/home/administrator/Desktop/realsense_file/src/storage/realsense_file/file_stream/data_objects/occupancy_map_impl.cpp" "/home/administrator/Desktop/realsense_file/CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/occupancy_map_impl.cpp.o" + "/home/administrator/Desktop/realsense_file/src/storage/realsense_file/file_stream/data_objects/pose_impl.cpp" "/home/administrator/Desktop/realsense_file/CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/pose_impl.cpp.o" + "/home/administrator/Desktop/realsense_file/src/storage/realsense_file/file_stream/data_objects/property_impl.cpp" "/home/administrator/Desktop/realsense_file/CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/property_impl.cpp.o" + "/home/administrator/Desktop/realsense_file/src/storage/realsense_file/file_stream/data_objects/time_sample_impl.cpp" "/home/administrator/Desktop/realsense_file/CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/time_sample_impl.cpp.o" + "/home/administrator/Desktop/realsense_file/src/storage/realsense_file/file_stream/data_objects/vendor_data_impl.cpp" "/home/administrator/Desktop/realsense_file/CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/vendor_data_impl.cpp.o" + "/home/administrator/Desktop/realsense_file/src/storage/realsense_file/file_stream/ros_writer_impl.cpp" "/home/administrator/Desktop/realsense_file/CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/ros_writer_impl.cpp.o" + "/home/administrator/Desktop/realsense_file/src/storage/realsense_file/file_stream/stream_playback_impl.cpp" "/home/administrator/Desktop/realsense_file/CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/stream_playback_impl.cpp.o" + "/home/administrator/Desktop/realsense_file/src/storage/realsense_file/file_stream/stream_recorder_impl.cpp" "/home/administrator/Desktop/realsense_file/CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/stream_recorder_impl.cpp.o" + ) +set(CMAKE_CXX_COMPILER_ID "GNU") + +# The include file search paths: +set(CMAKE_CXX_TARGET_INCLUDE_PATH + "include" + "src/storage/realsense_file/include/msgs" + "3rd_party/boost" + "3rd_party/rosbag/console_bridge/include" + "3rd_party/rosbag/cpp_common/include" + "3rd_party/rosbag/rosbag_storage/include" + "3rd_party/rosbag/roscpp_serialization/include" + "3rd_party/rosbag/rostime/include" + "3rd_party/rosbag/roscpp_traits/include" + "3rd_party/rosbag/roslz4/include" + "3rd_party/lz4/lib" + "src/storage/realsense_file" + ) + +# Pairs of files generated by the same build rule. +set(CMAKE_MULTIPLE_OUTPUT_PAIRS + "/home/administrator/Desktop/realsense_file/librealsense_file.so" "/home/administrator/Desktop/realsense_file/librealsense_file.so." + ) + + +# Targets to which this target links. +set(CMAKE_TARGET_LINKED_INFO_FILES + ) + +# Fortran module output directory. +set(CMAKE_Fortran_TARGET_MODULE_DIR "") diff --git a/realsense-file/CMakeFiles/realsense_file.dir/build.make b/realsense-file/CMakeFiles/realsense_file.dir/build.make new file mode 100644 index 0000000000..1de0babb0a --- /dev/null +++ b/realsense-file/CMakeFiles/realsense_file.dir/build.make @@ -0,0 +1,1062 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.5 + +# Delete rule output on recipe failure. +.DELETE_ON_ERROR: + + +#============================================================================= +# Special targets provided by cmake. + +# Disable implicit rules so canonical targets will work. +.SUFFIXES: + + +# Remove some rules from gmake that .SUFFIXES does not remove. +SUFFIXES = + +.SUFFIXES: .hpux_make_needs_suffix_list + + +# Suppress display of executed commands. +$(VERBOSE).SILENT: + + +# A target that is always out of date. +cmake_force: + +.PHONY : cmake_force + +#============================================================================= +# Set environment variables for the build. + +# The shell in which to execute make rules. +SHELL = /bin/sh + +# The CMake executable. +CMAKE_COMMAND = /usr/bin/cmake + +# The command to remove a file. +RM = /usr/bin/cmake -E remove -f + +# Escaping for special characters. +EQUALS = = + +# The top-level source directory on which CMake was run. +CMAKE_SOURCE_DIR = /home/administrator/Desktop/realsense_file + +# The top-level build directory on which CMake was run. +CMAKE_BINARY_DIR = /home/administrator/Desktop/realsense_file + +# Include any dependencies generated for this target. +include CMakeFiles/realsense_file.dir/depend.make + +# Include the progress variables for this target. +include CMakeFiles/realsense_file.dir/progress.make + +# Include the compile flags for this target's objects. +include CMakeFiles/realsense_file.dir/flags.make + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/conversions.cpp.o: CMakeFiles/realsense_file.dir/flags.make +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/conversions.cpp.o: src/storage/realsense_file/file_stream/conversions.cpp + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --progress-dir=/home/administrator/Desktop/realsense_file/CMakeFiles --progress-num=$(CMAKE_PROGRESS_1) "Building CXX object CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/conversions.cpp.o" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -o CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/conversions.cpp.o -c /home/administrator/Desktop/realsense_file/src/storage/realsense_file/file_stream/conversions.cpp + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/conversions.cpp.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Preprocessing CXX source to CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/conversions.cpp.i" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/administrator/Desktop/realsense_file/src/storage/realsense_file/file_stream/conversions.cpp > CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/conversions.cpp.i + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/conversions.cpp.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Compiling CXX source to assembly CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/conversions.cpp.s" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/administrator/Desktop/realsense_file/src/storage/realsense_file/file_stream/conversions.cpp -o CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/conversions.cpp.s + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/conversions.cpp.o.requires: + +.PHONY : CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/conversions.cpp.o.requires + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/conversions.cpp.o.provides: CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/conversions.cpp.o.requires + $(MAKE) -f CMakeFiles/realsense_file.dir/build.make CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/conversions.cpp.o.provides.build +.PHONY : CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/conversions.cpp.o.provides + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/conversions.cpp.o.provides.build: CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/conversions.cpp.o + + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/ros_writer_impl.cpp.o: CMakeFiles/realsense_file.dir/flags.make +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/ros_writer_impl.cpp.o: src/storage/realsense_file/file_stream/ros_writer_impl.cpp + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --progress-dir=/home/administrator/Desktop/realsense_file/CMakeFiles --progress-num=$(CMAKE_PROGRESS_2) "Building CXX object CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/ros_writer_impl.cpp.o" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -o CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/ros_writer_impl.cpp.o -c /home/administrator/Desktop/realsense_file/src/storage/realsense_file/file_stream/ros_writer_impl.cpp + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/ros_writer_impl.cpp.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Preprocessing CXX source to CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/ros_writer_impl.cpp.i" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/administrator/Desktop/realsense_file/src/storage/realsense_file/file_stream/ros_writer_impl.cpp > CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/ros_writer_impl.cpp.i + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/ros_writer_impl.cpp.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Compiling CXX source to assembly CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/ros_writer_impl.cpp.s" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/administrator/Desktop/realsense_file/src/storage/realsense_file/file_stream/ros_writer_impl.cpp -o CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/ros_writer_impl.cpp.s + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/ros_writer_impl.cpp.o.requires: + +.PHONY : CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/ros_writer_impl.cpp.o.requires + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/ros_writer_impl.cpp.o.provides: CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/ros_writer_impl.cpp.o.requires + $(MAKE) -f CMakeFiles/realsense_file.dir/build.make CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/ros_writer_impl.cpp.o.provides.build +.PHONY : CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/ros_writer_impl.cpp.o.provides + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/ros_writer_impl.cpp.o.provides.build: CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/ros_writer_impl.cpp.o + + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/stream_recorder_impl.cpp.o: CMakeFiles/realsense_file.dir/flags.make +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/stream_recorder_impl.cpp.o: src/storage/realsense_file/file_stream/stream_recorder_impl.cpp + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --progress-dir=/home/administrator/Desktop/realsense_file/CMakeFiles --progress-num=$(CMAKE_PROGRESS_3) "Building CXX object CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/stream_recorder_impl.cpp.o" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -o CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/stream_recorder_impl.cpp.o -c /home/administrator/Desktop/realsense_file/src/storage/realsense_file/file_stream/stream_recorder_impl.cpp + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/stream_recorder_impl.cpp.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Preprocessing CXX source to CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/stream_recorder_impl.cpp.i" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/administrator/Desktop/realsense_file/src/storage/realsense_file/file_stream/stream_recorder_impl.cpp > CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/stream_recorder_impl.cpp.i + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/stream_recorder_impl.cpp.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Compiling CXX source to assembly CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/stream_recorder_impl.cpp.s" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/administrator/Desktop/realsense_file/src/storage/realsense_file/file_stream/stream_recorder_impl.cpp -o CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/stream_recorder_impl.cpp.s + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/stream_recorder_impl.cpp.o.requires: + +.PHONY : CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/stream_recorder_impl.cpp.o.requires + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/stream_recorder_impl.cpp.o.provides: CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/stream_recorder_impl.cpp.o.requires + $(MAKE) -f CMakeFiles/realsense_file.dir/build.make CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/stream_recorder_impl.cpp.o.provides.build +.PHONY : CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/stream_recorder_impl.cpp.o.provides + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/stream_recorder_impl.cpp.o.provides.build: CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/stream_recorder_impl.cpp.o + + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/stream_playback_impl.cpp.o: CMakeFiles/realsense_file.dir/flags.make +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/stream_playback_impl.cpp.o: src/storage/realsense_file/file_stream/stream_playback_impl.cpp + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --progress-dir=/home/administrator/Desktop/realsense_file/CMakeFiles --progress-num=$(CMAKE_PROGRESS_4) "Building CXX object CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/stream_playback_impl.cpp.o" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -o CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/stream_playback_impl.cpp.o -c /home/administrator/Desktop/realsense_file/src/storage/realsense_file/file_stream/stream_playback_impl.cpp + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/stream_playback_impl.cpp.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Preprocessing CXX source to CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/stream_playback_impl.cpp.i" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/administrator/Desktop/realsense_file/src/storage/realsense_file/file_stream/stream_playback_impl.cpp > CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/stream_playback_impl.cpp.i + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/stream_playback_impl.cpp.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Compiling CXX source to assembly CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/stream_playback_impl.cpp.s" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/administrator/Desktop/realsense_file/src/storage/realsense_file/file_stream/stream_playback_impl.cpp -o CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/stream_playback_impl.cpp.s + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/stream_playback_impl.cpp.o.requires: + +.PHONY : CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/stream_playback_impl.cpp.o.requires + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/stream_playback_impl.cpp.o.provides: CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/stream_playback_impl.cpp.o.requires + $(MAKE) -f CMakeFiles/realsense_file.dir/build.make CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/stream_playback_impl.cpp.o.provides.build +.PHONY : CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/stream_playback_impl.cpp.o.provides + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/stream_playback_impl.cpp.o.provides.build: CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/stream_playback_impl.cpp.o + + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/vendor_data_impl.cpp.o: CMakeFiles/realsense_file.dir/flags.make +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/vendor_data_impl.cpp.o: src/storage/realsense_file/file_stream/data_objects/vendor_data_impl.cpp + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --progress-dir=/home/administrator/Desktop/realsense_file/CMakeFiles --progress-num=$(CMAKE_PROGRESS_5) "Building CXX object CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/vendor_data_impl.cpp.o" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -o CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/vendor_data_impl.cpp.o -c /home/administrator/Desktop/realsense_file/src/storage/realsense_file/file_stream/data_objects/vendor_data_impl.cpp + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/vendor_data_impl.cpp.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Preprocessing CXX source to CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/vendor_data_impl.cpp.i" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/administrator/Desktop/realsense_file/src/storage/realsense_file/file_stream/data_objects/vendor_data_impl.cpp > CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/vendor_data_impl.cpp.i + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/vendor_data_impl.cpp.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Compiling CXX source to assembly CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/vendor_data_impl.cpp.s" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/administrator/Desktop/realsense_file/src/storage/realsense_file/file_stream/data_objects/vendor_data_impl.cpp -o CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/vendor_data_impl.cpp.s + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/vendor_data_impl.cpp.o.requires: + +.PHONY : CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/vendor_data_impl.cpp.o.requires + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/vendor_data_impl.cpp.o.provides: CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/vendor_data_impl.cpp.o.requires + $(MAKE) -f CMakeFiles/realsense_file.dir/build.make CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/vendor_data_impl.cpp.o.provides.build +.PHONY : CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/vendor_data_impl.cpp.o.provides + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/vendor_data_impl.cpp.o.provides.build: CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/vendor_data_impl.cpp.o + + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/compressed_image_impl.cpp.o: CMakeFiles/realsense_file.dir/flags.make +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/compressed_image_impl.cpp.o: src/storage/realsense_file/file_stream/data_objects/compressed_image_impl.cpp + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --progress-dir=/home/administrator/Desktop/realsense_file/CMakeFiles --progress-num=$(CMAKE_PROGRESS_6) "Building CXX object CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/compressed_image_impl.cpp.o" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -o CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/compressed_image_impl.cpp.o -c /home/administrator/Desktop/realsense_file/src/storage/realsense_file/file_stream/data_objects/compressed_image_impl.cpp + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/compressed_image_impl.cpp.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Preprocessing CXX source to CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/compressed_image_impl.cpp.i" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/administrator/Desktop/realsense_file/src/storage/realsense_file/file_stream/data_objects/compressed_image_impl.cpp > CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/compressed_image_impl.cpp.i + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/compressed_image_impl.cpp.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Compiling CXX source to assembly CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/compressed_image_impl.cpp.s" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/administrator/Desktop/realsense_file/src/storage/realsense_file/file_stream/data_objects/compressed_image_impl.cpp -o CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/compressed_image_impl.cpp.s + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/compressed_image_impl.cpp.o.requires: + +.PHONY : CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/compressed_image_impl.cpp.o.requires + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/compressed_image_impl.cpp.o.provides: CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/compressed_image_impl.cpp.o.requires + $(MAKE) -f CMakeFiles/realsense_file.dir/build.make CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/compressed_image_impl.cpp.o.provides.build +.PHONY : CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/compressed_image_impl.cpp.o.provides + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/compressed_image_impl.cpp.o.provides.build: CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/compressed_image_impl.cpp.o + + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/image_impl.cpp.o: CMakeFiles/realsense_file.dir/flags.make +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/image_impl.cpp.o: src/storage/realsense_file/file_stream/data_objects/image_impl.cpp + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --progress-dir=/home/administrator/Desktop/realsense_file/CMakeFiles --progress-num=$(CMAKE_PROGRESS_7) "Building CXX object CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/image_impl.cpp.o" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -o CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/image_impl.cpp.o -c /home/administrator/Desktop/realsense_file/src/storage/realsense_file/file_stream/data_objects/image_impl.cpp + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/image_impl.cpp.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Preprocessing CXX source to CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/image_impl.cpp.i" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/administrator/Desktop/realsense_file/src/storage/realsense_file/file_stream/data_objects/image_impl.cpp > CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/image_impl.cpp.i + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/image_impl.cpp.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Compiling CXX source to assembly CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/image_impl.cpp.s" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/administrator/Desktop/realsense_file/src/storage/realsense_file/file_stream/data_objects/image_impl.cpp -o CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/image_impl.cpp.s + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/image_impl.cpp.o.requires: + +.PHONY : CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/image_impl.cpp.o.requires + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/image_impl.cpp.o.provides: CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/image_impl.cpp.o.requires + $(MAKE) -f CMakeFiles/realsense_file.dir/build.make CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/image_impl.cpp.o.provides.build +.PHONY : CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/image_impl.cpp.o.provides + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/image_impl.cpp.o.provides.build: CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/image_impl.cpp.o + + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/image_stream_info_impl.cpp.o: CMakeFiles/realsense_file.dir/flags.make +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/image_stream_info_impl.cpp.o: src/storage/realsense_file/file_stream/data_objects/image_stream_info_impl.cpp + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --progress-dir=/home/administrator/Desktop/realsense_file/CMakeFiles --progress-num=$(CMAKE_PROGRESS_8) "Building CXX object CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/image_stream_info_impl.cpp.o" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -o CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/image_stream_info_impl.cpp.o -c /home/administrator/Desktop/realsense_file/src/storage/realsense_file/file_stream/data_objects/image_stream_info_impl.cpp + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/image_stream_info_impl.cpp.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Preprocessing CXX source to CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/image_stream_info_impl.cpp.i" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/administrator/Desktop/realsense_file/src/storage/realsense_file/file_stream/data_objects/image_stream_info_impl.cpp > CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/image_stream_info_impl.cpp.i + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/image_stream_info_impl.cpp.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Compiling CXX source to assembly CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/image_stream_info_impl.cpp.s" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/administrator/Desktop/realsense_file/src/storage/realsense_file/file_stream/data_objects/image_stream_info_impl.cpp -o CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/image_stream_info_impl.cpp.s + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/image_stream_info_impl.cpp.o.requires: + +.PHONY : CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/image_stream_info_impl.cpp.o.requires + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/image_stream_info_impl.cpp.o.provides: CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/image_stream_info_impl.cpp.o.requires + $(MAKE) -f CMakeFiles/realsense_file.dir/build.make CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/image_stream_info_impl.cpp.o.provides.build +.PHONY : CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/image_stream_info_impl.cpp.o.provides + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/image_stream_info_impl.cpp.o.provides.build: CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/image_stream_info_impl.cpp.o + + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/motion_sample_impl.cpp.o: CMakeFiles/realsense_file.dir/flags.make +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/motion_sample_impl.cpp.o: src/storage/realsense_file/file_stream/data_objects/motion_sample_impl.cpp + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --progress-dir=/home/administrator/Desktop/realsense_file/CMakeFiles --progress-num=$(CMAKE_PROGRESS_9) "Building CXX object CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/motion_sample_impl.cpp.o" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -o CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/motion_sample_impl.cpp.o -c /home/administrator/Desktop/realsense_file/src/storage/realsense_file/file_stream/data_objects/motion_sample_impl.cpp + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/motion_sample_impl.cpp.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Preprocessing CXX source to CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/motion_sample_impl.cpp.i" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/administrator/Desktop/realsense_file/src/storage/realsense_file/file_stream/data_objects/motion_sample_impl.cpp > CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/motion_sample_impl.cpp.i + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/motion_sample_impl.cpp.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Compiling CXX source to assembly CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/motion_sample_impl.cpp.s" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/administrator/Desktop/realsense_file/src/storage/realsense_file/file_stream/data_objects/motion_sample_impl.cpp -o CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/motion_sample_impl.cpp.s + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/motion_sample_impl.cpp.o.requires: + +.PHONY : CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/motion_sample_impl.cpp.o.requires + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/motion_sample_impl.cpp.o.provides: CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/motion_sample_impl.cpp.o.requires + $(MAKE) -f CMakeFiles/realsense_file.dir/build.make CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/motion_sample_impl.cpp.o.provides.build +.PHONY : CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/motion_sample_impl.cpp.o.provides + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/motion_sample_impl.cpp.o.provides.build: CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/motion_sample_impl.cpp.o + + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/motion_stream_info_impl.cpp.o: CMakeFiles/realsense_file.dir/flags.make +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/motion_stream_info_impl.cpp.o: src/storage/realsense_file/file_stream/data_objects/motion_stream_info_impl.cpp + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --progress-dir=/home/administrator/Desktop/realsense_file/CMakeFiles --progress-num=$(CMAKE_PROGRESS_10) "Building CXX object CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/motion_stream_info_impl.cpp.o" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -o CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/motion_stream_info_impl.cpp.o -c /home/administrator/Desktop/realsense_file/src/storage/realsense_file/file_stream/data_objects/motion_stream_info_impl.cpp + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/motion_stream_info_impl.cpp.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Preprocessing CXX source to CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/motion_stream_info_impl.cpp.i" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/administrator/Desktop/realsense_file/src/storage/realsense_file/file_stream/data_objects/motion_stream_info_impl.cpp > CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/motion_stream_info_impl.cpp.i + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/motion_stream_info_impl.cpp.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Compiling CXX source to assembly CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/motion_stream_info_impl.cpp.s" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/administrator/Desktop/realsense_file/src/storage/realsense_file/file_stream/data_objects/motion_stream_info_impl.cpp -o CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/motion_stream_info_impl.cpp.s + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/motion_stream_info_impl.cpp.o.requires: + +.PHONY : CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/motion_stream_info_impl.cpp.o.requires + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/motion_stream_info_impl.cpp.o.provides: CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/motion_stream_info_impl.cpp.o.requires + $(MAKE) -f CMakeFiles/realsense_file.dir/build.make CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/motion_stream_info_impl.cpp.o.provides.build +.PHONY : CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/motion_stream_info_impl.cpp.o.provides + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/motion_stream_info_impl.cpp.o.provides.build: CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/motion_stream_info_impl.cpp.o + + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/property_impl.cpp.o: CMakeFiles/realsense_file.dir/flags.make +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/property_impl.cpp.o: src/storage/realsense_file/file_stream/data_objects/property_impl.cpp + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --progress-dir=/home/administrator/Desktop/realsense_file/CMakeFiles --progress-num=$(CMAKE_PROGRESS_11) "Building CXX object CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/property_impl.cpp.o" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -o CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/property_impl.cpp.o -c /home/administrator/Desktop/realsense_file/src/storage/realsense_file/file_stream/data_objects/property_impl.cpp + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/property_impl.cpp.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Preprocessing CXX source to CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/property_impl.cpp.i" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/administrator/Desktop/realsense_file/src/storage/realsense_file/file_stream/data_objects/property_impl.cpp > CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/property_impl.cpp.i + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/property_impl.cpp.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Compiling CXX source to assembly CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/property_impl.cpp.s" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/administrator/Desktop/realsense_file/src/storage/realsense_file/file_stream/data_objects/property_impl.cpp -o CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/property_impl.cpp.s + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/property_impl.cpp.o.requires: + +.PHONY : CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/property_impl.cpp.o.requires + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/property_impl.cpp.o.provides: CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/property_impl.cpp.o.requires + $(MAKE) -f CMakeFiles/realsense_file.dir/build.make CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/property_impl.cpp.o.provides.build +.PHONY : CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/property_impl.cpp.o.provides + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/property_impl.cpp.o.provides.build: CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/property_impl.cpp.o + + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/time_sample_impl.cpp.o: CMakeFiles/realsense_file.dir/flags.make +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/time_sample_impl.cpp.o: src/storage/realsense_file/file_stream/data_objects/time_sample_impl.cpp + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --progress-dir=/home/administrator/Desktop/realsense_file/CMakeFiles --progress-num=$(CMAKE_PROGRESS_12) "Building CXX object CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/time_sample_impl.cpp.o" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -o CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/time_sample_impl.cpp.o -c /home/administrator/Desktop/realsense_file/src/storage/realsense_file/file_stream/data_objects/time_sample_impl.cpp + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/time_sample_impl.cpp.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Preprocessing CXX source to CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/time_sample_impl.cpp.i" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/administrator/Desktop/realsense_file/src/storage/realsense_file/file_stream/data_objects/time_sample_impl.cpp > CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/time_sample_impl.cpp.i + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/time_sample_impl.cpp.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Compiling CXX source to assembly CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/time_sample_impl.cpp.s" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/administrator/Desktop/realsense_file/src/storage/realsense_file/file_stream/data_objects/time_sample_impl.cpp -o CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/time_sample_impl.cpp.s + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/time_sample_impl.cpp.o.requires: + +.PHONY : CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/time_sample_impl.cpp.o.requires + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/time_sample_impl.cpp.o.provides: CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/time_sample_impl.cpp.o.requires + $(MAKE) -f CMakeFiles/realsense_file.dir/build.make CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/time_sample_impl.cpp.o.provides.build +.PHONY : CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/time_sample_impl.cpp.o.provides + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/time_sample_impl.cpp.o.provides.build: CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/time_sample_impl.cpp.o + + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/log_impl.cpp.o: CMakeFiles/realsense_file.dir/flags.make +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/log_impl.cpp.o: src/storage/realsense_file/file_stream/data_objects/log_impl.cpp + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --progress-dir=/home/administrator/Desktop/realsense_file/CMakeFiles --progress-num=$(CMAKE_PROGRESS_13) "Building CXX object CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/log_impl.cpp.o" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -o CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/log_impl.cpp.o -c /home/administrator/Desktop/realsense_file/src/storage/realsense_file/file_stream/data_objects/log_impl.cpp + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/log_impl.cpp.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Preprocessing CXX source to CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/log_impl.cpp.i" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/administrator/Desktop/realsense_file/src/storage/realsense_file/file_stream/data_objects/log_impl.cpp > CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/log_impl.cpp.i + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/log_impl.cpp.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Compiling CXX source to assembly CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/log_impl.cpp.s" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/administrator/Desktop/realsense_file/src/storage/realsense_file/file_stream/data_objects/log_impl.cpp -o CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/log_impl.cpp.s + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/log_impl.cpp.o.requires: + +.PHONY : CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/log_impl.cpp.o.requires + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/log_impl.cpp.o.provides: CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/log_impl.cpp.o.requires + $(MAKE) -f CMakeFiles/realsense_file.dir/build.make CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/log_impl.cpp.o.provides.build +.PHONY : CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/log_impl.cpp.o.provides + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/log_impl.cpp.o.provides.build: CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/log_impl.cpp.o + + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/pose_impl.cpp.o: CMakeFiles/realsense_file.dir/flags.make +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/pose_impl.cpp.o: src/storage/realsense_file/file_stream/data_objects/pose_impl.cpp + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --progress-dir=/home/administrator/Desktop/realsense_file/CMakeFiles --progress-num=$(CMAKE_PROGRESS_14) "Building CXX object CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/pose_impl.cpp.o" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -o CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/pose_impl.cpp.o -c /home/administrator/Desktop/realsense_file/src/storage/realsense_file/file_stream/data_objects/pose_impl.cpp + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/pose_impl.cpp.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Preprocessing CXX source to CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/pose_impl.cpp.i" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/administrator/Desktop/realsense_file/src/storage/realsense_file/file_stream/data_objects/pose_impl.cpp > CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/pose_impl.cpp.i + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/pose_impl.cpp.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Compiling CXX source to assembly CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/pose_impl.cpp.s" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/administrator/Desktop/realsense_file/src/storage/realsense_file/file_stream/data_objects/pose_impl.cpp -o CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/pose_impl.cpp.s + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/pose_impl.cpp.o.requires: + +.PHONY : CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/pose_impl.cpp.o.requires + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/pose_impl.cpp.o.provides: CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/pose_impl.cpp.o.requires + $(MAKE) -f CMakeFiles/realsense_file.dir/build.make CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/pose_impl.cpp.o.provides.build +.PHONY : CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/pose_impl.cpp.o.provides + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/pose_impl.cpp.o.provides.build: CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/pose_impl.cpp.o + + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/occupancy_map_impl.cpp.o: CMakeFiles/realsense_file.dir/flags.make +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/occupancy_map_impl.cpp.o: src/storage/realsense_file/file_stream/data_objects/occupancy_map_impl.cpp + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --progress-dir=/home/administrator/Desktop/realsense_file/CMakeFiles --progress-num=$(CMAKE_PROGRESS_15) "Building CXX object CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/occupancy_map_impl.cpp.o" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -o CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/occupancy_map_impl.cpp.o -c /home/administrator/Desktop/realsense_file/src/storage/realsense_file/file_stream/data_objects/occupancy_map_impl.cpp + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/occupancy_map_impl.cpp.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Preprocessing CXX source to CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/occupancy_map_impl.cpp.i" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/administrator/Desktop/realsense_file/src/storage/realsense_file/file_stream/data_objects/occupancy_map_impl.cpp > CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/occupancy_map_impl.cpp.i + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/occupancy_map_impl.cpp.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Compiling CXX source to assembly CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/occupancy_map_impl.cpp.s" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/administrator/Desktop/realsense_file/src/storage/realsense_file/file_stream/data_objects/occupancy_map_impl.cpp -o CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/occupancy_map_impl.cpp.s + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/occupancy_map_impl.cpp.o.requires: + +.PHONY : CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/occupancy_map_impl.cpp.o.requires + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/occupancy_map_impl.cpp.o.provides: CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/occupancy_map_impl.cpp.o.requires + $(MAKE) -f CMakeFiles/realsense_file.dir/build.make CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/occupancy_map_impl.cpp.o.provides.build +.PHONY : CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/occupancy_map_impl.cpp.o.provides + +CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/occupancy_map_impl.cpp.o.provides.build: CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/occupancy_map_impl.cpp.o + + +CMakeFiles/realsense_file.dir/3rd_party/lz4/lib/lz4.c.o: CMakeFiles/realsense_file.dir/flags.make +CMakeFiles/realsense_file.dir/3rd_party/lz4/lib/lz4.c.o: 3rd_party/lz4/lib/lz4.c + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --progress-dir=/home/administrator/Desktop/realsense_file/CMakeFiles --progress-num=$(CMAKE_PROGRESS_16) "Building C object CMakeFiles/realsense_file.dir/3rd_party/lz4/lib/lz4.c.o" + /usr/bin/cc $(C_DEFINES) $(C_INCLUDES) $(C_FLAGS) -o CMakeFiles/realsense_file.dir/3rd_party/lz4/lib/lz4.c.o -c /home/administrator/Desktop/realsense_file/3rd_party/lz4/lib/lz4.c + +CMakeFiles/realsense_file.dir/3rd_party/lz4/lib/lz4.c.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Preprocessing C source to CMakeFiles/realsense_file.dir/3rd_party/lz4/lib/lz4.c.i" + /usr/bin/cc $(C_DEFINES) $(C_INCLUDES) $(C_FLAGS) -E /home/administrator/Desktop/realsense_file/3rd_party/lz4/lib/lz4.c > CMakeFiles/realsense_file.dir/3rd_party/lz4/lib/lz4.c.i + +CMakeFiles/realsense_file.dir/3rd_party/lz4/lib/lz4.c.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Compiling C source to assembly CMakeFiles/realsense_file.dir/3rd_party/lz4/lib/lz4.c.s" + /usr/bin/cc $(C_DEFINES) $(C_INCLUDES) $(C_FLAGS) -S /home/administrator/Desktop/realsense_file/3rd_party/lz4/lib/lz4.c -o CMakeFiles/realsense_file.dir/3rd_party/lz4/lib/lz4.c.s + +CMakeFiles/realsense_file.dir/3rd_party/lz4/lib/lz4.c.o.requires: + +.PHONY : CMakeFiles/realsense_file.dir/3rd_party/lz4/lib/lz4.c.o.requires + +CMakeFiles/realsense_file.dir/3rd_party/lz4/lib/lz4.c.o.provides: CMakeFiles/realsense_file.dir/3rd_party/lz4/lib/lz4.c.o.requires + $(MAKE) -f CMakeFiles/realsense_file.dir/build.make CMakeFiles/realsense_file.dir/3rd_party/lz4/lib/lz4.c.o.provides.build +.PHONY : CMakeFiles/realsense_file.dir/3rd_party/lz4/lib/lz4.c.o.provides + +CMakeFiles/realsense_file.dir/3rd_party/lz4/lib/lz4.c.o.provides.build: CMakeFiles/realsense_file.dir/3rd_party/lz4/lib/lz4.c.o + + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/console_bridge/src/console.cpp.o: CMakeFiles/realsense_file.dir/flags.make +CMakeFiles/realsense_file.dir/3rd_party/rosbag/console_bridge/src/console.cpp.o: 3rd_party/rosbag/console_bridge/src/console.cpp + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --progress-dir=/home/administrator/Desktop/realsense_file/CMakeFiles --progress-num=$(CMAKE_PROGRESS_17) "Building CXX object CMakeFiles/realsense_file.dir/3rd_party/rosbag/console_bridge/src/console.cpp.o" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -o CMakeFiles/realsense_file.dir/3rd_party/rosbag/console_bridge/src/console.cpp.o -c /home/administrator/Desktop/realsense_file/3rd_party/rosbag/console_bridge/src/console.cpp + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/console_bridge/src/console.cpp.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Preprocessing CXX source to CMakeFiles/realsense_file.dir/3rd_party/rosbag/console_bridge/src/console.cpp.i" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/administrator/Desktop/realsense_file/3rd_party/rosbag/console_bridge/src/console.cpp > CMakeFiles/realsense_file.dir/3rd_party/rosbag/console_bridge/src/console.cpp.i + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/console_bridge/src/console.cpp.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Compiling CXX source to assembly CMakeFiles/realsense_file.dir/3rd_party/rosbag/console_bridge/src/console.cpp.s" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/administrator/Desktop/realsense_file/3rd_party/rosbag/console_bridge/src/console.cpp -o CMakeFiles/realsense_file.dir/3rd_party/rosbag/console_bridge/src/console.cpp.s + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/console_bridge/src/console.cpp.o.requires: + +.PHONY : CMakeFiles/realsense_file.dir/3rd_party/rosbag/console_bridge/src/console.cpp.o.requires + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/console_bridge/src/console.cpp.o.provides: CMakeFiles/realsense_file.dir/3rd_party/rosbag/console_bridge/src/console.cpp.o.requires + $(MAKE) -f CMakeFiles/realsense_file.dir/build.make CMakeFiles/realsense_file.dir/3rd_party/rosbag/console_bridge/src/console.cpp.o.provides.build +.PHONY : CMakeFiles/realsense_file.dir/3rd_party/rosbag/console_bridge/src/console.cpp.o.provides + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/console_bridge/src/console.cpp.o.provides.build: CMakeFiles/realsense_file.dir/3rd_party/rosbag/console_bridge/src/console.cpp.o + + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rostime/src/rate.cpp.o: CMakeFiles/realsense_file.dir/flags.make +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rostime/src/rate.cpp.o: 3rd_party/rosbag/rostime/src/rate.cpp + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --progress-dir=/home/administrator/Desktop/realsense_file/CMakeFiles --progress-num=$(CMAKE_PROGRESS_18) "Building CXX object CMakeFiles/realsense_file.dir/3rd_party/rosbag/rostime/src/rate.cpp.o" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -o CMakeFiles/realsense_file.dir/3rd_party/rosbag/rostime/src/rate.cpp.o -c /home/administrator/Desktop/realsense_file/3rd_party/rosbag/rostime/src/rate.cpp + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rostime/src/rate.cpp.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Preprocessing CXX source to CMakeFiles/realsense_file.dir/3rd_party/rosbag/rostime/src/rate.cpp.i" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/administrator/Desktop/realsense_file/3rd_party/rosbag/rostime/src/rate.cpp > CMakeFiles/realsense_file.dir/3rd_party/rosbag/rostime/src/rate.cpp.i + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rostime/src/rate.cpp.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Compiling CXX source to assembly CMakeFiles/realsense_file.dir/3rd_party/rosbag/rostime/src/rate.cpp.s" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/administrator/Desktop/realsense_file/3rd_party/rosbag/rostime/src/rate.cpp -o CMakeFiles/realsense_file.dir/3rd_party/rosbag/rostime/src/rate.cpp.s + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rostime/src/rate.cpp.o.requires: + +.PHONY : CMakeFiles/realsense_file.dir/3rd_party/rosbag/rostime/src/rate.cpp.o.requires + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rostime/src/rate.cpp.o.provides: CMakeFiles/realsense_file.dir/3rd_party/rosbag/rostime/src/rate.cpp.o.requires + $(MAKE) -f CMakeFiles/realsense_file.dir/build.make CMakeFiles/realsense_file.dir/3rd_party/rosbag/rostime/src/rate.cpp.o.provides.build +.PHONY : CMakeFiles/realsense_file.dir/3rd_party/rosbag/rostime/src/rate.cpp.o.provides + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rostime/src/rate.cpp.o.provides.build: CMakeFiles/realsense_file.dir/3rd_party/rosbag/rostime/src/rate.cpp.o + + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rostime/src/time.cpp.o: CMakeFiles/realsense_file.dir/flags.make +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rostime/src/time.cpp.o: 3rd_party/rosbag/rostime/src/time.cpp + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --progress-dir=/home/administrator/Desktop/realsense_file/CMakeFiles --progress-num=$(CMAKE_PROGRESS_19) "Building CXX object CMakeFiles/realsense_file.dir/3rd_party/rosbag/rostime/src/time.cpp.o" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -o CMakeFiles/realsense_file.dir/3rd_party/rosbag/rostime/src/time.cpp.o -c /home/administrator/Desktop/realsense_file/3rd_party/rosbag/rostime/src/time.cpp + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rostime/src/time.cpp.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Preprocessing CXX source to CMakeFiles/realsense_file.dir/3rd_party/rosbag/rostime/src/time.cpp.i" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/administrator/Desktop/realsense_file/3rd_party/rosbag/rostime/src/time.cpp > CMakeFiles/realsense_file.dir/3rd_party/rosbag/rostime/src/time.cpp.i + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rostime/src/time.cpp.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Compiling CXX source to assembly CMakeFiles/realsense_file.dir/3rd_party/rosbag/rostime/src/time.cpp.s" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/administrator/Desktop/realsense_file/3rd_party/rosbag/rostime/src/time.cpp -o CMakeFiles/realsense_file.dir/3rd_party/rosbag/rostime/src/time.cpp.s + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rostime/src/time.cpp.o.requires: + +.PHONY : CMakeFiles/realsense_file.dir/3rd_party/rosbag/rostime/src/time.cpp.o.requires + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rostime/src/time.cpp.o.provides: CMakeFiles/realsense_file.dir/3rd_party/rosbag/rostime/src/time.cpp.o.requires + $(MAKE) -f CMakeFiles/realsense_file.dir/build.make CMakeFiles/realsense_file.dir/3rd_party/rosbag/rostime/src/time.cpp.o.provides.build +.PHONY : CMakeFiles/realsense_file.dir/3rd_party/rosbag/rostime/src/time.cpp.o.provides + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rostime/src/time.cpp.o.provides.build: CMakeFiles/realsense_file.dir/3rd_party/rosbag/rostime/src/time.cpp.o + + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rostime/src/duration.cpp.o: CMakeFiles/realsense_file.dir/flags.make +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rostime/src/duration.cpp.o: 3rd_party/rosbag/rostime/src/duration.cpp + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --progress-dir=/home/administrator/Desktop/realsense_file/CMakeFiles --progress-num=$(CMAKE_PROGRESS_20) "Building CXX object CMakeFiles/realsense_file.dir/3rd_party/rosbag/rostime/src/duration.cpp.o" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -o CMakeFiles/realsense_file.dir/3rd_party/rosbag/rostime/src/duration.cpp.o -c /home/administrator/Desktop/realsense_file/3rd_party/rosbag/rostime/src/duration.cpp + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rostime/src/duration.cpp.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Preprocessing CXX source to CMakeFiles/realsense_file.dir/3rd_party/rosbag/rostime/src/duration.cpp.i" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/administrator/Desktop/realsense_file/3rd_party/rosbag/rostime/src/duration.cpp > CMakeFiles/realsense_file.dir/3rd_party/rosbag/rostime/src/duration.cpp.i + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rostime/src/duration.cpp.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Compiling CXX source to assembly CMakeFiles/realsense_file.dir/3rd_party/rosbag/rostime/src/duration.cpp.s" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/administrator/Desktop/realsense_file/3rd_party/rosbag/rostime/src/duration.cpp -o CMakeFiles/realsense_file.dir/3rd_party/rosbag/rostime/src/duration.cpp.s + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rostime/src/duration.cpp.o.requires: + +.PHONY : CMakeFiles/realsense_file.dir/3rd_party/rosbag/rostime/src/duration.cpp.o.requires + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rostime/src/duration.cpp.o.provides: CMakeFiles/realsense_file.dir/3rd_party/rosbag/rostime/src/duration.cpp.o.requires + $(MAKE) -f CMakeFiles/realsense_file.dir/build.make CMakeFiles/realsense_file.dir/3rd_party/rosbag/rostime/src/duration.cpp.o.provides.build +.PHONY : CMakeFiles/realsense_file.dir/3rd_party/rosbag/rostime/src/duration.cpp.o.provides + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rostime/src/duration.cpp.o.provides.build: CMakeFiles/realsense_file.dir/3rd_party/rosbag/rostime/src/duration.cpp.o + + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/stream.cpp.o: CMakeFiles/realsense_file.dir/flags.make +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/stream.cpp.o: 3rd_party/rosbag/rosbag_storage/src/stream.cpp + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --progress-dir=/home/administrator/Desktop/realsense_file/CMakeFiles --progress-num=$(CMAKE_PROGRESS_21) "Building CXX object CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/stream.cpp.o" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -o CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/stream.cpp.o -c /home/administrator/Desktop/realsense_file/3rd_party/rosbag/rosbag_storage/src/stream.cpp + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/stream.cpp.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Preprocessing CXX source to CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/stream.cpp.i" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/administrator/Desktop/realsense_file/3rd_party/rosbag/rosbag_storage/src/stream.cpp > CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/stream.cpp.i + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/stream.cpp.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Compiling CXX source to assembly CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/stream.cpp.s" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/administrator/Desktop/realsense_file/3rd_party/rosbag/rosbag_storage/src/stream.cpp -o CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/stream.cpp.s + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/stream.cpp.o.requires: + +.PHONY : CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/stream.cpp.o.requires + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/stream.cpp.o.provides: CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/stream.cpp.o.requires + $(MAKE) -f CMakeFiles/realsense_file.dir/build.make CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/stream.cpp.o.provides.build +.PHONY : CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/stream.cpp.o.provides + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/stream.cpp.o.provides.build: CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/stream.cpp.o + + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/buffer.cpp.o: CMakeFiles/realsense_file.dir/flags.make +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/buffer.cpp.o: 3rd_party/rosbag/rosbag_storage/src/buffer.cpp + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --progress-dir=/home/administrator/Desktop/realsense_file/CMakeFiles --progress-num=$(CMAKE_PROGRESS_22) "Building CXX object CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/buffer.cpp.o" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -o CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/buffer.cpp.o -c /home/administrator/Desktop/realsense_file/3rd_party/rosbag/rosbag_storage/src/buffer.cpp + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/buffer.cpp.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Preprocessing CXX source to CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/buffer.cpp.i" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/administrator/Desktop/realsense_file/3rd_party/rosbag/rosbag_storage/src/buffer.cpp > CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/buffer.cpp.i + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/buffer.cpp.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Compiling CXX source to assembly CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/buffer.cpp.s" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/administrator/Desktop/realsense_file/3rd_party/rosbag/rosbag_storage/src/buffer.cpp -o CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/buffer.cpp.s + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/buffer.cpp.o.requires: + +.PHONY : CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/buffer.cpp.o.requires + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/buffer.cpp.o.provides: CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/buffer.cpp.o.requires + $(MAKE) -f CMakeFiles/realsense_file.dir/build.make CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/buffer.cpp.o.provides.build +.PHONY : CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/buffer.cpp.o.provides + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/buffer.cpp.o.provides.build: CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/buffer.cpp.o + + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/chunked_file.cpp.o: CMakeFiles/realsense_file.dir/flags.make +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/chunked_file.cpp.o: 3rd_party/rosbag/rosbag_storage/src/chunked_file.cpp + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --progress-dir=/home/administrator/Desktop/realsense_file/CMakeFiles --progress-num=$(CMAKE_PROGRESS_23) "Building CXX object CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/chunked_file.cpp.o" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -o CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/chunked_file.cpp.o -c /home/administrator/Desktop/realsense_file/3rd_party/rosbag/rosbag_storage/src/chunked_file.cpp + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/chunked_file.cpp.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Preprocessing CXX source to CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/chunked_file.cpp.i" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/administrator/Desktop/realsense_file/3rd_party/rosbag/rosbag_storage/src/chunked_file.cpp > CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/chunked_file.cpp.i + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/chunked_file.cpp.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Compiling CXX source to assembly CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/chunked_file.cpp.s" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/administrator/Desktop/realsense_file/3rd_party/rosbag/rosbag_storage/src/chunked_file.cpp -o CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/chunked_file.cpp.s + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/chunked_file.cpp.o.requires: + +.PHONY : CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/chunked_file.cpp.o.requires + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/chunked_file.cpp.o.provides: CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/chunked_file.cpp.o.requires + $(MAKE) -f CMakeFiles/realsense_file.dir/build.make CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/chunked_file.cpp.o.provides.build +.PHONY : CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/chunked_file.cpp.o.provides + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/chunked_file.cpp.o.provides.build: CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/chunked_file.cpp.o + + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/message_instance.cpp.o: CMakeFiles/realsense_file.dir/flags.make +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/message_instance.cpp.o: 3rd_party/rosbag/rosbag_storage/src/message_instance.cpp + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --progress-dir=/home/administrator/Desktop/realsense_file/CMakeFiles --progress-num=$(CMAKE_PROGRESS_24) "Building CXX object CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/message_instance.cpp.o" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -o CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/message_instance.cpp.o -c /home/administrator/Desktop/realsense_file/3rd_party/rosbag/rosbag_storage/src/message_instance.cpp + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/message_instance.cpp.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Preprocessing CXX source to CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/message_instance.cpp.i" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/administrator/Desktop/realsense_file/3rd_party/rosbag/rosbag_storage/src/message_instance.cpp > CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/message_instance.cpp.i + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/message_instance.cpp.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Compiling CXX source to assembly CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/message_instance.cpp.s" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/administrator/Desktop/realsense_file/3rd_party/rosbag/rosbag_storage/src/message_instance.cpp -o CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/message_instance.cpp.s + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/message_instance.cpp.o.requires: + +.PHONY : CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/message_instance.cpp.o.requires + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/message_instance.cpp.o.provides: CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/message_instance.cpp.o.requires + $(MAKE) -f CMakeFiles/realsense_file.dir/build.make CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/message_instance.cpp.o.provides.build +.PHONY : CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/message_instance.cpp.o.provides + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/message_instance.cpp.o.provides.build: CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/message_instance.cpp.o + + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/view.cpp.o: CMakeFiles/realsense_file.dir/flags.make +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/view.cpp.o: 3rd_party/rosbag/rosbag_storage/src/view.cpp + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --progress-dir=/home/administrator/Desktop/realsense_file/CMakeFiles --progress-num=$(CMAKE_PROGRESS_25) "Building CXX object CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/view.cpp.o" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -o CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/view.cpp.o -c /home/administrator/Desktop/realsense_file/3rd_party/rosbag/rosbag_storage/src/view.cpp + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/view.cpp.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Preprocessing CXX source to CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/view.cpp.i" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/administrator/Desktop/realsense_file/3rd_party/rosbag/rosbag_storage/src/view.cpp > CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/view.cpp.i + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/view.cpp.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Compiling CXX source to assembly CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/view.cpp.s" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/administrator/Desktop/realsense_file/3rd_party/rosbag/rosbag_storage/src/view.cpp -o CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/view.cpp.s + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/view.cpp.o.requires: + +.PHONY : CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/view.cpp.o.requires + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/view.cpp.o.provides: CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/view.cpp.o.requires + $(MAKE) -f CMakeFiles/realsense_file.dir/build.make CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/view.cpp.o.provides.build +.PHONY : CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/view.cpp.o.provides + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/view.cpp.o.provides.build: CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/view.cpp.o + + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/bag_player.cpp.o: CMakeFiles/realsense_file.dir/flags.make +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/bag_player.cpp.o: 3rd_party/rosbag/rosbag_storage/src/bag_player.cpp + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --progress-dir=/home/administrator/Desktop/realsense_file/CMakeFiles --progress-num=$(CMAKE_PROGRESS_26) "Building CXX object CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/bag_player.cpp.o" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -o CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/bag_player.cpp.o -c /home/administrator/Desktop/realsense_file/3rd_party/rosbag/rosbag_storage/src/bag_player.cpp + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/bag_player.cpp.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Preprocessing CXX source to CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/bag_player.cpp.i" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/administrator/Desktop/realsense_file/3rd_party/rosbag/rosbag_storage/src/bag_player.cpp > CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/bag_player.cpp.i + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/bag_player.cpp.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Compiling CXX source to assembly CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/bag_player.cpp.s" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/administrator/Desktop/realsense_file/3rd_party/rosbag/rosbag_storage/src/bag_player.cpp -o CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/bag_player.cpp.s + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/bag_player.cpp.o.requires: + +.PHONY : CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/bag_player.cpp.o.requires + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/bag_player.cpp.o.provides: CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/bag_player.cpp.o.requires + $(MAKE) -f CMakeFiles/realsense_file.dir/build.make CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/bag_player.cpp.o.provides.build +.PHONY : CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/bag_player.cpp.o.provides + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/bag_player.cpp.o.provides.build: CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/bag_player.cpp.o + + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/uncompressed_stream.cpp.o: CMakeFiles/realsense_file.dir/flags.make +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/uncompressed_stream.cpp.o: 3rd_party/rosbag/rosbag_storage/src/uncompressed_stream.cpp + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --progress-dir=/home/administrator/Desktop/realsense_file/CMakeFiles --progress-num=$(CMAKE_PROGRESS_27) "Building CXX object CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/uncompressed_stream.cpp.o" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -o CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/uncompressed_stream.cpp.o -c /home/administrator/Desktop/realsense_file/3rd_party/rosbag/rosbag_storage/src/uncompressed_stream.cpp + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/uncompressed_stream.cpp.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Preprocessing CXX source to CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/uncompressed_stream.cpp.i" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/administrator/Desktop/realsense_file/3rd_party/rosbag/rosbag_storage/src/uncompressed_stream.cpp > CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/uncompressed_stream.cpp.i + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/uncompressed_stream.cpp.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Compiling CXX source to assembly CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/uncompressed_stream.cpp.s" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/administrator/Desktop/realsense_file/3rd_party/rosbag/rosbag_storage/src/uncompressed_stream.cpp -o CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/uncompressed_stream.cpp.s + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/uncompressed_stream.cpp.o.requires: + +.PHONY : CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/uncompressed_stream.cpp.o.requires + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/uncompressed_stream.cpp.o.provides: CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/uncompressed_stream.cpp.o.requires + $(MAKE) -f CMakeFiles/realsense_file.dir/build.make CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/uncompressed_stream.cpp.o.provides.build +.PHONY : CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/uncompressed_stream.cpp.o.provides + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/uncompressed_stream.cpp.o.provides.build: CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/uncompressed_stream.cpp.o + + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/lz4_stream.cpp.o: CMakeFiles/realsense_file.dir/flags.make +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/lz4_stream.cpp.o: 3rd_party/rosbag/rosbag_storage/src/lz4_stream.cpp + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --progress-dir=/home/administrator/Desktop/realsense_file/CMakeFiles --progress-num=$(CMAKE_PROGRESS_28) "Building CXX object CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/lz4_stream.cpp.o" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -o CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/lz4_stream.cpp.o -c /home/administrator/Desktop/realsense_file/3rd_party/rosbag/rosbag_storage/src/lz4_stream.cpp + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/lz4_stream.cpp.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Preprocessing CXX source to CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/lz4_stream.cpp.i" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/administrator/Desktop/realsense_file/3rd_party/rosbag/rosbag_storage/src/lz4_stream.cpp > CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/lz4_stream.cpp.i + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/lz4_stream.cpp.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Compiling CXX source to assembly CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/lz4_stream.cpp.s" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/administrator/Desktop/realsense_file/3rd_party/rosbag/rosbag_storage/src/lz4_stream.cpp -o CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/lz4_stream.cpp.s + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/lz4_stream.cpp.o.requires: + +.PHONY : CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/lz4_stream.cpp.o.requires + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/lz4_stream.cpp.o.provides: CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/lz4_stream.cpp.o.requires + $(MAKE) -f CMakeFiles/realsense_file.dir/build.make CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/lz4_stream.cpp.o.provides.build +.PHONY : CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/lz4_stream.cpp.o.provides + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/lz4_stream.cpp.o.provides.build: CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/lz4_stream.cpp.o + + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/bag.cpp.o: CMakeFiles/realsense_file.dir/flags.make +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/bag.cpp.o: 3rd_party/rosbag/rosbag_storage/src/bag.cpp + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --progress-dir=/home/administrator/Desktop/realsense_file/CMakeFiles --progress-num=$(CMAKE_PROGRESS_29) "Building CXX object CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/bag.cpp.o" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -o CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/bag.cpp.o -c /home/administrator/Desktop/realsense_file/3rd_party/rosbag/rosbag_storage/src/bag.cpp + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/bag.cpp.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Preprocessing CXX source to CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/bag.cpp.i" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/administrator/Desktop/realsense_file/3rd_party/rosbag/rosbag_storage/src/bag.cpp > CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/bag.cpp.i + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/bag.cpp.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Compiling CXX source to assembly CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/bag.cpp.s" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/administrator/Desktop/realsense_file/3rd_party/rosbag/rosbag_storage/src/bag.cpp -o CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/bag.cpp.s + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/bag.cpp.o.requires: + +.PHONY : CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/bag.cpp.o.requires + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/bag.cpp.o.provides: CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/bag.cpp.o.requires + $(MAKE) -f CMakeFiles/realsense_file.dir/build.make CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/bag.cpp.o.provides.build +.PHONY : CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/bag.cpp.o.provides + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/bag.cpp.o.provides.build: CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/bag.cpp.o + + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/query.cpp.o: CMakeFiles/realsense_file.dir/flags.make +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/query.cpp.o: 3rd_party/rosbag/rosbag_storage/src/query.cpp + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --progress-dir=/home/administrator/Desktop/realsense_file/CMakeFiles --progress-num=$(CMAKE_PROGRESS_30) "Building CXX object CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/query.cpp.o" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -o CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/query.cpp.o -c /home/administrator/Desktop/realsense_file/3rd_party/rosbag/rosbag_storage/src/query.cpp + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/query.cpp.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Preprocessing CXX source to CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/query.cpp.i" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/administrator/Desktop/realsense_file/3rd_party/rosbag/rosbag_storage/src/query.cpp > CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/query.cpp.i + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/query.cpp.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Compiling CXX source to assembly CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/query.cpp.s" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/administrator/Desktop/realsense_file/3rd_party/rosbag/rosbag_storage/src/query.cpp -o CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/query.cpp.s + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/query.cpp.o.requires: + +.PHONY : CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/query.cpp.o.requires + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/query.cpp.o.provides: CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/query.cpp.o.requires + $(MAKE) -f CMakeFiles/realsense_file.dir/build.make CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/query.cpp.o.provides.build +.PHONY : CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/query.cpp.o.provides + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/query.cpp.o.provides.build: CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/query.cpp.o + + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/cpp_common/src/header.cpp.o: CMakeFiles/realsense_file.dir/flags.make +CMakeFiles/realsense_file.dir/3rd_party/rosbag/cpp_common/src/header.cpp.o: 3rd_party/rosbag/cpp_common/src/header.cpp + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --progress-dir=/home/administrator/Desktop/realsense_file/CMakeFiles --progress-num=$(CMAKE_PROGRESS_31) "Building CXX object CMakeFiles/realsense_file.dir/3rd_party/rosbag/cpp_common/src/header.cpp.o" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -o CMakeFiles/realsense_file.dir/3rd_party/rosbag/cpp_common/src/header.cpp.o -c /home/administrator/Desktop/realsense_file/3rd_party/rosbag/cpp_common/src/header.cpp + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/cpp_common/src/header.cpp.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Preprocessing CXX source to CMakeFiles/realsense_file.dir/3rd_party/rosbag/cpp_common/src/header.cpp.i" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/administrator/Desktop/realsense_file/3rd_party/rosbag/cpp_common/src/header.cpp > CMakeFiles/realsense_file.dir/3rd_party/rosbag/cpp_common/src/header.cpp.i + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/cpp_common/src/header.cpp.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Compiling CXX source to assembly CMakeFiles/realsense_file.dir/3rd_party/rosbag/cpp_common/src/header.cpp.s" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/administrator/Desktop/realsense_file/3rd_party/rosbag/cpp_common/src/header.cpp -o CMakeFiles/realsense_file.dir/3rd_party/rosbag/cpp_common/src/header.cpp.s + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/cpp_common/src/header.cpp.o.requires: + +.PHONY : CMakeFiles/realsense_file.dir/3rd_party/rosbag/cpp_common/src/header.cpp.o.requires + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/cpp_common/src/header.cpp.o.provides: CMakeFiles/realsense_file.dir/3rd_party/rosbag/cpp_common/src/header.cpp.o.requires + $(MAKE) -f CMakeFiles/realsense_file.dir/build.make CMakeFiles/realsense_file.dir/3rd_party/rosbag/cpp_common/src/header.cpp.o.provides.build +.PHONY : CMakeFiles/realsense_file.dir/3rd_party/rosbag/cpp_common/src/header.cpp.o.provides + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/cpp_common/src/header.cpp.o.provides.build: CMakeFiles/realsense_file.dir/3rd_party/rosbag/cpp_common/src/header.cpp.o + + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/cpp_common/src/debug.cpp.o: CMakeFiles/realsense_file.dir/flags.make +CMakeFiles/realsense_file.dir/3rd_party/rosbag/cpp_common/src/debug.cpp.o: 3rd_party/rosbag/cpp_common/src/debug.cpp + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --progress-dir=/home/administrator/Desktop/realsense_file/CMakeFiles --progress-num=$(CMAKE_PROGRESS_32) "Building CXX object CMakeFiles/realsense_file.dir/3rd_party/rosbag/cpp_common/src/debug.cpp.o" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -o CMakeFiles/realsense_file.dir/3rd_party/rosbag/cpp_common/src/debug.cpp.o -c /home/administrator/Desktop/realsense_file/3rd_party/rosbag/cpp_common/src/debug.cpp + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/cpp_common/src/debug.cpp.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Preprocessing CXX source to CMakeFiles/realsense_file.dir/3rd_party/rosbag/cpp_common/src/debug.cpp.i" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/administrator/Desktop/realsense_file/3rd_party/rosbag/cpp_common/src/debug.cpp > CMakeFiles/realsense_file.dir/3rd_party/rosbag/cpp_common/src/debug.cpp.i + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/cpp_common/src/debug.cpp.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Compiling CXX source to assembly CMakeFiles/realsense_file.dir/3rd_party/rosbag/cpp_common/src/debug.cpp.s" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/administrator/Desktop/realsense_file/3rd_party/rosbag/cpp_common/src/debug.cpp -o CMakeFiles/realsense_file.dir/3rd_party/rosbag/cpp_common/src/debug.cpp.s + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/cpp_common/src/debug.cpp.o.requires: + +.PHONY : CMakeFiles/realsense_file.dir/3rd_party/rosbag/cpp_common/src/debug.cpp.o.requires + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/cpp_common/src/debug.cpp.o.provides: CMakeFiles/realsense_file.dir/3rd_party/rosbag/cpp_common/src/debug.cpp.o.requires + $(MAKE) -f CMakeFiles/realsense_file.dir/build.make CMakeFiles/realsense_file.dir/3rd_party/rosbag/cpp_common/src/debug.cpp.o.provides.build +.PHONY : CMakeFiles/realsense_file.dir/3rd_party/rosbag/cpp_common/src/debug.cpp.o.provides + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/cpp_common/src/debug.cpp.o.provides.build: CMakeFiles/realsense_file.dir/3rd_party/rosbag/cpp_common/src/debug.cpp.o + + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/roscpp_serialization/src/serialization.cpp.o: CMakeFiles/realsense_file.dir/flags.make +CMakeFiles/realsense_file.dir/3rd_party/rosbag/roscpp_serialization/src/serialization.cpp.o: 3rd_party/rosbag/roscpp_serialization/src/serialization.cpp + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --progress-dir=/home/administrator/Desktop/realsense_file/CMakeFiles --progress-num=$(CMAKE_PROGRESS_33) "Building CXX object CMakeFiles/realsense_file.dir/3rd_party/rosbag/roscpp_serialization/src/serialization.cpp.o" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -o CMakeFiles/realsense_file.dir/3rd_party/rosbag/roscpp_serialization/src/serialization.cpp.o -c /home/administrator/Desktop/realsense_file/3rd_party/rosbag/roscpp_serialization/src/serialization.cpp + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/roscpp_serialization/src/serialization.cpp.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Preprocessing CXX source to CMakeFiles/realsense_file.dir/3rd_party/rosbag/roscpp_serialization/src/serialization.cpp.i" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/administrator/Desktop/realsense_file/3rd_party/rosbag/roscpp_serialization/src/serialization.cpp > CMakeFiles/realsense_file.dir/3rd_party/rosbag/roscpp_serialization/src/serialization.cpp.i + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/roscpp_serialization/src/serialization.cpp.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Compiling CXX source to assembly CMakeFiles/realsense_file.dir/3rd_party/rosbag/roscpp_serialization/src/serialization.cpp.s" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/administrator/Desktop/realsense_file/3rd_party/rosbag/roscpp_serialization/src/serialization.cpp -o CMakeFiles/realsense_file.dir/3rd_party/rosbag/roscpp_serialization/src/serialization.cpp.s + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/roscpp_serialization/src/serialization.cpp.o.requires: + +.PHONY : CMakeFiles/realsense_file.dir/3rd_party/rosbag/roscpp_serialization/src/serialization.cpp.o.requires + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/roscpp_serialization/src/serialization.cpp.o.provides: CMakeFiles/realsense_file.dir/3rd_party/rosbag/roscpp_serialization/src/serialization.cpp.o.requires + $(MAKE) -f CMakeFiles/realsense_file.dir/build.make CMakeFiles/realsense_file.dir/3rd_party/rosbag/roscpp_serialization/src/serialization.cpp.o.provides.build +.PHONY : CMakeFiles/realsense_file.dir/3rd_party/rosbag/roscpp_serialization/src/serialization.cpp.o.provides + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/roscpp_serialization/src/serialization.cpp.o.provides.build: CMakeFiles/realsense_file.dir/3rd_party/rosbag/roscpp_serialization/src/serialization.cpp.o + + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/roslz4/src/_roslz4module.c.o: CMakeFiles/realsense_file.dir/flags.make +CMakeFiles/realsense_file.dir/3rd_party/rosbag/roslz4/src/_roslz4module.c.o: 3rd_party/rosbag/roslz4/src/_roslz4module.c + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --progress-dir=/home/administrator/Desktop/realsense_file/CMakeFiles --progress-num=$(CMAKE_PROGRESS_34) "Building C object CMakeFiles/realsense_file.dir/3rd_party/rosbag/roslz4/src/_roslz4module.c.o" + /usr/bin/cc $(C_DEFINES) $(C_INCLUDES) $(C_FLAGS) -o CMakeFiles/realsense_file.dir/3rd_party/rosbag/roslz4/src/_roslz4module.c.o -c /home/administrator/Desktop/realsense_file/3rd_party/rosbag/roslz4/src/_roslz4module.c + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/roslz4/src/_roslz4module.c.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Preprocessing C source to CMakeFiles/realsense_file.dir/3rd_party/rosbag/roslz4/src/_roslz4module.c.i" + /usr/bin/cc $(C_DEFINES) $(C_INCLUDES) $(C_FLAGS) -E /home/administrator/Desktop/realsense_file/3rd_party/rosbag/roslz4/src/_roslz4module.c > CMakeFiles/realsense_file.dir/3rd_party/rosbag/roslz4/src/_roslz4module.c.i + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/roslz4/src/_roslz4module.c.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Compiling C source to assembly CMakeFiles/realsense_file.dir/3rd_party/rosbag/roslz4/src/_roslz4module.c.s" + /usr/bin/cc $(C_DEFINES) $(C_INCLUDES) $(C_FLAGS) -S /home/administrator/Desktop/realsense_file/3rd_party/rosbag/roslz4/src/_roslz4module.c -o CMakeFiles/realsense_file.dir/3rd_party/rosbag/roslz4/src/_roslz4module.c.s + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/roslz4/src/_roslz4module.c.o.requires: + +.PHONY : CMakeFiles/realsense_file.dir/3rd_party/rosbag/roslz4/src/_roslz4module.c.o.requires + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/roslz4/src/_roslz4module.c.o.provides: CMakeFiles/realsense_file.dir/3rd_party/rosbag/roslz4/src/_roslz4module.c.o.requires + $(MAKE) -f CMakeFiles/realsense_file.dir/build.make CMakeFiles/realsense_file.dir/3rd_party/rosbag/roslz4/src/_roslz4module.c.o.provides.build +.PHONY : CMakeFiles/realsense_file.dir/3rd_party/rosbag/roslz4/src/_roslz4module.c.o.provides + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/roslz4/src/_roslz4module.c.o.provides.build: CMakeFiles/realsense_file.dir/3rd_party/rosbag/roslz4/src/_roslz4module.c.o + + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/roslz4/src/lz4s.c.o: CMakeFiles/realsense_file.dir/flags.make +CMakeFiles/realsense_file.dir/3rd_party/rosbag/roslz4/src/lz4s.c.o: 3rd_party/rosbag/roslz4/src/lz4s.c + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --progress-dir=/home/administrator/Desktop/realsense_file/CMakeFiles --progress-num=$(CMAKE_PROGRESS_35) "Building C object CMakeFiles/realsense_file.dir/3rd_party/rosbag/roslz4/src/lz4s.c.o" + /usr/bin/cc $(C_DEFINES) $(C_INCLUDES) $(C_FLAGS) -o CMakeFiles/realsense_file.dir/3rd_party/rosbag/roslz4/src/lz4s.c.o -c /home/administrator/Desktop/realsense_file/3rd_party/rosbag/roslz4/src/lz4s.c + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/roslz4/src/lz4s.c.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Preprocessing C source to CMakeFiles/realsense_file.dir/3rd_party/rosbag/roslz4/src/lz4s.c.i" + /usr/bin/cc $(C_DEFINES) $(C_INCLUDES) $(C_FLAGS) -E /home/administrator/Desktop/realsense_file/3rd_party/rosbag/roslz4/src/lz4s.c > CMakeFiles/realsense_file.dir/3rd_party/rosbag/roslz4/src/lz4s.c.i + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/roslz4/src/lz4s.c.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Compiling C source to assembly CMakeFiles/realsense_file.dir/3rd_party/rosbag/roslz4/src/lz4s.c.s" + /usr/bin/cc $(C_DEFINES) $(C_INCLUDES) $(C_FLAGS) -S /home/administrator/Desktop/realsense_file/3rd_party/rosbag/roslz4/src/lz4s.c -o CMakeFiles/realsense_file.dir/3rd_party/rosbag/roslz4/src/lz4s.c.s + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/roslz4/src/lz4s.c.o.requires: + +.PHONY : CMakeFiles/realsense_file.dir/3rd_party/rosbag/roslz4/src/lz4s.c.o.requires + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/roslz4/src/lz4s.c.o.provides: CMakeFiles/realsense_file.dir/3rd_party/rosbag/roslz4/src/lz4s.c.o.requires + $(MAKE) -f CMakeFiles/realsense_file.dir/build.make CMakeFiles/realsense_file.dir/3rd_party/rosbag/roslz4/src/lz4s.c.o.provides.build +.PHONY : CMakeFiles/realsense_file.dir/3rd_party/rosbag/roslz4/src/lz4s.c.o.provides + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/roslz4/src/lz4s.c.o.provides.build: CMakeFiles/realsense_file.dir/3rd_party/rosbag/roslz4/src/lz4s.c.o + + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/roslz4/src/xxhash.c.o: CMakeFiles/realsense_file.dir/flags.make +CMakeFiles/realsense_file.dir/3rd_party/rosbag/roslz4/src/xxhash.c.o: 3rd_party/rosbag/roslz4/src/xxhash.c + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --progress-dir=/home/administrator/Desktop/realsense_file/CMakeFiles --progress-num=$(CMAKE_PROGRESS_36) "Building C object CMakeFiles/realsense_file.dir/3rd_party/rosbag/roslz4/src/xxhash.c.o" + /usr/bin/cc $(C_DEFINES) $(C_INCLUDES) $(C_FLAGS) -o CMakeFiles/realsense_file.dir/3rd_party/rosbag/roslz4/src/xxhash.c.o -c /home/administrator/Desktop/realsense_file/3rd_party/rosbag/roslz4/src/xxhash.c + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/roslz4/src/xxhash.c.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Preprocessing C source to CMakeFiles/realsense_file.dir/3rd_party/rosbag/roslz4/src/xxhash.c.i" + /usr/bin/cc $(C_DEFINES) $(C_INCLUDES) $(C_FLAGS) -E /home/administrator/Desktop/realsense_file/3rd_party/rosbag/roslz4/src/xxhash.c > CMakeFiles/realsense_file.dir/3rd_party/rosbag/roslz4/src/xxhash.c.i + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/roslz4/src/xxhash.c.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Compiling C source to assembly CMakeFiles/realsense_file.dir/3rd_party/rosbag/roslz4/src/xxhash.c.s" + /usr/bin/cc $(C_DEFINES) $(C_INCLUDES) $(C_FLAGS) -S /home/administrator/Desktop/realsense_file/3rd_party/rosbag/roslz4/src/xxhash.c -o CMakeFiles/realsense_file.dir/3rd_party/rosbag/roslz4/src/xxhash.c.s + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/roslz4/src/xxhash.c.o.requires: + +.PHONY : CMakeFiles/realsense_file.dir/3rd_party/rosbag/roslz4/src/xxhash.c.o.requires + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/roslz4/src/xxhash.c.o.provides: CMakeFiles/realsense_file.dir/3rd_party/rosbag/roslz4/src/xxhash.c.o.requires + $(MAKE) -f CMakeFiles/realsense_file.dir/build.make CMakeFiles/realsense_file.dir/3rd_party/rosbag/roslz4/src/xxhash.c.o.provides.build +.PHONY : CMakeFiles/realsense_file.dir/3rd_party/rosbag/roslz4/src/xxhash.c.o.provides + +CMakeFiles/realsense_file.dir/3rd_party/rosbag/roslz4/src/xxhash.c.o.provides.build: CMakeFiles/realsense_file.dir/3rd_party/rosbag/roslz4/src/xxhash.c.o + + +# Object files for target realsense_file +realsense_file_OBJECTS = \ +"CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/conversions.cpp.o" \ +"CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/ros_writer_impl.cpp.o" \ +"CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/stream_recorder_impl.cpp.o" \ +"CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/stream_playback_impl.cpp.o" \ +"CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/vendor_data_impl.cpp.o" \ +"CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/compressed_image_impl.cpp.o" \ +"CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/image_impl.cpp.o" \ +"CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/image_stream_info_impl.cpp.o" \ +"CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/motion_sample_impl.cpp.o" \ +"CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/motion_stream_info_impl.cpp.o" \ +"CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/property_impl.cpp.o" \ +"CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/time_sample_impl.cpp.o" \ +"CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/log_impl.cpp.o" \ +"CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/pose_impl.cpp.o" \ +"CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/occupancy_map_impl.cpp.o" \ +"CMakeFiles/realsense_file.dir/3rd_party/lz4/lib/lz4.c.o" \ +"CMakeFiles/realsense_file.dir/3rd_party/rosbag/console_bridge/src/console.cpp.o" \ +"CMakeFiles/realsense_file.dir/3rd_party/rosbag/rostime/src/rate.cpp.o" \ +"CMakeFiles/realsense_file.dir/3rd_party/rosbag/rostime/src/time.cpp.o" \ +"CMakeFiles/realsense_file.dir/3rd_party/rosbag/rostime/src/duration.cpp.o" \ +"CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/stream.cpp.o" \ +"CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/buffer.cpp.o" \ +"CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/chunked_file.cpp.o" \ +"CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/message_instance.cpp.o" \ +"CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/view.cpp.o" \ +"CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/bag_player.cpp.o" \ +"CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/uncompressed_stream.cpp.o" \ +"CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/lz4_stream.cpp.o" \ +"CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/bag.cpp.o" \ +"CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/query.cpp.o" \ +"CMakeFiles/realsense_file.dir/3rd_party/rosbag/cpp_common/src/header.cpp.o" \ +"CMakeFiles/realsense_file.dir/3rd_party/rosbag/cpp_common/src/debug.cpp.o" \ +"CMakeFiles/realsense_file.dir/3rd_party/rosbag/roscpp_serialization/src/serialization.cpp.o" \ +"CMakeFiles/realsense_file.dir/3rd_party/rosbag/roslz4/src/_roslz4module.c.o" \ +"CMakeFiles/realsense_file.dir/3rd_party/rosbag/roslz4/src/lz4s.c.o" \ +"CMakeFiles/realsense_file.dir/3rd_party/rosbag/roslz4/src/xxhash.c.o" + +# External object files for target realsense_file +realsense_file_EXTERNAL_OBJECTS = + +librealsense_file.so.: CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/conversions.cpp.o +librealsense_file.so.: CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/ros_writer_impl.cpp.o +librealsense_file.so.: CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/stream_recorder_impl.cpp.o +librealsense_file.so.: CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/stream_playback_impl.cpp.o +librealsense_file.so.: CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/vendor_data_impl.cpp.o +librealsense_file.so.: CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/compressed_image_impl.cpp.o +librealsense_file.so.: CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/image_impl.cpp.o +librealsense_file.so.: CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/image_stream_info_impl.cpp.o +librealsense_file.so.: CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/motion_sample_impl.cpp.o +librealsense_file.so.: CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/motion_stream_info_impl.cpp.o +librealsense_file.so.: CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/property_impl.cpp.o +librealsense_file.so.: CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/time_sample_impl.cpp.o +librealsense_file.so.: CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/log_impl.cpp.o +librealsense_file.so.: CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/pose_impl.cpp.o +librealsense_file.so.: CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/occupancy_map_impl.cpp.o +librealsense_file.so.: CMakeFiles/realsense_file.dir/3rd_party/lz4/lib/lz4.c.o +librealsense_file.so.: CMakeFiles/realsense_file.dir/3rd_party/rosbag/console_bridge/src/console.cpp.o +librealsense_file.so.: CMakeFiles/realsense_file.dir/3rd_party/rosbag/rostime/src/rate.cpp.o +librealsense_file.so.: CMakeFiles/realsense_file.dir/3rd_party/rosbag/rostime/src/time.cpp.o +librealsense_file.so.: CMakeFiles/realsense_file.dir/3rd_party/rosbag/rostime/src/duration.cpp.o +librealsense_file.so.: CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/stream.cpp.o +librealsense_file.so.: CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/buffer.cpp.o +librealsense_file.so.: CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/chunked_file.cpp.o +librealsense_file.so.: CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/message_instance.cpp.o +librealsense_file.so.: CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/view.cpp.o +librealsense_file.so.: CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/bag_player.cpp.o +librealsense_file.so.: CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/uncompressed_stream.cpp.o +librealsense_file.so.: CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/lz4_stream.cpp.o +librealsense_file.so.: CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/bag.cpp.o +librealsense_file.so.: CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/query.cpp.o +librealsense_file.so.: CMakeFiles/realsense_file.dir/3rd_party/rosbag/cpp_common/src/header.cpp.o +librealsense_file.so.: CMakeFiles/realsense_file.dir/3rd_party/rosbag/cpp_common/src/debug.cpp.o +librealsense_file.so.: CMakeFiles/realsense_file.dir/3rd_party/rosbag/roscpp_serialization/src/serialization.cpp.o +librealsense_file.so.: CMakeFiles/realsense_file.dir/3rd_party/rosbag/roslz4/src/_roslz4module.c.o +librealsense_file.so.: CMakeFiles/realsense_file.dir/3rd_party/rosbag/roslz4/src/lz4s.c.o +librealsense_file.so.: CMakeFiles/realsense_file.dir/3rd_party/rosbag/roslz4/src/xxhash.c.o +librealsense_file.so.: CMakeFiles/realsense_file.dir/build.make +librealsense_file.so.: CMakeFiles/realsense_file.dir/link.txt + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --bold --progress-dir=/home/administrator/Desktop/realsense_file/CMakeFiles --progress-num=$(CMAKE_PROGRESS_37) "Linking CXX shared library librealsense_file.so" + $(CMAKE_COMMAND) -E cmake_link_script CMakeFiles/realsense_file.dir/link.txt --verbose=$(VERBOSE) + $(CMAKE_COMMAND) -E cmake_symlink_library librealsense_file.so. librealsense_file.so. librealsense_file.so + +librealsense_file.so: librealsense_file.so. + @$(CMAKE_COMMAND) -E touch_nocreate librealsense_file.so + +# Rule to build all files generated by this target. +CMakeFiles/realsense_file.dir/build: librealsense_file.so + +.PHONY : CMakeFiles/realsense_file.dir/build + +CMakeFiles/realsense_file.dir/requires: CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/conversions.cpp.o.requires +CMakeFiles/realsense_file.dir/requires: CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/ros_writer_impl.cpp.o.requires +CMakeFiles/realsense_file.dir/requires: CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/stream_recorder_impl.cpp.o.requires +CMakeFiles/realsense_file.dir/requires: CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/stream_playback_impl.cpp.o.requires +CMakeFiles/realsense_file.dir/requires: CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/vendor_data_impl.cpp.o.requires +CMakeFiles/realsense_file.dir/requires: CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/compressed_image_impl.cpp.o.requires +CMakeFiles/realsense_file.dir/requires: CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/image_impl.cpp.o.requires +CMakeFiles/realsense_file.dir/requires: CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/image_stream_info_impl.cpp.o.requires +CMakeFiles/realsense_file.dir/requires: CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/motion_sample_impl.cpp.o.requires +CMakeFiles/realsense_file.dir/requires: CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/motion_stream_info_impl.cpp.o.requires +CMakeFiles/realsense_file.dir/requires: CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/property_impl.cpp.o.requires +CMakeFiles/realsense_file.dir/requires: CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/time_sample_impl.cpp.o.requires +CMakeFiles/realsense_file.dir/requires: CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/log_impl.cpp.o.requires +CMakeFiles/realsense_file.dir/requires: CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/pose_impl.cpp.o.requires +CMakeFiles/realsense_file.dir/requires: CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/occupancy_map_impl.cpp.o.requires +CMakeFiles/realsense_file.dir/requires: CMakeFiles/realsense_file.dir/3rd_party/lz4/lib/lz4.c.o.requires +CMakeFiles/realsense_file.dir/requires: CMakeFiles/realsense_file.dir/3rd_party/rosbag/console_bridge/src/console.cpp.o.requires +CMakeFiles/realsense_file.dir/requires: CMakeFiles/realsense_file.dir/3rd_party/rosbag/rostime/src/rate.cpp.o.requires +CMakeFiles/realsense_file.dir/requires: CMakeFiles/realsense_file.dir/3rd_party/rosbag/rostime/src/time.cpp.o.requires +CMakeFiles/realsense_file.dir/requires: CMakeFiles/realsense_file.dir/3rd_party/rosbag/rostime/src/duration.cpp.o.requires +CMakeFiles/realsense_file.dir/requires: CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/stream.cpp.o.requires +CMakeFiles/realsense_file.dir/requires: CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/buffer.cpp.o.requires +CMakeFiles/realsense_file.dir/requires: CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/chunked_file.cpp.o.requires +CMakeFiles/realsense_file.dir/requires: CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/message_instance.cpp.o.requires +CMakeFiles/realsense_file.dir/requires: CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/view.cpp.o.requires +CMakeFiles/realsense_file.dir/requires: CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/bag_player.cpp.o.requires +CMakeFiles/realsense_file.dir/requires: CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/uncompressed_stream.cpp.o.requires +CMakeFiles/realsense_file.dir/requires: CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/lz4_stream.cpp.o.requires +CMakeFiles/realsense_file.dir/requires: CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/bag.cpp.o.requires +CMakeFiles/realsense_file.dir/requires: CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/query.cpp.o.requires +CMakeFiles/realsense_file.dir/requires: CMakeFiles/realsense_file.dir/3rd_party/rosbag/cpp_common/src/header.cpp.o.requires +CMakeFiles/realsense_file.dir/requires: CMakeFiles/realsense_file.dir/3rd_party/rosbag/cpp_common/src/debug.cpp.o.requires +CMakeFiles/realsense_file.dir/requires: CMakeFiles/realsense_file.dir/3rd_party/rosbag/roscpp_serialization/src/serialization.cpp.o.requires +CMakeFiles/realsense_file.dir/requires: CMakeFiles/realsense_file.dir/3rd_party/rosbag/roslz4/src/_roslz4module.c.o.requires +CMakeFiles/realsense_file.dir/requires: CMakeFiles/realsense_file.dir/3rd_party/rosbag/roslz4/src/lz4s.c.o.requires +CMakeFiles/realsense_file.dir/requires: CMakeFiles/realsense_file.dir/3rd_party/rosbag/roslz4/src/xxhash.c.o.requires + +.PHONY : CMakeFiles/realsense_file.dir/requires + +CMakeFiles/realsense_file.dir/clean: + $(CMAKE_COMMAND) -P CMakeFiles/realsense_file.dir/cmake_clean.cmake +.PHONY : CMakeFiles/realsense_file.dir/clean + +CMakeFiles/realsense_file.dir/depend: + cd /home/administrator/Desktop/realsense_file && $(CMAKE_COMMAND) -E cmake_depends "Unix Makefiles" /home/administrator/Desktop/realsense_file /home/administrator/Desktop/realsense_file /home/administrator/Desktop/realsense_file /home/administrator/Desktop/realsense_file /home/administrator/Desktop/realsense_file/CMakeFiles/realsense_file.dir/DependInfo.cmake --color=$(COLOR) +.PHONY : CMakeFiles/realsense_file.dir/depend + diff --git a/realsense-file/CMakeFiles/realsense_file.dir/cmake_clean.cmake b/realsense-file/CMakeFiles/realsense_file.dir/cmake_clean.cmake new file mode 100644 index 0000000000..d97f295fc5 --- /dev/null +++ b/realsense-file/CMakeFiles/realsense_file.dir/cmake_clean.cmake @@ -0,0 +1,46 @@ +file(REMOVE_RECURSE + "CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/conversions.cpp.o" + "CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/ros_writer_impl.cpp.o" + "CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/stream_recorder_impl.cpp.o" + "CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/stream_playback_impl.cpp.o" + "CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/vendor_data_impl.cpp.o" + "CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/compressed_image_impl.cpp.o" + "CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/image_impl.cpp.o" + "CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/image_stream_info_impl.cpp.o" + "CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/motion_sample_impl.cpp.o" + "CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/motion_stream_info_impl.cpp.o" + "CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/property_impl.cpp.o" + "CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/time_sample_impl.cpp.o" + "CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/log_impl.cpp.o" + "CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/pose_impl.cpp.o" + "CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/occupancy_map_impl.cpp.o" + "CMakeFiles/realsense_file.dir/3rd_party/lz4/lib/lz4.c.o" + "CMakeFiles/realsense_file.dir/3rd_party/rosbag/console_bridge/src/console.cpp.o" + "CMakeFiles/realsense_file.dir/3rd_party/rosbag/rostime/src/rate.cpp.o" + "CMakeFiles/realsense_file.dir/3rd_party/rosbag/rostime/src/time.cpp.o" + "CMakeFiles/realsense_file.dir/3rd_party/rosbag/rostime/src/duration.cpp.o" + "CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/stream.cpp.o" + "CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/buffer.cpp.o" + "CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/chunked_file.cpp.o" + "CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/message_instance.cpp.o" + "CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/view.cpp.o" + "CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/bag_player.cpp.o" + "CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/uncompressed_stream.cpp.o" + "CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/lz4_stream.cpp.o" + "CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/bag.cpp.o" + "CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/query.cpp.o" + "CMakeFiles/realsense_file.dir/3rd_party/rosbag/cpp_common/src/header.cpp.o" + "CMakeFiles/realsense_file.dir/3rd_party/rosbag/cpp_common/src/debug.cpp.o" + "CMakeFiles/realsense_file.dir/3rd_party/rosbag/roscpp_serialization/src/serialization.cpp.o" + "CMakeFiles/realsense_file.dir/3rd_party/rosbag/roslz4/src/_roslz4module.c.o" + "CMakeFiles/realsense_file.dir/3rd_party/rosbag/roslz4/src/lz4s.c.o" + "CMakeFiles/realsense_file.dir/3rd_party/rosbag/roslz4/src/xxhash.c.o" + "librealsense_file.pdb" + "librealsense_file.so" + "librealsense_file.so." +) + +# Per-language clean rules from dependency scanning. +foreach(lang C CXX) + include(CMakeFiles/realsense_file.dir/cmake_clean_${lang}.cmake OPTIONAL) +endforeach() diff --git a/realsense-file/CMakeFiles/realsense_file.dir/depend.make b/realsense-file/CMakeFiles/realsense_file.dir/depend.make new file mode 100644 index 0000000000..97a89cf657 --- /dev/null +++ b/realsense-file/CMakeFiles/realsense_file.dir/depend.make @@ -0,0 +1,2 @@ +# Empty dependencies file for realsense_file. +# This may be replaced when dependencies are built. diff --git a/realsense-file/CMakeFiles/realsense_file.dir/flags.make b/realsense-file/CMakeFiles/realsense_file.dir/flags.make new file mode 100644 index 0000000000..2cb59ad59d --- /dev/null +++ b/realsense-file/CMakeFiles/realsense_file.dir/flags.make @@ -0,0 +1,17 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.5 + +# compile C with /usr/bin/cc +# compile CXX with /usr/bin/c++ +C_FLAGS = -fPIC + +C_DEFINES = -Drealsense_file_EXPORTS + +C_INCLUDES = -I/home/administrator/Desktop/realsense_file/include -I/home/administrator/Desktop/realsense_file/src/storage/realsense_file/include/msgs -I/home/administrator/Desktop/realsense_file/3rd_party/boost -I/home/administrator/Desktop/realsense_file/3rd_party/rosbag/console_bridge/include -I/home/administrator/Desktop/realsense_file/3rd_party/rosbag/cpp_common/include -I/home/administrator/Desktop/realsense_file/3rd_party/rosbag/rosbag_storage/include -I/home/administrator/Desktop/realsense_file/3rd_party/rosbag/roscpp_serialization/include -I/home/administrator/Desktop/realsense_file/3rd_party/rosbag/rostime/include -I/home/administrator/Desktop/realsense_file/3rd_party/rosbag/roscpp_traits/include -I/home/administrator/Desktop/realsense_file/3rd_party/rosbag/roslz4/include -I/home/administrator/Desktop/realsense_file/3rd_party/lz4/lib -I/home/administrator/Desktop/realsense_file/src/storage/realsense_file + +CXX_FLAGS = -std=c++11 -fPIC -fPIC + +CXX_DEFINES = -Drealsense_file_EXPORTS + +CXX_INCLUDES = -I/home/administrator/Desktop/realsense_file/include -I/home/administrator/Desktop/realsense_file/src/storage/realsense_file/include/msgs -I/home/administrator/Desktop/realsense_file/3rd_party/boost -I/home/administrator/Desktop/realsense_file/3rd_party/rosbag/console_bridge/include -I/home/administrator/Desktop/realsense_file/3rd_party/rosbag/cpp_common/include -I/home/administrator/Desktop/realsense_file/3rd_party/rosbag/rosbag_storage/include -I/home/administrator/Desktop/realsense_file/3rd_party/rosbag/roscpp_serialization/include -I/home/administrator/Desktop/realsense_file/3rd_party/rosbag/rostime/include -I/home/administrator/Desktop/realsense_file/3rd_party/rosbag/roscpp_traits/include -I/home/administrator/Desktop/realsense_file/3rd_party/rosbag/roslz4/include -I/home/administrator/Desktop/realsense_file/3rd_party/lz4/lib -I/home/administrator/Desktop/realsense_file/src/storage/realsense_file + diff --git a/realsense-file/CMakeFiles/realsense_file.dir/link.txt b/realsense-file/CMakeFiles/realsense_file.dir/link.txt new file mode 100644 index 0000000000..67e0fff6d0 --- /dev/null +++ b/realsense-file/CMakeFiles/realsense_file.dir/link.txt @@ -0,0 +1 @@ +/usr/bin/c++ -fPIC -std=c++11 -fPIC -shared -Wl,-soname,librealsense_file.so. -o librealsense_file.so. CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/conversions.cpp.o CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/ros_writer_impl.cpp.o CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/stream_recorder_impl.cpp.o CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/stream_playback_impl.cpp.o CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/vendor_data_impl.cpp.o CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/compressed_image_impl.cpp.o CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/image_impl.cpp.o CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/image_stream_info_impl.cpp.o CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/motion_sample_impl.cpp.o CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/motion_stream_info_impl.cpp.o CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/property_impl.cpp.o CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/time_sample_impl.cpp.o CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/log_impl.cpp.o CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/pose_impl.cpp.o CMakeFiles/realsense_file.dir/src/storage/realsense_file/file_stream/data_objects/occupancy_map_impl.cpp.o CMakeFiles/realsense_file.dir/3rd_party/lz4/lib/lz4.c.o CMakeFiles/realsense_file.dir/3rd_party/rosbag/console_bridge/src/console.cpp.o CMakeFiles/realsense_file.dir/3rd_party/rosbag/rostime/src/rate.cpp.o CMakeFiles/realsense_file.dir/3rd_party/rosbag/rostime/src/time.cpp.o CMakeFiles/realsense_file.dir/3rd_party/rosbag/rostime/src/duration.cpp.o CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/stream.cpp.o CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/buffer.cpp.o CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/chunked_file.cpp.o CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/message_instance.cpp.o CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/view.cpp.o CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/bag_player.cpp.o CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/uncompressed_stream.cpp.o CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/lz4_stream.cpp.o CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/bag.cpp.o CMakeFiles/realsense_file.dir/3rd_party/rosbag/rosbag_storage/src/query.cpp.o CMakeFiles/realsense_file.dir/3rd_party/rosbag/cpp_common/src/header.cpp.o CMakeFiles/realsense_file.dir/3rd_party/rosbag/cpp_common/src/debug.cpp.o CMakeFiles/realsense_file.dir/3rd_party/rosbag/roscpp_serialization/src/serialization.cpp.o CMakeFiles/realsense_file.dir/3rd_party/rosbag/roslz4/src/_roslz4module.c.o CMakeFiles/realsense_file.dir/3rd_party/rosbag/roslz4/src/lz4s.c.o CMakeFiles/realsense_file.dir/3rd_party/rosbag/roslz4/src/xxhash.c.o diff --git a/realsense-file/CMakeFiles/realsense_file.dir/progress.make b/realsense-file/CMakeFiles/realsense_file.dir/progress.make new file mode 100644 index 0000000000..8898dbed22 --- /dev/null +++ b/realsense-file/CMakeFiles/realsense_file.dir/progress.make @@ -0,0 +1,38 @@ +CMAKE_PROGRESS_1 = 1 +CMAKE_PROGRESS_2 = 2 +CMAKE_PROGRESS_3 = 3 +CMAKE_PROGRESS_4 = 4 +CMAKE_PROGRESS_5 = 5 +CMAKE_PROGRESS_6 = 6 +CMAKE_PROGRESS_7 = 7 +CMAKE_PROGRESS_8 = 8 +CMAKE_PROGRESS_9 = 9 +CMAKE_PROGRESS_10 = 10 +CMAKE_PROGRESS_11 = 11 +CMAKE_PROGRESS_12 = 12 +CMAKE_PROGRESS_13 = 13 +CMAKE_PROGRESS_14 = 14 +CMAKE_PROGRESS_15 = 15 +CMAKE_PROGRESS_16 = 16 +CMAKE_PROGRESS_17 = 17 +CMAKE_PROGRESS_18 = 18 +CMAKE_PROGRESS_19 = 19 +CMAKE_PROGRESS_20 = 20 +CMAKE_PROGRESS_21 = 21 +CMAKE_PROGRESS_22 = 22 +CMAKE_PROGRESS_23 = 23 +CMAKE_PROGRESS_24 = 24 +CMAKE_PROGRESS_25 = 25 +CMAKE_PROGRESS_26 = 26 +CMAKE_PROGRESS_27 = 27 +CMAKE_PROGRESS_28 = 28 +CMAKE_PROGRESS_29 = 29 +CMAKE_PROGRESS_30 = 30 +CMAKE_PROGRESS_31 = 31 +CMAKE_PROGRESS_32 = 32 +CMAKE_PROGRESS_33 = 33 +CMAKE_PROGRESS_34 = 34 +CMAKE_PROGRESS_35 = 35 +CMAKE_PROGRESS_36 = 36 +CMAKE_PROGRESS_37 = 37 + diff --git a/realsense-file/CMakeLists.txt b/realsense-file/CMakeLists.txt new file mode 100644 index 0000000000..5d1e91096d --- /dev/null +++ b/realsense-file/CMakeLists.txt @@ -0,0 +1,138 @@ +cmake_minimum_required(VERSION 2.8.9) +project(realsense_file) + +SET(ROOT_DIR ${CMAKE_CURRENT_SOURCE_DIR}) + +set(HEADER_FILES_ROSBAG + + ${HEADER_FILES_ROSLZ4} +) +set(HEADER_FILES_FILE_STREAM + ${ROOT_DIR}/include/rs/storage/realsense_file/stream_recorder.h + ${ROOT_DIR}/include/rs/storage/realsense_file/status.h + ${ROOT_DIR}/include/rs/storage/realsense_file/stream_playback.h + ${ROOT_DIR}/include/rs/storage/realsense_file/file_types.h + ${ROOT_DIR}/include/rs/storage/realsense_file/ros_writer.h + ${ROOT_DIR}/include/rs/storage/realsense_file/data_objects/stream_data.h + ${ROOT_DIR}/include/rs/storage/realsense_file/data_objects/property.h + ${ROOT_DIR}/include/rs/storage/realsense_file/data_objects/vendor_data.h + ${ROOT_DIR}/include/rs/storage/realsense_file/data_objects/image_stream_info.h + ${ROOT_DIR}/include/rs/storage/realsense_file/data_objects/motion_stream_info.h + ${ROOT_DIR}/include/rs/storage/realsense_file/data_objects/image.h + ${ROOT_DIR}/include/rs/storage/realsense_file/data_objects/compressed_image.h + ${ROOT_DIR}/include/rs/storage/realsense_file/data_objects/motion_sample.h + ${ROOT_DIR}/include/rs/storage/realsense_file/data_objects/time_sample.h + ${ROOT_DIR}/include/rs/storage/realsense_file/data_objects/log.h + ${ROOT_DIR}/include/rs/storage/realsense_file/data_objects/pose.h + ${ROOT_DIR}/include/rs/storage/realsense_file/data_objects/occupancy_map.h +) +set(SOURCE_FILES_FILE_STREAM + ${ROOT_DIR}/src/storage/realsense_file/file_stream/include/conversions.h + ${ROOT_DIR}/src/storage/realsense_file/file_stream/include/topic.h + ${ROOT_DIR}/src/storage/realsense_file/file_stream/include/ros_writer_impl.h + ${ROOT_DIR}/src/storage/realsense_file/file_stream/include/stream_recorder_impl.h + ${ROOT_DIR}/src/storage/realsense_file/file_stream/include/stream_playback_impl.h + ${ROOT_DIR}/src/storage/realsense_file/file_stream/include/data_objects/vendor_data_impl.h + ${ROOT_DIR}/src/storage/realsense_file/file_stream/include/data_objects/compressed_image_impl.h + ${ROOT_DIR}/src/storage/realsense_file/file_stream/include/data_objects/image_impl.h + ${ROOT_DIR}/src/storage/realsense_file/file_stream/include/data_objects/image_stream_info_impl.h + ${ROOT_DIR}/src/storage/realsense_file/file_stream/include/data_objects/motion_sample_impl.h + ${ROOT_DIR}/src/storage/realsense_file/file_stream/include/data_objects/motion_stream_info_impl.h + ${ROOT_DIR}/src/storage/realsense_file/file_stream/include/data_objects/property_impl.h + ${ROOT_DIR}/src/storage/realsense_file/file_stream/include/data_objects/time_sample_impl.h + ${ROOT_DIR}/src/storage/realsense_file/file_stream/include/data_objects/log_impl.h + ${ROOT_DIR}/src/storage/realsense_file/file_stream/include/data_objects/pose_impl.h + ${ROOT_DIR}/src/storage/realsense_file/file_stream/include/data_objects/occupancy_map_impl.h + + ${ROOT_DIR}/src/storage/realsense_file/file_stream/conversions.cpp + ${ROOT_DIR}/src/storage/realsense_file/file_stream/ros_writer_impl.cpp + ${ROOT_DIR}/src/storage/realsense_file/file_stream/stream_recorder_impl.cpp + ${ROOT_DIR}/src/storage/realsense_file/file_stream/stream_playback_impl.cpp + ${ROOT_DIR}/src/storage/realsense_file/file_stream/data_objects/vendor_data_impl.cpp + ${ROOT_DIR}/src/storage/realsense_file/file_stream/data_objects/compressed_image_impl.cpp + ${ROOT_DIR}/src/storage/realsense_file/file_stream/data_objects/image_impl.cpp + ${ROOT_DIR}/src/storage/realsense_file/file_stream/data_objects/image_stream_info_impl.cpp + ${ROOT_DIR}/src/storage/realsense_file/file_stream/data_objects/motion_sample_impl.cpp + ${ROOT_DIR}/src/storage/realsense_file/file_stream/data_objects/motion_stream_info_impl.cpp + ${ROOT_DIR}/src/storage/realsense_file/file_stream/data_objects/property_impl.cpp + ${ROOT_DIR}/src/storage/realsense_file/file_stream/data_objects/time_sample_impl.cpp + ${ROOT_DIR}/src/storage/realsense_file/file_stream/data_objects/log_impl.cpp + ${ROOT_DIR}/src/storage/realsense_file/file_stream/data_objects/pose_impl.cpp + ${ROOT_DIR}/src/storage/realsense_file/file_stream/data_objects/occupancy_map_impl.cpp +) + +set(ROSBAG_HEADER_DIRS + ${ROOT_DIR}/3rd_party/rosbag/console_bridge/include/ + ${ROOT_DIR}/3rd_party/rosbag/cpp_common/include/ + ${ROOT_DIR}/3rd_party/rosbag/rosbag_storage/include/ + ${ROOT_DIR}/3rd_party/rosbag/roscpp_serialization/include/ + ${ROOT_DIR}/3rd_party/rosbag/rostime/include/ + ${ROOT_DIR}/3rd_party/rosbag/roscpp_traits/include/ + ${ROOT_DIR}/3rd_party/rosbag/roslz4/include/ + ) + + +set(BOOST_DIR ${ROOT_DIR}/3rd_party/boost) +set(BOOST_INCLUDE_PATH ${BOOST_DIR}/) +set(LZ4_DIR ${ROOT_DIR}/3rd_party/lz4) +set(LZ4_INCLUDE_PATH ${LZ4_DIR}/lib/) +set(ROSBAG_DIR 3rd_party/rosbag) +#set(ROSBAG_INCLUDE_PATH ${ROSBAG_DIR}/) +set(REALSENSE_FILE_DIR realsense_file) +set(REALSENSE_FILE_INCLUDE_PATH ${REALSENSE_FILE_DIR}/include/) + +#find_package(Boost COMPONENTS system REQUIRED) +set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11") +set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIC") + +FILE(GLOB_RECURSE AllSources ${LZ4_DIR}/lib/lz4.h ${LZ4_DIR}/lib/lz4.c ${BOOST_DIR} ${ROSBAG_DIR}/*.h ${ROSBAG_DIR}/*.cpp ${ROSBAG_DIR}/*.c ${REALSENSE_FILE_DIR} ${REALSENSE_FILE_DIR}/*.h ${REALSENSE_FILE_DIR}/*.cpp) +#MESSAGE("Boost files: ${AllSources}") +include_directories( + ${ROOT_DIR}/include + ${ROOT_DIR}/src/storage/realsense_file/include/msgs + ${BOOST_INCLUDE_PATH} + ${ROSBAG_HEADER_DIRS} + ${LZ4_INCLUDE_PATH} + ${ROOT_DIR}/src/storage/realsense_file +) +set_property(GLOBAL PROPERTY USE_FOLDERS ON) +source_group("Header Files\\3rd_party\\lz4" FILES + 3rd_party/lz4/lib/lz4.h + ) +source_group("Source Files\\3rd_party\\lz4" FILES + 3rd_party/lz4/lib/lz4.c + ) + +source_group("Header Files\\3rd_party\\boost" REGULAR_EXPRESSION + 3rd_party/boost/boost/*.hpp + ) + +add_library(${PROJECT_NAME} STATIC + ${HEADER_FILES_FILE_STREAM} + ${SOURCE_FILES_FILE_STREAM} + ${AllSources} + + #${HEADER_FILES_ROSBAG} + #${SOURCE_FILES_ROSBAG} + ##${SOURCE_FILES_COMPRESSION} +) + +set_target_properties(${PROJECT_NAME} PROPERTIES VERSION "${LIBVERSION}" SOVERSION "${LIBSOVERSION}") + +target_link_libraries(${PROJECT_NAME} +# ${Boost_SYSTEM_LIBRARY} +# liblz4_x64 +) + +set_target_properties (${PROJECT_NAME} PROPERTIES + FOLDER Library +) + +set(CMAKECONFIG_INSTALL_DIR "${CMAKE_INSTALL_LIBDIR}/../cmake/realsense2") + +install(TARGETS ${PROJECT_NAME} + EXPORT realsense2Targets + RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} + LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} + ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} +) diff --git a/realsense-file/include/rs/storage/realsense_file/data_objects/compressed_image.h b/realsense-file/include/rs/storage/realsense_file/data_objects/compressed_image.h new file mode 100644 index 0000000000..1353dbc4c4 --- /dev/null +++ b/realsense-file/include/rs/storage/realsense_file/data_objects/compressed_image.h @@ -0,0 +1,58 @@ +// License: Apache 2.0. See LICENSE file in root directory. +// Copyright(c) 2017 Intel Corporation. All Rights Reserved. + +#pragma once +#include +#include "rs/storage/realsense_file/data_objects/stream_data.h" + +#ifdef _WIN32 +#ifdef realsense_file_EXPORTS +#define DLL_EXPORT __declspec(dllexport) +#else +#define DLL_EXPORT __declspec(dllimport) +#endif /* realsense_file_EXPORTS */ +#else /* defined (WIN32) */ +#define DLL_EXPORT +#endif + +namespace rs +{ + namespace file_format + { + namespace ros_data_objects + { + struct DLL_EXPORT compressed_image_info + { + std::string stream; + uint32_t width; + uint32_t height; + file_types::pixel_format format; + uint32_t step; + file_types::nanoseconds capture_time; + file_types::seconds timestamp; + file_types::nanoseconds system_time; + file_types::timestamp_domain timestamp_domain; + uint32_t device_id; + uint32_t frame_number; + std::shared_ptr data; + file_types::compression_type compression_type; + uint32_t compression_size; + std::map> metadata; + }; + + class DLL_EXPORT compressed_image : public sample + { + public: + virtual ~compressed_image(){} + virtual compressed_image_info get_info() const = 0; + virtual void set_info(const compressed_image_info& info) = 0; + + static std::string get_topic(std::string stream, uint32_t device_id); + static std::string get_info_topic(std::string stream, uint32_t device_id); + + static std::shared_ptr create(const compressed_image_info& info); + + }; + } + } +} diff --git a/realsense-file/include/rs/storage/realsense_file/data_objects/image.h b/realsense-file/include/rs/storage/realsense_file/data_objects/image.h new file mode 100644 index 0000000000..85713ed934 --- /dev/null +++ b/realsense-file/include/rs/storage/realsense_file/data_objects/image.h @@ -0,0 +1,58 @@ +// License: Apache 2.0. See LICENSE file in root directory. +// Copyright(c) 2017 Intel Corporation. All Rights Reserved. + +#pragma once +#include +#include +#include "rs/storage/realsense_file/data_objects/stream_data.h" + +#ifdef _WIN32 +#ifdef realsense_file_EXPORTS +#define DLL_EXPORT __declspec(dllexport) +#else +#define DLL_EXPORT __declspec(dllimport) +#endif /* realsense_file_EXPORTS */ +#else /* defined (WIN32) */ +#define DLL_EXPORT +#endif + +namespace rs +{ + namespace file_format + { + namespace ros_data_objects + { + struct DLL_EXPORT image_info + { + std::string stream; + uint32_t width; + uint32_t height; + file_types::pixel_format format; + uint32_t step; + file_types::nanoseconds capture_time; + file_types::seconds timestamp; + file_types::nanoseconds system_time; + file_types::timestamp_domain timestamp_domain; + uint32_t device_id; + uint32_t frame_number; + std::shared_ptr data; + std::map> metadata; + }; + + class DLL_EXPORT image : public sample + { + public: + virtual ~image() = default; + + virtual const image_info& get_info() const = 0; + virtual void set_info(const image_info& info) = 0; + + static std::string get_topic(std::string stream, uint32_t device_id); + static std::string get_info_topic(std::string stream, uint32_t device_id); + + static std::shared_ptr create(const image_info& info); + + }; + } + } +} diff --git a/realsense-file/include/rs/storage/realsense_file/data_objects/image_stream_info.h b/realsense-file/include/rs/storage/realsense_file/data_objects/image_stream_info.h new file mode 100644 index 0000000000..7959c37c47 --- /dev/null +++ b/realsense-file/include/rs/storage/realsense_file/data_objects/image_stream_info.h @@ -0,0 +1,48 @@ +// License: Apache 2.0. See LICENSE file in root directory. +// Copyright(c) 2017 Intel Corporation. All Rights Reserved. + +#pragma once +#include "rs/storage/realsense_file/data_objects/stream_data.h" + +#ifdef _WIN32 +#ifdef realsense_file_EXPORTS +#define DLL_EXPORT __declspec(dllexport) +#else +#define DLL_EXPORT __declspec(dllimport) +#endif /* realsense_file_EXPORTS */ +#else /* defined (WIN32) */ +#define DLL_EXPORT +#endif + +namespace rs +{ + namespace file_format + { + namespace ros_data_objects + { + struct DLL_EXPORT image_stream_data + { + uint32_t width; + uint32_t height; + file_types::intrinsics intrinsics; + file_types::stream_extrinsics stream_extrinsics; + uint32_t device_id; + std::string type; + uint32_t fps; + file_types::pixel_format format; + }; + + class DLL_EXPORT image_stream_info : public stream_info + { + public: + virtual ~image_stream_info(){} + static std::string get_topic(const uint32_t& device_id); + + virtual const image_stream_data& get_info() const = 0; + virtual void set_info(const image_stream_data& info) = 0; + + static std::shared_ptr create(const image_stream_data& info); + }; + } + } +} diff --git a/realsense-file/include/rs/storage/realsense_file/data_objects/log.h b/realsense-file/include/rs/storage/realsense_file/data_objects/log.h new file mode 100644 index 0000000000..2faed2d0b4 --- /dev/null +++ b/realsense-file/include/rs/storage/realsense_file/data_objects/log.h @@ -0,0 +1,50 @@ +// License: Apache 2.0. See LICENSE file in root directory. +// Copyright(c) 2017 Intel Corporation. All Rights Reserved. + +#pragma once + +#include +#include "rs/storage/realsense_file/data_objects/stream_data.h" + +#ifdef _WIN32 +#ifdef realsense_file_EXPORTS +#define DLL_EXPORT __declspec(dllexport) +#else +#define DLL_EXPORT __declspec(dllimport) +#endif /* realsense_file_EXPORTS */ +#else /* defined (WIN32) */ +#define DLL_EXPORT +#endif + +namespace rs +{ + namespace file_format + { + namespace ros_data_objects + { + struct DLL_EXPORT log_info + { + uint8_t level; + std::string message; + std::string file; + std::string function; + uint32_t line; + file_types::nanoseconds capture_time; + + }; + + class DLL_EXPORT log : public sample + { + public: + virtual ~log() = default; + + virtual log_info get_info() const = 0; + virtual void set_info(const log_info& info) = 0; + + static std::string get_topic(); + static std::shared_ptr create(const log_info& info); + }; + } + } +} + diff --git a/realsense-file/include/rs/storage/realsense_file/data_objects/motion_sample.h b/realsense-file/include/rs/storage/realsense_file/data_objects/motion_sample.h new file mode 100644 index 0000000000..9b67b1c04b --- /dev/null +++ b/realsense-file/include/rs/storage/realsense_file/data_objects/motion_sample.h @@ -0,0 +1,48 @@ +// License: Apache 2.0. See LICENSE file in root directory. +// Copyright(c) 2017 Intel Corporation. All Rights Reserved. + +#pragma once +#include "rs/storage/realsense_file/data_objects/stream_data.h" + +#ifdef _WIN32 +#ifdef realsense_file_EXPORTS +#define DLL_EXPORT __declspec(dllexport) +#else +#define DLL_EXPORT __declspec(dllimport) +#endif /* realsense_file_EXPORTS */ +#else /* defined (WIN32) */ +#define DLL_EXPORT +#endif + +namespace rs +{ + namespace file_format + { + namespace ros_data_objects + { + struct DLL_EXPORT motion_info + { + file_types::nanoseconds capture_time; + uint32_t device_id; + file_types::motion_type type; + float data[3]; + file_types::seconds timestamp; + uint32_t frame_number; + }; + + class DLL_EXPORT motion_sample : public sample + { + public: + virtual ~motion_sample() = default; + + virtual motion_info get_info() const = 0; + virtual void set_info(const motion_info& info) = 0; + + static std::string get_topic(file_types::motion_type, uint32_t device_id); + + static std::shared_ptr create(const motion_info& info); + }; + } + } + +} diff --git a/realsense-file/include/rs/storage/realsense_file/data_objects/motion_stream_info.h b/realsense-file/include/rs/storage/realsense_file/data_objects/motion_stream_info.h new file mode 100644 index 0000000000..3ec2e7e423 --- /dev/null +++ b/realsense-file/include/rs/storage/realsense_file/data_objects/motion_stream_info.h @@ -0,0 +1,46 @@ +// License: Apache 2.0. See LICENSE file in root directory. +// Copyright(c) 2017 Intel Corporation. All Rights Reserved. + +#pragma once +#include "rs/storage/realsense_file/data_objects/stream_data.h" + +#ifdef _WIN32 +#ifdef realsense_file_EXPORTS +#define DLL_EXPORT __declspec(dllexport) +#else +#define DLL_EXPORT __declspec(dllimport) +#endif /* realsense_file_EXPORTS */ +#else /* defined (WIN32) */ +#define DLL_EXPORT +#endif + +namespace rs +{ + namespace file_format + { + namespace ros_data_objects + { + struct DLL_EXPORT motion_stream_data + { + file_types::motion_type type; + uint32_t fps; + file_types::motion_intrinsics intrinsics; + file_types::stream_extrinsics stream_extrinsics; + uint32_t device_id; + }; + + class DLL_EXPORT motion_stream_info : public stream_info + { + public: + virtual ~motion_stream_info(){} + + virtual motion_stream_data get_info() const = 0; + virtual void set_info(const motion_stream_data& info) = 0; + + static std::string get_topic(uint32_t device_id); + + static std::shared_ptr create(const motion_stream_data& info); + }; + } + } +} diff --git a/realsense-file/include/rs/storage/realsense_file/data_objects/occupancy_map.h b/realsense-file/include/rs/storage/realsense_file/data_objects/occupancy_map.h new file mode 100644 index 0000000000..012fa84024 --- /dev/null +++ b/realsense-file/include/rs/storage/realsense_file/data_objects/occupancy_map.h @@ -0,0 +1,49 @@ +// License: Apache 2.0. See LICENSE file in root directory. +// Copyright(c) 2017 Intel Corporation. All Rights Reserved. + +#pragma once +#include "rs/storage/realsense_file/data_objects/stream_data.h" + +#ifdef _WIN32 +#ifdef realsense_file_EXPORTS +#define DLL_EXPORT __declspec(dllexport) +#else +#define DLL_EXPORT __declspec(dllimport) +#endif /* realsense_file_EXPORTS */ +#else /* defined (WIN32) */ +#define DLL_EXPORT +#endif + +namespace rs +{ + namespace file_format + { + namespace ros_data_objects + { + struct DLL_EXPORT occupancy_map_info + { + uint8_t accuracy; + uint8_t reserved; + uint16_t tile_count; + std::shared_ptr tiles; + file_types::nanoseconds capture_time; + uint32_t device_id; + + }; + + class DLL_EXPORT occupancy_map : public sample + { + public: + virtual ~occupancy_map() = default; + + virtual occupancy_map_info get_info() const = 0; + virtual void set_info(const occupancy_map_info& info) = 0; + + static std::string get_topic(uint32_t device_id); + static std::shared_ptr create(const occupancy_map_info& info); + }; + } + } +} + + diff --git a/realsense-file/include/rs/storage/realsense_file/data_objects/pose.h b/realsense-file/include/rs/storage/realsense_file/data_objects/pose.h new file mode 100644 index 0000000000..3d1c2d39b9 --- /dev/null +++ b/realsense-file/include/rs/storage/realsense_file/data_objects/pose.h @@ -0,0 +1,53 @@ +// License: Apache 2.0. See LICENSE file in root directory. +// Copyright(c) 2017 Intel Corporation. All Rights Reserved. + +#pragma once + +#include "rs/storage/realsense_file/data_objects/stream_data.h" + +#ifdef _WIN32 +#ifdef realsense_file_EXPORTS +#define DLL_EXPORT __declspec(dllexport) +#else +#define DLL_EXPORT __declspec(dllimport) +#endif /* realsense_file_EXPORTS */ +#else /* defined (WIN32) */ +#define DLL_EXPORT +#endif + +namespace rs +{ + namespace file_format + { + namespace ros_data_objects + { + struct DLL_EXPORT pose_info + { + file_types::vector3 translation; + file_types::vector4 rotation; + file_types::vector3 velocity; + file_types::vector3 angular_velocity; + file_types::vector3 acceleration; + file_types::vector3 angular_acceleration; + file_types::nanoseconds capture_time; + file_types::nanoseconds timestamp; + file_types::nanoseconds system_timestamp; + uint32_t device_id; + + }; + + class DLL_EXPORT pose : public sample + { + public: + virtual ~pose() = default; + + virtual pose_info get_info() const = 0; + virtual void set_info(const pose_info& info) = 0; + + static std::string get_topic(uint32_t device_id); + static std::shared_ptr create(const pose_info& info); + }; + } + } +} + diff --git a/realsense-file/include/rs/storage/realsense_file/data_objects/property.h b/realsense-file/include/rs/storage/realsense_file/data_objects/property.h new file mode 100644 index 0000000000..8dc844a003 --- /dev/null +++ b/realsense-file/include/rs/storage/realsense_file/data_objects/property.h @@ -0,0 +1,49 @@ +// License: Apache 2.0. See LICENSE file in root directory. +// Copyright(c) 2017 Intel Corporation. All Rights Reserved. + +#pragma once +#include "rs/storage/realsense_file/data_objects/stream_data.h" + +#ifdef _WIN32 +#ifdef realsense_file_EXPORTS +#define DLL_EXPORT __declspec(dllexport) +#else +#define DLL_EXPORT __declspec(dllimport) +#endif /* realsense_file_EXPORTS */ +#else /* defined (WIN32) */ +#define DLL_EXPORT +#endif + +namespace rs +{ + namespace file_format + { + namespace ros_data_objects + { + + struct DLL_EXPORT property_info + { + file_types::nanoseconds capture_time; + uint32_t device_id; + std::string key; + double value; + }; + + class DLL_EXPORT property : public sample + { + public: + virtual ~property() = default; + + virtual property_info get_info() const = 0; + virtual void set_info(const property_info& info) = 0; + + static std::string get_topic(const std::string& key, uint32_t device_id); + + static std::shared_ptr create(const property_info& info); + + }; + } + } +} + + diff --git a/realsense-file/include/rs/storage/realsense_file/data_objects/stream_data.h b/realsense-file/include/rs/storage/realsense_file/data_objects/stream_data.h new file mode 100644 index 0000000000..c6268a7a4a --- /dev/null +++ b/realsense-file/include/rs/storage/realsense_file/data_objects/stream_data.h @@ -0,0 +1,35 @@ +// License: Apache 2.0. See LICENSE file in root directory. +// Copyright(c) 2017 Intel Corporation. All Rights Reserved. + +#pragma once +#include +#include "rs/storage/realsense_file/status.h" +#include "rs/storage/realsense_file/ros_writer.h" +#include "rs/storage/realsense_file/file_types.h" + +namespace rs +{ + namespace file_format + { + namespace ros_data_objects + { + class stream_data + { + public: + virtual ~stream_data(){} + virtual rs::file_format::status write_data(std::shared_ptr file) = 0; + }; + + struct stream_info : stream_data + { + virtual ~stream_info(){} + }; + + struct sample : stream_data + { + virtual ~sample(){} + virtual file_types::sample_type get_type() const = 0; + }; + } + } +} diff --git a/realsense-file/include/rs/storage/realsense_file/data_objects/time_sample.h b/realsense-file/include/rs/storage/realsense_file/data_objects/time_sample.h new file mode 100644 index 0000000000..aec8498de6 --- /dev/null +++ b/realsense-file/include/rs/storage/realsense_file/data_objects/time_sample.h @@ -0,0 +1,50 @@ +// License: Apache 2.0. See LICENSE file in root directory. +// Copyright(c) 2017 Intel Corporation. All Rights Reserved. + +#pragma once +#include "rs/storage/realsense_file/data_objects/stream_data.h" + +#ifdef _WIN32 +#ifdef realsense_file_EXPORTS +#define DLL_EXPORT __declspec(dllexport) +#else +#define DLL_EXPORT __declspec(dllimport) +#endif /* realsense_file_EXPORTS */ +#else /* defined (WIN32) */ +#define DLL_EXPORT +#endif + +namespace rs +{ + namespace file_format + { + namespace ros_data_objects + { + + struct DLL_EXPORT time_sample_info + { + file_types::nanoseconds capture_time; + uint32_t device_id; + std::string source; + file_types::seconds timestamp; + uint32_t frame_number; + }; + + class DLL_EXPORT time_sample : public sample + { + public: + virtual ~time_sample() = default; + + virtual time_sample_info get_info() const = 0; + virtual void set_info(const time_sample_info& info) = 0; + + static std::string get_topic(uint32_t device_id); + + static std::shared_ptr create(const time_sample_info& info); + + }; + } + } +} + + diff --git a/realsense-file/include/rs/storage/realsense_file/data_objects/vendor_data.h b/realsense-file/include/rs/storage/realsense_file/data_objects/vendor_data.h new file mode 100644 index 0000000000..87bd7cc4d8 --- /dev/null +++ b/realsense-file/include/rs/storage/realsense_file/data_objects/vendor_data.h @@ -0,0 +1,45 @@ +// License: Apache 2.0. See LICENSE file in root directory. +// Copyright(c) 2017 Intel Corporation. All Rights Reserved. + +#pragma once +#include "rs/storage/realsense_file/data_objects/stream_data.h" + +#ifdef _WIN32 +#ifdef realsense_file_EXPORTS +#define DLL_EXPORT __declspec(dllexport) +#else +#define DLL_EXPORT __declspec(dllimport) +#endif /* realsense_file_EXPORTS */ +#else /* defined (WIN32) */ +#define DLL_EXPORT +#endif + +namespace rs +{ + namespace file_format + { + namespace ros_data_objects + { + struct DLL_EXPORT vendor_info + { + std::string name; + std::string value; + uint32_t device_id; + }; + + class DLL_EXPORT vendor_data : public stream_data + { + public: + virtual ~vendor_data() = default; + + virtual vendor_info get_info() const = 0; + virtual void set_info(const vendor_info& info) = 0; + + static std::string get_topic(const uint32_t& device_id = -1); + static std::shared_ptr create(const vendor_info& info); + }; + } + } +} + + diff --git a/realsense-file/include/rs/storage/realsense_file/file_types.h b/realsense-file/include/rs/storage/realsense_file/file_types.h new file mode 100644 index 0000000000..699d21cee6 --- /dev/null +++ b/realsense-file/include/rs/storage/realsense_file/file_types.h @@ -0,0 +1,208 @@ +// License: Apache 2.0. See LICENSE file in root directory. +// Copyright(c) 2017 Intel Corporation. All Rights Reserved. + +#pragma once +#include +#include + +namespace rs +{ + namespace file_format + { + namespace file_types + { + + using nanoseconds = std::chrono::duration; + using microseconds = std::chrono::duration; + using seconds = std::chrono::duration; + + /** + * @brief Sample type + */ + enum sample_type + { + st_image, + st_compressed_image, + st_motion, + st_time, + st_log, + st_property, + st_pose, + st_occupancy_map + }; + + /** + * @brief Motion stream type + */ + enum motion_type + { + gyro, /**< Gyroscope */ + accel /**< Accelerometer */ + }; + + /** + * @brief Motion stream type - represented with string + */ + namespace motion_stream_type + { + const std::string GYRO = "GYROMETER"; + const std::string ACCL = "ACCLEROMETER"; + } + + /** + * @brief Stream type + */ + namespace stream_type + { + const std::string DEPTH = "DEPTH"; /**< Native stream of depth data produced by the device */ + const std::string COLOR = "COLOR"; /**< Native stream of color data captured by the device */ + const std::string INFRARED = "INFRARED"; /**< Native stream of infrared data captured by the device */ + const std::string INFRARED2 = "INFRARED2"; /**< Native stream of infrared data captured from a second viewpoint by the device */ + const std::string FISHEYE = "FISHEYE"; /**< Native stream of fish-eye (wide) data captured from the dedicate motion camera */ + const std::string RECTIFIED_COLOR = "RECTIFIED_COLOR"; /**< Synthetic stream containing undistorted color data with no extrinsic rotation from the depth stream */ + } + + /** + * @brief Distortion model types + */ + namespace distortion + { + const std::string DISTORTION_NONE = "DISTORTION_NONE"; /**< Rectilinear images. No distortion compensation required. */ + const std::string DISTORTION_MODIFIED_BROWN_CONRADY = "DISTORTION_MODIFIED_BROWN_CONRADY"; /**< Equivalent to Brown-Conrady distortion, except that tangential distortion is applied to radially distorted points */ + const std::string DISTORTION_UNMODIFIED_BROWN_CONRADY = "DISTORTION_UNMODIFIED_BROWN_CONRADY"; /**< Unmodified Brown-Conrady distortion model */ + const std::string DISTORTION_INVERSE_BROWN_CONRADY = "DISTORTION_INVERSE_BROWN_CONRADY"; /**< Equivalent to Brown-Conrady distortion, except undistorts image instead of distorting it */ + const std::string DISTORTION_FTHETA = "DISTORTION_FTHETA"; /**< F-Theta fish-eye distortion model */ + } + + /** + * @brief Image pixel format + */ + enum class pixel_format : int32_t + { + custom = 0, /**< custom pixel format that is not part of the given pixel format list */ + z16 = 1, /**< 16-bit linear depth values. The depth is meters is equal to depth scale * pixel value */ + disparity16 = 2, /**< 16-bit linear disparity values. The depth in meters is equal to depth scale / pixel value */ + xyz32f = 3, /**< 32-bit floating point 3D coordinates. */ + yuyv = 4, /**< The yuyv color format. See [fourcc.org](http://fourcc.org/) for the description and memory layout.*/ + rgb8 = 5, /**< The 24-bit RGB24 color format. See [fourcc.org](http://fourcc.org/) for the description and memory layout.*/ + bgr8 = 6, /**< The 24-bit BGR24 color format. See [fourcc.org](http://fourcc.org/) for the description and memory layout.*/ + rgba8 = 7, /**< The 32-bit RGBA32 color format. See [fourcc.org](http://fourcc.org/) for the description and memory layout. */ + bgra8 = 8, /**< The 32-bit BGRA32 color format. See [fourcc.org](http://fourcc.org/) for the description and memory layout. */ + y8 = 9, /**< The 8-bit gray format. Also used for the 8-bit IR data. See [fourcc.org](http://fourcc.org/) for the description and memory layout. */ + y16 = 10, /**< The 16-bit gray format. Also used for the 16-bit IR data. See [fourcc.org](http://fourcc.org/) for the description and memory layout. */ + raw8 = 11, /**< The 8-bit gray format. */ + raw10 = 12, /**< Four 10-bit luminance values encoded into a 5-byte macro pixel */ + raw16 = 13, /**< Custom format for camera calibration */ + uyvy = 14, /**< The uyvy color format. See [fourcc.org](http://fourcc.org/) for the description and memory layout.*/ + yuy2 = 15, /**< The yuy2 color format. See [fourcc.org](http://fourcc.org/) for the description and memory layout.*/ + nv12 = 16 /**< The nv12 color format. See [fourcc.org](http://fourcc.org/) for the description and memory layout.*/ + }; + + /** + * @brief Additional pixel format that are not supported by ros, not included in the file + * sensor_msgs/image_encodings.h + */ + namespace additional_image_encodings + { + const std::string DISPARITY16 = "DISPARITY16"; + const std::string RAW10 = "RAW10"; + const std::string RAW16 = "RAW16"; + const std::string XYZ32F = "XYZ32F"; + const std::string YUYV = "YUYV"; + const std::string YUY2 = "YUY2"; + const std::string NV12 = "NV12"; + const std::string CUSTOM = "CUSTOM"; + } + + /** + * @brief Compression types + */ + enum compression_type + { + none = 0, + h264 = 1, + lzo = 2, + lz4 = 3, + jpeg = 4, + png = 5 + }; + + /** + * @brief Timestamp domain types + */ + enum timestamp_domain + { + camera = 0, /**< Frame timestamp was measured in relation to the camera clock */ + hardware_clock = 1, /**< Frame timestamp was measured in relation to the camera clock */ + microcontroller = 2, /**< Frame timestamp was measured in relation to the microcontroller clock */ + system_time = 3 /**< Frame timestamp was measured in relation to the OS system clock */ + }; + + /** + * @brief Metadata types + */ + enum metadata_type + { + actual_exposure = 0, + actual_fps = 1 + }; + + /** @brief Stream intrinsic parameters */ + struct intrinsics + { + float ppx; /**< Horizontal coordinate of the principal point of the image, as a pixel offset from the left edge */ + float ppy; /**< Vertical coordinate of the principal point of the image, as a pixel offset from the top edge */ + float fx; /**< Focal length of the image plane, as a multiple of pixel width */ + float fy; /**< Focal length of the image plane, as a multiple of pixel height */ + std::string model; /**< Distortion model of the image */ + float coeffs[5]; /**< Distortion coefficients */ + }; + + /** @brief Camera extrinsics parameters */ + struct extrinsics + { + float rotation[9]; /**< Column-major 3x3 rotation matrix */ + float translation[3]; /**< Three-element translation vector, in meters */ + }; + + + /** + * @brief Stream extrinsics + */ + struct stream_extrinsics + { + extrinsics extrinsics_data; /**< Represents the extrinsics data*/ + uint64_t reference_point_id; /**< Unique identifier of the extrinsics reference point, used as a key to which different extinsics are calculated*/ + }; + + /** + * @brief Represents the motion sensor scale, bias and variances. + */ + struct motion_intrinsics + { + /* Scale X cross axis cross axis Bias X */ + /* cross axis Scale Y cross axis Bias Y */ + /* cross axis cross axis Scale Z Bias Z */ + float data[3][4]; /**< Interpret data array values */ + float noise_variances[3]; /**< Variance of noise for X, Y, and Z axis */ + float bias_variances[3]; /**< Variance of bias for X, Y, and Z axis */ + }; + + /** + * @brief vector3 + */ + struct vector3 + { + float x, y, z; + }; + + /** + * @brief vector4 + */ + struct vector4 + { + float x, y, z, w; + }; + } + } +} diff --git a/realsense-file/include/rs/storage/realsense_file/ros_writer.h b/realsense-file/include/rs/storage/realsense_file/ros_writer.h new file mode 100644 index 0000000000..7b1e512437 --- /dev/null +++ b/realsense-file/include/rs/storage/realsense_file/ros_writer.h @@ -0,0 +1,26 @@ +// License: Apache 2.0. See LICENSE file in root directory. +// Copyright(c) 2017 Intel Corporation. All Rights Reserved. +#pragma once + +#ifdef _WIN32 +#ifdef realsense_file_EXPORTS +#define DLL_EXPORT __declspec(dllexport) +#else +#define DLL_EXPORT __declspec(dllimport) +#endif /* realsense_file_EXPORTS */ +#else /* defined (WIN32) */ +#define DLL_EXPORT +#endif + +namespace rs +{ + namespace file_format + { + class DLL_EXPORT ros_writer + { + public: + + virtual ~ros_writer() = default; + }; + } +} diff --git a/realsense-file/include/rs/storage/realsense_file/status.h b/realsense-file/include/rs/storage/realsense_file/status.h new file mode 100644 index 0000000000..3bfdf51b1a --- /dev/null +++ b/realsense-file/include/rs/storage/realsense_file/status.h @@ -0,0 +1,41 @@ +// License: Apache 2.0. See LICENSE file in root directory. +// Copyright(c) 2017 Intel Corporation. All Rights Reserved. + +/** +* \file status.h +* @brief Describes the return status codes used by SDK interfaces. +*/ + +#pragma once + +namespace rs +{ + namespace file_format + { + /** @brief + * Defines return codes that SDK interfaces + * use. Negative values indicate errors, a zero value indicates success, + * and positive values indicate warnings. + */ + enum status + { + /* success */ + status_no_error = 0, /**< Operation succeeded without any warning */ + + /* errors */ + status_feature_unsupported = -1, /**< Unsupported feature */ + status_param_unsupported = -2, /**< Unsupported parameter(s) */ + status_item_unavailable = -3, /**< Item not found/not available */ + status_key_already_exists = -4, /**< Key already exists in the data structure */ + status_invalid_argument = -5, /**< Argument passed to the method is invalid */ + status_allocation_failled = -6, /**< Failure in allocation */ + + status_file_write_failed = -401, /**< Failure in open file in WRITE mode */ + status_file_read_failed = -402, /**< Failure in open file in READ mode */ + status_file_close_failed = -403, /**< Failure in close a file handle */ + status_file_eof = -404, /**< EOF */ + + }; + } +} + diff --git a/realsense-file/include/rs/storage/realsense_file/stream_playback.h b/realsense-file/include/rs/storage/realsense_file/stream_playback.h new file mode 100644 index 0000000000..dc725afb22 --- /dev/null +++ b/realsense-file/include/rs/storage/realsense_file/stream_playback.h @@ -0,0 +1,107 @@ +// License: Apache 2.0. See LICENSE file in root directory. +// Copyright(c) 2017 Intel Corporation. All Rights Reserved. + +#pragma once +#include +#include "data_objects/stream_data.h" +#include "data_objects/vendor_data.h" +#include "data_objects/stream_data.h" +#include "rs/storage/realsense_file/file_types.h" + +#ifdef _WIN32 +#ifdef realsense_file_EXPORTS +#define DLL_EXPORT __declspec(dllexport) +#else +#define DLL_EXPORT __declspec(dllimport) +#endif /* realsense_file_EXPORTS */ +#else /* defined (_WIN32) */ +#define DLL_EXPORT +#endif + +namespace rs +{ + namespace file_format + { + + + /** + * @brief The stream_playback provides an interface for playing realsense format files + * + */ + class DLL_EXPORT stream_playback + { + public: + virtual ~stream_playback() = default; + /** + * @brief Returns a vector of vendor_data objects for the corresponding device + * + * @param[out] vendor_data Vector of the vendor information + * @param[in] device_id Device identifier + * @return status_no_error Successful execution + * @return status_item_unavailable No vendor info data of the requested device id is found in the file + * @return status_file_read_failed Failed to read from file + */ + virtual status read_vendor_data(std::vector>& vendor_data, + uint32_t device_id) const = 0; + + /** + * @brief Sets the player to play only the requested topics + * The player will continue playing from the time before the set_filter call. + * To get a stream_data topic, use the static function get_topic for each stream_data type. + * To play all the recorded items set the function with an empty vector. + * + * @param[in] topics List of the chosen topics + * @return status_no_error Successful execution + * @return status_item_unavailable At list one of the topics does not exist in the file + * @return status_file_eof The file reached the end + */ + virtual status set_filter(std::vector topics) = 0; + + /** + * @brief Set the player to play from the requested timestamp. + * The player will play only the chosen streams (if they were set with set_filter) + * If the begin time is out of range the status will be status_invalid_argument + * To seek to begin time call seek_to_time with begin = 0 + * + * @param[in] begin The requested timestamp + * @return status_no_error Successful execution + * @return status_invalid_argument The begin argument is out of range + */ + virtual status seek_to_time(file_types::nanoseconds begin) = 0; + + /** + * @brief Returns a vector of stream_info objects for the corresponding device and stream type + * + * @param[out] stream_infos Vector of the stream information + * @param[in] type Requested stream type + * @param[in] device_id Requested device identifier + * @return status_no_error Successful execution + * @return status_item_unavailable No stream info data of the requested device id and type is found in the file + * @return status_file_read_failed Failed to read from file + * @return status_param_unsupported The sample type is not supported by the file format + */ + virtual status read_stream_infos(std::vector>& stream_infos, + file_types::sample_type type, uint32_t device_id) const = 0; + + /** + * @brief Returns the next sample by arrival time + * + * @param[out] sample An object implements the sample interface + * @return status_no_error Successful execution + * @return status_file_read_failed Failed to read from file + * @return status_file_eof The file reached the end + */ + virtual status read_next_sample(std::shared_ptr& sample) = 0; + + /** + * @brief Returns the total duration of the file + * @param[out] duration On successful execution will hold the file duration (in nanoseconds) + * @return status_no_error on successful execution + */ + virtual status get_file_duration(file_types::nanoseconds& duration) const = 0; + + static bool create(const std::string& file_path, std::unique_ptr& player); + + }; + } +} diff --git a/realsense-file/include/rs/storage/realsense_file/stream_recorder.h b/realsense-file/include/rs/storage/realsense_file/stream_recorder.h new file mode 100644 index 0000000000..12c222fc6f --- /dev/null +++ b/realsense-file/include/rs/storage/realsense_file/stream_recorder.h @@ -0,0 +1,45 @@ +// License: Apache 2.0. See LICENSE file in root directory. +// Copyright(c) 2017 Intel Corporation. All Rights Reserved. + +#pragma once + +#include "data_objects/stream_data.h" + +#ifdef _WIN32 +#ifdef realsense_file_EXPORTS +#define DLL_EXPORT __declspec(dllexport) +#else +#define DLL_EXPORT __declspec(dllimport) +#endif /* realsense_file_EXPORTS */ +#else /* defined (_WIN32) */ +#define DLL_EXPORT +#endif + +namespace rs +{ + namespace file_format + { + /** + * @brief The stream_recorder provides an interface for recording realsense format files + * + */ + class DLL_EXPORT stream_recorder + { + public: + + virtual ~stream_recorder() = default; + + /** + * @brief Writes a stream_data object to the file + * + * @param[in] data an object implements the stream_data interface + * @return status_no_error Successful execution + * @return status_param_unsupported One of the stream data feilds is not supported + */ + virtual status record(std::shared_ptr data) = 0; + + static bool create(const std::string& file_path, std::unique_ptr& recorder); + }; + } +} + diff --git a/realsense-file/src/storage/realsense_file/CMakeLists.txt b/realsense-file/src/storage/realsense_file/CMakeLists.txt new file mode 100644 index 0000000000..2814b55861 --- /dev/null +++ b/realsense-file/src/storage/realsense_file/CMakeLists.txt @@ -0,0 +1,32 @@ +cmake_minimum_required(VERSION 2.8.9) +project(realsense_file) + +find_package(Boost COMPONENTS system REQUIRED) + +set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIC") + +include(rosbag/config.cmake) +include(file_stream/config.cmake) + +include_directories( + ${ROOT_DIR}/src/storage/realsense_file/include/msgs + ${ROSBAG_HEADER_DIRS} + ${ROOT_DIR}/src/storage/realsense_file +) + +add_library(${PROJECT_NAME} SHARED + ${HEADER_FILES_FILE_STREAM} + ${SOURCE_FILES_FILE_STREAM} + ${HEADER_FILES_ROSBAG} + ${SOURCE_FILES_ROSBAG} + ${SOURCE_FILES_COMPRESSION} +) + +set_target_properties(${PROJECT_NAME} PROPERTIES VERSION "${LIBVERSION}" SOVERSION "${LIBSOVERSION}") + +target_link_libraries(${PROJECT_NAME} + ${Boost_SYSTEM_LIBRARY} + ${LZ4} +) + +install(TARGETS ${PROJECT_NAME} DESTINATION lib) diff --git a/realsense-file/src/storage/realsense_file/file_stream/config.cmake b/realsense-file/src/storage/realsense_file/file_stream/config.cmake new file mode 100644 index 0000000000..c1a70b05f7 --- /dev/null +++ b/realsense-file/src/storage/realsense_file/file_stream/config.cmake @@ -0,0 +1,61 @@ +cmake_minimum_required(VERSION 2.8) +#------------------------------------------------------------------------------------ + +#------------------------------------------------------------------------------------ + +set(HEADER_FILES_FILE_STREAM + ${ROOT_DIR}/include/rs/storage/realsense_file/stream_recorder.h + ${ROOT_DIR}/include/rs/storage/realsense_file/status.h + ${ROOT_DIR}/include/rs/storage/realsense_file/stream_playback.h + ${ROOT_DIR}/include/rs/storage/realsense_file/file_types.h + ${ROOT_DIR}/include/rs/storage/realsense_file/ros_writer.h + ${ROOT_DIR}/include/rs/storage/realsense_file/data_objects/stream_data.h + ${ROOT_DIR}/include/rs/storage/realsense_file/data_objects/property.h + ${ROOT_DIR}/include/rs/storage/realsense_file/data_objects/vendor_data.h + ${ROOT_DIR}/include/rs/storage/realsense_file/data_objects/image_stream_info.h + ${ROOT_DIR}/include/rs/storage/realsense_file/data_objects/motion_stream_info.h + ${ROOT_DIR}/include/rs/storage/realsense_file/data_objects/image.h + ${ROOT_DIR}/include/rs/storage/realsense_file/data_objects/compressed_image.h + ${ROOT_DIR}/include/rs/storage/realsense_file/data_objects/motion_sample.h + ${ROOT_DIR}/include/rs/storage/realsense_file/data_objects/time_sample.h + ${ROOT_DIR}/include/rs/storage/realsense_file/data_objects/log.h + ${ROOT_DIR}/include/rs/storage/realsense_file/data_objects/pose.h + ${ROOT_DIR}/include/rs/storage/realsense_file/data_objects/occupancy_map.h +) +set(SOURCE_FILES_FILE_STREAM + file_stream/include/conversions.h + file_stream/include/topic.h + file_stream/include/ros_writer_impl.h + file_stream/include/stream_recorder_impl.h + file_stream/include/stream_playback_impl.h + file_stream/include/data_objects/vendor_data_impl.h + file_stream/include/data_objects/compressed_image_impl.h + file_stream/include/data_objects/image_impl.h + file_stream/include/data_objects/image_stream_info_impl.h + file_stream/include/data_objects/motion_sample_impl.h + file_stream/include/data_objects/motion_stream_info_impl.h + file_stream/include/data_objects/property_impl.h + file_stream/include/data_objects/time_sample_impl.h + file_stream/include/data_objects/log_impl.h + file_stream/include/data_objects/pose_impl.h + file_stream/include/data_objects/occupancy_map_impl.h + + file_stream/conversions.cpp + file_stream/ros_writer_impl.cpp + file_stream/stream_recorder_impl.cpp + file_stream/stream_playback_impl.cpp + file_stream/data_objects/vendor_data_impl.cpp + file_stream/data_objects/compressed_image_impl.cpp + file_stream/data_objects/image_impl.cpp + file_stream/data_objects/image_stream_info_impl.cpp + file_stream/data_objects/motion_sample_impl.cpp + file_stream/data_objects/motion_stream_info_impl.cpp + file_stream/data_objects/property_impl.cpp + file_stream/data_objects/time_sample_impl.cpp + file_stream/data_objects/log_impl.cpp + file_stream/data_objects/pose_impl.cpp + file_stream/data_objects/occupancy_map_impl.cpp +) + + + diff --git a/realsense-file/src/storage/realsense_file/file_stream/conversions.cpp b/realsense-file/src/storage/realsense_file/file_stream/conversions.cpp new file mode 100644 index 0000000000..cf1fb13ff7 --- /dev/null +++ b/realsense-file/src/storage/realsense_file/file_stream/conversions.cpp @@ -0,0 +1,161 @@ +// License: Apache 2.0. See LICENSE file in root directory. +// Copyright(c) 2017 Intel Corporation. All Rights Reserved. + +#include "file_stream/include/conversions.h" +#include "sensor_msgs/image_encodings.h" + +using namespace rs::file_format; + +bool conversions::convert(file_types::pixel_format source, std::string& target) +{ + switch(source) + { + case file_types::pixel_format::z16 : + target = sensor_msgs::image_encodings::MONO16; break; + case file_types::pixel_format::disparity16 : + target = file_types::additional_image_encodings::DISPARITY16; break; + case file_types::pixel_format::xyz32f : + target = file_types::additional_image_encodings::XYZ32F; break; + case file_types::pixel_format::yuyv : + target = file_types::additional_image_encodings::YUYV; break; + case file_types::pixel_format::rgb8 : + target = sensor_msgs::image_encodings::RGB8; break; + case file_types::pixel_format::bgr8 : + target = sensor_msgs::image_encodings::BGR8; break; + case file_types::pixel_format::rgba8 : + target = sensor_msgs::image_encodings::RGBA8; break; + case file_types::pixel_format::bgra8 : + target = sensor_msgs::image_encodings::BGRA8; break; + case file_types::pixel_format::y8 : + target = sensor_msgs::image_encodings::TYPE_8UC1; break; + case file_types::pixel_format::y16 : + target = sensor_msgs::image_encodings::TYPE_16UC1; break; + case file_types::pixel_format::raw8 : + target = sensor_msgs::image_encodings::MONO8; break; + case file_types::pixel_format::raw10 : + target = file_types::additional_image_encodings::RAW10; break; + case file_types::pixel_format::raw16 : + target = file_types::additional_image_encodings::RAW16; break; + case file_types::pixel_format::uyvy : + target = sensor_msgs::image_encodings::YUV422; break; + case file_types::pixel_format::yuy2 : + target = file_types::additional_image_encodings::YUY2; break; + case file_types::pixel_format::nv12 : + target = file_types::additional_image_encodings::NV12; break; + case file_types::pixel_format::custom : + target = file_types::additional_image_encodings::CUSTOM; break; + default: return false; + } + return true; +} + +bool conversions::convert(const std::string& source, file_types::pixel_format& target) +{ + if(source == sensor_msgs::image_encodings::MONO16) + target = file_types::pixel_format::z16; + else if(source == file_types::additional_image_encodings::DISPARITY16) + target = file_types::pixel_format::disparity16; + else if(source == file_types::additional_image_encodings::XYZ32F) + target = file_types::pixel_format::xyz32f; + else if(source == file_types::additional_image_encodings::YUYV) + target = file_types::pixel_format::yuyv; + else if(source == sensor_msgs::image_encodings::RGB8) + target = file_types::pixel_format::rgb8; + else if(source == sensor_msgs::image_encodings::BGR8) + target = file_types::pixel_format::bgr8; + else if(source == sensor_msgs::image_encodings::RGBA8) + target = file_types::pixel_format::rgba8; + else if(source == sensor_msgs::image_encodings::BGRA8) + target = file_types::pixel_format::bgra8; + else if(source == sensor_msgs::image_encodings::TYPE_8UC1) + target = file_types::pixel_format::y8; + else if(source == sensor_msgs::image_encodings::TYPE_16UC1) + target = file_types::pixel_format::y16; + else if(source == sensor_msgs::image_encodings::MONO8) + target = file_types::pixel_format::raw8; + else if(source == file_types::additional_image_encodings::RAW10) + target = file_types::pixel_format::raw10; + else if(source == file_types::additional_image_encodings::RAW16) + target = file_types::pixel_format::raw16; + else if(source == sensor_msgs::image_encodings::YUV422) + target = file_types::pixel_format::uyvy; + else if(source == file_types::additional_image_encodings::YUY2) + target = file_types::pixel_format::yuy2; + else if(source == file_types::additional_image_encodings::NV12) + target = file_types::pixel_format::nv12; + else if(source == file_types::additional_image_encodings::CUSTOM) + target = file_types::pixel_format::custom; + else return false; + + return true; +} + +bool conversions::convert(file_types::compression_type source, std::string& target) +{ + switch(source) + { + case file_types::h264 : + target = "h264"; break; + case file_types::lz4 : + target = "lz4"; break; + case file_types::jpeg : + target = "jpeg"; break; + case file_types::png : + target = "png"; break; + default: + return false; + } + return true; +} + +bool conversions::convert(file_types::motion_type source, std::string& target) +{ + switch(source) + { + case file_types::motion_type::accel: + target = rs::file_format::file_types::motion_stream_type::ACCL; break; + case file_types::motion_type::gyro: + target = rs::file_format::file_types::motion_stream_type::GYRO; break; + default: + return false; + } + return true; + +} + +bool conversions::convert(const std::string& source, file_types::motion_type& target) +{ + if(source == rs::file_format::file_types::motion_stream_type::ACCL) + target = file_types::motion_type::accel; + else if(source == rs::file_format::file_types::motion_stream_type::GYRO) + target = file_types::motion_type::gyro; + else return false; + return true; +} + +void conversions::convert(const realsense_msgs::motion_intrinsics& source, rs::file_format::file_types::motion_intrinsics& target) +{ + memcpy(target.bias_variances, &source.bias_variances[0], sizeof(target.bias_variances)); + memcpy(target.noise_variances, &source.noise_variances[0], sizeof(target.noise_variances)); + memcpy(target.data, &source.data[0], sizeof(target.data)); +} + +void conversions::convert(const rs::file_format::file_types::motion_intrinsics& source, realsense_msgs::motion_intrinsics& target) +{ + memcpy(&target.bias_variances[0], source.bias_variances, sizeof(source.bias_variances)); + memcpy(&target.noise_variances[0], source.noise_variances, sizeof(source.noise_variances)); + memcpy(&target.data[0], source.data, sizeof(source.data)); +} + +void conversions::convert(const realsense_msgs::extrinsics& source, rs::file_format::file_types::extrinsics& target) +{ + memcpy(target.rotation, &source.rotation[0], sizeof(target.rotation)); + memcpy(target.translation, &source.translation[0], sizeof(target.translation)); +} + +void conversions::convert(const rs::file_format::file_types::extrinsics& source, realsense_msgs::extrinsics& target) +{ + memcpy(&target.rotation[0], source.rotation, sizeof(source.rotation)); + memcpy(&target.translation[0], source.translation, sizeof(source.translation)); +} + diff --git a/realsense-file/src/storage/realsense_file/file_stream/data_objects/compressed_image_impl.cpp b/realsense-file/src/storage/realsense_file/file_stream/data_objects/compressed_image_impl.cpp new file mode 100644 index 0000000000..b793242621 --- /dev/null +++ b/realsense-file/src/storage/realsense_file/file_stream/data_objects/compressed_image_impl.cpp @@ -0,0 +1,95 @@ +// License: Apache 2.0. See LICENSE file in root directory. +// Copyright(c) 2017 Intel Corporation. All Rights Reserved. + +#include "realsense_msgs/compressed_frame_info.h" +#include "sensor_msgs/CompressedImage.h" +#include "rosbag/view.h" +#include "file_stream/include/conversions.h" +#include "file_stream/include/topic.h" +#include "file_stream/include/data_objects/compressed_image_impl.h" +#include "file_stream/include/ros_writer_impl.h" + +using namespace rs::file_format; +using namespace rs::file_format::ros_data_objects; + +std::string compressed_image::get_topic(std::string stream, uint32_t device_id) +{ + return "/camera/" + stream + "/compressed_image/" + std::to_string(device_id); +} + +std::string compressed_image::get_info_topic(std::string stream, uint32_t device_id) +{ + return "/camera/" + stream + "/rs_compressed_frame_info_ext/" + std::to_string(device_id); +} + +std::shared_ptr compressed_image::create(const compressed_image_info& info) +{ + return std::make_shared(info); +} + +compressed_image_impl::compressed_image_impl(const compressed_image_info &info) : m_info(info){} + +compressed_image_impl::~compressed_image_impl() +{ +} + +file_types::sample_type compressed_image_impl::get_type() const { return file_types::st_compressed_image; } + +status compressed_image_impl::write_data(std::shared_ptr file) +{ + + sensor_msgs::CompressedImage image; + + if(conversions::convert(m_info.compression_type, image.format) == false) + { + return status_param_unsupported; + } + image.data.assign(m_info.data.get(), m_info.data.get() + (m_info.compression_size)); + image.header.seq = m_info.frame_number; + image.header.stamp = ros::Time(m_info.timestamp.count()); + + auto image_topic = get_topic(m_info.stream, m_info.device_id); + auto file_instance = std::static_pointer_cast(file); + auto retval = file_instance->write(image_topic, m_info.capture_time, image); + if(retval != status_no_error) + { + return retval; + } + realsense_msgs::compressed_frame_info msg; + msg.system_time = m_info.system_time.count(); + msg.time_stamp_domain = m_info.timestamp_domain; + msg.height = m_info.height; + msg.width = m_info.width; + msg.step = m_info.step; + + for(auto data : m_info.metadata) + { + realsense_msgs::metadata metadata; + metadata.type = data.first; + const uint8_t* raw_metadata = data.second.data(); + metadata.data.assign(raw_metadata, raw_metadata + data.second.size()); + msg.frame_metadata.push_back(metadata); + } + + if(conversions::convert(m_info.format, msg.encoding) == false) + { + return status_item_unavailable; + } + auto info_topic = get_info_topic(topic(image_topic).at(2), std::stoi(topic(image_topic).at(4))); + retval = file_instance->write(info_topic, m_info.capture_time, msg); + if(retval != status_no_error) + { + return retval; + } + return status_no_error; +} + +compressed_image_info compressed_image_impl::get_info() const +{ + return m_info; +} + +void compressed_image_impl::set_info(const compressed_image_info &info) +{ + m_info = info; +} diff --git a/realsense-file/src/storage/realsense_file/file_stream/data_objects/image_impl.cpp b/realsense-file/src/storage/realsense_file/file_stream/data_objects/image_impl.cpp new file mode 100644 index 0000000000..9e07169452 --- /dev/null +++ b/realsense-file/src/storage/realsense_file/file_stream/data_objects/image_impl.cpp @@ -0,0 +1,102 @@ +// License: Apache 2.0. See LICENSE file in root directory. +// Copyright(c) 2017 Intel Corporation. All Rights Reserved. + +#include "sensor_msgs/Image.h" +#include "realsense_msgs/frame_info.h" +#include "realsense_msgs/compressed_frame_info.h" +#include "rosbag/view.h" +#include "file_stream/include/conversions.h" +#include "file_stream/include/data_objects/image_impl.h" +#include "file_stream/include/stream_recorder_impl.h" +#include "file_stream/include/topic.h" +#include "file_stream/include/ros_writer_impl.h" + +using namespace rs::file_format; +using namespace rs::file_format::ros_data_objects; +using namespace rs::file_format::file_types; + +std::string image::get_topic(std::string stream, uint32_t device_id) +{ + return "/camera/" + stream + "/image_raw/" + std::to_string(device_id); +} + +std::string image::get_info_topic(std::string stream, uint32_t device_id) +{ + return "/camera/" + stream + "/rs_frame_info_ext/" + std::to_string(device_id); +} + +std::shared_ptr image::create(const image_info& info) +{ + return std::make_shared(info); +} + +image_impl::image_impl(const image_info &info) : + m_info(info) {} + + +image_impl::~image_impl() +{ +} + + +file_types::sample_type image_impl::get_type() const { return file_types::st_image; } + +status image_impl::write_data(std::shared_ptr file) +{ + sensor_msgs::Image image; + image.height = m_info.height; + image.width = m_info.width; + image.step = m_info.step; + + if(conversions::convert(m_info.format, image.encoding) == false) + { + return status_param_unsupported; + } + + image.is_bigendian = 0; + + image.data.assign(m_info.data.get(), m_info.data.get() + (m_info.step * m_info.height)); + image.header.seq = m_info.frame_number; + image.header.stamp = ros::Time(m_info.timestamp.count()); + + auto image_topic = get_topic(m_info.stream, m_info.device_id); + auto file_instance = std::static_pointer_cast(file); + auto retval = file_instance->write(image_topic, m_info.capture_time, image); + if(retval != status_no_error) + { + return retval; + } + + realsense_msgs::frame_info msg; + msg.system_time = m_info.system_time.count(); + msg.time_stamp_domain = m_info.timestamp_domain; + + for(auto data : m_info.metadata) + { + realsense_msgs::metadata metadata; + metadata.type = data.first; + const uint8_t* raw_metadata = data.second.data(); + metadata.data.assign(raw_metadata, raw_metadata + data.second.size()); + msg.frame_metadata.push_back(metadata); + } + + auto info_topic = get_info_topic(topic(image_topic).at(2), std::stoi(topic(image_topic).at(4))); + retval = file_instance->write(info_topic, m_info.capture_time, msg); + if(retval != status_no_error) + { + return retval; + } + return status_no_error; +} + +const image_info &image_impl::get_info() const +{ + return m_info; +} + + +void image_impl::set_info(const image_info &info) +{ + m_info = info; +} + diff --git a/realsense-file/src/storage/realsense_file/file_stream/data_objects/image_stream_info_impl.cpp b/realsense-file/src/storage/realsense_file/file_stream/data_objects/image_stream_info_impl.cpp new file mode 100644 index 0000000000..96cbb556dc --- /dev/null +++ b/realsense-file/src/storage/realsense_file/file_stream/data_objects/image_stream_info_impl.cpp @@ -0,0 +1,86 @@ +// License: Apache 2.0. See LICENSE file in root directory. +// Copyright(c) 2017 Intel Corporation. All Rights Reserved. + +#include "realsense_msgs/stream_info.h" +#include "file_stream/include/conversions.h" +#include "file_stream/include/topic.h" +#include "file_stream/include/ros_writer_impl.h" +#include "file_stream/include/data_objects/image_stream_info_impl.h" + +using namespace rs::file_format; +using namespace rs::file_format::ros_data_objects; +using namespace rs::file_format::file_types; + +std::string image_stream_info::get_topic(const uint32_t& device_id) +{ + return "/camera/rs_stream_info/" + std::to_string(device_id); +} + +std::shared_ptr image_stream_info::create(const image_stream_data& info) +{ + return std::make_shared(info); +} + +void image_stream_info_impl::assign(const image_stream_data& in_info, image_stream_data& out_info) +{ + out_info = in_info; + out_info.intrinsics.fx = in_info.intrinsics.fx; + out_info.intrinsics.ppx = in_info.intrinsics.ppx; + out_info.intrinsics.fy = in_info.intrinsics.fy; + out_info.intrinsics.ppy = in_info.intrinsics.ppy; + std::memcpy(out_info.intrinsics.coeffs, + in_info.intrinsics.coeffs, + sizeof(out_info.intrinsics.coeffs)); + + std::memcpy(out_info.stream_extrinsics.extrinsics_data.rotation, + in_info.stream_extrinsics.extrinsics_data.rotation, + sizeof(out_info.stream_extrinsics.extrinsics_data.rotation)); + std::memcpy(out_info.stream_extrinsics.extrinsics_data.translation, + in_info.stream_extrinsics.extrinsics_data.translation, + sizeof(out_info.stream_extrinsics.extrinsics_data.translation)); + out_info.stream_extrinsics.reference_point_id = in_info.stream_extrinsics.reference_point_id; +} + + +image_stream_info_impl::image_stream_info_impl(const image_stream_data& info) : m_info(info) +{ + assign(info, m_info); +} + +status image_stream_info_impl::write_data(std::shared_ptr file) +{ + realsense_msgs::stream_info msg; + msg.stream_type = m_info.type; + msg.fps = m_info.fps; + msg.width = m_info.width; + msg.height = m_info.height; + if(conversions::convert(m_info.format, msg.encoding) == false) + { + return status_param_unsupported; + } + msg.camera_info.height = m_info.height; + msg.camera_info.width = m_info.width; + msg.camera_info.K[0] = m_info.intrinsics.fx; + msg.camera_info.K[2] = m_info.intrinsics.ppx; + + msg.camera_info.K[4] = m_info.intrinsics.fy; + msg.camera_info.K[5] = m_info.intrinsics.ppy; + msg.camera_info.K[8] = 1; + msg.camera_info.D.assign(m_info.intrinsics.coeffs, m_info.intrinsics.coeffs + 5); + msg.camera_info.distortion_model = m_info.intrinsics.model; + + conversions::convert(m_info.stream_extrinsics.extrinsics_data, msg.stream_extrinsics.extrinsics); + msg.stream_extrinsics.reference_point_id = m_info.stream_extrinsics.reference_point_id; + auto file_instance = std::static_pointer_cast(file); + return file_instance->write(get_topic(m_info.device_id), file_types::nanoseconds::min(), msg); +} + +const image_stream_data &image_stream_info_impl::get_info() const +{ + return m_info; +} + +void image_stream_info_impl::set_info(const image_stream_data &info) +{ + assign(info, m_info); +} diff --git a/realsense-file/src/storage/realsense_file/file_stream/data_objects/log_impl.cpp b/realsense-file/src/storage/realsense_file/file_stream/data_objects/log_impl.cpp new file mode 100644 index 0000000000..467cc7ce6a --- /dev/null +++ b/realsense-file/src/storage/realsense_file/file_stream/data_objects/log_impl.cpp @@ -0,0 +1,51 @@ +// License: Apache 2.0. See LICENSE file in root directory. +// Copyright(c) 2017 Intel Corporation. All Rights Reserved. + +#include "rosgraph_msgs/Log.h" +#include "file_stream/include/topic.h" +#include "file_stream/include/data_objects/log_impl.h" +#include "file_stream/include/conversions.h" +#include "file_stream/include/ros_writer_impl.h" + +using namespace rs::file_format; +using namespace rs::file_format::ros_data_objects; +using namespace rs::file_format::file_types; + +std::string log::get_topic() +{ + return "/log"; +} + +std::shared_ptr rs::file_format::ros_data_objects::log::create(const log_info& info) +{ + return std::make_shared(info); +} + +log_impl::log_impl(const log_info &info) : m_info(info) {} + +file_types::sample_type log_impl::get_type() const { return file_types::st_log; } + +status log_impl::write_data(std::shared_ptr file) +{ + rosgraph_msgs::Log msg; + msg.level = m_info.level; + msg.msg = m_info.message; + msg.file = m_info.file; + msg.function = m_info.function; + msg.line = m_info.line; + + auto file_instance = std::static_pointer_cast(file); + return file_instance->write(get_topic(), m_info.capture_time, msg); +} + +log_info log_impl::get_info() const +{ + return m_info; +} + +void log_impl::set_info(const log_info &info) +{ + m_info = info; +} + + diff --git a/realsense-file/src/storage/realsense_file/file_stream/data_objects/motion_sample_impl.cpp b/realsense-file/src/storage/realsense_file/file_stream/data_objects/motion_sample_impl.cpp new file mode 100644 index 0000000000..d316f0bace --- /dev/null +++ b/realsense-file/src/storage/realsense_file/file_stream/data_objects/motion_sample_impl.cpp @@ -0,0 +1,112 @@ +// License: Apache 2.0. See LICENSE file in root directory. +// Copyright(c) 2017 Intel Corporation. All Rights Reserved. + +#include "sensor_msgs/Imu.h" +#include "rosbag/view.h" +#include "file_stream/include/conversions.h" +#include "file_stream/include/topic.h" +#include "file_stream/include/ros_writer_impl.h" +#include "file_stream/include/data_objects/motion_sample_impl.h" + +using namespace rs::file_format; +using namespace rs::file_format::ros_data_objects; +using namespace rs::file_format::file_types; + +inline sensor_msgs::ImuPtr create_imu_message(const std::string& frame_id, const uint64_t seq_id) +{ + sensor_msgs::ImuPtr imuMessage(new sensor_msgs::Imu()); + imuMessage->header.frame_id = frame_id; + imuMessage->header.seq = static_cast(seq_id); + return imuMessage; +} + +inline sensor_msgs::ImuPtr create_accelerometer_message(const std::string& frame_id, const uint64_t seq_id) +{ + sensor_msgs::ImuPtr accelerometerMessagePtr = create_imu_message(frame_id, seq_id); + accelerometerMessagePtr->orientation_covariance[0] = -1; + accelerometerMessagePtr->angular_velocity_covariance[0] = -1; + + return accelerometerMessagePtr; +} + +inline sensor_msgs::ImuPtr create_gyrometer_message(const std::string& frame_id, const uint64_t seq_id) +{ + sensor_msgs::ImuPtr gyrometerMessagePtr = create_imu_message(frame_id, seq_id); + gyrometerMessagePtr->orientation_covariance[0] = -1; + gyrometerMessagePtr->linear_acceleration_covariance[0] = -1; + + return gyrometerMessagePtr; +} + +std::string motion_sample::get_topic(file_types::motion_type type, uint32_t device_id = 0) +{ + std::string type_str; + conversions::convert(type, type_str); + return "/imu/" + type_str + "/imu_raw/" + std::to_string(device_id); +} + +std::shared_ptr motion_sample::create(const motion_info& info) +{ + return std::make_shared(info); +} + +motion_sample_impl::motion_sample_impl(const motion_info &info): m_info(info) +{ + std::memcpy(m_info.data, info.data, sizeof(m_info.data)); +} + +file_types::sample_type motion_sample_impl::get_type() const { return file_types::st_motion; } + +status motion_sample_impl::write_data(std::shared_ptr file) +{ + std::string topic = get_topic(m_info.type, m_info.device_id); + std::string type_str; + if(conversions::convert(m_info.type, type_str) == false) + { + return status_param_unsupported; + } + auto file_instance = std::static_pointer_cast(file); + if(type_str == file_types::motion_stream_type::ACCL) + { + sensor_msgs::ImuPtr accelerometer = create_accelerometer_message(topic, m_info.frame_number); + accelerometer->linear_acceleration.x = m_info.data[0]; + accelerometer->linear_acceleration.y = m_info.data[1]; + accelerometer->linear_acceleration.z = m_info.data[2]; + + accelerometer->header.stamp = ros::Time(m_info.timestamp.count()); + if(file_instance->write(topic, m_info.capture_time, accelerometer) != status_no_error) + { + return status_file_write_failed; + } + } + else if(type_str == file_types::motion_stream_type::GYRO) + { + sensor_msgs::ImuPtr gyrometer = create_gyrometer_message(topic, m_info.frame_number); + gyrometer->angular_velocity.x = m_info.data[0]; + gyrometer->angular_velocity.y = m_info.data[1]; + gyrometer->angular_velocity.z = m_info.data[2]; + + gyrometer->header.stamp = ros::Time(m_info.timestamp.count()); + gyrometer->header.seq = m_info.frame_number; + if(file_instance->write(topic, m_info.capture_time, gyrometer) != status_no_error) + { + return status_file_write_failed; + } + }else + { + return status_feature_unsupported; + } + return status_no_error; +} + +motion_info motion_sample_impl::get_info() const +{ + return m_info; +} + +void motion_sample_impl::set_info(const motion_info &info) +{ + m_info = info; + std::memcpy(m_info.data, info.data, sizeof(m_info.data)); +} + diff --git a/realsense-file/src/storage/realsense_file/file_stream/data_objects/motion_stream_info_impl.cpp b/realsense-file/src/storage/realsense_file/file_stream/data_objects/motion_stream_info_impl.cpp new file mode 100644 index 0000000000..d7b6125abf --- /dev/null +++ b/realsense-file/src/storage/realsense_file/file_stream/data_objects/motion_stream_info_impl.cpp @@ -0,0 +1,83 @@ +// License: Apache 2.0. See LICENSE file in root directory. +// Copyright(c) 2017 Intel Corporation. All Rights Reserved. + +#include "file_stream/include/data_objects/motion_stream_info_impl.h" +#include "realsense_msgs/motion_stream_info.h" +#include "file_stream/include/conversions.h" +#include "file_stream/include/topic.h" +#include "file_stream/include/ros_writer_impl.h" + +using namespace rs::file_format; +using namespace rs::file_format::ros_data_objects; +using namespace rs::file_format::file_types; + +std::string motion_stream_info::get_topic(uint32_t device_id) +{ + return "/camera/rs_motion_stream_info/" + std::to_string(device_id); +} + +std::shared_ptr motion_stream_info::create(const motion_stream_data& info) +{ + return std::make_shared(info); +} + +void motion_stream_info_impl::assign(const motion_stream_data& in_info, motion_stream_data& out_info) +{ + out_info = in_info; + std::memcpy(out_info.intrinsics.bias_variances, + in_info.intrinsics.bias_variances, + sizeof(out_info.intrinsics.bias_variances)); + std::memcpy(out_info.intrinsics.noise_variances, + in_info.intrinsics.noise_variances, + sizeof(out_info.intrinsics.noise_variances)); + std::memcpy(out_info.intrinsics.data, + in_info.intrinsics.data, + sizeof(out_info.intrinsics.data)); + + std::memcpy(out_info.stream_extrinsics.extrinsics_data.rotation, + in_info.stream_extrinsics.extrinsics_data.rotation, + sizeof(out_info.stream_extrinsics.extrinsics_data.rotation)); + std::memcpy(out_info.stream_extrinsics.extrinsics_data.translation, + in_info.stream_extrinsics.extrinsics_data.translation, + sizeof(out_info.stream_extrinsics.extrinsics_data.translation)); + out_info.stream_extrinsics.reference_point_id = in_info.stream_extrinsics.reference_point_id; + +} + +motion_stream_info_impl::~motion_stream_info_impl() +{ +} + +motion_stream_info_impl::motion_stream_info_impl(const motion_stream_data &info) : m_info(info) +{ + assign(info, m_info); +} + +status motion_stream_info_impl::write_data(std::shared_ptr file) +{ + realsense_msgs::motion_stream_info msg; + msg.fps = m_info.fps; + + if(conversions::convert(m_info.type, msg.motion_type) == false) + { + return status_param_unsupported; + } + + conversions::convert(m_info.intrinsics, msg.stream_intrinsics); + conversions::convert(m_info.stream_extrinsics.extrinsics_data, msg.stream_extrinsics.extrinsics); + msg.stream_extrinsics.reference_point_id = m_info.stream_extrinsics.reference_point_id; + + auto file_instance = std::static_pointer_cast(file); + return file_instance->write(get_topic(m_info.device_id), file_types::nanoseconds::min(), msg); +} + +motion_stream_data motion_stream_info_impl::get_info() const +{ + return m_info; +} + +void motion_stream_info_impl::set_info(const motion_stream_data &info) +{ + assign(info, m_info); +} + diff --git a/realsense-file/src/storage/realsense_file/file_stream/data_objects/occupancy_map_impl.cpp b/realsense-file/src/storage/realsense_file/file_stream/data_objects/occupancy_map_impl.cpp new file mode 100644 index 0000000000..ac6f8e1d08 --- /dev/null +++ b/realsense-file/src/storage/realsense_file/file_stream/data_objects/occupancy_map_impl.cpp @@ -0,0 +1,48 @@ +// License: Apache 2.0. See LICENSE file in root directory. +// Copyright(c) 2017 Intel Corporation. All Rights Reserved. + +#include "realsense_msgs/occupancy_map.h" +#include "file_stream/include/topic.h" +#include "file_stream/include/data_objects/occupancy_map_impl.h" +#include "file_stream/include/conversions.h" +#include "file_stream/include/ros_writer_impl.h" + +using namespace rs::file_format; +using namespace rs::file_format::ros_data_objects; +using namespace rs::file_format::file_types; + +std::string occupancy_map::get_topic(uint32_t device_id) +{ + return "/camera/rs_occupancy_map/" + std::to_string(device_id); +} + +std::shared_ptr occupancy_map::create(const occupancy_map_info& info) +{ + return std::make_shared(info); +} + +occupancy_map_impl::occupancy_map_impl(const occupancy_map_info &info) : m_info(info) {} + +file_types::sample_type occupancy_map_impl::get_type() const { return file_types::st_occupancy_map; } + +status occupancy_map_impl::write_data(std::shared_ptr file) +{ + realsense_msgs::occupancy_map msg; + msg.accuracy = m_info.accuracy; + msg.reserved = m_info.reserved; + msg.tile_count = m_info.tile_count; + msg.tiles.assign(m_info.tiles.get(), m_info.tiles.get() + (m_info.tile_count * 3)); + + auto file_instance = std::static_pointer_cast(file); + return file_instance->write(get_topic(m_info.device_id), m_info.capture_time, msg); +} + +occupancy_map_info occupancy_map_impl::get_info() const +{ + return m_info; +} + +void occupancy_map_impl::set_info(const occupancy_map_info &info) +{ + m_info = info; +} diff --git a/realsense-file/src/storage/realsense_file/file_stream/data_objects/pose_impl.cpp b/realsense-file/src/storage/realsense_file/file_stream/data_objects/pose_impl.cpp new file mode 100644 index 0000000000..cd3b253983 --- /dev/null +++ b/realsense-file/src/storage/realsense_file/file_stream/data_objects/pose_impl.cpp @@ -0,0 +1,75 @@ +// License: Apache 2.0. See LICENSE file in root directory. +// Copyright(c) 2017 Intel Corporation. All Rights Reserved. + +#include "realsense_msgs/pose.h" +#include "file_stream/include/topic.h" +#include "file_stream/include/data_objects/pose_impl.h" +#include "file_stream/include/conversions.h" +#include "file_stream/include/ros_writer_impl.h" + +using namespace rs::file_format; +using namespace rs::file_format::ros_data_objects; +using namespace rs::file_format::file_types; + +std::string pose::get_topic(uint32_t device_id) +{ + return "/camera/rs_6DoF/" + std::to_string(device_id); +} + +std::shared_ptr pose::create(const pose_info& info) +{ + return std::make_shared(info); +} + +pose_impl::pose_impl(const pose_info &info) : m_info(info) +{ +} + +file_types::sample_type pose_impl::get_type() const { return file_types::st_pose; } + +status pose_impl::write_data(std::shared_ptr file) +{ + realsense_msgs::pose msg; + + msg.translation.x = m_info.translation.x; + msg.translation.y = m_info.translation.y; + msg.translation.z = m_info.translation.z; + + msg.rotation.x = m_info.rotation.x; + msg.rotation.y = m_info.rotation.y; + msg.rotation.z = m_info.rotation.z; + msg.rotation.w = m_info.rotation.w; + + msg.velocity.x = m_info.velocity.x; + msg.velocity.y = m_info.velocity.y; + msg.velocity.z = m_info.velocity.z; + + msg.angular_velocity.x = m_info.angular_velocity.x; + msg.angular_velocity.y = m_info.angular_velocity.y; + msg.angular_velocity.z = m_info.angular_velocity.z; + + msg.acceleration.x = m_info.acceleration.x; + msg.acceleration.y = m_info.acceleration.y; + msg.acceleration.z = m_info.acceleration.z; + + msg.angular_acceleration.x = m_info.angular_acceleration.x; + msg.angular_acceleration.y = m_info.angular_acceleration.y; + msg.angular_acceleration.z = m_info.angular_acceleration.z; + + msg.timestamp = m_info.timestamp.count(); + msg.system_timestamp = m_info.system_timestamp.count(); + + auto file_instance = std::static_pointer_cast(file); + return file_instance->write(get_topic(m_info.device_id), m_info.capture_time, msg); + +} + +pose_info pose_impl::get_info() const +{ + return m_info; +} + +void pose_impl::set_info(const pose_info &info) +{ + m_info = info; +} diff --git a/realsense-file/src/storage/realsense_file/file_stream/data_objects/property_impl.cpp b/realsense-file/src/storage/realsense_file/file_stream/data_objects/property_impl.cpp new file mode 100644 index 0000000000..4c5c7bf9c9 --- /dev/null +++ b/realsense-file/src/storage/realsense_file/file_stream/data_objects/property_impl.cpp @@ -0,0 +1,45 @@ +// License: Apache 2.0. See LICENSE file in root directory. +// Copyright(c) 2017 Intel Corporation. All Rights Reserved. + +#include "file_stream/include/data_objects/property_impl.h" +#include "file_stream/include/conversions.h" +#include "file_stream/include/topic.h" +#include "file_stream/include/ros_writer_impl.h" +#include "std_msgs/Float64.h" + +using namespace rs::file_format; +using namespace rs::file_format::ros_data_objects; +using namespace rs::file_format::file_types; + +std::string property::get_topic(const std::string& key, uint32_t device_id) +{ + return "/camera/property/" + key + "/" + std::to_string(device_id); +} + +std::shared_ptr property::create(const property_info& info) +{ + return std::make_shared(info); +} + +property_impl::property_impl(const property_info &info) : m_info(info) {} + +file_types::sample_type property_impl::get_type() const { return file_types::st_property; } + +status property_impl::write_data(std::shared_ptr file) +{ + std_msgs::Float64 msg; + msg.data = m_info.value; + auto file_instance = std::static_pointer_cast(file); + return file_instance->write(get_topic(m_info.key, m_info.device_id), m_info.capture_time, msg); +} + +property_info property_impl::get_info() const +{ + return m_info; +} + +void property_impl::set_info(const property_info &info) +{ + m_info = info; +} + diff --git a/realsense-file/src/storage/realsense_file/file_stream/data_objects/time_sample_impl.cpp b/realsense-file/src/storage/realsense_file/file_stream/data_objects/time_sample_impl.cpp new file mode 100644 index 0000000000..626be90e34 --- /dev/null +++ b/realsense-file/src/storage/realsense_file/file_stream/data_objects/time_sample_impl.cpp @@ -0,0 +1,51 @@ +// License: Apache 2.0. See LICENSE file in root directory. +// Copyright(c) 2017 Intel Corporation. All Rights Reserved. + +#include "sensor_msgs/TimeReference.h" +#include "rosbag/view.h" +#include "file_stream/include/topic.h" +#include "file_stream/include/data_objects/time_sample_impl.h" +#include "file_stream/include//conversions.h" +#include "file_stream/include/ros_writer_impl.h" + +using namespace rs::file_format; +using namespace rs::file_format::ros_data_objects; +using namespace rs::file_format::file_types; + +std::string time_sample::get_topic(uint32_t device_id) +{ + return "/time/" + std::to_string(device_id); +} + +std::shared_ptr time_sample::create(const time_sample_info& info) +{ + return std::make_shared(info); +} + +time_sample_impl::time_sample_impl(const time_sample_info &info): m_info(info) {} + +file_types::sample_type time_sample_impl::get_type() const { return file_types::st_time; } + +status time_sample_impl::write_data(std::shared_ptr file) +{ + std::string topic = "/time/" + std::to_string(m_info.device_id); + sensor_msgs::TimeReference msg; + msg.header.seq = m_info.frame_number; + msg.header.stamp = ros::Time(m_info.timestamp.count()); + msg.time_ref = ros::Time(m_info.timestamp.count()); + msg.source = m_info.source; + + auto file_instance = std::static_pointer_cast(file); + return file_instance->write(topic, m_info.capture_time, msg); +} + +time_sample_info time_sample_impl::get_info() const +{ + return m_info; +} + +void time_sample_impl::set_info(const time_sample_info &info) +{ + m_info = info; +} + diff --git a/realsense-file/src/storage/realsense_file/file_stream/data_objects/vendor_data_impl.cpp b/realsense-file/src/storage/realsense_file/file_stream/data_objects/vendor_data_impl.cpp new file mode 100644 index 0000000000..816640388f --- /dev/null +++ b/realsense-file/src/storage/realsense_file/file_stream/data_objects/vendor_data_impl.cpp @@ -0,0 +1,46 @@ +// License: Apache 2.0. See LICENSE file in root directory. +// Copyright(c) 2017 Intel Corporation. All Rights Reserved. + +#include "realsense_msgs/vendor_data.h" +#include "rosbag/view.h" +#include "file_stream/include/topic.h" +#include "file_stream/include/ros_writer_impl.h" +#include "file_stream/include/data_objects/vendor_data_impl.h" + +using namespace rs::file_format; +using namespace rs::file_format::ros_data_objects; +using namespace rs::file_format::file_types; + +std::string vendor_data::get_topic(const uint32_t& device_id) +{ + return "/info/" + std::to_string(device_id); +} + +std::shared_ptr vendor_data::create(const vendor_info& info) +{ + return std::make_shared(info); +} + +vendor_data_impl::vendor_data_impl(const vendor_info &info): m_info(info){} + +vendor_data_impl::~vendor_data_impl(){} + +status vendor_data_impl::write_data(std::shared_ptr file) +{ + realsense_msgs::vendor_data msg; + msg.value = m_info.value; + msg.name = m_info.name; + auto file_instance = std::static_pointer_cast(file); + return file_instance->write(get_topic(m_info.device_id), file_types::nanoseconds::min(), msg); +} + +vendor_info vendor_data_impl::get_info() const +{ + return m_info; +} + +void vendor_data_impl::set_info(const vendor_info &info) +{ + m_info = info; +} + diff --git a/realsense-file/src/storage/realsense_file/file_stream/include/conversions.h b/realsense-file/src/storage/realsense_file/file_stream/include/conversions.h new file mode 100644 index 0000000000..2a1f16722b --- /dev/null +++ b/realsense-file/src/storage/realsense_file/file_stream/include/conversions.h @@ -0,0 +1,37 @@ +// License: Apache 2.0. See LICENSE file in root directory. +// Copyright(c) 2017 Intel Corporation. All Rights Reserved. + +#pragma once +#include "rs/storage/realsense_file/file_types.h" +#include "std_msgs/Float32.h" +#include "std_msgs/String.h" +#include "realsense_msgs/motion_intrinsics.h" +#include "realsense_msgs/extrinsics.h" +#include "rosbag/bag.h" + +namespace rs +{ + namespace file_format + { + namespace conversions + { + bool convert(file_types::pixel_format source, std::string& target); + + bool convert(const std::string& source, file_types::pixel_format& target); + + bool convert(file_types::compression_type source, std::string& target); + + bool convert(file_types::motion_type source, std::string& target); + + bool convert(const std::string& source, file_types::motion_type& target); + + void convert(const realsense_msgs::motion_intrinsics& source, rs::file_format::file_types::motion_intrinsics& target); + + void convert(const rs::file_format::file_types::motion_intrinsics& source, realsense_msgs::motion_intrinsics& target); + + void convert(const realsense_msgs::extrinsics& source, rs::file_format::file_types::extrinsics& target); + + void convert(const rs::file_format::file_types::extrinsics& source, realsense_msgs::extrinsics& target); + } + } +} diff --git a/realsense-file/src/storage/realsense_file/file_stream/include/data_objects/compressed_image_impl.h b/realsense-file/src/storage/realsense_file/file_stream/include/data_objects/compressed_image_impl.h new file mode 100644 index 0000000000..f396a16b0a --- /dev/null +++ b/realsense-file/src/storage/realsense_file/file_stream/include/data_objects/compressed_image_impl.h @@ -0,0 +1,33 @@ +// License: Apache 2.0. See LICENSE file in root directory. +// Copyright(c) 2017 Intel Corporation. All Rights Reserved. +#pragma once + +#include "rs/storage/realsense_file/data_objects/compressed_image.h" + +namespace rs +{ + namespace file_format + { + namespace ros_data_objects + { + + class compressed_image_impl : public compressed_image + { + private: + compressed_image_info m_info; + + public: + compressed_image_impl(const compressed_image_info& info); + + virtual ~compressed_image_impl(); + virtual file_types::sample_type get_type() const override; + + virtual status write_data(std::shared_ptr file) override; + + virtual compressed_image_info get_info() const override; + + virtual void set_info(const compressed_image_info& info) override; + }; + } + } +} diff --git a/realsense-file/src/storage/realsense_file/file_stream/include/data_objects/image_impl.h b/realsense-file/src/storage/realsense_file/file_stream/include/data_objects/image_impl.h new file mode 100644 index 0000000000..31c74a72c0 --- /dev/null +++ b/realsense-file/src/storage/realsense_file/file_stream/include/data_objects/image_impl.h @@ -0,0 +1,33 @@ +// License: Apache 2.0. See LICENSE file in root directory. +// Copyright(c) 2017 Intel Corporation. All Rights Reserved. +#pragma once +#include "rs/storage/realsense_file/data_objects/image.h" + +namespace rs +{ + namespace file_format + { + namespace ros_data_objects + { + class image_impl : public image + { + private: + image_info m_info; + + public: + + image_impl(const image_info& info); + + virtual ~image_impl(); + + virtual file_types::sample_type get_type() const override; + + virtual status write_data(std::shared_ptr file) override; + + virtual const image_info& get_info() const override; + + virtual void set_info(const image_info& info) override; + }; + } + } +} diff --git a/realsense-file/src/storage/realsense_file/file_stream/include/data_objects/image_stream_info_impl.h b/realsense-file/src/storage/realsense_file/file_stream/include/data_objects/image_stream_info_impl.h new file mode 100644 index 0000000000..7870cedee2 --- /dev/null +++ b/realsense-file/src/storage/realsense_file/file_stream/include/data_objects/image_stream_info_impl.h @@ -0,0 +1,32 @@ +// License: Apache 2.0. See LICENSE file in root directory. +// Copyright(c) 2017 Intel Corporation. All Rights Reserved. +#pragma once + +#include "rs/storage/realsense_file/data_objects/image_stream_info.h" + +namespace rs +{ + namespace file_format + { + namespace ros_data_objects + { + class image_stream_info_impl : public image_stream_info + { + private: + image_stream_data m_info; + void assign(const image_stream_data& in_info, image_stream_data& out_info); + + public: + image_stream_info_impl(const image_stream_data& info); + + virtual ~image_stream_info_impl() = default; + + virtual status write_data(std::shared_ptr file) override; + + virtual const image_stream_data& get_info() const override; + + virtual void set_info(const image_stream_data& info) override; + }; + } + } +} diff --git a/realsense-file/src/storage/realsense_file/file_stream/include/data_objects/log_impl.h b/realsense-file/src/storage/realsense_file/file_stream/include/data_objects/log_impl.h new file mode 100644 index 0000000000..67e80dac75 --- /dev/null +++ b/realsense-file/src/storage/realsense_file/file_stream/include/data_objects/log_impl.h @@ -0,0 +1,36 @@ +// License: Apache 2.0. See LICENSE file in root directory. +// Copyright(c) 2017 Intel Corporation. All Rights Reserved. + +#pragma once + +#include "rs/storage/realsense_file/data_objects/log.h" + +namespace rs +{ + namespace file_format + { + namespace ros_data_objects + { + class log_impl : public log + { + private: + log_info m_info; + public: + log_impl(const log_info& info); + + virtual ~log_impl() = default; + + virtual file_types::sample_type get_type() const override; + + virtual status write_data(std::shared_ptr file) override; + + virtual log_info get_info() const override; + + virtual void set_info(const log_info& info) override; + + }; + } + } +} + + diff --git a/realsense-file/src/storage/realsense_file/file_stream/include/data_objects/motion_sample_impl.h b/realsense-file/src/storage/realsense_file/file_stream/include/data_objects/motion_sample_impl.h new file mode 100644 index 0000000000..ddf78fd269 --- /dev/null +++ b/realsense-file/src/storage/realsense_file/file_stream/include/data_objects/motion_sample_impl.h @@ -0,0 +1,36 @@ +// License: Apache 2.0. See LICENSE file in root directory. +// Copyright(c) 2017 Intel Corporation. All Rights Reserved. + +#pragma once + +#include "rs/storage/realsense_file/data_objects/motion_sample.h" + +namespace rs +{ + namespace file_format + { + namespace ros_data_objects + { + class motion_sample_impl : public motion_sample + { + private: + motion_info m_info; + public: + motion_sample_impl(const motion_info& info); + + virtual ~motion_sample_impl() = default; + + virtual file_types::sample_type get_type() const override; + + virtual status write_data(std::shared_ptr file) override; + + virtual motion_info get_info() const override; + + virtual void set_info(const motion_info& info) override; + + }; + } + } +} + + diff --git a/realsense-file/src/storage/realsense_file/file_stream/include/data_objects/motion_stream_info_impl.h b/realsense-file/src/storage/realsense_file/file_stream/include/data_objects/motion_stream_info_impl.h new file mode 100644 index 0000000000..a637fb7e62 --- /dev/null +++ b/realsense-file/src/storage/realsense_file/file_stream/include/data_objects/motion_stream_info_impl.h @@ -0,0 +1,35 @@ +// License: Apache 2.0. See LICENSE file in root directory. +// Copyright(c) 2017 Intel Corporation. All Rights Reserved. + +#pragma once + +#include "rs/storage/realsense_file/data_objects/motion_stream_info.h" + +namespace rs +{ + namespace file_format + { + namespace ros_data_objects + { + class motion_stream_info_impl : public motion_stream_info + { + private: + motion_stream_data m_info; + + void assign(const motion_stream_data& in_info, motion_stream_data& out_info); + + public: + motion_stream_info_impl(const motion_stream_data& info); + + virtual ~motion_stream_info_impl(); + + virtual status write_data(std::shared_ptr file) override; + + virtual motion_stream_data get_info() const override; + + virtual void set_info(const motion_stream_data& info) override; + + }; + } + } +} diff --git a/realsense-file/src/storage/realsense_file/file_stream/include/data_objects/occupancy_map_impl.h b/realsense-file/src/storage/realsense_file/file_stream/include/data_objects/occupancy_map_impl.h new file mode 100644 index 0000000000..9c74096b99 --- /dev/null +++ b/realsense-file/src/storage/realsense_file/file_stream/include/data_objects/occupancy_map_impl.h @@ -0,0 +1,36 @@ +// License: Apache 2.0. See LICENSE file in root directory. +// Copyright(c) 2017 Intel Corporation. All Rights Reserved. + +#pragma once + +#include "rs/storage/realsense_file/data_objects/occupancy_map.h" + +namespace rs +{ + namespace file_format + { + namespace ros_data_objects + { + class occupancy_map_impl : public occupancy_map + { + private: + occupancy_map_info m_info; + public: + occupancy_map_impl(const occupancy_map_info& info); + + virtual ~occupancy_map_impl() = default; + + virtual file_types::sample_type get_type() const override; + + virtual status write_data(std::shared_ptr file) override; + + virtual occupancy_map_info get_info() const override; + + virtual void set_info(const occupancy_map_info& info) override; + + }; + } + } +} + + diff --git a/realsense-file/src/storage/realsense_file/file_stream/include/data_objects/pose_impl.h b/realsense-file/src/storage/realsense_file/file_stream/include/data_objects/pose_impl.h new file mode 100644 index 0000000000..632e7ab812 --- /dev/null +++ b/realsense-file/src/storage/realsense_file/file_stream/include/data_objects/pose_impl.h @@ -0,0 +1,36 @@ +// License: Apache 2.0. See LICENSE file in root directory. +// Copyright(c) 2017 Intel Corporation. All Rights Reserved. + +#pragma once + +#include "rs/storage/realsense_file/data_objects/pose.h" + +namespace rs +{ + namespace file_format + { + namespace ros_data_objects + { + class pose_impl : public pose + { + private: + pose_info m_info; + public: + pose_impl(const pose_info& info); + + virtual ~pose_impl() = default; + + virtual file_types::sample_type get_type() const override; + + virtual status write_data(std::shared_ptr file) override; + + virtual pose_info get_info() const override; + + virtual void set_info(const pose_info& info) override; + + }; + } + } +} + + diff --git a/realsense-file/src/storage/realsense_file/file_stream/include/data_objects/property_impl.h b/realsense-file/src/storage/realsense_file/file_stream/include/data_objects/property_impl.h new file mode 100644 index 0000000000..4d98c64d92 --- /dev/null +++ b/realsense-file/src/storage/realsense_file/file_stream/include/data_objects/property_impl.h @@ -0,0 +1,35 @@ +// License: Apache 2.0. See LICENSE file in root directory. +// Copyright(c) 2017 Intel Corporation. All Rights Reserved. + +#pragma once + +#include "rs/storage/realsense_file/data_objects/property.h" + +namespace rs +{ + namespace file_format + { + namespace ros_data_objects + { + class property_impl : public property + { + private: + property_info m_info; + public: + property_impl(const property_info& info); + + virtual ~property_impl() = default; + + virtual file_types::sample_type get_type() const override; + + virtual status write_data(std::shared_ptr file) override; + + virtual property_info get_info() const override; + + virtual void set_info(const property_info& info) override; + }; + } + } +} + + diff --git a/realsense-file/src/storage/realsense_file/file_stream/include/data_objects/time_sample_impl.h b/realsense-file/src/storage/realsense_file/file_stream/include/data_objects/time_sample_impl.h new file mode 100644 index 0000000000..98020c9302 --- /dev/null +++ b/realsense-file/src/storage/realsense_file/file_stream/include/data_objects/time_sample_impl.h @@ -0,0 +1,34 @@ +// License: Apache 2.0. See LICENSE file in root directory. +// Copyright(c) 2017 Intel Corporation. All Rights Reserved. +#pragma once + +#include "rs/storage/realsense_file/data_objects/time_sample.h" + +namespace rs +{ + namespace file_format + { + namespace ros_data_objects + { + + class time_sample_impl : public time_sample + { + private: + time_sample_info m_info; + public: + time_sample_impl(const time_sample_info& info); + + virtual file_types::sample_type get_type() const override; + + virtual status write_data(std::shared_ptr file) override; + + virtual time_sample_info get_info() const override; + + virtual void set_info(const time_sample_info& info) override; + }; + } + } +} + + + diff --git a/realsense-file/src/storage/realsense_file/file_stream/include/data_objects/vendor_data_impl.h b/realsense-file/src/storage/realsense_file/file_stream/include/data_objects/vendor_data_impl.h new file mode 100644 index 0000000000..cf44ea51cf --- /dev/null +++ b/realsense-file/src/storage/realsense_file/file_stream/include/data_objects/vendor_data_impl.h @@ -0,0 +1,32 @@ +// License: Apache 2.0. See LICENSE file in root directory. +// Copyright(c) 2017 Intel Corporation. All Rights Reserved. +#pragma once +#include "rs/storage/realsense_file/data_objects/vendor_data.h" + +namespace rs +{ + namespace file_format + { + namespace ros_data_objects + { + class vendor_data_impl : public vendor_data + { + private: + vendor_info m_info; + public: + + vendor_data_impl(const vendor_info& info); + + virtual ~vendor_data_impl(); + + virtual status write_data(std::shared_ptr file) override; + + virtual vendor_info get_info() const override; + + virtual void set_info(const vendor_info& info) override; + }; + } + } +} + + diff --git a/realsense-file/src/storage/realsense_file/file_stream/include/file_format_version.h b/realsense-file/src/storage/realsense_file/file_stream/include/file_format_version.h new file mode 100644 index 0000000000..7a96c133be --- /dev/null +++ b/realsense-file/src/storage/realsense_file/file_stream/include/file_format_version.h @@ -0,0 +1,18 @@ +// License: Apache 2.0. See LICENSE file in root directory. +// Copyright(c) 2017 Intel Corporation. All Rights Reserved. + +namespace rs +{ + namespace file_format + { + static const std::string get_file_version_topic() + { + return "/FILE_VERSION"; + } + + static constexpr uint32_t get_file_version() + { + return 1; + } + } +} diff --git a/realsense-file/src/storage/realsense_file/file_stream/include/ros_writer_impl.h b/realsense-file/src/storage/realsense_file/file_stream/include/ros_writer_impl.h new file mode 100644 index 0000000000..dc97f83638 --- /dev/null +++ b/realsense-file/src/storage/realsense_file/file_stream/include/ros_writer_impl.h @@ -0,0 +1,57 @@ +// License: Apache 2.0. See LICENSE file in root directory. +// Copyright(c) 2017 Intel Corporation. All Rights Reserved. + +#pragma once +#include +#include "rs/storage/realsense_file/ros_writer.h" +#include "rs/storage/realsense_file/status.h" +#include "rs/storage/realsense_file/file_types.h" +#include "rosbag/bag.h" + +namespace rs +{ + namespace file_format + { + class ros_writer_impl : public ros_writer + { + public: + virtual ~ros_writer_impl() + { + m_file->close(); + } + + ros_writer_impl(std::string file_path); + + template + status write(std::string const& topic, file_types::nanoseconds const& time, T const& msg); + + private: + std::shared_ptr m_file; + }; + + template + status ros_writer_impl::write(std::string const& topic, file_types::nanoseconds const& time, T const& msg) + { + try + { + if (time == file_types::nanoseconds::min()) + { + m_file->write(topic, ros::TIME_MIN, msg); + } + else + { + std::chrono::duration sec = std::chrono::duration_cast>(time); + file_types::nanoseconds range = time - std::chrono::duration_cast(sec); + ros::Time capture_time = ros::Time(sec.count(), + std::chrono::duration_cast>(range).count()); + m_file->write(topic, capture_time, msg); + } + } + catch (rosbag::BagIOException&) + { + return status_file_write_failed; + } + return status_no_error; + } + } +} diff --git a/realsense-file/src/storage/realsense_file/file_stream/include/stream_playback_impl.h b/realsense-file/src/storage/realsense_file/file_stream/include/stream_playback_impl.h new file mode 100644 index 0000000000..e204ec0faf --- /dev/null +++ b/realsense-file/src/storage/realsense_file/file_stream/include/stream_playback_impl.h @@ -0,0 +1,69 @@ +// License: Apache 2.0. See LICENSE file in root directory. +// Copyright(c) 2017 Intel Corporation. All Rights Reserved. +#pragma once +#include + +#include "rs/storage/realsense_file/stream_playback.h" +#include "rs/storage/realsense_file/data_objects/compressed_image.h" +#include "rs/storage/realsense_file/data_objects/image.h" +#include "rs/storage/realsense_file/data_objects/image_stream_info.h" +#include "rs/storage/realsense_file/data_objects/motion_stream_info.h" +#include "rs/storage/realsense_file/data_objects/motion_sample.h" +#include "rs/storage/realsense_file/data_objects/time_sample.h" +#include "rs/storage/realsense_file/data_objects/property.h" +#include "rs/storage/realsense_file/data_objects/pose.h" +#include "rs/storage/realsense_file/data_objects/occupancy_map.h" +#include "rs/storage/realsense_file/data_objects/log.h" +#include "rosbag/view.h" + +namespace rs +{ + namespace file_format + { + class stream_playback_impl : public stream_playback + { + public: + + stream_playback_impl(const std::string& file_path); + + virtual ~stream_playback_impl(); + + virtual status set_filter(std::vector topics) override; + + virtual status seek_to_time(file_types::nanoseconds seek_time) override; + + virtual status read_vendor_data(std::vector>& vendor_data, + uint32_t device_id) const override; + virtual status read_stream_infos(std::vector>& stream_infos, + file_types::sample_type type, uint32_t device_id) const override; + + virtual status read_next_sample(std::shared_ptr& sample) override; + virtual status get_file_duration(file_types::nanoseconds& duration) const override; + + private: + std::shared_ptr create_compressed_image(const rosbag::MessageInstance &image_data) const; + std::shared_ptr create_image(const rosbag::MessageInstance &image_data) const; + std::shared_ptr create_image_stream_info(const rosbag::MessageInstance &info_msg) const; + std::shared_ptr create_log(const rosbag::MessageInstance &message) const; + std::shared_ptr create_motion_sample(const rosbag::MessageInstance &message) const; + std::shared_ptr create_motion_info(const rosbag::MessageInstance &message) const; + std::shared_ptr create_occupancy_map(const rosbag::MessageInstance &message) const; + std::shared_ptr create_property(const rosbag::MessageInstance &message) const; + std::shared_ptr create_six_dof(const rosbag::MessageInstance &message) const; + std::shared_ptr create_time_sample(const rosbag::MessageInstance &message) const; + std::shared_ptr create_vendor_data(const rosbag::MessageInstance &message) const; + bool get_file_version_from_file(uint32_t& version); + status seek_to_time(file_types::nanoseconds seek_time, std::unique_ptr& samples_view) const; + + rosbag::Bag m_file; + std::unique_ptr m_samples_view; + rosbag::View::iterator m_samples_itrator; + mutable std::mutex m_mutex; + std::vector m_topics; + + + }; + } +} + + diff --git a/realsense-file/src/storage/realsense_file/file_stream/include/stream_recorder_impl.h b/realsense-file/src/storage/realsense_file/file_stream/include/stream_recorder_impl.h new file mode 100644 index 0000000000..072e189b24 --- /dev/null +++ b/realsense-file/src/storage/realsense_file/file_stream/include/stream_recorder_impl.h @@ -0,0 +1,28 @@ +// License: Apache 2.0. See LICENSE file in root directory. +// Copyright(c) 2017 Intel Corporation. All Rights Reserved. +#pragma once + +#include "rs/storage/realsense_file/stream_recorder.h" +#include "rs/storage/realsense_file/ros_writer.h" +#include +#include + +namespace rs +{ + namespace file_format + { + class stream_recorder_impl : public stream_recorder + { + public: + stream_recorder_impl(const std::string& file_path); + + virtual ~stream_recorder_impl(); + + virtual status record(std::shared_ptr data); + + private: + bool write_file_version(); + std::shared_ptr m_file; + }; + } +} diff --git a/realsense-file/src/storage/realsense_file/file_stream/include/topic.h b/realsense-file/src/storage/realsense_file/file_stream/include/topic.h new file mode 100644 index 0000000000..79bb3d88c3 --- /dev/null +++ b/realsense-file/src/storage/realsense_file/file_stream/include/topic.h @@ -0,0 +1,41 @@ +// License: Apache 2.0. See LICENSE file in root directory. +// Copyright(c) 2017 Intel Corporation. All Rights Reserved. + +#pragma once +#include +#include + +namespace rs +{ + namespace file_format + { + class topic + { + private: + std::string m_value; + const std::string elements_separator = "/"; + + public: + topic(const std::string& value) : m_value(value) {} + std::string to_string() const { return m_value; } + std::string at(uint32_t index) const + { + size_t current_pos = 0; + std::string token; + std::string value_copy = m_value; + uint32_t elements_iterator = 0; + while ((current_pos = value_copy.find(elements_separator)) != std::string::npos) { + token = value_copy.substr(0, current_pos); + if(elements_iterator == index) return token; + value_copy.erase(0, current_pos + elements_separator.length()); + ++elements_iterator; + } + + if( elements_iterator == index) + return value_copy; + + return std::string(); + } + }; + } +} diff --git a/realsense-file/src/storage/realsense_file/file_stream/ros_writer_impl.cpp b/realsense-file/src/storage/realsense_file/file_stream/ros_writer_impl.cpp new file mode 100644 index 0000000000..a22f2e30c5 --- /dev/null +++ b/realsense-file/src/storage/realsense_file/file_stream/ros_writer_impl.cpp @@ -0,0 +1,22 @@ +// License: Apache 2.0. See LICENSE file in root directory. +// Copyright(c) 2017 Intel Corporation. All Rights Reserved. + +#include +#include +#include "file_stream/include/ros_writer_impl.h" +//#include "rs_sdk_version.h" +using namespace rs::file_format; + +ros_writer_impl::ros_writer_impl(std::string file_path) +{ + try + { + m_file = std::make_shared(); + m_file->open(file_path, rosbag::BagMode::Write); + m_file->setCompression(rosbag::CompressionType::LZ4); + } catch(rosbag::BagIOException&) + { + throw std::runtime_error("failed to open file"); + } +} + diff --git a/realsense-file/src/storage/realsense_file/file_stream/stream_playback_impl.cpp b/realsense-file/src/storage/realsense_file/file_stream/stream_playback_impl.cpp new file mode 100644 index 0000000000..3ffa3e8ffd --- /dev/null +++ b/realsense-file/src/storage/realsense_file/file_stream/stream_playback_impl.cpp @@ -0,0 +1,634 @@ +// License: Apache 2.0. See LICENSE file in root directory. +// Copyright(c) 2017 Intel Corporation. All Rights Reserved. + +#include + +#include "file_stream/include/stream_playback_impl.h" +#include "rs/storage/realsense_file/data_objects/vendor_data.h" +#include "rosbag/view.h" +#include "rs/storage/realsense_file/file_types.h" +#include "realsense_msgs/compressed_frame_info.h" +#include "realsense_msgs/frame_info.h" +#include "realsense_msgs/stream_info.h" +#include "realsense_msgs/motion_stream_info.h" +#include "realsense_msgs/vendor_data.h" +#include "realsense_msgs/pose.h" +#include "realsense_msgs/occupancy_map.h" + +#include "rosgraph_msgs/Log.h" +#include "sensor_msgs/Imu.h" +#include "sensor_msgs/Image.h" +#include "sensor_msgs/CompressedImage.h" +#include "sensor_msgs/TimeReference.h" + +#include "std_msgs/Float64.h" +#include "file_stream/include/conversions.h" +#include "file_stream/include/topic.h" + +#include "std_msgs/UInt32.h" +#include "file_stream/include/file_format_version.h" + +using namespace rs::file_format; +using namespace rs::file_format::file_types; + + +inline std::vector get_topics(std::unique_ptr& view) +{ + std::vector topics; + for(const rosbag::ConnectionInfo* connection : view->getConnections()) + { + topics.emplace_back(connection->topic); + } + return topics; +} + +bool stream_playback::create(const std::string& file_path, std::unique_ptr& player) +{ + try + { + player = std::unique_ptr(new stream_playback_impl(file_path)); + } + catch (std::exception&) + { + return false; + } + return true; +} + +bool stream_playback_impl::get_file_version_from_file(uint32_t& version) +{ + rosbag::View view(m_file, rosbag::TopicQuery(get_file_version_topic())); + if (view.size() == 0) + { + return false; + } + + auto item = *view.begin(); + std_msgs::UInt32Ptr msg = item.instantiate(); + if (msg == nullptr) + { + return false; + } + version = msg->data; + + return true; +} + +stream_playback_impl::stream_playback_impl(const std::string &file_path) +{ + if (file_path.empty()) + { + throw std::invalid_argument("file_path"); + } + + m_file.open(file_path, rosbag::BagMode::Read); + + uint32_t version = 0; + if(get_file_version_from_file(version) == false) + { + throw std::runtime_error("failed to read file version"); + } + + if(version != get_file_version()) + { + throw std::runtime_error("unsupported file version"); + } + + m_samples_view = std::unique_ptr(new rosbag::View(m_file)); + m_samples_itrator = m_samples_view->begin(); + m_topics = get_topics(m_samples_view); +} + +stream_playback_impl::~stream_playback_impl() +{ +} + +status stream_playback_impl::set_filter(std::vector topics) +{ + std::unique_lock locker(m_mutex); + if(m_samples_itrator == m_samples_view->end()) + { + return status::status_file_eof; + } + rosbag::MessageInstance sample_msg = *m_samples_itrator; + auto curr_time = sample_msg.getTime(); + + m_samples_view = std::unique_ptr(new rosbag::View()); + + if(topics.empty() == false) + { + auto view = std::unique_ptr(new rosbag::View(m_file)); + std::vector topics_in_file = get_topics(view); + for(auto element : topics) + { + if(std::find(topics_in_file.begin(), topics_in_file.end(), element) == topics_in_file.end()) + { + return status::status_item_unavailable; + } + m_samples_view->addQuery(m_file, rosbag::TopicQuery(element), curr_time); + + } + m_topics = topics; + } + else + { + //the default state of view is to get all topics + m_samples_view = std::unique_ptr(new rosbag::View(m_file, curr_time)); + m_topics = get_topics(m_samples_view); + } + m_samples_itrator = m_samples_view->begin(); + return status_no_error; +} +status stream_playback_impl::seek_to_time(file_types::nanoseconds seek_time, std::unique_ptr& samples_view) const +{ + ros::Time to_time = ros::TIME_MIN; + if(seek_time.count() != 0) + { + std::chrono::duration sec = std::chrono::duration_cast>(seek_time); + file_types::nanoseconds range = seek_time - std::chrono::duration_cast(sec); + to_time = ros::Time(sec.count(), std::chrono::duration_cast>(range).count()); + } + + if(m_topics.empty() == true) + { + samples_view = std::unique_ptr(new rosbag::View(m_file)); + } + else + { + samples_view = std::unique_ptr(new rosbag::View()); + for(auto topic : m_topics) + { + samples_view->addQuery(m_file, rosbag::TopicQuery(topic), to_time); + } + } + if(samples_view->begin() == samples_view->end()) + { + return status_invalid_argument; + } + + return status_no_error; + +} +status stream_playback_impl::seek_to_time(file_types::nanoseconds seek_time) +{ + std::unique_lock locker(m_mutex); + std::unique_ptr samples_view; + status sts = seek_to_time(seek_time, samples_view); + if(sts != status_no_error) + { + return sts; + } + m_samples_view = std::move(samples_view); + m_samples_itrator = m_samples_view->begin(); + return status_no_error; +} + +status stream_playback_impl::read_vendor_data(std::vector>& vendor_data, + uint32_t device_id) const +{ + auto vendor_data_topic = ros_data_objects::vendor_data::get_topic(device_id); + rosbag::View view(m_file, rosbag::TopicQuery(vendor_data_topic)); + if (view.size() == 0) + { + return status_item_unavailable; + } + for (auto message_instance : view) + { + auto vendor_item = create_vendor_data(message_instance); + if(vendor_item == nullptr) + { + return status_file_read_failed; + } + vendor_data.push_back(vendor_item); + } + return status_no_error; +} + +status stream_playback_impl::read_stream_infos(std::vector>& stream_infos, + file_types::sample_type type, uint32_t device_id) const +{ + switch(type) + { + case file_types::st_image : + case file_types::st_compressed_image : + { + auto topic = ros_data_objects::image_stream_info::get_topic(device_id); + rosbag::View view(m_file, rosbag::TopicQuery(topic)); + if (view.size() == 0) + { + return status_item_unavailable; + } + for (auto message_instance : view) + { + auto info = create_image_stream_info(message_instance); + if(info == nullptr) + { + return status_file_read_failed; + } + stream_infos.push_back(info); + } + break; + } + case file_types::st_motion : + { + auto topic = ros_data_objects::motion_stream_info::get_topic(device_id); + rosbag::View view(m_file, rosbag::TopicQuery(topic)); + if (view.size() == 0) + { + return status_item_unavailable; + } + for (auto message_instance : view) + { + auto info = create_motion_info(message_instance); + if(info == nullptr) + { + return status_file_read_failed; + } + stream_infos.push_back(info); + } + break; + } + default : return status_param_unsupported; + } + return status_no_error; +} + +status stream_playback_impl::read_next_sample(std::shared_ptr& sample) +{ + std::unique_lock locker(m_mutex); + for( ; m_samples_itrator != m_samples_view->end(); ++m_samples_itrator) + { + rosbag::MessageInstance sample_msg = *m_samples_itrator; + if(sample_msg.isType()) + { + sample = create_image(sample_msg); + } + else if(sample_msg.isType()) + { + sample = create_compressed_image(sample_msg); + } + else if(sample_msg.isType()) + { + sample = create_time_sample(sample_msg); + } + else if(sample_msg.isType()) + { + sample = create_motion_sample(sample_msg); + } + else if(sample_msg.getTopic().find("/camera/property/") != std::string::npos) + { + sample = create_property(sample_msg); + } + else if(sample_msg.isType()) + { + sample = create_six_dof(sample_msg); + } + else if(sample_msg.isType()) + { + sample = create_occupancy_map(sample_msg); + } + else if(sample_msg.isType()) + { + sample = create_log(sample_msg); + } + else + { + continue; + } + ++m_samples_itrator; + if(sample == nullptr) + { + return status_file_read_failed; + } + return status_no_error; + } + + return status_file_eof; +} + +std::shared_ptr stream_playback_impl::create_compressed_image(const rosbag::MessageInstance &image_data) const +{ + sensor_msgs::CompressedImagePtr msg = image_data.instantiate(); + if (msg == nullptr) + { + return nullptr; + } + ros_data_objects::compressed_image_info info = {}; + topic image_topic(image_data.getTopic()); + auto device_str = topic(image_data.getTopic()).at(4); + info.device_id = static_cast(std::stoll(device_str)); + info.timestamp = seconds(msg->header.stamp.toSec()); + info.stream = topic(image_data.getTopic()).at(2); + + info.frame_number = msg->header.seq; + info.capture_time = nanoseconds(image_data.getTime().toNSec()); + + info.data = std::shared_ptr(new uint8_t[msg->data.size()], + [](uint8_t* ptr){delete[] ptr;}); + + memcpy(info.data.get(), &msg->data[0], msg->data.size()); + + info.compression_size = static_cast(msg->data.size()); + + auto info_topic = ros_data_objects::compressed_image::get_info_topic(image_topic.at(1), std::stoi(image_topic.at(3))); + rosbag::View view_info(m_file, rosbag::TopicQuery(info_topic), image_data.getTime()); + if (view_info.begin() == view_info.end()) + { + return nullptr; + } + rosbag::MessageInstance frame_info = *view_info.begin(); + + realsense_msgs::compressed_frame_infoPtr info_msg = + frame_info.instantiate(); + if (msg == nullptr) + { + return nullptr; + } + info.system_time = nanoseconds(info_msg->system_time); + info.timestamp_domain = static_cast(info_msg->time_stamp_domain); + info.height = info_msg->height; + info.width = info_msg->width; + info.step = info_msg->step; + for(auto metadata : info_msg->frame_metadata) + { + info.metadata[static_cast(metadata.type)] = metadata.data; + } + auto sts = conversions::convert(info_msg->encoding, info.format); + if(sts != status_no_error) + { + return nullptr; + } + + return ros_data_objects::compressed_image::create(info); +} + +std::shared_ptr stream_playback_impl::create_image(const rosbag::MessageInstance &image_data) const +{ + sensor_msgs::ImagePtr msg = image_data.instantiate(); + if (msg == nullptr) + { + return nullptr; + } + ros_data_objects::image_info info = {}; + topic image_topic(image_data.getTopic()); + auto device_str = topic(image_data.getTopic()).at(4); + info.device_id = static_cast(std::stoll(device_str)); + info.timestamp = seconds(msg->header.stamp.toSec()); + info.stream = topic(image_data.getTopic()).at(2); + + info.frame_number = msg->header.seq; + if(conversions::convert(msg->encoding, info.format) == false) + { + return nullptr; + } + info.width = msg->width; + info.height = msg->height; + info.step = msg->step; + + info.capture_time = nanoseconds(image_data.getTime().toNSec()); + + info.data = std::shared_ptr(new uint8_t[info.step * info.height], + [](uint8_t* ptr){delete[] ptr;}); + memcpy(info.data.get(), &msg->data[0], msg->data.size()); + auto info_topic = ros_data_objects::image::get_info_topic(image_topic.at(2), std::stoi(image_topic.at(4))); + rosbag::View view_info(m_file, rosbag::TopicQuery(info_topic), image_data.getTime()); + if (view_info.begin() == view_info.end()) + { + return nullptr; + } + realsense_msgs::frame_infoPtr info_msg = (*view_info.begin()).instantiate(); + if (info_msg == nullptr) + { + return nullptr; + } + info.system_time = nanoseconds(info_msg->system_time); + info.timestamp_domain = static_cast(info_msg->time_stamp_domain); + for(auto metadata : info_msg->frame_metadata) + { + info.metadata[static_cast(metadata.type)] = metadata.data; + } + return ros_data_objects::image::create(info); +} + +std::shared_ptr stream_playback_impl::create_image_stream_info(const rosbag::MessageInstance &info_msg) const +{ + realsense_msgs::stream_infoPtr msg = info_msg.instantiate(); + if (msg == nullptr) + { + return nullptr; + } + ros_data_objects::image_stream_data info = {}; + auto device_str = topic(info_msg.getTopic()).at(3); + info.device_id = static_cast(std::stoll(device_str)); + info.type = msg->stream_type; + info.fps = msg->fps; + info.width = msg->width; + info.height = msg->height; + if(conversions::convert(msg->encoding, info.format) == false) + { + return nullptr; + } + info.intrinsics.fx = static_cast(msg->camera_info.K[0]); + info.intrinsics.ppx = static_cast(msg->camera_info.K[2]); + info.intrinsics.fy = static_cast(msg->camera_info.K[4]); + info.intrinsics.ppy = static_cast(msg->camera_info.K[5]); + info.intrinsics.model = msg->camera_info.distortion_model; + + for(uint32_t i = 0; i < msg->camera_info.D.size(); ++i ) + { + info.intrinsics.coeffs[i] = static_cast((&msg->camera_info.D[0])[i]); + } + conversions::convert(msg->stream_extrinsics.extrinsics, info.stream_extrinsics.extrinsics_data); + info.stream_extrinsics.reference_point_id = msg->stream_extrinsics.reference_point_id; + + return ros_data_objects::image_stream_info::create(info); +} + +std::shared_ptr stream_playback_impl::create_log(const rosbag::MessageInstance &message) const +{ + rosgraph_msgs::LogPtr msg = message.instantiate(); + ros_data_objects::log_info info = {}; + info.level = msg->level; + info.message = msg->msg; + info.file = msg->file; + info.function = msg->function; + info.line = msg->line; + return ros_data_objects::log::create(info); +} + +std::shared_ptr stream_playback_impl::create_motion_sample(const rosbag::MessageInstance &message) const +{ + sensor_msgs::ImuPtr msg = message.instantiate(); + if (msg == nullptr) + { + return nullptr; + } + ros_data_objects::motion_info info = {}; + auto device_str = topic(message.getTopic()).at(4); + info.device_id = static_cast(std::stoll(device_str)); + info.frame_number = msg->header.seq; + info.timestamp = seconds(msg->header.stamp.toSec()); + + if(message.getTopic() == ros_data_objects::motion_sample::get_topic(file_types::motion_type::accel, info.device_id)) + { + info.type = file_types::motion_type::accel; + info.data[0] = static_cast(msg->linear_acceleration.x); + info.data[1] = static_cast(msg->linear_acceleration.y); + info.data[2] = static_cast(msg->linear_acceleration.z); + }else if(message.getTopic() == ros_data_objects::motion_sample::get_topic(file_types::motion_type::gyro, info.device_id)) + { + info.type = file_types::motion_type::gyro; + info.data[0] = static_cast(msg->angular_velocity.x); + info.data[1] = static_cast(msg->angular_velocity.y); + info.data[2] = static_cast(msg->angular_velocity.z); + }else + { + return nullptr; + } + + info.capture_time = nanoseconds(message.getTime().toNSec()); + + return ros_data_objects::motion_sample::create(info); +} + +std::shared_ptr stream_playback_impl::create_motion_info(const rosbag::MessageInstance &message) const +{ + realsense_msgs::motion_stream_infoPtr msg = message.instantiate(); + if (msg == nullptr) + { + return nullptr; + } + ros_data_objects::motion_stream_data info = {}; + auto device_str = topic(message.getTopic()).at(3); + info.device_id = static_cast(std::stoll(device_str)); + info.fps = msg->fps; + if(conversions::convert(msg->motion_type, info.type) == false) + { + return nullptr; + } + + conversions::convert(msg->stream_intrinsics, info.intrinsics); + conversions::convert(msg->stream_extrinsics.extrinsics, info.stream_extrinsics.extrinsics_data); + info.stream_extrinsics.reference_point_id = msg->stream_extrinsics.reference_point_id; + + return ros_data_objects::motion_stream_info::create(info); +} + +std::shared_ptr stream_playback_impl::create_occupancy_map(const rosbag::MessageInstance &message) const +{ + realsense_msgs::occupancy_mapPtr msg = message.instantiate(); + ros_data_objects::occupancy_map_info info = {}; + info.accuracy = msg->accuracy; + info.reserved = msg->reserved; + info.tile_count = msg->tile_count; + + info.tiles = std::shared_ptr(new float_t[msg->tiles.size()], + [](float_t* ptr){delete[] ptr;}); + + memcpy(info.tiles.get(), &msg->tiles[0], msg->tiles.size()); + auto device_str = topic(message.getTopic()).at(3); + info.device_id = static_cast(std::stoll(device_str)); + info.capture_time = nanoseconds(message.getTime().toNSec()); + return ros_data_objects::occupancy_map::create(info); +} + +std::shared_ptr stream_playback_impl::create_property(const rosbag::MessageInstance &message) const +{ + std_msgs::Float64Ptr msg = message.instantiate(); + ros_data_objects::property_info info = {}; + info.value = msg->data; + info.key = topic(message.getTopic()).at(3); + auto device_str = topic(message.getTopic()).at(4); + info.device_id = static_cast(std::stoll(device_str)); + info.capture_time = nanoseconds(message.getTime().toNSec()); + return ros_data_objects::property::create(info); +} + +std::shared_ptr stream_playback_impl::create_six_dof(const rosbag::MessageInstance &message) const +{ + realsense_msgs::posePtr msg = message.instantiate(); + + ros_data_objects::pose_info info = {}; + info.translation.x = static_cast(msg->translation.x); + info.translation.y = static_cast(msg->translation.y); + info.translation.z = static_cast(msg->translation.z); + + info.rotation.x = static_cast(msg->rotation.x); + info.rotation.y = static_cast(msg->rotation.y); + info.rotation.z = static_cast(msg->rotation.z); + info.rotation.w = static_cast(msg->rotation.w); + + info.velocity.x = static_cast(msg->velocity.x); + info.velocity.y = static_cast(msg->velocity.y); + info.velocity.z = static_cast(msg->velocity.z); + + info.angular_velocity.x = static_cast(msg->angular_velocity.x); + info.angular_velocity.y = static_cast(msg->angular_velocity.y); + info.angular_velocity.z = static_cast(msg->angular_velocity.z); + + info.acceleration.x = static_cast(msg->acceleration.x); + info.acceleration.y = static_cast(msg->acceleration.y); + info.acceleration.z = static_cast(msg->acceleration.z); + + info.angular_acceleration.x = static_cast(msg->angular_acceleration.x); + info.angular_acceleration.y = static_cast(msg->angular_acceleration.y); + info.angular_acceleration.z = static_cast(msg->angular_acceleration.z); + + info.timestamp = nanoseconds(msg->timestamp); + info.system_timestamp = nanoseconds(msg->system_timestamp); + + auto device_str = topic(message.getTopic()).at(3); + info.device_id = static_cast(std::stoll(device_str)); + info.capture_time = nanoseconds(message.getTime().toNSec()); + return ros_data_objects::pose::create(info); +} + +std::shared_ptr stream_playback_impl::create_time_sample(const rosbag::MessageInstance &message) const +{ + sensor_msgs::TimeReferencePtr msg = message.instantiate(); + if (msg == nullptr) + { + return nullptr; + } + ros_data_objects::time_sample_info info = {}; + info.frame_number = msg->header.seq; + info.timestamp = seconds(msg->header.stamp.toSec()); + info.source = msg->source; + info.capture_time = nanoseconds(message.getTime().toNSec()); + auto device_str = topic(message.getTopic()).at(2); + info.device_id = static_cast(std::stoll(device_str)); + + return ros_data_objects::time_sample::create(info); +} + +std::shared_ptr stream_playback_impl::create_vendor_data(const rosbag::MessageInstance &message) const +{ + realsense_msgs::vendor_dataPtr msg = message.instantiate(); + if (msg == nullptr) + { + return nullptr; + } + ros_data_objects::vendor_info info = {}; + info.name = msg->name; + info.value = msg->value; + auto device_str = topic(message.getTopic()).at(2); + info.device_id = static_cast(std::stoll(device_str)); + + return ros_data_objects::vendor_data::create(info); +} +status stream_playback_impl::get_file_duration(file_types::nanoseconds& duration) const +{ + std::unique_lock locker(m_mutex); + std::unique_ptr samples_view; + auto first_non_frame_time = ros::TIME_MIN.toNSec()+1; + status sts = seek_to_time(file_types::nanoseconds(first_non_frame_time), samples_view); + if(sts != status_no_error) + { + return sts; + } + auto samples_itrator = samples_view->begin(); + auto first_frame_time = samples_itrator->getTime(); + auto total_time = samples_view->getEndTime() - first_frame_time; + duration = file_types::nanoseconds(total_time.toNSec()); + return status_no_error; +} diff --git a/realsense-file/src/storage/realsense_file/file_stream/stream_recorder_impl.cpp b/realsense-file/src/storage/realsense_file/file_stream/stream_recorder_impl.cpp new file mode 100644 index 0000000000..c5270fff6c --- /dev/null +++ b/realsense-file/src/storage/realsense_file/file_stream/stream_recorder_impl.cpp @@ -0,0 +1,62 @@ +// License: Apache 2.0. See LICENSE file in root directory. +// Copyright(c) 2017 Intel Corporation. All Rights Reserved. + +#include "include/stream_recorder_impl.h" +#include "file_stream/include/ros_writer_impl.h" +#include "std_msgs/UInt32.h" +#include "file_stream/include/file_format_version.h" +#include "file_stream/include/ros_writer_impl.h" + +using namespace rs::file_format; + +bool stream_recorder::create(const std::string& file_path, std::unique_ptr& recorder) +{ + try + { + recorder = std::unique_ptr(new stream_recorder_impl(file_path)); + } + catch (std::exception&) + { + return false; + } + return true; +} + +bool stream_recorder_impl::write_file_version() +{ + std_msgs::UInt32 msg; + msg.data = get_file_version(); + + auto file_instance = std::static_pointer_cast(m_file); + + if(file_instance->write(get_file_version_topic(), file_types::nanoseconds::min(), msg) != status::status_no_error) + { + return false; + } + return true; +} + +stream_recorder_impl::stream_recorder_impl(const std::string &file_path) +{ + if (file_path.empty()) + { + throw std::invalid_argument("file_path"); + } + m_file = std::make_shared(file_path); + + if(write_file_version() == false) + { + throw std::runtime_error("failed to write file version"); + } + +} + +stream_recorder_impl::~stream_recorder_impl() +{ + m_file.reset(); +} + +status stream_recorder_impl::record(std::shared_ptr data) +{ + return data->write_data(m_file); +} diff --git a/realsense-file/src/storage/realsense_file/include/msgs/geometry_msgs/Accel.h b/realsense-file/src/storage/realsense_file/include/msgs/geometry_msgs/Accel.h new file mode 100644 index 0000000000..cbd17225e5 --- /dev/null +++ b/realsense-file/src/storage/realsense_file/include/msgs/geometry_msgs/Accel.h @@ -0,0 +1,213 @@ +// Generated by gencpp from file geometry_msgs/Accel.msg +// DO NOT EDIT! + + +#ifndef GEOMETRY_MSGS_MESSAGE_ACCEL_H +#define GEOMETRY_MSGS_MESSAGE_ACCEL_H + + +#include +#include +#include + +#include +#include +#include +#include + +#include +#include + +namespace geometry_msgs +{ +template +struct Accel_ +{ + typedef Accel_ Type; + + Accel_() + : linear() + , angular() { + } + Accel_(const ContainerAllocator& _alloc) + : linear(_alloc) + , angular(_alloc) { + (void)_alloc; + } + + + + typedef ::geometry_msgs::Vector3_ _linear_type; + _linear_type linear; + + typedef ::geometry_msgs::Vector3_ _angular_type; + _angular_type angular; + + + + + typedef std::shared_ptr< ::geometry_msgs::Accel_ > Ptr; + typedef std::shared_ptr< ::geometry_msgs::Accel_ const> ConstPtr; + +}; // struct Accel_ + +typedef ::geometry_msgs::Accel_ > Accel; + +typedef std::shared_ptr< ::geometry_msgs::Accel > AccelPtr; +typedef std::shared_ptr< ::geometry_msgs::Accel const> AccelConstPtr; + +// constants requiring out of line definition + + + +template +std::ostream& operator<<(std::ostream& s, const ::geometry_msgs::Accel_ & v) +{ +ros::message_operations::Printer< ::geometry_msgs::Accel_ >::stream(s, "", v); +return s; +} + +} // namespace geometry_msgs + +namespace ros +{ +namespace message_traits +{ + + + +// BOOLTRAITS {'IsFixedSize': True, 'IsMessage': True, 'HasHeader': False} +// {'std_msgs': ['/opt/ros/kinetic/share/std_msgs/cmake/../msg'], 'geometry_msgs': ['/tmp/binarydeb/ros-kinetic-geometry-msgs-1.12.5/msg']} + +// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types'] + + + + +template +struct IsFixedSize< ::geometry_msgs::Accel_ > + : TrueType + { }; + +template +struct IsFixedSize< ::geometry_msgs::Accel_ const> + : TrueType + { }; + +template +struct IsMessage< ::geometry_msgs::Accel_ > + : TrueType + { }; + +template +struct IsMessage< ::geometry_msgs::Accel_ const> + : TrueType + { }; + +template +struct HasHeader< ::geometry_msgs::Accel_ > + : FalseType + { }; + +template +struct HasHeader< ::geometry_msgs::Accel_ const> + : FalseType + { }; + + +template +struct MD5Sum< ::geometry_msgs::Accel_ > +{ + static const char* value() + { + return "9f195f881246fdfa2798d1d3eebca84a"; + } + + static const char* value(const ::geometry_msgs::Accel_&) { return value(); } + static const uint64_t static_value1 = 0x9f195f881246fdfaULL; + static const uint64_t static_value2 = 0x2798d1d3eebca84aULL; +}; + +template +struct DataType< ::geometry_msgs::Accel_ > +{ + static const char* value() + { + return "geometry_msgs/Accel"; + } + + static const char* value(const ::geometry_msgs::Accel_&) { return value(); } +}; + +template +struct Definition< ::geometry_msgs::Accel_ > +{ + static const char* value() + { + return "# This expresses acceleration in free space broken into its linear and angular parts.\n\ +Vector3 linear\n\ +Vector3 angular\n\ +\n\ +================================================================================\n\ +MSG: geometry_msgs/Vector3\n\ +# This represents a vector in free space. \n\ +# It is only meant to represent a direction. Therefore, it does not\n\ +# make sense to apply a translation to it (e.g., when applying a \n\ +# generic rigid transformation to a Vector3, tf2 will only apply the\n\ +# rotation). If you want your data to be translatable too, use the\n\ +# geometry_msgs/Point message instead.\n\ +\n\ +float64 x\n\ +float64 y\n\ +float64 z\n\ +"; + } + + static const char* value(const ::geometry_msgs::Accel_&) { return value(); } +}; + +} // namespace message_traits +} // namespace ros + +namespace ros +{ +namespace serialization +{ + + template struct Serializer< ::geometry_msgs::Accel_ > + { + template inline static void allInOne(Stream& stream, T m) + { + stream.next(m.linear); + stream.next(m.angular); + } + + ROS_DECLARE_ALLINONE_SERIALIZER; + }; // struct Accel_ + +} // namespace serialization +} // namespace ros + +namespace ros +{ +namespace message_operations +{ + +template +struct Printer< ::geometry_msgs::Accel_ > +{ + template static void stream(Stream& s, const std::string& indent, const ::geometry_msgs::Accel_& v) + { + s << indent << "linear: "; + s << std::endl; + Printer< ::geometry_msgs::Vector3_ >::stream(s, indent + " ", v.linear); + s << indent << "angular: "; + s << std::endl; + Printer< ::geometry_msgs::Vector3_ >::stream(s, indent + " ", v.angular); + } +}; + +} // namespace message_operations +} // namespace ros + +#endif // GEOMETRY_MSGS_MESSAGE_ACCEL_H diff --git a/realsense-file/src/storage/realsense_file/include/msgs/geometry_msgs/AccelStamped.h b/realsense-file/src/storage/realsense_file/include/msgs/geometry_msgs/AccelStamped.h new file mode 100644 index 0000000000..89a38319b6 --- /dev/null +++ b/realsense-file/src/storage/realsense_file/include/msgs/geometry_msgs/AccelStamped.h @@ -0,0 +1,237 @@ +// Generated by gencpp from file geometry_msgs/AccelStamped.msg +// DO NOT EDIT! + + +#ifndef GEOMETRY_MSGS_MESSAGE_ACCELSTAMPED_H +#define GEOMETRY_MSGS_MESSAGE_ACCELSTAMPED_H + + +#include +#include +#include + +#include +#include +#include +#include + +#include +#include + +namespace geometry_msgs +{ +template +struct AccelStamped_ +{ + typedef AccelStamped_ Type; + + AccelStamped_() + : header() + , accel() { + } + AccelStamped_(const ContainerAllocator& _alloc) + : header(_alloc) + , accel(_alloc) { + (void)_alloc; + } + + + + typedef ::std_msgs::Header_ _header_type; + _header_type header; + + typedef ::geometry_msgs::Accel_ _accel_type; + _accel_type accel; + + + + + typedef std::shared_ptr< ::geometry_msgs::AccelStamped_ > Ptr; + typedef std::shared_ptr< ::geometry_msgs::AccelStamped_ const> ConstPtr; + +}; // struct AccelStamped_ + +typedef ::geometry_msgs::AccelStamped_ > AccelStamped; + +typedef std::shared_ptr< ::geometry_msgs::AccelStamped > AccelStampedPtr; +typedef std::shared_ptr< ::geometry_msgs::AccelStamped const> AccelStampedConstPtr; + +// constants requiring out of line definition + + + +template +std::ostream& operator<<(std::ostream& s, const ::geometry_msgs::AccelStamped_ & v) +{ +ros::message_operations::Printer< ::geometry_msgs::AccelStamped_ >::stream(s, "", v); +return s; +} + +} // namespace geometry_msgs + +namespace ros +{ +namespace message_traits +{ + + + +// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': True} +// {'std_msgs': ['/opt/ros/kinetic/share/std_msgs/cmake/../msg'], 'geometry_msgs': ['/tmp/binarydeb/ros-kinetic-geometry-msgs-1.12.5/msg']} + +// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types'] + + + + +template +struct IsFixedSize< ::geometry_msgs::AccelStamped_ > + : FalseType + { }; + +template +struct IsFixedSize< ::geometry_msgs::AccelStamped_ const> + : FalseType + { }; + +template +struct IsMessage< ::geometry_msgs::AccelStamped_ > + : TrueType + { }; + +template +struct IsMessage< ::geometry_msgs::AccelStamped_ const> + : TrueType + { }; + +template +struct HasHeader< ::geometry_msgs::AccelStamped_ > + : TrueType + { }; + +template +struct HasHeader< ::geometry_msgs::AccelStamped_ const> + : TrueType + { }; + + +template +struct MD5Sum< ::geometry_msgs::AccelStamped_ > +{ + static const char* value() + { + return "d8a98a5d81351b6eb0578c78557e7659"; + } + + static const char* value(const ::geometry_msgs::AccelStamped_&) { return value(); } + static const uint64_t static_value1 = 0xd8a98a5d81351b6eULL; + static const uint64_t static_value2 = 0xb0578c78557e7659ULL; +}; + +template +struct DataType< ::geometry_msgs::AccelStamped_ > +{ + static const char* value() + { + return "geometry_msgs/AccelStamped"; + } + + static const char* value(const ::geometry_msgs::AccelStamped_&) { return value(); } +}; + +template +struct Definition< ::geometry_msgs::AccelStamped_ > +{ + static const char* value() + { + return "# An accel with reference coordinate frame and timestamp\n\ +Header header\n\ +Accel accel\n\ +\n\ +================================================================================\n\ +MSG: std_msgs/Header\n\ +# Standard metadata for higher-level stamped data types.\n\ +# This is generally used to communicate timestamped data \n\ +# in a particular coordinate frame.\n\ +# \n\ +# sequence ID: consecutively increasing ID \n\ +uint32 seq\n\ +#Two-integer timestamp that is expressed as:\n\ +# * stamp.sec: seconds (stamp_secs) since epoch (in Python the variable is called 'secs')\n\ +# * stamp.nsec: nanoseconds since stamp_secs (in Python the variable is called 'nsecs')\n\ +# time-handling sugar is provided by the client library\n\ +time stamp\n\ +#Frame this data is associated with\n\ +# 0: no frame\n\ +# 1: global frame\n\ +string frame_id\n\ +\n\ +================================================================================\n\ +MSG: geometry_msgs/Accel\n\ +# This expresses acceleration in free space broken into its linear and angular parts.\n\ +Vector3 linear\n\ +Vector3 angular\n\ +\n\ +================================================================================\n\ +MSG: geometry_msgs/Vector3\n\ +# This represents a vector in free space. \n\ +# It is only meant to represent a direction. Therefore, it does not\n\ +# make sense to apply a translation to it (e.g., when applying a \n\ +# generic rigid transformation to a Vector3, tf2 will only apply the\n\ +# rotation). If you want your data to be translatable too, use the\n\ +# geometry_msgs/Point message instead.\n\ +\n\ +float64 x\n\ +float64 y\n\ +float64 z\n\ +"; + } + + static const char* value(const ::geometry_msgs::AccelStamped_&) { return value(); } +}; + +} // namespace message_traits +} // namespace ros + +namespace ros +{ +namespace serialization +{ + + template struct Serializer< ::geometry_msgs::AccelStamped_ > + { + template inline static void allInOne(Stream& stream, T m) + { + stream.next(m.header); + stream.next(m.accel); + } + + ROS_DECLARE_ALLINONE_SERIALIZER; + }; // struct AccelStamped_ + +} // namespace serialization +} // namespace ros + +namespace ros +{ +namespace message_operations +{ + +template +struct Printer< ::geometry_msgs::AccelStamped_ > +{ + template static void stream(Stream& s, const std::string& indent, const ::geometry_msgs::AccelStamped_& v) + { + s << indent << "header: "; + s << std::endl; + Printer< ::std_msgs::Header_ >::stream(s, indent + " ", v.header); + s << indent << "accel: "; + s << std::endl; + Printer< ::geometry_msgs::Accel_ >::stream(s, indent + " ", v.accel); + } +}; + +} // namespace message_operations +} // namespace ros + +#endif // GEOMETRY_MSGS_MESSAGE_ACCELSTAMPED_H diff --git a/realsense-file/src/storage/realsense_file/include/msgs/geometry_msgs/AccelWithCovariance.h b/realsense-file/src/storage/realsense_file/include/msgs/geometry_msgs/AccelWithCovariance.h new file mode 100644 index 0000000000..e77b4ac536 --- /dev/null +++ b/realsense-file/src/storage/realsense_file/include/msgs/geometry_msgs/AccelWithCovariance.h @@ -0,0 +1,229 @@ +// Generated by gencpp from file geometry_msgs/AccelWithCovariance.msg +// DO NOT EDIT! + + +#ifndef GEOMETRY_MSGS_MESSAGE_ACCELWITHCOVARIANCE_H +#define GEOMETRY_MSGS_MESSAGE_ACCELWITHCOVARIANCE_H + + +#include +#include +#include + +#include +#include +#include +#include + +#include + +namespace geometry_msgs +{ +template +struct AccelWithCovariance_ +{ + typedef AccelWithCovariance_ Type; + + AccelWithCovariance_() + : accel() + , covariance() { + covariance.assign(0.0); + } + AccelWithCovariance_(const ContainerAllocator& _alloc) + : accel(_alloc) + , covariance() { + (void)_alloc; + covariance.assign(0.0); + } + + + + typedef ::geometry_msgs::Accel_ _accel_type; + _accel_type accel; + + typedef boost::array _covariance_type; + _covariance_type covariance; + + + + + typedef std::shared_ptr< ::geometry_msgs::AccelWithCovariance_ > Ptr; + typedef std::shared_ptr< ::geometry_msgs::AccelWithCovariance_ const> ConstPtr; + +}; // struct AccelWithCovariance_ + +typedef ::geometry_msgs::AccelWithCovariance_ > AccelWithCovariance; + +typedef std::shared_ptr< ::geometry_msgs::AccelWithCovariance > AccelWithCovariancePtr; +typedef std::shared_ptr< ::geometry_msgs::AccelWithCovariance const> AccelWithCovarianceConstPtr; + +// constants requiring out of line definition + + + +template +std::ostream& operator<<(std::ostream& s, const ::geometry_msgs::AccelWithCovariance_ & v) +{ +ros::message_operations::Printer< ::geometry_msgs::AccelWithCovariance_ >::stream(s, "", v); +return s; +} + +} // namespace geometry_msgs + +namespace ros +{ +namespace message_traits +{ + + + +// BOOLTRAITS {'IsFixedSize': True, 'IsMessage': True, 'HasHeader': False} +// {'std_msgs': ['/opt/ros/kinetic/share/std_msgs/cmake/../msg'], 'geometry_msgs': ['/tmp/binarydeb/ros-kinetic-geometry-msgs-1.12.5/msg']} + +// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types'] + + + + +template +struct IsFixedSize< ::geometry_msgs::AccelWithCovariance_ > + : TrueType + { }; + +template +struct IsFixedSize< ::geometry_msgs::AccelWithCovariance_ const> + : TrueType + { }; + +template +struct IsMessage< ::geometry_msgs::AccelWithCovariance_ > + : TrueType + { }; + +template +struct IsMessage< ::geometry_msgs::AccelWithCovariance_ const> + : TrueType + { }; + +template +struct HasHeader< ::geometry_msgs::AccelWithCovariance_ > + : FalseType + { }; + +template +struct HasHeader< ::geometry_msgs::AccelWithCovariance_ const> + : FalseType + { }; + + +template +struct MD5Sum< ::geometry_msgs::AccelWithCovariance_ > +{ + static const char* value() + { + return "ad5a718d699c6be72a02b8d6a139f334"; + } + + static const char* value(const ::geometry_msgs::AccelWithCovariance_&) { return value(); } + static const uint64_t static_value1 = 0xad5a718d699c6be7ULL; + static const uint64_t static_value2 = 0x2a02b8d6a139f334ULL; +}; + +template +struct DataType< ::geometry_msgs::AccelWithCovariance_ > +{ + static const char* value() + { + return "geometry_msgs/AccelWithCovariance"; + } + + static const char* value(const ::geometry_msgs::AccelWithCovariance_&) { return value(); } +}; + +template +struct Definition< ::geometry_msgs::AccelWithCovariance_ > +{ + static const char* value() + { + return "# This expresses acceleration in free space with uncertainty.\n\ +\n\ +Accel accel\n\ +\n\ +# Row-major representation of the 6x6 covariance matrix\n\ +# The orientation parameters use a fixed-axis representation.\n\ +# In order, the parameters are:\n\ +# (x, y, z, rotation about X axis, rotation about Y axis, rotation about Z axis)\n\ +float64[36] covariance\n\ +\n\ +================================================================================\n\ +MSG: geometry_msgs/Accel\n\ +# This expresses acceleration in free space broken into its linear and angular parts.\n\ +Vector3 linear\n\ +Vector3 angular\n\ +\n\ +================================================================================\n\ +MSG: geometry_msgs/Vector3\n\ +# This represents a vector in free space. \n\ +# It is only meant to represent a direction. Therefore, it does not\n\ +# make sense to apply a translation to it (e.g., when applying a \n\ +# generic rigid transformation to a Vector3, tf2 will only apply the\n\ +# rotation). If you want your data to be translatable too, use the\n\ +# geometry_msgs/Point message instead.\n\ +\n\ +float64 x\n\ +float64 y\n\ +float64 z\n\ +"; + } + + static const char* value(const ::geometry_msgs::AccelWithCovariance_&) { return value(); } +}; + +} // namespace message_traits +} // namespace ros + +namespace ros +{ +namespace serialization +{ + + template struct Serializer< ::geometry_msgs::AccelWithCovariance_ > + { + template inline static void allInOne(Stream& stream, T m) + { + stream.next(m.accel); + stream.next(m.covariance); + } + + ROS_DECLARE_ALLINONE_SERIALIZER; + }; // struct AccelWithCovariance_ + +} // namespace serialization +} // namespace ros + +namespace ros +{ +namespace message_operations +{ + +template +struct Printer< ::geometry_msgs::AccelWithCovariance_ > +{ + template static void stream(Stream& s, const std::string& indent, const ::geometry_msgs::AccelWithCovariance_& v) + { + s << indent << "accel: "; + s << std::endl; + Printer< ::geometry_msgs::Accel_ >::stream(s, indent + " ", v.accel); + s << indent << "covariance[]" << std::endl; + for (size_t i = 0; i < v.covariance.size(); ++i) + { + s << indent << " covariance[" << i << "]: "; + Printer::stream(s, indent + " ", v.covariance[i]); + } + } +}; + +} // namespace message_operations +} // namespace ros + +#endif // GEOMETRY_MSGS_MESSAGE_ACCELWITHCOVARIANCE_H diff --git a/realsense-file/src/storage/realsense_file/include/msgs/geometry_msgs/AccelWithCovarianceStamped.h b/realsense-file/src/storage/realsense_file/include/msgs/geometry_msgs/AccelWithCovarianceStamped.h new file mode 100644 index 0000000000..72dea5f1c9 --- /dev/null +++ b/realsense-file/src/storage/realsense_file/include/msgs/geometry_msgs/AccelWithCovarianceStamped.h @@ -0,0 +1,249 @@ +// Generated by gencpp from file geometry_msgs/AccelWithCovarianceStamped.msg +// DO NOT EDIT! + + +#ifndef GEOMETRY_MSGS_MESSAGE_ACCELWITHCOVARIANCESTAMPED_H +#define GEOMETRY_MSGS_MESSAGE_ACCELWITHCOVARIANCESTAMPED_H + + +#include +#include +#include + +#include +#include +#include +#include + +#include +#include + +namespace geometry_msgs +{ +template +struct AccelWithCovarianceStamped_ +{ + typedef AccelWithCovarianceStamped_ Type; + + AccelWithCovarianceStamped_() + : header() + , accel() { + } + AccelWithCovarianceStamped_(const ContainerAllocator& _alloc) + : header(_alloc) + , accel(_alloc) { + (void)_alloc; + } + + + + typedef ::std_msgs::Header_ _header_type; + _header_type header; + + typedef ::geometry_msgs::AccelWithCovariance_ _accel_type; + _accel_type accel; + + + + + typedef std::shared_ptr< ::geometry_msgs::AccelWithCovarianceStamped_ > Ptr; + typedef std::shared_ptr< ::geometry_msgs::AccelWithCovarianceStamped_ const> ConstPtr; + +}; // struct AccelWithCovarianceStamped_ + +typedef ::geometry_msgs::AccelWithCovarianceStamped_ > AccelWithCovarianceStamped; + +typedef std::shared_ptr< ::geometry_msgs::AccelWithCovarianceStamped > AccelWithCovarianceStampedPtr; +typedef std::shared_ptr< ::geometry_msgs::AccelWithCovarianceStamped const> AccelWithCovarianceStampedConstPtr; + +// constants requiring out of line definition + + + +template +std::ostream& operator<<(std::ostream& s, const ::geometry_msgs::AccelWithCovarianceStamped_ & v) +{ +ros::message_operations::Printer< ::geometry_msgs::AccelWithCovarianceStamped_ >::stream(s, "", v); +return s; +} + +} // namespace geometry_msgs + +namespace ros +{ +namespace message_traits +{ + + + +// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': True} +// {'std_msgs': ['/opt/ros/kinetic/share/std_msgs/cmake/../msg'], 'geometry_msgs': ['/tmp/binarydeb/ros-kinetic-geometry-msgs-1.12.5/msg']} + +// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types'] + + + + +template +struct IsFixedSize< ::geometry_msgs::AccelWithCovarianceStamped_ > + : FalseType + { }; + +template +struct IsFixedSize< ::geometry_msgs::AccelWithCovarianceStamped_ const> + : FalseType + { }; + +template +struct IsMessage< ::geometry_msgs::AccelWithCovarianceStamped_ > + : TrueType + { }; + +template +struct IsMessage< ::geometry_msgs::AccelWithCovarianceStamped_ const> + : TrueType + { }; + +template +struct HasHeader< ::geometry_msgs::AccelWithCovarianceStamped_ > + : TrueType + { }; + +template +struct HasHeader< ::geometry_msgs::AccelWithCovarianceStamped_ const> + : TrueType + { }; + + +template +struct MD5Sum< ::geometry_msgs::AccelWithCovarianceStamped_ > +{ + static const char* value() + { + return "96adb295225031ec8d57fb4251b0a886"; + } + + static const char* value(const ::geometry_msgs::AccelWithCovarianceStamped_&) { return value(); } + static const uint64_t static_value1 = 0x96adb295225031ecULL; + static const uint64_t static_value2 = 0x8d57fb4251b0a886ULL; +}; + +template +struct DataType< ::geometry_msgs::AccelWithCovarianceStamped_ > +{ + static const char* value() + { + return "geometry_msgs/AccelWithCovarianceStamped"; + } + + static const char* value(const ::geometry_msgs::AccelWithCovarianceStamped_&) { return value(); } +}; + +template +struct Definition< ::geometry_msgs::AccelWithCovarianceStamped_ > +{ + static const char* value() + { + return "# This represents an estimated accel with reference coordinate frame and timestamp.\n\ +Header header\n\ +AccelWithCovariance accel\n\ +\n\ +================================================================================\n\ +MSG: std_msgs/Header\n\ +# Standard metadata for higher-level stamped data types.\n\ +# This is generally used to communicate timestamped data \n\ +# in a particular coordinate frame.\n\ +# \n\ +# sequence ID: consecutively increasing ID \n\ +uint32 seq\n\ +#Two-integer timestamp that is expressed as:\n\ +# * stamp.sec: seconds (stamp_secs) since epoch (in Python the variable is called 'secs')\n\ +# * stamp.nsec: nanoseconds since stamp_secs (in Python the variable is called 'nsecs')\n\ +# time-handling sugar is provided by the client library\n\ +time stamp\n\ +#Frame this data is associated with\n\ +# 0: no frame\n\ +# 1: global frame\n\ +string frame_id\n\ +\n\ +================================================================================\n\ +MSG: geometry_msgs/AccelWithCovariance\n\ +# This expresses acceleration in free space with uncertainty.\n\ +\n\ +Accel accel\n\ +\n\ +# Row-major representation of the 6x6 covariance matrix\n\ +# The orientation parameters use a fixed-axis representation.\n\ +# In order, the parameters are:\n\ +# (x, y, z, rotation about X axis, rotation about Y axis, rotation about Z axis)\n\ +float64[36] covariance\n\ +\n\ +================================================================================\n\ +MSG: geometry_msgs/Accel\n\ +# This expresses acceleration in free space broken into its linear and angular parts.\n\ +Vector3 linear\n\ +Vector3 angular\n\ +\n\ +================================================================================\n\ +MSG: geometry_msgs/Vector3\n\ +# This represents a vector in free space. \n\ +# It is only meant to represent a direction. Therefore, it does not\n\ +# make sense to apply a translation to it (e.g., when applying a \n\ +# generic rigid transformation to a Vector3, tf2 will only apply the\n\ +# rotation). If you want your data to be translatable too, use the\n\ +# geometry_msgs/Point message instead.\n\ +\n\ +float64 x\n\ +float64 y\n\ +float64 z\n\ +"; + } + + static const char* value(const ::geometry_msgs::AccelWithCovarianceStamped_&) { return value(); } +}; + +} // namespace message_traits +} // namespace ros + +namespace ros +{ +namespace serialization +{ + + template struct Serializer< ::geometry_msgs::AccelWithCovarianceStamped_ > + { + template inline static void allInOne(Stream& stream, T m) + { + stream.next(m.header); + stream.next(m.accel); + } + + ROS_DECLARE_ALLINONE_SERIALIZER; + }; // struct AccelWithCovarianceStamped_ + +} // namespace serialization +} // namespace ros + +namespace ros +{ +namespace message_operations +{ + +template +struct Printer< ::geometry_msgs::AccelWithCovarianceStamped_ > +{ + template static void stream(Stream& s, const std::string& indent, const ::geometry_msgs::AccelWithCovarianceStamped_& v) + { + s << indent << "header: "; + s << std::endl; + Printer< ::std_msgs::Header_ >::stream(s, indent + " ", v.header); + s << indent << "accel: "; + s << std::endl; + Printer< ::geometry_msgs::AccelWithCovariance_ >::stream(s, indent + " ", v.accel); + } +}; + +} // namespace message_operations +} // namespace ros + +#endif // GEOMETRY_MSGS_MESSAGE_ACCELWITHCOVARIANCESTAMPED_H diff --git a/realsense-file/src/storage/realsense_file/include/msgs/geometry_msgs/Inertia.h b/realsense-file/src/storage/realsense_file/include/msgs/geometry_msgs/Inertia.h new file mode 100644 index 0000000000..f43dfac6e6 --- /dev/null +++ b/realsense-file/src/storage/realsense_file/include/msgs/geometry_msgs/Inertia.h @@ -0,0 +1,272 @@ +// Generated by gencpp from file geometry_msgs/Inertia.msg +// DO NOT EDIT! + + +#ifndef GEOMETRY_MSGS_MESSAGE_INERTIA_H +#define GEOMETRY_MSGS_MESSAGE_INERTIA_H + + +#include +#include +#include + +#include +#include +#include +#include + +#include + +namespace geometry_msgs +{ +template +struct Inertia_ +{ + typedef Inertia_ Type; + + Inertia_() + : m(0.0) + , com() + , ixx(0.0) + , ixy(0.0) + , ixz(0.0) + , iyy(0.0) + , iyz(0.0) + , izz(0.0) { + } + Inertia_(const ContainerAllocator& _alloc) + : m(0.0) + , com(_alloc) + , ixx(0.0) + , ixy(0.0) + , ixz(0.0) + , iyy(0.0) + , iyz(0.0) + , izz(0.0) { + (void)_alloc; + } + + + + typedef double _m_type; + _m_type m; + + typedef ::geometry_msgs::Vector3_ _com_type; + _com_type com; + + typedef double _ixx_type; + _ixx_type ixx; + + typedef double _ixy_type; + _ixy_type ixy; + + typedef double _ixz_type; + _ixz_type ixz; + + typedef double _iyy_type; + _iyy_type iyy; + + typedef double _iyz_type; + _iyz_type iyz; + + typedef double _izz_type; + _izz_type izz; + + + + + typedef std::shared_ptr< ::geometry_msgs::Inertia_ > Ptr; + typedef std::shared_ptr< ::geometry_msgs::Inertia_ const> ConstPtr; + +}; // struct Inertia_ + +typedef ::geometry_msgs::Inertia_ > Inertia; + +typedef std::shared_ptr< ::geometry_msgs::Inertia > InertiaPtr; +typedef std::shared_ptr< ::geometry_msgs::Inertia const> InertiaConstPtr; + +// constants requiring out of line definition + + + +template +std::ostream& operator<<(std::ostream& s, const ::geometry_msgs::Inertia_ & v) +{ +ros::message_operations::Printer< ::geometry_msgs::Inertia_ >::stream(s, "", v); +return s; +} + +} // namespace geometry_msgs + +namespace ros +{ +namespace message_traits +{ + + + +// BOOLTRAITS {'IsFixedSize': True, 'IsMessage': True, 'HasHeader': False} +// {'std_msgs': ['/opt/ros/kinetic/share/std_msgs/cmake/../msg'], 'geometry_msgs': ['/tmp/binarydeb/ros-kinetic-geometry-msgs-1.12.5/msg']} + +// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types'] + + + + +template +struct IsFixedSize< ::geometry_msgs::Inertia_ > + : TrueType + { }; + +template +struct IsFixedSize< ::geometry_msgs::Inertia_ const> + : TrueType + { }; + +template +struct IsMessage< ::geometry_msgs::Inertia_ > + : TrueType + { }; + +template +struct IsMessage< ::geometry_msgs::Inertia_ const> + : TrueType + { }; + +template +struct HasHeader< ::geometry_msgs::Inertia_ > + : FalseType + { }; + +template +struct HasHeader< ::geometry_msgs::Inertia_ const> + : FalseType + { }; + + +template +struct MD5Sum< ::geometry_msgs::Inertia_ > +{ + static const char* value() + { + return "1d26e4bb6c83ff141c5cf0d883c2b0fe"; + } + + static const char* value(const ::geometry_msgs::Inertia_&) { return value(); } + static const uint64_t static_value1 = 0x1d26e4bb6c83ff14ULL; + static const uint64_t static_value2 = 0x1c5cf0d883c2b0feULL; +}; + +template +struct DataType< ::geometry_msgs::Inertia_ > +{ + static const char* value() + { + return "geometry_msgs/Inertia"; + } + + static const char* value(const ::geometry_msgs::Inertia_&) { return value(); } +}; + +template +struct Definition< ::geometry_msgs::Inertia_ > +{ + static const char* value() + { + return "# Mass [kg]\n\ +float64 m\n\ +\n\ +# Center of mass [m]\n\ +geometry_msgs/Vector3 com\n\ +\n\ +# Inertia Tensor [kg-m^2]\n\ +# | ixx ixy ixz |\n\ +# I = | ixy iyy iyz |\n\ +# | ixz iyz izz |\n\ +float64 ixx\n\ +float64 ixy\n\ +float64 ixz\n\ +float64 iyy\n\ +float64 iyz\n\ +float64 izz\n\ +\n\ +================================================================================\n\ +MSG: geometry_msgs/Vector3\n\ +# This represents a vector in free space. \n\ +# It is only meant to represent a direction. Therefore, it does not\n\ +# make sense to apply a translation to it (e.g., when applying a \n\ +# generic rigid transformation to a Vector3, tf2 will only apply the\n\ +# rotation). If you want your data to be translatable too, use the\n\ +# geometry_msgs/Point message instead.\n\ +\n\ +float64 x\n\ +float64 y\n\ +float64 z\n\ +"; + } + + static const char* value(const ::geometry_msgs::Inertia_&) { return value(); } +}; + +} // namespace message_traits +} // namespace ros + +namespace ros +{ +namespace serialization +{ + + template struct Serializer< ::geometry_msgs::Inertia_ > + { + template inline static void allInOne(Stream& stream, T m) + { + stream.next(m.m); + stream.next(m.com); + stream.next(m.ixx); + stream.next(m.ixy); + stream.next(m.ixz); + stream.next(m.iyy); + stream.next(m.iyz); + stream.next(m.izz); + } + + ROS_DECLARE_ALLINONE_SERIALIZER; + }; // struct Inertia_ + +} // namespace serialization +} // namespace ros + +namespace ros +{ +namespace message_operations +{ + +template +struct Printer< ::geometry_msgs::Inertia_ > +{ + template static void stream(Stream& s, const std::string& indent, const ::geometry_msgs::Inertia_& v) + { + s << indent << "m: "; + Printer::stream(s, indent + " ", v.m); + s << indent << "com: "; + s << std::endl; + Printer< ::geometry_msgs::Vector3_ >::stream(s, indent + " ", v.com); + s << indent << "ixx: "; + Printer::stream(s, indent + " ", v.ixx); + s << indent << "ixy: "; + Printer::stream(s, indent + " ", v.ixy); + s << indent << "ixz: "; + Printer::stream(s, indent + " ", v.ixz); + s << indent << "iyy: "; + Printer::stream(s, indent + " ", v.iyy); + s << indent << "iyz: "; + Printer::stream(s, indent + " ", v.iyz); + s << indent << "izz: "; + Printer::stream(s, indent + " ", v.izz); + } +}; + +} // namespace message_operations +} // namespace ros + +#endif // GEOMETRY_MSGS_MESSAGE_INERTIA_H diff --git a/realsense-file/src/storage/realsense_file/include/msgs/geometry_msgs/InertiaStamped.h b/realsense-file/src/storage/realsense_file/include/msgs/geometry_msgs/InertiaStamped.h new file mode 100644 index 0000000000..e73f619b0b --- /dev/null +++ b/realsense-file/src/storage/realsense_file/include/msgs/geometry_msgs/InertiaStamped.h @@ -0,0 +1,249 @@ +// Generated by gencpp from file geometry_msgs/InertiaStamped.msg +// DO NOT EDIT! + + +#ifndef GEOMETRY_MSGS_MESSAGE_INERTIASTAMPED_H +#define GEOMETRY_MSGS_MESSAGE_INERTIASTAMPED_H + + +#include +#include +#include + +#include +#include +#include +#include + +#include +#include + +namespace geometry_msgs +{ +template +struct InertiaStamped_ +{ + typedef InertiaStamped_ Type; + + InertiaStamped_() + : header() + , inertia() { + } + InertiaStamped_(const ContainerAllocator& _alloc) + : header(_alloc) + , inertia(_alloc) { + (void)_alloc; + } + + + + typedef ::std_msgs::Header_ _header_type; + _header_type header; + + typedef ::geometry_msgs::Inertia_ _inertia_type; + _inertia_type inertia; + + + + + typedef std::shared_ptr< ::geometry_msgs::InertiaStamped_ > Ptr; + typedef std::shared_ptr< ::geometry_msgs::InertiaStamped_ const> ConstPtr; + +}; // struct InertiaStamped_ + +typedef ::geometry_msgs::InertiaStamped_ > InertiaStamped; + +typedef std::shared_ptr< ::geometry_msgs::InertiaStamped > InertiaStampedPtr; +typedef std::shared_ptr< ::geometry_msgs::InertiaStamped const> InertiaStampedConstPtr; + +// constants requiring out of line definition + + + +template +std::ostream& operator<<(std::ostream& s, const ::geometry_msgs::InertiaStamped_ & v) +{ +ros::message_operations::Printer< ::geometry_msgs::InertiaStamped_ >::stream(s, "", v); +return s; +} + +} // namespace geometry_msgs + +namespace ros +{ +namespace message_traits +{ + + + +// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': True} +// {'std_msgs': ['/opt/ros/kinetic/share/std_msgs/cmake/../msg'], 'geometry_msgs': ['/tmp/binarydeb/ros-kinetic-geometry-msgs-1.12.5/msg']} + +// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types'] + + + + +template +struct IsFixedSize< ::geometry_msgs::InertiaStamped_ > + : FalseType + { }; + +template +struct IsFixedSize< ::geometry_msgs::InertiaStamped_ const> + : FalseType + { }; + +template +struct IsMessage< ::geometry_msgs::InertiaStamped_ > + : TrueType + { }; + +template +struct IsMessage< ::geometry_msgs::InertiaStamped_ const> + : TrueType + { }; + +template +struct HasHeader< ::geometry_msgs::InertiaStamped_ > + : TrueType + { }; + +template +struct HasHeader< ::geometry_msgs::InertiaStamped_ const> + : TrueType + { }; + + +template +struct MD5Sum< ::geometry_msgs::InertiaStamped_ > +{ + static const char* value() + { + return "ddee48caeab5a966c5e8d166654a9ac7"; + } + + static const char* value(const ::geometry_msgs::InertiaStamped_&) { return value(); } + static const uint64_t static_value1 = 0xddee48caeab5a966ULL; + static const uint64_t static_value2 = 0xc5e8d166654a9ac7ULL; +}; + +template +struct DataType< ::geometry_msgs::InertiaStamped_ > +{ + static const char* value() + { + return "geometry_msgs/InertiaStamped"; + } + + static const char* value(const ::geometry_msgs::InertiaStamped_&) { return value(); } +}; + +template +struct Definition< ::geometry_msgs::InertiaStamped_ > +{ + static const char* value() + { + return "Header header\n\ +Inertia inertia\n\ +\n\ +================================================================================\n\ +MSG: std_msgs/Header\n\ +# Standard metadata for higher-level stamped data types.\n\ +# This is generally used to communicate timestamped data \n\ +# in a particular coordinate frame.\n\ +# \n\ +# sequence ID: consecutively increasing ID \n\ +uint32 seq\n\ +#Two-integer timestamp that is expressed as:\n\ +# * stamp.sec: seconds (stamp_secs) since epoch (in Python the variable is called 'secs')\n\ +# * stamp.nsec: nanoseconds since stamp_secs (in Python the variable is called 'nsecs')\n\ +# time-handling sugar is provided by the client library\n\ +time stamp\n\ +#Frame this data is associated with\n\ +# 0: no frame\n\ +# 1: global frame\n\ +string frame_id\n\ +\n\ +================================================================================\n\ +MSG: geometry_msgs/Inertia\n\ +# Mass [kg]\n\ +float64 m\n\ +\n\ +# Center of mass [m]\n\ +geometry_msgs/Vector3 com\n\ +\n\ +# Inertia Tensor [kg-m^2]\n\ +# | ixx ixy ixz |\n\ +# I = | ixy iyy iyz |\n\ +# | ixz iyz izz |\n\ +float64 ixx\n\ +float64 ixy\n\ +float64 ixz\n\ +float64 iyy\n\ +float64 iyz\n\ +float64 izz\n\ +\n\ +================================================================================\n\ +MSG: geometry_msgs/Vector3\n\ +# This represents a vector in free space. \n\ +# It is only meant to represent a direction. Therefore, it does not\n\ +# make sense to apply a translation to it (e.g., when applying a \n\ +# generic rigid transformation to a Vector3, tf2 will only apply the\n\ +# rotation). If you want your data to be translatable too, use the\n\ +# geometry_msgs/Point message instead.\n\ +\n\ +float64 x\n\ +float64 y\n\ +float64 z\n\ +"; + } + + static const char* value(const ::geometry_msgs::InertiaStamped_&) { return value(); } +}; + +} // namespace message_traits +} // namespace ros + +namespace ros +{ +namespace serialization +{ + + template struct Serializer< ::geometry_msgs::InertiaStamped_ > + { + template inline static void allInOne(Stream& stream, T m) + { + stream.next(m.header); + stream.next(m.inertia); + } + + ROS_DECLARE_ALLINONE_SERIALIZER; + }; // struct InertiaStamped_ + +} // namespace serialization +} // namespace ros + +namespace ros +{ +namespace message_operations +{ + +template +struct Printer< ::geometry_msgs::InertiaStamped_ > +{ + template static void stream(Stream& s, const std::string& indent, const ::geometry_msgs::InertiaStamped_& v) + { + s << indent << "header: "; + s << std::endl; + Printer< ::std_msgs::Header_ >::stream(s, indent + " ", v.header); + s << indent << "inertia: "; + s << std::endl; + Printer< ::geometry_msgs::Inertia_ >::stream(s, indent + " ", v.inertia); + } +}; + +} // namespace message_operations +} // namespace ros + +#endif // GEOMETRY_MSGS_MESSAGE_INERTIASTAMPED_H diff --git a/realsense-file/src/storage/realsense_file/include/msgs/geometry_msgs/Point.h b/realsense-file/src/storage/realsense_file/include/msgs/geometry_msgs/Point.h new file mode 100644 index 0000000000..c75eb82bcf --- /dev/null +++ b/realsense-file/src/storage/realsense_file/include/msgs/geometry_msgs/Point.h @@ -0,0 +1,205 @@ +// Generated by gencpp from file geometry_msgs/Point.msg +// DO NOT EDIT! + + +#ifndef GEOMETRY_MSGS_MESSAGE_POINT_H +#define GEOMETRY_MSGS_MESSAGE_POINT_H + + +#include +#include +#include + +#include +#include +#include +#include + + +namespace geometry_msgs +{ +template +struct Point_ +{ + typedef Point_ Type; + + Point_() + : x(0.0) + , y(0.0) + , z(0.0) { + } + Point_(const ContainerAllocator& _alloc) + : x(0.0) + , y(0.0) + , z(0.0) { + (void)_alloc; + } + + + + typedef double _x_type; + _x_type x; + + typedef double _y_type; + _y_type y; + + typedef double _z_type; + _z_type z; + + + + + typedef std::shared_ptr< ::geometry_msgs::Point_ > Ptr; + typedef std::shared_ptr< ::geometry_msgs::Point_ const> ConstPtr; + +}; // struct Point_ + +typedef ::geometry_msgs::Point_ > Point; + +typedef std::shared_ptr< ::geometry_msgs::Point > PointPtr; +typedef std::shared_ptr< ::geometry_msgs::Point const> PointConstPtr; + +// constants requiring out of line definition + + + +template +std::ostream& operator<<(std::ostream& s, const ::geometry_msgs::Point_ & v) +{ +ros::message_operations::Printer< ::geometry_msgs::Point_ >::stream(s, "", v); +return s; +} + +} // namespace geometry_msgs + +namespace ros +{ +namespace message_traits +{ + + + +// BOOLTRAITS {'IsFixedSize': True, 'IsMessage': True, 'HasHeader': False} +// {'std_msgs': ['/opt/ros/kinetic/share/std_msgs/cmake/../msg'], 'geometry_msgs': ['/tmp/binarydeb/ros-kinetic-geometry-msgs-1.12.5/msg']} + +// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types'] + + + + +template +struct IsFixedSize< ::geometry_msgs::Point_ > + : TrueType + { }; + +template +struct IsFixedSize< ::geometry_msgs::Point_ const> + : TrueType + { }; + +template +struct IsMessage< ::geometry_msgs::Point_ > + : TrueType + { }; + +template +struct IsMessage< ::geometry_msgs::Point_ const> + : TrueType + { }; + +template +struct HasHeader< ::geometry_msgs::Point_ > + : FalseType + { }; + +template +struct HasHeader< ::geometry_msgs::Point_ const> + : FalseType + { }; + + +template +struct MD5Sum< ::geometry_msgs::Point_ > +{ + static const char* value() + { + return "4a842b65f413084dc2b10fb484ea7f17"; + } + + static const char* value(const ::geometry_msgs::Point_&) { return value(); } + static const uint64_t static_value1 = 0x4a842b65f413084dULL; + static const uint64_t static_value2 = 0xc2b10fb484ea7f17ULL; +}; + +template +struct DataType< ::geometry_msgs::Point_ > +{ + static const char* value() + { + return "geometry_msgs/Point"; + } + + static const char* value(const ::geometry_msgs::Point_&) { return value(); } +}; + +template +struct Definition< ::geometry_msgs::Point_ > +{ + static const char* value() + { + return "# This contains the position of a point in free space\n\ +float64 x\n\ +float64 y\n\ +float64 z\n\ +"; + } + + static const char* value(const ::geometry_msgs::Point_&) { return value(); } +}; + +} // namespace message_traits +} // namespace ros + +namespace ros +{ +namespace serialization +{ + + template struct Serializer< ::geometry_msgs::Point_ > + { + template inline static void allInOne(Stream& stream, T m) + { + stream.next(m.x); + stream.next(m.y); + stream.next(m.z); + } + + ROS_DECLARE_ALLINONE_SERIALIZER; + }; // struct Point_ + +} // namespace serialization +} // namespace ros + +namespace ros +{ +namespace message_operations +{ + +template +struct Printer< ::geometry_msgs::Point_ > +{ + template static void stream(Stream& s, const std::string& indent, const ::geometry_msgs::Point_& v) + { + s << indent << "x: "; + Printer::stream(s, indent + " ", v.x); + s << indent << "y: "; + Printer::stream(s, indent + " ", v.y); + s << indent << "z: "; + Printer::stream(s, indent + " ", v.z); + } +}; + +} // namespace message_operations +} // namespace ros + +#endif // GEOMETRY_MSGS_MESSAGE_POINT_H diff --git a/realsense-file/src/storage/realsense_file/include/msgs/geometry_msgs/Point32.h b/realsense-file/src/storage/realsense_file/include/msgs/geometry_msgs/Point32.h new file mode 100644 index 0000000000..0c7bd6174e --- /dev/null +++ b/realsense-file/src/storage/realsense_file/include/msgs/geometry_msgs/Point32.h @@ -0,0 +1,212 @@ +// Generated by gencpp from file geometry_msgs/Point32.msg +// DO NOT EDIT! + + +#ifndef GEOMETRY_MSGS_MESSAGE_POINT32_H +#define GEOMETRY_MSGS_MESSAGE_POINT32_H + + +#include +#include +#include + +#include +#include +#include +#include + + +namespace geometry_msgs +{ +template +struct Point32_ +{ + typedef Point32_ Type; + + Point32_() + : x(0.0) + , y(0.0) + , z(0.0) { + } + Point32_(const ContainerAllocator& _alloc) + : x(0.0) + , y(0.0) + , z(0.0) { + (void)_alloc; + } + + + + typedef float _x_type; + _x_type x; + + typedef float _y_type; + _y_type y; + + typedef float _z_type; + _z_type z; + + + + + typedef std::shared_ptr< ::geometry_msgs::Point32_ > Ptr; + typedef std::shared_ptr< ::geometry_msgs::Point32_ const> ConstPtr; + +}; // struct Point32_ + +typedef ::geometry_msgs::Point32_ > Point32; + +typedef std::shared_ptr< ::geometry_msgs::Point32 > Point32Ptr; +typedef std::shared_ptr< ::geometry_msgs::Point32 const> Point32ConstPtr; + +// constants requiring out of line definition + + + +template +std::ostream& operator<<(std::ostream& s, const ::geometry_msgs::Point32_ & v) +{ +ros::message_operations::Printer< ::geometry_msgs::Point32_ >::stream(s, "", v); +return s; +} + +} // namespace geometry_msgs + +namespace ros +{ +namespace message_traits +{ + + + +// BOOLTRAITS {'IsFixedSize': True, 'IsMessage': True, 'HasHeader': False} +// {'std_msgs': ['/opt/ros/kinetic/share/std_msgs/cmake/../msg'], 'geometry_msgs': ['/tmp/binarydeb/ros-kinetic-geometry-msgs-1.12.5/msg']} + +// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types'] + + + + +template +struct IsFixedSize< ::geometry_msgs::Point32_ > + : TrueType + { }; + +template +struct IsFixedSize< ::geometry_msgs::Point32_ const> + : TrueType + { }; + +template +struct IsMessage< ::geometry_msgs::Point32_ > + : TrueType + { }; + +template +struct IsMessage< ::geometry_msgs::Point32_ const> + : TrueType + { }; + +template +struct HasHeader< ::geometry_msgs::Point32_ > + : FalseType + { }; + +template +struct HasHeader< ::geometry_msgs::Point32_ const> + : FalseType + { }; + + +template +struct MD5Sum< ::geometry_msgs::Point32_ > +{ + static const char* value() + { + return "cc153912f1453b708d221682bc23d9ac"; + } + + static const char* value(const ::geometry_msgs::Point32_&) { return value(); } + static const uint64_t static_value1 = 0xcc153912f1453b70ULL; + static const uint64_t static_value2 = 0x8d221682bc23d9acULL; +}; + +template +struct DataType< ::geometry_msgs::Point32_ > +{ + static const char* value() + { + return "geometry_msgs/Point32"; + } + + static const char* value(const ::geometry_msgs::Point32_&) { return value(); } +}; + +template +struct Definition< ::geometry_msgs::Point32_ > +{ + static const char* value() + { + return "# This contains the position of a point in free space(with 32 bits of precision).\n\ +# It is recommeded to use Point wherever possible instead of Point32. \n\ +# \n\ +# This recommendation is to promote interoperability. \n\ +#\n\ +# This message is designed to take up less space when sending\n\ +# lots of points at once, as in the case of a PointCloud. \n\ +\n\ +float32 x\n\ +float32 y\n\ +float32 z\n\ +"; + } + + static const char* value(const ::geometry_msgs::Point32_&) { return value(); } +}; + +} // namespace message_traits +} // namespace ros + +namespace ros +{ +namespace serialization +{ + + template struct Serializer< ::geometry_msgs::Point32_ > + { + template inline static void allInOne(Stream& stream, T m) + { + stream.next(m.x); + stream.next(m.y); + stream.next(m.z); + } + + ROS_DECLARE_ALLINONE_SERIALIZER; + }; // struct Point32_ + +} // namespace serialization +} // namespace ros + +namespace ros +{ +namespace message_operations +{ + +template +struct Printer< ::geometry_msgs::Point32_ > +{ + template static void stream(Stream& s, const std::string& indent, const ::geometry_msgs::Point32_& v) + { + s << indent << "x: "; + Printer::stream(s, indent + " ", v.x); + s << indent << "y: "; + Printer::stream(s, indent + " ", v.y); + s << indent << "z: "; + Printer::stream(s, indent + " ", v.z); + } +}; + +} // namespace message_operations +} // namespace ros + +#endif // GEOMETRY_MSGS_MESSAGE_POINT32_H diff --git a/realsense-file/src/storage/realsense_file/include/msgs/geometry_msgs/PointStamped.h b/realsense-file/src/storage/realsense_file/include/msgs/geometry_msgs/PointStamped.h new file mode 100644 index 0000000000..fb86958939 --- /dev/null +++ b/realsense-file/src/storage/realsense_file/include/msgs/geometry_msgs/PointStamped.h @@ -0,0 +1,225 @@ +// Generated by gencpp from file geometry_msgs/PointStamped.msg +// DO NOT EDIT! + + +#ifndef GEOMETRY_MSGS_MESSAGE_POINTSTAMPED_H +#define GEOMETRY_MSGS_MESSAGE_POINTSTAMPED_H + + +#include +#include +#include + +#include +#include +#include +#include + +#include +#include + +namespace geometry_msgs +{ +template +struct PointStamped_ +{ + typedef PointStamped_ Type; + + PointStamped_() + : header() + , point() { + } + PointStamped_(const ContainerAllocator& _alloc) + : header(_alloc) + , point(_alloc) { + (void)_alloc; + } + + + + typedef ::std_msgs::Header_ _header_type; + _header_type header; + + typedef ::geometry_msgs::Point_ _point_type; + _point_type point; + + + + + typedef std::shared_ptr< ::geometry_msgs::PointStamped_ > Ptr; + typedef std::shared_ptr< ::geometry_msgs::PointStamped_ const> ConstPtr; + +}; // struct PointStamped_ + +typedef ::geometry_msgs::PointStamped_ > PointStamped; + +typedef std::shared_ptr< ::geometry_msgs::PointStamped > PointStampedPtr; +typedef std::shared_ptr< ::geometry_msgs::PointStamped const> PointStampedConstPtr; + +// constants requiring out of line definition + + + +template +std::ostream& operator<<(std::ostream& s, const ::geometry_msgs::PointStamped_ & v) +{ +ros::message_operations::Printer< ::geometry_msgs::PointStamped_ >::stream(s, "", v); +return s; +} + +} // namespace geometry_msgs + +namespace ros +{ +namespace message_traits +{ + + + +// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': True} +// {'std_msgs': ['/opt/ros/kinetic/share/std_msgs/cmake/../msg'], 'geometry_msgs': ['/tmp/binarydeb/ros-kinetic-geometry-msgs-1.12.5/msg']} + +// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types'] + + + + +template +struct IsFixedSize< ::geometry_msgs::PointStamped_ > + : FalseType + { }; + +template +struct IsFixedSize< ::geometry_msgs::PointStamped_ const> + : FalseType + { }; + +template +struct IsMessage< ::geometry_msgs::PointStamped_ > + : TrueType + { }; + +template +struct IsMessage< ::geometry_msgs::PointStamped_ const> + : TrueType + { }; + +template +struct HasHeader< ::geometry_msgs::PointStamped_ > + : TrueType + { }; + +template +struct HasHeader< ::geometry_msgs::PointStamped_ const> + : TrueType + { }; + + +template +struct MD5Sum< ::geometry_msgs::PointStamped_ > +{ + static const char* value() + { + return "c63aecb41bfdfd6b7e1fac37c7cbe7bf"; + } + + static const char* value(const ::geometry_msgs::PointStamped_&) { return value(); } + static const uint64_t static_value1 = 0xc63aecb41bfdfd6bULL; + static const uint64_t static_value2 = 0x7e1fac37c7cbe7bfULL; +}; + +template +struct DataType< ::geometry_msgs::PointStamped_ > +{ + static const char* value() + { + return "geometry_msgs/PointStamped"; + } + + static const char* value(const ::geometry_msgs::PointStamped_&) { return value(); } +}; + +template +struct Definition< ::geometry_msgs::PointStamped_ > +{ + static const char* value() + { + return "# This represents a Point with reference coordinate frame and timestamp\n\ +Header header\n\ +Point point\n\ +\n\ +================================================================================\n\ +MSG: std_msgs/Header\n\ +# Standard metadata for higher-level stamped data types.\n\ +# This is generally used to communicate timestamped data \n\ +# in a particular coordinate frame.\n\ +# \n\ +# sequence ID: consecutively increasing ID \n\ +uint32 seq\n\ +#Two-integer timestamp that is expressed as:\n\ +# * stamp.sec: seconds (stamp_secs) since epoch (in Python the variable is called 'secs')\n\ +# * stamp.nsec: nanoseconds since stamp_secs (in Python the variable is called 'nsecs')\n\ +# time-handling sugar is provided by the client library\n\ +time stamp\n\ +#Frame this data is associated with\n\ +# 0: no frame\n\ +# 1: global frame\n\ +string frame_id\n\ +\n\ +================================================================================\n\ +MSG: geometry_msgs/Point\n\ +# This contains the position of a point in free space\n\ +float64 x\n\ +float64 y\n\ +float64 z\n\ +"; + } + + static const char* value(const ::geometry_msgs::PointStamped_&) { return value(); } +}; + +} // namespace message_traits +} // namespace ros + +namespace ros +{ +namespace serialization +{ + + template struct Serializer< ::geometry_msgs::PointStamped_ > + { + template inline static void allInOne(Stream& stream, T m) + { + stream.next(m.header); + stream.next(m.point); + } + + ROS_DECLARE_ALLINONE_SERIALIZER; + }; // struct PointStamped_ + +} // namespace serialization +} // namespace ros + +namespace ros +{ +namespace message_operations +{ + +template +struct Printer< ::geometry_msgs::PointStamped_ > +{ + template static void stream(Stream& s, const std::string& indent, const ::geometry_msgs::PointStamped_& v) + { + s << indent << "header: "; + s << std::endl; + Printer< ::std_msgs::Header_ >::stream(s, indent + " ", v.header); + s << indent << "point: "; + s << std::endl; + Printer< ::geometry_msgs::Point_ >::stream(s, indent + " ", v.point); + } +}; + +} // namespace message_operations +} // namespace ros + +#endif // GEOMETRY_MSGS_MESSAGE_POINTSTAMPED_H diff --git a/realsense-file/src/storage/realsense_file/include/msgs/geometry_msgs/Polygon.h b/realsense-file/src/storage/realsense_file/include/msgs/geometry_msgs/Polygon.h new file mode 100644 index 0000000000..44d1cee866 --- /dev/null +++ b/realsense-file/src/storage/realsense_file/include/msgs/geometry_msgs/Polygon.h @@ -0,0 +1,208 @@ +// Generated by gencpp from file geometry_msgs/Polygon.msg +// DO NOT EDIT! + + +#ifndef GEOMETRY_MSGS_MESSAGE_POLYGON_H +#define GEOMETRY_MSGS_MESSAGE_POLYGON_H + + +#include +#include +#include + +#include +#include +#include +#include + +#include + +namespace geometry_msgs +{ +template +struct Polygon_ +{ + typedef Polygon_ Type; + + Polygon_() + : points() { + } + Polygon_(const ContainerAllocator& _alloc) + : points(_alloc) { + (void)_alloc; + } + + + + typedef std::vector< ::geometry_msgs::Point32_ , typename ContainerAllocator::template rebind< ::geometry_msgs::Point32_ >::other > _points_type; + _points_type points; + + + + + typedef std::shared_ptr< ::geometry_msgs::Polygon_ > Ptr; + typedef std::shared_ptr< ::geometry_msgs::Polygon_ const> ConstPtr; + +}; // struct Polygon_ + +typedef ::geometry_msgs::Polygon_ > Polygon; + +typedef std::shared_ptr< ::geometry_msgs::Polygon > PolygonPtr; +typedef std::shared_ptr< ::geometry_msgs::Polygon const> PolygonConstPtr; + +// constants requiring out of line definition + + + +template +std::ostream& operator<<(std::ostream& s, const ::geometry_msgs::Polygon_ & v) +{ +ros::message_operations::Printer< ::geometry_msgs::Polygon_ >::stream(s, "", v); +return s; +} + +} // namespace geometry_msgs + +namespace ros +{ +namespace message_traits +{ + + + +// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': False} +// {'std_msgs': ['/opt/ros/kinetic/share/std_msgs/cmake/../msg'], 'geometry_msgs': ['/tmp/binarydeb/ros-kinetic-geometry-msgs-1.12.5/msg']} + +// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types'] + + + + +template +struct IsFixedSize< ::geometry_msgs::Polygon_ > + : FalseType + { }; + +template +struct IsFixedSize< ::geometry_msgs::Polygon_ const> + : FalseType + { }; + +template +struct IsMessage< ::geometry_msgs::Polygon_ > + : TrueType + { }; + +template +struct IsMessage< ::geometry_msgs::Polygon_ const> + : TrueType + { }; + +template +struct HasHeader< ::geometry_msgs::Polygon_ > + : FalseType + { }; + +template +struct HasHeader< ::geometry_msgs::Polygon_ const> + : FalseType + { }; + + +template +struct MD5Sum< ::geometry_msgs::Polygon_ > +{ + static const char* value() + { + return "cd60a26494a087f577976f0329fa120e"; + } + + static const char* value(const ::geometry_msgs::Polygon_&) { return value(); } + static const uint64_t static_value1 = 0xcd60a26494a087f5ULL; + static const uint64_t static_value2 = 0x77976f0329fa120eULL; +}; + +template +struct DataType< ::geometry_msgs::Polygon_ > +{ + static const char* value() + { + return "geometry_msgs/Polygon"; + } + + static const char* value(const ::geometry_msgs::Polygon_&) { return value(); } +}; + +template +struct Definition< ::geometry_msgs::Polygon_ > +{ + static const char* value() + { + return "#A specification of a polygon where the first and last points are assumed to be connected\n\ +Point32[] points\n\ +\n\ +================================================================================\n\ +MSG: geometry_msgs/Point32\n\ +# This contains the position of a point in free space(with 32 bits of precision).\n\ +# It is recommeded to use Point wherever possible instead of Point32. \n\ +# \n\ +# This recommendation is to promote interoperability. \n\ +#\n\ +# This message is designed to take up less space when sending\n\ +# lots of points at once, as in the case of a PointCloud. \n\ +\n\ +float32 x\n\ +float32 y\n\ +float32 z\n\ +"; + } + + static const char* value(const ::geometry_msgs::Polygon_&) { return value(); } +}; + +} // namespace message_traits +} // namespace ros + +namespace ros +{ +namespace serialization +{ + + template struct Serializer< ::geometry_msgs::Polygon_ > + { + template inline static void allInOne(Stream& stream, T m) + { + stream.next(m.points); + } + + ROS_DECLARE_ALLINONE_SERIALIZER; + }; // struct Polygon_ + +} // namespace serialization +} // namespace ros + +namespace ros +{ +namespace message_operations +{ + +template +struct Printer< ::geometry_msgs::Polygon_ > +{ + template static void stream(Stream& s, const std::string& indent, const ::geometry_msgs::Polygon_& v) + { + s << indent << "points[]" << std::endl; + for (size_t i = 0; i < v.points.size(); ++i) + { + s << indent << " points[" << i << "]: "; + s << std::endl; + s << indent; + Printer< ::geometry_msgs::Point32_ >::stream(s, indent + " ", v.points[i]); + } + } +}; + +} // namespace message_operations +} // namespace ros + +#endif // GEOMETRY_MSGS_MESSAGE_POLYGON_H diff --git a/realsense-file/src/storage/realsense_file/include/msgs/geometry_msgs/PolygonStamped.h b/realsense-file/src/storage/realsense_file/include/msgs/geometry_msgs/PolygonStamped.h new file mode 100644 index 0000000000..de18cf8c88 --- /dev/null +++ b/realsense-file/src/storage/realsense_file/include/msgs/geometry_msgs/PolygonStamped.h @@ -0,0 +1,237 @@ +// Generated by gencpp from file geometry_msgs/PolygonStamped.msg +// DO NOT EDIT! + + +#ifndef GEOMETRY_MSGS_MESSAGE_POLYGONSTAMPED_H +#define GEOMETRY_MSGS_MESSAGE_POLYGONSTAMPED_H + + +#include +#include +#include + +#include +#include +#include +#include + +#include +#include + +namespace geometry_msgs +{ +template +struct PolygonStamped_ +{ + typedef PolygonStamped_ Type; + + PolygonStamped_() + : header() + , polygon() { + } + PolygonStamped_(const ContainerAllocator& _alloc) + : header(_alloc) + , polygon(_alloc) { + (void)_alloc; + } + + + + typedef ::std_msgs::Header_ _header_type; + _header_type header; + + typedef ::geometry_msgs::Polygon_ _polygon_type; + _polygon_type polygon; + + + + + typedef std::shared_ptr< ::geometry_msgs::PolygonStamped_ > Ptr; + typedef std::shared_ptr< ::geometry_msgs::PolygonStamped_ const> ConstPtr; + +}; // struct PolygonStamped_ + +typedef ::geometry_msgs::PolygonStamped_ > PolygonStamped; + +typedef std::shared_ptr< ::geometry_msgs::PolygonStamped > PolygonStampedPtr; +typedef std::shared_ptr< ::geometry_msgs::PolygonStamped const> PolygonStampedConstPtr; + +// constants requiring out of line definition + + + +template +std::ostream& operator<<(std::ostream& s, const ::geometry_msgs::PolygonStamped_ & v) +{ +ros::message_operations::Printer< ::geometry_msgs::PolygonStamped_ >::stream(s, "", v); +return s; +} + +} // namespace geometry_msgs + +namespace ros +{ +namespace message_traits +{ + + + +// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': True} +// {'std_msgs': ['/opt/ros/kinetic/share/std_msgs/cmake/../msg'], 'geometry_msgs': ['/tmp/binarydeb/ros-kinetic-geometry-msgs-1.12.5/msg']} + +// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types'] + + + + +template +struct IsFixedSize< ::geometry_msgs::PolygonStamped_ > + : FalseType + { }; + +template +struct IsFixedSize< ::geometry_msgs::PolygonStamped_ const> + : FalseType + { }; + +template +struct IsMessage< ::geometry_msgs::PolygonStamped_ > + : TrueType + { }; + +template +struct IsMessage< ::geometry_msgs::PolygonStamped_ const> + : TrueType + { }; + +template +struct HasHeader< ::geometry_msgs::PolygonStamped_ > + : TrueType + { }; + +template +struct HasHeader< ::geometry_msgs::PolygonStamped_ const> + : TrueType + { }; + + +template +struct MD5Sum< ::geometry_msgs::PolygonStamped_ > +{ + static const char* value() + { + return "c6be8f7dc3bee7fe9e8d296070f53340"; + } + + static const char* value(const ::geometry_msgs::PolygonStamped_&) { return value(); } + static const uint64_t static_value1 = 0xc6be8f7dc3bee7feULL; + static const uint64_t static_value2 = 0x9e8d296070f53340ULL; +}; + +template +struct DataType< ::geometry_msgs::PolygonStamped_ > +{ + static const char* value() + { + return "geometry_msgs/PolygonStamped"; + } + + static const char* value(const ::geometry_msgs::PolygonStamped_&) { return value(); } +}; + +template +struct Definition< ::geometry_msgs::PolygonStamped_ > +{ + static const char* value() + { + return "# This represents a Polygon with reference coordinate frame and timestamp\n\ +Header header\n\ +Polygon polygon\n\ +\n\ +================================================================================\n\ +MSG: std_msgs/Header\n\ +# Standard metadata for higher-level stamped data types.\n\ +# This is generally used to communicate timestamped data \n\ +# in a particular coordinate frame.\n\ +# \n\ +# sequence ID: consecutively increasing ID \n\ +uint32 seq\n\ +#Two-integer timestamp that is expressed as:\n\ +# * stamp.sec: seconds (stamp_secs) since epoch (in Python the variable is called 'secs')\n\ +# * stamp.nsec: nanoseconds since stamp_secs (in Python the variable is called 'nsecs')\n\ +# time-handling sugar is provided by the client library\n\ +time stamp\n\ +#Frame this data is associated with\n\ +# 0: no frame\n\ +# 1: global frame\n\ +string frame_id\n\ +\n\ +================================================================================\n\ +MSG: geometry_msgs/Polygon\n\ +#A specification of a polygon where the first and last points are assumed to be connected\n\ +Point32[] points\n\ +\n\ +================================================================================\n\ +MSG: geometry_msgs/Point32\n\ +# This contains the position of a point in free space(with 32 bits of precision).\n\ +# It is recommeded to use Point wherever possible instead of Point32. \n\ +# \n\ +# This recommendation is to promote interoperability. \n\ +#\n\ +# This message is designed to take up less space when sending\n\ +# lots of points at once, as in the case of a PointCloud. \n\ +\n\ +float32 x\n\ +float32 y\n\ +float32 z\n\ +"; + } + + static const char* value(const ::geometry_msgs::PolygonStamped_&) { return value(); } +}; + +} // namespace message_traits +} // namespace ros + +namespace ros +{ +namespace serialization +{ + + template struct Serializer< ::geometry_msgs::PolygonStamped_ > + { + template inline static void allInOne(Stream& stream, T m) + { + stream.next(m.header); + stream.next(m.polygon); + } + + ROS_DECLARE_ALLINONE_SERIALIZER; + }; // struct PolygonStamped_ + +} // namespace serialization +} // namespace ros + +namespace ros +{ +namespace message_operations +{ + +template +struct Printer< ::geometry_msgs::PolygonStamped_ > +{ + template static void stream(Stream& s, const std::string& indent, const ::geometry_msgs::PolygonStamped_& v) + { + s << indent << "header: "; + s << std::endl; + Printer< ::std_msgs::Header_ >::stream(s, indent + " ", v.header); + s << indent << "polygon: "; + s << std::endl; + Printer< ::geometry_msgs::Polygon_ >::stream(s, indent + " ", v.polygon); + } +}; + +} // namespace message_operations +} // namespace ros + +#endif // GEOMETRY_MSGS_MESSAGE_POLYGONSTAMPED_H diff --git a/realsense-file/src/storage/realsense_file/include/msgs/geometry_msgs/Pose.h b/realsense-file/src/storage/realsense_file/include/msgs/geometry_msgs/Pose.h new file mode 100644 index 0000000000..7a31fceb0f --- /dev/null +++ b/realsense-file/src/storage/realsense_file/include/msgs/geometry_msgs/Pose.h @@ -0,0 +1,216 @@ +// Generated by gencpp from file geometry_msgs/Pose.msg +// DO NOT EDIT! + + +#ifndef GEOMETRY_MSGS_MESSAGE_POSE_H +#define GEOMETRY_MSGS_MESSAGE_POSE_H + + +#include +#include +#include + +#include +#include +#include +#include + +#include +#include + +namespace geometry_msgs +{ +template +struct Pose_ +{ + typedef Pose_ Type; + + Pose_() + : position() + , orientation() { + } + Pose_(const ContainerAllocator& _alloc) + : position(_alloc) + , orientation(_alloc) { + (void)_alloc; + } + + + + typedef ::geometry_msgs::Point_ _position_type; + _position_type position; + + typedef ::geometry_msgs::Quaternion_ _orientation_type; + _orientation_type orientation; + + + + + typedef std::shared_ptr< ::geometry_msgs::Pose_ > Ptr; + typedef std::shared_ptr< ::geometry_msgs::Pose_ const> ConstPtr; + +}; // struct Pose_ + +typedef ::geometry_msgs::Pose_ > Pose; + +typedef std::shared_ptr< ::geometry_msgs::Pose > PosePtr; +typedef std::shared_ptr< ::geometry_msgs::Pose const> PoseConstPtr; + +// constants requiring out of line definition + + + +template +std::ostream& operator<<(std::ostream& s, const ::geometry_msgs::Pose_ & v) +{ +ros::message_operations::Printer< ::geometry_msgs::Pose_ >::stream(s, "", v); +return s; +} + +} // namespace geometry_msgs + +namespace ros +{ +namespace message_traits +{ + + + +// BOOLTRAITS {'IsFixedSize': True, 'IsMessage': True, 'HasHeader': False} +// {'std_msgs': ['/opt/ros/kinetic/share/std_msgs/cmake/../msg'], 'geometry_msgs': ['/tmp/binarydeb/ros-kinetic-geometry-msgs-1.12.5/msg']} + +// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types'] + + + + +template +struct IsFixedSize< ::geometry_msgs::Pose_ > + : TrueType + { }; + +template +struct IsFixedSize< ::geometry_msgs::Pose_ const> + : TrueType + { }; + +template +struct IsMessage< ::geometry_msgs::Pose_ > + : TrueType + { }; + +template +struct IsMessage< ::geometry_msgs::Pose_ const> + : TrueType + { }; + +template +struct HasHeader< ::geometry_msgs::Pose_ > + : FalseType + { }; + +template +struct HasHeader< ::geometry_msgs::Pose_ const> + : FalseType + { }; + + +template +struct MD5Sum< ::geometry_msgs::Pose_ > +{ + static const char* value() + { + return "e45d45a5a1ce597b249e23fb30fc871f"; + } + + static const char* value(const ::geometry_msgs::Pose_&) { return value(); } + static const uint64_t static_value1 = 0xe45d45a5a1ce597bULL; + static const uint64_t static_value2 = 0x249e23fb30fc871fULL; +}; + +template +struct DataType< ::geometry_msgs::Pose_ > +{ + static const char* value() + { + return "geometry_msgs/Pose"; + } + + static const char* value(const ::geometry_msgs::Pose_&) { return value(); } +}; + +template +struct Definition< ::geometry_msgs::Pose_ > +{ + static const char* value() + { + return "# A representation of pose in free space, composed of position and orientation. \n\ +Point position\n\ +Quaternion orientation\n\ +\n\ +================================================================================\n\ +MSG: geometry_msgs/Point\n\ +# This contains the position of a point in free space\n\ +float64 x\n\ +float64 y\n\ +float64 z\n\ +\n\ +================================================================================\n\ +MSG: geometry_msgs/Quaternion\n\ +# This represents an orientation in free space in quaternion form.\n\ +\n\ +float64 x\n\ +float64 y\n\ +float64 z\n\ +float64 w\n\ +"; + } + + static const char* value(const ::geometry_msgs::Pose_&) { return value(); } +}; + +} // namespace message_traits +} // namespace ros + +namespace ros +{ +namespace serialization +{ + + template struct Serializer< ::geometry_msgs::Pose_ > + { + template inline static void allInOne(Stream& stream, T m) + { + stream.next(m.position); + stream.next(m.orientation); + } + + ROS_DECLARE_ALLINONE_SERIALIZER; + }; // struct Pose_ + +} // namespace serialization +} // namespace ros + +namespace ros +{ +namespace message_operations +{ + +template +struct Printer< ::geometry_msgs::Pose_ > +{ + template static void stream(Stream& s, const std::string& indent, const ::geometry_msgs::Pose_& v) + { + s << indent << "position: "; + s << std::endl; + Printer< ::geometry_msgs::Point_ >::stream(s, indent + " ", v.position); + s << indent << "orientation: "; + s << std::endl; + Printer< ::geometry_msgs::Quaternion_ >::stream(s, indent + " ", v.orientation); + } +}; + +} // namespace message_operations +} // namespace ros + +#endif // GEOMETRY_MSGS_MESSAGE_POSE_H diff --git a/realsense-file/src/storage/realsense_file/include/msgs/geometry_msgs/Pose2D.h b/realsense-file/src/storage/realsense_file/include/msgs/geometry_msgs/Pose2D.h new file mode 100644 index 0000000000..471a5a0e20 --- /dev/null +++ b/realsense-file/src/storage/realsense_file/include/msgs/geometry_msgs/Pose2D.h @@ -0,0 +1,206 @@ +// Generated by gencpp from file geometry_msgs/Pose2D.msg +// DO NOT EDIT! + + +#ifndef GEOMETRY_MSGS_MESSAGE_POSE2D_H +#define GEOMETRY_MSGS_MESSAGE_POSE2D_H + + +#include +#include +#include + +#include +#include +#include +#include + + +namespace geometry_msgs +{ +template +struct Pose2D_ +{ + typedef Pose2D_ Type; + + Pose2D_() + : x(0.0) + , y(0.0) + , theta(0.0) { + } + Pose2D_(const ContainerAllocator& _alloc) + : x(0.0) + , y(0.0) + , theta(0.0) { + (void)_alloc; + } + + + + typedef double _x_type; + _x_type x; + + typedef double _y_type; + _y_type y; + + typedef double _theta_type; + _theta_type theta; + + + + + typedef std::shared_ptr< ::geometry_msgs::Pose2D_ > Ptr; + typedef std::shared_ptr< ::geometry_msgs::Pose2D_ const> ConstPtr; + +}; // struct Pose2D_ + +typedef ::geometry_msgs::Pose2D_ > Pose2D; + +typedef std::shared_ptr< ::geometry_msgs::Pose2D > Pose2DPtr; +typedef std::shared_ptr< ::geometry_msgs::Pose2D const> Pose2DConstPtr; + +// constants requiring out of line definition + + + +template +std::ostream& operator<<(std::ostream& s, const ::geometry_msgs::Pose2D_ & v) +{ +ros::message_operations::Printer< ::geometry_msgs::Pose2D_ >::stream(s, "", v); +return s; +} + +} // namespace geometry_msgs + +namespace ros +{ +namespace message_traits +{ + + + +// BOOLTRAITS {'IsFixedSize': True, 'IsMessage': True, 'HasHeader': False} +// {'std_msgs': ['/opt/ros/kinetic/share/std_msgs/cmake/../msg'], 'geometry_msgs': ['/tmp/binarydeb/ros-kinetic-geometry-msgs-1.12.5/msg']} + +// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types'] + + + + +template +struct IsFixedSize< ::geometry_msgs::Pose2D_ > + : TrueType + { }; + +template +struct IsFixedSize< ::geometry_msgs::Pose2D_ const> + : TrueType + { }; + +template +struct IsMessage< ::geometry_msgs::Pose2D_ > + : TrueType + { }; + +template +struct IsMessage< ::geometry_msgs::Pose2D_ const> + : TrueType + { }; + +template +struct HasHeader< ::geometry_msgs::Pose2D_ > + : FalseType + { }; + +template +struct HasHeader< ::geometry_msgs::Pose2D_ const> + : FalseType + { }; + + +template +struct MD5Sum< ::geometry_msgs::Pose2D_ > +{ + static const char* value() + { + return "938fa65709584ad8e77d238529be13b8"; + } + + static const char* value(const ::geometry_msgs::Pose2D_&) { return value(); } + static const uint64_t static_value1 = 0x938fa65709584ad8ULL; + static const uint64_t static_value2 = 0xe77d238529be13b8ULL; +}; + +template +struct DataType< ::geometry_msgs::Pose2D_ > +{ + static const char* value() + { + return "geometry_msgs/Pose2D"; + } + + static const char* value(const ::geometry_msgs::Pose2D_&) { return value(); } +}; + +template +struct Definition< ::geometry_msgs::Pose2D_ > +{ + static const char* value() + { + return "# This expresses a position and orientation on a 2D manifold.\n\ +\n\ +float64 x\n\ +float64 y\n\ +float64 theta\n\ +"; + } + + static const char* value(const ::geometry_msgs::Pose2D_&) { return value(); } +}; + +} // namespace message_traits +} // namespace ros + +namespace ros +{ +namespace serialization +{ + + template struct Serializer< ::geometry_msgs::Pose2D_ > + { + template inline static void allInOne(Stream& stream, T m) + { + stream.next(m.x); + stream.next(m.y); + stream.next(m.theta); + } + + ROS_DECLARE_ALLINONE_SERIALIZER; + }; // struct Pose2D_ + +} // namespace serialization +} // namespace ros + +namespace ros +{ +namespace message_operations +{ + +template +struct Printer< ::geometry_msgs::Pose2D_ > +{ + template static void stream(Stream& s, const std::string& indent, const ::geometry_msgs::Pose2D_& v) + { + s << indent << "x: "; + Printer::stream(s, indent + " ", v.x); + s << indent << "y: "; + Printer::stream(s, indent + " ", v.y); + s << indent << "theta: "; + Printer::stream(s, indent + " ", v.theta); + } +}; + +} // namespace message_operations +} // namespace ros + +#endif // GEOMETRY_MSGS_MESSAGE_POSE2D_H diff --git a/realsense-file/src/storage/realsense_file/include/msgs/geometry_msgs/PoseArray.h b/realsense-file/src/storage/realsense_file/include/msgs/geometry_msgs/PoseArray.h new file mode 100644 index 0000000000..ff6be2ed13 --- /dev/null +++ b/realsense-file/src/storage/realsense_file/include/msgs/geometry_msgs/PoseArray.h @@ -0,0 +1,247 @@ +// Generated by gencpp from file geometry_msgs/PoseArray.msg +// DO NOT EDIT! + + +#ifndef GEOMETRY_MSGS_MESSAGE_POSEARRAY_H +#define GEOMETRY_MSGS_MESSAGE_POSEARRAY_H + + +#include +#include +#include + +#include +#include +#include +#include + +#include +#include + +namespace geometry_msgs +{ +template +struct PoseArray_ +{ + typedef PoseArray_ Type; + + PoseArray_() + : header() + , poses() { + } + PoseArray_(const ContainerAllocator& _alloc) + : header(_alloc) + , poses(_alloc) { + (void)_alloc; + } + + + + typedef ::std_msgs::Header_ _header_type; + _header_type header; + + typedef std::vector< ::geometry_msgs::Pose_ , typename ContainerAllocator::template rebind< ::geometry_msgs::Pose_ >::other > _poses_type; + _poses_type poses; + + + + + typedef std::shared_ptr< ::geometry_msgs::PoseArray_ > Ptr; + typedef std::shared_ptr< ::geometry_msgs::PoseArray_ const> ConstPtr; + +}; // struct PoseArray_ + +typedef ::geometry_msgs::PoseArray_ > PoseArray; + +typedef std::shared_ptr< ::geometry_msgs::PoseArray > PoseArrayPtr; +typedef std::shared_ptr< ::geometry_msgs::PoseArray const> PoseArrayConstPtr; + +// constants requiring out of line definition + + + +template +std::ostream& operator<<(std::ostream& s, const ::geometry_msgs::PoseArray_ & v) +{ +ros::message_operations::Printer< ::geometry_msgs::PoseArray_ >::stream(s, "", v); +return s; +} + +} // namespace geometry_msgs + +namespace ros +{ +namespace message_traits +{ + + + +// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': True} +// {'std_msgs': ['/opt/ros/kinetic/share/std_msgs/cmake/../msg'], 'geometry_msgs': ['/tmp/binarydeb/ros-kinetic-geometry-msgs-1.12.5/msg']} + +// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types'] + + + + +template +struct IsFixedSize< ::geometry_msgs::PoseArray_ > + : FalseType + { }; + +template +struct IsFixedSize< ::geometry_msgs::PoseArray_ const> + : FalseType + { }; + +template +struct IsMessage< ::geometry_msgs::PoseArray_ > + : TrueType + { }; + +template +struct IsMessage< ::geometry_msgs::PoseArray_ const> + : TrueType + { }; + +template +struct HasHeader< ::geometry_msgs::PoseArray_ > + : TrueType + { }; + +template +struct HasHeader< ::geometry_msgs::PoseArray_ const> + : TrueType + { }; + + +template +struct MD5Sum< ::geometry_msgs::PoseArray_ > +{ + static const char* value() + { + return "916c28c5764443f268b296bb671b9d97"; + } + + static const char* value(const ::geometry_msgs::PoseArray_&) { return value(); } + static const uint64_t static_value1 = 0x916c28c5764443f2ULL; + static const uint64_t static_value2 = 0x68b296bb671b9d97ULL; +}; + +template +struct DataType< ::geometry_msgs::PoseArray_ > +{ + static const char* value() + { + return "geometry_msgs/PoseArray"; + } + + static const char* value(const ::geometry_msgs::PoseArray_&) { return value(); } +}; + +template +struct Definition< ::geometry_msgs::PoseArray_ > +{ + static const char* value() + { + return "# An array of poses with a header for global reference.\n\ +\n\ +Header header\n\ +\n\ +Pose[] poses\n\ +\n\ +================================================================================\n\ +MSG: std_msgs/Header\n\ +# Standard metadata for higher-level stamped data types.\n\ +# This is generally used to communicate timestamped data \n\ +# in a particular coordinate frame.\n\ +# \n\ +# sequence ID: consecutively increasing ID \n\ +uint32 seq\n\ +#Two-integer timestamp that is expressed as:\n\ +# * stamp.sec: seconds (stamp_secs) since epoch (in Python the variable is called 'secs')\n\ +# * stamp.nsec: nanoseconds since stamp_secs (in Python the variable is called 'nsecs')\n\ +# time-handling sugar is provided by the client library\n\ +time stamp\n\ +#Frame this data is associated with\n\ +# 0: no frame\n\ +# 1: global frame\n\ +string frame_id\n\ +\n\ +================================================================================\n\ +MSG: geometry_msgs/Pose\n\ +# A representation of pose in free space, composed of position and orientation. \n\ +Point position\n\ +Quaternion orientation\n\ +\n\ +================================================================================\n\ +MSG: geometry_msgs/Point\n\ +# This contains the position of a point in free space\n\ +float64 x\n\ +float64 y\n\ +float64 z\n\ +\n\ +================================================================================\n\ +MSG: geometry_msgs/Quaternion\n\ +# This represents an orientation in free space in quaternion form.\n\ +\n\ +float64 x\n\ +float64 y\n\ +float64 z\n\ +float64 w\n\ +"; + } + + static const char* value(const ::geometry_msgs::PoseArray_&) { return value(); } +}; + +} // namespace message_traits +} // namespace ros + +namespace ros +{ +namespace serialization +{ + + template struct Serializer< ::geometry_msgs::PoseArray_ > + { + template inline static void allInOne(Stream& stream, T m) + { + stream.next(m.header); + stream.next(m.poses); + } + + ROS_DECLARE_ALLINONE_SERIALIZER; + }; // struct PoseArray_ + +} // namespace serialization +} // namespace ros + +namespace ros +{ +namespace message_operations +{ + +template +struct Printer< ::geometry_msgs::PoseArray_ > +{ + template static void stream(Stream& s, const std::string& indent, const ::geometry_msgs::PoseArray_& v) + { + s << indent << "header: "; + s << std::endl; + Printer< ::std_msgs::Header_ >::stream(s, indent + " ", v.header); + s << indent << "poses[]" << std::endl; + for (size_t i = 0; i < v.poses.size(); ++i) + { + s << indent << " poses[" << i << "]: "; + s << std::endl; + s << indent; + Printer< ::geometry_msgs::Pose_ >::stream(s, indent + " ", v.poses[i]); + } + } +}; + +} // namespace message_operations +} // namespace ros + +#endif // GEOMETRY_MSGS_MESSAGE_POSEARRAY_H diff --git a/realsense-file/src/storage/realsense_file/include/msgs/geometry_msgs/PoseStamped.h b/realsense-file/src/storage/realsense_file/include/msgs/geometry_msgs/PoseStamped.h new file mode 100644 index 0000000000..4cf9ad34bf --- /dev/null +++ b/realsense-file/src/storage/realsense_file/include/msgs/geometry_msgs/PoseStamped.h @@ -0,0 +1,240 @@ +// Generated by gencpp from file geometry_msgs/PoseStamped.msg +// DO NOT EDIT! + + +#ifndef GEOMETRY_MSGS_MESSAGE_POSESTAMPED_H +#define GEOMETRY_MSGS_MESSAGE_POSESTAMPED_H + + +#include +#include +#include + +#include +#include +#include +#include + +#include +#include + +namespace geometry_msgs +{ +template +struct PoseStamped_ +{ + typedef PoseStamped_ Type; + + PoseStamped_() + : header() + , pose() { + } + PoseStamped_(const ContainerAllocator& _alloc) + : header(_alloc) + , pose(_alloc) { + (void)_alloc; + } + + + + typedef ::std_msgs::Header_ _header_type; + _header_type header; + + typedef ::geometry_msgs::Pose_ _pose_type; + _pose_type pose; + + + + + typedef std::shared_ptr< ::geometry_msgs::PoseStamped_ > Ptr; + typedef std::shared_ptr< ::geometry_msgs::PoseStamped_ const> ConstPtr; + +}; // struct PoseStamped_ + +typedef ::geometry_msgs::PoseStamped_ > PoseStamped; + +typedef std::shared_ptr< ::geometry_msgs::PoseStamped > PoseStampedPtr; +typedef std::shared_ptr< ::geometry_msgs::PoseStamped const> PoseStampedConstPtr; + +// constants requiring out of line definition + + + +template +std::ostream& operator<<(std::ostream& s, const ::geometry_msgs::PoseStamped_ & v) +{ +ros::message_operations::Printer< ::geometry_msgs::PoseStamped_ >::stream(s, "", v); +return s; +} + +} // namespace geometry_msgs + +namespace ros +{ +namespace message_traits +{ + + + +// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': True} +// {'std_msgs': ['/opt/ros/kinetic/share/std_msgs/cmake/../msg'], 'geometry_msgs': ['/tmp/binarydeb/ros-kinetic-geometry-msgs-1.12.5/msg']} + +// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types'] + + + + +template +struct IsFixedSize< ::geometry_msgs::PoseStamped_ > + : FalseType + { }; + +template +struct IsFixedSize< ::geometry_msgs::PoseStamped_ const> + : FalseType + { }; + +template +struct IsMessage< ::geometry_msgs::PoseStamped_ > + : TrueType + { }; + +template +struct IsMessage< ::geometry_msgs::PoseStamped_ const> + : TrueType + { }; + +template +struct HasHeader< ::geometry_msgs::PoseStamped_ > + : TrueType + { }; + +template +struct HasHeader< ::geometry_msgs::PoseStamped_ const> + : TrueType + { }; + + +template +struct MD5Sum< ::geometry_msgs::PoseStamped_ > +{ + static const char* value() + { + return "d3812c3cbc69362b77dc0b19b345f8f5"; + } + + static const char* value(const ::geometry_msgs::PoseStamped_&) { return value(); } + static const uint64_t static_value1 = 0xd3812c3cbc69362bULL; + static const uint64_t static_value2 = 0x77dc0b19b345f8f5ULL; +}; + +template +struct DataType< ::geometry_msgs::PoseStamped_ > +{ + static const char* value() + { + return "geometry_msgs/PoseStamped"; + } + + static const char* value(const ::geometry_msgs::PoseStamped_&) { return value(); } +}; + +template +struct Definition< ::geometry_msgs::PoseStamped_ > +{ + static const char* value() + { + return "# A Pose with reference coordinate frame and timestamp\n\ +Header header\n\ +Pose pose\n\ +\n\ +================================================================================\n\ +MSG: std_msgs/Header\n\ +# Standard metadata for higher-level stamped data types.\n\ +# This is generally used to communicate timestamped data \n\ +# in a particular coordinate frame.\n\ +# \n\ +# sequence ID: consecutively increasing ID \n\ +uint32 seq\n\ +#Two-integer timestamp that is expressed as:\n\ +# * stamp.sec: seconds (stamp_secs) since epoch (in Python the variable is called 'secs')\n\ +# * stamp.nsec: nanoseconds since stamp_secs (in Python the variable is called 'nsecs')\n\ +# time-handling sugar is provided by the client library\n\ +time stamp\n\ +#Frame this data is associated with\n\ +# 0: no frame\n\ +# 1: global frame\n\ +string frame_id\n\ +\n\ +================================================================================\n\ +MSG: geometry_msgs/Pose\n\ +# A representation of pose in free space, composed of position and orientation. \n\ +Point position\n\ +Quaternion orientation\n\ +\n\ +================================================================================\n\ +MSG: geometry_msgs/Point\n\ +# This contains the position of a point in free space\n\ +float64 x\n\ +float64 y\n\ +float64 z\n\ +\n\ +================================================================================\n\ +MSG: geometry_msgs/Quaternion\n\ +# This represents an orientation in free space in quaternion form.\n\ +\n\ +float64 x\n\ +float64 y\n\ +float64 z\n\ +float64 w\n\ +"; + } + + static const char* value(const ::geometry_msgs::PoseStamped_&) { return value(); } +}; + +} // namespace message_traits +} // namespace ros + +namespace ros +{ +namespace serialization +{ + + template struct Serializer< ::geometry_msgs::PoseStamped_ > + { + template inline static void allInOne(Stream& stream, T m) + { + stream.next(m.header); + stream.next(m.pose); + } + + ROS_DECLARE_ALLINONE_SERIALIZER; + }; // struct PoseStamped_ + +} // namespace serialization +} // namespace ros + +namespace ros +{ +namespace message_operations +{ + +template +struct Printer< ::geometry_msgs::PoseStamped_ > +{ + template static void stream(Stream& s, const std::string& indent, const ::geometry_msgs::PoseStamped_& v) + { + s << indent << "header: "; + s << std::endl; + Printer< ::std_msgs::Header_ >::stream(s, indent + " ", v.header); + s << indent << "pose: "; + s << std::endl; + Printer< ::geometry_msgs::Pose_ >::stream(s, indent + " ", v.pose); + } +}; + +} // namespace message_operations +} // namespace ros + +#endif // GEOMETRY_MSGS_MESSAGE_POSESTAMPED_H diff --git a/realsense-file/src/storage/realsense_file/include/msgs/geometry_msgs/PoseWithCovariance.h b/realsense-file/src/storage/realsense_file/include/msgs/geometry_msgs/PoseWithCovariance.h new file mode 100644 index 0000000000..bf3d2fa40a --- /dev/null +++ b/realsense-file/src/storage/realsense_file/include/msgs/geometry_msgs/PoseWithCovariance.h @@ -0,0 +1,232 @@ +// Generated by gencpp from file geometry_msgs/PoseWithCovariance.msg +// DO NOT EDIT! + + +#ifndef GEOMETRY_MSGS_MESSAGE_POSEWITHCOVARIANCE_H +#define GEOMETRY_MSGS_MESSAGE_POSEWITHCOVARIANCE_H + + +#include +#include +#include + +#include +#include +#include +#include + +#include + +namespace geometry_msgs +{ +template +struct PoseWithCovariance_ +{ + typedef PoseWithCovariance_ Type; + + PoseWithCovariance_() + : pose() + , covariance() { + covariance.assign(0.0); + } + PoseWithCovariance_(const ContainerAllocator& _alloc) + : pose(_alloc) + , covariance() { + (void)_alloc; + covariance.assign(0.0); + } + + + + typedef ::geometry_msgs::Pose_ _pose_type; + _pose_type pose; + + typedef boost::array _covariance_type; + _covariance_type covariance; + + + + + typedef std::shared_ptr< ::geometry_msgs::PoseWithCovariance_ > Ptr; + typedef std::shared_ptr< ::geometry_msgs::PoseWithCovariance_ const> ConstPtr; + +}; // struct PoseWithCovariance_ + +typedef ::geometry_msgs::PoseWithCovariance_ > PoseWithCovariance; + +typedef std::shared_ptr< ::geometry_msgs::PoseWithCovariance > PoseWithCovariancePtr; +typedef std::shared_ptr< ::geometry_msgs::PoseWithCovariance const> PoseWithCovarianceConstPtr; + +// constants requiring out of line definition + + + +template +std::ostream& operator<<(std::ostream& s, const ::geometry_msgs::PoseWithCovariance_ & v) +{ +ros::message_operations::Printer< ::geometry_msgs::PoseWithCovariance_ >::stream(s, "", v); +return s; +} + +} // namespace geometry_msgs + +namespace ros +{ +namespace message_traits +{ + + + +// BOOLTRAITS {'IsFixedSize': True, 'IsMessage': True, 'HasHeader': False} +// {'std_msgs': ['/opt/ros/kinetic/share/std_msgs/cmake/../msg'], 'geometry_msgs': ['/tmp/binarydeb/ros-kinetic-geometry-msgs-1.12.5/msg']} + +// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types'] + + + + +template +struct IsFixedSize< ::geometry_msgs::PoseWithCovariance_ > + : TrueType + { }; + +template +struct IsFixedSize< ::geometry_msgs::PoseWithCovariance_ const> + : TrueType + { }; + +template +struct IsMessage< ::geometry_msgs::PoseWithCovariance_ > + : TrueType + { }; + +template +struct IsMessage< ::geometry_msgs::PoseWithCovariance_ const> + : TrueType + { }; + +template +struct HasHeader< ::geometry_msgs::PoseWithCovariance_ > + : FalseType + { }; + +template +struct HasHeader< ::geometry_msgs::PoseWithCovariance_ const> + : FalseType + { }; + + +template +struct MD5Sum< ::geometry_msgs::PoseWithCovariance_ > +{ + static const char* value() + { + return "c23e848cf1b7533a8d7c259073a97e6f"; + } + + static const char* value(const ::geometry_msgs::PoseWithCovariance_&) { return value(); } + static const uint64_t static_value1 = 0xc23e848cf1b7533aULL; + static const uint64_t static_value2 = 0x8d7c259073a97e6fULL; +}; + +template +struct DataType< ::geometry_msgs::PoseWithCovariance_ > +{ + static const char* value() + { + return "geometry_msgs/PoseWithCovariance"; + } + + static const char* value(const ::geometry_msgs::PoseWithCovariance_&) { return value(); } +}; + +template +struct Definition< ::geometry_msgs::PoseWithCovariance_ > +{ + static const char* value() + { + return "# This represents a pose in free space with uncertainty.\n\ +\n\ +Pose pose\n\ +\n\ +# Row-major representation of the 6x6 covariance matrix\n\ +# The orientation parameters use a fixed-axis representation.\n\ +# In order, the parameters are:\n\ +# (x, y, z, rotation about X axis, rotation about Y axis, rotation about Z axis)\n\ +float64[36] covariance\n\ +\n\ +================================================================================\n\ +MSG: geometry_msgs/Pose\n\ +# A representation of pose in free space, composed of position and orientation. \n\ +Point position\n\ +Quaternion orientation\n\ +\n\ +================================================================================\n\ +MSG: geometry_msgs/Point\n\ +# This contains the position of a point in free space\n\ +float64 x\n\ +float64 y\n\ +float64 z\n\ +\n\ +================================================================================\n\ +MSG: geometry_msgs/Quaternion\n\ +# This represents an orientation in free space in quaternion form.\n\ +\n\ +float64 x\n\ +float64 y\n\ +float64 z\n\ +float64 w\n\ +"; + } + + static const char* value(const ::geometry_msgs::PoseWithCovariance_&) { return value(); } +}; + +} // namespace message_traits +} // namespace ros + +namespace ros +{ +namespace serialization +{ + + template struct Serializer< ::geometry_msgs::PoseWithCovariance_ > + { + template inline static void allInOne(Stream& stream, T m) + { + stream.next(m.pose); + stream.next(m.covariance); + } + + ROS_DECLARE_ALLINONE_SERIALIZER; + }; // struct PoseWithCovariance_ + +} // namespace serialization +} // namespace ros + +namespace ros +{ +namespace message_operations +{ + +template +struct Printer< ::geometry_msgs::PoseWithCovariance_ > +{ + template static void stream(Stream& s, const std::string& indent, const ::geometry_msgs::PoseWithCovariance_& v) + { + s << indent << "pose: "; + s << std::endl; + Printer< ::geometry_msgs::Pose_ >::stream(s, indent + " ", v.pose); + s << indent << "covariance[]" << std::endl; + for (size_t i = 0; i < v.covariance.size(); ++i) + { + s << indent << " covariance[" << i << "]: "; + Printer::stream(s, indent + " ", v.covariance[i]); + } + } +}; + +} // namespace message_operations +} // namespace ros + +#endif // GEOMETRY_MSGS_MESSAGE_POSEWITHCOVARIANCE_H diff --git a/realsense-file/src/storage/realsense_file/include/msgs/geometry_msgs/PoseWithCovarianceStamped.h b/realsense-file/src/storage/realsense_file/include/msgs/geometry_msgs/PoseWithCovarianceStamped.h new file mode 100644 index 0000000000..0e38ce21bb --- /dev/null +++ b/realsense-file/src/storage/realsense_file/include/msgs/geometry_msgs/PoseWithCovarianceStamped.h @@ -0,0 +1,253 @@ +// Generated by gencpp from file geometry_msgs/PoseWithCovarianceStamped.msg +// DO NOT EDIT! + + +#ifndef GEOMETRY_MSGS_MESSAGE_POSEWITHCOVARIANCESTAMPED_H +#define GEOMETRY_MSGS_MESSAGE_POSEWITHCOVARIANCESTAMPED_H + + +#include +#include +#include + +#include +#include +#include +#include + +#include +#include + +namespace geometry_msgs +{ +template +struct PoseWithCovarianceStamped_ +{ + typedef PoseWithCovarianceStamped_ Type; + + PoseWithCovarianceStamped_() + : header() + , pose() { + } + PoseWithCovarianceStamped_(const ContainerAllocator& _alloc) + : header(_alloc) + , pose(_alloc) { + (void)_alloc; + } + + + + typedef ::std_msgs::Header_ _header_type; + _header_type header; + + typedef ::geometry_msgs::PoseWithCovariance_ _pose_type; + _pose_type pose; + + + + + typedef std::shared_ptr< ::geometry_msgs::PoseWithCovarianceStamped_ > Ptr; + typedef std::shared_ptr< ::geometry_msgs::PoseWithCovarianceStamped_ const> ConstPtr; + +}; // struct PoseWithCovarianceStamped_ + +typedef ::geometry_msgs::PoseWithCovarianceStamped_ > PoseWithCovarianceStamped; + +typedef std::shared_ptr< ::geometry_msgs::PoseWithCovarianceStamped > PoseWithCovarianceStampedPtr; +typedef std::shared_ptr< ::geometry_msgs::PoseWithCovarianceStamped const> PoseWithCovarianceStampedConstPtr; + +// constants requiring out of line definition + + + +template +std::ostream& operator<<(std::ostream& s, const ::geometry_msgs::PoseWithCovarianceStamped_ & v) +{ +ros::message_operations::Printer< ::geometry_msgs::PoseWithCovarianceStamped_ >::stream(s, "", v); +return s; +} + +} // namespace geometry_msgs + +namespace ros +{ +namespace message_traits +{ + + + +// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': True} +// {'std_msgs': ['/opt/ros/kinetic/share/std_msgs/cmake/../msg'], 'geometry_msgs': ['/tmp/binarydeb/ros-kinetic-geometry-msgs-1.12.5/msg']} + +// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types'] + + + + +template +struct IsFixedSize< ::geometry_msgs::PoseWithCovarianceStamped_ > + : FalseType + { }; + +template +struct IsFixedSize< ::geometry_msgs::PoseWithCovarianceStamped_ const> + : FalseType + { }; + +template +struct IsMessage< ::geometry_msgs::PoseWithCovarianceStamped_ > + : TrueType + { }; + +template +struct IsMessage< ::geometry_msgs::PoseWithCovarianceStamped_ const> + : TrueType + { }; + +template +struct HasHeader< ::geometry_msgs::PoseWithCovarianceStamped_ > + : TrueType + { }; + +template +struct HasHeader< ::geometry_msgs::PoseWithCovarianceStamped_ const> + : TrueType + { }; + + +template +struct MD5Sum< ::geometry_msgs::PoseWithCovarianceStamped_ > +{ + static const char* value() + { + return "953b798c0f514ff060a53a3498ce6246"; + } + + static const char* value(const ::geometry_msgs::PoseWithCovarianceStamped_&) { return value(); } + static const uint64_t static_value1 = 0x953b798c0f514ff0ULL; + static const uint64_t static_value2 = 0x60a53a3498ce6246ULL; +}; + +template +struct DataType< ::geometry_msgs::PoseWithCovarianceStamped_ > +{ + static const char* value() + { + return "geometry_msgs/PoseWithCovarianceStamped"; + } + + static const char* value(const ::geometry_msgs::PoseWithCovarianceStamped_&) { return value(); } +}; + +template +struct Definition< ::geometry_msgs::PoseWithCovarianceStamped_ > +{ + static const char* value() + { + return "# This expresses an estimated pose with a reference coordinate frame and timestamp\n\ +\n\ +Header header\n\ +PoseWithCovariance pose\n\ +\n\ +================================================================================\n\ +MSG: std_msgs/Header\n\ +# Standard metadata for higher-level stamped data types.\n\ +# This is generally used to communicate timestamped data \n\ +# in a particular coordinate frame.\n\ +# \n\ +# sequence ID: consecutively increasing ID \n\ +uint32 seq\n\ +#Two-integer timestamp that is expressed as:\n\ +# * stamp.sec: seconds (stamp_secs) since epoch (in Python the variable is called 'secs')\n\ +# * stamp.nsec: nanoseconds since stamp_secs (in Python the variable is called 'nsecs')\n\ +# time-handling sugar is provided by the client library\n\ +time stamp\n\ +#Frame this data is associated with\n\ +# 0: no frame\n\ +# 1: global frame\n\ +string frame_id\n\ +\n\ +================================================================================\n\ +MSG: geometry_msgs/PoseWithCovariance\n\ +# This represents a pose in free space with uncertainty.\n\ +\n\ +Pose pose\n\ +\n\ +# Row-major representation of the 6x6 covariance matrix\n\ +# The orientation parameters use a fixed-axis representation.\n\ +# In order, the parameters are:\n\ +# (x, y, z, rotation about X axis, rotation about Y axis, rotation about Z axis)\n\ +float64[36] covariance\n\ +\n\ +================================================================================\n\ +MSG: geometry_msgs/Pose\n\ +# A representation of pose in free space, composed of position and orientation. \n\ +Point position\n\ +Quaternion orientation\n\ +\n\ +================================================================================\n\ +MSG: geometry_msgs/Point\n\ +# This contains the position of a point in free space\n\ +float64 x\n\ +float64 y\n\ +float64 z\n\ +\n\ +================================================================================\n\ +MSG: geometry_msgs/Quaternion\n\ +# This represents an orientation in free space in quaternion form.\n\ +\n\ +float64 x\n\ +float64 y\n\ +float64 z\n\ +float64 w\n\ +"; + } + + static const char* value(const ::geometry_msgs::PoseWithCovarianceStamped_&) { return value(); } +}; + +} // namespace message_traits +} // namespace ros + +namespace ros +{ +namespace serialization +{ + + template struct Serializer< ::geometry_msgs::PoseWithCovarianceStamped_ > + { + template inline static void allInOne(Stream& stream, T m) + { + stream.next(m.header); + stream.next(m.pose); + } + + ROS_DECLARE_ALLINONE_SERIALIZER; + }; // struct PoseWithCovarianceStamped_ + +} // namespace serialization +} // namespace ros + +namespace ros +{ +namespace message_operations +{ + +template +struct Printer< ::geometry_msgs::PoseWithCovarianceStamped_ > +{ + template static void stream(Stream& s, const std::string& indent, const ::geometry_msgs::PoseWithCovarianceStamped_& v) + { + s << indent << "header: "; + s << std::endl; + Printer< ::std_msgs::Header_ >::stream(s, indent + " ", v.header); + s << indent << "pose: "; + s << std::endl; + Printer< ::geometry_msgs::PoseWithCovariance_ >::stream(s, indent + " ", v.pose); + } +}; + +} // namespace message_operations +} // namespace ros + +#endif // GEOMETRY_MSGS_MESSAGE_POSEWITHCOVARIANCESTAMPED_H diff --git a/realsense-file/src/storage/realsense_file/include/msgs/geometry_msgs/Quaternion.h b/realsense-file/src/storage/realsense_file/include/msgs/geometry_msgs/Quaternion.h new file mode 100644 index 0000000000..038b415fa8 --- /dev/null +++ b/realsense-file/src/storage/realsense_file/include/msgs/geometry_msgs/Quaternion.h @@ -0,0 +1,215 @@ +// Generated by gencpp from file geometry_msgs/Quaternion.msg +// DO NOT EDIT! + + +#ifndef GEOMETRY_MSGS_MESSAGE_QUATERNION_H +#define GEOMETRY_MSGS_MESSAGE_QUATERNION_H + +#include +#include +#include +#include + +#include +#include +#include +#include + + +namespace geometry_msgs +{ +template +struct Quaternion_ +{ + typedef Quaternion_ Type; + + Quaternion_() + : x(0.0) + , y(0.0) + , z(0.0) + , w(0.0) { + } + Quaternion_(const ContainerAllocator& _alloc) + : x(0.0) + , y(0.0) + , z(0.0) + , w(0.0) { + (void)_alloc; + } + + + + typedef double _x_type; + _x_type x; + + typedef double _y_type; + _y_type y; + + typedef double _z_type; + _z_type z; + + typedef double _w_type; + _w_type w; + + + + + typedef std::shared_ptr< ::geometry_msgs::Quaternion_ > Ptr; + typedef std::shared_ptr< ::geometry_msgs::Quaternion_ const> ConstPtr; + +}; // struct Quaternion_ + +typedef ::geometry_msgs::Quaternion_ > Quaternion; + +typedef std::shared_ptr< ::geometry_msgs::Quaternion > QuaternionPtr; +typedef std::shared_ptr< ::geometry_msgs::Quaternion const> QuaternionConstPtr; + +// constants requiring out of line definition + + + +template +std::ostream& operator<<(std::ostream& s, const ::geometry_msgs::Quaternion_ & v) +{ +ros::message_operations::Printer< ::geometry_msgs::Quaternion_ >::stream(s, "", v); +return s; +} + +} // namespace geometry_msgs + +namespace ros +{ +namespace message_traits +{ + + + +// BOOLTRAITS {'IsFixedSize': True, 'IsMessage': True, 'HasHeader': False} +// {'std_msgs': ['/opt/ros/kinetic/share/std_msgs/cmake/../msg'], 'geometry_msgs': ['/tmp/binarydeb/ros-kinetic-geometry-msgs-1.12.5/msg']} + +// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types'] + + + + +template +struct IsFixedSize< ::geometry_msgs::Quaternion_ > + : TrueType + { }; + +template +struct IsFixedSize< ::geometry_msgs::Quaternion_ const> + : TrueType + { }; + +template +struct IsMessage< ::geometry_msgs::Quaternion_ > + : TrueType + { }; + +template +struct IsMessage< ::geometry_msgs::Quaternion_ const> + : TrueType + { }; + +template +struct HasHeader< ::geometry_msgs::Quaternion_ > + : FalseType + { }; + +template +struct HasHeader< ::geometry_msgs::Quaternion_ const> + : FalseType + { }; + + +template +struct MD5Sum< ::geometry_msgs::Quaternion_ > +{ + static const char* value() + { + return "a779879fadf0160734f906b8c19c7004"; + } + + static const char* value(const ::geometry_msgs::Quaternion_&) { return value(); } + static const uint64_t static_value1 = 0xa779879fadf01607ULL; + static const uint64_t static_value2 = 0x34f906b8c19c7004ULL; +}; + +template +struct DataType< ::geometry_msgs::Quaternion_ > +{ + static const char* value() + { + return "geometry_msgs/Quaternion"; + } + + static const char* value(const ::geometry_msgs::Quaternion_&) { return value(); } +}; + +template +struct Definition< ::geometry_msgs::Quaternion_ > +{ + static const char* value() + { + return "# This represents an orientation in free space in quaternion form.\n\ +\n\ +float64 x\n\ +float64 y\n\ +float64 z\n\ +float64 w\n\ +"; + } + + static const char* value(const ::geometry_msgs::Quaternion_&) { return value(); } +}; + +} // namespace message_traits +} // namespace ros + +namespace ros +{ +namespace serialization +{ + + template struct Serializer< ::geometry_msgs::Quaternion_ > + { + template inline static void allInOne(Stream& stream, T m) + { + stream.next(m.x); + stream.next(m.y); + stream.next(m.z); + stream.next(m.w); + } + + ROS_DECLARE_ALLINONE_SERIALIZER; + }; // struct Quaternion_ + +} // namespace serialization +} // namespace ros + +namespace ros +{ +namespace message_operations +{ + +template +struct Printer< ::geometry_msgs::Quaternion_ > +{ + template static void stream(Stream& s, const std::string& indent, const ::geometry_msgs::Quaternion_& v) + { + s << indent << "x: "; + Printer::stream(s, indent + " ", v.x); + s << indent << "y: "; + Printer::stream(s, indent + " ", v.y); + s << indent << "z: "; + Printer::stream(s, indent + " ", v.z); + s << indent << "w: "; + Printer::stream(s, indent + " ", v.w); + } +}; + +} // namespace message_operations +} // namespace ros + +#endif // GEOMETRY_MSGS_MESSAGE_QUATERNION_H diff --git a/realsense-file/src/storage/realsense_file/include/msgs/geometry_msgs/QuaternionStamped.h b/realsense-file/src/storage/realsense_file/include/msgs/geometry_msgs/QuaternionStamped.h new file mode 100644 index 0000000000..b44ff67a8d --- /dev/null +++ b/realsense-file/src/storage/realsense_file/include/msgs/geometry_msgs/QuaternionStamped.h @@ -0,0 +1,228 @@ +// Generated by gencpp from file geometry_msgs/QuaternionStamped.msg +// DO NOT EDIT! + + +#ifndef GEOMETRY_MSGS_MESSAGE_QUATERNIONSTAMPED_H +#define GEOMETRY_MSGS_MESSAGE_QUATERNIONSTAMPED_H + + +#include +#include +#include + +#include +#include +#include +#include + +#include +#include + +namespace geometry_msgs +{ +template +struct QuaternionStamped_ +{ + typedef QuaternionStamped_ Type; + + QuaternionStamped_() + : header() + , quaternion() { + } + QuaternionStamped_(const ContainerAllocator& _alloc) + : header(_alloc) + , quaternion(_alloc) { + (void)_alloc; + } + + + + typedef ::std_msgs::Header_ _header_type; + _header_type header; + + typedef ::geometry_msgs::Quaternion_ _quaternion_type; + _quaternion_type quaternion; + + + + + typedef std::shared_ptr< ::geometry_msgs::QuaternionStamped_ > Ptr; + typedef std::shared_ptr< ::geometry_msgs::QuaternionStamped_ const> ConstPtr; + +}; // struct QuaternionStamped_ + +typedef ::geometry_msgs::QuaternionStamped_ > QuaternionStamped; + +typedef std::shared_ptr< ::geometry_msgs::QuaternionStamped > QuaternionStampedPtr; +typedef std::shared_ptr< ::geometry_msgs::QuaternionStamped const> QuaternionStampedConstPtr; + +// constants requiring out of line definition + + + +template +std::ostream& operator<<(std::ostream& s, const ::geometry_msgs::QuaternionStamped_ & v) +{ +ros::message_operations::Printer< ::geometry_msgs::QuaternionStamped_ >::stream(s, "", v); +return s; +} + +} // namespace geometry_msgs + +namespace ros +{ +namespace message_traits +{ + + + +// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': True} +// {'std_msgs': ['/opt/ros/kinetic/share/std_msgs/cmake/../msg'], 'geometry_msgs': ['/tmp/binarydeb/ros-kinetic-geometry-msgs-1.12.5/msg']} + +// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types'] + + + + +template +struct IsFixedSize< ::geometry_msgs::QuaternionStamped_ > + : FalseType + { }; + +template +struct IsFixedSize< ::geometry_msgs::QuaternionStamped_ const> + : FalseType + { }; + +template +struct IsMessage< ::geometry_msgs::QuaternionStamped_ > + : TrueType + { }; + +template +struct IsMessage< ::geometry_msgs::QuaternionStamped_ const> + : TrueType + { }; + +template +struct HasHeader< ::geometry_msgs::QuaternionStamped_ > + : TrueType + { }; + +template +struct HasHeader< ::geometry_msgs::QuaternionStamped_ const> + : TrueType + { }; + + +template +struct MD5Sum< ::geometry_msgs::QuaternionStamped_ > +{ + static const char* value() + { + return "e57f1e547e0e1fd13504588ffc8334e2"; + } + + static const char* value(const ::geometry_msgs::QuaternionStamped_&) { return value(); } + static const uint64_t static_value1 = 0xe57f1e547e0e1fd1ULL; + static const uint64_t static_value2 = 0x3504588ffc8334e2ULL; +}; + +template +struct DataType< ::geometry_msgs::QuaternionStamped_ > +{ + static const char* value() + { + return "geometry_msgs/QuaternionStamped"; + } + + static const char* value(const ::geometry_msgs::QuaternionStamped_&) { return value(); } +}; + +template +struct Definition< ::geometry_msgs::QuaternionStamped_ > +{ + static const char* value() + { + return "# This represents an orientation with reference coordinate frame and timestamp.\n\ +\n\ +Header header\n\ +Quaternion quaternion\n\ +\n\ +================================================================================\n\ +MSG: std_msgs/Header\n\ +# Standard metadata for higher-level stamped data types.\n\ +# This is generally used to communicate timestamped data \n\ +# in a particular coordinate frame.\n\ +# \n\ +# sequence ID: consecutively increasing ID \n\ +uint32 seq\n\ +#Two-integer timestamp that is expressed as:\n\ +# * stamp.sec: seconds (stamp_secs) since epoch (in Python the variable is called 'secs')\n\ +# * stamp.nsec: nanoseconds since stamp_secs (in Python the variable is called 'nsecs')\n\ +# time-handling sugar is provided by the client library\n\ +time stamp\n\ +#Frame this data is associated with\n\ +# 0: no frame\n\ +# 1: global frame\n\ +string frame_id\n\ +\n\ +================================================================================\n\ +MSG: geometry_msgs/Quaternion\n\ +# This represents an orientation in free space in quaternion form.\n\ +\n\ +float64 x\n\ +float64 y\n\ +float64 z\n\ +float64 w\n\ +"; + } + + static const char* value(const ::geometry_msgs::QuaternionStamped_&) { return value(); } +}; + +} // namespace message_traits +} // namespace ros + +namespace ros +{ +namespace serialization +{ + + template struct Serializer< ::geometry_msgs::QuaternionStamped_ > + { + template inline static void allInOne(Stream& stream, T m) + { + stream.next(m.header); + stream.next(m.quaternion); + } + + ROS_DECLARE_ALLINONE_SERIALIZER; + }; // struct QuaternionStamped_ + +} // namespace serialization +} // namespace ros + +namespace ros +{ +namespace message_operations +{ + +template +struct Printer< ::geometry_msgs::QuaternionStamped_ > +{ + template static void stream(Stream& s, const std::string& indent, const ::geometry_msgs::QuaternionStamped_& v) + { + s << indent << "header: "; + s << std::endl; + Printer< ::std_msgs::Header_ >::stream(s, indent + " ", v.header); + s << indent << "quaternion: "; + s << std::endl; + Printer< ::geometry_msgs::Quaternion_ >::stream(s, indent + " ", v.quaternion); + } +}; + +} // namespace message_operations +} // namespace ros + +#endif // GEOMETRY_MSGS_MESSAGE_QUATERNIONSTAMPED_H diff --git a/realsense-file/src/storage/realsense_file/include/msgs/geometry_msgs/Transform.h b/realsense-file/src/storage/realsense_file/include/msgs/geometry_msgs/Transform.h new file mode 100644 index 0000000000..41c32f0e4e --- /dev/null +++ b/realsense-file/src/storage/realsense_file/include/msgs/geometry_msgs/Transform.h @@ -0,0 +1,222 @@ +// Generated by gencpp from file geometry_msgs/Transform.msg +// DO NOT EDIT! + + +#ifndef GEOMETRY_MSGS_MESSAGE_TRANSFORM_H +#define GEOMETRY_MSGS_MESSAGE_TRANSFORM_H + + +#include +#include +#include + +#include +#include +#include +#include + +#include +#include + +namespace geometry_msgs +{ +template +struct Transform_ +{ + typedef Transform_ Type; + + Transform_() + : translation() + , rotation() { + } + Transform_(const ContainerAllocator& _alloc) + : translation(_alloc) + , rotation(_alloc) { + (void)_alloc; + } + + + + typedef ::geometry_msgs::Vector3_ _translation_type; + _translation_type translation; + + typedef ::geometry_msgs::Quaternion_ _rotation_type; + _rotation_type rotation; + + + + + typedef std::shared_ptr< ::geometry_msgs::Transform_ > Ptr; + typedef std::shared_ptr< ::geometry_msgs::Transform_ const> ConstPtr; + +}; // struct Transform_ + +typedef ::geometry_msgs::Transform_ > Transform; + +typedef std::shared_ptr< ::geometry_msgs::Transform > TransformPtr; +typedef std::shared_ptr< ::geometry_msgs::Transform const> TransformConstPtr; + +// constants requiring out of line definition + + + +template +std::ostream& operator<<(std::ostream& s, const ::geometry_msgs::Transform_ & v) +{ +ros::message_operations::Printer< ::geometry_msgs::Transform_ >::stream(s, "", v); +return s; +} + +} // namespace geometry_msgs + +namespace ros +{ +namespace message_traits +{ + + + +// BOOLTRAITS {'IsFixedSize': True, 'IsMessage': True, 'HasHeader': False} +// {'std_msgs': ['/opt/ros/kinetic/share/std_msgs/cmake/../msg'], 'geometry_msgs': ['/tmp/binarydeb/ros-kinetic-geometry-msgs-1.12.5/msg']} + +// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types'] + + + + +template +struct IsFixedSize< ::geometry_msgs::Transform_ > + : TrueType + { }; + +template +struct IsFixedSize< ::geometry_msgs::Transform_ const> + : TrueType + { }; + +template +struct IsMessage< ::geometry_msgs::Transform_ > + : TrueType + { }; + +template +struct IsMessage< ::geometry_msgs::Transform_ const> + : TrueType + { }; + +template +struct HasHeader< ::geometry_msgs::Transform_ > + : FalseType + { }; + +template +struct HasHeader< ::geometry_msgs::Transform_ const> + : FalseType + { }; + + +template +struct MD5Sum< ::geometry_msgs::Transform_ > +{ + static const char* value() + { + return "ac9eff44abf714214112b05d54a3cf9b"; + } + + static const char* value(const ::geometry_msgs::Transform_&) { return value(); } + static const uint64_t static_value1 = 0xac9eff44abf71421ULL; + static const uint64_t static_value2 = 0x4112b05d54a3cf9bULL; +}; + +template +struct DataType< ::geometry_msgs::Transform_ > +{ + static const char* value() + { + return "geometry_msgs/Transform"; + } + + static const char* value(const ::geometry_msgs::Transform_&) { return value(); } +}; + +template +struct Definition< ::geometry_msgs::Transform_ > +{ + static const char* value() + { + return "# This represents the transform between two coordinate frames in free space.\n\ +\n\ +Vector3 translation\n\ +Quaternion rotation\n\ +\n\ +================================================================================\n\ +MSG: geometry_msgs/Vector3\n\ +# This represents a vector in free space. \n\ +# It is only meant to represent a direction. Therefore, it does not\n\ +# make sense to apply a translation to it (e.g., when applying a \n\ +# generic rigid transformation to a Vector3, tf2 will only apply the\n\ +# rotation). If you want your data to be translatable too, use the\n\ +# geometry_msgs/Point message instead.\n\ +\n\ +float64 x\n\ +float64 y\n\ +float64 z\n\ +================================================================================\n\ +MSG: geometry_msgs/Quaternion\n\ +# This represents an orientation in free space in quaternion form.\n\ +\n\ +float64 x\n\ +float64 y\n\ +float64 z\n\ +float64 w\n\ +"; + } + + static const char* value(const ::geometry_msgs::Transform_&) { return value(); } +}; + +} // namespace message_traits +} // namespace ros + +namespace ros +{ +namespace serialization +{ + + template struct Serializer< ::geometry_msgs::Transform_ > + { + template inline static void allInOne(Stream& stream, T m) + { + stream.next(m.translation); + stream.next(m.rotation); + } + + ROS_DECLARE_ALLINONE_SERIALIZER; + }; // struct Transform_ + +} // namespace serialization +} // namespace ros + +namespace ros +{ +namespace message_operations +{ + +template +struct Printer< ::geometry_msgs::Transform_ > +{ + template static void stream(Stream& s, const std::string& indent, const ::geometry_msgs::Transform_& v) + { + s << indent << "translation: "; + s << std::endl; + Printer< ::geometry_msgs::Vector3_ >::stream(s, indent + " ", v.translation); + s << indent << "rotation: "; + s << std::endl; + Printer< ::geometry_msgs::Quaternion_ >::stream(s, indent + " ", v.rotation); + } +}; + +} // namespace message_operations +} // namespace ros + +#endif // GEOMETRY_MSGS_MESSAGE_TRANSFORM_H diff --git a/realsense-file/src/storage/realsense_file/include/msgs/geometry_msgs/TransformStamped.h b/realsense-file/src/storage/realsense_file/include/msgs/geometry_msgs/TransformStamped.h new file mode 100644 index 0000000000..e6787e5d48 --- /dev/null +++ b/realsense-file/src/storage/realsense_file/include/msgs/geometry_msgs/TransformStamped.h @@ -0,0 +1,261 @@ +// Generated by gencpp from file geometry_msgs/TransformStamped.msg +// DO NOT EDIT! + + +#ifndef GEOMETRY_MSGS_MESSAGE_TRANSFORMSTAMPED_H +#define GEOMETRY_MSGS_MESSAGE_TRANSFORMSTAMPED_H + + +#include +#include +#include + +#include +#include +#include +#include + +#include +#include + +namespace geometry_msgs +{ +template +struct TransformStamped_ +{ + typedef TransformStamped_ Type; + + TransformStamped_() + : header() + , child_frame_id() + , transform() { + } + TransformStamped_(const ContainerAllocator& _alloc) + : header(_alloc) + , child_frame_id(_alloc) + , transform(_alloc) { + (void)_alloc; + } + + + + typedef ::std_msgs::Header_ _header_type; + _header_type header; + + typedef std::basic_string, typename ContainerAllocator::template rebind::other > _child_frame_id_type; + _child_frame_id_type child_frame_id; + + typedef ::geometry_msgs::Transform_ _transform_type; + _transform_type transform; + + + + + typedef std::shared_ptr< ::geometry_msgs::TransformStamped_ > Ptr; + typedef std::shared_ptr< ::geometry_msgs::TransformStamped_ const> ConstPtr; + +}; // struct TransformStamped_ + +typedef ::geometry_msgs::TransformStamped_ > TransformStamped; + +typedef std::shared_ptr< ::geometry_msgs::TransformStamped > TransformStampedPtr; +typedef std::shared_ptr< ::geometry_msgs::TransformStamped const> TransformStampedConstPtr; + +// constants requiring out of line definition + + + +template +std::ostream& operator<<(std::ostream& s, const ::geometry_msgs::TransformStamped_ & v) +{ +ros::message_operations::Printer< ::geometry_msgs::TransformStamped_ >::stream(s, "", v); +return s; +} + +} // namespace geometry_msgs + +namespace ros +{ +namespace message_traits +{ + + + +// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': True} +// {'std_msgs': ['/opt/ros/kinetic/share/std_msgs/cmake/../msg'], 'geometry_msgs': ['/tmp/binarydeb/ros-kinetic-geometry-msgs-1.12.5/msg']} + +// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types'] + + + + +template +struct IsFixedSize< ::geometry_msgs::TransformStamped_ > + : FalseType + { }; + +template +struct IsFixedSize< ::geometry_msgs::TransformStamped_ const> + : FalseType + { }; + +template +struct IsMessage< ::geometry_msgs::TransformStamped_ > + : TrueType + { }; + +template +struct IsMessage< ::geometry_msgs::TransformStamped_ const> + : TrueType + { }; + +template +struct HasHeader< ::geometry_msgs::TransformStamped_ > + : TrueType + { }; + +template +struct HasHeader< ::geometry_msgs::TransformStamped_ const> + : TrueType + { }; + + +template +struct MD5Sum< ::geometry_msgs::TransformStamped_ > +{ + static const char* value() + { + return "b5764a33bfeb3588febc2682852579b0"; + } + + static const char* value(const ::geometry_msgs::TransformStamped_&) { return value(); } + static const uint64_t static_value1 = 0xb5764a33bfeb3588ULL; + static const uint64_t static_value2 = 0xfebc2682852579b0ULL; +}; + +template +struct DataType< ::geometry_msgs::TransformStamped_ > +{ + static const char* value() + { + return "geometry_msgs/TransformStamped"; + } + + static const char* value(const ::geometry_msgs::TransformStamped_&) { return value(); } +}; + +template +struct Definition< ::geometry_msgs::TransformStamped_ > +{ + static const char* value() + { + return "# This expresses a transform from coordinate frame header.frame_id\n\ +# to the coordinate frame child_frame_id\n\ +#\n\ +# This message is mostly used by the \n\ +# tf package. \n\ +# See its documentation for more information.\n\ +\n\ +Header header\n\ +string child_frame_id # the frame id of the child frame\n\ +Transform transform\n\ +\n\ +================================================================================\n\ +MSG: std_msgs/Header\n\ +# Standard metadata for higher-level stamped data types.\n\ +# This is generally used to communicate timestamped data \n\ +# in a particular coordinate frame.\n\ +# \n\ +# sequence ID: consecutively increasing ID \n\ +uint32 seq\n\ +#Two-integer timestamp that is expressed as:\n\ +# * stamp.sec: seconds (stamp_secs) since epoch (in Python the variable is called 'secs')\n\ +# * stamp.nsec: nanoseconds since stamp_secs (in Python the variable is called 'nsecs')\n\ +# time-handling sugar is provided by the client library\n\ +time stamp\n\ +#Frame this data is associated with\n\ +# 0: no frame\n\ +# 1: global frame\n\ +string frame_id\n\ +\n\ +================================================================================\n\ +MSG: geometry_msgs/Transform\n\ +# This represents the transform between two coordinate frames in free space.\n\ +\n\ +Vector3 translation\n\ +Quaternion rotation\n\ +\n\ +================================================================================\n\ +MSG: geometry_msgs/Vector3\n\ +# This represents a vector in free space. \n\ +# It is only meant to represent a direction. Therefore, it does not\n\ +# make sense to apply a translation to it (e.g., when applying a \n\ +# generic rigid transformation to a Vector3, tf2 will only apply the\n\ +# rotation). If you want your data to be translatable too, use the\n\ +# geometry_msgs/Point message instead.\n\ +\n\ +float64 x\n\ +float64 y\n\ +float64 z\n\ +================================================================================\n\ +MSG: geometry_msgs/Quaternion\n\ +# This represents an orientation in free space in quaternion form.\n\ +\n\ +float64 x\n\ +float64 y\n\ +float64 z\n\ +float64 w\n\ +"; + } + + static const char* value(const ::geometry_msgs::TransformStamped_&) { return value(); } +}; + +} // namespace message_traits +} // namespace ros + +namespace ros +{ +namespace serialization +{ + + template struct Serializer< ::geometry_msgs::TransformStamped_ > + { + template inline static void allInOne(Stream& stream, T m) + { + stream.next(m.header); + stream.next(m.child_frame_id); + stream.next(m.transform); + } + + ROS_DECLARE_ALLINONE_SERIALIZER; + }; // struct TransformStamped_ + +} // namespace serialization +} // namespace ros + +namespace ros +{ +namespace message_operations +{ + +template +struct Printer< ::geometry_msgs::TransformStamped_ > +{ + template static void stream(Stream& s, const std::string& indent, const ::geometry_msgs::TransformStamped_& v) + { + s << indent << "header: "; + s << std::endl; + Printer< ::std_msgs::Header_ >::stream(s, indent + " ", v.header); + s << indent << "child_frame_id: "; + Printer, typename ContainerAllocator::template rebind::other > >::stream(s, indent + " ", v.child_frame_id); + s << indent << "transform: "; + s << std::endl; + Printer< ::geometry_msgs::Transform_ >::stream(s, indent + " ", v.transform); + } +}; + +} // namespace message_operations +} // namespace ros + +#endif // GEOMETRY_MSGS_MESSAGE_TRANSFORMSTAMPED_H diff --git a/realsense-file/src/storage/realsense_file/include/msgs/geometry_msgs/Twist.h b/realsense-file/src/storage/realsense_file/include/msgs/geometry_msgs/Twist.h new file mode 100644 index 0000000000..c7b0b6ae10 --- /dev/null +++ b/realsense-file/src/storage/realsense_file/include/msgs/geometry_msgs/Twist.h @@ -0,0 +1,213 @@ +// Generated by gencpp from file geometry_msgs/Twist.msg +// DO NOT EDIT! + + +#ifndef GEOMETRY_MSGS_MESSAGE_TWIST_H +#define GEOMETRY_MSGS_MESSAGE_TWIST_H + + +#include +#include +#include + +#include +#include +#include +#include + +#include +#include + +namespace geometry_msgs +{ +template +struct Twist_ +{ + typedef Twist_ Type; + + Twist_() + : linear() + , angular() { + } + Twist_(const ContainerAllocator& _alloc) + : linear(_alloc) + , angular(_alloc) { + (void)_alloc; + } + + + + typedef ::geometry_msgs::Vector3_ _linear_type; + _linear_type linear; + + typedef ::geometry_msgs::Vector3_ _angular_type; + _angular_type angular; + + + + + typedef std::shared_ptr< ::geometry_msgs::Twist_ > Ptr; + typedef std::shared_ptr< ::geometry_msgs::Twist_ const> ConstPtr; + +}; // struct Twist_ + +typedef ::geometry_msgs::Twist_ > Twist; + +typedef std::shared_ptr< ::geometry_msgs::Twist > TwistPtr; +typedef std::shared_ptr< ::geometry_msgs::Twist const> TwistConstPtr; + +// constants requiring out of line definition + + + +template +std::ostream& operator<<(std::ostream& s, const ::geometry_msgs::Twist_ & v) +{ +ros::message_operations::Printer< ::geometry_msgs::Twist_ >::stream(s, "", v); +return s; +} + +} // namespace geometry_msgs + +namespace ros +{ +namespace message_traits +{ + + + +// BOOLTRAITS {'IsFixedSize': True, 'IsMessage': True, 'HasHeader': False} +// {'std_msgs': ['/opt/ros/kinetic/share/std_msgs/cmake/../msg'], 'geometry_msgs': ['/tmp/binarydeb/ros-kinetic-geometry-msgs-1.12.5/msg']} + +// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types'] + + + + +template +struct IsFixedSize< ::geometry_msgs::Twist_ > + : TrueType + { }; + +template +struct IsFixedSize< ::geometry_msgs::Twist_ const> + : TrueType + { }; + +template +struct IsMessage< ::geometry_msgs::Twist_ > + : TrueType + { }; + +template +struct IsMessage< ::geometry_msgs::Twist_ const> + : TrueType + { }; + +template +struct HasHeader< ::geometry_msgs::Twist_ > + : FalseType + { }; + +template +struct HasHeader< ::geometry_msgs::Twist_ const> + : FalseType + { }; + + +template +struct MD5Sum< ::geometry_msgs::Twist_ > +{ + static const char* value() + { + return "9f195f881246fdfa2798d1d3eebca84a"; + } + + static const char* value(const ::geometry_msgs::Twist_&) { return value(); } + static const uint64_t static_value1 = 0x9f195f881246fdfaULL; + static const uint64_t static_value2 = 0x2798d1d3eebca84aULL; +}; + +template +struct DataType< ::geometry_msgs::Twist_ > +{ + static const char* value() + { + return "geometry_msgs/Twist"; + } + + static const char* value(const ::geometry_msgs::Twist_&) { return value(); } +}; + +template +struct Definition< ::geometry_msgs::Twist_ > +{ + static const char* value() + { + return "# This expresses velocity in free space broken into its linear and angular parts.\n\ +Vector3 linear\n\ +Vector3 angular\n\ +\n\ +================================================================================\n\ +MSG: geometry_msgs/Vector3\n\ +# This represents a vector in free space. \n\ +# It is only meant to represent a direction. Therefore, it does not\n\ +# make sense to apply a translation to it (e.g., when applying a \n\ +# generic rigid transformation to a Vector3, tf2 will only apply the\n\ +# rotation). If you want your data to be translatable too, use the\n\ +# geometry_msgs/Point message instead.\n\ +\n\ +float64 x\n\ +float64 y\n\ +float64 z\n\ +"; + } + + static const char* value(const ::geometry_msgs::Twist_&) { return value(); } +}; + +} // namespace message_traits +} // namespace ros + +namespace ros +{ +namespace serialization +{ + + template struct Serializer< ::geometry_msgs::Twist_ > + { + template inline static void allInOne(Stream& stream, T m) + { + stream.next(m.linear); + stream.next(m.angular); + } + + ROS_DECLARE_ALLINONE_SERIALIZER; + }; // struct Twist_ + +} // namespace serialization +} // namespace ros + +namespace ros +{ +namespace message_operations +{ + +template +struct Printer< ::geometry_msgs::Twist_ > +{ + template static void stream(Stream& s, const std::string& indent, const ::geometry_msgs::Twist_& v) + { + s << indent << "linear: "; + s << std::endl; + Printer< ::geometry_msgs::Vector3_ >::stream(s, indent + " ", v.linear); + s << indent << "angular: "; + s << std::endl; + Printer< ::geometry_msgs::Vector3_ >::stream(s, indent + " ", v.angular); + } +}; + +} // namespace message_operations +} // namespace ros + +#endif // GEOMETRY_MSGS_MESSAGE_TWIST_H diff --git a/realsense-file/src/storage/realsense_file/include/msgs/geometry_msgs/TwistStamped.h b/realsense-file/src/storage/realsense_file/include/msgs/geometry_msgs/TwistStamped.h new file mode 100644 index 0000000000..ce49119279 --- /dev/null +++ b/realsense-file/src/storage/realsense_file/include/msgs/geometry_msgs/TwistStamped.h @@ -0,0 +1,237 @@ +// Generated by gencpp from file geometry_msgs/TwistStamped.msg +// DO NOT EDIT! + + +#ifndef GEOMETRY_MSGS_MESSAGE_TWISTSTAMPED_H +#define GEOMETRY_MSGS_MESSAGE_TWISTSTAMPED_H + + +#include +#include +#include + +#include +#include +#include +#include + +#include +#include + +namespace geometry_msgs +{ +template +struct TwistStamped_ +{ + typedef TwistStamped_ Type; + + TwistStamped_() + : header() + , twist() { + } + TwistStamped_(const ContainerAllocator& _alloc) + : header(_alloc) + , twist(_alloc) { + (void)_alloc; + } + + + + typedef ::std_msgs::Header_ _header_type; + _header_type header; + + typedef ::geometry_msgs::Twist_ _twist_type; + _twist_type twist; + + + + + typedef std::shared_ptr< ::geometry_msgs::TwistStamped_ > Ptr; + typedef std::shared_ptr< ::geometry_msgs::TwistStamped_ const> ConstPtr; + +}; // struct TwistStamped_ + +typedef ::geometry_msgs::TwistStamped_ > TwistStamped; + +typedef std::shared_ptr< ::geometry_msgs::TwistStamped > TwistStampedPtr; +typedef std::shared_ptr< ::geometry_msgs::TwistStamped const> TwistStampedConstPtr; + +// constants requiring out of line definition + + + +template +std::ostream& operator<<(std::ostream& s, const ::geometry_msgs::TwistStamped_ & v) +{ +ros::message_operations::Printer< ::geometry_msgs::TwistStamped_ >::stream(s, "", v); +return s; +} + +} // namespace geometry_msgs + +namespace ros +{ +namespace message_traits +{ + + + +// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': True} +// {'std_msgs': ['/opt/ros/kinetic/share/std_msgs/cmake/../msg'], 'geometry_msgs': ['/tmp/binarydeb/ros-kinetic-geometry-msgs-1.12.5/msg']} + +// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types'] + + + + +template +struct IsFixedSize< ::geometry_msgs::TwistStamped_ > + : FalseType + { }; + +template +struct IsFixedSize< ::geometry_msgs::TwistStamped_ const> + : FalseType + { }; + +template +struct IsMessage< ::geometry_msgs::TwistStamped_ > + : TrueType + { }; + +template +struct IsMessage< ::geometry_msgs::TwistStamped_ const> + : TrueType + { }; + +template +struct HasHeader< ::geometry_msgs::TwistStamped_ > + : TrueType + { }; + +template +struct HasHeader< ::geometry_msgs::TwistStamped_ const> + : TrueType + { }; + + +template +struct MD5Sum< ::geometry_msgs::TwistStamped_ > +{ + static const char* value() + { + return "98d34b0043a2093cf9d9345ab6eef12e"; + } + + static const char* value(const ::geometry_msgs::TwistStamped_&) { return value(); } + static const uint64_t static_value1 = 0x98d34b0043a2093cULL; + static const uint64_t static_value2 = 0xf9d9345ab6eef12eULL; +}; + +template +struct DataType< ::geometry_msgs::TwistStamped_ > +{ + static const char* value() + { + return "geometry_msgs/TwistStamped"; + } + + static const char* value(const ::geometry_msgs::TwistStamped_&) { return value(); } +}; + +template +struct Definition< ::geometry_msgs::TwistStamped_ > +{ + static const char* value() + { + return "# A twist with reference coordinate frame and timestamp\n\ +Header header\n\ +Twist twist\n\ +\n\ +================================================================================\n\ +MSG: std_msgs/Header\n\ +# Standard metadata for higher-level stamped data types.\n\ +# This is generally used to communicate timestamped data \n\ +# in a particular coordinate frame.\n\ +# \n\ +# sequence ID: consecutively increasing ID \n\ +uint32 seq\n\ +#Two-integer timestamp that is expressed as:\n\ +# * stamp.sec: seconds (stamp_secs) since epoch (in Python the variable is called 'secs')\n\ +# * stamp.nsec: nanoseconds since stamp_secs (in Python the variable is called 'nsecs')\n\ +# time-handling sugar is provided by the client library\n\ +time stamp\n\ +#Frame this data is associated with\n\ +# 0: no frame\n\ +# 1: global frame\n\ +string frame_id\n\ +\n\ +================================================================================\n\ +MSG: geometry_msgs/Twist\n\ +# This expresses velocity in free space broken into its linear and angular parts.\n\ +Vector3 linear\n\ +Vector3 angular\n\ +\n\ +================================================================================\n\ +MSG: geometry_msgs/Vector3\n\ +# This represents a vector in free space. \n\ +# It is only meant to represent a direction. Therefore, it does not\n\ +# make sense to apply a translation to it (e.g., when applying a \n\ +# generic rigid transformation to a Vector3, tf2 will only apply the\n\ +# rotation). If you want your data to be translatable too, use the\n\ +# geometry_msgs/Point message instead.\n\ +\n\ +float64 x\n\ +float64 y\n\ +float64 z\n\ +"; + } + + static const char* value(const ::geometry_msgs::TwistStamped_&) { return value(); } +}; + +} // namespace message_traits +} // namespace ros + +namespace ros +{ +namespace serialization +{ + + template struct Serializer< ::geometry_msgs::TwistStamped_ > + { + template inline static void allInOne(Stream& stream, T m) + { + stream.next(m.header); + stream.next(m.twist); + } + + ROS_DECLARE_ALLINONE_SERIALIZER; + }; // struct TwistStamped_ + +} // namespace serialization +} // namespace ros + +namespace ros +{ +namespace message_operations +{ + +template +struct Printer< ::geometry_msgs::TwistStamped_ > +{ + template static void stream(Stream& s, const std::string& indent, const ::geometry_msgs::TwistStamped_& v) + { + s << indent << "header: "; + s << std::endl; + Printer< ::std_msgs::Header_ >::stream(s, indent + " ", v.header); + s << indent << "twist: "; + s << std::endl; + Printer< ::geometry_msgs::Twist_ >::stream(s, indent + " ", v.twist); + } +}; + +} // namespace message_operations +} // namespace ros + +#endif // GEOMETRY_MSGS_MESSAGE_TWISTSTAMPED_H diff --git a/realsense-file/src/storage/realsense_file/include/msgs/geometry_msgs/TwistWithCovariance.h b/realsense-file/src/storage/realsense_file/include/msgs/geometry_msgs/TwistWithCovariance.h new file mode 100644 index 0000000000..825543bdf4 --- /dev/null +++ b/realsense-file/src/storage/realsense_file/include/msgs/geometry_msgs/TwistWithCovariance.h @@ -0,0 +1,229 @@ +// Generated by gencpp from file geometry_msgs/TwistWithCovariance.msg +// DO NOT EDIT! + + +#ifndef GEOMETRY_MSGS_MESSAGE_TWISTWITHCOVARIANCE_H +#define GEOMETRY_MSGS_MESSAGE_TWISTWITHCOVARIANCE_H + + +#include +#include +#include + +#include +#include +#include +#include + +#include + +namespace geometry_msgs +{ +template +struct TwistWithCovariance_ +{ + typedef TwistWithCovariance_ Type; + + TwistWithCovariance_() + : twist() + , covariance() { + covariance.assign(0.0); + } + TwistWithCovariance_(const ContainerAllocator& _alloc) + : twist(_alloc) + , covariance() { + (void)_alloc; + covariance.assign(0.0); + } + + + + typedef ::geometry_msgs::Twist_ _twist_type; + _twist_type twist; + + typedef boost::array _covariance_type; + _covariance_type covariance; + + + + + typedef std::shared_ptr< ::geometry_msgs::TwistWithCovariance_ > Ptr; + typedef std::shared_ptr< ::geometry_msgs::TwistWithCovariance_ const> ConstPtr; + +}; // struct TwistWithCovariance_ + +typedef ::geometry_msgs::TwistWithCovariance_ > TwistWithCovariance; + +typedef std::shared_ptr< ::geometry_msgs::TwistWithCovariance > TwistWithCovariancePtr; +typedef std::shared_ptr< ::geometry_msgs::TwistWithCovariance const> TwistWithCovarianceConstPtr; + +// constants requiring out of line definition + + + +template +std::ostream& operator<<(std::ostream& s, const ::geometry_msgs::TwistWithCovariance_ & v) +{ +ros::message_operations::Printer< ::geometry_msgs::TwistWithCovariance_ >::stream(s, "", v); +return s; +} + +} // namespace geometry_msgs + +namespace ros +{ +namespace message_traits +{ + + + +// BOOLTRAITS {'IsFixedSize': True, 'IsMessage': True, 'HasHeader': False} +// {'std_msgs': ['/opt/ros/kinetic/share/std_msgs/cmake/../msg'], 'geometry_msgs': ['/tmp/binarydeb/ros-kinetic-geometry-msgs-1.12.5/msg']} + +// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types'] + + + + +template +struct IsFixedSize< ::geometry_msgs::TwistWithCovariance_ > + : TrueType + { }; + +template +struct IsFixedSize< ::geometry_msgs::TwistWithCovariance_ const> + : TrueType + { }; + +template +struct IsMessage< ::geometry_msgs::TwistWithCovariance_ > + : TrueType + { }; + +template +struct IsMessage< ::geometry_msgs::TwistWithCovariance_ const> + : TrueType + { }; + +template +struct HasHeader< ::geometry_msgs::TwistWithCovariance_ > + : FalseType + { }; + +template +struct HasHeader< ::geometry_msgs::TwistWithCovariance_ const> + : FalseType + { }; + + +template +struct MD5Sum< ::geometry_msgs::TwistWithCovariance_ > +{ + static const char* value() + { + return "1fe8a28e6890a4cc3ae4c3ca5c7d82e6"; + } + + static const char* value(const ::geometry_msgs::TwistWithCovariance_&) { return value(); } + static const uint64_t static_value1 = 0x1fe8a28e6890a4ccULL; + static const uint64_t static_value2 = 0x3ae4c3ca5c7d82e6ULL; +}; + +template +struct DataType< ::geometry_msgs::TwistWithCovariance_ > +{ + static const char* value() + { + return "geometry_msgs/TwistWithCovariance"; + } + + static const char* value(const ::geometry_msgs::TwistWithCovariance_&) { return value(); } +}; + +template +struct Definition< ::geometry_msgs::TwistWithCovariance_ > +{ + static const char* value() + { + return "# This expresses velocity in free space with uncertainty.\n\ +\n\ +Twist twist\n\ +\n\ +# Row-major representation of the 6x6 covariance matrix\n\ +# The orientation parameters use a fixed-axis representation.\n\ +# In order, the parameters are:\n\ +# (x, y, z, rotation about X axis, rotation about Y axis, rotation about Z axis)\n\ +float64[36] covariance\n\ +\n\ +================================================================================\n\ +MSG: geometry_msgs/Twist\n\ +# This expresses velocity in free space broken into its linear and angular parts.\n\ +Vector3 linear\n\ +Vector3 angular\n\ +\n\ +================================================================================\n\ +MSG: geometry_msgs/Vector3\n\ +# This represents a vector in free space. \n\ +# It is only meant to represent a direction. Therefore, it does not\n\ +# make sense to apply a translation to it (e.g., when applying a \n\ +# generic rigid transformation to a Vector3, tf2 will only apply the\n\ +# rotation). If you want your data to be translatable too, use the\n\ +# geometry_msgs/Point message instead.\n\ +\n\ +float64 x\n\ +float64 y\n\ +float64 z\n\ +"; + } + + static const char* value(const ::geometry_msgs::TwistWithCovariance_&) { return value(); } +}; + +} // namespace message_traits +} // namespace ros + +namespace ros +{ +namespace serialization +{ + + template struct Serializer< ::geometry_msgs::TwistWithCovariance_ > + { + template inline static void allInOne(Stream& stream, T m) + { + stream.next(m.twist); + stream.next(m.covariance); + } + + ROS_DECLARE_ALLINONE_SERIALIZER; + }; // struct TwistWithCovariance_ + +} // namespace serialization +} // namespace ros + +namespace ros +{ +namespace message_operations +{ + +template +struct Printer< ::geometry_msgs::TwistWithCovariance_ > +{ + template static void stream(Stream& s, const std::string& indent, const ::geometry_msgs::TwistWithCovariance_& v) + { + s << indent << "twist: "; + s << std::endl; + Printer< ::geometry_msgs::Twist_ >::stream(s, indent + " ", v.twist); + s << indent << "covariance[]" << std::endl; + for (size_t i = 0; i < v.covariance.size(); ++i) + { + s << indent << " covariance[" << i << "]: "; + Printer::stream(s, indent + " ", v.covariance[i]); + } + } +}; + +} // namespace message_operations +} // namespace ros + +#endif // GEOMETRY_MSGS_MESSAGE_TWISTWITHCOVARIANCE_H diff --git a/realsense-file/src/storage/realsense_file/include/msgs/geometry_msgs/TwistWithCovarianceStamped.h b/realsense-file/src/storage/realsense_file/include/msgs/geometry_msgs/TwistWithCovarianceStamped.h new file mode 100644 index 0000000000..ece266b555 --- /dev/null +++ b/realsense-file/src/storage/realsense_file/include/msgs/geometry_msgs/TwistWithCovarianceStamped.h @@ -0,0 +1,249 @@ +// Generated by gencpp from file geometry_msgs/TwistWithCovarianceStamped.msg +// DO NOT EDIT! + + +#ifndef GEOMETRY_MSGS_MESSAGE_TWISTWITHCOVARIANCESTAMPED_H +#define GEOMETRY_MSGS_MESSAGE_TWISTWITHCOVARIANCESTAMPED_H + + +#include +#include +#include + +#include +#include +#include +#include + +#include +#include + +namespace geometry_msgs +{ +template +struct TwistWithCovarianceStamped_ +{ + typedef TwistWithCovarianceStamped_ Type; + + TwistWithCovarianceStamped_() + : header() + , twist() { + } + TwistWithCovarianceStamped_(const ContainerAllocator& _alloc) + : header(_alloc) + , twist(_alloc) { + (void)_alloc; + } + + + + typedef ::std_msgs::Header_ _header_type; + _header_type header; + + typedef ::geometry_msgs::TwistWithCovariance_ _twist_type; + _twist_type twist; + + + + + typedef std::shared_ptr< ::geometry_msgs::TwistWithCovarianceStamped_ > Ptr; + typedef std::shared_ptr< ::geometry_msgs::TwistWithCovarianceStamped_ const> ConstPtr; + +}; // struct TwistWithCovarianceStamped_ + +typedef ::geometry_msgs::TwistWithCovarianceStamped_ > TwistWithCovarianceStamped; + +typedef std::shared_ptr< ::geometry_msgs::TwistWithCovarianceStamped > TwistWithCovarianceStampedPtr; +typedef std::shared_ptr< ::geometry_msgs::TwistWithCovarianceStamped const> TwistWithCovarianceStampedConstPtr; + +// constants requiring out of line definition + + + +template +std::ostream& operator<<(std::ostream& s, const ::geometry_msgs::TwistWithCovarianceStamped_ & v) +{ +ros::message_operations::Printer< ::geometry_msgs::TwistWithCovarianceStamped_ >::stream(s, "", v); +return s; +} + +} // namespace geometry_msgs + +namespace ros +{ +namespace message_traits +{ + + + +// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': True} +// {'std_msgs': ['/opt/ros/kinetic/share/std_msgs/cmake/../msg'], 'geometry_msgs': ['/tmp/binarydeb/ros-kinetic-geometry-msgs-1.12.5/msg']} + +// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types'] + + + + +template +struct IsFixedSize< ::geometry_msgs::TwistWithCovarianceStamped_ > + : FalseType + { }; + +template +struct IsFixedSize< ::geometry_msgs::TwistWithCovarianceStamped_ const> + : FalseType + { }; + +template +struct IsMessage< ::geometry_msgs::TwistWithCovarianceStamped_ > + : TrueType + { }; + +template +struct IsMessage< ::geometry_msgs::TwistWithCovarianceStamped_ const> + : TrueType + { }; + +template +struct HasHeader< ::geometry_msgs::TwistWithCovarianceStamped_ > + : TrueType + { }; + +template +struct HasHeader< ::geometry_msgs::TwistWithCovarianceStamped_ const> + : TrueType + { }; + + +template +struct MD5Sum< ::geometry_msgs::TwistWithCovarianceStamped_ > +{ + static const char* value() + { + return "8927a1a12fb2607ceea095b2dc440a96"; + } + + static const char* value(const ::geometry_msgs::TwistWithCovarianceStamped_&) { return value(); } + static const uint64_t static_value1 = 0x8927a1a12fb2607cULL; + static const uint64_t static_value2 = 0xeea095b2dc440a96ULL; +}; + +template +struct DataType< ::geometry_msgs::TwistWithCovarianceStamped_ > +{ + static const char* value() + { + return "geometry_msgs/TwistWithCovarianceStamped"; + } + + static const char* value(const ::geometry_msgs::TwistWithCovarianceStamped_&) { return value(); } +}; + +template +struct Definition< ::geometry_msgs::TwistWithCovarianceStamped_ > +{ + static const char* value() + { + return "# This represents an estimated twist with reference coordinate frame and timestamp.\n\ +Header header\n\ +TwistWithCovariance twist\n\ +\n\ +================================================================================\n\ +MSG: std_msgs/Header\n\ +# Standard metadata for higher-level stamped data types.\n\ +# This is generally used to communicate timestamped data \n\ +# in a particular coordinate frame.\n\ +# \n\ +# sequence ID: consecutively increasing ID \n\ +uint32 seq\n\ +#Two-integer timestamp that is expressed as:\n\ +# * stamp.sec: seconds (stamp_secs) since epoch (in Python the variable is called 'secs')\n\ +# * stamp.nsec: nanoseconds since stamp_secs (in Python the variable is called 'nsecs')\n\ +# time-handling sugar is provided by the client library\n\ +time stamp\n\ +#Frame this data is associated with\n\ +# 0: no frame\n\ +# 1: global frame\n\ +string frame_id\n\ +\n\ +================================================================================\n\ +MSG: geometry_msgs/TwistWithCovariance\n\ +# This expresses velocity in free space with uncertainty.\n\ +\n\ +Twist twist\n\ +\n\ +# Row-major representation of the 6x6 covariance matrix\n\ +# The orientation parameters use a fixed-axis representation.\n\ +# In order, the parameters are:\n\ +# (x, y, z, rotation about X axis, rotation about Y axis, rotation about Z axis)\n\ +float64[36] covariance\n\ +\n\ +================================================================================\n\ +MSG: geometry_msgs/Twist\n\ +# This expresses velocity in free space broken into its linear and angular parts.\n\ +Vector3 linear\n\ +Vector3 angular\n\ +\n\ +================================================================================\n\ +MSG: geometry_msgs/Vector3\n\ +# This represents a vector in free space. \n\ +# It is only meant to represent a direction. Therefore, it does not\n\ +# make sense to apply a translation to it (e.g., when applying a \n\ +# generic rigid transformation to a Vector3, tf2 will only apply the\n\ +# rotation). If you want your data to be translatable too, use the\n\ +# geometry_msgs/Point message instead.\n\ +\n\ +float64 x\n\ +float64 y\n\ +float64 z\n\ +"; + } + + static const char* value(const ::geometry_msgs::TwistWithCovarianceStamped_&) { return value(); } +}; + +} // namespace message_traits +} // namespace ros + +namespace ros +{ +namespace serialization +{ + + template struct Serializer< ::geometry_msgs::TwistWithCovarianceStamped_ > + { + template inline static void allInOne(Stream& stream, T m) + { + stream.next(m.header); + stream.next(m.twist); + } + + ROS_DECLARE_ALLINONE_SERIALIZER; + }; // struct TwistWithCovarianceStamped_ + +} // namespace serialization +} // namespace ros + +namespace ros +{ +namespace message_operations +{ + +template +struct Printer< ::geometry_msgs::TwistWithCovarianceStamped_ > +{ + template static void stream(Stream& s, const std::string& indent, const ::geometry_msgs::TwistWithCovarianceStamped_& v) + { + s << indent << "header: "; + s << std::endl; + Printer< ::std_msgs::Header_ >::stream(s, indent + " ", v.header); + s << indent << "twist: "; + s << std::endl; + Printer< ::geometry_msgs::TwistWithCovariance_ >::stream(s, indent + " ", v.twist); + } +}; + +} // namespace message_operations +} // namespace ros + +#endif // GEOMETRY_MSGS_MESSAGE_TWISTWITHCOVARIANCESTAMPED_H diff --git a/realsense-file/src/storage/realsense_file/include/msgs/geometry_msgs/Vector3.h b/realsense-file/src/storage/realsense_file/include/msgs/geometry_msgs/Vector3.h new file mode 100644 index 0000000000..a9567888f0 --- /dev/null +++ b/realsense-file/src/storage/realsense_file/include/msgs/geometry_msgs/Vector3.h @@ -0,0 +1,211 @@ +// Generated by gencpp from file geometry_msgs/Vector3.msg +// DO NOT EDIT! + + +#ifndef GEOMETRY_MSGS_MESSAGE_VECTOR3_H +#define GEOMETRY_MSGS_MESSAGE_VECTOR3_H + +#include +#include +#include +#include + +#include +#include +#include +#include + + +namespace geometry_msgs +{ +template +struct Vector3_ +{ + typedef Vector3_ Type; + + Vector3_() + : x(0.0) + , y(0.0) + , z(0.0) { + } + Vector3_(const ContainerAllocator& _alloc) + : x(0.0) + , y(0.0) + , z(0.0) { + (void)_alloc; + } + + + + typedef double _x_type; + _x_type x; + + typedef double _y_type; + _y_type y; + + typedef double _z_type; + _z_type z; + + + + + typedef std::shared_ptr< ::geometry_msgs::Vector3_ > Ptr; + typedef std::shared_ptr< ::geometry_msgs::Vector3_ const> ConstPtr; + +}; // struct Vector3_ + +typedef ::geometry_msgs::Vector3_ > Vector3; + +typedef std::shared_ptr< ::geometry_msgs::Vector3 > Vector3Ptr; +typedef std::shared_ptr< ::geometry_msgs::Vector3 const> Vector3ConstPtr; + +// constants requiring out of line definition + + + +template +std::ostream& operator<<(std::ostream& s, const ::geometry_msgs::Vector3_ & v) +{ +ros::message_operations::Printer< ::geometry_msgs::Vector3_ >::stream(s, "", v); +return s; +} + +} // namespace geometry_msgs + +namespace ros +{ +namespace message_traits +{ + + + +// BOOLTRAITS {'IsFixedSize': True, 'IsMessage': True, 'HasHeader': False} +// {'std_msgs': ['/opt/ros/kinetic/share/std_msgs/cmake/../msg'], 'geometry_msgs': ['/tmp/binarydeb/ros-kinetic-geometry-msgs-1.12.5/msg']} + +// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types'] + + + + +template +struct IsFixedSize< ::geometry_msgs::Vector3_ > + : TrueType + { }; + +template +struct IsFixedSize< ::geometry_msgs::Vector3_ const> + : TrueType + { }; + +template +struct IsMessage< ::geometry_msgs::Vector3_ > + : TrueType + { }; + +template +struct IsMessage< ::geometry_msgs::Vector3_ const> + : TrueType + { }; + +template +struct HasHeader< ::geometry_msgs::Vector3_ > + : FalseType + { }; + +template +struct HasHeader< ::geometry_msgs::Vector3_ const> + : FalseType + { }; + + +template +struct MD5Sum< ::geometry_msgs::Vector3_ > +{ + static const char* value() + { + return "4a842b65f413084dc2b10fb484ea7f17"; + } + + static const char* value(const ::geometry_msgs::Vector3_&) { return value(); } + static const uint64_t static_value1 = 0x4a842b65f413084dULL; + static const uint64_t static_value2 = 0xc2b10fb484ea7f17ULL; +}; + +template +struct DataType< ::geometry_msgs::Vector3_ > +{ + static const char* value() + { + return "geometry_msgs/Vector3"; + } + + static const char* value(const ::geometry_msgs::Vector3_&) { return value(); } +}; + +template +struct Definition< ::geometry_msgs::Vector3_ > +{ + static const char* value() + { + return "# This represents a vector in free space. \n\ +# It is only meant to represent a direction. Therefore, it does not\n\ +# make sense to apply a translation to it (e.g., when applying a \n\ +# generic rigid transformation to a Vector3, tf2 will only apply the\n\ +# rotation). If you want your data to be translatable too, use the\n\ +# geometry_msgs/Point message instead.\n\ +\n\ +float64 x\n\ +float64 y\n\ +float64 z\n\ +"; + } + + static const char* value(const ::geometry_msgs::Vector3_&) { return value(); } +}; + +} // namespace message_traits +} // namespace ros + +namespace ros +{ +namespace serialization +{ + + template struct Serializer< ::geometry_msgs::Vector3_ > + { + template inline static void allInOne(Stream& stream, T m) + { + stream.next(m.x); + stream.next(m.y); + stream.next(m.z); + } + + ROS_DECLARE_ALLINONE_SERIALIZER; + }; // struct Vector3_ + +} // namespace serialization +} // namespace ros + +namespace ros +{ +namespace message_operations +{ + +template +struct Printer< ::geometry_msgs::Vector3_ > +{ + template static void stream(Stream& s, const std::string& indent, const ::geometry_msgs::Vector3_& v) + { + s << indent << "x: "; + Printer::stream(s, indent + " ", v.x); + s << indent << "y: "; + Printer::stream(s, indent + " ", v.y); + s << indent << "z: "; + Printer::stream(s, indent + " ", v.z); + } +}; + +} // namespace message_operations +} // namespace ros + +#endif // GEOMETRY_MSGS_MESSAGE_VECTOR3_H diff --git a/realsense-file/src/storage/realsense_file/include/msgs/geometry_msgs/Vector3Stamped.h b/realsense-file/src/storage/realsense_file/include/msgs/geometry_msgs/Vector3Stamped.h new file mode 100644 index 0000000000..800bb0e275 --- /dev/null +++ b/realsense-file/src/storage/realsense_file/include/msgs/geometry_msgs/Vector3Stamped.h @@ -0,0 +1,231 @@ +// Generated by gencpp from file geometry_msgs/Vector3Stamped.msg +// DO NOT EDIT! + + +#ifndef GEOMETRY_MSGS_MESSAGE_VECTOR3STAMPED_H +#define GEOMETRY_MSGS_MESSAGE_VECTOR3STAMPED_H + + +#include +#include +#include + +#include +#include +#include +#include + +#include +#include + +namespace geometry_msgs +{ +template +struct Vector3Stamped_ +{ + typedef Vector3Stamped_ Type; + + Vector3Stamped_() + : header() + , vector() { + } + Vector3Stamped_(const ContainerAllocator& _alloc) + : header(_alloc) + , vector(_alloc) { + (void)_alloc; + } + + + + typedef ::std_msgs::Header_ _header_type; + _header_type header; + + typedef ::geometry_msgs::Vector3_ _vector_type; + _vector_type vector; + + + + + typedef std::shared_ptr< ::geometry_msgs::Vector3Stamped_ > Ptr; + typedef std::shared_ptr< ::geometry_msgs::Vector3Stamped_ const> ConstPtr; + +}; // struct Vector3Stamped_ + +typedef ::geometry_msgs::Vector3Stamped_ > Vector3Stamped; + +typedef std::shared_ptr< ::geometry_msgs::Vector3Stamped > Vector3StampedPtr; +typedef std::shared_ptr< ::geometry_msgs::Vector3Stamped const> Vector3StampedConstPtr; + +// constants requiring out of line definition + + + +template +std::ostream& operator<<(std::ostream& s, const ::geometry_msgs::Vector3Stamped_ & v) +{ +ros::message_operations::Printer< ::geometry_msgs::Vector3Stamped_ >::stream(s, "", v); +return s; +} + +} // namespace geometry_msgs + +namespace ros +{ +namespace message_traits +{ + + + +// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': True} +// {'std_msgs': ['/opt/ros/kinetic/share/std_msgs/cmake/../msg'], 'geometry_msgs': ['/tmp/binarydeb/ros-kinetic-geometry-msgs-1.12.5/msg']} + +// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types'] + + + + +template +struct IsFixedSize< ::geometry_msgs::Vector3Stamped_ > + : FalseType + { }; + +template +struct IsFixedSize< ::geometry_msgs::Vector3Stamped_ const> + : FalseType + { }; + +template +struct IsMessage< ::geometry_msgs::Vector3Stamped_ > + : TrueType + { }; + +template +struct IsMessage< ::geometry_msgs::Vector3Stamped_ const> + : TrueType + { }; + +template +struct HasHeader< ::geometry_msgs::Vector3Stamped_ > + : TrueType + { }; + +template +struct HasHeader< ::geometry_msgs::Vector3Stamped_ const> + : TrueType + { }; + + +template +struct MD5Sum< ::geometry_msgs::Vector3Stamped_ > +{ + static const char* value() + { + return "7b324c7325e683bf02a9b14b01090ec7"; + } + + static const char* value(const ::geometry_msgs::Vector3Stamped_&) { return value(); } + static const uint64_t static_value1 = 0x7b324c7325e683bfULL; + static const uint64_t static_value2 = 0x02a9b14b01090ec7ULL; +}; + +template +struct DataType< ::geometry_msgs::Vector3Stamped_ > +{ + static const char* value() + { + return "geometry_msgs/Vector3Stamped"; + } + + static const char* value(const ::geometry_msgs::Vector3Stamped_&) { return value(); } +}; + +template +struct Definition< ::geometry_msgs::Vector3Stamped_ > +{ + static const char* value() + { + return "# This represents a Vector3 with reference coordinate frame and timestamp\n\ +Header header\n\ +Vector3 vector\n\ +\n\ +================================================================================\n\ +MSG: std_msgs/Header\n\ +# Standard metadata for higher-level stamped data types.\n\ +# This is generally used to communicate timestamped data \n\ +# in a particular coordinate frame.\n\ +# \n\ +# sequence ID: consecutively increasing ID \n\ +uint32 seq\n\ +#Two-integer timestamp that is expressed as:\n\ +# * stamp.sec: seconds (stamp_secs) since epoch (in Python the variable is called 'secs')\n\ +# * stamp.nsec: nanoseconds since stamp_secs (in Python the variable is called 'nsecs')\n\ +# time-handling sugar is provided by the client library\n\ +time stamp\n\ +#Frame this data is associated with\n\ +# 0: no frame\n\ +# 1: global frame\n\ +string frame_id\n\ +\n\ +================================================================================\n\ +MSG: geometry_msgs/Vector3\n\ +# This represents a vector in free space. \n\ +# It is only meant to represent a direction. Therefore, it does not\n\ +# make sense to apply a translation to it (e.g., when applying a \n\ +# generic rigid transformation to a Vector3, tf2 will only apply the\n\ +# rotation). If you want your data to be translatable too, use the\n\ +# geometry_msgs/Point message instead.\n\ +\n\ +float64 x\n\ +float64 y\n\ +float64 z\n\ +"; + } + + static const char* value(const ::geometry_msgs::Vector3Stamped_&) { return value(); } +}; + +} // namespace message_traits +} // namespace ros + +namespace ros +{ +namespace serialization +{ + + template struct Serializer< ::geometry_msgs::Vector3Stamped_ > + { + template inline static void allInOne(Stream& stream, T m) + { + stream.next(m.header); + stream.next(m.vector); + } + + ROS_DECLARE_ALLINONE_SERIALIZER; + }; // struct Vector3Stamped_ + +} // namespace serialization +} // namespace ros + +namespace ros +{ +namespace message_operations +{ + +template +struct Printer< ::geometry_msgs::Vector3Stamped_ > +{ + template static void stream(Stream& s, const std::string& indent, const ::geometry_msgs::Vector3Stamped_& v) + { + s << indent << "header: "; + s << std::endl; + Printer< ::std_msgs::Header_ >::stream(s, indent + " ", v.header); + s << indent << "vector: "; + s << std::endl; + Printer< ::geometry_msgs::Vector3_ >::stream(s, indent + " ", v.vector); + } +}; + +} // namespace message_operations +} // namespace ros + +#endif // GEOMETRY_MSGS_MESSAGE_VECTOR3STAMPED_H diff --git a/realsense-file/src/storage/realsense_file/include/msgs/geometry_msgs/Wrench.h b/realsense-file/src/storage/realsense_file/include/msgs/geometry_msgs/Wrench.h new file mode 100644 index 0000000000..890273b500 --- /dev/null +++ b/realsense-file/src/storage/realsense_file/include/msgs/geometry_msgs/Wrench.h @@ -0,0 +1,214 @@ +// Generated by gencpp from file geometry_msgs/Wrench.msg +// DO NOT EDIT! + + +#ifndef GEOMETRY_MSGS_MESSAGE_WRENCH_H +#define GEOMETRY_MSGS_MESSAGE_WRENCH_H + + +#include +#include +#include + +#include +#include +#include +#include + +#include +#include + +namespace geometry_msgs +{ +template +struct Wrench_ +{ + typedef Wrench_ Type; + + Wrench_() + : force() + , torque() { + } + Wrench_(const ContainerAllocator& _alloc) + : force(_alloc) + , torque(_alloc) { + (void)_alloc; + } + + + + typedef ::geometry_msgs::Vector3_ _force_type; + _force_type force; + + typedef ::geometry_msgs::Vector3_ _torque_type; + _torque_type torque; + + + + + typedef std::shared_ptr< ::geometry_msgs::Wrench_ > Ptr; + typedef std::shared_ptr< ::geometry_msgs::Wrench_ const> ConstPtr; + +}; // struct Wrench_ + +typedef ::geometry_msgs::Wrench_ > Wrench; + +typedef std::shared_ptr< ::geometry_msgs::Wrench > WrenchPtr; +typedef std::shared_ptr< ::geometry_msgs::Wrench const> WrenchConstPtr; + +// constants requiring out of line definition + + + +template +std::ostream& operator<<(std::ostream& s, const ::geometry_msgs::Wrench_ & v) +{ +ros::message_operations::Printer< ::geometry_msgs::Wrench_ >::stream(s, "", v); +return s; +} + +} // namespace geometry_msgs + +namespace ros +{ +namespace message_traits +{ + + + +// BOOLTRAITS {'IsFixedSize': True, 'IsMessage': True, 'HasHeader': False} +// {'std_msgs': ['/opt/ros/kinetic/share/std_msgs/cmake/../msg'], 'geometry_msgs': ['/tmp/binarydeb/ros-kinetic-geometry-msgs-1.12.5/msg']} + +// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types'] + + + + +template +struct IsFixedSize< ::geometry_msgs::Wrench_ > + : TrueType + { }; + +template +struct IsFixedSize< ::geometry_msgs::Wrench_ const> + : TrueType + { }; + +template +struct IsMessage< ::geometry_msgs::Wrench_ > + : TrueType + { }; + +template +struct IsMessage< ::geometry_msgs::Wrench_ const> + : TrueType + { }; + +template +struct HasHeader< ::geometry_msgs::Wrench_ > + : FalseType + { }; + +template +struct HasHeader< ::geometry_msgs::Wrench_ const> + : FalseType + { }; + + +template +struct MD5Sum< ::geometry_msgs::Wrench_ > +{ + static const char* value() + { + return "4f539cf138b23283b520fd271b567936"; + } + + static const char* value(const ::geometry_msgs::Wrench_&) { return value(); } + static const uint64_t static_value1 = 0x4f539cf138b23283ULL; + static const uint64_t static_value2 = 0xb520fd271b567936ULL; +}; + +template +struct DataType< ::geometry_msgs::Wrench_ > +{ + static const char* value() + { + return "geometry_msgs/Wrench"; + } + + static const char* value(const ::geometry_msgs::Wrench_&) { return value(); } +}; + +template +struct Definition< ::geometry_msgs::Wrench_ > +{ + static const char* value() + { + return "# This represents force in free space, separated into\n\ +# its linear and angular parts.\n\ +Vector3 force\n\ +Vector3 torque\n\ +\n\ +================================================================================\n\ +MSG: geometry_msgs/Vector3\n\ +# This represents a vector in free space. \n\ +# It is only meant to represent a direction. Therefore, it does not\n\ +# make sense to apply a translation to it (e.g., when applying a \n\ +# generic rigid transformation to a Vector3, tf2 will only apply the\n\ +# rotation). If you want your data to be translatable too, use the\n\ +# geometry_msgs/Point message instead.\n\ +\n\ +float64 x\n\ +float64 y\n\ +float64 z\n\ +"; + } + + static const char* value(const ::geometry_msgs::Wrench_&) { return value(); } +}; + +} // namespace message_traits +} // namespace ros + +namespace ros +{ +namespace serialization +{ + + template struct Serializer< ::geometry_msgs::Wrench_ > + { + template inline static void allInOne(Stream& stream, T m) + { + stream.next(m.force); + stream.next(m.torque); + } + + ROS_DECLARE_ALLINONE_SERIALIZER; + }; // struct Wrench_ + +} // namespace serialization +} // namespace ros + +namespace ros +{ +namespace message_operations +{ + +template +struct Printer< ::geometry_msgs::Wrench_ > +{ + template static void stream(Stream& s, const std::string& indent, const ::geometry_msgs::Wrench_& v) + { + s << indent << "force: "; + s << std::endl; + Printer< ::geometry_msgs::Vector3_ >::stream(s, indent + " ", v.force); + s << indent << "torque: "; + s << std::endl; + Printer< ::geometry_msgs::Vector3_ >::stream(s, indent + " ", v.torque); + } +}; + +} // namespace message_operations +} // namespace ros + +#endif // GEOMETRY_MSGS_MESSAGE_WRENCH_H diff --git a/realsense-file/src/storage/realsense_file/include/msgs/geometry_msgs/WrenchStamped.h b/realsense-file/src/storage/realsense_file/include/msgs/geometry_msgs/WrenchStamped.h new file mode 100644 index 0000000000..a3c4cf51c2 --- /dev/null +++ b/realsense-file/src/storage/realsense_file/include/msgs/geometry_msgs/WrenchStamped.h @@ -0,0 +1,238 @@ +// Generated by gencpp from file geometry_msgs/WrenchStamped.msg +// DO NOT EDIT! + + +#ifndef GEOMETRY_MSGS_MESSAGE_WRENCHSTAMPED_H +#define GEOMETRY_MSGS_MESSAGE_WRENCHSTAMPED_H + + +#include +#include +#include + +#include +#include +#include +#include + +#include +#include + +namespace geometry_msgs +{ +template +struct WrenchStamped_ +{ + typedef WrenchStamped_ Type; + + WrenchStamped_() + : header() + , wrench() { + } + WrenchStamped_(const ContainerAllocator& _alloc) + : header(_alloc) + , wrench(_alloc) { + (void)_alloc; + } + + + + typedef ::std_msgs::Header_ _header_type; + _header_type header; + + typedef ::geometry_msgs::Wrench_ _wrench_type; + _wrench_type wrench; + + + + + typedef std::shared_ptr< ::geometry_msgs::WrenchStamped_ > Ptr; + typedef std::shared_ptr< ::geometry_msgs::WrenchStamped_ const> ConstPtr; + +}; // struct WrenchStamped_ + +typedef ::geometry_msgs::WrenchStamped_ > WrenchStamped; + +typedef std::shared_ptr< ::geometry_msgs::WrenchStamped > WrenchStampedPtr; +typedef std::shared_ptr< ::geometry_msgs::WrenchStamped const> WrenchStampedConstPtr; + +// constants requiring out of line definition + + + +template +std::ostream& operator<<(std::ostream& s, const ::geometry_msgs::WrenchStamped_ & v) +{ +ros::message_operations::Printer< ::geometry_msgs::WrenchStamped_ >::stream(s, "", v); +return s; +} + +} // namespace geometry_msgs + +namespace ros +{ +namespace message_traits +{ + + + +// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': True} +// {'std_msgs': ['/opt/ros/kinetic/share/std_msgs/cmake/../msg'], 'geometry_msgs': ['/tmp/binarydeb/ros-kinetic-geometry-msgs-1.12.5/msg']} + +// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types'] + + + + +template +struct IsFixedSize< ::geometry_msgs::WrenchStamped_ > + : FalseType + { }; + +template +struct IsFixedSize< ::geometry_msgs::WrenchStamped_ const> + : FalseType + { }; + +template +struct IsMessage< ::geometry_msgs::WrenchStamped_ > + : TrueType + { }; + +template +struct IsMessage< ::geometry_msgs::WrenchStamped_ const> + : TrueType + { }; + +template +struct HasHeader< ::geometry_msgs::WrenchStamped_ > + : TrueType + { }; + +template +struct HasHeader< ::geometry_msgs::WrenchStamped_ const> + : TrueType + { }; + + +template +struct MD5Sum< ::geometry_msgs::WrenchStamped_ > +{ + static const char* value() + { + return "d78d3cb249ce23087ade7e7d0c40cfa7"; + } + + static const char* value(const ::geometry_msgs::WrenchStamped_&) { return value(); } + static const uint64_t static_value1 = 0xd78d3cb249ce2308ULL; + static const uint64_t static_value2 = 0x7ade7e7d0c40cfa7ULL; +}; + +template +struct DataType< ::geometry_msgs::WrenchStamped_ > +{ + static const char* value() + { + return "geometry_msgs/WrenchStamped"; + } + + static const char* value(const ::geometry_msgs::WrenchStamped_&) { return value(); } +}; + +template +struct Definition< ::geometry_msgs::WrenchStamped_ > +{ + static const char* value() + { + return "# A wrench with reference coordinate frame and timestamp\n\ +Header header\n\ +Wrench wrench\n\ +\n\ +================================================================================\n\ +MSG: std_msgs/Header\n\ +# Standard metadata for higher-level stamped data types.\n\ +# This is generally used to communicate timestamped data \n\ +# in a particular coordinate frame.\n\ +# \n\ +# sequence ID: consecutively increasing ID \n\ +uint32 seq\n\ +#Two-integer timestamp that is expressed as:\n\ +# * stamp.sec: seconds (stamp_secs) since epoch (in Python the variable is called 'secs')\n\ +# * stamp.nsec: nanoseconds since stamp_secs (in Python the variable is called 'nsecs')\n\ +# time-handling sugar is provided by the client library\n\ +time stamp\n\ +#Frame this data is associated with\n\ +# 0: no frame\n\ +# 1: global frame\n\ +string frame_id\n\ +\n\ +================================================================================\n\ +MSG: geometry_msgs/Wrench\n\ +# This represents force in free space, separated into\n\ +# its linear and angular parts.\n\ +Vector3 force\n\ +Vector3 torque\n\ +\n\ +================================================================================\n\ +MSG: geometry_msgs/Vector3\n\ +# This represents a vector in free space. \n\ +# It is only meant to represent a direction. Therefore, it does not\n\ +# make sense to apply a translation to it (e.g., when applying a \n\ +# generic rigid transformation to a Vector3, tf2 will only apply the\n\ +# rotation). If you want your data to be translatable too, use the\n\ +# geometry_msgs/Point message instead.\n\ +\n\ +float64 x\n\ +float64 y\n\ +float64 z\n\ +"; + } + + static const char* value(const ::geometry_msgs::WrenchStamped_&) { return value(); } +}; + +} // namespace message_traits +} // namespace ros + +namespace ros +{ +namespace serialization +{ + + template struct Serializer< ::geometry_msgs::WrenchStamped_ > + { + template inline static void allInOne(Stream& stream, T m) + { + stream.next(m.header); + stream.next(m.wrench); + } + + ROS_DECLARE_ALLINONE_SERIALIZER; + }; // struct WrenchStamped_ + +} // namespace serialization +} // namespace ros + +namespace ros +{ +namespace message_operations +{ + +template +struct Printer< ::geometry_msgs::WrenchStamped_ > +{ + template static void stream(Stream& s, const std::string& indent, const ::geometry_msgs::WrenchStamped_& v) + { + s << indent << "header: "; + s << std::endl; + Printer< ::std_msgs::Header_ >::stream(s, indent + " ", v.header); + s << indent << "wrench: "; + s << std::endl; + Printer< ::geometry_msgs::Wrench_ >::stream(s, indent + " ", v.wrench); + } +}; + +} // namespace message_operations +} // namespace ros + +#endif // GEOMETRY_MSGS_MESSAGE_WRENCHSTAMPED_H diff --git a/realsense-file/src/storage/realsense_file/include/msgs/realsense_msgs/compressed_frame_info.h b/realsense-file/src/storage/realsense_file/include/msgs/realsense_msgs/compressed_frame_info.h new file mode 100644 index 0000000000..58f8edb3f7 --- /dev/null +++ b/realsense-file/src/storage/realsense_file/include/msgs/realsense_msgs/compressed_frame_info.h @@ -0,0 +1,252 @@ +// Generated by gencpp from file realsense_msgs/compressed_frame_info.msg +// DO NOT EDIT! + + +#ifndef REALSENSE_MSGS_MESSAGE_COMPRESSED_FRAME_INFO_H +#define REALSENSE_MSGS_MESSAGE_COMPRESSED_FRAME_INFO_H + +#include +#include +#include +#include + +#include +#include +#include +#include + +#include + +namespace realsense_msgs +{ +template +struct compressed_frame_info_ +{ + typedef compressed_frame_info_ Type; + + compressed_frame_info_() + : system_time(0) + , frame_metadata() + , time_stamp_domain(0) + , width(0) + , height(0) + , encoding() + , step(0) { + } + compressed_frame_info_(const ContainerAllocator& _alloc) + : system_time(0) + , frame_metadata(_alloc) + , time_stamp_domain(0) + , width(0) + , height(0) + , encoding(_alloc) + , step(0) { + (void)_alloc; + } + + + + typedef uint64_t _system_time_type; + _system_time_type system_time; + + typedef std::vector< ::realsense_msgs::metadata_ , typename ContainerAllocator::template rebind< ::realsense_msgs::metadata_ >::other > _frame_metadata_type; + _frame_metadata_type frame_metadata; + + typedef uint32_t _time_stamp_domain_type; + _time_stamp_domain_type time_stamp_domain; + + typedef uint32_t _width_type; + _width_type width; + + typedef uint32_t _height_type; + _height_type height; + + typedef std::basic_string, typename ContainerAllocator::template rebind::other > _encoding_type; + _encoding_type encoding; + + typedef uint32_t _step_type; + _step_type step; + + + + + typedef std::shared_ptr< ::realsense_msgs::compressed_frame_info_ > Ptr; + typedef std::shared_ptr< ::realsense_msgs::compressed_frame_info_ const> ConstPtr; + +}; // struct compressed_frame_info_ + +typedef ::realsense_msgs::compressed_frame_info_ > compressed_frame_info; + +typedef std::shared_ptr< ::realsense_msgs::compressed_frame_info > compressed_frame_infoPtr; +typedef std::shared_ptr< ::realsense_msgs::compressed_frame_info const> compressed_frame_infoConstPtr; + +// constants requiring out of line definition + + + +template +std::ostream& operator<<(std::ostream& s, const ::realsense_msgs::compressed_frame_info_ & v) +{ +ros::message_operations::Printer< ::realsense_msgs::compressed_frame_info_ >::stream(s, "", v); +return s; +} + +} // namespace realsense_msgs + +namespace ros +{ +namespace message_traits +{ + + + +// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': False} +// {'sensor_msgs': ['/opt/ros/kinetic/share/sensor_msgs/cmake/../msg'], 'geometry_msgs': ['/opt/ros/kinetic/share/geometry_msgs/cmake/../msg'], 'std_msgs': ['/opt/ros/kinetic/share/std_msgs/cmake/../msg'], 'realsense_msgs': ['/home/administrator/ros/realsense_sdk_internal/sdk_internal/tools/realsense_msgs_generator/msg']} + +// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types'] + + + + +template +struct IsFixedSize< ::realsense_msgs::compressed_frame_info_ > + : FalseType + { }; + +template +struct IsFixedSize< ::realsense_msgs::compressed_frame_info_ const> + : FalseType + { }; + +template +struct IsMessage< ::realsense_msgs::compressed_frame_info_ > + : TrueType + { }; + +template +struct IsMessage< ::realsense_msgs::compressed_frame_info_ const> + : TrueType + { }; + +template +struct HasHeader< ::realsense_msgs::compressed_frame_info_ > + : FalseType + { }; + +template +struct HasHeader< ::realsense_msgs::compressed_frame_info_ const> + : FalseType + { }; + + +template +struct MD5Sum< ::realsense_msgs::compressed_frame_info_ > +{ + static const char* value() + { + return "64a56816b5cc611196b9f32528adbddc"; + } + + static const char* value(const ::realsense_msgs::compressed_frame_info_&) { return value(); } + static const uint64_t static_value1 = 0x64a56816b5cc6111ULL; + static const uint64_t static_value2 = 0x96b9f32528adbddcULL; +}; + +template +struct DataType< ::realsense_msgs::compressed_frame_info_ > +{ + static const char* value() + { + return "realsense_msgs/compressed_frame_info"; + } + + static const char* value(const ::realsense_msgs::compressed_frame_info_&) { return value(); } +}; + +template +struct Definition< ::realsense_msgs::compressed_frame_info_ > +{ + static const char* value() + { + return "uint64 system_time\n\ +realsense_msgs/metadata[] frame_metadata\n\ +uint32 time_stamp_domain\n\ +uint32 width\n\ +uint32 height \n\ +string encoding\n\ +uint32 step\n\ +\n\ +================================================================================\n\ +MSG: realsense_msgs/metadata\n\ +uint32 type\n\ +uint8[] data\n\ +"; + } + + static const char* value(const ::realsense_msgs::compressed_frame_info_&) { return value(); } +}; + +} // namespace message_traits +} // namespace ros + +namespace ros +{ +namespace serialization +{ + + template struct Serializer< ::realsense_msgs::compressed_frame_info_ > + { + template inline static void allInOne(Stream& stream, T m) + { + stream.next(m.system_time); + stream.next(m.frame_metadata); + stream.next(m.time_stamp_domain); + stream.next(m.width); + stream.next(m.height); + stream.next(m.encoding); + stream.next(m.step); + } + + ROS_DECLARE_ALLINONE_SERIALIZER; + }; // struct compressed_frame_info_ + +} // namespace serialization +} // namespace ros + +namespace ros +{ +namespace message_operations +{ + +template +struct Printer< ::realsense_msgs::compressed_frame_info_ > +{ + template static void stream(Stream& s, const std::string& indent, const ::realsense_msgs::compressed_frame_info_& v) + { + s << indent << "system_time: "; + Printer::stream(s, indent + " ", v.system_time); + s << indent << "frame_metadata[]" << std::endl; + for (size_t i = 0; i < v.frame_metadata.size(); ++i) + { + s << indent << " frame_metadata[" << i << "]: "; + s << std::endl; + s << indent; + Printer< ::realsense_msgs::metadata_ >::stream(s, indent + " ", v.frame_metadata[i]); + } + s << indent << "time_stamp_domain: "; + Printer::stream(s, indent + " ", v.time_stamp_domain); + s << indent << "width: "; + Printer::stream(s, indent + " ", v.width); + s << indent << "height: "; + Printer::stream(s, indent + " ", v.height); + s << indent << "encoding: "; + Printer, typename ContainerAllocator::template rebind::other > >::stream(s, indent + " ", v.encoding); + s << indent << "step: "; + Printer::stream(s, indent + " ", v.step); + } +}; + +} // namespace message_operations +} // namespace ros + +#endif // REALSENSE_MSGS_MESSAGE_COMPRESSED_FRAME_INFO_H diff --git a/realsense-file/src/storage/realsense_file/include/msgs/realsense_msgs/extrinsics.h b/realsense-file/src/storage/realsense_file/include/msgs/realsense_msgs/extrinsics.h new file mode 100644 index 0000000000..b39d096ed7 --- /dev/null +++ b/realsense-file/src/storage/realsense_file/include/msgs/realsense_msgs/extrinsics.h @@ -0,0 +1,209 @@ +// Generated by gencpp from file realsense_msgs/extrinsics.msg +// DO NOT EDIT! + + +#ifndef REALSENSE_MSGS_MESSAGE_EXTRINSICS_H +#define REALSENSE_MSGS_MESSAGE_EXTRINSICS_H + +#include +#include +#include +#include + +#include +#include +#include +#include + + +namespace realsense_msgs +{ +template +struct extrinsics_ +{ + typedef extrinsics_ Type; + + extrinsics_() + : rotation() + , translation() { + rotation.fill(0.0); + + translation.fill(0.0); + } + extrinsics_(const ContainerAllocator& _alloc) + : rotation() + , translation() { + (void)_alloc; + rotation.fill(0.0); + + translation.fill(0.0); + } + + + + typedef std::array _rotation_type; + _rotation_type rotation; + + typedef std::array _translation_type; + _translation_type translation; + + + + + typedef std::shared_ptr< ::realsense_msgs::extrinsics_ > Ptr; + typedef std::shared_ptr< ::realsense_msgs::extrinsics_ const> ConstPtr; + +}; // struct extrinsics_ + +typedef ::realsense_msgs::extrinsics_ > extrinsics; + +typedef std::shared_ptr< ::realsense_msgs::extrinsics > extrinsicsPtr; +typedef std::shared_ptr< ::realsense_msgs::extrinsics const> extrinsicsConstPtr; + +// constants requiring out of line definition + + + +template +std::ostream& operator<<(std::ostream& s, const ::realsense_msgs::extrinsics_ & v) +{ +ros::message_operations::Printer< ::realsense_msgs::extrinsics_ >::stream(s, "", v); +return s; +} + +} // namespace realsense_msgs + +namespace ros +{ +namespace message_traits +{ + + + +// BOOLTRAITS {'IsFixedSize': True, 'IsMessage': True, 'HasHeader': False} +// {'sensor_msgs': ['/opt/ros/kinetic/share/sensor_msgs/cmake/../msg'], 'geometry_msgs': ['/opt/ros/kinetic/share/geometry_msgs/cmake/../msg'], 'std_msgs': ['/opt/ros/kinetic/share/std_msgs/cmake/../msg'], 'realsense_msgs': ['/home/administrator/realsense_ros_file/realsense_file/realsense_msgs/msg']} + +// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types'] + + + + +template +struct IsFixedSize< ::realsense_msgs::extrinsics_ > + : TrueType + { }; + +template +struct IsFixedSize< ::realsense_msgs::extrinsics_ const> + : TrueType + { }; + +template +struct IsMessage< ::realsense_msgs::extrinsics_ > + : TrueType + { }; + +template +struct IsMessage< ::realsense_msgs::extrinsics_ const> + : TrueType + { }; + +template +struct HasHeader< ::realsense_msgs::extrinsics_ > + : FalseType + { }; + +template +struct HasHeader< ::realsense_msgs::extrinsics_ const> + : FalseType + { }; + + +template +struct MD5Sum< ::realsense_msgs::extrinsics_ > +{ + static const char* value() + { + return "21af2234bc223eca7ed86d7046906de5"; + } + + static const char* value(const ::realsense_msgs::extrinsics_&) { return value(); } + static const uint64_t static_value1 = 0x21af2234bc223ecaULL; + static const uint64_t static_value2 = 0x7ed86d7046906de5ULL; +}; + +template +struct DataType< ::realsense_msgs::extrinsics_ > +{ + static const char* value() + { + return "realsense_msgs/extrinsics"; + } + + static const char* value(const ::realsense_msgs::extrinsics_&) { return value(); } +}; + +template +struct Definition< ::realsense_msgs::extrinsics_ > +{ + static const char* value() + { + return "float32[9] rotation # column-major 3x3 rotation matrix \n\ +float32[3] translation # 3 element translation vector, in meters \n\ +"; + } + + static const char* value(const ::realsense_msgs::extrinsics_&) { return value(); } +}; + +} // namespace message_traits +} // namespace ros + +namespace ros +{ +namespace serialization +{ + + template struct Serializer< ::realsense_msgs::extrinsics_ > + { + template inline static void allInOne(Stream& stream, T m) + { + stream.next(m.rotation); + stream.next(m.translation); + } + + ROS_DECLARE_ALLINONE_SERIALIZER; + }; // struct extrinsics_ + +} // namespace serialization +} // namespace ros + +namespace ros +{ +namespace message_operations +{ + +template +struct Printer< ::realsense_msgs::extrinsics_ > +{ + template static void stream(Stream& s, const std::string& indent, const ::realsense_msgs::extrinsics_& v) + { + s << indent << "rotation[]" << std::endl; + for (size_t i = 0; i < v.rotation.size(); ++i) + { + s << indent << " rotation[" << i << "]: "; + Printer::stream(s, indent + " ", v.rotation[i]); + } + s << indent << "translation[]" << std::endl; + for (size_t i = 0; i < v.translation.size(); ++i) + { + s << indent << " translation[" << i << "]: "; + Printer::stream(s, indent + " ", v.translation[i]); + } + } +}; + +} // namespace message_operations +} // namespace ros + +#endif // REALSENSE_MSGS_MESSAGE_EXTRINSICS_H diff --git a/realsense-file/src/storage/realsense_file/include/msgs/realsense_msgs/frame_info.h b/realsense-file/src/storage/realsense_file/include/msgs/realsense_msgs/frame_info.h new file mode 100644 index 0000000000..0f08e1c6fd --- /dev/null +++ b/realsense-file/src/storage/realsense_file/include/msgs/realsense_msgs/frame_info.h @@ -0,0 +1,216 @@ +// Generated by gencpp from file realsense_msgs/frame_info.msg +// DO NOT EDIT! + + +#ifndef REALSENSE_MSGS_MESSAGE_FRAME_INFO_H +#define REALSENSE_MSGS_MESSAGE_FRAME_INFO_H + +#include +#include +#include +#include + +#include +#include +#include +#include + +#include + +namespace realsense_msgs +{ +template +struct frame_info_ +{ + typedef frame_info_ Type; + + frame_info_() + : system_time(0) + , frame_metadata() + , time_stamp_domain(0) { + } + frame_info_(const ContainerAllocator& _alloc) + : system_time(0) + , frame_metadata(_alloc) + , time_stamp_domain(0) { + (void)_alloc; + } + + + + typedef uint64_t _system_time_type; + _system_time_type system_time; + + typedef std::vector< ::realsense_msgs::metadata_ , typename ContainerAllocator::template rebind< ::realsense_msgs::metadata_ >::other > _frame_metadata_type; + _frame_metadata_type frame_metadata; + + typedef uint32_t _time_stamp_domain_type; + _time_stamp_domain_type time_stamp_domain; + + + + + typedef std::shared_ptr< ::realsense_msgs::frame_info_ > Ptr; + typedef std::shared_ptr< ::realsense_msgs::frame_info_ const> ConstPtr; + +}; // struct frame_info_ + +typedef ::realsense_msgs::frame_info_ > frame_info; + +typedef std::shared_ptr< ::realsense_msgs::frame_info > frame_infoPtr; +typedef std::shared_ptr< ::realsense_msgs::frame_info const> frame_infoConstPtr; + +// constants requiring out of line definition + + + +template +std::ostream& operator<<(std::ostream& s, const ::realsense_msgs::frame_info_ & v) +{ +ros::message_operations::Printer< ::realsense_msgs::frame_info_ >::stream(s, "", v); +return s; +} + +} // namespace realsense_msgs + +namespace ros +{ +namespace message_traits +{ + + + +// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': False} +// {'sensor_msgs': ['/opt/ros/kinetic/share/sensor_msgs/cmake/../msg'], 'geometry_msgs': ['/opt/ros/kinetic/share/geometry_msgs/cmake/../msg'], 'std_msgs': ['/opt/ros/kinetic/share/std_msgs/cmake/../msg'], 'realsense_msgs': ['/home/administrator/ros/realsense_sdk_internal/sdk_internal/tools/realsense_msgs_generator/msg']} + +// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types'] + + + + +template +struct IsFixedSize< ::realsense_msgs::frame_info_ > + : FalseType + { }; + +template +struct IsFixedSize< ::realsense_msgs::frame_info_ const> + : FalseType + { }; + +template +struct IsMessage< ::realsense_msgs::frame_info_ > + : TrueType + { }; + +template +struct IsMessage< ::realsense_msgs::frame_info_ const> + : TrueType + { }; + +template +struct HasHeader< ::realsense_msgs::frame_info_ > + : FalseType + { }; + +template +struct HasHeader< ::realsense_msgs::frame_info_ const> + : FalseType + { }; + + +template +struct MD5Sum< ::realsense_msgs::frame_info_ > +{ + static const char* value() + { + return "6859690af0611d3a4c9b75ba3627900a"; + } + + static const char* value(const ::realsense_msgs::frame_info_&) { return value(); } + static const uint64_t static_value1 = 0x6859690af0611d3aULL; + static const uint64_t static_value2 = 0x4c9b75ba3627900aULL; +}; + +template +struct DataType< ::realsense_msgs::frame_info_ > +{ + static const char* value() + { + return "realsense_msgs/frame_info"; + } + + static const char* value(const ::realsense_msgs::frame_info_&) { return value(); } +}; + +template +struct Definition< ::realsense_msgs::frame_info_ > +{ + static const char* value() + { + return "uint64 system_time\n\ +realsense_msgs/metadata[] frame_metadata\n\ +uint32 time_stamp_domain\n\ +\n\ +================================================================================\n\ +MSG: realsense_msgs/metadata\n\ +uint32 type\n\ +uint8[] data\n\ +"; + } + + static const char* value(const ::realsense_msgs::frame_info_&) { return value(); } +}; + +} // namespace message_traits +} // namespace ros + +namespace ros +{ +namespace serialization +{ + + template struct Serializer< ::realsense_msgs::frame_info_ > + { + template inline static void allInOne(Stream& stream, T m) + { + stream.next(m.system_time); + stream.next(m.frame_metadata); + stream.next(m.time_stamp_domain); + } + + ROS_DECLARE_ALLINONE_SERIALIZER; + }; // struct frame_info_ + +} // namespace serialization +} // namespace ros + +namespace ros +{ +namespace message_operations +{ + +template +struct Printer< ::realsense_msgs::frame_info_ > +{ + template static void stream(Stream& s, const std::string& indent, const ::realsense_msgs::frame_info_& v) + { + s << indent << "system_time: "; + Printer::stream(s, indent + " ", v.system_time); + s << indent << "frame_metadata[]" << std::endl; + for (size_t i = 0; i < v.frame_metadata.size(); ++i) + { + s << indent << " frame_metadata[" << i << "]: "; + s << std::endl; + s << indent; + Printer< ::realsense_msgs::metadata_ >::stream(s, indent + " ", v.frame_metadata[i]); + } + s << indent << "time_stamp_domain: "; + Printer::stream(s, indent + " ", v.time_stamp_domain); + } +}; + +} // namespace message_operations +} // namespace ros + +#endif // REALSENSE_MSGS_MESSAGE_FRAME_INFO_H diff --git a/realsense-file/src/storage/realsense_file/include/msgs/realsense_msgs/metadata.h b/realsense-file/src/storage/realsense_file/include/msgs/realsense_msgs/metadata.h new file mode 100644 index 0000000000..50b3dde8ad --- /dev/null +++ b/realsense-file/src/storage/realsense_file/include/msgs/realsense_msgs/metadata.h @@ -0,0 +1,199 @@ +// Generated by gencpp from file realsense_msgs/metadata.msg +// DO NOT EDIT! + + +#ifndef REALSENSE_MSGS_MESSAGE_METADATA_H +#define REALSENSE_MSGS_MESSAGE_METADATA_H + +#include +#include +#include +#include + +#include +#include +#include +#include + + +namespace realsense_msgs +{ +template +struct metadata_ +{ + typedef metadata_ Type; + + metadata_() + : type(0) + , data() { + } + metadata_(const ContainerAllocator& _alloc) + : type(0) + , data(_alloc) { + (void)_alloc; + } + + + + typedef uint32_t _type_type; + _type_type type; + + typedef std::vector::other > _data_type; + _data_type data; + + + + + typedef std::shared_ptr< ::realsense_msgs::metadata_ > Ptr; + typedef std::shared_ptr< ::realsense_msgs::metadata_ const> ConstPtr; + +}; // struct metadata_ + +typedef ::realsense_msgs::metadata_ > metadata; + +typedef std::shared_ptr< ::realsense_msgs::metadata > metadataPtr; +typedef std::shared_ptr< ::realsense_msgs::metadata const> metadataConstPtr; + +// constants requiring out of line definition + + + +template +std::ostream& operator<<(std::ostream& s, const ::realsense_msgs::metadata_ & v) +{ +ros::message_operations::Printer< ::realsense_msgs::metadata_ >::stream(s, "", v); +return s; +} + +} // namespace realsense_msgs + +namespace ros +{ +namespace message_traits +{ + + + +// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': False} +// {'sensor_msgs': ['/opt/ros/kinetic/share/sensor_msgs/cmake/../msg'], 'geometry_msgs': ['/opt/ros/kinetic/share/geometry_msgs/cmake/../msg'], 'std_msgs': ['/opt/ros/kinetic/share/std_msgs/cmake/../msg'], 'realsense_msgs': ['/home/administrator/ros/realsense_sdk_internal/sdk_internal/tools/realsense_msgs_generator/msg']} + +// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types'] + + + + +template +struct IsFixedSize< ::realsense_msgs::metadata_ > + : FalseType + { }; + +template +struct IsFixedSize< ::realsense_msgs::metadata_ const> + : FalseType + { }; + +template +struct IsMessage< ::realsense_msgs::metadata_ > + : TrueType + { }; + +template +struct IsMessage< ::realsense_msgs::metadata_ const> + : TrueType + { }; + +template +struct HasHeader< ::realsense_msgs::metadata_ > + : FalseType + { }; + +template +struct HasHeader< ::realsense_msgs::metadata_ const> + : FalseType + { }; + + +template +struct MD5Sum< ::realsense_msgs::metadata_ > +{ + static const char* value() + { + return "ca2eb36f087bcfd95f0aa6ff2df9ebdb"; + } + + static const char* value(const ::realsense_msgs::metadata_&) { return value(); } + static const uint64_t static_value1 = 0xca2eb36f087bcfd9ULL; + static const uint64_t static_value2 = 0x5f0aa6ff2df9ebdbULL; +}; + +template +struct DataType< ::realsense_msgs::metadata_ > +{ + static const char* value() + { + return "realsense_msgs/metadata"; + } + + static const char* value(const ::realsense_msgs::metadata_&) { return value(); } +}; + +template +struct Definition< ::realsense_msgs::metadata_ > +{ + static const char* value() + { + return "uint32 type\n\ +uint8[] data\n\ +"; + } + + static const char* value(const ::realsense_msgs::metadata_&) { return value(); } +}; + +} // namespace message_traits +} // namespace ros + +namespace ros +{ +namespace serialization +{ + + template struct Serializer< ::realsense_msgs::metadata_ > + { + template inline static void allInOne(Stream& stream, T m) + { + stream.next(m.type); + stream.next(m.data); + } + + ROS_DECLARE_ALLINONE_SERIALIZER; + }; // struct metadata_ + +} // namespace serialization +} // namespace ros + +namespace ros +{ +namespace message_operations +{ + +template +struct Printer< ::realsense_msgs::metadata_ > +{ + template static void stream(Stream& s, const std::string& indent, const ::realsense_msgs::metadata_& v) + { + s << indent << "type: "; + Printer::stream(s, indent + " ", v.type); + s << indent << "data[]" << std::endl; + for (size_t i = 0; i < v.data.size(); ++i) + { + s << indent << " data[" << i << "]: "; + Printer::stream(s, indent + " ", v.data[i]); + } + } +}; + +} // namespace message_operations +} // namespace ros + +#endif // REALSENSE_MSGS_MESSAGE_METADATA_H diff --git a/realsense-file/src/storage/realsense_file/include/msgs/realsense_msgs/motion_intrinsics.h b/realsense-file/src/storage/realsense_file/include/msgs/realsense_msgs/motion_intrinsics.h new file mode 100644 index 0000000000..b14e061827 --- /dev/null +++ b/realsense-file/src/storage/realsense_file/include/msgs/realsense_msgs/motion_intrinsics.h @@ -0,0 +1,226 @@ +// Generated by gencpp from file realsense_msgs/motion_intrinsics.msg +// DO NOT EDIT! + + +#ifndef REALSENSE_MSGS_MESSAGE_MOTION_INTRINSICS_H +#define REALSENSE_MSGS_MESSAGE_MOTION_INTRINSICS_H + +#include +#include +#include +#include + +#include +#include +#include +#include + + +namespace realsense_msgs +{ +template +struct motion_intrinsics_ +{ + typedef motion_intrinsics_ Type; + + motion_intrinsics_() + : data() + , noise_variances() + , bias_variances() { + data.fill(0.0); + + noise_variances.fill(0.0); + + bias_variances.fill(0.0); + } + motion_intrinsics_(const ContainerAllocator& _alloc) + : data() + , noise_variances() + , bias_variances() { + (void)_alloc; + data.fill(0.0); + + noise_variances.fill(0.0); + + bias_variances.fill(0.0); + } + + + + typedef std::array _data_type; + _data_type data; + + typedef std::array _noise_variances_type; + _noise_variances_type noise_variances; + + typedef std::array _bias_variances_type; + _bias_variances_type bias_variances; + + + + + typedef std::shared_ptr< ::realsense_msgs::motion_intrinsics_ > Ptr; + typedef std::shared_ptr< ::realsense_msgs::motion_intrinsics_ const> ConstPtr; + +}; // struct motion_intrinsics_ + +typedef ::realsense_msgs::motion_intrinsics_ > motion_intrinsics; + +typedef std::shared_ptr< ::realsense_msgs::motion_intrinsics > motion_intrinsicsPtr; +typedef std::shared_ptr< ::realsense_msgs::motion_intrinsics const> motion_intrinsicsConstPtr; + +// constants requiring out of line definition + + + +template +std::ostream& operator<<(std::ostream& s, const ::realsense_msgs::motion_intrinsics_ & v) +{ +ros::message_operations::Printer< ::realsense_msgs::motion_intrinsics_ >::stream(s, "", v); +return s; +} + +} // namespace realsense_msgs + +namespace ros +{ +namespace message_traits +{ + + + +// BOOLTRAITS {'IsFixedSize': True, 'IsMessage': True, 'HasHeader': False} +// {'sensor_msgs': ['/opt/ros/kinetic/share/sensor_msgs/cmake/../msg'], 'geometry_msgs': ['/opt/ros/kinetic/share/geometry_msgs/cmake/../msg'], 'std_msgs': ['/opt/ros/kinetic/share/std_msgs/cmake/../msg'], 'realsense_msgs': ['/home/administrator/realsense_ros_file/realsense_file/realsense_msgs/msg']} + +// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types'] + + + + +template +struct IsFixedSize< ::realsense_msgs::motion_intrinsics_ > + : TrueType + { }; + +template +struct IsFixedSize< ::realsense_msgs::motion_intrinsics_ const> + : TrueType + { }; + +template +struct IsMessage< ::realsense_msgs::motion_intrinsics_ > + : TrueType + { }; + +template +struct IsMessage< ::realsense_msgs::motion_intrinsics_ const> + : TrueType + { }; + +template +struct HasHeader< ::realsense_msgs::motion_intrinsics_ > + : FalseType + { }; + +template +struct HasHeader< ::realsense_msgs::motion_intrinsics_ const> + : FalseType + { }; + + +template +struct MD5Sum< ::realsense_msgs::motion_intrinsics_ > +{ + static const char* value() + { + return "aebdc2f8f9726f1c3ca823ab56e47429"; + } + + static const char* value(const ::realsense_msgs::motion_intrinsics_&) { return value(); } + static const uint64_t static_value1 = 0xaebdc2f8f9726f1cULL; + static const uint64_t static_value2 = 0x3ca823ab56e47429ULL; +}; + +template +struct DataType< ::realsense_msgs::motion_intrinsics_ > +{ + static const char* value() + { + return "realsense_msgs/motion_intrinsics"; + } + + static const char* value(const ::realsense_msgs::motion_intrinsics_&) { return value(); } +}; + +template +struct Definition< ::realsense_msgs::motion_intrinsics_ > +{ + static const char* value() + { + return "float32[12] data\n\ +float32[3] noise_variances\n\ +float32[3] bias_variances\n\ +"; + } + + static const char* value(const ::realsense_msgs::motion_intrinsics_&) { return value(); } +}; + +} // namespace message_traits +} // namespace ros + +namespace ros +{ +namespace serialization +{ + + template struct Serializer< ::realsense_msgs::motion_intrinsics_ > + { + template inline static void allInOne(Stream& stream, T m) + { + stream.next(m.data); + stream.next(m.noise_variances); + stream.next(m.bias_variances); + } + + ROS_DECLARE_ALLINONE_SERIALIZER; + }; // struct motion_intrinsics_ + +} // namespace serialization +} // namespace ros + +namespace ros +{ +namespace message_operations +{ + +template +struct Printer< ::realsense_msgs::motion_intrinsics_ > +{ + template static void stream(Stream& s, const std::string& indent, const ::realsense_msgs::motion_intrinsics_& v) + { + s << indent << "data[]" << std::endl; + for (size_t i = 0; i < v.data.size(); ++i) + { + s << indent << " data[" << i << "]: "; + Printer::stream(s, indent + " ", v.data[i]); + } + s << indent << "noise_variances[]" << std::endl; + for (size_t i = 0; i < v.noise_variances.size(); ++i) + { + s << indent << " noise_variances[" << i << "]: "; + Printer::stream(s, indent + " ", v.noise_variances[i]); + } + s << indent << "bias_variances[]" << std::endl; + for (size_t i = 0; i < v.bias_variances.size(); ++i) + { + s << indent << " bias_variances[" << i << "]: "; + Printer::stream(s, indent + " ", v.bias_variances[i]); + } + } +}; + +} // namespace message_operations +} // namespace ros + +#endif // REALSENSE_MSGS_MESSAGE_MOTION_INTRINSICS_H diff --git a/realsense-file/src/storage/realsense_file/include/msgs/realsense_msgs/motion_stream_info.h b/realsense-file/src/storage/realsense_file/include/msgs/realsense_msgs/motion_stream_info.h new file mode 100644 index 0000000000..40e822c3f0 --- /dev/null +++ b/realsense-file/src/storage/realsense_file/include/msgs/realsense_msgs/motion_stream_info.h @@ -0,0 +1,234 @@ +// Generated by gencpp from file realsense_msgs/motion_stream_info.msg +// DO NOT EDIT! + + +#ifndef REALSENSE_MSGS_MESSAGE_MOTION_STREAM_INFO_H +#define REALSENSE_MSGS_MESSAGE_MOTION_STREAM_INFO_H + +#include +#include +#include +#include + +#include +#include +#include +#include + +#include +#include + +namespace realsense_msgs +{ +template +struct motion_stream_info_ +{ + typedef motion_stream_info_ Type; + + motion_stream_info_() + : motion_type() + , fps(0) + , stream_intrinsics() + , stream_extrinsics() { + } + motion_stream_info_(const ContainerAllocator& _alloc) + : motion_type(_alloc) + , fps(0) + , stream_intrinsics(_alloc) + , stream_extrinsics(_alloc) { + (void)_alloc; + } + + + + typedef std::basic_string, typename ContainerAllocator::template rebind::other > _motion_type_type; + _motion_type_type motion_type; + + typedef uint32_t _fps_type; + _fps_type fps; + + typedef ::realsense_msgs::motion_intrinsics_ _stream_intrinsics_type; + _stream_intrinsics_type stream_intrinsics; + + typedef ::realsense_msgs::stream_extrinsics_ _stream_extrinsics_type; + _stream_extrinsics_type stream_extrinsics; + + + + + typedef std::shared_ptr< ::realsense_msgs::motion_stream_info_ > Ptr; + typedef std::shared_ptr< ::realsense_msgs::motion_stream_info_ const> ConstPtr; + +}; // struct motion_stream_info_ + +typedef ::realsense_msgs::motion_stream_info_ > motion_stream_info; + +typedef std::shared_ptr< ::realsense_msgs::motion_stream_info > motion_stream_infoPtr; +typedef std::shared_ptr< ::realsense_msgs::motion_stream_info const> motion_stream_infoConstPtr; + +// constants requiring out of line definition + + + +template +std::ostream& operator<<(std::ostream& s, const ::realsense_msgs::motion_stream_info_ & v) +{ +ros::message_operations::Printer< ::realsense_msgs::motion_stream_info_ >::stream(s, "", v); +return s; +} + +} // namespace realsense_msgs + +namespace ros +{ +namespace message_traits +{ + + + +// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': False} +// {'sensor_msgs': ['/opt/ros/kinetic/share/sensor_msgs/cmake/../msg'], 'geometry_msgs': ['/opt/ros/kinetic/share/geometry_msgs/cmake/../msg'], 'std_msgs': ['/opt/ros/kinetic/share/std_msgs/cmake/../msg'], 'realsense_msgs': ['/home/administrator/ros/realsense_sdk_internal/sdk_internal/tools/realsense_msgs_generator/msg']} + +// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types'] + + + + +template +struct IsFixedSize< ::realsense_msgs::motion_stream_info_ > + : FalseType + { }; + +template +struct IsFixedSize< ::realsense_msgs::motion_stream_info_ const> + : FalseType + { }; + +template +struct IsMessage< ::realsense_msgs::motion_stream_info_ > + : TrueType + { }; + +template +struct IsMessage< ::realsense_msgs::motion_stream_info_ const> + : TrueType + { }; + +template +struct HasHeader< ::realsense_msgs::motion_stream_info_ > + : FalseType + { }; + +template +struct HasHeader< ::realsense_msgs::motion_stream_info_ const> + : FalseType + { }; + + +template +struct MD5Sum< ::realsense_msgs::motion_stream_info_ > +{ + static const char* value() + { + return "02cc8b81050aeef9ff36df30d8eacb2d"; + } + + static const char* value(const ::realsense_msgs::motion_stream_info_&) { return value(); } + static const uint64_t static_value1 = 0x02cc8b81050aeef9ULL; + static const uint64_t static_value2 = 0xff36df30d8eacb2dULL; +}; + +template +struct DataType< ::realsense_msgs::motion_stream_info_ > +{ + static const char* value() + { + return "realsense_msgs/motion_stream_info"; + } + + static const char* value(const ::realsense_msgs::motion_stream_info_&) { return value(); } +}; + +template +struct Definition< ::realsense_msgs::motion_stream_info_ > +{ + static const char* value() + { + return "string motion_type\n\ +uint32 fps\n\ +realsense_msgs/motion_intrinsics stream_intrinsics\n\ +realsense_msgs/stream_extrinsics stream_extrinsics\n\ +\n\ +\n\ +================================================================================\n\ +MSG: realsense_msgs/motion_intrinsics\n\ +float32[12] data\n\ +float32[3] noise_variances\n\ +float32[3] bias_variances\n\ +\n\ +================================================================================\n\ +MSG: realsense_msgs/stream_extrinsics\n\ +realsense_msgs/extrinsics extrinsics\n\ +uint64 reference_point_id\n\ +\n\ +================================================================================\n\ +MSG: realsense_msgs/extrinsics\n\ +float32[9] rotation # column-major 3x3 rotation matrix \n\ +float32[3] translation # 3 element translation vector, in meters \n\ +"; + } + + static const char* value(const ::realsense_msgs::motion_stream_info_&) { return value(); } +}; + +} // namespace message_traits +} // namespace ros + +namespace ros +{ +namespace serialization +{ + + template struct Serializer< ::realsense_msgs::motion_stream_info_ > + { + template inline static void allInOne(Stream& stream, T m) + { + stream.next(m.motion_type); + stream.next(m.fps); + stream.next(m.stream_intrinsics); + stream.next(m.stream_extrinsics); + } + + ROS_DECLARE_ALLINONE_SERIALIZER; + }; // struct motion_stream_info_ + +} // namespace serialization +} // namespace ros + +namespace ros +{ +namespace message_operations +{ + +template +struct Printer< ::realsense_msgs::motion_stream_info_ > +{ + template static void stream(Stream& s, const std::string& indent, const ::realsense_msgs::motion_stream_info_& v) + { + s << indent << "motion_type: "; + Printer, typename ContainerAllocator::template rebind::other > >::stream(s, indent + " ", v.motion_type); + s << indent << "fps: "; + Printer::stream(s, indent + " ", v.fps); + s << indent << "stream_intrinsics: "; + s << std::endl; + Printer< ::realsense_msgs::motion_intrinsics_ >::stream(s, indent + " ", v.stream_intrinsics); + s << indent << "stream_extrinsics: "; + s << std::endl; + Printer< ::realsense_msgs::stream_extrinsics_ >::stream(s, indent + " ", v.stream_extrinsics); + } +}; + +} // namespace message_operations +} // namespace ros + +#endif // REALSENSE_MSGS_MESSAGE_MOTION_STREAM_INFO_H diff --git a/realsense-file/src/storage/realsense_file/include/msgs/realsense_msgs/occupancy_map.h b/realsense-file/src/storage/realsense_file/include/msgs/realsense_msgs/occupancy_map.h new file mode 100644 index 0000000000..5a71629520 --- /dev/null +++ b/realsense-file/src/storage/realsense_file/include/msgs/realsense_msgs/occupancy_map.h @@ -0,0 +1,217 @@ +// Generated by gencpp from file realsense_msgs/occupancy_map.msg +// DO NOT EDIT! + + +#ifndef REALSENSE_MSGS_MESSAGE_OCCUPANCY_MAP_H +#define REALSENSE_MSGS_MESSAGE_OCCUPANCY_MAP_H + +#include +#include +#include +#include + +#include +#include +#include +#include + + +namespace realsense_msgs +{ +template +struct occupancy_map_ +{ + typedef occupancy_map_ Type; + + occupancy_map_() + : accuracy(0) + , reserved(0) + , tile_count(0) + , tiles() { + } + occupancy_map_(const ContainerAllocator& _alloc) + : accuracy(0) + , reserved(0) + , tile_count(0) + , tiles(_alloc) { + (void)_alloc; + } + + + + typedef uint8_t _accuracy_type; + _accuracy_type accuracy; + + typedef int8_t _reserved_type; + _reserved_type reserved; + + typedef uint16_t _tile_count_type; + _tile_count_type tile_count; + + typedef std::vector::other > _tiles_type; + _tiles_type tiles; + + + + + typedef std::shared_ptr< ::realsense_msgs::occupancy_map_ > Ptr; + typedef std::shared_ptr< ::realsense_msgs::occupancy_map_ const> ConstPtr; + +}; // struct occupancy_map_ + +typedef ::realsense_msgs::occupancy_map_ > occupancy_map; + +typedef std::shared_ptr< ::realsense_msgs::occupancy_map > occupancy_mapPtr; +typedef std::shared_ptr< ::realsense_msgs::occupancy_map const> occupancy_mapConstPtr; + +// constants requiring out of line definition + + + +template +std::ostream& operator<<(std::ostream& s, const ::realsense_msgs::occupancy_map_ & v) +{ +ros::message_operations::Printer< ::realsense_msgs::occupancy_map_ >::stream(s, "", v); +return s; +} + +} // namespace realsense_msgs + +namespace ros +{ +namespace message_traits +{ + + + +// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': False} +// {'sensor_msgs': ['/opt/ros/kinetic/share/sensor_msgs/cmake/../msg'], 'geometry_msgs': ['/opt/ros/kinetic/share/geometry_msgs/cmake/../msg'], 'std_msgs': ['/opt/ros/kinetic/share/std_msgs/cmake/../msg'], 'realsense_msgs': ['/home/administrator/realsense_ros_file/realsense_file/realsense_msgs/msg']} + +// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types'] + + + + +template +struct IsFixedSize< ::realsense_msgs::occupancy_map_ > + : FalseType + { }; + +template +struct IsFixedSize< ::realsense_msgs::occupancy_map_ const> + : FalseType + { }; + +template +struct IsMessage< ::realsense_msgs::occupancy_map_ > + : TrueType + { }; + +template +struct IsMessage< ::realsense_msgs::occupancy_map_ const> + : TrueType + { }; + +template +struct HasHeader< ::realsense_msgs::occupancy_map_ > + : FalseType + { }; + +template +struct HasHeader< ::realsense_msgs::occupancy_map_ const> + : FalseType + { }; + + +template +struct MD5Sum< ::realsense_msgs::occupancy_map_ > +{ + static const char* value() + { + return "e1b78aba30e7abd0605079857ac6fbc7"; + } + + static const char* value(const ::realsense_msgs::occupancy_map_&) { return value(); } + static const uint64_t static_value1 = 0xe1b78aba30e7abd0ULL; + static const uint64_t static_value2 = 0x605079857ac6fbc7ULL; +}; + +template +struct DataType< ::realsense_msgs::occupancy_map_ > +{ + static const char* value() + { + return "realsense_msgs/occupancy_map"; + } + + static const char* value(const ::realsense_msgs::occupancy_map_&) { return value(); } +}; + +template +struct Definition< ::realsense_msgs::occupancy_map_ > +{ + static const char* value() + { + return "uint8 accuracy\n\ +byte reserved\n\ +uint16 tile_count\n\ +float32[] tiles\n\ +"; + } + + static const char* value(const ::realsense_msgs::occupancy_map_&) { return value(); } +}; + +} // namespace message_traits +} // namespace ros + +namespace ros +{ +namespace serialization +{ + + template struct Serializer< ::realsense_msgs::occupancy_map_ > + { + template inline static void allInOne(Stream& stream, T m) + { + stream.next(m.accuracy); + stream.next(m.reserved); + stream.next(m.tile_count); + stream.next(m.tiles); + } + + ROS_DECLARE_ALLINONE_SERIALIZER; + }; // struct occupancy_map_ + +} // namespace serialization +} // namespace ros + +namespace ros +{ +namespace message_operations +{ + +template +struct Printer< ::realsense_msgs::occupancy_map_ > +{ + template static void stream(Stream& s, const std::string& indent, const ::realsense_msgs::occupancy_map_& v) + { + s << indent << "accuracy: "; + Printer::stream(s, indent + " ", v.accuracy); + s << indent << "reserved: "; + Printer::stream(s, indent + " ", v.reserved); + s << indent << "tile_count: "; + Printer::stream(s, indent + " ", v.tile_count); + s << indent << "tiles[]" << std::endl; + for (size_t i = 0; i < v.tiles.size(); ++i) + { + s << indent << " tiles[" << i << "]: "; + Printer::stream(s, indent + " ", v.tiles[i]); + } + } +}; + +} // namespace message_operations +} // namespace ros + +#endif // REALSENSE_MSGS_MESSAGE_OCCUPANCY_MAP_H diff --git a/realsense-file/src/storage/realsense_file/include/msgs/realsense_msgs/pose.h b/realsense-file/src/storage/realsense_file/include/msgs/realsense_msgs/pose.h new file mode 100644 index 0000000000..3f2815bac5 --- /dev/null +++ b/realsense-file/src/storage/realsense_file/include/msgs/realsense_msgs/pose.h @@ -0,0 +1,282 @@ +// Generated by gencpp from file realsense_msgs/pose.msg +// DO NOT EDIT! + + +#ifndef REALSENSE_MSGS_MESSAGE_POSE_H +#define REALSENSE_MSGS_MESSAGE_POSE_H + +#include +#include +#include +#include + +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +namespace realsense_msgs +{ +template +struct pose_ +{ + typedef pose_ Type; + + pose_() + : translation() + , rotation() + , velocity() + , angular_velocity() + , acceleration() + , angular_acceleration() + , timestamp(0) + , system_timestamp(0) { + } + pose_(const ContainerAllocator& _alloc) + : translation(_alloc) + , rotation(_alloc) + , velocity(_alloc) + , angular_velocity(_alloc) + , acceleration(_alloc) + , angular_acceleration(_alloc) + , timestamp(0) + , system_timestamp(0) { + (void)_alloc; + } + + + + typedef ::geometry_msgs::Vector3_ _translation_type; + _translation_type translation; + + typedef ::geometry_msgs::Quaternion_ _rotation_type; + _rotation_type rotation; + + typedef ::geometry_msgs::Vector3_ _velocity_type; + _velocity_type velocity; + + typedef ::geometry_msgs::Vector3_ _angular_velocity_type; + _angular_velocity_type angular_velocity; + + typedef ::geometry_msgs::Vector3_ _acceleration_type; + _acceleration_type acceleration; + + typedef ::geometry_msgs::Vector3_ _angular_acceleration_type; + _angular_acceleration_type angular_acceleration; + + typedef uint64_t _timestamp_type; + _timestamp_type timestamp; + + typedef uint64_t _system_timestamp_type; + _system_timestamp_type system_timestamp; + + + + + typedef std::shared_ptr< ::realsense_msgs::pose_ > Ptr; + typedef std::shared_ptr< ::realsense_msgs::pose_ const> ConstPtr; + +}; // struct pose_ + +typedef ::realsense_msgs::pose_ > pose; + +typedef std::shared_ptr< ::realsense_msgs::pose > posePtr; +typedef std::shared_ptr< ::realsense_msgs::pose const> poseConstPtr; + +// constants requiring out of line definition + + + +template +std::ostream& operator<<(std::ostream& s, const ::realsense_msgs::pose_ & v) +{ +ros::message_operations::Printer< ::realsense_msgs::pose_ >::stream(s, "", v); +return s; +} + +} // namespace realsense_msgs + +namespace ros +{ +namespace message_traits +{ + + + +// BOOLTRAITS {'IsFixedSize': True, 'IsMessage': True, 'HasHeader': False} +// {'sensor_msgs': ['/opt/ros/kinetic/share/sensor_msgs/cmake/../msg'], 'geometry_msgs': ['/opt/ros/kinetic/share/geometry_msgs/cmake/../msg'], 'std_msgs': ['/opt/ros/kinetic/share/std_msgs/cmake/../msg'], 'realsense_msgs': ['/home/administrator/ros/realsense_sdk_internal/sdk_internal/tools/realsense_msgs_generator/msg']} + +// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types'] + + + + +template +struct IsFixedSize< ::realsense_msgs::pose_ > + : TrueType + { }; + +template +struct IsFixedSize< ::realsense_msgs::pose_ const> + : TrueType + { }; + +template +struct IsMessage< ::realsense_msgs::pose_ > + : TrueType + { }; + +template +struct IsMessage< ::realsense_msgs::pose_ const> + : TrueType + { }; + +template +struct HasHeader< ::realsense_msgs::pose_ > + : FalseType + { }; + +template +struct HasHeader< ::realsense_msgs::pose_ const> + : FalseType + { }; + + +template +struct MD5Sum< ::realsense_msgs::pose_ > +{ + static const char* value() + { + return "befd7be861f6533fae56f3f40630413c"; + } + + static const char* value(const ::realsense_msgs::pose_&) { return value(); } + static const uint64_t static_value1 = 0xbefd7be861f6533fULL; + static const uint64_t static_value2 = 0xae56f3f40630413cULL; +}; + +template +struct DataType< ::realsense_msgs::pose_ > +{ + static const char* value() + { + return "realsense_msgs/pose"; + } + + static const char* value(const ::realsense_msgs::pose_&) { return value(); } +}; + +template +struct Definition< ::realsense_msgs::pose_ > +{ + static const char* value() + { + return "geometry_msgs/Vector3 translation\n\ +geometry_msgs/Quaternion rotation \n\ +geometry_msgs/Vector3 velocity \n\ +geometry_msgs/Vector3 angular_velocity \n\ +geometry_msgs/Vector3 acceleration \n\ +geometry_msgs/Vector3 angular_acceleration\n\ +uint64 timestamp\n\ +uint64 system_timestamp\n\ +\n\ +================================================================================\n\ +MSG: geometry_msgs/Vector3\n\ +# This represents a vector in free space. \n\ +# It is only meant to represent a direction. Therefore, it does not\n\ +# make sense to apply a translation to it (e.g., when applying a \n\ +# generic rigid transformation to a Vector3, tf2 will only apply the\n\ +# rotation). If you want your data to be translatable too, use the\n\ +# geometry_msgs/Point message instead.\n\ +\n\ +float64 x\n\ +float64 y\n\ +float64 z\n\ +================================================================================\n\ +MSG: geometry_msgs/Quaternion\n\ +# This represents an orientation in free space in quaternion form.\n\ +\n\ +float64 x\n\ +float64 y\n\ +float64 z\n\ +float64 w\n\ +"; + } + + static const char* value(const ::realsense_msgs::pose_&) { return value(); } +}; + +} // namespace message_traits +} // namespace ros + +namespace ros +{ +namespace serialization +{ + + template struct Serializer< ::realsense_msgs::pose_ > + { + template inline static void allInOne(Stream& stream, T m) + { + stream.next(m.translation); + stream.next(m.rotation); + stream.next(m.velocity); + stream.next(m.angular_velocity); + stream.next(m.acceleration); + stream.next(m.angular_acceleration); + stream.next(m.timestamp); + stream.next(m.system_timestamp); + } + + ROS_DECLARE_ALLINONE_SERIALIZER; + }; // struct pose_ + +} // namespace serialization +} // namespace ros + +namespace ros +{ +namespace message_operations +{ + +template +struct Printer< ::realsense_msgs::pose_ > +{ + template static void stream(Stream& s, const std::string& indent, const ::realsense_msgs::pose_& v) + { + s << indent << "translation: "; + s << std::endl; + Printer< ::geometry_msgs::Vector3_ >::stream(s, indent + " ", v.translation); + s << indent << "rotation: "; + s << std::endl; + Printer< ::geometry_msgs::Quaternion_ >::stream(s, indent + " ", v.rotation); + s << indent << "velocity: "; + s << std::endl; + Printer< ::geometry_msgs::Vector3_ >::stream(s, indent + " ", v.velocity); + s << indent << "angular_velocity: "; + s << std::endl; + Printer< ::geometry_msgs::Vector3_ >::stream(s, indent + " ", v.angular_velocity); + s << indent << "acceleration: "; + s << std::endl; + Printer< ::geometry_msgs::Vector3_ >::stream(s, indent + " ", v.acceleration); + s << indent << "angular_acceleration: "; + s << std::endl; + Printer< ::geometry_msgs::Vector3_ >::stream(s, indent + " ", v.angular_acceleration); + s << indent << "timestamp: "; + Printer::stream(s, indent + " ", v.timestamp); + s << indent << "system_timestamp: "; + Printer::stream(s, indent + " ", v.system_timestamp); + } +}; + +} // namespace message_operations +} // namespace ros + +#endif // REALSENSE_MSGS_MESSAGE_POSE_H diff --git a/realsense-file/src/storage/realsense_file/include/msgs/realsense_msgs/stream_extrinsics.h b/realsense-file/src/storage/realsense_file/include/msgs/realsense_msgs/stream_extrinsics.h new file mode 100644 index 0000000000..c180e8800e --- /dev/null +++ b/realsense-file/src/storage/realsense_file/include/msgs/realsense_msgs/stream_extrinsics.h @@ -0,0 +1,202 @@ +// Generated by gencpp from file realsense_msgs/stream_extrinsics.msg +// DO NOT EDIT! + + +#ifndef REALSENSE_MSGS_MESSAGE_STREAM_EXTRINSICS_H +#define REALSENSE_MSGS_MESSAGE_STREAM_EXTRINSICS_H + +#include +#include +#include +#include + +#include +#include +#include +#include + +#include + +namespace realsense_msgs +{ +template +struct stream_extrinsics_ +{ + typedef stream_extrinsics_ Type; + + stream_extrinsics_() + : extrinsics() + , reference_point_id(0) { + } + stream_extrinsics_(const ContainerAllocator& _alloc) + : extrinsics(_alloc) + , reference_point_id(0) { + (void)_alloc; + } + + + + typedef ::realsense_msgs::extrinsics_ _extrinsics_type; + _extrinsics_type extrinsics; + + typedef uint64_t _reference_point_id_type; + _reference_point_id_type reference_point_id; + + + + + typedef std::shared_ptr< ::realsense_msgs::stream_extrinsics_ > Ptr; + typedef std::shared_ptr< ::realsense_msgs::stream_extrinsics_ const> ConstPtr; + +}; // struct stream_extrinsics_ + +typedef ::realsense_msgs::stream_extrinsics_ > stream_extrinsics; + +typedef std::shared_ptr< ::realsense_msgs::stream_extrinsics > stream_extrinsicsPtr; +typedef std::shared_ptr< ::realsense_msgs::stream_extrinsics const> stream_extrinsicsConstPtr; + +// constants requiring out of line definition + + + +template +std::ostream& operator<<(std::ostream& s, const ::realsense_msgs::stream_extrinsics_ & v) +{ +ros::message_operations::Printer< ::realsense_msgs::stream_extrinsics_ >::stream(s, "", v); +return s; +} + +} // namespace realsense_msgs + +namespace ros +{ +namespace message_traits +{ + + + +// BOOLTRAITS {'IsFixedSize': True, 'IsMessage': True, 'HasHeader': False} +// {'sensor_msgs': ['/opt/ros/kinetic/share/sensor_msgs/cmake/../msg'], 'geometry_msgs': ['/opt/ros/kinetic/share/geometry_msgs/cmake/../msg'], 'std_msgs': ['/opt/ros/kinetic/share/std_msgs/cmake/../msg'], 'realsense_msgs': ['/home/administrator/ros/realsense_sdk_internal/sdk_internal/tools/realsense_msgs_generator/msg']} + +// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types'] + + + + +template +struct IsFixedSize< ::realsense_msgs::stream_extrinsics_ > + : TrueType + { }; + +template +struct IsFixedSize< ::realsense_msgs::stream_extrinsics_ const> + : TrueType + { }; + +template +struct IsMessage< ::realsense_msgs::stream_extrinsics_ > + : TrueType + { }; + +template +struct IsMessage< ::realsense_msgs::stream_extrinsics_ const> + : TrueType + { }; + +template +struct HasHeader< ::realsense_msgs::stream_extrinsics_ > + : FalseType + { }; + +template +struct HasHeader< ::realsense_msgs::stream_extrinsics_ const> + : FalseType + { }; + + +template +struct MD5Sum< ::realsense_msgs::stream_extrinsics_ > +{ + static const char* value() + { + return "442fca173ef45a4a4e680d953efd6523"; + } + + static const char* value(const ::realsense_msgs::stream_extrinsics_&) { return value(); } + static const uint64_t static_value1 = 0x442fca173ef45a4aULL; + static const uint64_t static_value2 = 0x4e680d953efd6523ULL; +}; + +template +struct DataType< ::realsense_msgs::stream_extrinsics_ > +{ + static const char* value() + { + return "realsense_msgs/stream_extrinsics"; + } + + static const char* value(const ::realsense_msgs::stream_extrinsics_&) { return value(); } +}; + +template +struct Definition< ::realsense_msgs::stream_extrinsics_ > +{ + static const char* value() + { + return "realsense_msgs/extrinsics extrinsics\n\ +uint64 reference_point_id\n\ +\n\ +================================================================================\n\ +MSG: realsense_msgs/extrinsics\n\ +float32[9] rotation # column-major 3x3 rotation matrix \n\ +float32[3] translation # 3 element translation vector, in meters \n\ +"; + } + + static const char* value(const ::realsense_msgs::stream_extrinsics_&) { return value(); } +}; + +} // namespace message_traits +} // namespace ros + +namespace ros +{ +namespace serialization +{ + + template struct Serializer< ::realsense_msgs::stream_extrinsics_ > + { + template inline static void allInOne(Stream& stream, T m) + { + stream.next(m.extrinsics); + stream.next(m.reference_point_id); + } + + ROS_DECLARE_ALLINONE_SERIALIZER; + }; // struct stream_extrinsics_ + +} // namespace serialization +} // namespace ros + +namespace ros +{ +namespace message_operations +{ + +template +struct Printer< ::realsense_msgs::stream_extrinsics_ > +{ + template static void stream(Stream& s, const std::string& indent, const ::realsense_msgs::stream_extrinsics_& v) + { + s << indent << "extrinsics: "; + s << std::endl; + Printer< ::realsense_msgs::extrinsics_ >::stream(s, indent + " ", v.extrinsics); + s << indent << "reference_point_id: "; + Printer::stream(s, indent + " ", v.reference_point_id); + } +}; + +} // namespace message_operations +} // namespace ros + +#endif // REALSENSE_MSGS_MESSAGE_STREAM_EXTRINSICS_H diff --git a/realsense-file/src/storage/realsense_file/include/msgs/realsense_msgs/stream_info.h b/realsense-file/src/storage/realsense_file/include/msgs/realsense_msgs/stream_info.h new file mode 100644 index 0000000000..23e07dddac --- /dev/null +++ b/realsense-file/src/storage/realsense_file/include/msgs/realsense_msgs/stream_info.h @@ -0,0 +1,428 @@ +// Generated by gencpp from file realsense_msgs/stream_info.msg +// DO NOT EDIT! + + +#ifndef REALSENSE_MSGS_MESSAGE_STREAM_INFO_H +#define REALSENSE_MSGS_MESSAGE_STREAM_INFO_H + +#include +#include +#include +#include + +#include +#include +#include +#include + +#include +#include + +namespace realsense_msgs +{ +template +struct stream_info_ +{ + typedef stream_info_ Type; + + stream_info_() + : stream_type() + , fps(0) + , camera_info() + , stream_extrinsics() + , width(0) + , height(0) + , encoding() { + } + stream_info_(const ContainerAllocator& _alloc) + : stream_type(_alloc) + , fps(0) + , camera_info(_alloc) + , stream_extrinsics(_alloc) + , width(0) + , height(0) + , encoding(_alloc) { + (void)_alloc; + } + + + + typedef std::basic_string, typename ContainerAllocator::template rebind::other > _stream_type_type; + _stream_type_type stream_type; + + typedef uint32_t _fps_type; + _fps_type fps; + + typedef ::sensor_msgs::CameraInfo_ _camera_info_type; + _camera_info_type camera_info; + + typedef ::realsense_msgs::stream_extrinsics_ _stream_extrinsics_type; + _stream_extrinsics_type stream_extrinsics; + + typedef uint32_t _width_type; + _width_type width; + + typedef uint32_t _height_type; + _height_type height; + + typedef std::basic_string, typename ContainerAllocator::template rebind::other > _encoding_type; + _encoding_type encoding; + + + + + typedef std::shared_ptr< ::realsense_msgs::stream_info_ > Ptr; + typedef std::shared_ptr< ::realsense_msgs::stream_info_ const> ConstPtr; + +}; // struct stream_info_ + +typedef ::realsense_msgs::stream_info_ > stream_info; + +typedef std::shared_ptr< ::realsense_msgs::stream_info > stream_infoPtr; +typedef std::shared_ptr< ::realsense_msgs::stream_info const> stream_infoConstPtr; + +// constants requiring out of line definition + + + +template +std::ostream& operator<<(std::ostream& s, const ::realsense_msgs::stream_info_ & v) +{ +ros::message_operations::Printer< ::realsense_msgs::stream_info_ >::stream(s, "", v); +return s; +} + +} // namespace realsense_msgs + +namespace ros +{ +namespace message_traits +{ + + + +// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': False} +// {'sensor_msgs': ['/opt/ros/kinetic/share/sensor_msgs/cmake/../msg'], 'geometry_msgs': ['/opt/ros/kinetic/share/geometry_msgs/cmake/../msg'], 'std_msgs': ['/opt/ros/kinetic/share/std_msgs/cmake/../msg'], 'realsense_msgs': ['/home/administrator/ros/realsense_sdk_internal/sdk_internal/tools/realsense_msgs_generator/msg']} + +// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types'] + + + + +template +struct IsFixedSize< ::realsense_msgs::stream_info_ > + : FalseType + { }; + +template +struct IsFixedSize< ::realsense_msgs::stream_info_ const> + : FalseType + { }; + +template +struct IsMessage< ::realsense_msgs::stream_info_ > + : TrueType + { }; + +template +struct IsMessage< ::realsense_msgs::stream_info_ const> + : TrueType + { }; + +template +struct HasHeader< ::realsense_msgs::stream_info_ > + : FalseType + { }; + +template +struct HasHeader< ::realsense_msgs::stream_info_ const> + : FalseType + { }; + + +template +struct MD5Sum< ::realsense_msgs::stream_info_ > +{ + static const char* value() + { + return "bb1936d2159196ee8329f39f35277eb4"; + } + + static const char* value(const ::realsense_msgs::stream_info_&) { return value(); } + static const uint64_t static_value1 = 0xbb1936d2159196eeULL; + static const uint64_t static_value2 = 0x8329f39f35277eb4ULL; +}; + +template +struct DataType< ::realsense_msgs::stream_info_ > +{ + static const char* value() + { + return "realsense_msgs/stream_info"; + } + + static const char* value(const ::realsense_msgs::stream_info_&) { return value(); } +}; + +template +struct Definition< ::realsense_msgs::stream_info_ > +{ + static const char* value() + { + return "string stream_type\n\ +uint32 fps\n\ +sensor_msgs/CameraInfo camera_info\n\ +realsense_msgs/stream_extrinsics stream_extrinsics\n\ +uint32 width\n\ +uint32 height \n\ +string encoding\n\ +\n\ +================================================================================\n\ +MSG: sensor_msgs/CameraInfo\n\ +# This message defines meta information for a camera. It should be in a\n\ +# camera namespace on topic \"camera_info\" and accompanied by up to five\n\ +# image topics named:\n\ +#\n\ +# image_raw - raw data from the camera driver, possibly Bayer encoded\n\ +# image - monochrome, distorted\n\ +# image_color - color, distorted\n\ +# image_rect - monochrome, rectified\n\ +# image_rect_color - color, rectified\n\ +#\n\ +# The image_pipeline contains packages (image_proc, stereo_image_proc)\n\ +# for producing the four processed image topics from image_raw and\n\ +# camera_info. The meaning of the camera parameters are described in\n\ +# detail at http://www.ros.org/wiki/image_pipeline/CameraInfo.\n\ +#\n\ +# The image_geometry package provides a user-friendly interface to\n\ +# common operations using this meta information. If you want to, e.g.,\n\ +# project a 3d point into image coordinates, we strongly recommend\n\ +# using image_geometry.\n\ +#\n\ +# If the camera is uncalibrated, the matrices D, K, R, P should be left\n\ +# zeroed out. In particular, clients may assume that K[0] == 0.0\n\ +# indicates an uncalibrated camera.\n\ +\n\ +#######################################################################\n\ +# Image acquisition info #\n\ +#######################################################################\n\ +\n\ +# Time of image acquisition, camera coordinate frame ID\n\ +Header header # Header timestamp should be acquisition time of image\n\ + # Header frame_id should be optical frame of camera\n\ + # origin of frame should be optical center of camera\n\ + # +x should point to the right in the image\n\ + # +y should point down in the image\n\ + # +z should point into the plane of the image\n\ +\n\ +\n\ +#######################################################################\n\ +# Calibration Parameters #\n\ +#######################################################################\n\ +# These are fixed during camera calibration. Their values will be the #\n\ +# same in all messages until the camera is recalibrated. Note that #\n\ +# self-calibrating systems may \"recalibrate\" frequently. #\n\ +# #\n\ +# The internal parameters can be used to warp a raw (distorted) image #\n\ +# to: #\n\ +# 1. An undistorted image (requires D and K) #\n\ +# 2. A rectified image (requires D, K, R) #\n\ +# The projection matrix P projects 3D points into the rectified image.#\n\ +#######################################################################\n\ +\n\ +# The image dimensions with which the camera was calibrated. Normally\n\ +# this will be the full camera resolution in pixels.\n\ +uint32 height\n\ +uint32 width\n\ +\n\ +# The distortion model used. Supported models are listed in\n\ +# sensor_msgs/distortion_models.h. For most cameras, \"plumb_bob\" - a\n\ +# simple model of radial and tangential distortion - is sufficient.\n\ +string distortion_model\n\ +\n\ +# The distortion parameters, size depending on the distortion model.\n\ +# For \"plumb_bob\", the 5 parameters are: (k1, k2, t1, t2, k3).\n\ +float64[] D\n\ +\n\ +# Intrinsic camera matrix for the raw (distorted) images.\n\ +# [fx 0 cx]\n\ +# K = [ 0 fy cy]\n\ +# [ 0 0 1]\n\ +# Projects 3D points in the camera coordinate frame to 2D pixel\n\ +# coordinates using the focal lengths (fx, fy) and principal point\n\ +# (cx, cy).\n\ +float64[9] K # 3x3 row-major matrix\n\ +\n\ +# Rectification matrix (stereo cameras only)\n\ +# A rotation matrix aligning the camera coordinate system to the ideal\n\ +# stereo image plane so that epipolar lines in both stereo images are\n\ +# parallel.\n\ +float64[9] R # 3x3 row-major matrix\n\ +\n\ +# Projection/camera matrix\n\ +# [fx' 0 cx' Tx]\n\ +# P = [ 0 fy' cy' Ty]\n\ +# [ 0 0 1 0]\n\ +# By convention, this matrix specifies the intrinsic (camera) matrix\n\ +# of the processed (rectified) image. That is, the left 3x3 portion\n\ +# is the normal camera intrinsic matrix for the rectified image.\n\ +# It projects 3D points in the camera coordinate frame to 2D pixel\n\ +# coordinates using the focal lengths (fx', fy') and principal point\n\ +# (cx', cy') - these may differ from the values in K.\n\ +# For monocular cameras, Tx = Ty = 0. Normally, monocular cameras will\n\ +# also have R = the identity and P[1:3,1:3] = K.\n\ +# For a stereo pair, the fourth column [Tx Ty 0]' is related to the\n\ +# position of the optical center of the second camera in the first\n\ +# camera's frame. We assume Tz = 0 so both cameras are in the same\n\ +# stereo image plane. The first camera always has Tx = Ty = 0. For\n\ +# the right (second) camera of a horizontal stereo pair, Ty = 0 and\n\ +# Tx = -fx' * B, where B is the baseline between the cameras.\n\ +# Given a 3D point [X Y Z]', the projection (x, y) of the point onto\n\ +# the rectified image is given by:\n\ +# [u v w]' = P * [X Y Z 1]'\n\ +# x = u / w\n\ +# y = v / w\n\ +# This holds for both images of a stereo pair.\n\ +float64[12] P # 3x4 row-major matrix\n\ +\n\ +\n\ +#######################################################################\n\ +# Operational Parameters #\n\ +#######################################################################\n\ +# These define the image region actually captured by the camera #\n\ +# driver. Although they affect the geometry of the output image, they #\n\ +# may be changed freely without recalibrating the camera. #\n\ +#######################################################################\n\ +\n\ +# Binning refers here to any camera setting which combines rectangular\n\ +# neighborhoods of pixels into larger \"super-pixels.\" It reduces the\n\ +# resolution of the output image to\n\ +# (width / binning_x) x (height / binning_y).\n\ +# The default values binning_x = binning_y = 0 is considered the same\n\ +# as binning_x = binning_y = 1 (no subsampling).\n\ +uint32 binning_x\n\ +uint32 binning_y\n\ +\n\ +# Region of interest (subwindow of full camera resolution), given in\n\ +# full resolution (unbinned) image coordinates. A particular ROI\n\ +# always denotes the same window of pixels on the camera sensor,\n\ +# regardless of binning settings.\n\ +# The default setting of roi (all values 0) is considered the same as\n\ +# full resolution (roi.width = width, roi.height = height).\n\ +RegionOfInterest roi\n\ +\n\ +================================================================================\n\ +MSG: std_msgs/Header\n\ +# Standard metadata for higher-level stamped data types.\n\ +# This is generally used to communicate timestamped data \n\ +# in a particular coordinate frame.\n\ +# \n\ +# sequence ID: consecutively increasing ID \n\ +uint32 seq\n\ +#Two-integer timestamp that is expressed as:\n\ +# * stamp.sec: seconds (stamp_secs) since epoch (in Python the variable is called 'secs')\n\ +# * stamp.nsec: nanoseconds since stamp_secs (in Python the variable is called 'nsecs')\n\ +# time-handling sugar is provided by the client library\n\ +time stamp\n\ +#Frame this data is associated with\n\ +# 0: no frame\n\ +# 1: global frame\n\ +string frame_id\n\ +\n\ +================================================================================\n\ +MSG: sensor_msgs/RegionOfInterest\n\ +# This message is used to specify a region of interest within an image.\n\ +#\n\ +# When used to specify the ROI setting of the camera when the image was\n\ +# taken, the height and width fields should either match the height and\n\ +# width fields for the associated image; or height = width = 0\n\ +# indicates that the full resolution image was captured.\n\ +\n\ +uint32 x_offset # Leftmost pixel of the ROI\n\ + # (0 if the ROI includes the left edge of the image)\n\ +uint32 y_offset # Topmost pixel of the ROI\n\ + # (0 if the ROI includes the top edge of the image)\n\ +uint32 height # Height of ROI\n\ +uint32 width # Width of ROI\n\ +\n\ +# True if a distinct rectified ROI should be calculated from the \"raw\"\n\ +# ROI in this message. Typically this should be False if the full image\n\ +# is captured (ROI not used), and True if a subwindow is captured (ROI\n\ +# used).\n\ +bool do_rectify\n\ +\n\ +================================================================================\n\ +MSG: realsense_msgs/stream_extrinsics\n\ +realsense_msgs/extrinsics extrinsics\n\ +uint64 reference_point_id\n\ +\n\ +================================================================================\n\ +MSG: realsense_msgs/extrinsics\n\ +float32[9] rotation # column-major 3x3 rotation matrix \n\ +float32[3] translation # 3 element translation vector, in meters \n\ +"; + } + + static const char* value(const ::realsense_msgs::stream_info_&) { return value(); } +}; + +} // namespace message_traits +} // namespace ros + +namespace ros +{ +namespace serialization +{ + + template struct Serializer< ::realsense_msgs::stream_info_ > + { + template inline static void allInOne(Stream& stream, T m) + { + stream.next(m.stream_type); + stream.next(m.fps); + stream.next(m.camera_info); + stream.next(m.stream_extrinsics); + stream.next(m.width); + stream.next(m.height); + stream.next(m.encoding); + } + + ROS_DECLARE_ALLINONE_SERIALIZER; + }; // struct stream_info_ + +} // namespace serialization +} // namespace ros + +namespace ros +{ +namespace message_operations +{ + +template +struct Printer< ::realsense_msgs::stream_info_ > +{ + template static void stream(Stream& s, const std::string& indent, const ::realsense_msgs::stream_info_& v) + { + s << indent << "stream_type: "; + Printer, typename ContainerAllocator::template rebind::other > >::stream(s, indent + " ", v.stream_type); + s << indent << "fps: "; + Printer::stream(s, indent + " ", v.fps); + s << indent << "camera_info: "; + s << std::endl; + Printer< ::sensor_msgs::CameraInfo_ >::stream(s, indent + " ", v.camera_info); + s << indent << "stream_extrinsics: "; + s << std::endl; + Printer< ::realsense_msgs::stream_extrinsics_ >::stream(s, indent + " ", v.stream_extrinsics); + s << indent << "width: "; + Printer::stream(s, indent + " ", v.width); + s << indent << "height: "; + Printer::stream(s, indent + " ", v.height); + s << indent << "encoding: "; + Printer, typename ContainerAllocator::template rebind::other > >::stream(s, indent + " ", v.encoding); + } +}; + +} // namespace message_operations +} // namespace ros + +#endif // REALSENSE_MSGS_MESSAGE_STREAM_INFO_H diff --git a/realsense-file/src/storage/realsense_file/include/msgs/realsense_msgs/vendor_data.h b/realsense-file/src/storage/realsense_file/include/msgs/realsense_msgs/vendor_data.h new file mode 100644 index 0000000000..c2fd89c1b2 --- /dev/null +++ b/realsense-file/src/storage/realsense_file/include/msgs/realsense_msgs/vendor_data.h @@ -0,0 +1,195 @@ +// Generated by gencpp from file realsense_msgs/vendor_data.msg +// DO NOT EDIT! + + +#ifndef REALSENSE_MSGS_MESSAGE_VENDOR_DATA_H +#define REALSENSE_MSGS_MESSAGE_VENDOR_DATA_H + + +#include +#include +#include + +#include +#include +#include +#include + + +namespace realsense_msgs +{ +template +struct vendor_data_ +{ + typedef vendor_data_ Type; + + vendor_data_() + : name() + , value() { + } + vendor_data_(const ContainerAllocator& _alloc) + : name(_alloc) + , value(_alloc) { + (void)_alloc; + } + + + + typedef std::basic_string, typename ContainerAllocator::template rebind::other > _name_type; + _name_type name; + + typedef std::basic_string, typename ContainerAllocator::template rebind::other > _value_type; + _value_type value; + + + + + typedef std::shared_ptr< ::realsense_msgs::vendor_data_ > Ptr; + typedef std::shared_ptr< ::realsense_msgs::vendor_data_ const> ConstPtr; + +}; // struct vendor_data_ + +typedef ::realsense_msgs::vendor_data_ > vendor_data; + +typedef std::shared_ptr< ::realsense_msgs::vendor_data > vendor_dataPtr; +typedef std::shared_ptr< ::realsense_msgs::vendor_data const> vendor_dataConstPtr; + +// constants requiring out of line definition + + + +template +std::ostream& operator<<(std::ostream& s, const ::realsense_msgs::vendor_data_ & v) +{ +ros::message_operations::Printer< ::realsense_msgs::vendor_data_ >::stream(s, "", v); +return s; +} + +} // namespace realsense_msgs + +namespace ros +{ +namespace message_traits +{ + + + +// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': False} +// {'sensor_msgs': ['/opt/ros/kinetic/share/sensor_msgs/cmake/../msg'], 'geometry_msgs': ['/opt/ros/kinetic/share/geometry_msgs/cmake/../msg'], 'std_msgs': ['/opt/ros/kinetic/share/std_msgs/cmake/../msg'], 'realsense_msgs': ['/home/administrator/realsense_ros_file/realsense_file/realsense_msgs/msg']} + +// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types'] + + + + +template +struct IsFixedSize< ::realsense_msgs::vendor_data_ > + : FalseType + { }; + +template +struct IsFixedSize< ::realsense_msgs::vendor_data_ const> + : FalseType + { }; + +template +struct IsMessage< ::realsense_msgs::vendor_data_ > + : TrueType + { }; + +template +struct IsMessage< ::realsense_msgs::vendor_data_ const> + : TrueType + { }; + +template +struct HasHeader< ::realsense_msgs::vendor_data_ > + : FalseType + { }; + +template +struct HasHeader< ::realsense_msgs::vendor_data_ const> + : FalseType + { }; + + +template +struct MD5Sum< ::realsense_msgs::vendor_data_ > +{ + static const char* value() + { + return "bc6ccc4a57f61779c8eaae61e9f422e0"; + } + + static const char* value(const ::realsense_msgs::vendor_data_&) { return value(); } + static const uint64_t static_value1 = 0xbc6ccc4a57f61779ULL; + static const uint64_t static_value2 = 0xc8eaae61e9f422e0ULL; +}; + +template +struct DataType< ::realsense_msgs::vendor_data_ > +{ + static const char* value() + { + return "realsense_msgs/vendor_data"; + } + + static const char* value(const ::realsense_msgs::vendor_data_&) { return value(); } +}; + +template +struct Definition< ::realsense_msgs::vendor_data_ > +{ + static const char* value() + { + return "string name\n\ +string value\n\ +"; + } + + static const char* value(const ::realsense_msgs::vendor_data_&) { return value(); } +}; + +} // namespace message_traits +} // namespace ros + +namespace ros +{ +namespace serialization +{ + + template struct Serializer< ::realsense_msgs::vendor_data_ > + { + template inline static void allInOne(Stream& stream, T m) + { + stream.next(m.name); + stream.next(m.value); + } + + ROS_DECLARE_ALLINONE_SERIALIZER; + }; // struct vendor_data_ + +} // namespace serialization +} // namespace ros + +namespace ros +{ +namespace message_operations +{ + +template +struct Printer< ::realsense_msgs::vendor_data_ > +{ + template static void stream(Stream& s, const std::string& indent, const ::realsense_msgs::vendor_data_& v) + { + s << indent << "name: "; + Printer, typename ContainerAllocator::template rebind::other > >::stream(s, indent + " ", v.name); + s << indent << "value: "; + Printer, typename ContainerAllocator::template rebind::other > >::stream(s, indent + " ", v.value); + } +}; + +} // namespace message_operations +} // namespace ros + +#endif // REALSENSE_MSGS_MESSAGE_VENDOR_DATA_H diff --git a/realsense-file/src/storage/realsense_file/include/msgs/rosgraph_msgs/Clock.h b/realsense-file/src/storage/realsense_file/include/msgs/rosgraph_msgs/Clock.h new file mode 100644 index 0000000000..5403afa994 --- /dev/null +++ b/realsense-file/src/storage/realsense_file/include/msgs/rosgraph_msgs/Clock.h @@ -0,0 +1,189 @@ +// Generated by gencpp from file rosgraph_msgs/Clock.msg +// DO NOT EDIT! + + +#ifndef ROSGRAPH_MSGS_MESSAGE_CLOCK_H +#define ROSGRAPH_MSGS_MESSAGE_CLOCK_H + + +#include +#include +#include + +#include +#include +#include +#include + + +namespace rosgraph_msgs +{ +template +struct Clock_ +{ + typedef Clock_ Type; + + Clock_() + : clock() { + } + Clock_(const ContainerAllocator& _alloc) + : clock() { + (void)_alloc; + } + + + + typedef ros::Time _clock_type; + _clock_type clock; + + + + + typedef boost::shared_ptr< ::rosgraph_msgs::Clock_ > Ptr; + typedef boost::shared_ptr< ::rosgraph_msgs::Clock_ const> ConstPtr; + +}; // struct Clock_ + +typedef ::rosgraph_msgs::Clock_ > Clock; + +typedef boost::shared_ptr< ::rosgraph_msgs::Clock > ClockPtr; +typedef boost::shared_ptr< ::rosgraph_msgs::Clock const> ClockConstPtr; + +// constants requiring out of line definition + + + +template +std::ostream& operator<<(std::ostream& s, const ::rosgraph_msgs::Clock_ & v) +{ +ros::message_operations::Printer< ::rosgraph_msgs::Clock_ >::stream(s, "", v); +return s; +} + +} // namespace rosgraph_msgs + +namespace ros +{ +namespace message_traits +{ + + + +// BOOLTRAITS {'IsFixedSize': True, 'IsMessage': True, 'HasHeader': False} +// {'rosgraph_msgs': ['/tmp/binarydeb/ros-kinetic-rosgraph-msgs-1.11.2/msg'], 'std_msgs': ['/opt/ros/kinetic/share/std_msgs/cmake/../msg']} + +// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types'] + + + + +template +struct IsFixedSize< ::rosgraph_msgs::Clock_ > + : TrueType + { }; + +template +struct IsFixedSize< ::rosgraph_msgs::Clock_ const> + : TrueType + { }; + +template +struct IsMessage< ::rosgraph_msgs::Clock_ > + : TrueType + { }; + +template +struct IsMessage< ::rosgraph_msgs::Clock_ const> + : TrueType + { }; + +template +struct HasHeader< ::rosgraph_msgs::Clock_ > + : FalseType + { }; + +template +struct HasHeader< ::rosgraph_msgs::Clock_ const> + : FalseType + { }; + + +template +struct MD5Sum< ::rosgraph_msgs::Clock_ > +{ + static const char* value() + { + return "a9c97c1d230cfc112e270351a944ee47"; + } + + static const char* value(const ::rosgraph_msgs::Clock_&) { return value(); } + static const uint64_t static_value1 = 0xa9c97c1d230cfc11ULL; + static const uint64_t static_value2 = 0x2e270351a944ee47ULL; +}; + +template +struct DataType< ::rosgraph_msgs::Clock_ > +{ + static const char* value() + { + return "rosgraph_msgs/Clock"; + } + + static const char* value(const ::rosgraph_msgs::Clock_&) { return value(); } +}; + +template +struct Definition< ::rosgraph_msgs::Clock_ > +{ + static const char* value() + { + return "# roslib/Clock is used for publishing simulated time in ROS. \n\ +# This message simply communicates the current time.\n\ +# For more information, see http://www.ros.org/wiki/Clock\n\ +time clock\n\ +"; + } + + static const char* value(const ::rosgraph_msgs::Clock_&) { return value(); } +}; + +} // namespace message_traits +} // namespace ros + +namespace ros +{ +namespace serialization +{ + + template struct Serializer< ::rosgraph_msgs::Clock_ > + { + template inline static void allInOne(Stream& stream, T m) + { + stream.next(m.clock); + } + + ROS_DECLARE_ALLINONE_SERIALIZER; + }; // struct Clock_ + +} // namespace serialization +} // namespace ros + +namespace ros +{ +namespace message_operations +{ + +template +struct Printer< ::rosgraph_msgs::Clock_ > +{ + template static void stream(Stream& s, const std::string& indent, const ::rosgraph_msgs::Clock_& v) + { + s << indent << "clock: "; + Printer::stream(s, indent + " ", v.clock); + } +}; + +} // namespace message_operations +} // namespace ros + +#endif // ROSGRAPH_MSGS_MESSAGE_CLOCK_H diff --git a/realsense-file/src/storage/realsense_file/include/msgs/rosgraph_msgs/Log.h b/realsense-file/src/storage/realsense_file/include/msgs/rosgraph_msgs/Log.h new file mode 100644 index 0000000000..a49d762903 --- /dev/null +++ b/realsense-file/src/storage/realsense_file/include/msgs/rosgraph_msgs/Log.h @@ -0,0 +1,299 @@ +// Generated by gencpp from file rosgraph_msgs/Log.msg +// DO NOT EDIT! + + +#ifndef ROSGRAPH_MSGS_MESSAGE_LOG_H +#define ROSGRAPH_MSGS_MESSAGE_LOG_H + +#include +#include +#include +#include + +#include +#include +#include +#include + +#include + +namespace rosgraph_msgs +{ +template +struct Log_ +{ + typedef Log_ Type; + + Log_() + : header() + , level(0) + , name() + , msg() + , file() + , function() + , line(0) + , topics() { + } + Log_(const ContainerAllocator& _alloc) + : header(_alloc) + , level(0) + , name(_alloc) + , msg(_alloc) + , file(_alloc) + , function(_alloc) + , line(0) + , topics(_alloc) { + (void)_alloc; + } + + + + typedef ::std_msgs::Header_ _header_type; + _header_type header; + + typedef int8_t _level_type; + _level_type level; + + typedef std::basic_string, typename ContainerAllocator::template rebind::other > _name_type; + _name_type name; + + typedef std::basic_string, typename ContainerAllocator::template rebind::other > _msg_type; + _msg_type msg; + + typedef std::basic_string, typename ContainerAllocator::template rebind::other > _file_type; + _file_type file; + + typedef std::basic_string, typename ContainerAllocator::template rebind::other > _function_type; + _function_type function; + + typedef uint32_t _line_type; + _line_type line; + + typedef std::vector, typename ContainerAllocator::template rebind::other > , typename ContainerAllocator::template rebind, typename ContainerAllocator::template rebind::other > >::other > _topics_type; + _topics_type topics; + +#undef ERROR + enum { DEBUG = 1 }; + enum { INFO = 2 }; + enum { WARN = 4 }; + enum { ERROR = 8 }; + enum { FATAL = 16 }; + + + typedef std::shared_ptr< ::rosgraph_msgs::Log_ > Ptr; + typedef std::shared_ptr< ::rosgraph_msgs::Log_ const> ConstPtr; + +}; // struct Log_ + +typedef ::rosgraph_msgs::Log_ > Log; + +typedef std::shared_ptr< ::rosgraph_msgs::Log > LogPtr; +typedef std::shared_ptr< ::rosgraph_msgs::Log const> LogConstPtr; + +// constants requiring out of line definition + + + + + + + + + + + + + +template +std::ostream& operator<<(std::ostream& s, const ::rosgraph_msgs::Log_ & v) +{ +ros::message_operations::Printer< ::rosgraph_msgs::Log_ >::stream(s, "", v); +return s; +} + +} // namespace rosgraph_msgs + +namespace ros +{ +namespace message_traits +{ + + + +// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': True} +// {'rosgraph_msgs': ['/tmp/binarydeb/ros-kinetic-rosgraph-msgs-1.11.2/msg'], 'std_msgs': ['/opt/ros/kinetic/share/std_msgs/cmake/../msg']} + +// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types'] + + + + +template +struct IsFixedSize< ::rosgraph_msgs::Log_ > + : FalseType + { }; + +template +struct IsFixedSize< ::rosgraph_msgs::Log_ const> + : FalseType + { }; + +template +struct IsMessage< ::rosgraph_msgs::Log_ > + : TrueType + { }; + +template +struct IsMessage< ::rosgraph_msgs::Log_ const> + : TrueType + { }; + +template +struct HasHeader< ::rosgraph_msgs::Log_ > + : TrueType + { }; + +template +struct HasHeader< ::rosgraph_msgs::Log_ const> + : TrueType + { }; + + +template +struct MD5Sum< ::rosgraph_msgs::Log_ > +{ + static const char* value() + { + return "acffd30cd6b6de30f120938c17c593fb"; + } + + static const char* value(const ::rosgraph_msgs::Log_&) { return value(); } + static const uint64_t static_value1 = 0xacffd30cd6b6de30ULL; + static const uint64_t static_value2 = 0xf120938c17c593fbULL; +}; + +template +struct DataType< ::rosgraph_msgs::Log_ > +{ + static const char* value() + { + return "rosgraph_msgs/Log"; + } + + static const char* value(const ::rosgraph_msgs::Log_&) { return value(); } +}; + +template +struct Definition< ::rosgraph_msgs::Log_ > +{ + static const char* value() + { + return "##\n\ +## Severity level constants\n\ +##\n\ +byte DEBUG=1 #debug level\n\ +byte INFO=2 #general level\n\ +byte WARN=4 #warning level\n\ +byte ERROR=8 #error level\n\ +byte FATAL=16 #fatal/critical level\n\ +##\n\ +## Fields\n\ +##\n\ +Header header\n\ +byte level\n\ +string name # name of the node\n\ +string msg # message \n\ +string file # file the message came from\n\ +string function # function the message came from\n\ +uint32 line # line the message came from\n\ +string[] topics # topic names that the node publishes\n\ +\n\ +================================================================================\n\ +MSG: std_msgs/Header\n\ +# Standard metadata for higher-level stamped data types.\n\ +# This is generally used to communicate timestamped data \n\ +# in a particular coordinate frame.\n\ +# \n\ +# sequence ID: consecutively increasing ID \n\ +uint32 seq\n\ +#Two-integer timestamp that is expressed as:\n\ +# * stamp.sec: seconds (stamp_secs) since epoch (in Python the variable is called 'secs')\n\ +# * stamp.nsec: nanoseconds since stamp_secs (in Python the variable is called 'nsecs')\n\ +# time-handling sugar is provided by the client library\n\ +time stamp\n\ +#Frame this data is associated with\n\ +# 0: no frame\n\ +# 1: global frame\n\ +string frame_id\n\ +"; + } + + static const char* value(const ::rosgraph_msgs::Log_&) { return value(); } +}; + +} // namespace message_traits +} // namespace ros + +namespace ros +{ +namespace serialization +{ + + template struct Serializer< ::rosgraph_msgs::Log_ > + { + template inline static void allInOne(Stream& stream, T m) + { + stream.next(m.header); + stream.next(m.level); + stream.next(m.name); + stream.next(m.msg); + stream.next(m.file); + stream.next(m.function); + stream.next(m.line); + stream.next(m.topics); + } + + ROS_DECLARE_ALLINONE_SERIALIZER; + }; // struct Log_ + +} // namespace serialization +} // namespace ros + +namespace ros +{ +namespace message_operations +{ + +template +struct Printer< ::rosgraph_msgs::Log_ > +{ + template static void stream(Stream& s, const std::string& indent, const ::rosgraph_msgs::Log_& v) + { + s << indent << "header: "; + s << std::endl; + Printer< ::std_msgs::Header_ >::stream(s, indent + " ", v.header); + s << indent << "level: "; + Printer::stream(s, indent + " ", v.level); + s << indent << "name: "; + Printer, typename ContainerAllocator::template rebind::other > >::stream(s, indent + " ", v.name); + s << indent << "msg: "; + Printer, typename ContainerAllocator::template rebind::other > >::stream(s, indent + " ", v.msg); + s << indent << "file: "; + Printer, typename ContainerAllocator::template rebind::other > >::stream(s, indent + " ", v.file); + s << indent << "function: "; + Printer, typename ContainerAllocator::template rebind::other > >::stream(s, indent + " ", v.function); + s << indent << "line: "; + Printer::stream(s, indent + " ", v.line); + s << indent << "topics[]" << std::endl; + for (size_t i = 0; i < v.topics.size(); ++i) + { + s << indent << " topics[" << i << "]: "; + Printer, typename ContainerAllocator::template rebind::other > >::stream(s, indent + " ", v.topics[i]); + } + } +}; + +} // namespace message_operations +} // namespace ros + +#endif // ROSGRAPH_MSGS_MESSAGE_LOG_H diff --git a/realsense-file/src/storage/realsense_file/include/msgs/rosgraph_msgs/TopicStatistics.h b/realsense-file/src/storage/realsense_file/include/msgs/rosgraph_msgs/TopicStatistics.h new file mode 100644 index 0000000000..a6fe6954fa --- /dev/null +++ b/realsense-file/src/storage/realsense_file/include/msgs/rosgraph_msgs/TopicStatistics.h @@ -0,0 +1,321 @@ +// Generated by gencpp from file rosgraph_msgs/TopicStatistics.msg +// DO NOT EDIT! + + +#ifndef ROSGRAPH_MSGS_MESSAGE_TOPICSTATISTICS_H +#define ROSGRAPH_MSGS_MESSAGE_TOPICSTATISTICS_H + + +#include +#include +#include + +#include +#include +#include +#include + + +namespace rosgraph_msgs +{ +template +struct TopicStatistics_ +{ + typedef TopicStatistics_ Type; + + TopicStatistics_() + : topic() + , node_pub() + , node_sub() + , window_start() + , window_stop() + , delivered_msgs(0) + , dropped_msgs(0) + , traffic(0) + , period_mean() + , period_stddev() + , period_max() + , stamp_age_mean() + , stamp_age_stddev() + , stamp_age_max() { + } + TopicStatistics_(const ContainerAllocator& _alloc) + : topic(_alloc) + , node_pub(_alloc) + , node_sub(_alloc) + , window_start() + , window_stop() + , delivered_msgs(0) + , dropped_msgs(0) + , traffic(0) + , period_mean() + , period_stddev() + , period_max() + , stamp_age_mean() + , stamp_age_stddev() + , stamp_age_max() { + (void)_alloc; + } + + + + typedef std::basic_string, typename ContainerAllocator::template rebind::other > _topic_type; + _topic_type topic; + + typedef std::basic_string, typename ContainerAllocator::template rebind::other > _node_pub_type; + _node_pub_type node_pub; + + typedef std::basic_string, typename ContainerAllocator::template rebind::other > _node_sub_type; + _node_sub_type node_sub; + + typedef ros::Time _window_start_type; + _window_start_type window_start; + + typedef ros::Time _window_stop_type; + _window_stop_type window_stop; + + typedef int32_t _delivered_msgs_type; + _delivered_msgs_type delivered_msgs; + + typedef int32_t _dropped_msgs_type; + _dropped_msgs_type dropped_msgs; + + typedef int32_t _traffic_type; + _traffic_type traffic; + + typedef ros::Duration _period_mean_type; + _period_mean_type period_mean; + + typedef ros::Duration _period_stddev_type; + _period_stddev_type period_stddev; + + typedef ros::Duration _period_max_type; + _period_max_type period_max; + + typedef ros::Duration _stamp_age_mean_type; + _stamp_age_mean_type stamp_age_mean; + + typedef ros::Duration _stamp_age_stddev_type; + _stamp_age_stddev_type stamp_age_stddev; + + typedef ros::Duration _stamp_age_max_type; + _stamp_age_max_type stamp_age_max; + + + + + typedef boost::shared_ptr< ::rosgraph_msgs::TopicStatistics_ > Ptr; + typedef boost::shared_ptr< ::rosgraph_msgs::TopicStatistics_ const> ConstPtr; + +}; // struct TopicStatistics_ + +typedef ::rosgraph_msgs::TopicStatistics_ > TopicStatistics; + +typedef boost::shared_ptr< ::rosgraph_msgs::TopicStatistics > TopicStatisticsPtr; +typedef boost::shared_ptr< ::rosgraph_msgs::TopicStatistics const> TopicStatisticsConstPtr; + +// constants requiring out of line definition + + + +template +std::ostream& operator<<(std::ostream& s, const ::rosgraph_msgs::TopicStatistics_ & v) +{ +ros::message_operations::Printer< ::rosgraph_msgs::TopicStatistics_ >::stream(s, "", v); +return s; +} + +} // namespace rosgraph_msgs + +namespace ros +{ +namespace message_traits +{ + + + +// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': False} +// {'rosgraph_msgs': ['/tmp/binarydeb/ros-kinetic-rosgraph-msgs-1.11.2/msg'], 'std_msgs': ['/opt/ros/kinetic/share/std_msgs/cmake/../msg']} + +// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types'] + + + + +template +struct IsFixedSize< ::rosgraph_msgs::TopicStatistics_ > + : FalseType + { }; + +template +struct IsFixedSize< ::rosgraph_msgs::TopicStatistics_ const> + : FalseType + { }; + +template +struct IsMessage< ::rosgraph_msgs::TopicStatistics_ > + : TrueType + { }; + +template +struct IsMessage< ::rosgraph_msgs::TopicStatistics_ const> + : TrueType + { }; + +template +struct HasHeader< ::rosgraph_msgs::TopicStatistics_ > + : FalseType + { }; + +template +struct HasHeader< ::rosgraph_msgs::TopicStatistics_ const> + : FalseType + { }; + + +template +struct MD5Sum< ::rosgraph_msgs::TopicStatistics_ > +{ + static const char* value() + { + return "10152ed868c5097a5e2e4a89d7daa710"; + } + + static const char* value(const ::rosgraph_msgs::TopicStatistics_&) { return value(); } + static const uint64_t static_value1 = 0x10152ed868c5097aULL; + static const uint64_t static_value2 = 0x5e2e4a89d7daa710ULL; +}; + +template +struct DataType< ::rosgraph_msgs::TopicStatistics_ > +{ + static const char* value() + { + return "rosgraph_msgs/TopicStatistics"; + } + + static const char* value(const ::rosgraph_msgs::TopicStatistics_&) { return value(); } +}; + +template +struct Definition< ::rosgraph_msgs::TopicStatistics_ > +{ + static const char* value() + { + return "# name of the topic\n\ +string topic\n\ +\n\ +# node id of the publisher\n\ +string node_pub\n\ +\n\ +# node id of the subscriber\n\ +string node_sub\n\ +\n\ +# the statistics apply to this time window\n\ +time window_start\n\ +time window_stop\n\ +\n\ +# number of messages delivered during the window\n\ +int32 delivered_msgs\n\ +# numbers of messages dropped during the window\n\ +int32 dropped_msgs\n\ +\n\ +# traffic during the window, in bytes\n\ +int32 traffic\n\ +\n\ +# mean/stddev/max period between two messages\n\ +duration period_mean\n\ +duration period_stddev\n\ +duration period_max\n\ +\n\ +# mean/stddev/max age of the message based on the\n\ +# timestamp in the message header. In case the\n\ +# message does not have a header, it will be 0.\n\ +duration stamp_age_mean\n\ +duration stamp_age_stddev\n\ +duration stamp_age_max\n\ +"; + } + + static const char* value(const ::rosgraph_msgs::TopicStatistics_&) { return value(); } +}; + +} // namespace message_traits +} // namespace ros + +namespace ros +{ +namespace serialization +{ + + template struct Serializer< ::rosgraph_msgs::TopicStatistics_ > + { + template inline static void allInOne(Stream& stream, T m) + { + stream.next(m.topic); + stream.next(m.node_pub); + stream.next(m.node_sub); + stream.next(m.window_start); + stream.next(m.window_stop); + stream.next(m.delivered_msgs); + stream.next(m.dropped_msgs); + stream.next(m.traffic); + stream.next(m.period_mean); + stream.next(m.period_stddev); + stream.next(m.period_max); + stream.next(m.stamp_age_mean); + stream.next(m.stamp_age_stddev); + stream.next(m.stamp_age_max); + } + + ROS_DECLARE_ALLINONE_SERIALIZER; + }; // struct TopicStatistics_ + +} // namespace serialization +} // namespace ros + +namespace ros +{ +namespace message_operations +{ + +template +struct Printer< ::rosgraph_msgs::TopicStatistics_ > +{ + template static void stream(Stream& s, const std::string& indent, const ::rosgraph_msgs::TopicStatistics_& v) + { + s << indent << "topic: "; + Printer, typename ContainerAllocator::template rebind::other > >::stream(s, indent + " ", v.topic); + s << indent << "node_pub: "; + Printer, typename ContainerAllocator::template rebind::other > >::stream(s, indent + " ", v.node_pub); + s << indent << "node_sub: "; + Printer, typename ContainerAllocator::template rebind::other > >::stream(s, indent + " ", v.node_sub); + s << indent << "window_start: "; + Printer::stream(s, indent + " ", v.window_start); + s << indent << "window_stop: "; + Printer::stream(s, indent + " ", v.window_stop); + s << indent << "delivered_msgs: "; + Printer::stream(s, indent + " ", v.delivered_msgs); + s << indent << "dropped_msgs: "; + Printer::stream(s, indent + " ", v.dropped_msgs); + s << indent << "traffic: "; + Printer::stream(s, indent + " ", v.traffic); + s << indent << "period_mean: "; + Printer::stream(s, indent + " ", v.period_mean); + s << indent << "period_stddev: "; + Printer::stream(s, indent + " ", v.period_stddev); + s << indent << "period_max: "; + Printer::stream(s, indent + " ", v.period_max); + s << indent << "stamp_age_mean: "; + Printer::stream(s, indent + " ", v.stamp_age_mean); + s << indent << "stamp_age_stddev: "; + Printer::stream(s, indent + " ", v.stamp_age_stddev); + s << indent << "stamp_age_max: "; + Printer::stream(s, indent + " ", v.stamp_age_max); + } +}; + +} // namespace message_operations +} // namespace ros + +#endif // ROSGRAPH_MSGS_MESSAGE_TOPICSTATISTICS_H diff --git a/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/BatteryState.h b/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/BatteryState.h new file mode 100644 index 0000000000..71cfabca95 --- /dev/null +++ b/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/BatteryState.h @@ -0,0 +1,425 @@ +// Generated by gencpp from file sensor_msgs/BatteryState.msg +// DO NOT EDIT! + + +#ifndef SENSOR_MSGS_MESSAGE_BATTERYSTATE_H +#define SENSOR_MSGS_MESSAGE_BATTERYSTATE_H + + +#include +#include +#include + +#include +#include +#include +#include + +#include + +namespace sensor_msgs +{ +template +struct BatteryState_ +{ + typedef BatteryState_ Type; + + BatteryState_() + : header() + , voltage(0.0) + , current(0.0) + , charge(0.0) + , capacity(0.0) + , design_capacity(0.0) + , percentage(0.0) + , power_supply_status(0) + , power_supply_health(0) + , power_supply_technology(0) + , present(false) + , cell_voltage() + , location() + , serial_number() { + } + BatteryState_(const ContainerAllocator& _alloc) + : header(_alloc) + , voltage(0.0) + , current(0.0) + , charge(0.0) + , capacity(0.0) + , design_capacity(0.0) + , percentage(0.0) + , power_supply_status(0) + , power_supply_health(0) + , power_supply_technology(0) + , present(false) + , cell_voltage(_alloc) + , location(_alloc) + , serial_number(_alloc) { + (void)_alloc; + } + + + + typedef ::std_msgs::Header_ _header_type; + _header_type header; + + typedef float _voltage_type; + _voltage_type voltage; + + typedef float _current_type; + _current_type current; + + typedef float _charge_type; + _charge_type charge; + + typedef float _capacity_type; + _capacity_type capacity; + + typedef float _design_capacity_type; + _design_capacity_type design_capacity; + + typedef float _percentage_type; + _percentage_type percentage; + + typedef uint8_t _power_supply_status_type; + _power_supply_status_type power_supply_status; + + typedef uint8_t _power_supply_health_type; + _power_supply_health_type power_supply_health; + + typedef uint8_t _power_supply_technology_type; + _power_supply_technology_type power_supply_technology; + + typedef uint8_t _present_type; + _present_type present; + + typedef std::vector::other > _cell_voltage_type; + _cell_voltage_type cell_voltage; + + typedef std::basic_string, typename ContainerAllocator::template rebind::other > _location_type; + _location_type location; + + typedef std::basic_string, typename ContainerAllocator::template rebind::other > _serial_number_type; + _serial_number_type serial_number; + + + enum { POWER_SUPPLY_STATUS_UNKNOWN = 0u }; + enum { POWER_SUPPLY_STATUS_CHARGING = 1u }; + enum { POWER_SUPPLY_STATUS_DISCHARGING = 2u }; + enum { POWER_SUPPLY_STATUS_NOT_CHARGING = 3u }; + enum { POWER_SUPPLY_STATUS_FULL = 4u }; + enum { POWER_SUPPLY_HEALTH_UNKNOWN = 0u }; + enum { POWER_SUPPLY_HEALTH_GOOD = 1u }; + enum { POWER_SUPPLY_HEALTH_OVERHEAT = 2u }; + enum { POWER_SUPPLY_HEALTH_DEAD = 3u }; + enum { POWER_SUPPLY_HEALTH_OVERVOLTAGE = 4u }; + enum { POWER_SUPPLY_HEALTH_UNSPEC_FAILURE = 5u }; + enum { POWER_SUPPLY_HEALTH_COLD = 6u }; + enum { POWER_SUPPLY_HEALTH_WATCHDOG_TIMER_EXPIRE = 7u }; + enum { POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE = 8u }; + enum { POWER_SUPPLY_TECHNOLOGY_UNKNOWN = 0u }; + enum { POWER_SUPPLY_TECHNOLOGY_NIMH = 1u }; + enum { POWER_SUPPLY_TECHNOLOGY_LION = 2u }; + enum { POWER_SUPPLY_TECHNOLOGY_LIPO = 3u }; + enum { POWER_SUPPLY_TECHNOLOGY_LIFE = 4u }; + enum { POWER_SUPPLY_TECHNOLOGY_NICD = 5u }; + enum { POWER_SUPPLY_TECHNOLOGY_LIMN = 6u }; + + + typedef boost::shared_ptr< ::sensor_msgs::BatteryState_ > Ptr; + typedef boost::shared_ptr< ::sensor_msgs::BatteryState_ const> ConstPtr; + +}; // struct BatteryState_ + +typedef ::sensor_msgs::BatteryState_ > BatteryState; + +typedef boost::shared_ptr< ::sensor_msgs::BatteryState > BatteryStatePtr; +typedef boost::shared_ptr< ::sensor_msgs::BatteryState const> BatteryStateConstPtr; + +// constants requiring out of line definition + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +template +std::ostream& operator<<(std::ostream& s, const ::sensor_msgs::BatteryState_ & v) +{ +ros::message_operations::Printer< ::sensor_msgs::BatteryState_ >::stream(s, "", v); +return s; +} + +} // namespace sensor_msgs + +namespace ros +{ +namespace message_traits +{ + + + +// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': True} +// {'std_msgs': ['/opt/ros/kinetic/share/std_msgs/cmake/../msg'], 'geometry_msgs': ['/opt/ros/kinetic/share/geometry_msgs/cmake/../msg'], 'sensor_msgs': ['/tmp/binarydeb/ros-kinetic-sensor-msgs-1.12.5/msg']} + +// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types'] + + + + +template +struct IsFixedSize< ::sensor_msgs::BatteryState_ > + : FalseType + { }; + +template +struct IsFixedSize< ::sensor_msgs::BatteryState_ const> + : FalseType + { }; + +template +struct IsMessage< ::sensor_msgs::BatteryState_ > + : TrueType + { }; + +template +struct IsMessage< ::sensor_msgs::BatteryState_ const> + : TrueType + { }; + +template +struct HasHeader< ::sensor_msgs::BatteryState_ > + : TrueType + { }; + +template +struct HasHeader< ::sensor_msgs::BatteryState_ const> + : TrueType + { }; + + +template +struct MD5Sum< ::sensor_msgs::BatteryState_ > +{ + static const char* value() + { + return "476f837fa6771f6e16e3bf4ef96f8770"; + } + + static const char* value(const ::sensor_msgs::BatteryState_&) { return value(); } + static const uint64_t static_value1 = 0x476f837fa6771f6eULL; + static const uint64_t static_value2 = 0x16e3bf4ef96f8770ULL; +}; + +template +struct DataType< ::sensor_msgs::BatteryState_ > +{ + static const char* value() + { + return "sensor_msgs/BatteryState"; + } + + static const char* value(const ::sensor_msgs::BatteryState_&) { return value(); } +}; + +template +struct Definition< ::sensor_msgs::BatteryState_ > +{ + static const char* value() + { + return "\n\ +# Constants are chosen to match the enums in the linux kernel\n\ +# defined in include/linux/power_supply.h as of version 3.7\n\ +# The one difference is for style reasons the constants are\n\ +# all uppercase not mixed case.\n\ +\n\ +# Power supply status constants\n\ +uint8 POWER_SUPPLY_STATUS_UNKNOWN = 0\n\ +uint8 POWER_SUPPLY_STATUS_CHARGING = 1\n\ +uint8 POWER_SUPPLY_STATUS_DISCHARGING = 2\n\ +uint8 POWER_SUPPLY_STATUS_NOT_CHARGING = 3\n\ +uint8 POWER_SUPPLY_STATUS_FULL = 4\n\ +\n\ +# Power supply health constants\n\ +uint8 POWER_SUPPLY_HEALTH_UNKNOWN = 0\n\ +uint8 POWER_SUPPLY_HEALTH_GOOD = 1\n\ +uint8 POWER_SUPPLY_HEALTH_OVERHEAT = 2\n\ +uint8 POWER_SUPPLY_HEALTH_DEAD = 3\n\ +uint8 POWER_SUPPLY_HEALTH_OVERVOLTAGE = 4\n\ +uint8 POWER_SUPPLY_HEALTH_UNSPEC_FAILURE = 5\n\ +uint8 POWER_SUPPLY_HEALTH_COLD = 6\n\ +uint8 POWER_SUPPLY_HEALTH_WATCHDOG_TIMER_EXPIRE = 7\n\ +uint8 POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE = 8\n\ +\n\ +# Power supply technology (chemistry) constants\n\ +uint8 POWER_SUPPLY_TECHNOLOGY_UNKNOWN = 0\n\ +uint8 POWER_SUPPLY_TECHNOLOGY_NIMH = 1\n\ +uint8 POWER_SUPPLY_TECHNOLOGY_LION = 2\n\ +uint8 POWER_SUPPLY_TECHNOLOGY_LIPO = 3\n\ +uint8 POWER_SUPPLY_TECHNOLOGY_LIFE = 4\n\ +uint8 POWER_SUPPLY_TECHNOLOGY_NICD = 5\n\ +uint8 POWER_SUPPLY_TECHNOLOGY_LIMN = 6\n\ +\n\ +Header header\n\ +float32 voltage # Voltage in Volts (Mandatory)\n\ +float32 current # Negative when discharging (A) (If unmeasured NaN)\n\ +float32 charge # Current charge in Ah (If unmeasured NaN)\n\ +float32 capacity # Capacity in Ah (last full capacity) (If unmeasured NaN)\n\ +float32 design_capacity # Capacity in Ah (design capacity) (If unmeasured NaN)\n\ +float32 percentage # Charge percentage on 0 to 1 range (If unmeasured NaN)\n\ +uint8 power_supply_status # The charging status as reported. Values defined above\n\ +uint8 power_supply_health # The battery health metric. Values defined above\n\ +uint8 power_supply_technology # The battery chemistry. Values defined above\n\ +bool present # True if the battery is present\n\ +\n\ +float32[] cell_voltage # An array of individual cell voltages for each cell in the pack\n\ + # If individual voltages unknown but number of cells known set each to NaN\n\ +string location # The location into which the battery is inserted. (slot number or plug)\n\ +string serial_number # The best approximation of the battery serial number\n\ +\n\ +================================================================================\n\ +MSG: std_msgs/Header\n\ +# Standard metadata for higher-level stamped data types.\n\ +# This is generally used to communicate timestamped data \n\ +# in a particular coordinate frame.\n\ +# \n\ +# sequence ID: consecutively increasing ID \n\ +uint32 seq\n\ +#Two-integer timestamp that is expressed as:\n\ +# * stamp.sec: seconds (stamp_secs) since epoch (in Python the variable is called 'secs')\n\ +# * stamp.nsec: nanoseconds since stamp_secs (in Python the variable is called 'nsecs')\n\ +# time-handling sugar is provided by the client library\n\ +time stamp\n\ +#Frame this data is associated with\n\ +# 0: no frame\n\ +# 1: global frame\n\ +string frame_id\n\ +"; + } + + static const char* value(const ::sensor_msgs::BatteryState_&) { return value(); } +}; + +} // namespace message_traits +} // namespace ros + +namespace ros +{ +namespace serialization +{ + + template struct Serializer< ::sensor_msgs::BatteryState_ > + { + template inline static void allInOne(Stream& stream, T m) + { + stream.next(m.header); + stream.next(m.voltage); + stream.next(m.current); + stream.next(m.charge); + stream.next(m.capacity); + stream.next(m.design_capacity); + stream.next(m.percentage); + stream.next(m.power_supply_status); + stream.next(m.power_supply_health); + stream.next(m.power_supply_technology); + stream.next(m.present); + stream.next(m.cell_voltage); + stream.next(m.location); + stream.next(m.serial_number); + } + + ROS_DECLARE_ALLINONE_SERIALIZER; + }; // struct BatteryState_ + +} // namespace serialization +} // namespace ros + +namespace ros +{ +namespace message_operations +{ + +template +struct Printer< ::sensor_msgs::BatteryState_ > +{ + template static void stream(Stream& s, const std::string& indent, const ::sensor_msgs::BatteryState_& v) + { + s << indent << "header: "; + s << std::endl; + Printer< ::std_msgs::Header_ >::stream(s, indent + " ", v.header); + s << indent << "voltage: "; + Printer::stream(s, indent + " ", v.voltage); + s << indent << "current: "; + Printer::stream(s, indent + " ", v.current); + s << indent << "charge: "; + Printer::stream(s, indent + " ", v.charge); + s << indent << "capacity: "; + Printer::stream(s, indent + " ", v.capacity); + s << indent << "design_capacity: "; + Printer::stream(s, indent + " ", v.design_capacity); + s << indent << "percentage: "; + Printer::stream(s, indent + " ", v.percentage); + s << indent << "power_supply_status: "; + Printer::stream(s, indent + " ", v.power_supply_status); + s << indent << "power_supply_health: "; + Printer::stream(s, indent + " ", v.power_supply_health); + s << indent << "power_supply_technology: "; + Printer::stream(s, indent + " ", v.power_supply_technology); + s << indent << "present: "; + Printer::stream(s, indent + " ", v.present); + s << indent << "cell_voltage[]" << std::endl; + for (size_t i = 0; i < v.cell_voltage.size(); ++i) + { + s << indent << " cell_voltage[" << i << "]: "; + Printer::stream(s, indent + " ", v.cell_voltage[i]); + } + s << indent << "location: "; + Printer, typename ContainerAllocator::template rebind::other > >::stream(s, indent + " ", v.location); + s << indent << "serial_number: "; + Printer, typename ContainerAllocator::template rebind::other > >::stream(s, indent + " ", v.serial_number); + } +}; + +} // namespace message_operations +} // namespace ros + +#endif // SENSOR_MSGS_MESSAGE_BATTERYSTATE_H diff --git a/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/CameraInfo.h b/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/CameraInfo.h new file mode 100644 index 0000000000..795d4d785d --- /dev/null +++ b/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/CameraInfo.h @@ -0,0 +1,467 @@ +// Generated by gencpp from file sensor_msgs/CameraInfo.msg +// DO NOT EDIT! + + +#ifndef SENSOR_MSGS_MESSAGE_CAMERAINFO_H +#define SENSOR_MSGS_MESSAGE_CAMERAINFO_H + +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +#include +#include + +namespace sensor_msgs +{ +template +struct CameraInfo_ +{ + typedef CameraInfo_ Type; + + CameraInfo_() + : header() + , height(0) + , width(0) + , distortion_model() + , D() + , K() + , R() + , P() + , binning_x(0) + , binning_y(0) + , roi() { + K.fill(0.0); + + R.fill(0.0); + + P.fill(0.0); + } + CameraInfo_(const ContainerAllocator& _alloc) + : header(_alloc) + , height(0) + , width(0) + , distortion_model(_alloc) + , D(_alloc) + , K() + , R() + , P() + , binning_x(0) + , binning_y(0) + , roi(_alloc) { + (void)_alloc; + K.fill(0.0); + + R.fill(0.0); + + P.fill(0.0); + } + + + + typedef ::std_msgs::Header_ _header_type; + _header_type header; + + typedef uint32_t _height_type; + _height_type height; + + typedef uint32_t _width_type; + _width_type width; + + typedef std::basic_string, typename ContainerAllocator::template rebind::other > _distortion_model_type; + _distortion_model_type distortion_model; + + typedef std::vector::other > _D_type; + _D_type D; + + typedef std::array _K_type; + _K_type K; + + typedef std::array _R_type; + _R_type R; + + typedef std::array _P_type; + _P_type P; + + typedef uint32_t _binning_x_type; + _binning_x_type binning_x; + + typedef uint32_t _binning_y_type; + _binning_y_type binning_y; + + typedef ::sensor_msgs::RegionOfInterest_ _roi_type; + _roi_type roi; + + + + + typedef std::shared_ptr< ::sensor_msgs::CameraInfo_ > Ptr; + typedef std::shared_ptr< ::sensor_msgs::CameraInfo_ const> ConstPtr; + +}; // struct CameraInfo_ + +typedef ::sensor_msgs::CameraInfo_ > CameraInfo; + +typedef std::shared_ptr< ::sensor_msgs::CameraInfo > CameraInfoPtr; +typedef std::shared_ptr< ::sensor_msgs::CameraInfo const> CameraInfoConstPtr; + +// constants requiring out of line definition + + + +template +std::ostream& operator<<(std::ostream& s, const ::sensor_msgs::CameraInfo_ & v) +{ +ros::message_operations::Printer< ::sensor_msgs::CameraInfo_ >::stream(s, "", v); +return s; +} + +} // namespace sensor_msgs + +namespace ros +{ +namespace message_traits +{ + + + +// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': True} +// {'std_msgs': ['/opt/ros/kinetic/share/std_msgs/cmake/../msg'], 'geometry_msgs': ['/opt/ros/kinetic/share/geometry_msgs/cmake/../msg'], 'sensor_msgs': ['/tmp/binarydeb/ros-kinetic-sensor-msgs-1.12.5/msg']} + +// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types'] + + + + +template +struct IsFixedSize< ::sensor_msgs::CameraInfo_ > + : FalseType + { }; + +template +struct IsFixedSize< ::sensor_msgs::CameraInfo_ const> + : FalseType + { }; + +template +struct IsMessage< ::sensor_msgs::CameraInfo_ > + : TrueType + { }; + +template +struct IsMessage< ::sensor_msgs::CameraInfo_ const> + : TrueType + { }; + +template +struct HasHeader< ::sensor_msgs::CameraInfo_ > + : TrueType + { }; + +template +struct HasHeader< ::sensor_msgs::CameraInfo_ const> + : TrueType + { }; + + +template +struct MD5Sum< ::sensor_msgs::CameraInfo_ > +{ + static const char* value() + { + return "c9a58c1b0b154e0e6da7578cb991d214"; + } + + static const char* value(const ::sensor_msgs::CameraInfo_&) { return value(); } + static const uint64_t static_value1 = 0xc9a58c1b0b154e0eULL; + static const uint64_t static_value2 = 0x6da7578cb991d214ULL; +}; + +template +struct DataType< ::sensor_msgs::CameraInfo_ > +{ + static const char* value() + { + return "sensor_msgs/CameraInfo"; + } + + static const char* value(const ::sensor_msgs::CameraInfo_&) { return value(); } +}; + +template +struct Definition< ::sensor_msgs::CameraInfo_ > +{ + static const char* value() + { + return "# This message defines meta information for a camera. It should be in a\n\ +# camera namespace on topic \"camera_info\" and accompanied by up to five\n\ +# image topics named:\n\ +#\n\ +# image_raw - raw data from the camera driver, possibly Bayer encoded\n\ +# image - monochrome, distorted\n\ +# image_color - color, distorted\n\ +# image_rect - monochrome, rectified\n\ +# image_rect_color - color, rectified\n\ +#\n\ +# The image_pipeline contains packages (image_proc, stereo_image_proc)\n\ +# for producing the four processed image topics from image_raw and\n\ +# camera_info. The meaning of the camera parameters are described in\n\ +# detail at http://www.ros.org/wiki/image_pipeline/CameraInfo.\n\ +#\n\ +# The image_geometry package provides a user-friendly interface to\n\ +# common operations using this meta information. If you want to, e.g.,\n\ +# project a 3d point into image coordinates, we strongly recommend\n\ +# using image_geometry.\n\ +#\n\ +# If the camera is uncalibrated, the matrices D, K, R, P should be left\n\ +# zeroed out. In particular, clients may assume that K[0] == 0.0\n\ +# indicates an uncalibrated camera.\n\ +\n\ +#######################################################################\n\ +# Image acquisition info #\n\ +#######################################################################\n\ +\n\ +# Time of image acquisition, camera coordinate frame ID\n\ +Header header # Header timestamp should be acquisition time of image\n\ + # Header frame_id should be optical frame of camera\n\ + # origin of frame should be optical center of camera\n\ + # +x should point to the right in the image\n\ + # +y should point down in the image\n\ + # +z should point into the plane of the image\n\ +\n\ +\n\ +#######################################################################\n\ +# Calibration Parameters #\n\ +#######################################################################\n\ +# These are fixed during camera calibration. Their values will be the #\n\ +# same in all messages until the camera is recalibrated. Note that #\n\ +# self-calibrating systems may \"recalibrate\" frequently. #\n\ +# #\n\ +# The internal parameters can be used to warp a raw (distorted) image #\n\ +# to: #\n\ +# 1. An undistorted image (requires D and K) #\n\ +# 2. A rectified image (requires D, K, R) #\n\ +# The projection matrix P projects 3D points into the rectified image.#\n\ +#######################################################################\n\ +\n\ +# The image dimensions with which the camera was calibrated. Normally\n\ +# this will be the full camera resolution in pixels.\n\ +uint32 height\n\ +uint32 width\n\ +\n\ +# The distortion model used. Supported models are listed in\n\ +# sensor_msgs/distortion_models.h. For most cameras, \"plumb_bob\" - a\n\ +# simple model of radial and tangential distortion - is sufficient.\n\ +string distortion_model\n\ +\n\ +# The distortion parameters, size depending on the distortion model.\n\ +# For \"plumb_bob\", the 5 parameters are: (k1, k2, t1, t2, k3).\n\ +float64[] D\n\ +\n\ +# Intrinsic camera matrix for the raw (distorted) images.\n\ +# [fx 0 cx]\n\ +# K = [ 0 fy cy]\n\ +# [ 0 0 1]\n\ +# Projects 3D points in the camera coordinate frame to 2D pixel\n\ +# coordinates using the focal lengths (fx, fy) and principal point\n\ +# (cx, cy).\n\ +float64[9] K # 3x3 row-major matrix\n\ +\n\ +# Rectification matrix (stereo cameras only)\n\ +# A rotation matrix aligning the camera coordinate system to the ideal\n\ +# stereo image plane so that epipolar lines in both stereo images are\n\ +# parallel.\n\ +float64[9] R # 3x3 row-major matrix\n\ +\n\ +# Projection/camera matrix\n\ +# [fx' 0 cx' Tx]\n\ +# P = [ 0 fy' cy' Ty]\n\ +# [ 0 0 1 0]\n\ +# By convention, this matrix specifies the intrinsic (camera) matrix\n\ +# of the processed (rectified) image. That is, the left 3x3 portion\n\ +# is the normal camera intrinsic matrix for the rectified image.\n\ +# It projects 3D points in the camera coordinate frame to 2D pixel\n\ +# coordinates using the focal lengths (fx', fy') and principal point\n\ +# (cx', cy') - these may differ from the values in K.\n\ +# For monocular cameras, Tx = Ty = 0. Normally, monocular cameras will\n\ +# also have R = the identity and P[1:3,1:3] = K.\n\ +# For a stereo pair, the fourth column [Tx Ty 0]' is related to the\n\ +# position of the optical center of the second camera in the first\n\ +# camera's frame. We assume Tz = 0 so both cameras are in the same\n\ +# stereo image plane. The first camera always has Tx = Ty = 0. For\n\ +# the right (second) camera of a horizontal stereo pair, Ty = 0 and\n\ +# Tx = -fx' * B, where B is the baseline between the cameras.\n\ +# Given a 3D point [X Y Z]', the projection (x, y) of the point onto\n\ +# the rectified image is given by:\n\ +# [u v w]' = P * [X Y Z 1]'\n\ +# x = u / w\n\ +# y = v / w\n\ +# This holds for both images of a stereo pair.\n\ +float64[12] P # 3x4 row-major matrix\n\ +\n\ +\n\ +#######################################################################\n\ +# Operational Parameters #\n\ +#######################################################################\n\ +# These define the image region actually captured by the camera #\n\ +# driver. Although they affect the geometry of the output image, they #\n\ +# may be changed freely without recalibrating the camera. #\n\ +#######################################################################\n\ +\n\ +# Binning refers here to any camera setting which combines rectangular\n\ +# neighborhoods of pixels into larger \"super-pixels.\" It reduces the\n\ +# resolution of the output image to\n\ +# (width / binning_x) x (height / binning_y).\n\ +# The default values binning_x = binning_y = 0 is considered the same\n\ +# as binning_x = binning_y = 1 (no subsampling).\n\ +uint32 binning_x\n\ +uint32 binning_y\n\ +\n\ +# Region of interest (subwindow of full camera resolution), given in\n\ +# full resolution (unbinned) image coordinates. A particular ROI\n\ +# always denotes the same window of pixels on the camera sensor,\n\ +# regardless of binning settings.\n\ +# The default setting of roi (all values 0) is considered the same as\n\ +# full resolution (roi.width = width, roi.height = height).\n\ +RegionOfInterest roi\n\ +\n\ +================================================================================\n\ +MSG: std_msgs/Header\n\ +# Standard metadata for higher-level stamped data types.\n\ +# This is generally used to communicate timestamped data \n\ +# in a particular coordinate frame.\n\ +# \n\ +# sequence ID: consecutively increasing ID \n\ +uint32 seq\n\ +#Two-integer timestamp that is expressed as:\n\ +# * stamp.sec: seconds (stamp_secs) since epoch (in Python the variable is called 'secs')\n\ +# * stamp.nsec: nanoseconds since stamp_secs (in Python the variable is called 'nsecs')\n\ +# time-handling sugar is provided by the client library\n\ +time stamp\n\ +#Frame this data is associated with\n\ +# 0: no frame\n\ +# 1: global frame\n\ +string frame_id\n\ +\n\ +================================================================================\n\ +MSG: sensor_msgs/RegionOfInterest\n\ +# This message is used to specify a region of interest within an image.\n\ +#\n\ +# When used to specify the ROI setting of the camera when the image was\n\ +# taken, the height and width fields should either match the height and\n\ +# width fields for the associated image; or height = width = 0\n\ +# indicates that the full resolution image was captured.\n\ +\n\ +uint32 x_offset # Leftmost pixel of the ROI\n\ + # (0 if the ROI includes the left edge of the image)\n\ +uint32 y_offset # Topmost pixel of the ROI\n\ + # (0 if the ROI includes the top edge of the image)\n\ +uint32 height # Height of ROI\n\ +uint32 width # Width of ROI\n\ +\n\ +# True if a distinct rectified ROI should be calculated from the \"raw\"\n\ +# ROI in this message. Typically this should be False if the full image\n\ +# is captured (ROI not used), and True if a subwindow is captured (ROI\n\ +# used).\n\ +bool do_rectify\n\ +"; + } + + static const char* value(const ::sensor_msgs::CameraInfo_&) { return value(); } +}; + +} // namespace message_traits +} // namespace ros + +namespace ros +{ +namespace serialization +{ + + template struct Serializer< ::sensor_msgs::CameraInfo_ > + { + template inline static void allInOne(Stream& stream, T m) + { + stream.next(m.header); + stream.next(m.height); + stream.next(m.width); + stream.next(m.distortion_model); + stream.next(m.D); + stream.next(m.K); + stream.next(m.R); + stream.next(m.P); + stream.next(m.binning_x); + stream.next(m.binning_y); + stream.next(m.roi); + } + + ROS_DECLARE_ALLINONE_SERIALIZER; + }; // struct CameraInfo_ + +} // namespace serialization +} // namespace ros + +namespace ros +{ +namespace message_operations +{ + +template +struct Printer< ::sensor_msgs::CameraInfo_ > +{ + template static void stream(Stream& s, const std::string& indent, const ::sensor_msgs::CameraInfo_& v) + { + s << indent << "header: "; + s << std::endl; + Printer< ::std_msgs::Header_ >::stream(s, indent + " ", v.header); + s << indent << "height: "; + Printer::stream(s, indent + " ", v.height); + s << indent << "width: "; + Printer::stream(s, indent + " ", v.width); + s << indent << "distortion_model: "; + Printer, typename ContainerAllocator::template rebind::other > >::stream(s, indent + " ", v.distortion_model); + s << indent << "D[]" << std::endl; + for (size_t i = 0; i < v.D.size(); ++i) + { + s << indent << " D[" << i << "]: "; + Printer::stream(s, indent + " ", v.D[i]); + } + s << indent << "K[]" << std::endl; + for (size_t i = 0; i < v.K.size(); ++i) + { + s << indent << " K[" << i << "]: "; + Printer::stream(s, indent + " ", v.K[i]); + } + s << indent << "R[]" << std::endl; + for (size_t i = 0; i < v.R.size(); ++i) + { + s << indent << " R[" << i << "]: "; + Printer::stream(s, indent + " ", v.R[i]); + } + s << indent << "P[]" << std::endl; + for (size_t i = 0; i < v.P.size(); ++i) + { + s << indent << " P[" << i << "]: "; + Printer::stream(s, indent + " ", v.P[i]); + } + s << indent << "binning_x: "; + Printer::stream(s, indent + " ", v.binning_x); + s << indent << "binning_y: "; + Printer::stream(s, indent + " ", v.binning_y); + s << indent << "roi: "; + s << std::endl; + Printer< ::sensor_msgs::RegionOfInterest_ >::stream(s, indent + " ", v.roi); + } +}; + +} // namespace message_operations +} // namespace ros + +#endif // SENSOR_MSGS_MESSAGE_CAMERAINFO_H diff --git a/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/ChannelFloat32.h b/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/ChannelFloat32.h new file mode 100644 index 0000000000..183105d7c0 --- /dev/null +++ b/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/ChannelFloat32.h @@ -0,0 +1,221 @@ +// Generated by gencpp from file sensor_msgs/ChannelFloat32.msg +// DO NOT EDIT! + + +#ifndef SENSOR_MSGS_MESSAGE_CHANNELFLOAT32_H +#define SENSOR_MSGS_MESSAGE_CHANNELFLOAT32_H + + +#include +#include +#include + +#include +#include +#include +#include + + +namespace sensor_msgs +{ +template +struct ChannelFloat32_ +{ + typedef ChannelFloat32_ Type; + + ChannelFloat32_() + : name() + , values() { + } + ChannelFloat32_(const ContainerAllocator& _alloc) + : name(_alloc) + , values(_alloc) { + (void)_alloc; + } + + + + typedef std::basic_string, typename ContainerAllocator::template rebind::other > _name_type; + _name_type name; + + typedef std::vector::other > _values_type; + _values_type values; + + + + + typedef boost::shared_ptr< ::sensor_msgs::ChannelFloat32_ > Ptr; + typedef boost::shared_ptr< ::sensor_msgs::ChannelFloat32_ const> ConstPtr; + +}; // struct ChannelFloat32_ + +typedef ::sensor_msgs::ChannelFloat32_ > ChannelFloat32; + +typedef boost::shared_ptr< ::sensor_msgs::ChannelFloat32 > ChannelFloat32Ptr; +typedef boost::shared_ptr< ::sensor_msgs::ChannelFloat32 const> ChannelFloat32ConstPtr; + +// constants requiring out of line definition + + + +template +std::ostream& operator<<(std::ostream& s, const ::sensor_msgs::ChannelFloat32_ & v) +{ +ros::message_operations::Printer< ::sensor_msgs::ChannelFloat32_ >::stream(s, "", v); +return s; +} + +} // namespace sensor_msgs + +namespace ros +{ +namespace message_traits +{ + + + +// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': False} +// {'std_msgs': ['/opt/ros/kinetic/share/std_msgs/cmake/../msg'], 'geometry_msgs': ['/opt/ros/kinetic/share/geometry_msgs/cmake/../msg'], 'sensor_msgs': ['/tmp/binarydeb/ros-kinetic-sensor-msgs-1.12.5/msg']} + +// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types'] + + + + +template +struct IsFixedSize< ::sensor_msgs::ChannelFloat32_ > + : FalseType + { }; + +template +struct IsFixedSize< ::sensor_msgs::ChannelFloat32_ const> + : FalseType + { }; + +template +struct IsMessage< ::sensor_msgs::ChannelFloat32_ > + : TrueType + { }; + +template +struct IsMessage< ::sensor_msgs::ChannelFloat32_ const> + : TrueType + { }; + +template +struct HasHeader< ::sensor_msgs::ChannelFloat32_ > + : FalseType + { }; + +template +struct HasHeader< ::sensor_msgs::ChannelFloat32_ const> + : FalseType + { }; + + +template +struct MD5Sum< ::sensor_msgs::ChannelFloat32_ > +{ + static const char* value() + { + return "3d40139cdd33dfedcb71ffeeeb42ae7f"; + } + + static const char* value(const ::sensor_msgs::ChannelFloat32_&) { return value(); } + static const uint64_t static_value1 = 0x3d40139cdd33dfedULL; + static const uint64_t static_value2 = 0xcb71ffeeeb42ae7fULL; +}; + +template +struct DataType< ::sensor_msgs::ChannelFloat32_ > +{ + static const char* value() + { + return "sensor_msgs/ChannelFloat32"; + } + + static const char* value(const ::sensor_msgs::ChannelFloat32_&) { return value(); } +}; + +template +struct Definition< ::sensor_msgs::ChannelFloat32_ > +{ + static const char* value() + { + return "# This message is used by the PointCloud message to hold optional data\n\ +# associated with each point in the cloud. The length of the values\n\ +# array should be the same as the length of the points array in the\n\ +# PointCloud, and each value should be associated with the corresponding\n\ +# point.\n\ +\n\ +# Channel names in existing practice include:\n\ +# \"u\", \"v\" - row and column (respectively) in the left stereo image.\n\ +# This is opposite to usual conventions but remains for\n\ +# historical reasons. The newer PointCloud2 message has no\n\ +# such problem.\n\ +# \"rgb\" - For point clouds produced by color stereo cameras. uint8\n\ +# (R,G,B) values packed into the least significant 24 bits,\n\ +# in order.\n\ +# \"intensity\" - laser or pixel intensity.\n\ +# \"distance\"\n\ +\n\ +# The channel name should give semantics of the channel (e.g.\n\ +# \"intensity\" instead of \"value\").\n\ +string name\n\ +\n\ +# The values array should be 1-1 with the elements of the associated\n\ +# PointCloud.\n\ +float32[] values\n\ +"; + } + + static const char* value(const ::sensor_msgs::ChannelFloat32_&) { return value(); } +}; + +} // namespace message_traits +} // namespace ros + +namespace ros +{ +namespace serialization +{ + + template struct Serializer< ::sensor_msgs::ChannelFloat32_ > + { + template inline static void allInOne(Stream& stream, T m) + { + stream.next(m.name); + stream.next(m.values); + } + + ROS_DECLARE_ALLINONE_SERIALIZER; + }; // struct ChannelFloat32_ + +} // namespace serialization +} // namespace ros + +namespace ros +{ +namespace message_operations +{ + +template +struct Printer< ::sensor_msgs::ChannelFloat32_ > +{ + template static void stream(Stream& s, const std::string& indent, const ::sensor_msgs::ChannelFloat32_& v) + { + s << indent << "name: "; + Printer, typename ContainerAllocator::template rebind::other > >::stream(s, indent + " ", v.name); + s << indent << "values[]" << std::endl; + for (size_t i = 0; i < v.values.size(); ++i) + { + s << indent << " values[" << i << "]: "; + Printer::stream(s, indent + " ", v.values[i]); + } + } +}; + +} // namespace message_operations +} // namespace ros + +#endif // SENSOR_MSGS_MESSAGE_CHANNELFLOAT32_H diff --git a/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/CompressedImage.h b/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/CompressedImage.h new file mode 100644 index 0000000000..f566ce44a8 --- /dev/null +++ b/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/CompressedImage.h @@ -0,0 +1,238 @@ +// Generated by gencpp from file sensor_msgs/CompressedImage.msg +// DO NOT EDIT! + + +#ifndef SENSOR_MSGS_MESSAGE_COMPRESSEDIMAGE_H +#define SENSOR_MSGS_MESSAGE_COMPRESSEDIMAGE_H + +#include +#include +#include +#include + +#include +#include +#include +#include + +#include + +namespace sensor_msgs +{ +template +struct CompressedImage_ +{ + typedef CompressedImage_ Type; + + CompressedImage_() + : header() + , format() + , data() { + } + CompressedImage_(const ContainerAllocator& _alloc) + : header(_alloc) + , format(_alloc) + , data(_alloc) { + (void)_alloc; + } + + + + typedef ::std_msgs::Header_ _header_type; + _header_type header; + + typedef std::basic_string, typename ContainerAllocator::template rebind::other > _format_type; + _format_type format; + + typedef std::vector::other > _data_type; + _data_type data; + + + + + typedef std::shared_ptr< ::sensor_msgs::CompressedImage_ > Ptr; + typedef std::shared_ptr< ::sensor_msgs::CompressedImage_ const> ConstPtr; + +}; // struct CompressedImage_ + +typedef ::sensor_msgs::CompressedImage_ > CompressedImage; + +typedef std::shared_ptr< ::sensor_msgs::CompressedImage > CompressedImagePtr; +typedef std::shared_ptr< ::sensor_msgs::CompressedImage const> CompressedImageConstPtr; + +// constants requiring out of line definition + + + +template +std::ostream& operator<<(std::ostream& s, const ::sensor_msgs::CompressedImage_ & v) +{ +ros::message_operations::Printer< ::sensor_msgs::CompressedImage_ >::stream(s, "", v); +return s; +} + +} // namespace sensor_msgs + +namespace ros +{ +namespace message_traits +{ + + + +// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': True} +// {'std_msgs': ['/opt/ros/kinetic/share/std_msgs/cmake/../msg'], 'geometry_msgs': ['/opt/ros/kinetic/share/geometry_msgs/cmake/../msg'], 'sensor_msgs': ['/tmp/binarydeb/ros-kinetic-sensor-msgs-1.12.5/msg']} + +// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types'] + + + + +template +struct IsFixedSize< ::sensor_msgs::CompressedImage_ > + : FalseType + { }; + +template +struct IsFixedSize< ::sensor_msgs::CompressedImage_ const> + : FalseType + { }; + +template +struct IsMessage< ::sensor_msgs::CompressedImage_ > + : TrueType + { }; + +template +struct IsMessage< ::sensor_msgs::CompressedImage_ const> + : TrueType + { }; + +template +struct HasHeader< ::sensor_msgs::CompressedImage_ > + : TrueType + { }; + +template +struct HasHeader< ::sensor_msgs::CompressedImage_ const> + : TrueType + { }; + + +template +struct MD5Sum< ::sensor_msgs::CompressedImage_ > +{ + static const char* value() + { + return "8f7a12909da2c9d3332d540a0977563f"; + } + + static const char* value(const ::sensor_msgs::CompressedImage_&) { return value(); } + static const uint64_t static_value1 = 0x8f7a12909da2c9d3ULL; + static const uint64_t static_value2 = 0x332d540a0977563fULL; +}; + +template +struct DataType< ::sensor_msgs::CompressedImage_ > +{ + static const char* value() + { + return "sensor_msgs/CompressedImage"; + } + + static const char* value(const ::sensor_msgs::CompressedImage_&) { return value(); } +}; + +template +struct Definition< ::sensor_msgs::CompressedImage_ > +{ + static const char* value() + { + return "# This message contains a compressed image\n\ +\n\ +Header header # Header timestamp should be acquisition time of image\n\ + # Header frame_id should be optical frame of camera\n\ + # origin of frame should be optical center of cameara\n\ + # +x should point to the right in the image\n\ + # +y should point down in the image\n\ + # +z should point into to plane of the image\n\ +\n\ +string format # Specifies the format of the data\n\ + # Acceptable values:\n\ + # jpeg, png\n\ +uint8[] data # Compressed image buffer\n\ +\n\ +================================================================================\n\ +MSG: std_msgs/Header\n\ +# Standard metadata for higher-level stamped data types.\n\ +# This is generally used to communicate timestamped data \n\ +# in a particular coordinate frame.\n\ +# \n\ +# sequence ID: consecutively increasing ID \n\ +uint32 seq\n\ +#Two-integer timestamp that is expressed as:\n\ +# * stamp.sec: seconds (stamp_secs) since epoch (in Python the variable is called 'secs')\n\ +# * stamp.nsec: nanoseconds since stamp_secs (in Python the variable is called 'nsecs')\n\ +# time-handling sugar is provided by the client library\n\ +time stamp\n\ +#Frame this data is associated with\n\ +# 0: no frame\n\ +# 1: global frame\n\ +string frame_id\n\ +"; + } + + static const char* value(const ::sensor_msgs::CompressedImage_&) { return value(); } +}; + +} // namespace message_traits +} // namespace ros + +namespace ros +{ +namespace serialization +{ + + template struct Serializer< ::sensor_msgs::CompressedImage_ > + { + template inline static void allInOne(Stream& stream, T m) + { + stream.next(m.header); + stream.next(m.format); + stream.next(m.data); + } + + ROS_DECLARE_ALLINONE_SERIALIZER; + }; // struct CompressedImage_ + +} // namespace serialization +} // namespace ros + +namespace ros +{ +namespace message_operations +{ + +template +struct Printer< ::sensor_msgs::CompressedImage_ > +{ + template static void stream(Stream& s, const std::string& indent, const ::sensor_msgs::CompressedImage_& v) + { + s << indent << "header: "; + s << std::endl; + Printer< ::std_msgs::Header_ >::stream(s, indent + " ", v.header); + s << indent << "format: "; + Printer, typename ContainerAllocator::template rebind::other > >::stream(s, indent + " ", v.format); + s << indent << "data[]" << std::endl; + for (size_t i = 0; i < v.data.size(); ++i) + { + s << indent << " data[" << i << "]: "; + Printer::stream(s, indent + " ", v.data[i]); + } + } +}; + +} // namespace message_operations +} // namespace ros + +#endif // SENSOR_MSGS_MESSAGE_COMPRESSEDIMAGE_H diff --git a/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/FluidPressure.h b/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/FluidPressure.h new file mode 100644 index 0000000000..9f4974a9b3 --- /dev/null +++ b/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/FluidPressure.h @@ -0,0 +1,232 @@ +// Generated by gencpp from file sensor_msgs/FluidPressure.msg +// DO NOT EDIT! + + +#ifndef SENSOR_MSGS_MESSAGE_FLUIDPRESSURE_H +#define SENSOR_MSGS_MESSAGE_FLUIDPRESSURE_H + + +#include +#include +#include + +#include +#include +#include +#include + +#include + +namespace sensor_msgs +{ +template +struct FluidPressure_ +{ + typedef FluidPressure_ Type; + + FluidPressure_() + : header() + , fluid_pressure(0.0) + , variance(0.0) { + } + FluidPressure_(const ContainerAllocator& _alloc) + : header(_alloc) + , fluid_pressure(0.0) + , variance(0.0) { + (void)_alloc; + } + + + + typedef ::std_msgs::Header_ _header_type; + _header_type header; + + typedef double _fluid_pressure_type; + _fluid_pressure_type fluid_pressure; + + typedef double _variance_type; + _variance_type variance; + + + + + typedef boost::shared_ptr< ::sensor_msgs::FluidPressure_ > Ptr; + typedef boost::shared_ptr< ::sensor_msgs::FluidPressure_ const> ConstPtr; + +}; // struct FluidPressure_ + +typedef ::sensor_msgs::FluidPressure_ > FluidPressure; + +typedef boost::shared_ptr< ::sensor_msgs::FluidPressure > FluidPressurePtr; +typedef boost::shared_ptr< ::sensor_msgs::FluidPressure const> FluidPressureConstPtr; + +// constants requiring out of line definition + + + +template +std::ostream& operator<<(std::ostream& s, const ::sensor_msgs::FluidPressure_ & v) +{ +ros::message_operations::Printer< ::sensor_msgs::FluidPressure_ >::stream(s, "", v); +return s; +} + +} // namespace sensor_msgs + +namespace ros +{ +namespace message_traits +{ + + + +// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': True} +// {'std_msgs': ['/opt/ros/kinetic/share/std_msgs/cmake/../msg'], 'geometry_msgs': ['/opt/ros/kinetic/share/geometry_msgs/cmake/../msg'], 'sensor_msgs': ['/tmp/binarydeb/ros-kinetic-sensor-msgs-1.12.5/msg']} + +// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types'] + + + + +template +struct IsFixedSize< ::sensor_msgs::FluidPressure_ > + : FalseType + { }; + +template +struct IsFixedSize< ::sensor_msgs::FluidPressure_ const> + : FalseType + { }; + +template +struct IsMessage< ::sensor_msgs::FluidPressure_ > + : TrueType + { }; + +template +struct IsMessage< ::sensor_msgs::FluidPressure_ const> + : TrueType + { }; + +template +struct HasHeader< ::sensor_msgs::FluidPressure_ > + : TrueType + { }; + +template +struct HasHeader< ::sensor_msgs::FluidPressure_ const> + : TrueType + { }; + + +template +struct MD5Sum< ::sensor_msgs::FluidPressure_ > +{ + static const char* value() + { + return "804dc5cea1c5306d6a2eb80b9833befe"; + } + + static const char* value(const ::sensor_msgs::FluidPressure_&) { return value(); } + static const uint64_t static_value1 = 0x804dc5cea1c5306dULL; + static const uint64_t static_value2 = 0x6a2eb80b9833befeULL; +}; + +template +struct DataType< ::sensor_msgs::FluidPressure_ > +{ + static const char* value() + { + return "sensor_msgs/FluidPressure"; + } + + static const char* value(const ::sensor_msgs::FluidPressure_&) { return value(); } +}; + +template +struct Definition< ::sensor_msgs::FluidPressure_ > +{ + static const char* value() + { + return " # Single pressure reading. This message is appropriate for measuring the\n\ + # pressure inside of a fluid (air, water, etc). This also includes\n\ + # atmospheric or barometric pressure.\n\ +\n\ + # This message is not appropriate for force/pressure contact sensors.\n\ +\n\ + Header header # timestamp of the measurement\n\ + # frame_id is the location of the pressure sensor\n\ +\n\ + float64 fluid_pressure # Absolute pressure reading in Pascals.\n\ +\n\ + float64 variance # 0 is interpreted as variance unknown\n\ +================================================================================\n\ +MSG: std_msgs/Header\n\ +# Standard metadata for higher-level stamped data types.\n\ +# This is generally used to communicate timestamped data \n\ +# in a particular coordinate frame.\n\ +# \n\ +# sequence ID: consecutively increasing ID \n\ +uint32 seq\n\ +#Two-integer timestamp that is expressed as:\n\ +# * stamp.sec: seconds (stamp_secs) since epoch (in Python the variable is called 'secs')\n\ +# * stamp.nsec: nanoseconds since stamp_secs (in Python the variable is called 'nsecs')\n\ +# time-handling sugar is provided by the client library\n\ +time stamp\n\ +#Frame this data is associated with\n\ +# 0: no frame\n\ +# 1: global frame\n\ +string frame_id\n\ +"; + } + + static const char* value(const ::sensor_msgs::FluidPressure_&) { return value(); } +}; + +} // namespace message_traits +} // namespace ros + +namespace ros +{ +namespace serialization +{ + + template struct Serializer< ::sensor_msgs::FluidPressure_ > + { + template inline static void allInOne(Stream& stream, T m) + { + stream.next(m.header); + stream.next(m.fluid_pressure); + stream.next(m.variance); + } + + ROS_DECLARE_ALLINONE_SERIALIZER; + }; // struct FluidPressure_ + +} // namespace serialization +} // namespace ros + +namespace ros +{ +namespace message_operations +{ + +template +struct Printer< ::sensor_msgs::FluidPressure_ > +{ + template static void stream(Stream& s, const std::string& indent, const ::sensor_msgs::FluidPressure_& v) + { + s << indent << "header: "; + s << std::endl; + Printer< ::std_msgs::Header_ >::stream(s, indent + " ", v.header); + s << indent << "fluid_pressure: "; + Printer::stream(s, indent + " ", v.fluid_pressure); + s << indent << "variance: "; + Printer::stream(s, indent + " ", v.variance); + } +}; + +} // namespace message_operations +} // namespace ros + +#endif // SENSOR_MSGS_MESSAGE_FLUIDPRESSURE_H diff --git a/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/Illuminance.h b/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/Illuminance.h new file mode 100644 index 0000000000..4c071683d6 --- /dev/null +++ b/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/Illuminance.h @@ -0,0 +1,241 @@ +// Generated by gencpp from file sensor_msgs/Illuminance.msg +// DO NOT EDIT! + + +#ifndef SENSOR_MSGS_MESSAGE_ILLUMINANCE_H +#define SENSOR_MSGS_MESSAGE_ILLUMINANCE_H + + +#include +#include +#include + +#include +#include +#include +#include + +#include + +namespace sensor_msgs +{ +template +struct Illuminance_ +{ + typedef Illuminance_ Type; + + Illuminance_() + : header() + , illuminance(0.0) + , variance(0.0) { + } + Illuminance_(const ContainerAllocator& _alloc) + : header(_alloc) + , illuminance(0.0) + , variance(0.0) { + (void)_alloc; + } + + + + typedef ::std_msgs::Header_ _header_type; + _header_type header; + + typedef double _illuminance_type; + _illuminance_type illuminance; + + typedef double _variance_type; + _variance_type variance; + + + + + typedef boost::shared_ptr< ::sensor_msgs::Illuminance_ > Ptr; + typedef boost::shared_ptr< ::sensor_msgs::Illuminance_ const> ConstPtr; + +}; // struct Illuminance_ + +typedef ::sensor_msgs::Illuminance_ > Illuminance; + +typedef boost::shared_ptr< ::sensor_msgs::Illuminance > IlluminancePtr; +typedef boost::shared_ptr< ::sensor_msgs::Illuminance const> IlluminanceConstPtr; + +// constants requiring out of line definition + + + +template +std::ostream& operator<<(std::ostream& s, const ::sensor_msgs::Illuminance_ & v) +{ +ros::message_operations::Printer< ::sensor_msgs::Illuminance_ >::stream(s, "", v); +return s; +} + +} // namespace sensor_msgs + +namespace ros +{ +namespace message_traits +{ + + + +// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': True} +// {'std_msgs': ['/opt/ros/kinetic/share/std_msgs/cmake/../msg'], 'geometry_msgs': ['/opt/ros/kinetic/share/geometry_msgs/cmake/../msg'], 'sensor_msgs': ['/tmp/binarydeb/ros-kinetic-sensor-msgs-1.12.5/msg']} + +// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types'] + + + + +template +struct IsFixedSize< ::sensor_msgs::Illuminance_ > + : FalseType + { }; + +template +struct IsFixedSize< ::sensor_msgs::Illuminance_ const> + : FalseType + { }; + +template +struct IsMessage< ::sensor_msgs::Illuminance_ > + : TrueType + { }; + +template +struct IsMessage< ::sensor_msgs::Illuminance_ const> + : TrueType + { }; + +template +struct HasHeader< ::sensor_msgs::Illuminance_ > + : TrueType + { }; + +template +struct HasHeader< ::sensor_msgs::Illuminance_ const> + : TrueType + { }; + + +template +struct MD5Sum< ::sensor_msgs::Illuminance_ > +{ + static const char* value() + { + return "8cf5febb0952fca9d650c3d11a81a188"; + } + + static const char* value(const ::sensor_msgs::Illuminance_&) { return value(); } + static const uint64_t static_value1 = 0x8cf5febb0952fca9ULL; + static const uint64_t static_value2 = 0xd650c3d11a81a188ULL; +}; + +template +struct DataType< ::sensor_msgs::Illuminance_ > +{ + static const char* value() + { + return "sensor_msgs/Illuminance"; + } + + static const char* value(const ::sensor_msgs::Illuminance_&) { return value(); } +}; + +template +struct Definition< ::sensor_msgs::Illuminance_ > +{ + static const char* value() + { + return " # Single photometric illuminance measurement. Light should be assumed to be\n\ + # measured along the sensor's x-axis (the area of detection is the y-z plane).\n\ + # The illuminance should have a 0 or positive value and be received with\n\ + # the sensor's +X axis pointing toward the light source.\n\ +\n\ + # Photometric illuminance is the measure of the human eye's sensitivity of the\n\ + # intensity of light encountering or passing through a surface.\n\ +\n\ + # All other Photometric and Radiometric measurements should\n\ + # not use this message.\n\ + # This message cannot represent:\n\ + # Luminous intensity (candela/light source output)\n\ + # Luminance (nits/light output per area)\n\ + # Irradiance (watt/area), etc.\n\ +\n\ + Header header # timestamp is the time the illuminance was measured\n\ + # frame_id is the location and direction of the reading\n\ +\n\ + float64 illuminance # Measurement of the Photometric Illuminance in Lux.\n\ +\n\ + float64 variance # 0 is interpreted as variance unknown\n\ +================================================================================\n\ +MSG: std_msgs/Header\n\ +# Standard metadata for higher-level stamped data types.\n\ +# This is generally used to communicate timestamped data \n\ +# in a particular coordinate frame.\n\ +# \n\ +# sequence ID: consecutively increasing ID \n\ +uint32 seq\n\ +#Two-integer timestamp that is expressed as:\n\ +# * stamp.sec: seconds (stamp_secs) since epoch (in Python the variable is called 'secs')\n\ +# * stamp.nsec: nanoseconds since stamp_secs (in Python the variable is called 'nsecs')\n\ +# time-handling sugar is provided by the client library\n\ +time stamp\n\ +#Frame this data is associated with\n\ +# 0: no frame\n\ +# 1: global frame\n\ +string frame_id\n\ +"; + } + + static const char* value(const ::sensor_msgs::Illuminance_&) { return value(); } +}; + +} // namespace message_traits +} // namespace ros + +namespace ros +{ +namespace serialization +{ + + template struct Serializer< ::sensor_msgs::Illuminance_ > + { + template inline static void allInOne(Stream& stream, T m) + { + stream.next(m.header); + stream.next(m.illuminance); + stream.next(m.variance); + } + + ROS_DECLARE_ALLINONE_SERIALIZER; + }; // struct Illuminance_ + +} // namespace serialization +} // namespace ros + +namespace ros +{ +namespace message_operations +{ + +template +struct Printer< ::sensor_msgs::Illuminance_ > +{ + template static void stream(Stream& s, const std::string& indent, const ::sensor_msgs::Illuminance_& v) + { + s << indent << "header: "; + s << std::endl; + Printer< ::std_msgs::Header_ >::stream(s, indent + " ", v.header); + s << indent << "illuminance: "; + Printer::stream(s, indent + " ", v.illuminance); + s << indent << "variance: "; + Printer::stream(s, indent + " ", v.variance); + } +}; + +} // namespace message_operations +} // namespace ros + +#endif // SENSOR_MSGS_MESSAGE_ILLUMINANCE_H diff --git a/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/Image.h b/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/Image.h new file mode 100644 index 0000000000..27a8e1297e --- /dev/null +++ b/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/Image.h @@ -0,0 +1,284 @@ +// Generated by gencpp from file sensor_msgs/Image.msg +// DO NOT EDIT! + + +#ifndef SENSOR_MSGS_MESSAGE_IMAGE_H +#define SENSOR_MSGS_MESSAGE_IMAGE_H + +#include +#include +#include +#include + +#include +#include +#include +#include + +#include + +namespace sensor_msgs +{ +template +struct Image_ +{ + typedef Image_ Type; + + Image_() + : header() + , height(0) + , width(0) + , encoding() + , is_bigendian(0) + , step(0) + , data() { + } + Image_(const ContainerAllocator& _alloc) + : header(_alloc) + , height(0) + , width(0) + , encoding(_alloc) + , is_bigendian(0) + , step(0) + , data(_alloc) { + (void)_alloc; + } + + + + typedef ::std_msgs::Header_ _header_type; + _header_type header; + + typedef uint32_t _height_type; + _height_type height; + + typedef uint32_t _width_type; + _width_type width; + + typedef std::basic_string, typename ContainerAllocator::template rebind::other > _encoding_type; + _encoding_type encoding; + + typedef uint8_t _is_bigendian_type; + _is_bigendian_type is_bigendian; + + typedef uint32_t _step_type; + _step_type step; + + typedef std::vector::other > _data_type; + _data_type data; + + + + + typedef std::shared_ptr< ::sensor_msgs::Image_ > Ptr; + typedef std::shared_ptr< ::sensor_msgs::Image_ const> ConstPtr; + +}; // struct Image_ + +typedef ::sensor_msgs::Image_ > Image; + +typedef std::shared_ptr< ::sensor_msgs::Image > ImagePtr; +typedef std::shared_ptr< ::sensor_msgs::Image const> ImageConstPtr; + +// constants requiring out of line definition + + + +template +std::ostream& operator<<(std::ostream& s, const ::sensor_msgs::Image_ & v) +{ +ros::message_operations::Printer< ::sensor_msgs::Image_ >::stream(s, "", v); +return s; +} + +} // namespace sensor_msgs + +namespace ros +{ +namespace message_traits +{ + + + +// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': True} +// {'std_msgs': ['/opt/ros/kinetic/share/std_msgs/cmake/../msg'], 'geometry_msgs': ['/opt/ros/kinetic/share/geometry_msgs/cmake/../msg'], 'sensor_msgs': ['/tmp/binarydeb/ros-kinetic-sensor-msgs-1.12.5/msg']} + +// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types'] + + + + +template +struct IsFixedSize< ::sensor_msgs::Image_ > + : FalseType + { }; + +template +struct IsFixedSize< ::sensor_msgs::Image_ const> + : FalseType + { }; + +template +struct IsMessage< ::sensor_msgs::Image_ > + : TrueType + { }; + +template +struct IsMessage< ::sensor_msgs::Image_ const> + : TrueType + { }; + +template +struct HasHeader< ::sensor_msgs::Image_ > + : TrueType + { }; + +template +struct HasHeader< ::sensor_msgs::Image_ const> + : TrueType + { }; + + +template +struct MD5Sum< ::sensor_msgs::Image_ > +{ + static const char* value() + { + return "060021388200f6f0f447d0fcd9c64743"; + } + + static const char* value(const ::sensor_msgs::Image_&) { return value(); } + static const uint64_t static_value1 = 0x060021388200f6f0ULL; + static const uint64_t static_value2 = 0xf447d0fcd9c64743ULL; +}; + +template +struct DataType< ::sensor_msgs::Image_ > +{ + static const char* value() + { + return "sensor_msgs/Image"; + } + + static const char* value(const ::sensor_msgs::Image_&) { return value(); } +}; + +template +struct Definition< ::sensor_msgs::Image_ > +{ + static const char* value() + { + return "# This message contains an uncompressed image\n\ +# (0, 0) is at top-left corner of image\n\ +#\n\ +\n\ +Header header # Header timestamp should be acquisition time of image\n\ + # Header frame_id should be optical frame of camera\n\ + # origin of frame should be optical center of cameara\n\ + # +x should point to the right in the image\n\ + # +y should point down in the image\n\ + # +z should point into to plane of the image\n\ + # If the frame_id here and the frame_id of the CameraInfo\n\ + # message associated with the image conflict\n\ + # the behavior is undefined\n\ +\n\ +uint32 height # image height, that is, number of rows\n\ +uint32 width # image width, that is, number of columns\n\ +\n\ +# The legal values for encoding are in file src/image_encodings.cpp\n\ +# If you want to standardize a new string format, join\n\ +# ros-users@lists.sourceforge.net and send an email proposing a new encoding.\n\ +\n\ +string encoding # Encoding of pixels -- channel meaning, ordering, size\n\ + # taken from the list of strings in include/sensor_msgs/image_encodings.h\n\ +\n\ +uint8 is_bigendian # is this data bigendian?\n\ +uint32 step # Full row length in bytes\n\ +uint8[] data # actual matrix data, size is (step * rows)\n\ +\n\ +================================================================================\n\ +MSG: std_msgs/Header\n\ +# Standard metadata for higher-level stamped data types.\n\ +# This is generally used to communicate timestamped data \n\ +# in a particular coordinate frame.\n\ +# \n\ +# sequence ID: consecutively increasing ID \n\ +uint32 seq\n\ +#Two-integer timestamp that is expressed as:\n\ +# * stamp.sec: seconds (stamp_secs) since epoch (in Python the variable is called 'secs')\n\ +# * stamp.nsec: nanoseconds since stamp_secs (in Python the variable is called 'nsecs')\n\ +# time-handling sugar is provided by the client library\n\ +time stamp\n\ +#Frame this data is associated with\n\ +# 0: no frame\n\ +# 1: global frame\n\ +string frame_id\n\ +"; + } + + static const char* value(const ::sensor_msgs::Image_&) { return value(); } +}; + +} // namespace message_traits +} // namespace ros + +namespace ros +{ +namespace serialization +{ + + template struct Serializer< ::sensor_msgs::Image_ > + { + template inline static void allInOne(Stream& stream, T m) + { + stream.next(m.header); + stream.next(m.height); + stream.next(m.width); + stream.next(m.encoding); + stream.next(m.is_bigendian); + stream.next(m.step); + stream.next(m.data); + } + + ROS_DECLARE_ALLINONE_SERIALIZER; + }; // struct Image_ + +} // namespace serialization +} // namespace ros + +namespace ros +{ +namespace message_operations +{ + +template +struct Printer< ::sensor_msgs::Image_ > +{ + template static void stream(Stream& s, const std::string& indent, const ::sensor_msgs::Image_& v) + { + s << indent << "header: "; + s << std::endl; + Printer< ::std_msgs::Header_ >::stream(s, indent + " ", v.header); + s << indent << "height: "; + Printer::stream(s, indent + " ", v.height); + s << indent << "width: "; + Printer::stream(s, indent + " ", v.width); + s << indent << "encoding: "; + Printer, typename ContainerAllocator::template rebind::other > >::stream(s, indent + " ", v.encoding); + s << indent << "is_bigendian: "; + Printer::stream(s, indent + " ", v.is_bigendian); + s << indent << "step: "; + Printer::stream(s, indent + " ", v.step); + s << indent << "data[]" << std::endl; + for (size_t i = 0; i < v.data.size(); ++i) + { + s << indent << " data[" << i << "]: "; + Printer::stream(s, indent + " ", v.data[i]); + } + } +}; + +} // namespace message_operations +} // namespace ros + +#endif // SENSOR_MSGS_MESSAGE_IMAGE_H diff --git a/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/Imu.h b/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/Imu.h new file mode 100644 index 0000000000..469cc65abd --- /dev/null +++ b/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/Imu.h @@ -0,0 +1,327 @@ +// Generated by gencpp from file sensor_msgs/Imu.msg +// DO NOT EDIT! + + +#ifndef SENSOR_MSGS_MESSAGE_IMU_H +#define SENSOR_MSGS_MESSAGE_IMU_H + + +#include +#include +#include + +#include +#include +#include +#include + +#include +#include +#include +#include + +namespace sensor_msgs +{ +template +struct Imu_ +{ + typedef Imu_ Type; + + Imu_() + : header() + , orientation() + , orientation_covariance() + , angular_velocity() + , angular_velocity_covariance() + , linear_acceleration() + , linear_acceleration_covariance() { + orientation_covariance.fill(0.0); + + angular_velocity_covariance.fill(0.0); + + linear_acceleration_covariance.fill(0.0); + } + Imu_(const ContainerAllocator& _alloc) + : header(_alloc) + , orientation(_alloc) + , orientation_covariance() + , angular_velocity(_alloc) + , angular_velocity_covariance() + , linear_acceleration(_alloc) + , linear_acceleration_covariance() { + (void)_alloc; + orientation_covariance.fill(0.0); + + angular_velocity_covariance.fill(0.0); + + linear_acceleration_covariance.fill(0.0); + } + + + + typedef ::std_msgs::Header_ _header_type; + _header_type header; + + typedef ::geometry_msgs::Quaternion_ _orientation_type; + _orientation_type orientation; + + typedef std::array _orientation_covariance_type; + _orientation_covariance_type orientation_covariance; + + typedef ::geometry_msgs::Vector3_ _angular_velocity_type; + _angular_velocity_type angular_velocity; + + typedef std::array _angular_velocity_covariance_type; + _angular_velocity_covariance_type angular_velocity_covariance; + + typedef ::geometry_msgs::Vector3_ _linear_acceleration_type; + _linear_acceleration_type linear_acceleration; + + typedef std::array _linear_acceleration_covariance_type; + _linear_acceleration_covariance_type linear_acceleration_covariance; + + + + + typedef std::shared_ptr< ::sensor_msgs::Imu_ > Ptr; + typedef std::shared_ptr< ::sensor_msgs::Imu_ const> ConstPtr; + +}; // struct Imu_ + +typedef ::sensor_msgs::Imu_ > Imu; + +typedef std::shared_ptr< ::sensor_msgs::Imu > ImuPtr; +typedef std::shared_ptr< ::sensor_msgs::Imu const> ImuConstPtr; + +// constants requiring out of line definition + + + +template +std::ostream& operator<<(std::ostream& s, const ::sensor_msgs::Imu_ & v) +{ +ros::message_operations::Printer< ::sensor_msgs::Imu_ >::stream(s, "", v); +return s; +} + +} // namespace sensor_msgs + +namespace ros +{ +namespace message_traits +{ + + + +// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': True} +// {'std_msgs': ['/opt/ros/kinetic/share/std_msgs/cmake/../msg'], 'geometry_msgs': ['/opt/ros/kinetic/share/geometry_msgs/cmake/../msg'], 'sensor_msgs': ['/tmp/binarydeb/ros-kinetic-sensor-msgs-1.12.5/msg']} + +// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types'] + + + + +template +struct IsFixedSize< ::sensor_msgs::Imu_ > + : FalseType + { }; + +template +struct IsFixedSize< ::sensor_msgs::Imu_ const> + : FalseType + { }; + +template +struct IsMessage< ::sensor_msgs::Imu_ > + : TrueType + { }; + +template +struct IsMessage< ::sensor_msgs::Imu_ const> + : TrueType + { }; + +template +struct HasHeader< ::sensor_msgs::Imu_ > + : TrueType + { }; + +template +struct HasHeader< ::sensor_msgs::Imu_ const> + : TrueType + { }; + + +template +struct MD5Sum< ::sensor_msgs::Imu_ > +{ + static const char* value() + { + return "6a62c6daae103f4ff57a132d6f95cec2"; + } + + static const char* value(const ::sensor_msgs::Imu_&) { return value(); } + static const uint64_t static_value1 = 0x6a62c6daae103f4fULL; + static const uint64_t static_value2 = 0xf57a132d6f95cec2ULL; +}; + +template +struct DataType< ::sensor_msgs::Imu_ > +{ + static const char* value() + { + return "sensor_msgs/Imu"; + } + + static const char* value(const ::sensor_msgs::Imu_&) { return value(); } +}; + +template +struct Definition< ::sensor_msgs::Imu_ > +{ + static const char* value() + { + return "# This is a message to hold data from an IMU (Inertial Measurement Unit)\n\ +#\n\ +# Accelerations should be in m/s^2 (not in g's), and rotational velocity should be in rad/sec\n\ +#\n\ +# If the covariance of the measurement is known, it should be filled in (if all you know is the \n\ +# variance of each measurement, e.g. from the datasheet, just put those along the diagonal)\n\ +# A covariance matrix of all zeros will be interpreted as \"covariance unknown\", and to use the\n\ +# data a covariance will have to be assumed or gotten from some other source\n\ +#\n\ +# If you have no estimate for one of the data elements (e.g. your IMU doesn't produce an orientation \n\ +# estimate), please set element 0 of the associated covariance matrix to -1\n\ +# If you are interpreting this message, please check for a value of -1 in the first element of each \n\ +# covariance matrix, and disregard the associated estimate.\n\ +\n\ +Header header\n\ +\n\ +geometry_msgs/Quaternion orientation\n\ +float64[9] orientation_covariance # Row major about x, y, z axes\n\ +\n\ +geometry_msgs/Vector3 angular_velocity\n\ +float64[9] angular_velocity_covariance # Row major about x, y, z axes\n\ +\n\ +geometry_msgs/Vector3 linear_acceleration\n\ +float64[9] linear_acceleration_covariance # Row major x, y z \n\ +\n\ +================================================================================\n\ +MSG: std_msgs/Header\n\ +# Standard metadata for higher-level stamped data types.\n\ +# This is generally used to communicate timestamped data \n\ +# in a particular coordinate frame.\n\ +# \n\ +# sequence ID: consecutively increasing ID \n\ +uint32 seq\n\ +#Two-integer timestamp that is expressed as:\n\ +# * stamp.sec: seconds (stamp_secs) since epoch (in Python the variable is called 'secs')\n\ +# * stamp.nsec: nanoseconds since stamp_secs (in Python the variable is called 'nsecs')\n\ +# time-handling sugar is provided by the client library\n\ +time stamp\n\ +#Frame this data is associated with\n\ +# 0: no frame\n\ +# 1: global frame\n\ +string frame_id\n\ +\n\ +================================================================================\n\ +MSG: geometry_msgs/Quaternion\n\ +# This represents an orientation in free space in quaternion form.\n\ +\n\ +float64 x\n\ +float64 y\n\ +float64 z\n\ +float64 w\n\ +\n\ +================================================================================\n\ +MSG: geometry_msgs/Vector3\n\ +# This represents a vector in free space. \n\ +# It is only meant to represent a direction. Therefore, it does not\n\ +# make sense to apply a translation to it (e.g., when applying a \n\ +# generic rigid transformation to a Vector3, tf2 will only apply the\n\ +# rotation). If you want your data to be translatable too, use the\n\ +# geometry_msgs/Point message instead.\n\ +\n\ +float64 x\n\ +float64 y\n\ +float64 z\n\ +"; + } + + static const char* value(const ::sensor_msgs::Imu_&) { return value(); } +}; + +} // namespace message_traits +} // namespace ros + +namespace ros +{ +namespace serialization +{ + + template struct Serializer< ::sensor_msgs::Imu_ > + { + template inline static void allInOne(Stream& stream, T m) + { + stream.next(m.header); + stream.next(m.orientation); + stream.next(m.orientation_covariance); + stream.next(m.angular_velocity); + stream.next(m.angular_velocity_covariance); + stream.next(m.linear_acceleration); + stream.next(m.linear_acceleration_covariance); + } + + ROS_DECLARE_ALLINONE_SERIALIZER; + }; // struct Imu_ + +} // namespace serialization +} // namespace ros + +namespace ros +{ +namespace message_operations +{ + +template +struct Printer< ::sensor_msgs::Imu_ > +{ + template static void stream(Stream& s, const std::string& indent, const ::sensor_msgs::Imu_& v) + { + s << indent << "header: "; + s << std::endl; + Printer< ::std_msgs::Header_ >::stream(s, indent + " ", v.header); + s << indent << "orientation: "; + s << std::endl; + Printer< ::geometry_msgs::Quaternion_ >::stream(s, indent + " ", v.orientation); + s << indent << "orientation_covariance[]" << std::endl; + for (size_t i = 0; i < v.orientation_covariance.size(); ++i) + { + s << indent << " orientation_covariance[" << i << "]: "; + Printer::stream(s, indent + " ", v.orientation_covariance[i]); + } + s << indent << "angular_velocity: "; + s << std::endl; + Printer< ::geometry_msgs::Vector3_ >::stream(s, indent + " ", v.angular_velocity); + s << indent << "angular_velocity_covariance[]" << std::endl; + for (size_t i = 0; i < v.angular_velocity_covariance.size(); ++i) + { + s << indent << " angular_velocity_covariance[" << i << "]: "; + Printer::stream(s, indent + " ", v.angular_velocity_covariance[i]); + } + s << indent << "linear_acceleration: "; + s << std::endl; + Printer< ::geometry_msgs::Vector3_ >::stream(s, indent + " ", v.linear_acceleration); + s << indent << "linear_acceleration_covariance[]" << std::endl; + for (size_t i = 0; i < v.linear_acceleration_covariance.size(); ++i) + { + s << indent << " linear_acceleration_covariance[" << i << "]: "; + Printer::stream(s, indent + " ", v.linear_acceleration_covariance[i]); + } + } +}; + +} // namespace message_operations +} // namespace ros + +#endif // SENSOR_MSGS_MESSAGE_IMU_H diff --git a/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/JointState.h b/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/JointState.h new file mode 100644 index 0000000000..5bc34ec067 --- /dev/null +++ b/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/JointState.h @@ -0,0 +1,279 @@ +// Generated by gencpp from file sensor_msgs/JointState.msg +// DO NOT EDIT! + + +#ifndef SENSOR_MSGS_MESSAGE_JOINTSTATE_H +#define SENSOR_MSGS_MESSAGE_JOINTSTATE_H + + +#include +#include +#include + +#include +#include +#include +#include + +#include + +namespace sensor_msgs +{ +template +struct JointState_ +{ + typedef JointState_ Type; + + JointState_() + : header() + , name() + , position() + , velocity() + , effort() { + } + JointState_(const ContainerAllocator& _alloc) + : header(_alloc) + , name(_alloc) + , position(_alloc) + , velocity(_alloc) + , effort(_alloc) { + (void)_alloc; + } + + + + typedef ::std_msgs::Header_ _header_type; + _header_type header; + + typedef std::vector, typename ContainerAllocator::template rebind::other > , typename ContainerAllocator::template rebind, typename ContainerAllocator::template rebind::other > >::other > _name_type; + _name_type name; + + typedef std::vector::other > _position_type; + _position_type position; + + typedef std::vector::other > _velocity_type; + _velocity_type velocity; + + typedef std::vector::other > _effort_type; + _effort_type effort; + + + + + typedef boost::shared_ptr< ::sensor_msgs::JointState_ > Ptr; + typedef boost::shared_ptr< ::sensor_msgs::JointState_ const> ConstPtr; + +}; // struct JointState_ + +typedef ::sensor_msgs::JointState_ > JointState; + +typedef boost::shared_ptr< ::sensor_msgs::JointState > JointStatePtr; +typedef boost::shared_ptr< ::sensor_msgs::JointState const> JointStateConstPtr; + +// constants requiring out of line definition + + + +template +std::ostream& operator<<(std::ostream& s, const ::sensor_msgs::JointState_ & v) +{ +ros::message_operations::Printer< ::sensor_msgs::JointState_ >::stream(s, "", v); +return s; +} + +} // namespace sensor_msgs + +namespace ros +{ +namespace message_traits +{ + + + +// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': True} +// {'std_msgs': ['/opt/ros/kinetic/share/std_msgs/cmake/../msg'], 'geometry_msgs': ['/opt/ros/kinetic/share/geometry_msgs/cmake/../msg'], 'sensor_msgs': ['/tmp/binarydeb/ros-kinetic-sensor-msgs-1.12.5/msg']} + +// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types'] + + + + +template +struct IsFixedSize< ::sensor_msgs::JointState_ > + : FalseType + { }; + +template +struct IsFixedSize< ::sensor_msgs::JointState_ const> + : FalseType + { }; + +template +struct IsMessage< ::sensor_msgs::JointState_ > + : TrueType + { }; + +template +struct IsMessage< ::sensor_msgs::JointState_ const> + : TrueType + { }; + +template +struct HasHeader< ::sensor_msgs::JointState_ > + : TrueType + { }; + +template +struct HasHeader< ::sensor_msgs::JointState_ const> + : TrueType + { }; + + +template +struct MD5Sum< ::sensor_msgs::JointState_ > +{ + static const char* value() + { + return "3066dcd76a6cfaef579bd0f34173e9fd"; + } + + static const char* value(const ::sensor_msgs::JointState_&) { return value(); } + static const uint64_t static_value1 = 0x3066dcd76a6cfaefULL; + static const uint64_t static_value2 = 0x579bd0f34173e9fdULL; +}; + +template +struct DataType< ::sensor_msgs::JointState_ > +{ + static const char* value() + { + return "sensor_msgs/JointState"; + } + + static const char* value(const ::sensor_msgs::JointState_&) { return value(); } +}; + +template +struct Definition< ::sensor_msgs::JointState_ > +{ + static const char* value() + { + return "# This is a message that holds data to describe the state of a set of torque controlled joints. \n\ +#\n\ +# The state of each joint (revolute or prismatic) is defined by:\n\ +# * the position of the joint (rad or m),\n\ +# * the velocity of the joint (rad/s or m/s) and \n\ +# * the effort that is applied in the joint (Nm or N).\n\ +#\n\ +# Each joint is uniquely identified by its name\n\ +# The header specifies the time at which the joint states were recorded. All the joint states\n\ +# in one message have to be recorded at the same time.\n\ +#\n\ +# This message consists of a multiple arrays, one for each part of the joint state. \n\ +# The goal is to make each of the fields optional. When e.g. your joints have no\n\ +# effort associated with them, you can leave the effort array empty. \n\ +#\n\ +# All arrays in this message should have the same size, or be empty.\n\ +# This is the only way to uniquely associate the joint name with the correct\n\ +# states.\n\ +\n\ +\n\ +Header header\n\ +\n\ +string[] name\n\ +float64[] position\n\ +float64[] velocity\n\ +float64[] effort\n\ +\n\ +================================================================================\n\ +MSG: std_msgs/Header\n\ +# Standard metadata for higher-level stamped data types.\n\ +# This is generally used to communicate timestamped data \n\ +# in a particular coordinate frame.\n\ +# \n\ +# sequence ID: consecutively increasing ID \n\ +uint32 seq\n\ +#Two-integer timestamp that is expressed as:\n\ +# * stamp.sec: seconds (stamp_secs) since epoch (in Python the variable is called 'secs')\n\ +# * stamp.nsec: nanoseconds since stamp_secs (in Python the variable is called 'nsecs')\n\ +# time-handling sugar is provided by the client library\n\ +time stamp\n\ +#Frame this data is associated with\n\ +# 0: no frame\n\ +# 1: global frame\n\ +string frame_id\n\ +"; + } + + static const char* value(const ::sensor_msgs::JointState_&) { return value(); } +}; + +} // namespace message_traits +} // namespace ros + +namespace ros +{ +namespace serialization +{ + + template struct Serializer< ::sensor_msgs::JointState_ > + { + template inline static void allInOne(Stream& stream, T m) + { + stream.next(m.header); + stream.next(m.name); + stream.next(m.position); + stream.next(m.velocity); + stream.next(m.effort); + } + + ROS_DECLARE_ALLINONE_SERIALIZER; + }; // struct JointState_ + +} // namespace serialization +} // namespace ros + +namespace ros +{ +namespace message_operations +{ + +template +struct Printer< ::sensor_msgs::JointState_ > +{ + template static void stream(Stream& s, const std::string& indent, const ::sensor_msgs::JointState_& v) + { + s << indent << "header: "; + s << std::endl; + Printer< ::std_msgs::Header_ >::stream(s, indent + " ", v.header); + s << indent << "name[]" << std::endl; + for (size_t i = 0; i < v.name.size(); ++i) + { + s << indent << " name[" << i << "]: "; + Printer, typename ContainerAllocator::template rebind::other > >::stream(s, indent + " ", v.name[i]); + } + s << indent << "position[]" << std::endl; + for (size_t i = 0; i < v.position.size(); ++i) + { + s << indent << " position[" << i << "]: "; + Printer::stream(s, indent + " ", v.position[i]); + } + s << indent << "velocity[]" << std::endl; + for (size_t i = 0; i < v.velocity.size(); ++i) + { + s << indent << " velocity[" << i << "]: "; + Printer::stream(s, indent + " ", v.velocity[i]); + } + s << indent << "effort[]" << std::endl; + for (size_t i = 0; i < v.effort.size(); ++i) + { + s << indent << " effort[" << i << "]: "; + Printer::stream(s, indent + " ", v.effort[i]); + } + } +}; + +} // namespace message_operations +} // namespace ros + +#endif // SENSOR_MSGS_MESSAGE_JOINTSTATE_H diff --git a/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/Joy.h b/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/Joy.h new file mode 100644 index 0000000000..f912e5634d --- /dev/null +++ b/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/Joy.h @@ -0,0 +1,233 @@ +// Generated by gencpp from file sensor_msgs/Joy.msg +// DO NOT EDIT! + + +#ifndef SENSOR_MSGS_MESSAGE_JOY_H +#define SENSOR_MSGS_MESSAGE_JOY_H + + +#include +#include +#include + +#include +#include +#include +#include + +#include + +namespace sensor_msgs +{ +template +struct Joy_ +{ + typedef Joy_ Type; + + Joy_() + : header() + , axes() + , buttons() { + } + Joy_(const ContainerAllocator& _alloc) + : header(_alloc) + , axes(_alloc) + , buttons(_alloc) { + (void)_alloc; + } + + + + typedef ::std_msgs::Header_ _header_type; + _header_type header; + + typedef std::vector::other > _axes_type; + _axes_type axes; + + typedef std::vector::other > _buttons_type; + _buttons_type buttons; + + + + + typedef boost::shared_ptr< ::sensor_msgs::Joy_ > Ptr; + typedef boost::shared_ptr< ::sensor_msgs::Joy_ const> ConstPtr; + +}; // struct Joy_ + +typedef ::sensor_msgs::Joy_ > Joy; + +typedef boost::shared_ptr< ::sensor_msgs::Joy > JoyPtr; +typedef boost::shared_ptr< ::sensor_msgs::Joy const> JoyConstPtr; + +// constants requiring out of line definition + + + +template +std::ostream& operator<<(std::ostream& s, const ::sensor_msgs::Joy_ & v) +{ +ros::message_operations::Printer< ::sensor_msgs::Joy_ >::stream(s, "", v); +return s; +} + +} // namespace sensor_msgs + +namespace ros +{ +namespace message_traits +{ + + + +// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': True} +// {'std_msgs': ['/opt/ros/kinetic/share/std_msgs/cmake/../msg'], 'geometry_msgs': ['/opt/ros/kinetic/share/geometry_msgs/cmake/../msg'], 'sensor_msgs': ['/tmp/binarydeb/ros-kinetic-sensor-msgs-1.12.5/msg']} + +// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types'] + + + + +template +struct IsFixedSize< ::sensor_msgs::Joy_ > + : FalseType + { }; + +template +struct IsFixedSize< ::sensor_msgs::Joy_ const> + : FalseType + { }; + +template +struct IsMessage< ::sensor_msgs::Joy_ > + : TrueType + { }; + +template +struct IsMessage< ::sensor_msgs::Joy_ const> + : TrueType + { }; + +template +struct HasHeader< ::sensor_msgs::Joy_ > + : TrueType + { }; + +template +struct HasHeader< ::sensor_msgs::Joy_ const> + : TrueType + { }; + + +template +struct MD5Sum< ::sensor_msgs::Joy_ > +{ + static const char* value() + { + return "5a9ea5f83505693b71e785041e67a8bb"; + } + + static const char* value(const ::sensor_msgs::Joy_&) { return value(); } + static const uint64_t static_value1 = 0x5a9ea5f83505693bULL; + static const uint64_t static_value2 = 0x71e785041e67a8bbULL; +}; + +template +struct DataType< ::sensor_msgs::Joy_ > +{ + static const char* value() + { + return "sensor_msgs/Joy"; + } + + static const char* value(const ::sensor_msgs::Joy_&) { return value(); } +}; + +template +struct Definition< ::sensor_msgs::Joy_ > +{ + static const char* value() + { + return "# Reports the state of a joysticks axes and buttons.\n\ +Header header # timestamp in the header is the time the data is received from the joystick\n\ +float32[] axes # the axes measurements from a joystick\n\ +int32[] buttons # the buttons measurements from a joystick \n\ +\n\ +================================================================================\n\ +MSG: std_msgs/Header\n\ +# Standard metadata for higher-level stamped data types.\n\ +# This is generally used to communicate timestamped data \n\ +# in a particular coordinate frame.\n\ +# \n\ +# sequence ID: consecutively increasing ID \n\ +uint32 seq\n\ +#Two-integer timestamp that is expressed as:\n\ +# * stamp.sec: seconds (stamp_secs) since epoch (in Python the variable is called 'secs')\n\ +# * stamp.nsec: nanoseconds since stamp_secs (in Python the variable is called 'nsecs')\n\ +# time-handling sugar is provided by the client library\n\ +time stamp\n\ +#Frame this data is associated with\n\ +# 0: no frame\n\ +# 1: global frame\n\ +string frame_id\n\ +"; + } + + static const char* value(const ::sensor_msgs::Joy_&) { return value(); } +}; + +} // namespace message_traits +} // namespace ros + +namespace ros +{ +namespace serialization +{ + + template struct Serializer< ::sensor_msgs::Joy_ > + { + template inline static void allInOne(Stream& stream, T m) + { + stream.next(m.header); + stream.next(m.axes); + stream.next(m.buttons); + } + + ROS_DECLARE_ALLINONE_SERIALIZER; + }; // struct Joy_ + +} // namespace serialization +} // namespace ros + +namespace ros +{ +namespace message_operations +{ + +template +struct Printer< ::sensor_msgs::Joy_ > +{ + template static void stream(Stream& s, const std::string& indent, const ::sensor_msgs::Joy_& v) + { + s << indent << "header: "; + s << std::endl; + Printer< ::std_msgs::Header_ >::stream(s, indent + " ", v.header); + s << indent << "axes[]" << std::endl; + for (size_t i = 0; i < v.axes.size(); ++i) + { + s << indent << " axes[" << i << "]: "; + Printer::stream(s, indent + " ", v.axes[i]); + } + s << indent << "buttons[]" << std::endl; + for (size_t i = 0; i < v.buttons.size(); ++i) + { + s << indent << " buttons[" << i << "]: "; + Printer::stream(s, indent + " ", v.buttons[i]); + } + } +}; + +} // namespace message_operations +} // namespace ros + +#endif // SENSOR_MSGS_MESSAGE_JOY_H diff --git a/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/JoyFeedback.h b/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/JoyFeedback.h new file mode 100644 index 0000000000..249c834df6 --- /dev/null +++ b/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/JoyFeedback.h @@ -0,0 +1,225 @@ +// Generated by gencpp from file sensor_msgs/JoyFeedback.msg +// DO NOT EDIT! + + +#ifndef SENSOR_MSGS_MESSAGE_JOYFEEDBACK_H +#define SENSOR_MSGS_MESSAGE_JOYFEEDBACK_H + + +#include +#include +#include + +#include +#include +#include +#include + + +namespace sensor_msgs +{ +template +struct JoyFeedback_ +{ + typedef JoyFeedback_ Type; + + JoyFeedback_() + : type(0) + , id(0) + , intensity(0.0) { + } + JoyFeedback_(const ContainerAllocator& _alloc) + : type(0) + , id(0) + , intensity(0.0) { + (void)_alloc; + } + + + + typedef uint8_t _type_type; + _type_type type; + + typedef uint8_t _id_type; + _id_type id; + + typedef float _intensity_type; + _intensity_type intensity; + + + enum { TYPE_LED = 0u }; + enum { TYPE_RUMBLE = 1u }; + enum { TYPE_BUZZER = 2u }; + + + typedef boost::shared_ptr< ::sensor_msgs::JoyFeedback_ > Ptr; + typedef boost::shared_ptr< ::sensor_msgs::JoyFeedback_ const> ConstPtr; + +}; // struct JoyFeedback_ + +typedef ::sensor_msgs::JoyFeedback_ > JoyFeedback; + +typedef boost::shared_ptr< ::sensor_msgs::JoyFeedback > JoyFeedbackPtr; +typedef boost::shared_ptr< ::sensor_msgs::JoyFeedback const> JoyFeedbackConstPtr; + +// constants requiring out of line definition + + + + + + + + + +template +std::ostream& operator<<(std::ostream& s, const ::sensor_msgs::JoyFeedback_ & v) +{ +ros::message_operations::Printer< ::sensor_msgs::JoyFeedback_ >::stream(s, "", v); +return s; +} + +} // namespace sensor_msgs + +namespace ros +{ +namespace message_traits +{ + + + +// BOOLTRAITS {'IsFixedSize': True, 'IsMessage': True, 'HasHeader': False} +// {'std_msgs': ['/opt/ros/kinetic/share/std_msgs/cmake/../msg'], 'geometry_msgs': ['/opt/ros/kinetic/share/geometry_msgs/cmake/../msg'], 'sensor_msgs': ['/tmp/binarydeb/ros-kinetic-sensor-msgs-1.12.5/msg']} + +// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types'] + + + + +template +struct IsFixedSize< ::sensor_msgs::JoyFeedback_ > + : TrueType + { }; + +template +struct IsFixedSize< ::sensor_msgs::JoyFeedback_ const> + : TrueType + { }; + +template +struct IsMessage< ::sensor_msgs::JoyFeedback_ > + : TrueType + { }; + +template +struct IsMessage< ::sensor_msgs::JoyFeedback_ const> + : TrueType + { }; + +template +struct HasHeader< ::sensor_msgs::JoyFeedback_ > + : FalseType + { }; + +template +struct HasHeader< ::sensor_msgs::JoyFeedback_ const> + : FalseType + { }; + + +template +struct MD5Sum< ::sensor_msgs::JoyFeedback_ > +{ + static const char* value() + { + return "f4dcd73460360d98f36e55ee7f2e46f1"; + } + + static const char* value(const ::sensor_msgs::JoyFeedback_&) { return value(); } + static const uint64_t static_value1 = 0xf4dcd73460360d98ULL; + static const uint64_t static_value2 = 0xf36e55ee7f2e46f1ULL; +}; + +template +struct DataType< ::sensor_msgs::JoyFeedback_ > +{ + static const char* value() + { + return "sensor_msgs/JoyFeedback"; + } + + static const char* value(const ::sensor_msgs::JoyFeedback_&) { return value(); } +}; + +template +struct Definition< ::sensor_msgs::JoyFeedback_ > +{ + static const char* value() + { + return "# Declare of the type of feedback\n\ +uint8 TYPE_LED = 0\n\ +uint8 TYPE_RUMBLE = 1\n\ +uint8 TYPE_BUZZER = 2\n\ +\n\ +uint8 type\n\ +\n\ +# This will hold an id number for each type of each feedback.\n\ +# Example, the first led would be id=0, the second would be id=1\n\ +uint8 id\n\ +\n\ +# Intensity of the feedback, from 0.0 to 1.0, inclusive. If device is\n\ +# actually binary, driver should treat 0<=x<0.5 as off, 0.5<=x<=1 as on.\n\ +float32 intensity\n\ +\n\ +"; + } + + static const char* value(const ::sensor_msgs::JoyFeedback_&) { return value(); } +}; + +} // namespace message_traits +} // namespace ros + +namespace ros +{ +namespace serialization +{ + + template struct Serializer< ::sensor_msgs::JoyFeedback_ > + { + template inline static void allInOne(Stream& stream, T m) + { + stream.next(m.type); + stream.next(m.id); + stream.next(m.intensity); + } + + ROS_DECLARE_ALLINONE_SERIALIZER; + }; // struct JoyFeedback_ + +} // namespace serialization +} // namespace ros + +namespace ros +{ +namespace message_operations +{ + +template +struct Printer< ::sensor_msgs::JoyFeedback_ > +{ + template static void stream(Stream& s, const std::string& indent, const ::sensor_msgs::JoyFeedback_& v) + { + s << indent << "type: "; + Printer::stream(s, indent + " ", v.type); + s << indent << "id: "; + Printer::stream(s, indent + " ", v.id); + s << indent << "intensity: "; + Printer::stream(s, indent + " ", v.intensity); + } +}; + +} // namespace message_operations +} // namespace ros + +#endif // SENSOR_MSGS_MESSAGE_JOYFEEDBACK_H diff --git a/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/JoyFeedbackArray.h b/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/JoyFeedbackArray.h new file mode 100644 index 0000000000..2b80aa5228 --- /dev/null +++ b/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/JoyFeedbackArray.h @@ -0,0 +1,211 @@ +// Generated by gencpp from file sensor_msgs/JoyFeedbackArray.msg +// DO NOT EDIT! + + +#ifndef SENSOR_MSGS_MESSAGE_JOYFEEDBACKARRAY_H +#define SENSOR_MSGS_MESSAGE_JOYFEEDBACKARRAY_H + + +#include +#include +#include + +#include +#include +#include +#include + +#include + +namespace sensor_msgs +{ +template +struct JoyFeedbackArray_ +{ + typedef JoyFeedbackArray_ Type; + + JoyFeedbackArray_() + : array() { + } + JoyFeedbackArray_(const ContainerAllocator& _alloc) + : array(_alloc) { + (void)_alloc; + } + + + + typedef std::vector< ::sensor_msgs::JoyFeedback_ , typename ContainerAllocator::template rebind< ::sensor_msgs::JoyFeedback_ >::other > _array_type; + _array_type array; + + + + + typedef boost::shared_ptr< ::sensor_msgs::JoyFeedbackArray_ > Ptr; + typedef boost::shared_ptr< ::sensor_msgs::JoyFeedbackArray_ const> ConstPtr; + +}; // struct JoyFeedbackArray_ + +typedef ::sensor_msgs::JoyFeedbackArray_ > JoyFeedbackArray; + +typedef boost::shared_ptr< ::sensor_msgs::JoyFeedbackArray > JoyFeedbackArrayPtr; +typedef boost::shared_ptr< ::sensor_msgs::JoyFeedbackArray const> JoyFeedbackArrayConstPtr; + +// constants requiring out of line definition + + + +template +std::ostream& operator<<(std::ostream& s, const ::sensor_msgs::JoyFeedbackArray_ & v) +{ +ros::message_operations::Printer< ::sensor_msgs::JoyFeedbackArray_ >::stream(s, "", v); +return s; +} + +} // namespace sensor_msgs + +namespace ros +{ +namespace message_traits +{ + + + +// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': False} +// {'std_msgs': ['/opt/ros/kinetic/share/std_msgs/cmake/../msg'], 'geometry_msgs': ['/opt/ros/kinetic/share/geometry_msgs/cmake/../msg'], 'sensor_msgs': ['/tmp/binarydeb/ros-kinetic-sensor-msgs-1.12.5/msg']} + +// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types'] + + + + +template +struct IsFixedSize< ::sensor_msgs::JoyFeedbackArray_ > + : FalseType + { }; + +template +struct IsFixedSize< ::sensor_msgs::JoyFeedbackArray_ const> + : FalseType + { }; + +template +struct IsMessage< ::sensor_msgs::JoyFeedbackArray_ > + : TrueType + { }; + +template +struct IsMessage< ::sensor_msgs::JoyFeedbackArray_ const> + : TrueType + { }; + +template +struct HasHeader< ::sensor_msgs::JoyFeedbackArray_ > + : FalseType + { }; + +template +struct HasHeader< ::sensor_msgs::JoyFeedbackArray_ const> + : FalseType + { }; + + +template +struct MD5Sum< ::sensor_msgs::JoyFeedbackArray_ > +{ + static const char* value() + { + return "cde5730a895b1fc4dee6f91b754b213d"; + } + + static const char* value(const ::sensor_msgs::JoyFeedbackArray_&) { return value(); } + static const uint64_t static_value1 = 0xcde5730a895b1fc4ULL; + static const uint64_t static_value2 = 0xdee6f91b754b213dULL; +}; + +template +struct DataType< ::sensor_msgs::JoyFeedbackArray_ > +{ + static const char* value() + { + return "sensor_msgs/JoyFeedbackArray"; + } + + static const char* value(const ::sensor_msgs::JoyFeedbackArray_&) { return value(); } +}; + +template +struct Definition< ::sensor_msgs::JoyFeedbackArray_ > +{ + static const char* value() + { + return "# This message publishes values for multiple feedback at once. \n\ +JoyFeedback[] array\n\ +================================================================================\n\ +MSG: sensor_msgs/JoyFeedback\n\ +# Declare of the type of feedback\n\ +uint8 TYPE_LED = 0\n\ +uint8 TYPE_RUMBLE = 1\n\ +uint8 TYPE_BUZZER = 2\n\ +\n\ +uint8 type\n\ +\n\ +# This will hold an id number for each type of each feedback.\n\ +# Example, the first led would be id=0, the second would be id=1\n\ +uint8 id\n\ +\n\ +# Intensity of the feedback, from 0.0 to 1.0, inclusive. If device is\n\ +# actually binary, driver should treat 0<=x<0.5 as off, 0.5<=x<=1 as on.\n\ +float32 intensity\n\ +\n\ +"; + } + + static const char* value(const ::sensor_msgs::JoyFeedbackArray_&) { return value(); } +}; + +} // namespace message_traits +} // namespace ros + +namespace ros +{ +namespace serialization +{ + + template struct Serializer< ::sensor_msgs::JoyFeedbackArray_ > + { + template inline static void allInOne(Stream& stream, T m) + { + stream.next(m.array); + } + + ROS_DECLARE_ALLINONE_SERIALIZER; + }; // struct JoyFeedbackArray_ + +} // namespace serialization +} // namespace ros + +namespace ros +{ +namespace message_operations +{ + +template +struct Printer< ::sensor_msgs::JoyFeedbackArray_ > +{ + template static void stream(Stream& s, const std::string& indent, const ::sensor_msgs::JoyFeedbackArray_& v) + { + s << indent << "array[]" << std::endl; + for (size_t i = 0; i < v.array.size(); ++i) + { + s << indent << " array[" << i << "]: "; + s << std::endl; + s << indent; + Printer< ::sensor_msgs::JoyFeedback_ >::stream(s, indent + " ", v.array[i]); + } + } +}; + +} // namespace message_operations +} // namespace ros + +#endif // SENSOR_MSGS_MESSAGE_JOYFEEDBACKARRAY_H diff --git a/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/LaserEcho.h b/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/LaserEcho.h new file mode 100644 index 0000000000..874b1b7d0e --- /dev/null +++ b/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/LaserEcho.h @@ -0,0 +1,194 @@ +// Generated by gencpp from file sensor_msgs/LaserEcho.msg +// DO NOT EDIT! + + +#ifndef SENSOR_MSGS_MESSAGE_LASERECHO_H +#define SENSOR_MSGS_MESSAGE_LASERECHO_H + + +#include +#include +#include + +#include +#include +#include +#include + + +namespace sensor_msgs +{ +template +struct LaserEcho_ +{ + typedef LaserEcho_ Type; + + LaserEcho_() + : echoes() { + } + LaserEcho_(const ContainerAllocator& _alloc) + : echoes(_alloc) { + (void)_alloc; + } + + + + typedef std::vector::other > _echoes_type; + _echoes_type echoes; + + + + + typedef boost::shared_ptr< ::sensor_msgs::LaserEcho_ > Ptr; + typedef boost::shared_ptr< ::sensor_msgs::LaserEcho_ const> ConstPtr; + +}; // struct LaserEcho_ + +typedef ::sensor_msgs::LaserEcho_ > LaserEcho; + +typedef boost::shared_ptr< ::sensor_msgs::LaserEcho > LaserEchoPtr; +typedef boost::shared_ptr< ::sensor_msgs::LaserEcho const> LaserEchoConstPtr; + +// constants requiring out of line definition + + + +template +std::ostream& operator<<(std::ostream& s, const ::sensor_msgs::LaserEcho_ & v) +{ +ros::message_operations::Printer< ::sensor_msgs::LaserEcho_ >::stream(s, "", v); +return s; +} + +} // namespace sensor_msgs + +namespace ros +{ +namespace message_traits +{ + + + +// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': False} +// {'std_msgs': ['/opt/ros/kinetic/share/std_msgs/cmake/../msg'], 'geometry_msgs': ['/opt/ros/kinetic/share/geometry_msgs/cmake/../msg'], 'sensor_msgs': ['/tmp/binarydeb/ros-kinetic-sensor-msgs-1.12.5/msg']} + +// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types'] + + + + +template +struct IsFixedSize< ::sensor_msgs::LaserEcho_ > + : FalseType + { }; + +template +struct IsFixedSize< ::sensor_msgs::LaserEcho_ const> + : FalseType + { }; + +template +struct IsMessage< ::sensor_msgs::LaserEcho_ > + : TrueType + { }; + +template +struct IsMessage< ::sensor_msgs::LaserEcho_ const> + : TrueType + { }; + +template +struct HasHeader< ::sensor_msgs::LaserEcho_ > + : FalseType + { }; + +template +struct HasHeader< ::sensor_msgs::LaserEcho_ const> + : FalseType + { }; + + +template +struct MD5Sum< ::sensor_msgs::LaserEcho_ > +{ + static const char* value() + { + return "8bc5ae449b200fba4d552b4225586696"; + } + + static const char* value(const ::sensor_msgs::LaserEcho_&) { return value(); } + static const uint64_t static_value1 = 0x8bc5ae449b200fbaULL; + static const uint64_t static_value2 = 0x4d552b4225586696ULL; +}; + +template +struct DataType< ::sensor_msgs::LaserEcho_ > +{ + static const char* value() + { + return "sensor_msgs/LaserEcho"; + } + + static const char* value(const ::sensor_msgs::LaserEcho_&) { return value(); } +}; + +template +struct Definition< ::sensor_msgs::LaserEcho_ > +{ + static const char* value() + { + return "# This message is a submessage of MultiEchoLaserScan and is not intended\n\ +# to be used separately.\n\ +\n\ +float32[] echoes # Multiple values of ranges or intensities.\n\ + # Each array represents data from the same angle increment.\n\ +"; + } + + static const char* value(const ::sensor_msgs::LaserEcho_&) { return value(); } +}; + +} // namespace message_traits +} // namespace ros + +namespace ros +{ +namespace serialization +{ + + template struct Serializer< ::sensor_msgs::LaserEcho_ > + { + template inline static void allInOne(Stream& stream, T m) + { + stream.next(m.echoes); + } + + ROS_DECLARE_ALLINONE_SERIALIZER; + }; // struct LaserEcho_ + +} // namespace serialization +} // namespace ros + +namespace ros +{ +namespace message_operations +{ + +template +struct Printer< ::sensor_msgs::LaserEcho_ > +{ + template static void stream(Stream& s, const std::string& indent, const ::sensor_msgs::LaserEcho_& v) + { + s << indent << "echoes[]" << std::endl; + for (size_t i = 0; i < v.echoes.size(); ++i) + { + s << indent << " echoes[" << i << "]: "; + Printer::stream(s, indent + " ", v.echoes[i]); + } + } +}; + +} // namespace message_operations +} // namespace ros + +#endif // SENSOR_MSGS_MESSAGE_LASERECHO_H diff --git a/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/LaserScan.h b/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/LaserScan.h new file mode 100644 index 0000000000..b1ee786f3f --- /dev/null +++ b/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/LaserScan.h @@ -0,0 +1,314 @@ +// Generated by gencpp from file sensor_msgs/LaserScan.msg +// DO NOT EDIT! + + +#ifndef SENSOR_MSGS_MESSAGE_LASERSCAN_H +#define SENSOR_MSGS_MESSAGE_LASERSCAN_H + + +#include +#include +#include + +#include +#include +#include +#include + +#include + +namespace sensor_msgs +{ +template +struct LaserScan_ +{ + typedef LaserScan_ Type; + + LaserScan_() + : header() + , angle_min(0.0) + , angle_max(0.0) + , angle_increment(0.0) + , time_increment(0.0) + , scan_time(0.0) + , range_min(0.0) + , range_max(0.0) + , ranges() + , intensities() { + } + LaserScan_(const ContainerAllocator& _alloc) + : header(_alloc) + , angle_min(0.0) + , angle_max(0.0) + , angle_increment(0.0) + , time_increment(0.0) + , scan_time(0.0) + , range_min(0.0) + , range_max(0.0) + , ranges(_alloc) + , intensities(_alloc) { + (void)_alloc; + } + + + + typedef ::std_msgs::Header_ _header_type; + _header_type header; + + typedef float _angle_min_type; + _angle_min_type angle_min; + + typedef float _angle_max_type; + _angle_max_type angle_max; + + typedef float _angle_increment_type; + _angle_increment_type angle_increment; + + typedef float _time_increment_type; + _time_increment_type time_increment; + + typedef float _scan_time_type; + _scan_time_type scan_time; + + typedef float _range_min_type; + _range_min_type range_min; + + typedef float _range_max_type; + _range_max_type range_max; + + typedef std::vector::other > _ranges_type; + _ranges_type ranges; + + typedef std::vector::other > _intensities_type; + _intensities_type intensities; + + + + + typedef boost::shared_ptr< ::sensor_msgs::LaserScan_ > Ptr; + typedef boost::shared_ptr< ::sensor_msgs::LaserScan_ const> ConstPtr; + +}; // struct LaserScan_ + +typedef ::sensor_msgs::LaserScan_ > LaserScan; + +typedef boost::shared_ptr< ::sensor_msgs::LaserScan > LaserScanPtr; +typedef boost::shared_ptr< ::sensor_msgs::LaserScan const> LaserScanConstPtr; + +// constants requiring out of line definition + + + +template +std::ostream& operator<<(std::ostream& s, const ::sensor_msgs::LaserScan_ & v) +{ +ros::message_operations::Printer< ::sensor_msgs::LaserScan_ >::stream(s, "", v); +return s; +} + +} // namespace sensor_msgs + +namespace ros +{ +namespace message_traits +{ + + + +// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': True} +// {'std_msgs': ['/opt/ros/kinetic/share/std_msgs/cmake/../msg'], 'geometry_msgs': ['/opt/ros/kinetic/share/geometry_msgs/cmake/../msg'], 'sensor_msgs': ['/tmp/binarydeb/ros-kinetic-sensor-msgs-1.12.5/msg']} + +// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types'] + + + + +template +struct IsFixedSize< ::sensor_msgs::LaserScan_ > + : FalseType + { }; + +template +struct IsFixedSize< ::sensor_msgs::LaserScan_ const> + : FalseType + { }; + +template +struct IsMessage< ::sensor_msgs::LaserScan_ > + : TrueType + { }; + +template +struct IsMessage< ::sensor_msgs::LaserScan_ const> + : TrueType + { }; + +template +struct HasHeader< ::sensor_msgs::LaserScan_ > + : TrueType + { }; + +template +struct HasHeader< ::sensor_msgs::LaserScan_ const> + : TrueType + { }; + + +template +struct MD5Sum< ::sensor_msgs::LaserScan_ > +{ + static const char* value() + { + return "90c7ef2dc6895d81024acba2ac42f369"; + } + + static const char* value(const ::sensor_msgs::LaserScan_&) { return value(); } + static const uint64_t static_value1 = 0x90c7ef2dc6895d81ULL; + static const uint64_t static_value2 = 0x024acba2ac42f369ULL; +}; + +template +struct DataType< ::sensor_msgs::LaserScan_ > +{ + static const char* value() + { + return "sensor_msgs/LaserScan"; + } + + static const char* value(const ::sensor_msgs::LaserScan_&) { return value(); } +}; + +template +struct Definition< ::sensor_msgs::LaserScan_ > +{ + static const char* value() + { + return "# Single scan from a planar laser range-finder\n\ +#\n\ +# If you have another ranging device with different behavior (e.g. a sonar\n\ +# array), please find or create a different message, since applications\n\ +# will make fairly laser-specific assumptions about this data\n\ +\n\ +Header header # timestamp in the header is the acquisition time of \n\ + # the first ray in the scan.\n\ + #\n\ + # in frame frame_id, angles are measured around \n\ + # the positive Z axis (counterclockwise, if Z is up)\n\ + # with zero angle being forward along the x axis\n\ + \n\ +float32 angle_min # start angle of the scan [rad]\n\ +float32 angle_max # end angle of the scan [rad]\n\ +float32 angle_increment # angular distance between measurements [rad]\n\ +\n\ +float32 time_increment # time between measurements [seconds] - if your scanner\n\ + # is moving, this will be used in interpolating position\n\ + # of 3d points\n\ +float32 scan_time # time between scans [seconds]\n\ +\n\ +float32 range_min # minimum range value [m]\n\ +float32 range_max # maximum range value [m]\n\ +\n\ +float32[] ranges # range data [m] (Note: values < range_min or > range_max should be discarded)\n\ +float32[] intensities # intensity data [device-specific units]. If your\n\ + # device does not provide intensities, please leave\n\ + # the array empty.\n\ +\n\ +================================================================================\n\ +MSG: std_msgs/Header\n\ +# Standard metadata for higher-level stamped data types.\n\ +# This is generally used to communicate timestamped data \n\ +# in a particular coordinate frame.\n\ +# \n\ +# sequence ID: consecutively increasing ID \n\ +uint32 seq\n\ +#Two-integer timestamp that is expressed as:\n\ +# * stamp.sec: seconds (stamp_secs) since epoch (in Python the variable is called 'secs')\n\ +# * stamp.nsec: nanoseconds since stamp_secs (in Python the variable is called 'nsecs')\n\ +# time-handling sugar is provided by the client library\n\ +time stamp\n\ +#Frame this data is associated with\n\ +# 0: no frame\n\ +# 1: global frame\n\ +string frame_id\n\ +"; + } + + static const char* value(const ::sensor_msgs::LaserScan_&) { return value(); } +}; + +} // namespace message_traits +} // namespace ros + +namespace ros +{ +namespace serialization +{ + + template struct Serializer< ::sensor_msgs::LaserScan_ > + { + template inline static void allInOne(Stream& stream, T m) + { + stream.next(m.header); + stream.next(m.angle_min); + stream.next(m.angle_max); + stream.next(m.angle_increment); + stream.next(m.time_increment); + stream.next(m.scan_time); + stream.next(m.range_min); + stream.next(m.range_max); + stream.next(m.ranges); + stream.next(m.intensities); + } + + ROS_DECLARE_ALLINONE_SERIALIZER; + }; // struct LaserScan_ + +} // namespace serialization +} // namespace ros + +namespace ros +{ +namespace message_operations +{ + +template +struct Printer< ::sensor_msgs::LaserScan_ > +{ + template static void stream(Stream& s, const std::string& indent, const ::sensor_msgs::LaserScan_& v) + { + s << indent << "header: "; + s << std::endl; + Printer< ::std_msgs::Header_ >::stream(s, indent + " ", v.header); + s << indent << "angle_min: "; + Printer::stream(s, indent + " ", v.angle_min); + s << indent << "angle_max: "; + Printer::stream(s, indent + " ", v.angle_max); + s << indent << "angle_increment: "; + Printer::stream(s, indent + " ", v.angle_increment); + s << indent << "time_increment: "; + Printer::stream(s, indent + " ", v.time_increment); + s << indent << "scan_time: "; + Printer::stream(s, indent + " ", v.scan_time); + s << indent << "range_min: "; + Printer::stream(s, indent + " ", v.range_min); + s << indent << "range_max: "; + Printer::stream(s, indent + " ", v.range_max); + s << indent << "ranges[]" << std::endl; + for (size_t i = 0; i < v.ranges.size(); ++i) + { + s << indent << " ranges[" << i << "]: "; + Printer::stream(s, indent + " ", v.ranges[i]); + } + s << indent << "intensities[]" << std::endl; + for (size_t i = 0; i < v.intensities.size(); ++i) + { + s << indent << " intensities[" << i << "]: "; + Printer::stream(s, indent + " ", v.intensities[i]); + } + } +}; + +} // namespace message_operations +} // namespace ros + +#endif // SENSOR_MSGS_MESSAGE_LASERSCAN_H diff --git a/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/MagneticField.h b/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/MagneticField.h new file mode 100644 index 0000000000..b9dc26c89f --- /dev/null +++ b/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/MagneticField.h @@ -0,0 +1,263 @@ +// Generated by gencpp from file sensor_msgs/MagneticField.msg +// DO NOT EDIT! + + +#ifndef SENSOR_MSGS_MESSAGE_MAGNETICFIELD_H +#define SENSOR_MSGS_MESSAGE_MAGNETICFIELD_H + + +#include +#include +#include + +#include +#include +#include +#include + +#include +#include + +namespace sensor_msgs +{ +template +struct MagneticField_ +{ + typedef MagneticField_ Type; + + MagneticField_() + : header() + , magnetic_field() + , magnetic_field_covariance() { + magnetic_field_covariance.assign(0.0); + } + MagneticField_(const ContainerAllocator& _alloc) + : header(_alloc) + , magnetic_field(_alloc) + , magnetic_field_covariance() { + (void)_alloc; + magnetic_field_covariance.assign(0.0); + } + + + + typedef ::std_msgs::Header_ _header_type; + _header_type header; + + typedef ::geometry_msgs::Vector3_ _magnetic_field_type; + _magnetic_field_type magnetic_field; + + typedef boost::array _magnetic_field_covariance_type; + _magnetic_field_covariance_type magnetic_field_covariance; + + + + + typedef boost::shared_ptr< ::sensor_msgs::MagneticField_ > Ptr; + typedef boost::shared_ptr< ::sensor_msgs::MagneticField_ const> ConstPtr; + +}; // struct MagneticField_ + +typedef ::sensor_msgs::MagneticField_ > MagneticField; + +typedef boost::shared_ptr< ::sensor_msgs::MagneticField > MagneticFieldPtr; +typedef boost::shared_ptr< ::sensor_msgs::MagneticField const> MagneticFieldConstPtr; + +// constants requiring out of line definition + + + +template +std::ostream& operator<<(std::ostream& s, const ::sensor_msgs::MagneticField_ & v) +{ +ros::message_operations::Printer< ::sensor_msgs::MagneticField_ >::stream(s, "", v); +return s; +} + +} // namespace sensor_msgs + +namespace ros +{ +namespace message_traits +{ + + + +// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': True} +// {'std_msgs': ['/opt/ros/kinetic/share/std_msgs/cmake/../msg'], 'geometry_msgs': ['/opt/ros/kinetic/share/geometry_msgs/cmake/../msg'], 'sensor_msgs': ['/tmp/binarydeb/ros-kinetic-sensor-msgs-1.12.5/msg']} + +// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types'] + + + + +template +struct IsFixedSize< ::sensor_msgs::MagneticField_ > + : FalseType + { }; + +template +struct IsFixedSize< ::sensor_msgs::MagneticField_ const> + : FalseType + { }; + +template +struct IsMessage< ::sensor_msgs::MagneticField_ > + : TrueType + { }; + +template +struct IsMessage< ::sensor_msgs::MagneticField_ const> + : TrueType + { }; + +template +struct HasHeader< ::sensor_msgs::MagneticField_ > + : TrueType + { }; + +template +struct HasHeader< ::sensor_msgs::MagneticField_ const> + : TrueType + { }; + + +template +struct MD5Sum< ::sensor_msgs::MagneticField_ > +{ + static const char* value() + { + return "2f3b0b43eed0c9501de0fa3ff89a45aa"; + } + + static const char* value(const ::sensor_msgs::MagneticField_&) { return value(); } + static const uint64_t static_value1 = 0x2f3b0b43eed0c950ULL; + static const uint64_t static_value2 = 0x1de0fa3ff89a45aaULL; +}; + +template +struct DataType< ::sensor_msgs::MagneticField_ > +{ + static const char* value() + { + return "sensor_msgs/MagneticField"; + } + + static const char* value(const ::sensor_msgs::MagneticField_&) { return value(); } +}; + +template +struct Definition< ::sensor_msgs::MagneticField_ > +{ + static const char* value() + { + return " # Measurement of the Magnetic Field vector at a specific location.\n\ +\n\ + # If the covariance of the measurement is known, it should be filled in\n\ + # (if all you know is the variance of each measurement, e.g. from the datasheet,\n\ + #just put those along the diagonal)\n\ + # A covariance matrix of all zeros will be interpreted as \"covariance unknown\",\n\ + # and to use the data a covariance will have to be assumed or gotten from some\n\ + # other source\n\ +\n\ +\n\ + Header header # timestamp is the time the\n\ + # field was measured\n\ + # frame_id is the location and orientation\n\ + # of the field measurement\n\ +\n\ + geometry_msgs/Vector3 magnetic_field # x, y, and z components of the\n\ + # field vector in Tesla\n\ + # If your sensor does not output 3 axes,\n\ + # put NaNs in the components not reported.\n\ +\n\ + float64[9] magnetic_field_covariance # Row major about x, y, z axes\n\ + # 0 is interpreted as variance unknown\n\ +================================================================================\n\ +MSG: std_msgs/Header\n\ +# Standard metadata for higher-level stamped data types.\n\ +# This is generally used to communicate timestamped data \n\ +# in a particular coordinate frame.\n\ +# \n\ +# sequence ID: consecutively increasing ID \n\ +uint32 seq\n\ +#Two-integer timestamp that is expressed as:\n\ +# * stamp.sec: seconds (stamp_secs) since epoch (in Python the variable is called 'secs')\n\ +# * stamp.nsec: nanoseconds since stamp_secs (in Python the variable is called 'nsecs')\n\ +# time-handling sugar is provided by the client library\n\ +time stamp\n\ +#Frame this data is associated with\n\ +# 0: no frame\n\ +# 1: global frame\n\ +string frame_id\n\ +\n\ +================================================================================\n\ +MSG: geometry_msgs/Vector3\n\ +# This represents a vector in free space. \n\ +# It is only meant to represent a direction. Therefore, it does not\n\ +# make sense to apply a translation to it (e.g., when applying a \n\ +# generic rigid transformation to a Vector3, tf2 will only apply the\n\ +# rotation). If you want your data to be translatable too, use the\n\ +# geometry_msgs/Point message instead.\n\ +\n\ +float64 x\n\ +float64 y\n\ +float64 z\n\ +"; + } + + static const char* value(const ::sensor_msgs::MagneticField_&) { return value(); } +}; + +} // namespace message_traits +} // namespace ros + +namespace ros +{ +namespace serialization +{ + + template struct Serializer< ::sensor_msgs::MagneticField_ > + { + template inline static void allInOne(Stream& stream, T m) + { + stream.next(m.header); + stream.next(m.magnetic_field); + stream.next(m.magnetic_field_covariance); + } + + ROS_DECLARE_ALLINONE_SERIALIZER; + }; // struct MagneticField_ + +} // namespace serialization +} // namespace ros + +namespace ros +{ +namespace message_operations +{ + +template +struct Printer< ::sensor_msgs::MagneticField_ > +{ + template static void stream(Stream& s, const std::string& indent, const ::sensor_msgs::MagneticField_& v) + { + s << indent << "header: "; + s << std::endl; + Printer< ::std_msgs::Header_ >::stream(s, indent + " ", v.header); + s << indent << "magnetic_field: "; + s << std::endl; + Printer< ::geometry_msgs::Vector3_ >::stream(s, indent + " ", v.magnetic_field); + s << indent << "magnetic_field_covariance[]" << std::endl; + for (size_t i = 0; i < v.magnetic_field_covariance.size(); ++i) + { + s << indent << " magnetic_field_covariance[" << i << "]: "; + Printer::stream(s, indent + " ", v.magnetic_field_covariance[i]); + } + } +}; + +} // namespace message_operations +} // namespace ros + +#endif // SENSOR_MSGS_MESSAGE_MAGNETICFIELD_H diff --git a/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/MultiDOFJointState.h b/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/MultiDOFJointState.h new file mode 100644 index 0000000000..5bc9cb7c00 --- /dev/null +++ b/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/MultiDOFJointState.h @@ -0,0 +1,329 @@ +// Generated by gencpp from file sensor_msgs/MultiDOFJointState.msg +// DO NOT EDIT! + + +#ifndef SENSOR_MSGS_MESSAGE_MULTIDOFJOINTSTATE_H +#define SENSOR_MSGS_MESSAGE_MULTIDOFJOINTSTATE_H + + +#include +#include +#include + +#include +#include +#include +#include + +#include +#include +#include +#include + +namespace sensor_msgs +{ +template +struct MultiDOFJointState_ +{ + typedef MultiDOFJointState_ Type; + + MultiDOFJointState_() + : header() + , joint_names() + , transforms() + , twist() + , wrench() { + } + MultiDOFJointState_(const ContainerAllocator& _alloc) + : header(_alloc) + , joint_names(_alloc) + , transforms(_alloc) + , twist(_alloc) + , wrench(_alloc) { + (void)_alloc; + } + + + + typedef ::std_msgs::Header_ _header_type; + _header_type header; + + typedef std::vector, typename ContainerAllocator::template rebind::other > , typename ContainerAllocator::template rebind, typename ContainerAllocator::template rebind::other > >::other > _joint_names_type; + _joint_names_type joint_names; + + typedef std::vector< ::geometry_msgs::Transform_ , typename ContainerAllocator::template rebind< ::geometry_msgs::Transform_ >::other > _transforms_type; + _transforms_type transforms; + + typedef std::vector< ::geometry_msgs::Twist_ , typename ContainerAllocator::template rebind< ::geometry_msgs::Twist_ >::other > _twist_type; + _twist_type twist; + + typedef std::vector< ::geometry_msgs::Wrench_ , typename ContainerAllocator::template rebind< ::geometry_msgs::Wrench_ >::other > _wrench_type; + _wrench_type wrench; + + + + + typedef boost::shared_ptr< ::sensor_msgs::MultiDOFJointState_ > Ptr; + typedef boost::shared_ptr< ::sensor_msgs::MultiDOFJointState_ const> ConstPtr; + +}; // struct MultiDOFJointState_ + +typedef ::sensor_msgs::MultiDOFJointState_ > MultiDOFJointState; + +typedef boost::shared_ptr< ::sensor_msgs::MultiDOFJointState > MultiDOFJointStatePtr; +typedef boost::shared_ptr< ::sensor_msgs::MultiDOFJointState const> MultiDOFJointStateConstPtr; + +// constants requiring out of line definition + + + +template +std::ostream& operator<<(std::ostream& s, const ::sensor_msgs::MultiDOFJointState_ & v) +{ +ros::message_operations::Printer< ::sensor_msgs::MultiDOFJointState_ >::stream(s, "", v); +return s; +} + +} // namespace sensor_msgs + +namespace ros +{ +namespace message_traits +{ + + + +// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': True} +// {'std_msgs': ['/opt/ros/kinetic/share/std_msgs/cmake/../msg'], 'geometry_msgs': ['/opt/ros/kinetic/share/geometry_msgs/cmake/../msg'], 'sensor_msgs': ['/tmp/binarydeb/ros-kinetic-sensor-msgs-1.12.5/msg']} + +// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types'] + + + + +template +struct IsFixedSize< ::sensor_msgs::MultiDOFJointState_ > + : FalseType + { }; + +template +struct IsFixedSize< ::sensor_msgs::MultiDOFJointState_ const> + : FalseType + { }; + +template +struct IsMessage< ::sensor_msgs::MultiDOFJointState_ > + : TrueType + { }; + +template +struct IsMessage< ::sensor_msgs::MultiDOFJointState_ const> + : TrueType + { }; + +template +struct HasHeader< ::sensor_msgs::MultiDOFJointState_ > + : TrueType + { }; + +template +struct HasHeader< ::sensor_msgs::MultiDOFJointState_ const> + : TrueType + { }; + + +template +struct MD5Sum< ::sensor_msgs::MultiDOFJointState_ > +{ + static const char* value() + { + return "690f272f0640d2631c305eeb8301e59d"; + } + + static const char* value(const ::sensor_msgs::MultiDOFJointState_&) { return value(); } + static const uint64_t static_value1 = 0x690f272f0640d263ULL; + static const uint64_t static_value2 = 0x1c305eeb8301e59dULL; +}; + +template +struct DataType< ::sensor_msgs::MultiDOFJointState_ > +{ + static const char* value() + { + return "sensor_msgs/MultiDOFJointState"; + } + + static const char* value(const ::sensor_msgs::MultiDOFJointState_&) { return value(); } +}; + +template +struct Definition< ::sensor_msgs::MultiDOFJointState_ > +{ + static const char* value() + { + return "# Representation of state for joints with multiple degrees of freedom, \n\ +# following the structure of JointState.\n\ +#\n\ +# It is assumed that a joint in a system corresponds to a transform that gets applied \n\ +# along the kinematic chain. For example, a planar joint (as in URDF) is 3DOF (x, y, yaw)\n\ +# and those 3DOF can be expressed as a transformation matrix, and that transformation\n\ +# matrix can be converted back to (x, y, yaw)\n\ +#\n\ +# Each joint is uniquely identified by its name\n\ +# The header specifies the time at which the joint states were recorded. All the joint states\n\ +# in one message have to be recorded at the same time.\n\ +#\n\ +# This message consists of a multiple arrays, one for each part of the joint state. \n\ +# The goal is to make each of the fields optional. When e.g. your joints have no\n\ +# wrench associated with them, you can leave the wrench array empty. \n\ +#\n\ +# All arrays in this message should have the same size, or be empty.\n\ +# This is the only way to uniquely associate the joint name with the correct\n\ +# states.\n\ +\n\ +Header header\n\ +\n\ +string[] joint_names\n\ +geometry_msgs/Transform[] transforms\n\ +geometry_msgs/Twist[] twist\n\ +geometry_msgs/Wrench[] wrench\n\ +\n\ +================================================================================\n\ +MSG: std_msgs/Header\n\ +# Standard metadata for higher-level stamped data types.\n\ +# This is generally used to communicate timestamped data \n\ +# in a particular coordinate frame.\n\ +# \n\ +# sequence ID: consecutively increasing ID \n\ +uint32 seq\n\ +#Two-integer timestamp that is expressed as:\n\ +# * stamp.sec: seconds (stamp_secs) since epoch (in Python the variable is called 'secs')\n\ +# * stamp.nsec: nanoseconds since stamp_secs (in Python the variable is called 'nsecs')\n\ +# time-handling sugar is provided by the client library\n\ +time stamp\n\ +#Frame this data is associated with\n\ +# 0: no frame\n\ +# 1: global frame\n\ +string frame_id\n\ +\n\ +================================================================================\n\ +MSG: geometry_msgs/Transform\n\ +# This represents the transform between two coordinate frames in free space.\n\ +\n\ +Vector3 translation\n\ +Quaternion rotation\n\ +\n\ +================================================================================\n\ +MSG: geometry_msgs/Vector3\n\ +# This represents a vector in free space. \n\ +# It is only meant to represent a direction. Therefore, it does not\n\ +# make sense to apply a translation to it (e.g., when applying a \n\ +# generic rigid transformation to a Vector3, tf2 will only apply the\n\ +# rotation). If you want your data to be translatable too, use the\n\ +# geometry_msgs/Point message instead.\n\ +\n\ +float64 x\n\ +float64 y\n\ +float64 z\n\ +================================================================================\n\ +MSG: geometry_msgs/Quaternion\n\ +# This represents an orientation in free space in quaternion form.\n\ +\n\ +float64 x\n\ +float64 y\n\ +float64 z\n\ +float64 w\n\ +\n\ +================================================================================\n\ +MSG: geometry_msgs/Twist\n\ +# This expresses velocity in free space broken into its linear and angular parts.\n\ +Vector3 linear\n\ +Vector3 angular\n\ +\n\ +================================================================================\n\ +MSG: geometry_msgs/Wrench\n\ +# This represents force in free space, separated into\n\ +# its linear and angular parts.\n\ +Vector3 force\n\ +Vector3 torque\n\ +"; + } + + static const char* value(const ::sensor_msgs::MultiDOFJointState_&) { return value(); } +}; + +} // namespace message_traits +} // namespace ros + +namespace ros +{ +namespace serialization +{ + + template struct Serializer< ::sensor_msgs::MultiDOFJointState_ > + { + template inline static void allInOne(Stream& stream, T m) + { + stream.next(m.header); + stream.next(m.joint_names); + stream.next(m.transforms); + stream.next(m.twist); + stream.next(m.wrench); + } + + ROS_DECLARE_ALLINONE_SERIALIZER; + }; // struct MultiDOFJointState_ + +} // namespace serialization +} // namespace ros + +namespace ros +{ +namespace message_operations +{ + +template +struct Printer< ::sensor_msgs::MultiDOFJointState_ > +{ + template static void stream(Stream& s, const std::string& indent, const ::sensor_msgs::MultiDOFJointState_& v) + { + s << indent << "header: "; + s << std::endl; + Printer< ::std_msgs::Header_ >::stream(s, indent + " ", v.header); + s << indent << "joint_names[]" << std::endl; + for (size_t i = 0; i < v.joint_names.size(); ++i) + { + s << indent << " joint_names[" << i << "]: "; + Printer, typename ContainerAllocator::template rebind::other > >::stream(s, indent + " ", v.joint_names[i]); + } + s << indent << "transforms[]" << std::endl; + for (size_t i = 0; i < v.transforms.size(); ++i) + { + s << indent << " transforms[" << i << "]: "; + s << std::endl; + s << indent; + Printer< ::geometry_msgs::Transform_ >::stream(s, indent + " ", v.transforms[i]); + } + s << indent << "twist[]" << std::endl; + for (size_t i = 0; i < v.twist.size(); ++i) + { + s << indent << " twist[" << i << "]: "; + s << std::endl; + s << indent; + Printer< ::geometry_msgs::Twist_ >::stream(s, indent + " ", v.twist[i]); + } + s << indent << "wrench[]" << std::endl; + for (size_t i = 0; i < v.wrench.size(); ++i) + { + s << indent << " wrench[" << i << "]: "; + s << std::endl; + s << indent; + Printer< ::geometry_msgs::Wrench_ >::stream(s, indent + " ", v.wrench[i]); + } + } +}; + +} // namespace message_operations +} // namespace ros + +#endif // SENSOR_MSGS_MESSAGE_MULTIDOFJOINTSTATE_H diff --git a/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/MultiEchoLaserScan.h b/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/MultiEchoLaserScan.h new file mode 100644 index 0000000000..4f946233ef --- /dev/null +++ b/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/MultiEchoLaserScan.h @@ -0,0 +1,329 @@ +// Generated by gencpp from file sensor_msgs/MultiEchoLaserScan.msg +// DO NOT EDIT! + + +#ifndef SENSOR_MSGS_MESSAGE_MULTIECHOLASERSCAN_H +#define SENSOR_MSGS_MESSAGE_MULTIECHOLASERSCAN_H + + +#include +#include +#include + +#include +#include +#include +#include + +#include +#include +#include + +namespace sensor_msgs +{ +template +struct MultiEchoLaserScan_ +{ + typedef MultiEchoLaserScan_ Type; + + MultiEchoLaserScan_() + : header() + , angle_min(0.0) + , angle_max(0.0) + , angle_increment(0.0) + , time_increment(0.0) + , scan_time(0.0) + , range_min(0.0) + , range_max(0.0) + , ranges() + , intensities() { + } + MultiEchoLaserScan_(const ContainerAllocator& _alloc) + : header(_alloc) + , angle_min(0.0) + , angle_max(0.0) + , angle_increment(0.0) + , time_increment(0.0) + , scan_time(0.0) + , range_min(0.0) + , range_max(0.0) + , ranges(_alloc) + , intensities(_alloc) { + (void)_alloc; + } + + + + typedef ::std_msgs::Header_ _header_type; + _header_type header; + + typedef float _angle_min_type; + _angle_min_type angle_min; + + typedef float _angle_max_type; + _angle_max_type angle_max; + + typedef float _angle_increment_type; + _angle_increment_type angle_increment; + + typedef float _time_increment_type; + _time_increment_type time_increment; + + typedef float _scan_time_type; + _scan_time_type scan_time; + + typedef float _range_min_type; + _range_min_type range_min; + + typedef float _range_max_type; + _range_max_type range_max; + + typedef std::vector< ::sensor_msgs::LaserEcho_ , typename ContainerAllocator::template rebind< ::sensor_msgs::LaserEcho_ >::other > _ranges_type; + _ranges_type ranges; + + typedef std::vector< ::sensor_msgs::LaserEcho_ , typename ContainerAllocator::template rebind< ::sensor_msgs::LaserEcho_ >::other > _intensities_type; + _intensities_type intensities; + + + + + typedef boost::shared_ptr< ::sensor_msgs::MultiEchoLaserScan_ > Ptr; + typedef boost::shared_ptr< ::sensor_msgs::MultiEchoLaserScan_ const> ConstPtr; + +}; // struct MultiEchoLaserScan_ + +typedef ::sensor_msgs::MultiEchoLaserScan_ > MultiEchoLaserScan; + +typedef boost::shared_ptr< ::sensor_msgs::MultiEchoLaserScan > MultiEchoLaserScanPtr; +typedef boost::shared_ptr< ::sensor_msgs::MultiEchoLaserScan const> MultiEchoLaserScanConstPtr; + +// constants requiring out of line definition + + + +template +std::ostream& operator<<(std::ostream& s, const ::sensor_msgs::MultiEchoLaserScan_ & v) +{ +ros::message_operations::Printer< ::sensor_msgs::MultiEchoLaserScan_ >::stream(s, "", v); +return s; +} + +} // namespace sensor_msgs + +namespace ros +{ +namespace message_traits +{ + + + +// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': True} +// {'std_msgs': ['/opt/ros/kinetic/share/std_msgs/cmake/../msg'], 'geometry_msgs': ['/opt/ros/kinetic/share/geometry_msgs/cmake/../msg'], 'sensor_msgs': ['/tmp/binarydeb/ros-kinetic-sensor-msgs-1.12.5/msg']} + +// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types'] + + + + +template +struct IsFixedSize< ::sensor_msgs::MultiEchoLaserScan_ > + : FalseType + { }; + +template +struct IsFixedSize< ::sensor_msgs::MultiEchoLaserScan_ const> + : FalseType + { }; + +template +struct IsMessage< ::sensor_msgs::MultiEchoLaserScan_ > + : TrueType + { }; + +template +struct IsMessage< ::sensor_msgs::MultiEchoLaserScan_ const> + : TrueType + { }; + +template +struct HasHeader< ::sensor_msgs::MultiEchoLaserScan_ > + : TrueType + { }; + +template +struct HasHeader< ::sensor_msgs::MultiEchoLaserScan_ const> + : TrueType + { }; + + +template +struct MD5Sum< ::sensor_msgs::MultiEchoLaserScan_ > +{ + static const char* value() + { + return "6fefb0c6da89d7c8abe4b339f5c2f8fb"; + } + + static const char* value(const ::sensor_msgs::MultiEchoLaserScan_&) { return value(); } + static const uint64_t static_value1 = 0x6fefb0c6da89d7c8ULL; + static const uint64_t static_value2 = 0xabe4b339f5c2f8fbULL; +}; + +template +struct DataType< ::sensor_msgs::MultiEchoLaserScan_ > +{ + static const char* value() + { + return "sensor_msgs/MultiEchoLaserScan"; + } + + static const char* value(const ::sensor_msgs::MultiEchoLaserScan_&) { return value(); } +}; + +template +struct Definition< ::sensor_msgs::MultiEchoLaserScan_ > +{ + static const char* value() + { + return "# Single scan from a multi-echo planar laser range-finder\n\ +#\n\ +# If you have another ranging device with different behavior (e.g. a sonar\n\ +# array), please find or create a different message, since applications\n\ +# will make fairly laser-specific assumptions about this data\n\ +\n\ +Header header # timestamp in the header is the acquisition time of \n\ + # the first ray in the scan.\n\ + #\n\ + # in frame frame_id, angles are measured around \n\ + # the positive Z axis (counterclockwise, if Z is up)\n\ + # with zero angle being forward along the x axis\n\ + \n\ +float32 angle_min # start angle of the scan [rad]\n\ +float32 angle_max # end angle of the scan [rad]\n\ +float32 angle_increment # angular distance between measurements [rad]\n\ +\n\ +float32 time_increment # time between measurements [seconds] - if your scanner\n\ + # is moving, this will be used in interpolating position\n\ + # of 3d points\n\ +float32 scan_time # time between scans [seconds]\n\ +\n\ +float32 range_min # minimum range value [m]\n\ +float32 range_max # maximum range value [m]\n\ +\n\ +LaserEcho[] ranges # range data [m] (Note: NaNs, values < range_min or > range_max should be discarded)\n\ + # +Inf measurements are out of range\n\ + # -Inf measurements are too close to determine exact distance.\n\ +LaserEcho[] intensities # intensity data [device-specific units]. If your\n\ + # device does not provide intensities, please leave\n\ + # the array empty.\n\ +================================================================================\n\ +MSG: std_msgs/Header\n\ +# Standard metadata for higher-level stamped data types.\n\ +# This is generally used to communicate timestamped data \n\ +# in a particular coordinate frame.\n\ +# \n\ +# sequence ID: consecutively increasing ID \n\ +uint32 seq\n\ +#Two-integer timestamp that is expressed as:\n\ +# * stamp.sec: seconds (stamp_secs) since epoch (in Python the variable is called 'secs')\n\ +# * stamp.nsec: nanoseconds since stamp_secs (in Python the variable is called 'nsecs')\n\ +# time-handling sugar is provided by the client library\n\ +time stamp\n\ +#Frame this data is associated with\n\ +# 0: no frame\n\ +# 1: global frame\n\ +string frame_id\n\ +\n\ +================================================================================\n\ +MSG: sensor_msgs/LaserEcho\n\ +# This message is a submessage of MultiEchoLaserScan and is not intended\n\ +# to be used separately.\n\ +\n\ +float32[] echoes # Multiple values of ranges or intensities.\n\ + # Each array represents data from the same angle increment.\n\ +"; + } + + static const char* value(const ::sensor_msgs::MultiEchoLaserScan_&) { return value(); } +}; + +} // namespace message_traits +} // namespace ros + +namespace ros +{ +namespace serialization +{ + + template struct Serializer< ::sensor_msgs::MultiEchoLaserScan_ > + { + template inline static void allInOne(Stream& stream, T m) + { + stream.next(m.header); + stream.next(m.angle_min); + stream.next(m.angle_max); + stream.next(m.angle_increment); + stream.next(m.time_increment); + stream.next(m.scan_time); + stream.next(m.range_min); + stream.next(m.range_max); + stream.next(m.ranges); + stream.next(m.intensities); + } + + ROS_DECLARE_ALLINONE_SERIALIZER; + }; // struct MultiEchoLaserScan_ + +} // namespace serialization +} // namespace ros + +namespace ros +{ +namespace message_operations +{ + +template +struct Printer< ::sensor_msgs::MultiEchoLaserScan_ > +{ + template static void stream(Stream& s, const std::string& indent, const ::sensor_msgs::MultiEchoLaserScan_& v) + { + s << indent << "header: "; + s << std::endl; + Printer< ::std_msgs::Header_ >::stream(s, indent + " ", v.header); + s << indent << "angle_min: "; + Printer::stream(s, indent + " ", v.angle_min); + s << indent << "angle_max: "; + Printer::stream(s, indent + " ", v.angle_max); + s << indent << "angle_increment: "; + Printer::stream(s, indent + " ", v.angle_increment); + s << indent << "time_increment: "; + Printer::stream(s, indent + " ", v.time_increment); + s << indent << "scan_time: "; + Printer::stream(s, indent + " ", v.scan_time); + s << indent << "range_min: "; + Printer::stream(s, indent + " ", v.range_min); + s << indent << "range_max: "; + Printer::stream(s, indent + " ", v.range_max); + s << indent << "ranges[]" << std::endl; + for (size_t i = 0; i < v.ranges.size(); ++i) + { + s << indent << " ranges[" << i << "]: "; + s << std::endl; + s << indent; + Printer< ::sensor_msgs::LaserEcho_ >::stream(s, indent + " ", v.ranges[i]); + } + s << indent << "intensities[]" << std::endl; + for (size_t i = 0; i < v.intensities.size(); ++i) + { + s << indent << " intensities[" << i << "]: "; + s << std::endl; + s << indent; + Printer< ::sensor_msgs::LaserEcho_ >::stream(s, indent + " ", v.intensities[i]); + } + } +}; + +} // namespace message_operations +} // namespace ros + +#endif // SENSOR_MSGS_MESSAGE_MULTIECHOLASERSCAN_H diff --git a/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/NavSatFix.h b/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/NavSatFix.h new file mode 100644 index 0000000000..1778936d6a --- /dev/null +++ b/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/NavSatFix.h @@ -0,0 +1,344 @@ +// Generated by gencpp from file sensor_msgs/NavSatFix.msg +// DO NOT EDIT! + + +#ifndef SENSOR_MSGS_MESSAGE_NAVSATFIX_H +#define SENSOR_MSGS_MESSAGE_NAVSATFIX_H + + +#include +#include +#include + +#include +#include +#include +#include + +#include +#include + +namespace sensor_msgs +{ +template +struct NavSatFix_ +{ + typedef NavSatFix_ Type; + + NavSatFix_() + : header() + , status() + , latitude(0.0) + , longitude(0.0) + , altitude(0.0) + , position_covariance() + , position_covariance_type(0) { + position_covariance.assign(0.0); + } + NavSatFix_(const ContainerAllocator& _alloc) + : header(_alloc) + , status(_alloc) + , latitude(0.0) + , longitude(0.0) + , altitude(0.0) + , position_covariance() + , position_covariance_type(0) { + (void)_alloc; + position_covariance.assign(0.0); + } + + + + typedef ::std_msgs::Header_ _header_type; + _header_type header; + + typedef ::sensor_msgs::NavSatStatus_ _status_type; + _status_type status; + + typedef double _latitude_type; + _latitude_type latitude; + + typedef double _longitude_type; + _longitude_type longitude; + + typedef double _altitude_type; + _altitude_type altitude; + + typedef boost::array _position_covariance_type; + _position_covariance_type position_covariance; + + typedef uint8_t _position_covariance_type_type; + _position_covariance_type_type position_covariance_type; + + + enum { COVARIANCE_TYPE_UNKNOWN = 0u }; + enum { COVARIANCE_TYPE_APPROXIMATED = 1u }; + enum { COVARIANCE_TYPE_DIAGONAL_KNOWN = 2u }; + enum { COVARIANCE_TYPE_KNOWN = 3u }; + + + typedef boost::shared_ptr< ::sensor_msgs::NavSatFix_ > Ptr; + typedef boost::shared_ptr< ::sensor_msgs::NavSatFix_ const> ConstPtr; + +}; // struct NavSatFix_ + +typedef ::sensor_msgs::NavSatFix_ > NavSatFix; + +typedef boost::shared_ptr< ::sensor_msgs::NavSatFix > NavSatFixPtr; +typedef boost::shared_ptr< ::sensor_msgs::NavSatFix const> NavSatFixConstPtr; + +// constants requiring out of line definition + + + + + + + + + + + +template +std::ostream& operator<<(std::ostream& s, const ::sensor_msgs::NavSatFix_ & v) +{ +ros::message_operations::Printer< ::sensor_msgs::NavSatFix_ >::stream(s, "", v); +return s; +} + +} // namespace sensor_msgs + +namespace ros +{ +namespace message_traits +{ + + + +// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': True} +// {'std_msgs': ['/opt/ros/kinetic/share/std_msgs/cmake/../msg'], 'geometry_msgs': ['/opt/ros/kinetic/share/geometry_msgs/cmake/../msg'], 'sensor_msgs': ['/tmp/binarydeb/ros-kinetic-sensor-msgs-1.12.5/msg']} + +// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types'] + + + + +template +struct IsFixedSize< ::sensor_msgs::NavSatFix_ > + : FalseType + { }; + +template +struct IsFixedSize< ::sensor_msgs::NavSatFix_ const> + : FalseType + { }; + +template +struct IsMessage< ::sensor_msgs::NavSatFix_ > + : TrueType + { }; + +template +struct IsMessage< ::sensor_msgs::NavSatFix_ const> + : TrueType + { }; + +template +struct HasHeader< ::sensor_msgs::NavSatFix_ > + : TrueType + { }; + +template +struct HasHeader< ::sensor_msgs::NavSatFix_ const> + : TrueType + { }; + + +template +struct MD5Sum< ::sensor_msgs::NavSatFix_ > +{ + static const char* value() + { + return "2d3a8cd499b9b4a0249fb98fd05cfa48"; + } + + static const char* value(const ::sensor_msgs::NavSatFix_&) { return value(); } + static const uint64_t static_value1 = 0x2d3a8cd499b9b4a0ULL; + static const uint64_t static_value2 = 0x249fb98fd05cfa48ULL; +}; + +template +struct DataType< ::sensor_msgs::NavSatFix_ > +{ + static const char* value() + { + return "sensor_msgs/NavSatFix"; + } + + static const char* value(const ::sensor_msgs::NavSatFix_&) { return value(); } +}; + +template +struct Definition< ::sensor_msgs::NavSatFix_ > +{ + static const char* value() + { + return "# Navigation Satellite fix for any Global Navigation Satellite System\n\ +#\n\ +# Specified using the WGS 84 reference ellipsoid\n\ +\n\ +# header.stamp specifies the ROS time for this measurement (the\n\ +# corresponding satellite time may be reported using the\n\ +# sensor_msgs/TimeReference message).\n\ +#\n\ +# header.frame_id is the frame of reference reported by the satellite\n\ +# receiver, usually the location of the antenna. This is a\n\ +# Euclidean frame relative to the vehicle, not a reference\n\ +# ellipsoid.\n\ +Header header\n\ +\n\ +# satellite fix status information\n\ +NavSatStatus status\n\ +\n\ +# Latitude [degrees]. Positive is north of equator; negative is south.\n\ +float64 latitude\n\ +\n\ +# Longitude [degrees]. Positive is east of prime meridian; negative is west.\n\ +float64 longitude\n\ +\n\ +# Altitude [m]. Positive is above the WGS 84 ellipsoid\n\ +# (quiet NaN if no altitude is available).\n\ +float64 altitude\n\ +\n\ +# Position covariance [m^2] defined relative to a tangential plane\n\ +# through the reported position. The components are East, North, and\n\ +# Up (ENU), in row-major order.\n\ +#\n\ +# Beware: this coordinate system exhibits singularities at the poles.\n\ +\n\ +float64[9] position_covariance\n\ +\n\ +# If the covariance of the fix is known, fill it in completely. If the\n\ +# GPS receiver provides the variance of each measurement, put them\n\ +# along the diagonal. If only Dilution of Precision is available,\n\ +# estimate an approximate covariance from that.\n\ +\n\ +uint8 COVARIANCE_TYPE_UNKNOWN = 0\n\ +uint8 COVARIANCE_TYPE_APPROXIMATED = 1\n\ +uint8 COVARIANCE_TYPE_DIAGONAL_KNOWN = 2\n\ +uint8 COVARIANCE_TYPE_KNOWN = 3\n\ +\n\ +uint8 position_covariance_type\n\ +\n\ +================================================================================\n\ +MSG: std_msgs/Header\n\ +# Standard metadata for higher-level stamped data types.\n\ +# This is generally used to communicate timestamped data \n\ +# in a particular coordinate frame.\n\ +# \n\ +# sequence ID: consecutively increasing ID \n\ +uint32 seq\n\ +#Two-integer timestamp that is expressed as:\n\ +# * stamp.sec: seconds (stamp_secs) since epoch (in Python the variable is called 'secs')\n\ +# * stamp.nsec: nanoseconds since stamp_secs (in Python the variable is called 'nsecs')\n\ +# time-handling sugar is provided by the client library\n\ +time stamp\n\ +#Frame this data is associated with\n\ +# 0: no frame\n\ +# 1: global frame\n\ +string frame_id\n\ +\n\ +================================================================================\n\ +MSG: sensor_msgs/NavSatStatus\n\ +# Navigation Satellite fix status for any Global Navigation Satellite System\n\ +\n\ +# Whether to output an augmented fix is determined by both the fix\n\ +# type and the last time differential corrections were received. A\n\ +# fix is valid when status >= STATUS_FIX.\n\ +\n\ +int8 STATUS_NO_FIX = -1 # unable to fix position\n\ +int8 STATUS_FIX = 0 # unaugmented fix\n\ +int8 STATUS_SBAS_FIX = 1 # with satellite-based augmentation\n\ +int8 STATUS_GBAS_FIX = 2 # with ground-based augmentation\n\ +\n\ +int8 status\n\ +\n\ +# Bits defining which Global Navigation Satellite System signals were\n\ +# used by the receiver.\n\ +\n\ +uint16 SERVICE_GPS = 1\n\ +uint16 SERVICE_GLONASS = 2\n\ +uint16 SERVICE_COMPASS = 4 # includes BeiDou.\n\ +uint16 SERVICE_GALILEO = 8\n\ +\n\ +uint16 service\n\ +"; + } + + static const char* value(const ::sensor_msgs::NavSatFix_&) { return value(); } +}; + +} // namespace message_traits +} // namespace ros + +namespace ros +{ +namespace serialization +{ + + template struct Serializer< ::sensor_msgs::NavSatFix_ > + { + template inline static void allInOne(Stream& stream, T m) + { + stream.next(m.header); + stream.next(m.status); + stream.next(m.latitude); + stream.next(m.longitude); + stream.next(m.altitude); + stream.next(m.position_covariance); + stream.next(m.position_covariance_type); + } + + ROS_DECLARE_ALLINONE_SERIALIZER; + }; // struct NavSatFix_ + +} // namespace serialization +} // namespace ros + +namespace ros +{ +namespace message_operations +{ + +template +struct Printer< ::sensor_msgs::NavSatFix_ > +{ + template static void stream(Stream& s, const std::string& indent, const ::sensor_msgs::NavSatFix_& v) + { + s << indent << "header: "; + s << std::endl; + Printer< ::std_msgs::Header_ >::stream(s, indent + " ", v.header); + s << indent << "status: "; + s << std::endl; + Printer< ::sensor_msgs::NavSatStatus_ >::stream(s, indent + " ", v.status); + s << indent << "latitude: "; + Printer::stream(s, indent + " ", v.latitude); + s << indent << "longitude: "; + Printer::stream(s, indent + " ", v.longitude); + s << indent << "altitude: "; + Printer::stream(s, indent + " ", v.altitude); + s << indent << "position_covariance[]" << std::endl; + for (size_t i = 0; i < v.position_covariance.size(); ++i) + { + s << indent << " position_covariance[" << i << "]: "; + Printer::stream(s, indent + " ", v.position_covariance[i]); + } + s << indent << "position_covariance_type: "; + Printer::stream(s, indent + " ", v.position_covariance_type); + } +}; + +} // namespace message_operations +} // namespace ros + +#endif // SENSOR_MSGS_MESSAGE_NAVSATFIX_H diff --git a/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/NavSatStatus.h b/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/NavSatStatus.h new file mode 100644 index 0000000000..296a0ea9da --- /dev/null +++ b/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/NavSatStatus.h @@ -0,0 +1,239 @@ +// Generated by gencpp from file sensor_msgs/NavSatStatus.msg +// DO NOT EDIT! + + +#ifndef SENSOR_MSGS_MESSAGE_NAVSATSTATUS_H +#define SENSOR_MSGS_MESSAGE_NAVSATSTATUS_H + + +#include +#include +#include + +#include +#include +#include +#include + + +namespace sensor_msgs +{ +template +struct NavSatStatus_ +{ + typedef NavSatStatus_ Type; + + NavSatStatus_() + : status(0) + , service(0) { + } + NavSatStatus_(const ContainerAllocator& _alloc) + : status(0) + , service(0) { + (void)_alloc; + } + + + + typedef int8_t _status_type; + _status_type status; + + typedef uint16_t _service_type; + _service_type service; + + + enum { STATUS_NO_FIX = -1 }; + enum { STATUS_FIX = 0 }; + enum { STATUS_SBAS_FIX = 1 }; + enum { STATUS_GBAS_FIX = 2 }; + enum { SERVICE_GPS = 1u }; + enum { SERVICE_GLONASS = 2u }; + enum { SERVICE_COMPASS = 4u }; + enum { SERVICE_GALILEO = 8u }; + + + typedef boost::shared_ptr< ::sensor_msgs::NavSatStatus_ > Ptr; + typedef boost::shared_ptr< ::sensor_msgs::NavSatStatus_ const> ConstPtr; + +}; // struct NavSatStatus_ + +typedef ::sensor_msgs::NavSatStatus_ > NavSatStatus; + +typedef boost::shared_ptr< ::sensor_msgs::NavSatStatus > NavSatStatusPtr; +typedef boost::shared_ptr< ::sensor_msgs::NavSatStatus const> NavSatStatusConstPtr; + +// constants requiring out of line definition + + + + + + + + + + + + + + + + + + + +template +std::ostream& operator<<(std::ostream& s, const ::sensor_msgs::NavSatStatus_ & v) +{ +ros::message_operations::Printer< ::sensor_msgs::NavSatStatus_ >::stream(s, "", v); +return s; +} + +} // namespace sensor_msgs + +namespace ros +{ +namespace message_traits +{ + + + +// BOOLTRAITS {'IsFixedSize': True, 'IsMessage': True, 'HasHeader': False} +// {'std_msgs': ['/opt/ros/kinetic/share/std_msgs/cmake/../msg'], 'geometry_msgs': ['/opt/ros/kinetic/share/geometry_msgs/cmake/../msg'], 'sensor_msgs': ['/tmp/binarydeb/ros-kinetic-sensor-msgs-1.12.5/msg']} + +// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types'] + + + + +template +struct IsFixedSize< ::sensor_msgs::NavSatStatus_ > + : TrueType + { }; + +template +struct IsFixedSize< ::sensor_msgs::NavSatStatus_ const> + : TrueType + { }; + +template +struct IsMessage< ::sensor_msgs::NavSatStatus_ > + : TrueType + { }; + +template +struct IsMessage< ::sensor_msgs::NavSatStatus_ const> + : TrueType + { }; + +template +struct HasHeader< ::sensor_msgs::NavSatStatus_ > + : FalseType + { }; + +template +struct HasHeader< ::sensor_msgs::NavSatStatus_ const> + : FalseType + { }; + + +template +struct MD5Sum< ::sensor_msgs::NavSatStatus_ > +{ + static const char* value() + { + return "331cdbddfa4bc96ffc3b9ad98900a54c"; + } + + static const char* value(const ::sensor_msgs::NavSatStatus_&) { return value(); } + static const uint64_t static_value1 = 0x331cdbddfa4bc96fULL; + static const uint64_t static_value2 = 0xfc3b9ad98900a54cULL; +}; + +template +struct DataType< ::sensor_msgs::NavSatStatus_ > +{ + static const char* value() + { + return "sensor_msgs/NavSatStatus"; + } + + static const char* value(const ::sensor_msgs::NavSatStatus_&) { return value(); } +}; + +template +struct Definition< ::sensor_msgs::NavSatStatus_ > +{ + static const char* value() + { + return "# Navigation Satellite fix status for any Global Navigation Satellite System\n\ +\n\ +# Whether to output an augmented fix is determined by both the fix\n\ +# type and the last time differential corrections were received. A\n\ +# fix is valid when status >= STATUS_FIX.\n\ +\n\ +int8 STATUS_NO_FIX = -1 # unable to fix position\n\ +int8 STATUS_FIX = 0 # unaugmented fix\n\ +int8 STATUS_SBAS_FIX = 1 # with satellite-based augmentation\n\ +int8 STATUS_GBAS_FIX = 2 # with ground-based augmentation\n\ +\n\ +int8 status\n\ +\n\ +# Bits defining which Global Navigation Satellite System signals were\n\ +# used by the receiver.\n\ +\n\ +uint16 SERVICE_GPS = 1\n\ +uint16 SERVICE_GLONASS = 2\n\ +uint16 SERVICE_COMPASS = 4 # includes BeiDou.\n\ +uint16 SERVICE_GALILEO = 8\n\ +\n\ +uint16 service\n\ +"; + } + + static const char* value(const ::sensor_msgs::NavSatStatus_&) { return value(); } +}; + +} // namespace message_traits +} // namespace ros + +namespace ros +{ +namespace serialization +{ + + template struct Serializer< ::sensor_msgs::NavSatStatus_ > + { + template inline static void allInOne(Stream& stream, T m) + { + stream.next(m.status); + stream.next(m.service); + } + + ROS_DECLARE_ALLINONE_SERIALIZER; + }; // struct NavSatStatus_ + +} // namespace serialization +} // namespace ros + +namespace ros +{ +namespace message_operations +{ + +template +struct Printer< ::sensor_msgs::NavSatStatus_ > +{ + template static void stream(Stream& s, const std::string& indent, const ::sensor_msgs::NavSatStatus_& v) + { + s << indent << "status: "; + Printer::stream(s, indent + " ", v.status); + s << indent << "service: "; + Printer::stream(s, indent + " ", v.service); + } +}; + +} // namespace message_operations +} // namespace ros + +#endif // SENSOR_MSGS_MESSAGE_NAVSATSTATUS_H diff --git a/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/PointCloud.h b/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/PointCloud.h new file mode 100644 index 0000000000..c1a9b5995e --- /dev/null +++ b/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/PointCloud.h @@ -0,0 +1,289 @@ +// Generated by gencpp from file sensor_msgs/PointCloud.msg +// DO NOT EDIT! + + +#ifndef SENSOR_MSGS_MESSAGE_POINTCLOUD_H +#define SENSOR_MSGS_MESSAGE_POINTCLOUD_H + + +#include +#include +#include + +#include +#include +#include +#include + +#include +#include +#include + +namespace sensor_msgs +{ +template +struct PointCloud_ +{ + typedef PointCloud_ Type; + + PointCloud_() + : header() + , points() + , channels() { + } + PointCloud_(const ContainerAllocator& _alloc) + : header(_alloc) + , points(_alloc) + , channels(_alloc) { + (void)_alloc; + } + + + + typedef ::std_msgs::Header_ _header_type; + _header_type header; + + typedef std::vector< ::geometry_msgs::Point32_ , typename ContainerAllocator::template rebind< ::geometry_msgs::Point32_ >::other > _points_type; + _points_type points; + + typedef std::vector< ::sensor_msgs::ChannelFloat32_ , typename ContainerAllocator::template rebind< ::sensor_msgs::ChannelFloat32_ >::other > _channels_type; + _channels_type channels; + + + + + typedef boost::shared_ptr< ::sensor_msgs::PointCloud_ > Ptr; + typedef boost::shared_ptr< ::sensor_msgs::PointCloud_ const> ConstPtr; + +}; // struct PointCloud_ + +typedef ::sensor_msgs::PointCloud_ > PointCloud; + +typedef boost::shared_ptr< ::sensor_msgs::PointCloud > PointCloudPtr; +typedef boost::shared_ptr< ::sensor_msgs::PointCloud const> PointCloudConstPtr; + +// constants requiring out of line definition + + + +template +std::ostream& operator<<(std::ostream& s, const ::sensor_msgs::PointCloud_ & v) +{ +ros::message_operations::Printer< ::sensor_msgs::PointCloud_ >::stream(s, "", v); +return s; +} + +} // namespace sensor_msgs + +namespace ros +{ +namespace message_traits +{ + + + +// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': True} +// {'std_msgs': ['/opt/ros/kinetic/share/std_msgs/cmake/../msg'], 'geometry_msgs': ['/opt/ros/kinetic/share/geometry_msgs/cmake/../msg'], 'sensor_msgs': ['/tmp/binarydeb/ros-kinetic-sensor-msgs-1.12.5/msg']} + +// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types'] + + + + +template +struct IsFixedSize< ::sensor_msgs::PointCloud_ > + : FalseType + { }; + +template +struct IsFixedSize< ::sensor_msgs::PointCloud_ const> + : FalseType + { }; + +template +struct IsMessage< ::sensor_msgs::PointCloud_ > + : TrueType + { }; + +template +struct IsMessage< ::sensor_msgs::PointCloud_ const> + : TrueType + { }; + +template +struct HasHeader< ::sensor_msgs::PointCloud_ > + : TrueType + { }; + +template +struct HasHeader< ::sensor_msgs::PointCloud_ const> + : TrueType + { }; + + +template +struct MD5Sum< ::sensor_msgs::PointCloud_ > +{ + static const char* value() + { + return "d8e9c3f5afbdd8a130fd1d2763945fca"; + } + + static const char* value(const ::sensor_msgs::PointCloud_&) { return value(); } + static const uint64_t static_value1 = 0xd8e9c3f5afbdd8a1ULL; + static const uint64_t static_value2 = 0x30fd1d2763945fcaULL; +}; + +template +struct DataType< ::sensor_msgs::PointCloud_ > +{ + static const char* value() + { + return "sensor_msgs/PointCloud"; + } + + static const char* value(const ::sensor_msgs::PointCloud_&) { return value(); } +}; + +template +struct Definition< ::sensor_msgs::PointCloud_ > +{ + static const char* value() + { + return "# This message holds a collection of 3d points, plus optional additional\n\ +# information about each point.\n\ +\n\ +# Time of sensor data acquisition, coordinate frame ID.\n\ +Header header\n\ +\n\ +# Array of 3d points. Each Point32 should be interpreted as a 3d point\n\ +# in the frame given in the header.\n\ +geometry_msgs/Point32[] points\n\ +\n\ +# Each channel should have the same number of elements as points array,\n\ +# and the data in each channel should correspond 1:1 with each point.\n\ +# Channel names in common practice are listed in ChannelFloat32.msg.\n\ +ChannelFloat32[] channels\n\ +\n\ +================================================================================\n\ +MSG: std_msgs/Header\n\ +# Standard metadata for higher-level stamped data types.\n\ +# This is generally used to communicate timestamped data \n\ +# in a particular coordinate frame.\n\ +# \n\ +# sequence ID: consecutively increasing ID \n\ +uint32 seq\n\ +#Two-integer timestamp that is expressed as:\n\ +# * stamp.sec: seconds (stamp_secs) since epoch (in Python the variable is called 'secs')\n\ +# * stamp.nsec: nanoseconds since stamp_secs (in Python the variable is called 'nsecs')\n\ +# time-handling sugar is provided by the client library\n\ +time stamp\n\ +#Frame this data is associated with\n\ +# 0: no frame\n\ +# 1: global frame\n\ +string frame_id\n\ +\n\ +================================================================================\n\ +MSG: geometry_msgs/Point32\n\ +# This contains the position of a point in free space(with 32 bits of precision).\n\ +# It is recommeded to use Point wherever possible instead of Point32. \n\ +# \n\ +# This recommendation is to promote interoperability. \n\ +#\n\ +# This message is designed to take up less space when sending\n\ +# lots of points at once, as in the case of a PointCloud. \n\ +\n\ +float32 x\n\ +float32 y\n\ +float32 z\n\ +================================================================================\n\ +MSG: sensor_msgs/ChannelFloat32\n\ +# This message is used by the PointCloud message to hold optional data\n\ +# associated with each point in the cloud. The length of the values\n\ +# array should be the same as the length of the points array in the\n\ +# PointCloud, and each value should be associated with the corresponding\n\ +# point.\n\ +\n\ +# Channel names in existing practice include:\n\ +# \"u\", \"v\" - row and column (respectively) in the left stereo image.\n\ +# This is opposite to usual conventions but remains for\n\ +# historical reasons. The newer PointCloud2 message has no\n\ +# such problem.\n\ +# \"rgb\" - For point clouds produced by color stereo cameras. uint8\n\ +# (R,G,B) values packed into the least significant 24 bits,\n\ +# in order.\n\ +# \"intensity\" - laser or pixel intensity.\n\ +# \"distance\"\n\ +\n\ +# The channel name should give semantics of the channel (e.g.\n\ +# \"intensity\" instead of \"value\").\n\ +string name\n\ +\n\ +# The values array should be 1-1 with the elements of the associated\n\ +# PointCloud.\n\ +float32[] values\n\ +"; + } + + static const char* value(const ::sensor_msgs::PointCloud_&) { return value(); } +}; + +} // namespace message_traits +} // namespace ros + +namespace ros +{ +namespace serialization +{ + + template struct Serializer< ::sensor_msgs::PointCloud_ > + { + template inline static void allInOne(Stream& stream, T m) + { + stream.next(m.header); + stream.next(m.points); + stream.next(m.channels); + } + + ROS_DECLARE_ALLINONE_SERIALIZER; + }; // struct PointCloud_ + +} // namespace serialization +} // namespace ros + +namespace ros +{ +namespace message_operations +{ + +template +struct Printer< ::sensor_msgs::PointCloud_ > +{ + template static void stream(Stream& s, const std::string& indent, const ::sensor_msgs::PointCloud_& v) + { + s << indent << "header: "; + s << std::endl; + Printer< ::std_msgs::Header_ >::stream(s, indent + " ", v.header); + s << indent << "points[]" << std::endl; + for (size_t i = 0; i < v.points.size(); ++i) + { + s << indent << " points[" << i << "]: "; + s << std::endl; + s << indent; + Printer< ::geometry_msgs::Point32_ >::stream(s, indent + " ", v.points[i]); + } + s << indent << "channels[]" << std::endl; + for (size_t i = 0; i < v.channels.size(); ++i) + { + s << indent << " channels[" << i << "]: "; + s << std::endl; + s << indent; + Printer< ::sensor_msgs::ChannelFloat32_ >::stream(s, indent + " ", v.channels[i]); + } + } +}; + +} // namespace message_operations +} // namespace ros + +#endif // SENSOR_MSGS_MESSAGE_POINTCLOUD_H diff --git a/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/PointCloud2.h b/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/PointCloud2.h new file mode 100644 index 0000000000..d8c4a152a7 --- /dev/null +++ b/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/PointCloud2.h @@ -0,0 +1,325 @@ +// Generated by gencpp from file sensor_msgs/PointCloud2.msg +// DO NOT EDIT! + + +#ifndef SENSOR_MSGS_MESSAGE_POINTCLOUD2_H +#define SENSOR_MSGS_MESSAGE_POINTCLOUD2_H + + +#include +#include +#include + +#include +#include +#include +#include + +#include +#include + +namespace sensor_msgs +{ +template +struct PointCloud2_ +{ + typedef PointCloud2_ Type; + + PointCloud2_() + : header() + , height(0) + , width(0) + , fields() + , is_bigendian(false) + , point_step(0) + , row_step(0) + , data() + , is_dense(false) { + } + PointCloud2_(const ContainerAllocator& _alloc) + : header(_alloc) + , height(0) + , width(0) + , fields(_alloc) + , is_bigendian(false) + , point_step(0) + , row_step(0) + , data(_alloc) + , is_dense(false) { + (void)_alloc; + } + + + + typedef ::std_msgs::Header_ _header_type; + _header_type header; + + typedef uint32_t _height_type; + _height_type height; + + typedef uint32_t _width_type; + _width_type width; + + typedef std::vector< ::sensor_msgs::PointField_ , typename ContainerAllocator::template rebind< ::sensor_msgs::PointField_ >::other > _fields_type; + _fields_type fields; + + typedef uint8_t _is_bigendian_type; + _is_bigendian_type is_bigendian; + + typedef uint32_t _point_step_type; + _point_step_type point_step; + + typedef uint32_t _row_step_type; + _row_step_type row_step; + + typedef std::vector::other > _data_type; + _data_type data; + + typedef uint8_t _is_dense_type; + _is_dense_type is_dense; + + + + + typedef boost::shared_ptr< ::sensor_msgs::PointCloud2_ > Ptr; + typedef boost::shared_ptr< ::sensor_msgs::PointCloud2_ const> ConstPtr; + +}; // struct PointCloud2_ + +typedef ::sensor_msgs::PointCloud2_ > PointCloud2; + +typedef boost::shared_ptr< ::sensor_msgs::PointCloud2 > PointCloud2Ptr; +typedef boost::shared_ptr< ::sensor_msgs::PointCloud2 const> PointCloud2ConstPtr; + +// constants requiring out of line definition + + + +template +std::ostream& operator<<(std::ostream& s, const ::sensor_msgs::PointCloud2_ & v) +{ +ros::message_operations::Printer< ::sensor_msgs::PointCloud2_ >::stream(s, "", v); +return s; +} + +} // namespace sensor_msgs + +namespace ros +{ +namespace message_traits +{ + + + +// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': True} +// {'std_msgs': ['/opt/ros/kinetic/share/std_msgs/cmake/../msg'], 'geometry_msgs': ['/opt/ros/kinetic/share/geometry_msgs/cmake/../msg'], 'sensor_msgs': ['/tmp/binarydeb/ros-kinetic-sensor-msgs-1.12.5/msg']} + +// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types'] + + + + +template +struct IsFixedSize< ::sensor_msgs::PointCloud2_ > + : FalseType + { }; + +template +struct IsFixedSize< ::sensor_msgs::PointCloud2_ const> + : FalseType + { }; + +template +struct IsMessage< ::sensor_msgs::PointCloud2_ > + : TrueType + { }; + +template +struct IsMessage< ::sensor_msgs::PointCloud2_ const> + : TrueType + { }; + +template +struct HasHeader< ::sensor_msgs::PointCloud2_ > + : TrueType + { }; + +template +struct HasHeader< ::sensor_msgs::PointCloud2_ const> + : TrueType + { }; + + +template +struct MD5Sum< ::sensor_msgs::PointCloud2_ > +{ + static const char* value() + { + return "1158d486dd51d683ce2f1be655c3c181"; + } + + static const char* value(const ::sensor_msgs::PointCloud2_&) { return value(); } + static const uint64_t static_value1 = 0x1158d486dd51d683ULL; + static const uint64_t static_value2 = 0xce2f1be655c3c181ULL; +}; + +template +struct DataType< ::sensor_msgs::PointCloud2_ > +{ + static const char* value() + { + return "sensor_msgs/PointCloud2"; + } + + static const char* value(const ::sensor_msgs::PointCloud2_&) { return value(); } +}; + +template +struct Definition< ::sensor_msgs::PointCloud2_ > +{ + static const char* value() + { + return "# This message holds a collection of N-dimensional points, which may\n\ +# contain additional information such as normals, intensity, etc. The\n\ +# point data is stored as a binary blob, its layout described by the\n\ +# contents of the \"fields\" array.\n\ +\n\ +# The point cloud data may be organized 2d (image-like) or 1d\n\ +# (unordered). Point clouds organized as 2d images may be produced by\n\ +# camera depth sensors such as stereo or time-of-flight.\n\ +\n\ +# Time of sensor data acquisition, and the coordinate frame ID (for 3d\n\ +# points).\n\ +Header header\n\ +\n\ +# 2D structure of the point cloud. If the cloud is unordered, height is\n\ +# 1 and width is the length of the point cloud.\n\ +uint32 height\n\ +uint32 width\n\ +\n\ +# Describes the channels and their layout in the binary data blob.\n\ +PointField[] fields\n\ +\n\ +bool is_bigendian # Is this data bigendian?\n\ +uint32 point_step # Length of a point in bytes\n\ +uint32 row_step # Length of a row in bytes\n\ +uint8[] data # Actual point data, size is (row_step*height)\n\ +\n\ +bool is_dense # True if there are no invalid points\n\ +\n\ +================================================================================\n\ +MSG: std_msgs/Header\n\ +# Standard metadata for higher-level stamped data types.\n\ +# This is generally used to communicate timestamped data \n\ +# in a particular coordinate frame.\n\ +# \n\ +# sequence ID: consecutively increasing ID \n\ +uint32 seq\n\ +#Two-integer timestamp that is expressed as:\n\ +# * stamp.sec: seconds (stamp_secs) since epoch (in Python the variable is called 'secs')\n\ +# * stamp.nsec: nanoseconds since stamp_secs (in Python the variable is called 'nsecs')\n\ +# time-handling sugar is provided by the client library\n\ +time stamp\n\ +#Frame this data is associated with\n\ +# 0: no frame\n\ +# 1: global frame\n\ +string frame_id\n\ +\n\ +================================================================================\n\ +MSG: sensor_msgs/PointField\n\ +# This message holds the description of one point entry in the\n\ +# PointCloud2 message format.\n\ +uint8 INT8 = 1\n\ +uint8 UINT8 = 2\n\ +uint8 INT16 = 3\n\ +uint8 UINT16 = 4\n\ +uint8 INT32 = 5\n\ +uint8 UINT32 = 6\n\ +uint8 FLOAT32 = 7\n\ +uint8 FLOAT64 = 8\n\ +\n\ +string name # Name of field\n\ +uint32 offset # Offset from start of point struct\n\ +uint8 datatype # Datatype enumeration, see above\n\ +uint32 count # How many elements in the field\n\ +"; + } + + static const char* value(const ::sensor_msgs::PointCloud2_&) { return value(); } +}; + +} // namespace message_traits +} // namespace ros + +namespace ros +{ +namespace serialization +{ + + template struct Serializer< ::sensor_msgs::PointCloud2_ > + { + template inline static void allInOne(Stream& stream, T m) + { + stream.next(m.header); + stream.next(m.height); + stream.next(m.width); + stream.next(m.fields); + stream.next(m.is_bigendian); + stream.next(m.point_step); + stream.next(m.row_step); + stream.next(m.data); + stream.next(m.is_dense); + } + + ROS_DECLARE_ALLINONE_SERIALIZER; + }; // struct PointCloud2_ + +} // namespace serialization +} // namespace ros + +namespace ros +{ +namespace message_operations +{ + +template +struct Printer< ::sensor_msgs::PointCloud2_ > +{ + template static void stream(Stream& s, const std::string& indent, const ::sensor_msgs::PointCloud2_& v) + { + s << indent << "header: "; + s << std::endl; + Printer< ::std_msgs::Header_ >::stream(s, indent + " ", v.header); + s << indent << "height: "; + Printer::stream(s, indent + " ", v.height); + s << indent << "width: "; + Printer::stream(s, indent + " ", v.width); + s << indent << "fields[]" << std::endl; + for (size_t i = 0; i < v.fields.size(); ++i) + { + s << indent << " fields[" << i << "]: "; + s << std::endl; + s << indent; + Printer< ::sensor_msgs::PointField_ >::stream(s, indent + " ", v.fields[i]); + } + s << indent << "is_bigendian: "; + Printer::stream(s, indent + " ", v.is_bigendian); + s << indent << "point_step: "; + Printer::stream(s, indent + " ", v.point_step); + s << indent << "row_step: "; + Printer::stream(s, indent + " ", v.row_step); + s << indent << "data[]" << std::endl; + for (size_t i = 0; i < v.data.size(); ++i) + { + s << indent << " data[" << i << "]: "; + Printer::stream(s, indent + " ", v.data[i]); + } + s << indent << "is_dense: "; + Printer::stream(s, indent + " ", v.is_dense); + } +}; + +} // namespace message_operations +} // namespace ros + +#endif // SENSOR_MSGS_MESSAGE_POINTCLOUD2_H diff --git a/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/PointField.h b/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/PointField.h new file mode 100644 index 0000000000..d9702f7370 --- /dev/null +++ b/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/PointField.h @@ -0,0 +1,248 @@ +// Generated by gencpp from file sensor_msgs/PointField.msg +// DO NOT EDIT! + + +#ifndef SENSOR_MSGS_MESSAGE_POINTFIELD_H +#define SENSOR_MSGS_MESSAGE_POINTFIELD_H + + +#include +#include +#include + +#include +#include +#include +#include + + +namespace sensor_msgs +{ +template +struct PointField_ +{ + typedef PointField_ Type; + + PointField_() + : name() + , offset(0) + , datatype(0) + , count(0) { + } + PointField_(const ContainerAllocator& _alloc) + : name(_alloc) + , offset(0) + , datatype(0) + , count(0) { + (void)_alloc; + } + + + + typedef std::basic_string, typename ContainerAllocator::template rebind::other > _name_type; + _name_type name; + + typedef uint32_t _offset_type; + _offset_type offset; + + typedef uint8_t _datatype_type; + _datatype_type datatype; + + typedef uint32_t _count_type; + _count_type count; + + + enum { INT8 = 1u }; + enum { UINT8 = 2u }; + enum { INT16 = 3u }; + enum { UINT16 = 4u }; + enum { INT32 = 5u }; + enum { UINT32 = 6u }; + enum { FLOAT32 = 7u }; + enum { FLOAT64 = 8u }; + + + typedef boost::shared_ptr< ::sensor_msgs::PointField_ > Ptr; + typedef boost::shared_ptr< ::sensor_msgs::PointField_ const> ConstPtr; + +}; // struct PointField_ + +typedef ::sensor_msgs::PointField_ > PointField; + +typedef boost::shared_ptr< ::sensor_msgs::PointField > PointFieldPtr; +typedef boost::shared_ptr< ::sensor_msgs::PointField const> PointFieldConstPtr; + +// constants requiring out of line definition + + + + + + + + + + + + + + + + + + + +template +std::ostream& operator<<(std::ostream& s, const ::sensor_msgs::PointField_ & v) +{ +ros::message_operations::Printer< ::sensor_msgs::PointField_ >::stream(s, "", v); +return s; +} + +} // namespace sensor_msgs + +namespace ros +{ +namespace message_traits +{ + + + +// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': False} +// {'std_msgs': ['/opt/ros/kinetic/share/std_msgs/cmake/../msg'], 'geometry_msgs': ['/opt/ros/kinetic/share/geometry_msgs/cmake/../msg'], 'sensor_msgs': ['/tmp/binarydeb/ros-kinetic-sensor-msgs-1.12.5/msg']} + +// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types'] + + + + +template +struct IsFixedSize< ::sensor_msgs::PointField_ > + : FalseType + { }; + +template +struct IsFixedSize< ::sensor_msgs::PointField_ const> + : FalseType + { }; + +template +struct IsMessage< ::sensor_msgs::PointField_ > + : TrueType + { }; + +template +struct IsMessage< ::sensor_msgs::PointField_ const> + : TrueType + { }; + +template +struct HasHeader< ::sensor_msgs::PointField_ > + : FalseType + { }; + +template +struct HasHeader< ::sensor_msgs::PointField_ const> + : FalseType + { }; + + +template +struct MD5Sum< ::sensor_msgs::PointField_ > +{ + static const char* value() + { + return "268eacb2962780ceac86cbd17e328150"; + } + + static const char* value(const ::sensor_msgs::PointField_&) { return value(); } + static const uint64_t static_value1 = 0x268eacb2962780ceULL; + static const uint64_t static_value2 = 0xac86cbd17e328150ULL; +}; + +template +struct DataType< ::sensor_msgs::PointField_ > +{ + static const char* value() + { + return "sensor_msgs/PointField"; + } + + static const char* value(const ::sensor_msgs::PointField_&) { return value(); } +}; + +template +struct Definition< ::sensor_msgs::PointField_ > +{ + static const char* value() + { + return "# This message holds the description of one point entry in the\n\ +# PointCloud2 message format.\n\ +uint8 INT8 = 1\n\ +uint8 UINT8 = 2\n\ +uint8 INT16 = 3\n\ +uint8 UINT16 = 4\n\ +uint8 INT32 = 5\n\ +uint8 UINT32 = 6\n\ +uint8 FLOAT32 = 7\n\ +uint8 FLOAT64 = 8\n\ +\n\ +string name # Name of field\n\ +uint32 offset # Offset from start of point struct\n\ +uint8 datatype # Datatype enumeration, see above\n\ +uint32 count # How many elements in the field\n\ +"; + } + + static const char* value(const ::sensor_msgs::PointField_&) { return value(); } +}; + +} // namespace message_traits +} // namespace ros + +namespace ros +{ +namespace serialization +{ + + template struct Serializer< ::sensor_msgs::PointField_ > + { + template inline static void allInOne(Stream& stream, T m) + { + stream.next(m.name); + stream.next(m.offset); + stream.next(m.datatype); + stream.next(m.count); + } + + ROS_DECLARE_ALLINONE_SERIALIZER; + }; // struct PointField_ + +} // namespace serialization +} // namespace ros + +namespace ros +{ +namespace message_operations +{ + +template +struct Printer< ::sensor_msgs::PointField_ > +{ + template static void stream(Stream& s, const std::string& indent, const ::sensor_msgs::PointField_& v) + { + s << indent << "name: "; + Printer, typename ContainerAllocator::template rebind::other > >::stream(s, indent + " ", v.name); + s << indent << "offset: "; + Printer::stream(s, indent + " ", v.offset); + s << indent << "datatype: "; + Printer::stream(s, indent + " ", v.datatype); + s << indent << "count: "; + Printer::stream(s, indent + " ", v.count); + } +}; + +} // namespace message_operations +} // namespace ros + +#endif // SENSOR_MSGS_MESSAGE_POINTFIELD_H diff --git a/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/Range.h b/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/Range.h new file mode 100644 index 0000000000..4534235feb --- /dev/null +++ b/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/Range.h @@ -0,0 +1,290 @@ +// Generated by gencpp from file sensor_msgs/Range.msg +// DO NOT EDIT! + + +#ifndef SENSOR_MSGS_MESSAGE_RANGE_H +#define SENSOR_MSGS_MESSAGE_RANGE_H + + +#include +#include +#include + +#include +#include +#include +#include + +#include + +namespace sensor_msgs +{ +template +struct Range_ +{ + typedef Range_ Type; + + Range_() + : header() + , radiation_type(0) + , field_of_view(0.0) + , min_range(0.0) + , max_range(0.0) + , range(0.0) { + } + Range_(const ContainerAllocator& _alloc) + : header(_alloc) + , radiation_type(0) + , field_of_view(0.0) + , min_range(0.0) + , max_range(0.0) + , range(0.0) { + (void)_alloc; + } + + + + typedef ::std_msgs::Header_ _header_type; + _header_type header; + + typedef uint8_t _radiation_type_type; + _radiation_type_type radiation_type; + + typedef float _field_of_view_type; + _field_of_view_type field_of_view; + + typedef float _min_range_type; + _min_range_type min_range; + + typedef float _max_range_type; + _max_range_type max_range; + + typedef float _range_type; + _range_type range; + + + enum { ULTRASOUND = 0u }; + enum { INFRARED = 1u }; + + + typedef boost::shared_ptr< ::sensor_msgs::Range_ > Ptr; + typedef boost::shared_ptr< ::sensor_msgs::Range_ const> ConstPtr; + +}; // struct Range_ + +typedef ::sensor_msgs::Range_ > Range; + +typedef boost::shared_ptr< ::sensor_msgs::Range > RangePtr; +typedef boost::shared_ptr< ::sensor_msgs::Range const> RangeConstPtr; + +// constants requiring out of line definition + + + + + + + +template +std::ostream& operator<<(std::ostream& s, const ::sensor_msgs::Range_ & v) +{ +ros::message_operations::Printer< ::sensor_msgs::Range_ >::stream(s, "", v); +return s; +} + +} // namespace sensor_msgs + +namespace ros +{ +namespace message_traits +{ + + + +// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': True} +// {'std_msgs': ['/opt/ros/kinetic/share/std_msgs/cmake/../msg'], 'geometry_msgs': ['/opt/ros/kinetic/share/geometry_msgs/cmake/../msg'], 'sensor_msgs': ['/tmp/binarydeb/ros-kinetic-sensor-msgs-1.12.5/msg']} + +// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types'] + + + + +template +struct IsFixedSize< ::sensor_msgs::Range_ > + : FalseType + { }; + +template +struct IsFixedSize< ::sensor_msgs::Range_ const> + : FalseType + { }; + +template +struct IsMessage< ::sensor_msgs::Range_ > + : TrueType + { }; + +template +struct IsMessage< ::sensor_msgs::Range_ const> + : TrueType + { }; + +template +struct HasHeader< ::sensor_msgs::Range_ > + : TrueType + { }; + +template +struct HasHeader< ::sensor_msgs::Range_ const> + : TrueType + { }; + + +template +struct MD5Sum< ::sensor_msgs::Range_ > +{ + static const char* value() + { + return "c005c34273dc426c67a020a87bc24148"; + } + + static const char* value(const ::sensor_msgs::Range_&) { return value(); } + static const uint64_t static_value1 = 0xc005c34273dc426cULL; + static const uint64_t static_value2 = 0x67a020a87bc24148ULL; +}; + +template +struct DataType< ::sensor_msgs::Range_ > +{ + static const char* value() + { + return "sensor_msgs/Range"; + } + + static const char* value(const ::sensor_msgs::Range_&) { return value(); } +}; + +template +struct Definition< ::sensor_msgs::Range_ > +{ + static const char* value() + { + return "# Single range reading from an active ranger that emits energy and reports\n\ +# one range reading that is valid along an arc at the distance measured. \n\ +# This message is not appropriate for laser scanners. See the LaserScan\n\ +# message if you are working with a laser scanner.\n\ +\n\ +# This message also can represent a fixed-distance (binary) ranger. This\n\ +# sensor will have min_range===max_range===distance of detection.\n\ +# These sensors follow REP 117 and will output -Inf if the object is detected\n\ +# and +Inf if the object is outside of the detection range.\n\ +\n\ +Header header # timestamp in the header is the time the ranger\n\ + # returned the distance reading\n\ +\n\ +# Radiation type enums\n\ +# If you want a value added to this list, send an email to the ros-users list\n\ +uint8 ULTRASOUND=0\n\ +uint8 INFRARED=1\n\ +\n\ +uint8 radiation_type # the type of radiation used by the sensor\n\ + # (sound, IR, etc) [enum]\n\ +\n\ +float32 field_of_view # the size of the arc that the distance reading is\n\ + # valid for [rad]\n\ + # the object causing the range reading may have\n\ + # been anywhere within -field_of_view/2 and\n\ + # field_of_view/2 at the measured range. \n\ + # 0 angle corresponds to the x-axis of the sensor.\n\ +\n\ +float32 min_range # minimum range value [m]\n\ +float32 max_range # maximum range value [m]\n\ + # Fixed distance rangers require min_range==max_range\n\ +\n\ +float32 range # range data [m]\n\ + # (Note: values < range_min or > range_max\n\ + # should be discarded)\n\ + # Fixed distance rangers only output -Inf or +Inf.\n\ + # -Inf represents a detection within fixed distance.\n\ + # (Detection too close to the sensor to quantify)\n\ + # +Inf represents no detection within the fixed distance.\n\ + # (Object out of range)\n\ +================================================================================\n\ +MSG: std_msgs/Header\n\ +# Standard metadata for higher-level stamped data types.\n\ +# This is generally used to communicate timestamped data \n\ +# in a particular coordinate frame.\n\ +# \n\ +# sequence ID: consecutively increasing ID \n\ +uint32 seq\n\ +#Two-integer timestamp that is expressed as:\n\ +# * stamp.sec: seconds (stamp_secs) since epoch (in Python the variable is called 'secs')\n\ +# * stamp.nsec: nanoseconds since stamp_secs (in Python the variable is called 'nsecs')\n\ +# time-handling sugar is provided by the client library\n\ +time stamp\n\ +#Frame this data is associated with\n\ +# 0: no frame\n\ +# 1: global frame\n\ +string frame_id\n\ +"; + } + + static const char* value(const ::sensor_msgs::Range_&) { return value(); } +}; + +} // namespace message_traits +} // namespace ros + +namespace ros +{ +namespace serialization +{ + + template struct Serializer< ::sensor_msgs::Range_ > + { + template inline static void allInOne(Stream& stream, T m) + { + stream.next(m.header); + stream.next(m.radiation_type); + stream.next(m.field_of_view); + stream.next(m.min_range); + stream.next(m.max_range); + stream.next(m.range); + } + + ROS_DECLARE_ALLINONE_SERIALIZER; + }; // struct Range_ + +} // namespace serialization +} // namespace ros + +namespace ros +{ +namespace message_operations +{ + +template +struct Printer< ::sensor_msgs::Range_ > +{ + template static void stream(Stream& s, const std::string& indent, const ::sensor_msgs::Range_& v) + { + s << indent << "header: "; + s << std::endl; + Printer< ::std_msgs::Header_ >::stream(s, indent + " ", v.header); + s << indent << "radiation_type: "; + Printer::stream(s, indent + " ", v.radiation_type); + s << indent << "field_of_view: "; + Printer::stream(s, indent + " ", v.field_of_view); + s << indent << "min_range: "; + Printer::stream(s, indent + " ", v.min_range); + s << indent << "max_range: "; + Printer::stream(s, indent + " ", v.max_range); + s << indent << "range: "; + Printer::stream(s, indent + " ", v.range); + } +}; + +} // namespace message_operations +} // namespace ros + +#endif // SENSOR_MSGS_MESSAGE_RANGE_H diff --git a/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/RegionOfInterest.h b/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/RegionOfInterest.h new file mode 100644 index 0000000000..92941ef606 --- /dev/null +++ b/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/RegionOfInterest.h @@ -0,0 +1,236 @@ +// Generated by gencpp from file sensor_msgs/RegionOfInterest.msg +// DO NOT EDIT! + + +#ifndef SENSOR_MSGS_MESSAGE_REGIONOFINTEREST_H +#define SENSOR_MSGS_MESSAGE_REGIONOFINTEREST_H + + +#include +#include +#include + +#include +#include +#include +#include + + +namespace sensor_msgs +{ +template +struct RegionOfInterest_ +{ + typedef RegionOfInterest_ Type; + + RegionOfInterest_() + : x_offset(0) + , y_offset(0) + , height(0) + , width(0) + , do_rectify(false) { + } + RegionOfInterest_(const ContainerAllocator& _alloc) + : x_offset(0) + , y_offset(0) + , height(0) + , width(0) + , do_rectify(false) { + (void)_alloc; + } + + + + typedef uint32_t _x_offset_type; + _x_offset_type x_offset; + + typedef uint32_t _y_offset_type; + _y_offset_type y_offset; + + typedef uint32_t _height_type; + _height_type height; + + typedef uint32_t _width_type; + _width_type width; + + typedef uint8_t _do_rectify_type; + _do_rectify_type do_rectify; + + + + + typedef std::shared_ptr< ::sensor_msgs::RegionOfInterest_ > Ptr; + typedef std::shared_ptr< ::sensor_msgs::RegionOfInterest_ const> ConstPtr; + +}; // struct RegionOfInterest_ + +typedef ::sensor_msgs::RegionOfInterest_ > RegionOfInterest; + +typedef std::shared_ptr< ::sensor_msgs::RegionOfInterest > RegionOfInterestPtr; +typedef std::shared_ptr< ::sensor_msgs::RegionOfInterest const> RegionOfInterestConstPtr; + +// constants requiring out of line definition + + + +template +std::ostream& operator<<(std::ostream& s, const ::sensor_msgs::RegionOfInterest_ & v) +{ +ros::message_operations::Printer< ::sensor_msgs::RegionOfInterest_ >::stream(s, "", v); +return s; +} + +} // namespace sensor_msgs + +namespace ros +{ +namespace message_traits +{ + + + +// BOOLTRAITS {'IsFixedSize': True, 'IsMessage': True, 'HasHeader': False} +// {'std_msgs': ['/opt/ros/kinetic/share/std_msgs/cmake/../msg'], 'geometry_msgs': ['/opt/ros/kinetic/share/geometry_msgs/cmake/../msg'], 'sensor_msgs': ['/tmp/binarydeb/ros-kinetic-sensor-msgs-1.12.5/msg']} + +// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types'] + + + + +template +struct IsFixedSize< ::sensor_msgs::RegionOfInterest_ > + : TrueType + { }; + +template +struct IsFixedSize< ::sensor_msgs::RegionOfInterest_ const> + : TrueType + { }; + +template +struct IsMessage< ::sensor_msgs::RegionOfInterest_ > + : TrueType + { }; + +template +struct IsMessage< ::sensor_msgs::RegionOfInterest_ const> + : TrueType + { }; + +template +struct HasHeader< ::sensor_msgs::RegionOfInterest_ > + : FalseType + { }; + +template +struct HasHeader< ::sensor_msgs::RegionOfInterest_ const> + : FalseType + { }; + + +template +struct MD5Sum< ::sensor_msgs::RegionOfInterest_ > +{ + static const char* value() + { + return "bdb633039d588fcccb441a4d43ccfe09"; + } + + static const char* value(const ::sensor_msgs::RegionOfInterest_&) { return value(); } + static const uint64_t static_value1 = 0xbdb633039d588fccULL; + static const uint64_t static_value2 = 0xcb441a4d43ccfe09ULL; +}; + +template +struct DataType< ::sensor_msgs::RegionOfInterest_ > +{ + static const char* value() + { + return "sensor_msgs/RegionOfInterest"; + } + + static const char* value(const ::sensor_msgs::RegionOfInterest_&) { return value(); } +}; + +template +struct Definition< ::sensor_msgs::RegionOfInterest_ > +{ + static const char* value() + { + return "# This message is used to specify a region of interest within an image.\n\ +#\n\ +# When used to specify the ROI setting of the camera when the image was\n\ +# taken, the height and width fields should either match the height and\n\ +# width fields for the associated image; or height = width = 0\n\ +# indicates that the full resolution image was captured.\n\ +\n\ +uint32 x_offset # Leftmost pixel of the ROI\n\ + # (0 if the ROI includes the left edge of the image)\n\ +uint32 y_offset # Topmost pixel of the ROI\n\ + # (0 if the ROI includes the top edge of the image)\n\ +uint32 height # Height of ROI\n\ +uint32 width # Width of ROI\n\ +\n\ +# True if a distinct rectified ROI should be calculated from the \"raw\"\n\ +# ROI in this message. Typically this should be False if the full image\n\ +# is captured (ROI not used), and True if a subwindow is captured (ROI\n\ +# used).\n\ +bool do_rectify\n\ +"; + } + + static const char* value(const ::sensor_msgs::RegionOfInterest_&) { return value(); } +}; + +} // namespace message_traits +} // namespace ros + +namespace ros +{ +namespace serialization +{ + + template struct Serializer< ::sensor_msgs::RegionOfInterest_ > + { + template inline static void allInOne(Stream& stream, T m) + { + stream.next(m.x_offset); + stream.next(m.y_offset); + stream.next(m.height); + stream.next(m.width); + stream.next(m.do_rectify); + } + + ROS_DECLARE_ALLINONE_SERIALIZER; + }; // struct RegionOfInterest_ + +} // namespace serialization +} // namespace ros + +namespace ros +{ +namespace message_operations +{ + +template +struct Printer< ::sensor_msgs::RegionOfInterest_ > +{ + template static void stream(Stream& s, const std::string& indent, const ::sensor_msgs::RegionOfInterest_& v) + { + s << indent << "x_offset: "; + Printer::stream(s, indent + " ", v.x_offset); + s << indent << "y_offset: "; + Printer::stream(s, indent + " ", v.y_offset); + s << indent << "height: "; + Printer::stream(s, indent + " ", v.height); + s << indent << "width: "; + Printer::stream(s, indent + " ", v.width); + s << indent << "do_rectify: "; + Printer::stream(s, indent + " ", v.do_rectify); + } +}; + +} // namespace message_operations +} // namespace ros + +#endif // SENSOR_MSGS_MESSAGE_REGIONOFINTEREST_H diff --git a/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/RelativeHumidity.h b/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/RelativeHumidity.h new file mode 100644 index 0000000000..706c5651c9 --- /dev/null +++ b/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/RelativeHumidity.h @@ -0,0 +1,232 @@ +// Generated by gencpp from file sensor_msgs/RelativeHumidity.msg +// DO NOT EDIT! + + +#ifndef SENSOR_MSGS_MESSAGE_RELATIVEHUMIDITY_H +#define SENSOR_MSGS_MESSAGE_RELATIVEHUMIDITY_H + + +#include +#include +#include + +#include +#include +#include +#include + +#include + +namespace sensor_msgs +{ +template +struct RelativeHumidity_ +{ + typedef RelativeHumidity_ Type; + + RelativeHumidity_() + : header() + , relative_humidity(0.0) + , variance(0.0) { + } + RelativeHumidity_(const ContainerAllocator& _alloc) + : header(_alloc) + , relative_humidity(0.0) + , variance(0.0) { + (void)_alloc; + } + + + + typedef ::std_msgs::Header_ _header_type; + _header_type header; + + typedef double _relative_humidity_type; + _relative_humidity_type relative_humidity; + + typedef double _variance_type; + _variance_type variance; + + + + + typedef boost::shared_ptr< ::sensor_msgs::RelativeHumidity_ > Ptr; + typedef boost::shared_ptr< ::sensor_msgs::RelativeHumidity_ const> ConstPtr; + +}; // struct RelativeHumidity_ + +typedef ::sensor_msgs::RelativeHumidity_ > RelativeHumidity; + +typedef boost::shared_ptr< ::sensor_msgs::RelativeHumidity > RelativeHumidityPtr; +typedef boost::shared_ptr< ::sensor_msgs::RelativeHumidity const> RelativeHumidityConstPtr; + +// constants requiring out of line definition + + + +template +std::ostream& operator<<(std::ostream& s, const ::sensor_msgs::RelativeHumidity_ & v) +{ +ros::message_operations::Printer< ::sensor_msgs::RelativeHumidity_ >::stream(s, "", v); +return s; +} + +} // namespace sensor_msgs + +namespace ros +{ +namespace message_traits +{ + + + +// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': True} +// {'std_msgs': ['/opt/ros/kinetic/share/std_msgs/cmake/../msg'], 'geometry_msgs': ['/opt/ros/kinetic/share/geometry_msgs/cmake/../msg'], 'sensor_msgs': ['/tmp/binarydeb/ros-kinetic-sensor-msgs-1.12.5/msg']} + +// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types'] + + + + +template +struct IsFixedSize< ::sensor_msgs::RelativeHumidity_ > + : FalseType + { }; + +template +struct IsFixedSize< ::sensor_msgs::RelativeHumidity_ const> + : FalseType + { }; + +template +struct IsMessage< ::sensor_msgs::RelativeHumidity_ > + : TrueType + { }; + +template +struct IsMessage< ::sensor_msgs::RelativeHumidity_ const> + : TrueType + { }; + +template +struct HasHeader< ::sensor_msgs::RelativeHumidity_ > + : TrueType + { }; + +template +struct HasHeader< ::sensor_msgs::RelativeHumidity_ const> + : TrueType + { }; + + +template +struct MD5Sum< ::sensor_msgs::RelativeHumidity_ > +{ + static const char* value() + { + return "8730015b05955b7e992ce29a2678d90f"; + } + + static const char* value(const ::sensor_msgs::RelativeHumidity_&) { return value(); } + static const uint64_t static_value1 = 0x8730015b05955b7eULL; + static const uint64_t static_value2 = 0x992ce29a2678d90fULL; +}; + +template +struct DataType< ::sensor_msgs::RelativeHumidity_ > +{ + static const char* value() + { + return "sensor_msgs/RelativeHumidity"; + } + + static const char* value(const ::sensor_msgs::RelativeHumidity_&) { return value(); } +}; + +template +struct Definition< ::sensor_msgs::RelativeHumidity_ > +{ + static const char* value() + { + return " # Single reading from a relative humidity sensor. Defines the ratio of partial\n\ + # pressure of water vapor to the saturated vapor pressure at a temperature.\n\ +\n\ + Header header # timestamp of the measurement\n\ + # frame_id is the location of the humidity sensor\n\ +\n\ + float64 relative_humidity # Expression of the relative humidity\n\ + # from 0.0 to 1.0.\n\ + # 0.0 is no partial pressure of water vapor\n\ + # 1.0 represents partial pressure of saturation\n\ +\n\ + float64 variance # 0 is interpreted as variance unknown\n\ +================================================================================\n\ +MSG: std_msgs/Header\n\ +# Standard metadata for higher-level stamped data types.\n\ +# This is generally used to communicate timestamped data \n\ +# in a particular coordinate frame.\n\ +# \n\ +# sequence ID: consecutively increasing ID \n\ +uint32 seq\n\ +#Two-integer timestamp that is expressed as:\n\ +# * stamp.sec: seconds (stamp_secs) since epoch (in Python the variable is called 'secs')\n\ +# * stamp.nsec: nanoseconds since stamp_secs (in Python the variable is called 'nsecs')\n\ +# time-handling sugar is provided by the client library\n\ +time stamp\n\ +#Frame this data is associated with\n\ +# 0: no frame\n\ +# 1: global frame\n\ +string frame_id\n\ +"; + } + + static const char* value(const ::sensor_msgs::RelativeHumidity_&) { return value(); } +}; + +} // namespace message_traits +} // namespace ros + +namespace ros +{ +namespace serialization +{ + + template struct Serializer< ::sensor_msgs::RelativeHumidity_ > + { + template inline static void allInOne(Stream& stream, T m) + { + stream.next(m.header); + stream.next(m.relative_humidity); + stream.next(m.variance); + } + + ROS_DECLARE_ALLINONE_SERIALIZER; + }; // struct RelativeHumidity_ + +} // namespace serialization +} // namespace ros + +namespace ros +{ +namespace message_operations +{ + +template +struct Printer< ::sensor_msgs::RelativeHumidity_ > +{ + template static void stream(Stream& s, const std::string& indent, const ::sensor_msgs::RelativeHumidity_& v) + { + s << indent << "header: "; + s << std::endl; + Printer< ::std_msgs::Header_ >::stream(s, indent + " ", v.header); + s << indent << "relative_humidity: "; + Printer::stream(s, indent + " ", v.relative_humidity); + s << indent << "variance: "; + Printer::stream(s, indent + " ", v.variance); + } +}; + +} // namespace message_operations +} // namespace ros + +#endif // SENSOR_MSGS_MESSAGE_RELATIVEHUMIDITY_H diff --git a/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/SetCameraInfo.h b/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/SetCameraInfo.h new file mode 100644 index 0000000000..2e4c1676da --- /dev/null +++ b/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/SetCameraInfo.h @@ -0,0 +1,123 @@ +// Generated by gencpp from file sensor_msgs/SetCameraInfo.msg +// DO NOT EDIT! + + +#ifndef SENSOR_MSGS_MESSAGE_SETCAMERAINFO_H +#define SENSOR_MSGS_MESSAGE_SETCAMERAINFO_H + +#include + + +#include +#include + + +namespace sensor_msgs +{ + +struct SetCameraInfo +{ + +typedef SetCameraInfoRequest Request; +typedef SetCameraInfoResponse Response; +Request request; +Response response; + +typedef Request RequestType; +typedef Response ResponseType; + +}; // struct SetCameraInfo +} // namespace sensor_msgs + + +namespace ros +{ +namespace service_traits +{ + + +template<> +struct MD5Sum< ::sensor_msgs::SetCameraInfo > { + static const char* value() + { + return "bef1df590ed75ed1f393692395e15482"; + } + + static const char* value(const ::sensor_msgs::SetCameraInfo&) { return value(); } +}; + +template<> +struct DataType< ::sensor_msgs::SetCameraInfo > { + static const char* value() + { + return "sensor_msgs/SetCameraInfo"; + } + + static const char* value(const ::sensor_msgs::SetCameraInfo&) { return value(); } +}; + + +// service_traits::MD5Sum< ::sensor_msgs::SetCameraInfoRequest> should match +// service_traits::MD5Sum< ::sensor_msgs::SetCameraInfo > +template<> +struct MD5Sum< ::sensor_msgs::SetCameraInfoRequest> +{ + static const char* value() + { + return MD5Sum< ::sensor_msgs::SetCameraInfo >::value(); + } + static const char* value(const ::sensor_msgs::SetCameraInfoRequest&) + { + return value(); + } +}; + +// service_traits::DataType< ::sensor_msgs::SetCameraInfoRequest> should match +// service_traits::DataType< ::sensor_msgs::SetCameraInfo > +template<> +struct DataType< ::sensor_msgs::SetCameraInfoRequest> +{ + static const char* value() + { + return DataType< ::sensor_msgs::SetCameraInfo >::value(); + } + static const char* value(const ::sensor_msgs::SetCameraInfoRequest&) + { + return value(); + } +}; + +// service_traits::MD5Sum< ::sensor_msgs::SetCameraInfoResponse> should match +// service_traits::MD5Sum< ::sensor_msgs::SetCameraInfo > +template<> +struct MD5Sum< ::sensor_msgs::SetCameraInfoResponse> +{ + static const char* value() + { + return MD5Sum< ::sensor_msgs::SetCameraInfo >::value(); + } + static const char* value(const ::sensor_msgs::SetCameraInfoResponse&) + { + return value(); + } +}; + +// service_traits::DataType< ::sensor_msgs::SetCameraInfoResponse> should match +// service_traits::DataType< ::sensor_msgs::SetCameraInfo > +template<> +struct DataType< ::sensor_msgs::SetCameraInfoResponse> +{ + static const char* value() + { + return DataType< ::sensor_msgs::SetCameraInfo >::value(); + } + static const char* value(const ::sensor_msgs::SetCameraInfoResponse&) + { + return value(); + } +}; + +} // namespace service_traits +} // namespace ros + +#endif // SENSOR_MSGS_MESSAGE_SETCAMERAINFO_H diff --git a/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/SetCameraInfoRequest.h b/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/SetCameraInfoRequest.h new file mode 100644 index 0000000000..d01c3bc61b --- /dev/null +++ b/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/SetCameraInfoRequest.h @@ -0,0 +1,370 @@ +// Generated by gencpp from file sensor_msgs/SetCameraInfoRequest.msg +// DO NOT EDIT! + + +#ifndef SENSOR_MSGS_MESSAGE_SETCAMERAINFOREQUEST_H +#define SENSOR_MSGS_MESSAGE_SETCAMERAINFOREQUEST_H + + +#include +#include +#include + +#include +#include +#include +#include + +#include + +namespace sensor_msgs +{ +template +struct SetCameraInfoRequest_ +{ + typedef SetCameraInfoRequest_ Type; + + SetCameraInfoRequest_() + : camera_info() { + } + SetCameraInfoRequest_(const ContainerAllocator& _alloc) + : camera_info(_alloc) { + (void)_alloc; + } + + + + typedef ::sensor_msgs::CameraInfo_ _camera_info_type; + _camera_info_type camera_info; + + + + + typedef boost::shared_ptr< ::sensor_msgs::SetCameraInfoRequest_ > Ptr; + typedef boost::shared_ptr< ::sensor_msgs::SetCameraInfoRequest_ const> ConstPtr; + +}; // struct SetCameraInfoRequest_ + +typedef ::sensor_msgs::SetCameraInfoRequest_ > SetCameraInfoRequest; + +typedef boost::shared_ptr< ::sensor_msgs::SetCameraInfoRequest > SetCameraInfoRequestPtr; +typedef boost::shared_ptr< ::sensor_msgs::SetCameraInfoRequest const> SetCameraInfoRequestConstPtr; + +// constants requiring out of line definition + + + +template +std::ostream& operator<<(std::ostream& s, const ::sensor_msgs::SetCameraInfoRequest_ & v) +{ +ros::message_operations::Printer< ::sensor_msgs::SetCameraInfoRequest_ >::stream(s, "", v); +return s; +} + +} // namespace sensor_msgs + +namespace ros +{ +namespace message_traits +{ + + + +// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': False} +// {'std_msgs': ['/opt/ros/kinetic/share/std_msgs/cmake/../msg'], 'geometry_msgs': ['/opt/ros/kinetic/share/geometry_msgs/cmake/../msg'], 'sensor_msgs': ['/tmp/binarydeb/ros-kinetic-sensor-msgs-1.12.5/msg']} + +// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types'] + + + + +template +struct IsFixedSize< ::sensor_msgs::SetCameraInfoRequest_ > + : FalseType + { }; + +template +struct IsFixedSize< ::sensor_msgs::SetCameraInfoRequest_ const> + : FalseType + { }; + +template +struct IsMessage< ::sensor_msgs::SetCameraInfoRequest_ > + : TrueType + { }; + +template +struct IsMessage< ::sensor_msgs::SetCameraInfoRequest_ const> + : TrueType + { }; + +template +struct HasHeader< ::sensor_msgs::SetCameraInfoRequest_ > + : FalseType + { }; + +template +struct HasHeader< ::sensor_msgs::SetCameraInfoRequest_ const> + : FalseType + { }; + + +template +struct MD5Sum< ::sensor_msgs::SetCameraInfoRequest_ > +{ + static const char* value() + { + return "ee34be01fdeee563d0d99cd594d5581d"; + } + + static const char* value(const ::sensor_msgs::SetCameraInfoRequest_&) { return value(); } + static const uint64_t static_value1 = 0xee34be01fdeee563ULL; + static const uint64_t static_value2 = 0xd0d99cd594d5581dULL; +}; + +template +struct DataType< ::sensor_msgs::SetCameraInfoRequest_ > +{ + static const char* value() + { + return "sensor_msgs/SetCameraInfoRequest"; + } + + static const char* value(const ::sensor_msgs::SetCameraInfoRequest_&) { return value(); } +}; + +template +struct Definition< ::sensor_msgs::SetCameraInfoRequest_ > +{ + static const char* value() + { + return "\n\ +\n\ +\n\ +\n\ +\n\ +\n\ +\n\ +\n\ +sensor_msgs/CameraInfo camera_info\n\ +\n\ +================================================================================\n\ +MSG: sensor_msgs/CameraInfo\n\ +# This message defines meta information for a camera. It should be in a\n\ +# camera namespace on topic \"camera_info\" and accompanied by up to five\n\ +# image topics named:\n\ +#\n\ +# image_raw - raw data from the camera driver, possibly Bayer encoded\n\ +# image - monochrome, distorted\n\ +# image_color - color, distorted\n\ +# image_rect - monochrome, rectified\n\ +# image_rect_color - color, rectified\n\ +#\n\ +# The image_pipeline contains packages (image_proc, stereo_image_proc)\n\ +# for producing the four processed image topics from image_raw and\n\ +# camera_info. The meaning of the camera parameters are described in\n\ +# detail at http://www.ros.org/wiki/image_pipeline/CameraInfo.\n\ +#\n\ +# The image_geometry package provides a user-friendly interface to\n\ +# common operations using this meta information. If you want to, e.g.,\n\ +# project a 3d point into image coordinates, we strongly recommend\n\ +# using image_geometry.\n\ +#\n\ +# If the camera is uncalibrated, the matrices D, K, R, P should be left\n\ +# zeroed out. In particular, clients may assume that K[0] == 0.0\n\ +# indicates an uncalibrated camera.\n\ +\n\ +#######################################################################\n\ +# Image acquisition info #\n\ +#######################################################################\n\ +\n\ +# Time of image acquisition, camera coordinate frame ID\n\ +Header header # Header timestamp should be acquisition time of image\n\ + # Header frame_id should be optical frame of camera\n\ + # origin of frame should be optical center of camera\n\ + # +x should point to the right in the image\n\ + # +y should point down in the image\n\ + # +z should point into the plane of the image\n\ +\n\ +\n\ +#######################################################################\n\ +# Calibration Parameters #\n\ +#######################################################################\n\ +# These are fixed during camera calibration. Their values will be the #\n\ +# same in all messages until the camera is recalibrated. Note that #\n\ +# self-calibrating systems may \"recalibrate\" frequently. #\n\ +# #\n\ +# The internal parameters can be used to warp a raw (distorted) image #\n\ +# to: #\n\ +# 1. An undistorted image (requires D and K) #\n\ +# 2. A rectified image (requires D, K, R) #\n\ +# The projection matrix P projects 3D points into the rectified image.#\n\ +#######################################################################\n\ +\n\ +# The image dimensions with which the camera was calibrated. Normally\n\ +# this will be the full camera resolution in pixels.\n\ +uint32 height\n\ +uint32 width\n\ +\n\ +# The distortion model used. Supported models are listed in\n\ +# sensor_msgs/distortion_models.h. For most cameras, \"plumb_bob\" - a\n\ +# simple model of radial and tangential distortion - is sufficient.\n\ +string distortion_model\n\ +\n\ +# The distortion parameters, size depending on the distortion model.\n\ +# For \"plumb_bob\", the 5 parameters are: (k1, k2, t1, t2, k3).\n\ +float64[] D\n\ +\n\ +# Intrinsic camera matrix for the raw (distorted) images.\n\ +# [fx 0 cx]\n\ +# K = [ 0 fy cy]\n\ +# [ 0 0 1]\n\ +# Projects 3D points in the camera coordinate frame to 2D pixel\n\ +# coordinates using the focal lengths (fx, fy) and principal point\n\ +# (cx, cy).\n\ +float64[9] K # 3x3 row-major matrix\n\ +\n\ +# Rectification matrix (stereo cameras only)\n\ +# A rotation matrix aligning the camera coordinate system to the ideal\n\ +# stereo image plane so that epipolar lines in both stereo images are\n\ +# parallel.\n\ +float64[9] R # 3x3 row-major matrix\n\ +\n\ +# Projection/camera matrix\n\ +# [fx' 0 cx' Tx]\n\ +# P = [ 0 fy' cy' Ty]\n\ +# [ 0 0 1 0]\n\ +# By convention, this matrix specifies the intrinsic (camera) matrix\n\ +# of the processed (rectified) image. That is, the left 3x3 portion\n\ +# is the normal camera intrinsic matrix for the rectified image.\n\ +# It projects 3D points in the camera coordinate frame to 2D pixel\n\ +# coordinates using the focal lengths (fx', fy') and principal point\n\ +# (cx', cy') - these may differ from the values in K.\n\ +# For monocular cameras, Tx = Ty = 0. Normally, monocular cameras will\n\ +# also have R = the identity and P[1:3,1:3] = K.\n\ +# For a stereo pair, the fourth column [Tx Ty 0]' is related to the\n\ +# position of the optical center of the second camera in the first\n\ +# camera's frame. We assume Tz = 0 so both cameras are in the same\n\ +# stereo image plane. The first camera always has Tx = Ty = 0. For\n\ +# the right (second) camera of a horizontal stereo pair, Ty = 0 and\n\ +# Tx = -fx' * B, where B is the baseline between the cameras.\n\ +# Given a 3D point [X Y Z]', the projection (x, y) of the point onto\n\ +# the rectified image is given by:\n\ +# [u v w]' = P * [X Y Z 1]'\n\ +# x = u / w\n\ +# y = v / w\n\ +# This holds for both images of a stereo pair.\n\ +float64[12] P # 3x4 row-major matrix\n\ +\n\ +\n\ +#######################################################################\n\ +# Operational Parameters #\n\ +#######################################################################\n\ +# These define the image region actually captured by the camera #\n\ +# driver. Although they affect the geometry of the output image, they #\n\ +# may be changed freely without recalibrating the camera. #\n\ +#######################################################################\n\ +\n\ +# Binning refers here to any camera setting which combines rectangular\n\ +# neighborhoods of pixels into larger \"super-pixels.\" It reduces the\n\ +# resolution of the output image to\n\ +# (width / binning_x) x (height / binning_y).\n\ +# The default values binning_x = binning_y = 0 is considered the same\n\ +# as binning_x = binning_y = 1 (no subsampling).\n\ +uint32 binning_x\n\ +uint32 binning_y\n\ +\n\ +# Region of interest (subwindow of full camera resolution), given in\n\ +# full resolution (unbinned) image coordinates. A particular ROI\n\ +# always denotes the same window of pixels on the camera sensor,\n\ +# regardless of binning settings.\n\ +# The default setting of roi (all values 0) is considered the same as\n\ +# full resolution (roi.width = width, roi.height = height).\n\ +RegionOfInterest roi\n\ +\n\ +================================================================================\n\ +MSG: std_msgs/Header\n\ +# Standard metadata for higher-level stamped data types.\n\ +# This is generally used to communicate timestamped data \n\ +# in a particular coordinate frame.\n\ +# \n\ +# sequence ID: consecutively increasing ID \n\ +uint32 seq\n\ +#Two-integer timestamp that is expressed as:\n\ +# * stamp.sec: seconds (stamp_secs) since epoch (in Python the variable is called 'secs')\n\ +# * stamp.nsec: nanoseconds since stamp_secs (in Python the variable is called 'nsecs')\n\ +# time-handling sugar is provided by the client library\n\ +time stamp\n\ +#Frame this data is associated with\n\ +# 0: no frame\n\ +# 1: global frame\n\ +string frame_id\n\ +\n\ +================================================================================\n\ +MSG: sensor_msgs/RegionOfInterest\n\ +# This message is used to specify a region of interest within an image.\n\ +#\n\ +# When used to specify the ROI setting of the camera when the image was\n\ +# taken, the height and width fields should either match the height and\n\ +# width fields for the associated image; or height = width = 0\n\ +# indicates that the full resolution image was captured.\n\ +\n\ +uint32 x_offset # Leftmost pixel of the ROI\n\ + # (0 if the ROI includes the left edge of the image)\n\ +uint32 y_offset # Topmost pixel of the ROI\n\ + # (0 if the ROI includes the top edge of the image)\n\ +uint32 height # Height of ROI\n\ +uint32 width # Width of ROI\n\ +\n\ +# True if a distinct rectified ROI should be calculated from the \"raw\"\n\ +# ROI in this message. Typically this should be False if the full image\n\ +# is captured (ROI not used), and True if a subwindow is captured (ROI\n\ +# used).\n\ +bool do_rectify\n\ +"; + } + + static const char* value(const ::sensor_msgs::SetCameraInfoRequest_&) { return value(); } +}; + +} // namespace message_traits +} // namespace ros + +namespace ros +{ +namespace serialization +{ + + template struct Serializer< ::sensor_msgs::SetCameraInfoRequest_ > + { + template inline static void allInOne(Stream& stream, T m) + { + stream.next(m.camera_info); + } + + ROS_DECLARE_ALLINONE_SERIALIZER; + }; // struct SetCameraInfoRequest_ + +} // namespace serialization +} // namespace ros + +namespace ros +{ +namespace message_operations +{ + +template +struct Printer< ::sensor_msgs::SetCameraInfoRequest_ > +{ + template static void stream(Stream& s, const std::string& indent, const ::sensor_msgs::SetCameraInfoRequest_& v) + { + s << indent << "camera_info: "; + s << std::endl; + Printer< ::sensor_msgs::CameraInfo_ >::stream(s, indent + " ", v.camera_info); + } +}; + +} // namespace message_operations +} // namespace ros + +#endif // SENSOR_MSGS_MESSAGE_SETCAMERAINFOREQUEST_H diff --git a/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/SetCameraInfoResponse.h b/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/SetCameraInfoResponse.h new file mode 100644 index 0000000000..9178452fac --- /dev/null +++ b/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/SetCameraInfoResponse.h @@ -0,0 +1,196 @@ +// Generated by gencpp from file sensor_msgs/SetCameraInfoResponse.msg +// DO NOT EDIT! + + +#ifndef SENSOR_MSGS_MESSAGE_SETCAMERAINFORESPONSE_H +#define SENSOR_MSGS_MESSAGE_SETCAMERAINFORESPONSE_H + + +#include +#include +#include + +#include +#include +#include +#include + + +namespace sensor_msgs +{ +template +struct SetCameraInfoResponse_ +{ + typedef SetCameraInfoResponse_ Type; + + SetCameraInfoResponse_() + : success(false) + , status_message() { + } + SetCameraInfoResponse_(const ContainerAllocator& _alloc) + : success(false) + , status_message(_alloc) { + (void)_alloc; + } + + + + typedef uint8_t _success_type; + _success_type success; + + typedef std::basic_string, typename ContainerAllocator::template rebind::other > _status_message_type; + _status_message_type status_message; + + + + + typedef boost::shared_ptr< ::sensor_msgs::SetCameraInfoResponse_ > Ptr; + typedef boost::shared_ptr< ::sensor_msgs::SetCameraInfoResponse_ const> ConstPtr; + +}; // struct SetCameraInfoResponse_ + +typedef ::sensor_msgs::SetCameraInfoResponse_ > SetCameraInfoResponse; + +typedef boost::shared_ptr< ::sensor_msgs::SetCameraInfoResponse > SetCameraInfoResponsePtr; +typedef boost::shared_ptr< ::sensor_msgs::SetCameraInfoResponse const> SetCameraInfoResponseConstPtr; + +// constants requiring out of line definition + + + +template +std::ostream& operator<<(std::ostream& s, const ::sensor_msgs::SetCameraInfoResponse_ & v) +{ +ros::message_operations::Printer< ::sensor_msgs::SetCameraInfoResponse_ >::stream(s, "", v); +return s; +} + +} // namespace sensor_msgs + +namespace ros +{ +namespace message_traits +{ + + + +// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': False} +// {'std_msgs': ['/opt/ros/kinetic/share/std_msgs/cmake/../msg'], 'geometry_msgs': ['/opt/ros/kinetic/share/geometry_msgs/cmake/../msg'], 'sensor_msgs': ['/tmp/binarydeb/ros-kinetic-sensor-msgs-1.12.5/msg']} + +// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types'] + + + + +template +struct IsFixedSize< ::sensor_msgs::SetCameraInfoResponse_ > + : FalseType + { }; + +template +struct IsFixedSize< ::sensor_msgs::SetCameraInfoResponse_ const> + : FalseType + { }; + +template +struct IsMessage< ::sensor_msgs::SetCameraInfoResponse_ > + : TrueType + { }; + +template +struct IsMessage< ::sensor_msgs::SetCameraInfoResponse_ const> + : TrueType + { }; + +template +struct HasHeader< ::sensor_msgs::SetCameraInfoResponse_ > + : FalseType + { }; + +template +struct HasHeader< ::sensor_msgs::SetCameraInfoResponse_ const> + : FalseType + { }; + + +template +struct MD5Sum< ::sensor_msgs::SetCameraInfoResponse_ > +{ + static const char* value() + { + return "2ec6f3eff0161f4257b808b12bc830c2"; + } + + static const char* value(const ::sensor_msgs::SetCameraInfoResponse_&) { return value(); } + static const uint64_t static_value1 = 0x2ec6f3eff0161f42ULL; + static const uint64_t static_value2 = 0x57b808b12bc830c2ULL; +}; + +template +struct DataType< ::sensor_msgs::SetCameraInfoResponse_ > +{ + static const char* value() + { + return "sensor_msgs/SetCameraInfoResponse"; + } + + static const char* value(const ::sensor_msgs::SetCameraInfoResponse_&) { return value(); } +}; + +template +struct Definition< ::sensor_msgs::SetCameraInfoResponse_ > +{ + static const char* value() + { + return "bool success\n\ +string status_message\n\ +\n\ +"; + } + + static const char* value(const ::sensor_msgs::SetCameraInfoResponse_&) { return value(); } +}; + +} // namespace message_traits +} // namespace ros + +namespace ros +{ +namespace serialization +{ + + template struct Serializer< ::sensor_msgs::SetCameraInfoResponse_ > + { + template inline static void allInOne(Stream& stream, T m) + { + stream.next(m.success); + stream.next(m.status_message); + } + + ROS_DECLARE_ALLINONE_SERIALIZER; + }; // struct SetCameraInfoResponse_ + +} // namespace serialization +} // namespace ros + +namespace ros +{ +namespace message_operations +{ + +template +struct Printer< ::sensor_msgs::SetCameraInfoResponse_ > +{ + template static void stream(Stream& s, const std::string& indent, const ::sensor_msgs::SetCameraInfoResponse_& v) + { + s << indent << "success: "; + Printer::stream(s, indent + " ", v.success); + s << indent << "status_message: "; + Printer, typename ContainerAllocator::template rebind::other > >::stream(s, indent + " ", v.status_message); + } +}; + +} // namespace message_operations +} // namespace ros + +#endif // SENSOR_MSGS_MESSAGE_SETCAMERAINFORESPONSE_H diff --git a/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/Temperature.h b/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/Temperature.h new file mode 100644 index 0000000000..8480c37039 --- /dev/null +++ b/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/Temperature.h @@ -0,0 +1,228 @@ +// Generated by gencpp from file sensor_msgs/Temperature.msg +// DO NOT EDIT! + + +#ifndef SENSOR_MSGS_MESSAGE_TEMPERATURE_H +#define SENSOR_MSGS_MESSAGE_TEMPERATURE_H + + +#include +#include +#include + +#include +#include +#include +#include + +#include + +namespace sensor_msgs +{ +template +struct Temperature_ +{ + typedef Temperature_ Type; + + Temperature_() + : header() + , temperature(0.0) + , variance(0.0) { + } + Temperature_(const ContainerAllocator& _alloc) + : header(_alloc) + , temperature(0.0) + , variance(0.0) { + (void)_alloc; + } + + + + typedef ::std_msgs::Header_ _header_type; + _header_type header; + + typedef double _temperature_type; + _temperature_type temperature; + + typedef double _variance_type; + _variance_type variance; + + + + + typedef boost::shared_ptr< ::sensor_msgs::Temperature_ > Ptr; + typedef boost::shared_ptr< ::sensor_msgs::Temperature_ const> ConstPtr; + +}; // struct Temperature_ + +typedef ::sensor_msgs::Temperature_ > Temperature; + +typedef boost::shared_ptr< ::sensor_msgs::Temperature > TemperaturePtr; +typedef boost::shared_ptr< ::sensor_msgs::Temperature const> TemperatureConstPtr; + +// constants requiring out of line definition + + + +template +std::ostream& operator<<(std::ostream& s, const ::sensor_msgs::Temperature_ & v) +{ +ros::message_operations::Printer< ::sensor_msgs::Temperature_ >::stream(s, "", v); +return s; +} + +} // namespace sensor_msgs + +namespace ros +{ +namespace message_traits +{ + + + +// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': True} +// {'std_msgs': ['/opt/ros/kinetic/share/std_msgs/cmake/../msg'], 'geometry_msgs': ['/opt/ros/kinetic/share/geometry_msgs/cmake/../msg'], 'sensor_msgs': ['/tmp/binarydeb/ros-kinetic-sensor-msgs-1.12.5/msg']} + +// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types'] + + + + +template +struct IsFixedSize< ::sensor_msgs::Temperature_ > + : FalseType + { }; + +template +struct IsFixedSize< ::sensor_msgs::Temperature_ const> + : FalseType + { }; + +template +struct IsMessage< ::sensor_msgs::Temperature_ > + : TrueType + { }; + +template +struct IsMessage< ::sensor_msgs::Temperature_ const> + : TrueType + { }; + +template +struct HasHeader< ::sensor_msgs::Temperature_ > + : TrueType + { }; + +template +struct HasHeader< ::sensor_msgs::Temperature_ const> + : TrueType + { }; + + +template +struct MD5Sum< ::sensor_msgs::Temperature_ > +{ + static const char* value() + { + return "ff71b307acdbe7c871a5a6d7ed359100"; + } + + static const char* value(const ::sensor_msgs::Temperature_&) { return value(); } + static const uint64_t static_value1 = 0xff71b307acdbe7c8ULL; + static const uint64_t static_value2 = 0x71a5a6d7ed359100ULL; +}; + +template +struct DataType< ::sensor_msgs::Temperature_ > +{ + static const char* value() + { + return "sensor_msgs/Temperature"; + } + + static const char* value(const ::sensor_msgs::Temperature_&) { return value(); } +}; + +template +struct Definition< ::sensor_msgs::Temperature_ > +{ + static const char* value() + { + return " # Single temperature reading.\n\ +\n\ + Header header # timestamp is the time the temperature was measured\n\ + # frame_id is the location of the temperature reading\n\ +\n\ + float64 temperature # Measurement of the Temperature in Degrees Celsius\n\ +\n\ + float64 variance # 0 is interpreted as variance unknown\n\ +================================================================================\n\ +MSG: std_msgs/Header\n\ +# Standard metadata for higher-level stamped data types.\n\ +# This is generally used to communicate timestamped data \n\ +# in a particular coordinate frame.\n\ +# \n\ +# sequence ID: consecutively increasing ID \n\ +uint32 seq\n\ +#Two-integer timestamp that is expressed as:\n\ +# * stamp.sec: seconds (stamp_secs) since epoch (in Python the variable is called 'secs')\n\ +# * stamp.nsec: nanoseconds since stamp_secs (in Python the variable is called 'nsecs')\n\ +# time-handling sugar is provided by the client library\n\ +time stamp\n\ +#Frame this data is associated with\n\ +# 0: no frame\n\ +# 1: global frame\n\ +string frame_id\n\ +"; + } + + static const char* value(const ::sensor_msgs::Temperature_&) { return value(); } +}; + +} // namespace message_traits +} // namespace ros + +namespace ros +{ +namespace serialization +{ + + template struct Serializer< ::sensor_msgs::Temperature_ > + { + template inline static void allInOne(Stream& stream, T m) + { + stream.next(m.header); + stream.next(m.temperature); + stream.next(m.variance); + } + + ROS_DECLARE_ALLINONE_SERIALIZER; + }; // struct Temperature_ + +} // namespace serialization +} // namespace ros + +namespace ros +{ +namespace message_operations +{ + +template +struct Printer< ::sensor_msgs::Temperature_ > +{ + template static void stream(Stream& s, const std::string& indent, const ::sensor_msgs::Temperature_& v) + { + s << indent << "header: "; + s << std::endl; + Printer< ::std_msgs::Header_ >::stream(s, indent + " ", v.header); + s << indent << "temperature: "; + Printer::stream(s, indent + " ", v.temperature); + s << indent << "variance: "; + Printer::stream(s, indent + " ", v.variance); + } +}; + +} // namespace message_operations +} // namespace ros + +#endif // SENSOR_MSGS_MESSAGE_TEMPERATURE_H diff --git a/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/TimeReference.h b/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/TimeReference.h new file mode 100644 index 0000000000..d3a67fee8a --- /dev/null +++ b/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/TimeReference.h @@ -0,0 +1,229 @@ +// Generated by gencpp from file sensor_msgs/TimeReference.msg +// DO NOT EDIT! + + +#ifndef SENSOR_MSGS_MESSAGE_TIMEREFERENCE_H +#define SENSOR_MSGS_MESSAGE_TIMEREFERENCE_H + + +#include +#include +#include +#include + +#include +#include +#include +#include + +#include + +namespace sensor_msgs +{ +template +struct TimeReference_ +{ + typedef TimeReference_ Type; + + TimeReference_() + : header() + , time_ref() + , source() { + } + TimeReference_(const ContainerAllocator& _alloc) + : header(_alloc) + , time_ref() + , source(_alloc) { + (void)_alloc; + } + + + + typedef ::std_msgs::Header_ _header_type; + _header_type header; + + typedef ros::Time _time_ref_type; + _time_ref_type time_ref; + + typedef std::basic_string, typename ContainerAllocator::template rebind::other > _source_type; + _source_type source; + + + + + typedef std::shared_ptr< ::sensor_msgs::TimeReference_ > Ptr; + typedef std::shared_ptr< ::sensor_msgs::TimeReference_ const> ConstPtr; + +}; // struct TimeReference_ + +typedef ::sensor_msgs::TimeReference_ > TimeReference; + +typedef std::shared_ptr< ::sensor_msgs::TimeReference > TimeReferencePtr; +typedef std::shared_ptr< ::sensor_msgs::TimeReference const> TimeReferenceConstPtr; + +// constants requiring out of line definition + + + +template +std::ostream& operator<<(std::ostream& s, const ::sensor_msgs::TimeReference_ & v) +{ +ros::message_operations::Printer< ::sensor_msgs::TimeReference_ >::stream(s, "", v); +return s; +} + +} // namespace sensor_msgs + +namespace ros +{ +namespace message_traits +{ + + + +// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': True} +// {'std_msgs': ['/opt/ros/kinetic/share/std_msgs/cmake/../msg'], 'geometry_msgs': ['/opt/ros/kinetic/share/geometry_msgs/cmake/../msg'], 'sensor_msgs': ['/tmp/binarydeb/ros-kinetic-sensor-msgs-1.12.5/msg']} + +// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types'] + + + + +template +struct IsFixedSize< ::sensor_msgs::TimeReference_ > + : FalseType + { }; + +template +struct IsFixedSize< ::sensor_msgs::TimeReference_ const> + : FalseType + { }; + +template +struct IsMessage< ::sensor_msgs::TimeReference_ > + : TrueType + { }; + +template +struct IsMessage< ::sensor_msgs::TimeReference_ const> + : TrueType + { }; + +template +struct HasHeader< ::sensor_msgs::TimeReference_ > + : TrueType + { }; + +template +struct HasHeader< ::sensor_msgs::TimeReference_ const> + : TrueType + { }; + + +template +struct MD5Sum< ::sensor_msgs::TimeReference_ > +{ + static const char* value() + { + return "fded64a0265108ba86c3d38fb11c0c16"; + } + + static const char* value(const ::sensor_msgs::TimeReference_&) { return value(); } + static const uint64_t static_value1 = 0xfded64a0265108baULL; + static const uint64_t static_value2 = 0x86c3d38fb11c0c16ULL; +}; + +template +struct DataType< ::sensor_msgs::TimeReference_ > +{ + static const char* value() + { + return "sensor_msgs/TimeReference"; + } + + static const char* value(const ::sensor_msgs::TimeReference_&) { return value(); } +}; + +template +struct Definition< ::sensor_msgs::TimeReference_ > +{ + static const char* value() + { + return "# Measurement from an external time source not actively synchronized with the system clock.\n\ +\n\ +Header header # stamp is system time for which measurement was valid\n\ + # frame_id is not used \n\ +\n\ +time time_ref # corresponding time from this external source\n\ +string source # (optional) name of time source\n\ +\n\ +================================================================================\n\ +MSG: std_msgs/Header\n\ +# Standard metadata for higher-level stamped data types.\n\ +# This is generally used to communicate timestamped data \n\ +# in a particular coordinate frame.\n\ +# \n\ +# sequence ID: consecutively increasing ID \n\ +uint32 seq\n\ +#Two-integer timestamp that is expressed as:\n\ +# * stamp.sec: seconds (stamp_secs) since epoch (in Python the variable is called 'secs')\n\ +# * stamp.nsec: nanoseconds since stamp_secs (in Python the variable is called 'nsecs')\n\ +# time-handling sugar is provided by the client library\n\ +time stamp\n\ +#Frame this data is associated with\n\ +# 0: no frame\n\ +# 1: global frame\n\ +string frame_id\n\ +"; + } + + static const char* value(const ::sensor_msgs::TimeReference_&) { return value(); } +}; + +} // namespace message_traits +} // namespace ros + +namespace ros +{ +namespace serialization +{ + + template struct Serializer< ::sensor_msgs::TimeReference_ > + { + template inline static void allInOne(Stream& stream, T m) + { + stream.next(m.header); + stream.next(m.time_ref); + stream.next(m.source); + } + + ROS_DECLARE_ALLINONE_SERIALIZER; + }; // struct TimeReference_ + +} // namespace serialization +} // namespace ros + +namespace ros +{ +namespace message_operations +{ + +template +struct Printer< ::sensor_msgs::TimeReference_ > +{ + template static void stream(Stream& s, const std::string& indent, const ::sensor_msgs::TimeReference_& v) + { + s << indent << "header: "; + s << std::endl; + Printer< ::std_msgs::Header_ >::stream(s, indent + " ", v.header); + s << indent << "time_ref: "; + Printer::stream(s, indent + " ", v.time_ref); + s << indent << "source: "; + Printer, typename ContainerAllocator::template rebind::other > >::stream(s, indent + " ", v.source); + } +}; + +} // namespace message_operations +} // namespace ros + +#endif // SENSOR_MSGS_MESSAGE_TIMEREFERENCE_H diff --git a/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/distortion_models.h b/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/distortion_models.h new file mode 100644 index 0000000000..c42492dc0a --- /dev/null +++ b/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/distortion_models.h @@ -0,0 +1,50 @@ + +/********************************************************************* +* Software License Agreement (BSD License) +* +* Copyright (c) 2010, Willow Garage, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions +* are met: +* +* * Redistributions of source code must retain the above copyright +* notice, this list of conditions and the following disclaimer. +* * Redistributions in binary form must reproduce the above +* copyright notice, this list of conditions and the following +* disclaimer in the documentation and/or other materials provided +* with the distribution. +* * Neither the name of the Willow Garage nor the names of its +* contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*********************************************************************/ + +#ifndef SENSOR_MSGS_DISTORTION_MODELS_H +#define SENSOR_MSGS_DISTORTION_MODELS_H + +#include + +namespace sensor_msgs +{ + namespace distortion_models + { + const std::string PLUMB_BOB = "plumb_bob"; + const std::string RATIONAL_POLYNOMIAL = "rational_polynomial"; + } +} + +#endif diff --git a/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/fill_image.h b/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/fill_image.h new file mode 100644 index 0000000000..8795d2fd8e --- /dev/null +++ b/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/fill_image.h @@ -0,0 +1,70 @@ +/********************************************************************* +* Software License Agreement (BSD License) +* +* Copyright (c) 2008, Willow Garage, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions +* are met: +* +* * Redistributions of source code must retain the above copyright +* notice, this list of conditions and the following disclaimer. +* * Redistributions in binary form must reproduce the above +* copyright notice, this list of conditions and the following +* disclaimer in the documentation and/or other materials provided +* with the distribution. +* * Neither the name of the Willow Garage nor the names of its +* contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*********************************************************************/ + +#ifndef FILLIMAGE_HH +#define FILLIMAGE_HH + +#include "sensor_msgs/Image.h" +#include "sensor_msgs/image_encodings.h" + +namespace sensor_msgs +{ + + static inline bool fillImage(Image& image, + const std::string& encoding_arg, + uint32_t rows_arg, + uint32_t cols_arg, + uint32_t step_arg, + const void* data_arg) + { + image.encoding = encoding_arg; + image.height = rows_arg; + image.width = cols_arg; + image.step = step_arg; + size_t st0 = (step_arg * rows_arg); + image.data.resize(st0); + memcpy(&image.data[0], data_arg, st0); + + image.is_bigendian = 0; + return true; + } + + static inline void clearImage(Image& image) + { + image.data.resize(0); + } +} + + +#endif diff --git a/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/image_encodings.h b/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/image_encodings.h new file mode 100644 index 0000000000..018049188d --- /dev/null +++ b/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/image_encodings.h @@ -0,0 +1,232 @@ + +/********************************************************************* +* Software License Agreement (BSD License) +* +* Copyright (c) 2009, Willow Garage, Inc. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions +* are met: +* +* * Redistributions of source code must retain the above copyright +* notice, this list of conditions and the following disclaimer. +* * Redistributions in binary form must reproduce the above +* copyright notice, this list of conditions and the following +* disclaimer in the documentation and/or other materials provided +* with the distribution. +* * Neither the name of the Willow Garage nor the names of its +* contributors may be used to endorse or promote products derived +* from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*********************************************************************/ + +#ifndef SENSOR_MSGS_IMAGE_ENCODINGS_H +#define SENSOR_MSGS_IMAGE_ENCODINGS_H + +#include +#include + +namespace sensor_msgs +{ + namespace image_encodings + { + const std::string RGB8 = "rgb8"; + const std::string RGBA8 = "rgba8"; + const std::string RGB16 = "rgb16"; + const std::string RGBA16 = "rgba16"; + const std::string BGR8 = "bgr8"; + const std::string BGRA8 = "bgra8"; + const std::string BGR16 = "bgr16"; + const std::string BGRA16 = "bgra16"; + const std::string MONO8="mono8"; + const std::string MONO16="mono16"; + + // OpenCV CvMat types + const std::string TYPE_8UC1="8UC1"; + const std::string TYPE_8UC2="8UC2"; + const std::string TYPE_8UC3="8UC3"; + const std::string TYPE_8UC4="8UC4"; + const std::string TYPE_8SC1="8SC1"; + const std::string TYPE_8SC2="8SC2"; + const std::string TYPE_8SC3="8SC3"; + const std::string TYPE_8SC4="8SC4"; + const std::string TYPE_16UC1="16UC1"; + const std::string TYPE_16UC2="16UC2"; + const std::string TYPE_16UC3="16UC3"; + const std::string TYPE_16UC4="16UC4"; + const std::string TYPE_16SC1="16SC1"; + const std::string TYPE_16SC2="16SC2"; + const std::string TYPE_16SC3="16SC3"; + const std::string TYPE_16SC4="16SC4"; + const std::string TYPE_32SC1="32SC1"; + const std::string TYPE_32SC2="32SC2"; + const std::string TYPE_32SC3="32SC3"; + const std::string TYPE_32SC4="32SC4"; + const std::string TYPE_32FC1="32FC1"; + const std::string TYPE_32FC2="32FC2"; + const std::string TYPE_32FC3="32FC3"; + const std::string TYPE_32FC4="32FC4"; + const std::string TYPE_64FC1="64FC1"; + const std::string TYPE_64FC2="64FC2"; + const std::string TYPE_64FC3="64FC3"; + const std::string TYPE_64FC4="64FC4"; + + // Bayer encodings + const std::string BAYER_RGGB8="bayer_rggb8"; + const std::string BAYER_BGGR8="bayer_bggr8"; + const std::string BAYER_GBRG8="bayer_gbrg8"; + const std::string BAYER_GRBG8="bayer_grbg8"; + const std::string BAYER_RGGB16="bayer_rggb16"; + const std::string BAYER_BGGR16="bayer_bggr16"; + const std::string BAYER_GBRG16="bayer_gbrg16"; + const std::string BAYER_GRBG16="bayer_grbg16"; + + // Miscellaneous + // This is the UYVY version of YUV422 codec http://www.fourcc.org/yuv.php#UYVY + // with an 8-bit depth + const std::string YUV422="yuv422"; + + // Prefixes for abstract image encodings + const std::string ABSTRACT_ENCODING_PREFIXES[] = { + "8UC", "8SC", "16UC", "16SC", "32SC", "32FC", "64FC"}; + + // Utility functions for inspecting an encoding string + static inline bool isColor(const std::string& encoding) + { + return encoding == RGB8 || encoding == BGR8 || + encoding == RGBA8 || encoding == BGRA8 || + encoding == RGB16 || encoding == BGR16 || + encoding == RGBA16 || encoding == BGRA16; + } + + static inline bool isMono(const std::string& encoding) + { + return encoding == MONO8 || encoding == MONO16; + } + + static inline bool isBayer(const std::string& encoding) + { + return encoding == BAYER_RGGB8 || encoding == BAYER_BGGR8 || + encoding == BAYER_GBRG8 || encoding == BAYER_GRBG8 || + encoding == BAYER_RGGB16 || encoding == BAYER_BGGR16 || + encoding == BAYER_GBRG16 || encoding == BAYER_GRBG16; + } + + static inline bool hasAlpha(const std::string& encoding) + { + return encoding == RGBA8 || encoding == BGRA8 || + encoding == RGBA16 || encoding == BGRA16; + } + + static inline int numChannels(const std::string& encoding) + { + // First do the common-case encodings + if (encoding == MONO8 || + encoding == MONO16) + return 1; + if (encoding == BGR8 || + encoding == RGB8 || + encoding == BGR16 || + encoding == RGB16) + return 3; + if (encoding == BGRA8 || + encoding == RGBA8 || + encoding == BGRA16 || + encoding == RGBA16) + return 4; + if (encoding == BAYER_RGGB8 || + encoding == BAYER_BGGR8 || + encoding == BAYER_GBRG8 || + encoding == BAYER_GRBG8 || + encoding == BAYER_RGGB16 || + encoding == BAYER_BGGR16 || + encoding == BAYER_GBRG16 || + encoding == BAYER_GRBG16) + return 1; + + // Now all the generic content encodings + // TODO: Rewrite with regex when ROS supports C++11 + for (size_t i=0; i < sizeof(ABSTRACT_ENCODING_PREFIXES) / sizeof(*ABSTRACT_ENCODING_PREFIXES); i++) + { + std::string prefix = ABSTRACT_ENCODING_PREFIXES[i]; + if (encoding.substr(0, prefix.size()) != prefix) + continue; + if (encoding.size() == prefix.size()) + return 1; // ex. 8UC -> 1 + int n_channel = atoi(encoding.substr(prefix.size(), + encoding.size() - prefix.size()).c_str()); // ex. 8UC5 -> 5 + if (n_channel != 0) + return n_channel; // valid encoding string + } + + if (encoding == YUV422) + return 2; + + throw std::runtime_error("Unknown encoding " + encoding); + return -1; + } + + static inline int bitDepth(const std::string& encoding) + { + if (encoding == MONO16) + return 16; + if (encoding == MONO8 || + encoding == BGR8 || + encoding == RGB8 || + encoding == BGRA8 || + encoding == RGBA8 || + encoding == BAYER_RGGB8 || + encoding == BAYER_BGGR8 || + encoding == BAYER_GBRG8 || + encoding == BAYER_GRBG8) + return 8; + + if (encoding == MONO16 || + encoding == BGR16 || + encoding == RGB16 || + encoding == BGRA16 || + encoding == RGBA16 || + encoding == BAYER_RGGB16 || + encoding == BAYER_BGGR16 || + encoding == BAYER_GBRG16 || + encoding == BAYER_GRBG16) + return 16; + + // Now all the generic content encodings + // TODO: Rewrite with regex when ROS supports C++11 + for (size_t i=0; i < sizeof(ABSTRACT_ENCODING_PREFIXES) / sizeof(*ABSTRACT_ENCODING_PREFIXES); i++) + { + std::string prefix = ABSTRACT_ENCODING_PREFIXES[i]; + if (encoding.substr(0, prefix.size()) != prefix) + continue; + if (encoding.size() == prefix.size()) + return atoi(prefix.c_str()); // ex. 8UC -> 8 + int n_channel = atoi(encoding.substr(prefix.size(), + encoding.size() - prefix.size()).c_str()); // ex. 8UC10 -> 10 + if (n_channel != 0) + return atoi(prefix.c_str()); // valid encoding string + } + + if (encoding == YUV422) + return 8; + + throw std::runtime_error("Unknown encoding " + encoding); + return -1; + } + } +} + +#endif diff --git a/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/impl/point_cloud2_iterator.h b/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/impl/point_cloud2_iterator.h new file mode 100644 index 0000000000..c8d7de8a92 --- /dev/null +++ b/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/impl/point_cloud2_iterator.h @@ -0,0 +1,416 @@ +/* + * Software License Agreement (BSD License) + * + * Copyright (c) 2013, Open Source Robotics Foundation + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials provided + * with the distribution. + * * Neither the name of Open Source Robotics Foundation nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN + * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef SENSOR_MSGS_IMPL_POINT_CLOUD_ITERATOR_H +#define SENSOR_MSGS_IMPL_POINT_CLOUD_ITERATOR_H + +#include +#include +#include +#include + +/** + * \brief Private implementation used by PointCloud2Iterator + * \author Vincent Rabaud + */ + +namespace +{ +/** Return the size of a datatype (which is an enum of sensor_msgs::PointField::) in bytes + * @param datatype one of the enums of sensor_msgs::PointField:: + */ +inline int sizeOfPointField(int datatype) +{ + if ((datatype == sensor_msgs::PointField::INT8) || (datatype == sensor_msgs::PointField::UINT8)) + return 1; + else if ((datatype == sensor_msgs::PointField::INT16) || (datatype == sensor_msgs::PointField::UINT16)) + return 2; + else if ((datatype == sensor_msgs::PointField::INT32) || (datatype == sensor_msgs::PointField::UINT32) || + (datatype == sensor_msgs::PointField::FLOAT32)) + return 4; + else if (datatype == sensor_msgs::PointField::FLOAT64) + return 8; + else + { + std::stringstream err; + err << "PointField of type " << datatype << " does not exist"; + throw std::runtime_error(err.str()); + } + return -1; +} + +/** Private function that adds a PointField to the "fields" member of a PointCloud2 + * @param cloud_msg the PointCloud2 to add a field to + * @param name the name of the field + * @param count the number of elements in the PointField + * @param datatype the datatype of the elements + * @param offset the offset of that element + * @return the offset of the next PointField that will be added to the PointCLoud2 + */ +inline int addPointField(sensor_msgs::PointCloud2 &cloud_msg, const std::string &name, int count, int datatype, + int offset) +{ + sensor_msgs::PointField point_field; + point_field.name = name; + point_field.count = count; + point_field.datatype = datatype; + point_field.offset = offset; + cloud_msg.fields.push_back(point_field); + + // Update the offset + return offset + point_field.count * sizeOfPointField(datatype); +} +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +namespace sensor_msgs +{ + +inline PointCloud2Modifier::PointCloud2Modifier(PointCloud2& cloud_msg) : cloud_msg_(cloud_msg) +{ +} + +inline size_t PointCloud2Modifier::size() const +{ + return cloud_msg_.data.size() / cloud_msg_.point_step; +} + +inline void PointCloud2Modifier::reserve(size_t size) +{ + cloud_msg_.data.reserve(size * cloud_msg_.point_step); +} + +inline void PointCloud2Modifier::resize(size_t size) +{ + cloud_msg_.data.resize(size * cloud_msg_.point_step); + + // Update height/width + if (cloud_msg_.height == 1) { + cloud_msg_.width = size; + cloud_msg_.row_step = size * cloud_msg_.point_step; + } else + if (cloud_msg_.width == 1) + cloud_msg_.height = size; + else { + cloud_msg_.height = 1; + cloud_msg_.width = size; + cloud_msg_.row_step = size * cloud_msg_.point_step; + } +} + +inline void PointCloud2Modifier::clear() +{ + cloud_msg_.data.clear(); + + // Update height/width + if (cloud_msg_.height == 1) + cloud_msg_.row_step = cloud_msg_.width = 0; + else + if (cloud_msg_.width == 1) + cloud_msg_.height = 0; + else + cloud_msg_.row_step = cloud_msg_.width = cloud_msg_.height = 0; +} + + +/** + * @brief Function setting some fields in a PointCloud and adjusting the + * internals of the PointCloud2 + * @param n_fields the number of fields to add. The fields are given as + * triplets: name of the field as char*, number of elements in the + * field, the datatype of the elements in the field + * + * E.g, you create your PointCloud2 message with XYZ/RGB as follows: + * 

+ *   setPointCloud2FieldsByString(cloud_msg, 4, "x", 1, sensor_msgs::PointField::FLOAT32,
+ *                                              "y", 1, sensor_msgs::PointField::FLOAT32,
+ *                                              "z", 1, sensor_msgs::PointField::FLOAT32,
+ *                                              "rgb", 1, sensor_msgs::PointField::FLOAT32);
+ *
+ * WARNING: THIS DOES NOT TAKE INTO ACCOUNT ANY PADDING AS DONE UNTIL HYDRO + * For simple usual cases, the overloaded setPointCloud2FieldsByString is what you want. + */ +inline void PointCloud2Modifier::setPointCloud2Fields(int n_fields, ...) +{ + cloud_msg_.fields.clear(); + cloud_msg_.fields.reserve(n_fields); + va_list vl; + va_start(vl, n_fields); + int offset = 0; + for (int i = 0; i < n_fields; ++i) { + // Create the corresponding PointField + std::string name(va_arg(vl, char*)); + int count(va_arg(vl, int)); + int datatype(va_arg(vl, int)); + offset = addPointField(cloud_msg_, name, count, datatype, offset); + } + va_end(vl); + + // Resize the point cloud accordingly + cloud_msg_.point_step = offset; + cloud_msg_.row_step = cloud_msg_.width * cloud_msg_.point_step; + cloud_msg_.data.resize(cloud_msg_.height * cloud_msg_.row_step); +} + +/** + * @brief Function setting some fields in a PointCloud and adjusting the + * internals of the PointCloud2 + * @param n_fields the number of fields to add. The fields are given as + * strings: "xyz" (3 floats), "rgb" (3 uchar stacked in a float), + * "rgba" (4 uchar stacked in a float) + * @return void + * + * WARNING: THIS FUNCTION DOES ADD ANY NECESSARY PADDING TRANSPARENTLY + */ +inline void PointCloud2Modifier::setPointCloud2FieldsByString(int n_fields, ...) +{ + cloud_msg_.fields.clear(); + cloud_msg_.fields.reserve(n_fields); + va_list vl; + va_start(vl, n_fields); + int offset = 0; + for (int i = 0; i < n_fields; ++i) { + // Create the corresponding PointFields + std::string + field_name = std::string(va_arg(vl, char*)); + if (field_name == "xyz") { + sensor_msgs::PointField point_field; + // Do x, y and z + offset = addPointField(cloud_msg_, "x", 1, sensor_msgs::PointField::FLOAT32, offset); + offset = addPointField(cloud_msg_, "y", 1, sensor_msgs::PointField::FLOAT32, offset); + offset = addPointField(cloud_msg_, "z", 1, sensor_msgs::PointField::FLOAT32, offset); + offset += sizeOfPointField(sensor_msgs::PointField::FLOAT32); + } else + if ((field_name == "rgb") || (field_name == "rgba")) { + offset = addPointField(cloud_msg_, field_name, 1, sensor_msgs::PointField::FLOAT32, offset); + offset += 3 * sizeOfPointField(sensor_msgs::PointField::FLOAT32); + } else + throw std::runtime_error("Field " + field_name + " does not exist"); + } + va_end(vl); + + // Resize the point cloud accordingly + cloud_msg_.point_step = offset; + cloud_msg_.row_step = cloud_msg_.width * cloud_msg_.point_step; + cloud_msg_.data.resize(cloud_msg_.height * cloud_msg_.row_step); +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +namespace impl +{ + +/** + */ +template class V> +PointCloud2IteratorBase::PointCloud2IteratorBase() : data_char_(0), data_(0), data_end_(0) +{ +} + +/** + * @param cloud_msg_ The PointCloud2 to iterate upon + * @param field_name The field to iterate upon + */ +template class V> +PointCloud2IteratorBase::PointCloud2IteratorBase(C &cloud_msg, const std::string &field_name) +{ + int offset = set_field(cloud_msg, field_name); + + data_char_ = &(cloud_msg.data.front()) + offset; + data_ = reinterpret_cast(data_char_); + data_end_ = reinterpret_cast(&(cloud_msg.data.back()) + 1 + offset); +} + +/** Assignment operator + * @param iter the iterator to copy data from + * @return a reference to *this + */ +template class V> +V& PointCloud2IteratorBase::operator =(const V &iter) +{ + if (this != &iter) + { + point_step_ = iter.point_step_; + data_char_ = iter.data_char_; + data_ = iter.data_; + data_end_ = iter.data_end_; + is_bigendian_ = iter.is_bigendian_; + } + + return *this; +} + +/** Access the i th element starting at the current pointer (useful when a field has several elements of the same + * type) + * @param i + * @return a reference to the i^th value from the current position + */ +template class V> +TT& PointCloud2IteratorBase::operator [](size_t i) const +{ + return *(data_ + i); +} + +/** Dereference the iterator. Equivalent to accessing it through [0] + * @return the value to which the iterator is pointing + */ +template class V> +TT& PointCloud2IteratorBase::operator *() const +{ + return *data_; +} + +/** Increase the iterator to the next element + * @return a reference to the updated iterator + */ +template class V> +V& PointCloud2IteratorBase::operator ++() +{ + data_char_ += point_step_; + data_ = reinterpret_cast(data_char_); + return *static_cast*>(this); +} + +/** Basic pointer addition + * @param i the amount to increase the iterator by + * @return an iterator with an increased position + */ +template class V> +V PointCloud2IteratorBase::operator +(int i) +{ + V res = *static_cast*>(this); + + res.data_char_ += i*point_step_; + res.data_ = reinterpret_cast(res.data_char_); + + return res; +} + +/** Increase the iterator by a certain amount + * @return a reference to the updated iterator + */ +template class V> +V& PointCloud2IteratorBase::operator +=(int i) +{ + data_char_ += i*point_step_; + data_ = reinterpret_cast(data_char_); + return *static_cast*>(this); +} + +/** Compare to another iterator + * @return whether the current iterator points to a different address than the other one + */ +template class V> +bool PointCloud2IteratorBase::operator !=(const V& iter) const +{ + return iter.data_ != data_; +} + +/** Return the end iterator + * @return the end iterator (useful when performing normal iterator processing with ++) + */ +template class V> +V PointCloud2IteratorBase::end() const +{ + V res = *static_cast*>(this); + res.data_ = data_end_; + return res; +} + +/** Common code to set the field of the PointCloud2 + * @param cloud_msg the PointCloud2 to modify + * @param field_name the name of the field to iterate upon + * @return the offset at which the field is found + */ +template class V> +int PointCloud2IteratorBase::set_field(const sensor_msgs::PointCloud2 &cloud_msg, const std::string &field_name) +{ + is_bigendian_ = cloud_msg.is_bigendian; + point_step_ = cloud_msg.point_step; + // make sure the channel is valid + std::vector::const_iterator field_iter = cloud_msg.fields.begin(), field_end = + cloud_msg.fields.end(); + while ((field_iter != field_end) && (field_iter->name != field_name)) + ++field_iter; + + if (field_iter == field_end) { + // Handle the special case of r,g,b,a (we assume they are understood as the channels of an rgb or rgba field) + if ((field_name == "r") || (field_name == "g") || (field_name == "b") || (field_name == "a")) + { + // Check that rgb or rgba is present + field_iter = cloud_msg.fields.begin(); + while ((field_iter != field_end) && (field_iter->name != "rgb") && (field_iter->name != "rgba")) + ++field_iter; + if (field_iter == field_end) + throw std::runtime_error("Field " + field_name + " does not exist"); + if (field_name == "r") + { + if (is_bigendian_) + return field_iter->offset + 1; + else + return field_iter->offset + 2; + } + if (field_name == "g") + { + if (is_bigendian_) + return field_iter->offset + 2; + else + return field_iter->offset + 1; + } + if (field_name == "b") + { + if (is_bigendian_) + return field_iter->offset + 3; + else + return field_iter->offset + 0; + } + if (field_name == "a") + { + if (is_bigendian_) + return field_iter->offset + 0; + else + return field_iter->offset + 3; + } + } else + throw std::runtime_error("Field " + field_name + " does not exist"); + } + + return field_iter->offset; +} + +} +} + +#endif// SENSOR_MSGS_IMPL_POINT_CLOUD_ITERATOR_H diff --git a/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/point_cloud2_iterator.h b/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/point_cloud2_iterator.h new file mode 100644 index 0000000000..5b9c7a1b55 --- /dev/null +++ b/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/point_cloud2_iterator.h @@ -0,0 +1,302 @@ +/* + * Software License Agreement (BSD License) + * + * Copyright (c) 2013, Open Source Robotics Foundation + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials provided + * with the distribution. + * * Neither the name of Open Source Robotics Foundation nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN + * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef SENSOR_MSGS_POINT_CLOUD2_ITERATOR_H +#define SENSOR_MSGS_POINT_CLOUD2_ITERATOR_H + +#include +#include +#include +#include + +/** + * \brief Tools for manipulating sensor_msgs + * + * This file provides two sets of utilities to modify and parse PointCloud2 + * The first set allows you to conveniently set the fields by hand: + * 
+ *   #include 
+ *   // Create a PointCloud2
+ *   sensor_msgs::PointCloud2 cloud_msg;
+ *   // Fill some internals of the PoinCloud2 like the header/width/height ...
+ *   cloud_msgs.height = 1;  cloud_msgs.width = 4;
+ *   // Set the point fields to xyzrgb and resize the vector with the following command
+ *   // 4 is for the number of added fields. Each come in triplet: the name of the PointField,
+ *   // the number of occurrences of the type in the PointField, the type of the PointField
+ *   sensor_msgs::PointCloud2Modifier modifier(cloud_msg);
+ *   modifier.setPointCloud2Fields(4, "x", 1, sensor_msgs::PointField::FLOAT32,
+ *                                            "y", 1, sensor_msgs::PointField::FLOAT32,
+ *                                            "z", 1, sensor_msgs::PointField::FLOAT32,
+ *                                            "rgb", 1, sensor_msgs::PointField::FLOAT32);
+ *   // For convenience and the xyz, rgb, rgba fields, you can also use the following overloaded function.
+ *   // You have to be aware that the following function does add extra padding for backward compatibility though
+ *   // so it is definitely the solution of choice for PointXYZ and PointXYZRGB
+ *   // 2 is for the number of fields to add
+ *   modifier.setPointCloud2FieldsByString(2, "xyz", "rgb");
+ *   // You can then reserve / resize as usual
+ *   modifier.resize(100);
+ *
+ * + * The second set allow you to traverse your PointCloud using an iterator: + * 
+ *   // Define some raw data we'll put in the PointCloud2
+ *   float point_data[] = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0};
+ *   uint8_t color_data[] = {40, 80, 120, 160, 200, 240, 20, 40, 60, 80, 100, 120};
+ *   // Define the iterators. When doing so, you define the Field you would like to iterate upon and
+ *   // the type of you would like returned: it is not necessary the type of the PointField as sometimes
+ *   // you pack data in another type (e.g. 3 uchar + 1 uchar for RGB are packed in a float)
+ *   sensor_msgs::PointCloud2Iterator iter_x(cloud_msg, "x");
+ *   sensor_msgs::PointCloud2Iterator iter_y(cloud_msg, "y");
+ *   sensor_msgs::PointCloud2Iterator iter_z(cloud_msg, "z");
+ *   // Even though the r,g,b,a fields do not exist (it's usually rgb, rgba), you can create iterators for
+ *   // those: they will handle data packing for you (in little endian RGB is packed as *,R,G,B in a float
+ *   // and RGBA as A,R,G,B)
+ *   sensor_msgs::PointCloud2Iterator iter_r(cloud_msg, "r");
+ *   sensor_msgs::PointCloud2Iterator iter_g(cloud_msg, "g");
+ *   sensor_msgs::PointCloud2Iterator iter_b(cloud_msg, "b");
+ *   // Fill the PointCloud2
+ *   for(size_t i=0; i
+ */
+
+namespace sensor_msgs
+{
+/**
+ * @brief Enables modifying a sensor_msgs::PointCloud2 like a container
+ */
+class PointCloud2Modifier
+{
+public:
+  /**
+   * @brief Default constructor
+   * @param cloud_msg The sensor_msgs::PointCloud2 to modify
+   */
+  PointCloud2Modifier(PointCloud2& cloud_msg);
+
+  /**
+   * @return the number of T's in the original sensor_msgs::PointCloud2
+   */
+  size_t size() const;
+
+  /**
+   * @param size The number of T's to reserve in the original sensor_msgs::PointCloud2 for
+   */
+  void reserve(size_t size);
+
+  /**
+   * @param size The number of T's to change the size of the original sensor_msgs::PointCloud2 by
+   */
+  void resize(size_t size);
+
+  /**
+   * @brief remove all T's from the original sensor_msgs::PointCloud2
+   */
+  void clear();
+
+  /**
+   * @brief Function setting some fields in a PointCloud and adjusting the
+   *        internals of the PointCloud2
+   * @param n_fields the number of fields to add. The fields are given as
+   *        triplets: name of the field as char*, number of elements in the
+   *        field, the datatype of the elements in the field
+   *
+   * E.g, you create your PointCloud2 message with XYZ/RGB as follows:
+   * 
+   *   setPointCloud2Fields(cloud_msg, 4, "x", 1, sensor_msgs::PointField::FLOAT32,
+   *                                              "y", 1, sensor_msgs::PointField::FLOAT32,
+   *                                              "z", 1, sensor_msgs::PointField::FLOAT32,
+   *                                              "rgb", 1, sensor_msgs::PointField::FLOAT32);
+   * 

+   * WARNING: THIS DOES NOT TAKE INTO ACCOUNT ANY PADDING AS DONE UNTIL HYDRO
+   * For simple usual cases, the overloaded setPointCloud2FieldsByString is what you want.
+   */
+  void setPointCloud2Fields(int n_fields, ...);
+
+  /**
+   * @brief Function setting some fields in a PointCloud and adjusting the
+   *        internals of the PointCloud2
+   * @param n_fields the number of fields to add. The fields are given as
+   *        strings: "xyz" (3 floats), "rgb" (3 uchar stacked in a float),
+   *        "rgba" (4 uchar stacked in a float)
+   * @return void
+   *
+   * WARNING: THIS FUNCTION DOES ADD ANY NECESSARY PADDING TRANSPARENTLY
+   */
+  void setPointCloud2FieldsByString(int n_fields, ...);
+protected:
+  /** A reference to the original sensor_msgs::PointCloud2 that we read */
+  PointCloud2& cloud_msg_;
+};
+
+namespace impl
+{
+/** Private base class for PointCloud2Iterator and PointCloud2ConstIterator
+ * T is the type of the value on which the child class will be templated
+ * TT is the type of the value to be retrieved (same as T except for constness)
+ * U is the type of the raw data in PointCloud2 (only uchar and const uchar are supported)
+ * C is the type of the pointcloud to intialize from (const or not)
+ * V is the derived class (yop, curiously recurring template pattern)
+ */
+template class V>
+class PointCloud2IteratorBase
+{
+public:
+  /**
+   */
+  PointCloud2IteratorBase();
+
+  /**
+   * @param cloud_msg The PointCloud2 to iterate upon
+   * @param field_name The field to iterate upon
+   */
+  PointCloud2IteratorBase(C &cloud_msg, const std::string &field_name);
+
+  /** Assignment operator
+   * @param iter the iterator to copy data from
+   * @return a reference to *this
+   */
+  V& operator =(const V& iter);
+
+  /** Access the i th element starting at the current pointer (useful when a field has several elements of the same
+   * type)
+   * @param i
+   * @return a reference to the i^th value from the current position
+   */
+  TT& operator [](size_t i) const;
+
+  /** Dereference the iterator. Equivalent to accessing it through [0]
+   * @return the value to which the iterator is pointing
+   */
+  TT& operator *() const;
+
+  /** Increase the iterator to the next element
+   * @return a reference to the updated iterator
+   */
+  V& operator ++();
+
+  /** Basic pointer addition
+   * @param i the amount to increase the iterator by
+   * @return an iterator with an increased position
+   */
+  V operator +(int i);
+
+  /** Increase the iterator by a certain amount
+   * @return a reference to the updated iterator
+   */
+  V& operator +=(int i);
+
+  /** Compare to another iterator
+   * @return whether the current iterator points to a different address than the other one
+   */
+  bool operator !=(const V& iter) const;
+
+  /** Return the end iterator
+   * @return the end iterator (useful when performing normal iterator processing with ++)
+   */
+  V end() const;
+
+private:
+  /** Common code to set the field of the PointCloud2
+   * @param cloud_msg the PointCloud2 to modify
+   * @param field_name the name of the field to iterate upon
+   * @return the offset at which the field is found
+   */
+  int set_field(const sensor_msgs::PointCloud2 &cloud_msg, const std::string &field_name);
+
+  /** The "point_step" of the original cloud */
+  int point_step_;
+  /** The raw data  in uchar* where the iterator is */
+  U* data_char_;
+  /** The cast data where the iterator is */
+  TT* data_;
+  /** The end() pointer of the iterator */
+  TT* data_end_;
+  /** Whether the fields are stored as bigendian */
+  bool is_bigendian_;
+};
+}
+
+/**
+ * \brief Class that can iterate over a PointCloud2
+ *
+ * T type of the element being iterated upon
+ * E.g, you create your PointClou2 message as follows:
+ * 
+ *   setPointCloud2FieldsByString(cloud_msg, 2, "xyz", "rgb");
+ * 

+ *
+ * For iterating over XYZ, you do :
+ * 
+ *   sensor_msgs::PointCloud2Iterator iter_x(cloud_msg, "x");
+ * 

+ * and then access X through iter_x[0] or *iter_x
+ * You could create an iterator for Y and Z too but as they are consecutive,
+ * you can just use iter_x[1] and iter_x[2]
+ *
+ * For iterating over RGB, you do:
+ * 
+ * sensor_msgs::PointCloud2Iterator iter_rgb(cloud_msg, "rgb");
+ * 

+ * and then access R,G,B through  iter_rgb[0], iter_rgb[1], iter_rgb[2]
+ */
+template
+class PointCloud2Iterator : public impl::PointCloud2IteratorBase
+{
+public:
+  PointCloud2Iterator(sensor_msgs::PointCloud2 &cloud_msg, const std::string &field_name) :
+    impl::PointCloud2IteratorBase::PointCloud2IteratorBase(cloud_msg, field_name) {}
+};
+
+/**
+ * \brief Same as a PointCloud2Iterator but for const data
+ */
+template
+class PointCloud2ConstIterator : public impl::PointCloud2IteratorBase
+{
+public:
+  PointCloud2ConstIterator(const sensor_msgs::PointCloud2 &cloud_msg, const std::string &field_name) :
+    impl::PointCloud2IteratorBase::PointCloud2IteratorBase(cloud_msg, field_name) {}
+};
+}
+
+#include 
+
+#endif// SENSOR_MSGS_POINT_CLOUD2_ITERATOR_H
diff --git a/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/point_cloud_conversion.h b/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/point_cloud_conversion.h
new file mode 100644
index 0000000000..439145dad7
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/point_cloud_conversion.h
@@ -0,0 +1,169 @@
+/*
+ * Software License Agreement (BSD License)
+ *
+ *  Copyright (c) 2010, Willow Garage, Inc.
+ *  All rights reserved.
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions
+ *  are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *   * Neither the name of Willow Garage, Inc. nor the names of its
+ *     contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ *  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ *  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ *  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ *  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ *  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ *  POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $Id$
+ *
+ */
+
+#ifndef SENSOR_MSGS_POINT_CLOUD_CONVERSION_H
+#define SENSOR_MSGS_POINT_CLOUD_CONVERSION_H
+
+#include 
+#include 
+#include 
+
+/** 
+  * \brief Convert between the old (sensor_msgs::PointCloud) and the new (sensor_msgs::PointCloud2) format.
+  * \author Radu Bogdan Rusu
+  */
+namespace sensor_msgs
+{
+  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+  /** \brief Get the index of a specified field (i.e., dimension/channel)
+    * \param points the the point cloud message
+    * \param field_name the string defining the field name
+    */
+static inline int getPointCloud2FieldIndex (const sensor_msgs::PointCloud2 &cloud, const std::string &field_name)
+{
+  // Get the index we need
+  for (size_t d = 0; d < cloud.fields.size (); ++d)
+    if (cloud.fields[d].name == field_name)
+      return (d);
+  return (-1);
+}
+
+  ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+  /** \brief Convert a sensor_msgs::PointCloud message to a sensor_msgs::PointCloud2 message.
+    * \param input the message in the sensor_msgs::PointCloud format
+    * \param output the resultant message in the sensor_msgs::PointCloud2 format
+    */ 
+static inline bool convertPointCloudToPointCloud2 (const sensor_msgs::PointCloud &input, sensor_msgs::PointCloud2 &output)
+{
+  output.header = input.header;
+  output.width  = input.points.size ();
+  output.height = 1;
+  output.fields.resize (3 + input.channels.size ());
+  // Convert x/y/z to fields
+  output.fields[0].name = "x"; output.fields[1].name = "y"; output.fields[2].name = "z";
+  int offset = 0;
+  // All offsets are *4, as all field data types are float32
+  for (size_t d = 0; d < output.fields.size (); ++d, offset += 4)
+  {
+    output.fields[d].offset = offset;
+    output.fields[d].datatype = sensor_msgs::PointField::FLOAT32;
+    output.fields[d].count  = 1;
+  }
+  output.point_step = offset;
+  output.row_step   = output.point_step * output.width;
+  // Convert the remaining of the channels to fields
+  for (size_t d = 0; d < input.channels.size (); ++d)
+    output.fields[3 + d].name = input.channels[d].name;
+  output.data.resize (input.points.size () * output.point_step);
+  output.is_bigendian = false;  // @todo ?
+  output.is_dense     = false;
+
+  // Copy the data points
+  for (size_t cp = 0; cp < input.points.size (); ++cp)
+  {
+    memcpy (&output.data[cp * output.point_step + output.fields[0].offset], &input.points[cp].x, sizeof (float));
+    memcpy (&output.data[cp * output.point_step + output.fields[1].offset], &input.points[cp].y, sizeof (float));
+    memcpy (&output.data[cp * output.point_step + output.fields[2].offset], &input.points[cp].z, sizeof (float));
+    for (size_t d = 0; d < input.channels.size (); ++d)
+    {
+      if (input.channels[d].values.size() == input.points.size())
+      {
+        memcpy (&output.data[cp * output.point_step + output.fields[3 + d].offset], &input.channels[d].values[cp], sizeof (float));
+      }
+    }
+  }
+  return (true);
+}
+
+  ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+  /** \brief Convert a sensor_msgs::PointCloud2 message to a sensor_msgs::PointCloud message.
+    * \param input the message in the sensor_msgs::PointCloud2 format
+    * \param output the resultant message in the sensor_msgs::PointCloud format
+    */ 
+static inline bool convertPointCloud2ToPointCloud (const sensor_msgs::PointCloud2 &input, sensor_msgs::PointCloud &output)
+{
+
+  output.header = input.header;
+  output.points.resize (input.width * input.height);
+  output.channels.resize (input.fields.size () - 3);
+  // Get the x/y/z field offsets
+  int x_idx = getPointCloud2FieldIndex (input, "x");
+  int y_idx = getPointCloud2FieldIndex (input, "y");
+  int z_idx = getPointCloud2FieldIndex (input, "z");
+  if (x_idx == -1 || y_idx == -1 || z_idx == -1)
+  {
+    std::cerr << "x/y/z coordinates not found! Cannot convert to sensor_msgs::PointCloud!" << std::endl;
+    return (false);
+  }
+  int x_offset = input.fields[x_idx].offset;
+  int y_offset = input.fields[y_idx].offset;
+  int z_offset = input.fields[z_idx].offset;
+  uint8_t x_datatype = input.fields[x_idx].datatype;
+  uint8_t y_datatype = input.fields[y_idx].datatype;
+  uint8_t z_datatype = input.fields[z_idx].datatype;
+   
+  // Convert the fields to channels
+  int cur_c = 0;
+  for (size_t d = 0; d < input.fields.size (); ++d)
+  {
+    if ((int)input.fields[d].offset == x_offset || (int)input.fields[d].offset == y_offset || (int)input.fields[d].offset == z_offset)
+      continue;
+    output.channels[cur_c].name = input.fields[d].name;
+    output.channels[cur_c].values.resize (output.points.size ());
+    cur_c++;
+  }
+
+  // Copy the data points
+  for (size_t cp = 0; cp < output.points.size (); ++cp)
+  {
+    // Copy x/y/z
+    output.points[cp].x = sensor_msgs::readPointCloud2BufferValue(&input.data[cp * input.point_step + x_offset], x_datatype);
+    output.points[cp].y = sensor_msgs::readPointCloud2BufferValue(&input.data[cp * input.point_step + y_offset], y_datatype);
+    output.points[cp].z = sensor_msgs::readPointCloud2BufferValue(&input.data[cp * input.point_step + z_offset], z_datatype);
+    // Copy the rest of the data
+    int cur_c = 0;
+    for (size_t d = 0; d < input.fields.size (); ++d)
+    {
+      if ((int)input.fields[d].offset == x_offset || (int)input.fields[d].offset == y_offset || (int)input.fields[d].offset == z_offset)
+        continue;
+      output.channels[cur_c++].values[cp] = sensor_msgs::readPointCloud2BufferValue(&input.data[cp * input.point_step + input.fields[d].offset], input.fields[d].datatype);
+    }
+  }
+  return (true);
+}
+}
+#endif// SENSOR_MSGS_POINT_CLOUD_CONVERSION_H
diff --git a/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/point_field_conversion.h b/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/point_field_conversion.h
new file mode 100644
index 0000000000..473b85306c
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/include/msgs/sensor_msgs/point_field_conversion.h
@@ -0,0 +1,178 @@
+/*
+ * Software License Agreement (BSD License)
+ *
+ * Robot Operating System code by the University of Osnabrück
+ * Copyright (c) 2015, University of Osnabrück
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ *   1. Redistributions of source code must retain the above 
+ *      copyright notice, this list of conditions and the following
+ *      disclaimer.
+ *
+ *   2. Redistributions in binary form must reproduce the above 
+ *      copyright notice, this list of conditions and the following
+ *      disclaimer in the documentation and/or other materials provided
+ *      with the distribution.
+ *
+ *   3. Neither the name of the copyright holder nor the names of its
+ *      contributors may be used to endorse or promote products derived
+ *      from this software without specific prior written permission.
+ *
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ *
+ *
+ * point_field_conversion.h
+ *
+ * Created on: 16.07.2015
+ *  Authors: Sebastian Pütz 
+ */
+
+#ifndef SENSOR_MSGS_POINT_FIELD_CONVERSION_H
+#define SENSOR_MSGS_POINT_FIELD_CONVERSION_H
+
+/** 
+  * \brief  This file provides a type to enum mapping for the different
+  *         PointField types and methods to read and write in 
+  *         a PointCloud2 buffer for the different PointField types.
+  * \author Sebastian Pütz
+  */
+namespace sensor_msgs{
+  /*!
+   * \Enum to type mapping.
+   */
+  template struct pointFieldTypeAsType {};
+  template<> struct pointFieldTypeAsType    { typedef int8_t   type; };
+  template<> struct pointFieldTypeAsType   { typedef uint8_t  type; };
+  template<> struct pointFieldTypeAsType   { typedef int16_t  type; };
+  template<> struct pointFieldTypeAsType  { typedef uint16_t type; };
+  template<> struct pointFieldTypeAsType   { typedef int32_t  type; };
+  template<> struct pointFieldTypeAsType  { typedef uint32_t type; };
+  template<> struct pointFieldTypeAsType { typedef float    type; };
+  template<> struct pointFieldTypeAsType { typedef double   type; };
+  
+  /*!
+   * \Type to enum mapping.
+   */
+  template struct typeAsPointFieldType {};
+  template<> struct typeAsPointFieldType   { static const uint8_t value = sensor_msgs::PointField::INT8;    };
+  template<> struct typeAsPointFieldType  { static const uint8_t value = sensor_msgs::PointField::UINT8;   };
+  template<> struct typeAsPointFieldType  { static const uint8_t value = sensor_msgs::PointField::INT16;   };
+  template<> struct typeAsPointFieldType { static const uint8_t value = sensor_msgs::PointField::UINT16;  };
+  template<> struct typeAsPointFieldType  { static const uint8_t value = sensor_msgs::PointField::INT32;   };
+  template<> struct typeAsPointFieldType { static const uint8_t value = sensor_msgs::PointField::UINT32;  };
+  template<> struct typeAsPointFieldType    { static const uint8_t value = sensor_msgs::PointField::FLOAT32; };
+  template<> struct typeAsPointFieldType   { static const uint8_t value = sensor_msgs::PointField::FLOAT64; };
+ 
+  /*!
+   * \Converts a value at the given pointer position, interpreted as the datatype
+   *  specified by the given template argument point_field_type, to the given
+   *  template type T and returns it.
+   * \param data_ptr            pointer into the point cloud 2 buffer
+   * \tparam point_field_type   sensor_msgs::PointField datatype value
+   * \tparam T                  return type
+   */
+  template
+    inline T readPointCloud2BufferValue(const unsigned char* data_ptr){
+      typedef typename pointFieldTypeAsType::type type;
+      return static_cast(*(reinterpret_cast(data_ptr)));
+    }
+  
+  /*!
+   * \Converts a value at the given pointer position interpreted as the datatype
+   *  specified by the given datatype parameter to the given template type and returns it.
+   * \param data_ptr    pointer into the point cloud 2 buffer
+   * \param datatype    sensor_msgs::PointField datatype value
+   * \tparam T          return type
+   */
+  template
+    inline T readPointCloud2BufferValue(const unsigned char* data_ptr, const unsigned char datatype){
+      switch(datatype){
+        case sensor_msgs::PointField::INT8:
+          return readPointCloud2BufferValue(data_ptr);
+        case sensor_msgs::PointField::UINT8:
+          return readPointCloud2BufferValue(data_ptr);
+        case sensor_msgs::PointField::INT16:
+          return readPointCloud2BufferValue(data_ptr);
+        case sensor_msgs::PointField::UINT16:
+          return readPointCloud2BufferValue(data_ptr);
+        case sensor_msgs::PointField::INT32:
+          return readPointCloud2BufferValue(data_ptr);
+        case sensor_msgs::PointField::UINT32:
+          return readPointCloud2BufferValue(data_ptr);
+        case sensor_msgs::PointField::FLOAT32:
+          return readPointCloud2BufferValue(data_ptr);
+        case sensor_msgs::PointField::FLOAT64:
+          return readPointCloud2BufferValue(data_ptr);
+      }
+    }
+
+  /*!
+   * \Inserts a given value at the given point position interpreted as the datatype
+   *  specified by the template argument point_field_type.
+   * \param data_ptr            pointer into the point cloud 2 buffer
+   * \param value               the value to insert
+   * \tparam point_field_type   sensor_msgs::PointField datatype value
+   * \tparam T                  type of the value to insert
+   */
+  template
+    inline void writePointCloud2BufferValue(unsigned char* data_ptr, T value){
+      typedef typename pointFieldTypeAsType::type type;
+      *(reinterpret_cast(data_ptr)) = static_cast(value);
+    }
+
+  /*!
+   * \Inserts a given value at the given point position interpreted as the datatype
+   *  specified by the given datatype parameter.
+   * \param data_ptr    pointer into the point cloud 2 buffer
+   * \param datatype    sensor_msgs::PointField datatype value
+   * \param value       the value to insert
+   * \tparam T          type of the value to insert
+   */
+  template
+    inline void writePointCloud2BufferValue(unsigned char* data_ptr, const unsigned char datatype, T value){
+      switch(datatype){
+        case sensor_msgs::PointField::INT8:
+          writePointCloud2BufferValue(data_ptr, value);
+          break;
+        case sensor_msgs::PointField::UINT8:
+          writePointCloud2BufferValue(data_ptr, value);
+          break;
+        case sensor_msgs::PointField::INT16:
+          writePointCloud2BufferValue(data_ptr, value);
+          break;
+        case sensor_msgs::PointField::UINT16:
+          writePointCloud2BufferValue(data_ptr, value);
+          break;
+        case sensor_msgs::PointField::INT32:
+          writePointCloud2BufferValue(data_ptr, value);
+          break;
+        case sensor_msgs::PointField::UINT32:
+          writePointCloud2BufferValue(data_ptr, value);
+          break;
+        case sensor_msgs::PointField::FLOAT32:
+          writePointCloud2BufferValue(data_ptr, value);
+          break;
+        case sensor_msgs::PointField::FLOAT64:
+          writePointCloud2BufferValue(data_ptr, value);
+          break;
+      }
+    }
+}
+
+#endif /* point_field_conversion.h */
diff --git a/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/Bool.h b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/Bool.h
new file mode 100644
index 0000000000..e8dbc1f25f
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/Bool.h
@@ -0,0 +1,186 @@
+// Generated by gencpp from file std_msgs/Bool.msg
+// DO NOT EDIT!
+
+
+#ifndef STD_MSGS_MESSAGE_BOOL_H
+#define STD_MSGS_MESSAGE_BOOL_H
+
+
+#include 
+#include 
+#include 
+
+#include 
+#include 
+#include 
+#include 
+
+
+namespace std_msgs
+{
+template 
+struct Bool_
+{
+  typedef Bool_ Type;
+
+  Bool_()
+    : data(false)  {
+    }
+  Bool_(const ContainerAllocator& _alloc)
+    : data(false)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef uint8_t _data_type;
+  _data_type data;
+
+
+
+
+  typedef boost::shared_ptr< ::std_msgs::Bool_ > Ptr;
+  typedef boost::shared_ptr< ::std_msgs::Bool_ const> ConstPtr;
+
+}; // struct Bool_
+
+typedef ::std_msgs::Bool_ > Bool;
+
+typedef boost::shared_ptr< ::std_msgs::Bool > BoolPtr;
+typedef boost::shared_ptr< ::std_msgs::Bool const> BoolConstPtr;
+
+// constants requiring out of line definition
+
+
+
+template
+std::ostream& operator<<(std::ostream& s, const ::std_msgs::Bool_ & v)
+{
+ros::message_operations::Printer< ::std_msgs::Bool_ >::stream(s, "", v);
+return s;
+}
+
+} // namespace std_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+// BOOLTRAITS {'IsFixedSize': True, 'IsMessage': True, 'HasHeader': False}
+// {'std_msgs': ['/tmp/binarydeb/ros-kinetic-std-msgs-0.5.10/msg']}
+
+// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types']
+
+
+
+
+template 
+struct IsFixedSize< ::std_msgs::Bool_ >
+  : TrueType
+  { };
+
+template 
+struct IsFixedSize< ::std_msgs::Bool_ const>
+  : TrueType
+  { };
+
+template 
+struct IsMessage< ::std_msgs::Bool_ >
+  : TrueType
+  { };
+
+template 
+struct IsMessage< ::std_msgs::Bool_ const>
+  : TrueType
+  { };
+
+template 
+struct HasHeader< ::std_msgs::Bool_ >
+  : FalseType
+  { };
+
+template 
+struct HasHeader< ::std_msgs::Bool_ const>
+  : FalseType
+  { };
+
+
+template
+struct MD5Sum< ::std_msgs::Bool_ >
+{
+  static const char* value()
+  {
+    return "8b94c1b53db61fb6aed406028ad6332a";
+  }
+
+  static const char* value(const ::std_msgs::Bool_&) { return value(); }
+  static const uint64_t static_value1 = 0x8b94c1b53db61fb6ULL;
+  static const uint64_t static_value2 = 0xaed406028ad6332aULL;
+};
+
+template
+struct DataType< ::std_msgs::Bool_ >
+{
+  static const char* value()
+  {
+    return "std_msgs/Bool";
+  }
+
+  static const char* value(const ::std_msgs::Bool_&) { return value(); }
+};
+
+template
+struct Definition< ::std_msgs::Bool_ >
+{
+  static const char* value()
+  {
+    return "bool data\n\
+";
+  }
+
+  static const char* value(const ::std_msgs::Bool_&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template struct Serializer< ::std_msgs::Bool_ >
+  {
+    template inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.data);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER;
+  }; // struct Bool_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template
+struct Printer< ::std_msgs::Bool_ >
+{
+  template static void stream(Stream& s, const std::string& indent, const ::std_msgs::Bool_& v)
+  {
+    s << indent << "data: ";
+    Printer::stream(s, indent + "  ", v.data);
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // STD_MSGS_MESSAGE_BOOL_H
diff --git a/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/Byte.h b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/Byte.h
new file mode 100644
index 0000000000..5f81ad158c
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/Byte.h
@@ -0,0 +1,186 @@
+// Generated by gencpp from file std_msgs/Byte.msg
+// DO NOT EDIT!
+
+
+#ifndef STD_MSGS_MESSAGE_BYTE_H
+#define STD_MSGS_MESSAGE_BYTE_H
+
+
+#include 
+#include 
+#include 
+
+#include 
+#include 
+#include 
+#include 
+
+
+namespace std_msgs
+{
+template 
+struct Byte_
+{
+  typedef Byte_ Type;
+
+  Byte_()
+    : data(0)  {
+    }
+  Byte_(const ContainerAllocator& _alloc)
+    : data(0)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef int8_t _data_type;
+  _data_type data;
+
+
+
+
+  typedef boost::shared_ptr< ::std_msgs::Byte_ > Ptr;
+  typedef boost::shared_ptr< ::std_msgs::Byte_ const> ConstPtr;
+
+}; // struct Byte_
+
+typedef ::std_msgs::Byte_ > Byte;
+
+typedef boost::shared_ptr< ::std_msgs::Byte > BytePtr;
+typedef boost::shared_ptr< ::std_msgs::Byte const> ByteConstPtr;
+
+// constants requiring out of line definition
+
+
+
+template
+std::ostream& operator<<(std::ostream& s, const ::std_msgs::Byte_ & v)
+{
+ros::message_operations::Printer< ::std_msgs::Byte_ >::stream(s, "", v);
+return s;
+}
+
+} // namespace std_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+// BOOLTRAITS {'IsFixedSize': True, 'IsMessage': True, 'HasHeader': False}
+// {'std_msgs': ['/tmp/binarydeb/ros-kinetic-std-msgs-0.5.10/msg']}
+
+// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types']
+
+
+
+
+template 
+struct IsFixedSize< ::std_msgs::Byte_ >
+  : TrueType
+  { };
+
+template 
+struct IsFixedSize< ::std_msgs::Byte_ const>
+  : TrueType
+  { };
+
+template 
+struct IsMessage< ::std_msgs::Byte_ >
+  : TrueType
+  { };
+
+template 
+struct IsMessage< ::std_msgs::Byte_ const>
+  : TrueType
+  { };
+
+template 
+struct HasHeader< ::std_msgs::Byte_ >
+  : FalseType
+  { };
+
+template 
+struct HasHeader< ::std_msgs::Byte_ const>
+  : FalseType
+  { };
+
+
+template
+struct MD5Sum< ::std_msgs::Byte_ >
+{
+  static const char* value()
+  {
+    return "ad736a2e8818154c487bb80fe42ce43b";
+  }
+
+  static const char* value(const ::std_msgs::Byte_&) { return value(); }
+  static const uint64_t static_value1 = 0xad736a2e8818154cULL;
+  static const uint64_t static_value2 = 0x487bb80fe42ce43bULL;
+};
+
+template
+struct DataType< ::std_msgs::Byte_ >
+{
+  static const char* value()
+  {
+    return "std_msgs/Byte";
+  }
+
+  static const char* value(const ::std_msgs::Byte_&) { return value(); }
+};
+
+template
+struct Definition< ::std_msgs::Byte_ >
+{
+  static const char* value()
+  {
+    return "byte data\n\
+";
+  }
+
+  static const char* value(const ::std_msgs::Byte_&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template struct Serializer< ::std_msgs::Byte_ >
+  {
+    template inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.data);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER;
+  }; // struct Byte_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template
+struct Printer< ::std_msgs::Byte_ >
+{
+  template static void stream(Stream& s, const std::string& indent, const ::std_msgs::Byte_& v)
+  {
+    s << indent << "data: ";
+    Printer::stream(s, indent + "  ", v.data);
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // STD_MSGS_MESSAGE_BYTE_H
diff --git a/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/ByteMultiArray.h b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/ByteMultiArray.h
new file mode 100644
index 0000000000..37b3a635d9
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/ByteMultiArray.h
@@ -0,0 +1,240 @@
+// Generated by gencpp from file std_msgs/ByteMultiArray.msg
+// DO NOT EDIT!
+
+
+#ifndef STD_MSGS_MESSAGE_BYTEMULTIARRAY_H
+#define STD_MSGS_MESSAGE_BYTEMULTIARRAY_H
+
+
+#include 
+#include 
+#include 
+
+#include 
+#include 
+#include 
+#include 
+
+#include 
+
+namespace std_msgs
+{
+template 
+struct ByteMultiArray_
+{
+  typedef ByteMultiArray_ Type;
+
+  ByteMultiArray_()
+    : layout()
+    , data()  {
+    }
+  ByteMultiArray_(const ContainerAllocator& _alloc)
+    : layout(_alloc)
+    , data(_alloc)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef  ::std_msgs::MultiArrayLayout_  _layout_type;
+  _layout_type layout;
+
+   typedef std::vector::other >  _data_type;
+  _data_type data;
+
+
+
+
+  typedef boost::shared_ptr< ::std_msgs::ByteMultiArray_ > Ptr;
+  typedef boost::shared_ptr< ::std_msgs::ByteMultiArray_ const> ConstPtr;
+
+}; // struct ByteMultiArray_
+
+typedef ::std_msgs::ByteMultiArray_ > ByteMultiArray;
+
+typedef boost::shared_ptr< ::std_msgs::ByteMultiArray > ByteMultiArrayPtr;
+typedef boost::shared_ptr< ::std_msgs::ByteMultiArray const> ByteMultiArrayConstPtr;
+
+// constants requiring out of line definition
+
+
+
+template
+std::ostream& operator<<(std::ostream& s, const ::std_msgs::ByteMultiArray_ & v)
+{
+ros::message_operations::Printer< ::std_msgs::ByteMultiArray_ >::stream(s, "", v);
+return s;
+}
+
+} // namespace std_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': False}
+// {'std_msgs': ['/tmp/binarydeb/ros-kinetic-std-msgs-0.5.10/msg']}
+
+// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types']
+
+
+
+
+template 
+struct IsFixedSize< ::std_msgs::ByteMultiArray_ >
+  : FalseType
+  { };
+
+template 
+struct IsFixedSize< ::std_msgs::ByteMultiArray_ const>
+  : FalseType
+  { };
+
+template 
+struct IsMessage< ::std_msgs::ByteMultiArray_ >
+  : TrueType
+  { };
+
+template 
+struct IsMessage< ::std_msgs::ByteMultiArray_ const>
+  : TrueType
+  { };
+
+template 
+struct HasHeader< ::std_msgs::ByteMultiArray_ >
+  : FalseType
+  { };
+
+template 
+struct HasHeader< ::std_msgs::ByteMultiArray_ const>
+  : FalseType
+  { };
+
+
+template
+struct MD5Sum< ::std_msgs::ByteMultiArray_ >
+{
+  static const char* value()
+  {
+    return "70ea476cbcfd65ac2f68f3cda1e891fe";
+  }
+
+  static const char* value(const ::std_msgs::ByteMultiArray_&) { return value(); }
+  static const uint64_t static_value1 = 0x70ea476cbcfd65acULL;
+  static const uint64_t static_value2 = 0x2f68f3cda1e891feULL;
+};
+
+template
+struct DataType< ::std_msgs::ByteMultiArray_ >
+{
+  static const char* value()
+  {
+    return "std_msgs/ByteMultiArray";
+  }
+
+  static const char* value(const ::std_msgs::ByteMultiArray_&) { return value(); }
+};
+
+template
+struct Definition< ::std_msgs::ByteMultiArray_ >
+{
+  static const char* value()
+  {
+    return "# Please look at the MultiArrayLayout message definition for\n\
+# documentation on all multiarrays.\n\
+\n\
+MultiArrayLayout  layout        # specification of data layout\n\
+byte[]            data          # array of data\n\
+\n\
+\n\
+================================================================================\n\
+MSG: std_msgs/MultiArrayLayout\n\
+# The multiarray declares a generic multi-dimensional array of a\n\
+# particular data type.  Dimensions are ordered from outer most\n\
+# to inner most.\n\
+\n\
+MultiArrayDimension[] dim # Array of dimension properties\n\
+uint32 data_offset        # padding elements at front of data\n\
+\n\
+# Accessors should ALWAYS be written in terms of dimension stride\n\
+# and specified outer-most dimension first.\n\
+# \n\
+# multiarray(i,j,k) = data[data_offset + dim_stride[1]*i + dim_stride[2]*j + k]\n\
+#\n\
+# A standard, 3-channel 640x480 image with interleaved color channels\n\
+# would be specified as:\n\
+#\n\
+# dim[0].label  = \"height\"\n\
+# dim[0].size   = 480\n\
+# dim[0].stride = 3*640*480 = 921600  (note dim[0] stride is just size of image)\n\
+# dim[1].label  = \"width\"\n\
+# dim[1].size   = 640\n\
+# dim[1].stride = 3*640 = 1920\n\
+# dim[2].label  = \"channel\"\n\
+# dim[2].size   = 3\n\
+# dim[2].stride = 3\n\
+#\n\
+# multiarray(i,j,k) refers to the ith row, jth column, and kth channel.\n\
+\n\
+================================================================================\n\
+MSG: std_msgs/MultiArrayDimension\n\
+string label   # label of given dimension\n\
+uint32 size    # size of given dimension (in type units)\n\
+uint32 stride  # stride of given dimension\n\
+";
+  }
+
+  static const char* value(const ::std_msgs::ByteMultiArray_&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template struct Serializer< ::std_msgs::ByteMultiArray_ >
+  {
+    template inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.layout);
+      stream.next(m.data);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER;
+  }; // struct ByteMultiArray_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template
+struct Printer< ::std_msgs::ByteMultiArray_ >
+{
+  template static void stream(Stream& s, const std::string& indent, const ::std_msgs::ByteMultiArray_& v)
+  {
+    s << indent << "layout: ";
+    s << std::endl;
+    Printer< ::std_msgs::MultiArrayLayout_ >::stream(s, indent + "  ", v.layout);
+    s << indent << "data[]" << std::endl;
+    for (size_t i = 0; i < v.data.size(); ++i)
+    {
+      s << indent << "  data[" << i << "]: ";
+      Printer::stream(s, indent + "  ", v.data[i]);
+    }
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // STD_MSGS_MESSAGE_BYTEMULTIARRAY_H
diff --git a/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/Char.h b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/Char.h
new file mode 100644
index 0000000000..422e230109
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/Char.h
@@ -0,0 +1,186 @@
+// Generated by gencpp from file std_msgs/Char.msg
+// DO NOT EDIT!
+
+
+#ifndef STD_MSGS_MESSAGE_CHAR_H
+#define STD_MSGS_MESSAGE_CHAR_H
+
+
+#include 
+#include 
+#include 
+
+#include 
+#include 
+#include 
+#include 
+
+
+namespace std_msgs
+{
+template 
+struct Char_
+{
+  typedef Char_ Type;
+
+  Char_()
+    : data(0)  {
+    }
+  Char_(const ContainerAllocator& _alloc)
+    : data(0)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef uint8_t _data_type;
+  _data_type data;
+
+
+
+
+  typedef boost::shared_ptr< ::std_msgs::Char_ > Ptr;
+  typedef boost::shared_ptr< ::std_msgs::Char_ const> ConstPtr;
+
+}; // struct Char_
+
+typedef ::std_msgs::Char_ > Char;
+
+typedef boost::shared_ptr< ::std_msgs::Char > CharPtr;
+typedef boost::shared_ptr< ::std_msgs::Char const> CharConstPtr;
+
+// constants requiring out of line definition
+
+
+
+template
+std::ostream& operator<<(std::ostream& s, const ::std_msgs::Char_ & v)
+{
+ros::message_operations::Printer< ::std_msgs::Char_ >::stream(s, "", v);
+return s;
+}
+
+} // namespace std_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+// BOOLTRAITS {'IsFixedSize': True, 'IsMessage': True, 'HasHeader': False}
+// {'std_msgs': ['/tmp/binarydeb/ros-kinetic-std-msgs-0.5.10/msg']}
+
+// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types']
+
+
+
+
+template 
+struct IsFixedSize< ::std_msgs::Char_ >
+  : TrueType
+  { };
+
+template 
+struct IsFixedSize< ::std_msgs::Char_ const>
+  : TrueType
+  { };
+
+template 
+struct IsMessage< ::std_msgs::Char_ >
+  : TrueType
+  { };
+
+template 
+struct IsMessage< ::std_msgs::Char_ const>
+  : TrueType
+  { };
+
+template 
+struct HasHeader< ::std_msgs::Char_ >
+  : FalseType
+  { };
+
+template 
+struct HasHeader< ::std_msgs::Char_ const>
+  : FalseType
+  { };
+
+
+template
+struct MD5Sum< ::std_msgs::Char_ >
+{
+  static const char* value()
+  {
+    return "1bf77f25acecdedba0e224b162199717";
+  }
+
+  static const char* value(const ::std_msgs::Char_&) { return value(); }
+  static const uint64_t static_value1 = 0x1bf77f25acecdedbULL;
+  static const uint64_t static_value2 = 0xa0e224b162199717ULL;
+};
+
+template
+struct DataType< ::std_msgs::Char_ >
+{
+  static const char* value()
+  {
+    return "std_msgs/Char";
+  }
+
+  static const char* value(const ::std_msgs::Char_&) { return value(); }
+};
+
+template
+struct Definition< ::std_msgs::Char_ >
+{
+  static const char* value()
+  {
+    return "char data\n\
+";
+  }
+
+  static const char* value(const ::std_msgs::Char_&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template struct Serializer< ::std_msgs::Char_ >
+  {
+    template inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.data);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER;
+  }; // struct Char_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template
+struct Printer< ::std_msgs::Char_ >
+{
+  template static void stream(Stream& s, const std::string& indent, const ::std_msgs::Char_& v)
+  {
+    s << indent << "data: ";
+    Printer::stream(s, indent + "  ", v.data);
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // STD_MSGS_MESSAGE_CHAR_H
diff --git a/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/ColorRGBA.h b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/ColorRGBA.h
new file mode 100644
index 0000000000..42a5c95439
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/ColorRGBA.h
@@ -0,0 +1,213 @@
+// Generated by gencpp from file std_msgs/ColorRGBA.msg
+// DO NOT EDIT!
+
+
+#ifndef STD_MSGS_MESSAGE_COLORRGBA_H
+#define STD_MSGS_MESSAGE_COLORRGBA_H
+
+
+#include 
+#include 
+#include 
+
+#include 
+#include 
+#include 
+#include 
+
+
+namespace std_msgs
+{
+template 
+struct ColorRGBA_
+{
+  typedef ColorRGBA_ Type;
+
+  ColorRGBA_()
+    : r(0.0)
+    , g(0.0)
+    , b(0.0)
+    , a(0.0)  {
+    }
+  ColorRGBA_(const ContainerAllocator& _alloc)
+    : r(0.0)
+    , g(0.0)
+    , b(0.0)
+    , a(0.0)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef float _r_type;
+  _r_type r;
+
+   typedef float _g_type;
+  _g_type g;
+
+   typedef float _b_type;
+  _b_type b;
+
+   typedef float _a_type;
+  _a_type a;
+
+
+
+
+  typedef boost::shared_ptr< ::std_msgs::ColorRGBA_ > Ptr;
+  typedef boost::shared_ptr< ::std_msgs::ColorRGBA_ const> ConstPtr;
+
+}; // struct ColorRGBA_
+
+typedef ::std_msgs::ColorRGBA_ > ColorRGBA;
+
+typedef boost::shared_ptr< ::std_msgs::ColorRGBA > ColorRGBAPtr;
+typedef boost::shared_ptr< ::std_msgs::ColorRGBA const> ColorRGBAConstPtr;
+
+// constants requiring out of line definition
+
+
+
+template
+std::ostream& operator<<(std::ostream& s, const ::std_msgs::ColorRGBA_ & v)
+{
+ros::message_operations::Printer< ::std_msgs::ColorRGBA_ >::stream(s, "", v);
+return s;
+}
+
+} // namespace std_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+// BOOLTRAITS {'IsFixedSize': True, 'IsMessage': True, 'HasHeader': False}
+// {'std_msgs': ['/tmp/binarydeb/ros-kinetic-std-msgs-0.5.10/msg']}
+
+// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types']
+
+
+
+
+template 
+struct IsFixedSize< ::std_msgs::ColorRGBA_ >
+  : TrueType
+  { };
+
+template 
+struct IsFixedSize< ::std_msgs::ColorRGBA_ const>
+  : TrueType
+  { };
+
+template 
+struct IsMessage< ::std_msgs::ColorRGBA_ >
+  : TrueType
+  { };
+
+template 
+struct IsMessage< ::std_msgs::ColorRGBA_ const>
+  : TrueType
+  { };
+
+template 
+struct HasHeader< ::std_msgs::ColorRGBA_ >
+  : FalseType
+  { };
+
+template 
+struct HasHeader< ::std_msgs::ColorRGBA_ const>
+  : FalseType
+  { };
+
+
+template
+struct MD5Sum< ::std_msgs::ColorRGBA_ >
+{
+  static const char* value()
+  {
+    return "a29a96539573343b1310c73607334b00";
+  }
+
+  static const char* value(const ::std_msgs::ColorRGBA_&) { return value(); }
+  static const uint64_t static_value1 = 0xa29a96539573343bULL;
+  static const uint64_t static_value2 = 0x1310c73607334b00ULL;
+};
+
+template
+struct DataType< ::std_msgs::ColorRGBA_ >
+{
+  static const char* value()
+  {
+    return "std_msgs/ColorRGBA";
+  }
+
+  static const char* value(const ::std_msgs::ColorRGBA_&) { return value(); }
+};
+
+template
+struct Definition< ::std_msgs::ColorRGBA_ >
+{
+  static const char* value()
+  {
+    return "float32 r\n\
+float32 g\n\
+float32 b\n\
+float32 a\n\
+";
+  }
+
+  static const char* value(const ::std_msgs::ColorRGBA_&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template struct Serializer< ::std_msgs::ColorRGBA_ >
+  {
+    template inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.r);
+      stream.next(m.g);
+      stream.next(m.b);
+      stream.next(m.a);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER;
+  }; // struct ColorRGBA_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template
+struct Printer< ::std_msgs::ColorRGBA_ >
+{
+  template static void stream(Stream& s, const std::string& indent, const ::std_msgs::ColorRGBA_& v)
+  {
+    s << indent << "r: ";
+    Printer::stream(s, indent + "  ", v.r);
+    s << indent << "g: ";
+    Printer::stream(s, indent + "  ", v.g);
+    s << indent << "b: ";
+    Printer::stream(s, indent + "  ", v.b);
+    s << indent << "a: ";
+    Printer::stream(s, indent + "  ", v.a);
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // STD_MSGS_MESSAGE_COLORRGBA_H
diff --git a/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/Duration.h b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/Duration.h
new file mode 100644
index 0000000000..47b1dfa253
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/Duration.h
@@ -0,0 +1,186 @@
+// Generated by gencpp from file std_msgs/Duration.msg
+// DO NOT EDIT!
+
+
+#ifndef STD_MSGS_MESSAGE_DURATION_H
+#define STD_MSGS_MESSAGE_DURATION_H
+
+
+#include 
+#include 
+#include 
+
+#include 
+#include 
+#include 
+#include 
+
+
+namespace std_msgs
+{
+template 
+struct Duration_
+{
+  typedef Duration_ Type;
+
+  Duration_()
+    : data()  {
+    }
+  Duration_(const ContainerAllocator& _alloc)
+    : data()  {
+  (void)_alloc;
+    }
+
+
+
+   typedef ros::Duration _data_type;
+  _data_type data;
+
+
+
+
+  typedef boost::shared_ptr< ::std_msgs::Duration_ > Ptr;
+  typedef boost::shared_ptr< ::std_msgs::Duration_ const> ConstPtr;
+
+}; // struct Duration_
+
+typedef ::std_msgs::Duration_ > Duration;
+
+typedef boost::shared_ptr< ::std_msgs::Duration > DurationPtr;
+typedef boost::shared_ptr< ::std_msgs::Duration const> DurationConstPtr;
+
+// constants requiring out of line definition
+
+
+
+template
+std::ostream& operator<<(std::ostream& s, const ::std_msgs::Duration_ & v)
+{
+ros::message_operations::Printer< ::std_msgs::Duration_ >::stream(s, "", v);
+return s;
+}
+
+} // namespace std_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+// BOOLTRAITS {'IsFixedSize': True, 'IsMessage': True, 'HasHeader': False}
+// {'std_msgs': ['/tmp/binarydeb/ros-kinetic-std-msgs-0.5.10/msg']}
+
+// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types']
+
+
+
+
+template 
+struct IsFixedSize< ::std_msgs::Duration_ >
+  : TrueType
+  { };
+
+template 
+struct IsFixedSize< ::std_msgs::Duration_ const>
+  : TrueType
+  { };
+
+template 
+struct IsMessage< ::std_msgs::Duration_ >
+  : TrueType
+  { };
+
+template 
+struct IsMessage< ::std_msgs::Duration_ const>
+  : TrueType
+  { };
+
+template 
+struct HasHeader< ::std_msgs::Duration_ >
+  : FalseType
+  { };
+
+template 
+struct HasHeader< ::std_msgs::Duration_ const>
+  : FalseType
+  { };
+
+
+template
+struct MD5Sum< ::std_msgs::Duration_ >
+{
+  static const char* value()
+  {
+    return "3e286caf4241d664e55f3ad380e2ae46";
+  }
+
+  static const char* value(const ::std_msgs::Duration_&) { return value(); }
+  static const uint64_t static_value1 = 0x3e286caf4241d664ULL;
+  static const uint64_t static_value2 = 0xe55f3ad380e2ae46ULL;
+};
+
+template
+struct DataType< ::std_msgs::Duration_ >
+{
+  static const char* value()
+  {
+    return "std_msgs/Duration";
+  }
+
+  static const char* value(const ::std_msgs::Duration_&) { return value(); }
+};
+
+template
+struct Definition< ::std_msgs::Duration_ >
+{
+  static const char* value()
+  {
+    return "duration data\n\
+";
+  }
+
+  static const char* value(const ::std_msgs::Duration_&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template struct Serializer< ::std_msgs::Duration_ >
+  {
+    template inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.data);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER;
+  }; // struct Duration_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template
+struct Printer< ::std_msgs::Duration_ >
+{
+  template static void stream(Stream& s, const std::string& indent, const ::std_msgs::Duration_& v)
+  {
+    s << indent << "data: ";
+    Printer::stream(s, indent + "  ", v.data);
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // STD_MSGS_MESSAGE_DURATION_H
diff --git a/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/Empty.h b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/Empty.h
new file mode 100644
index 0000000000..95f0620e7d
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/Empty.h
@@ -0,0 +1,178 @@
+// Generated by gencpp from file std_msgs/Empty.msg
+// DO NOT EDIT!
+
+
+#ifndef STD_MSGS_MESSAGE_EMPTY_H
+#define STD_MSGS_MESSAGE_EMPTY_H
+
+
+#include 
+#include 
+#include 
+
+#include 
+#include 
+#include 
+#include 
+
+
+namespace std_msgs
+{
+template 
+struct Empty_
+{
+  typedef Empty_ Type;
+
+  Empty_()
+    {
+    }
+  Empty_(const ContainerAllocator& _alloc)
+    {
+  (void)_alloc;
+    }
+
+
+
+
+
+
+  typedef boost::shared_ptr< ::std_msgs::Empty_ > Ptr;
+  typedef boost::shared_ptr< ::std_msgs::Empty_ const> ConstPtr;
+
+}; // struct Empty_
+
+typedef ::std_msgs::Empty_ > Empty;
+
+typedef boost::shared_ptr< ::std_msgs::Empty > EmptyPtr;
+typedef boost::shared_ptr< ::std_msgs::Empty const> EmptyConstPtr;
+
+// constants requiring out of line definition
+
+
+
+template
+std::ostream& operator<<(std::ostream& s, const ::std_msgs::Empty_ & v)
+{
+ros::message_operations::Printer< ::std_msgs::Empty_ >::stream(s, "", v);
+return s;
+}
+
+} // namespace std_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+// BOOLTRAITS {'IsFixedSize': True, 'IsMessage': True, 'HasHeader': False}
+// {'std_msgs': ['/tmp/binarydeb/ros-kinetic-std-msgs-0.5.10/msg']}
+
+// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types']
+
+
+
+
+template 
+struct IsFixedSize< ::std_msgs::Empty_ >
+  : TrueType
+  { };
+
+template 
+struct IsFixedSize< ::std_msgs::Empty_ const>
+  : TrueType
+  { };
+
+template 
+struct IsMessage< ::std_msgs::Empty_ >
+  : TrueType
+  { };
+
+template 
+struct IsMessage< ::std_msgs::Empty_ const>
+  : TrueType
+  { };
+
+template 
+struct HasHeader< ::std_msgs::Empty_ >
+  : FalseType
+  { };
+
+template 
+struct HasHeader< ::std_msgs::Empty_ const>
+  : FalseType
+  { };
+
+
+template
+struct MD5Sum< ::std_msgs::Empty_ >
+{
+  static const char* value()
+  {
+    return "d41d8cd98f00b204e9800998ecf8427e";
+  }
+
+  static const char* value(const ::std_msgs::Empty_&) { return value(); }
+  static const uint64_t static_value1 = 0xd41d8cd98f00b204ULL;
+  static const uint64_t static_value2 = 0xe9800998ecf8427eULL;
+};
+
+template
+struct DataType< ::std_msgs::Empty_ >
+{
+  static const char* value()
+  {
+    return "std_msgs/Empty";
+  }
+
+  static const char* value(const ::std_msgs::Empty_&) { return value(); }
+};
+
+template
+struct Definition< ::std_msgs::Empty_ >
+{
+  static const char* value()
+  {
+    return "\n\
+";
+  }
+
+  static const char* value(const ::std_msgs::Empty_&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template struct Serializer< ::std_msgs::Empty_ >
+  {
+    template inline static void allInOne(Stream&, T)
+    {}
+
+    ROS_DECLARE_ALLINONE_SERIALIZER;
+  }; // struct Empty_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template
+struct Printer< ::std_msgs::Empty_ >
+{
+  template static void stream(Stream&, const std::string&, const ::std_msgs::Empty_&)
+  {}
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // STD_MSGS_MESSAGE_EMPTY_H
diff --git a/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/Float32.h b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/Float32.h
new file mode 100644
index 0000000000..660bd0d8bf
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/Float32.h
@@ -0,0 +1,186 @@
+// Generated by gencpp from file std_msgs/Float32.msg
+// DO NOT EDIT!
+
+
+#ifndef STD_MSGS_MESSAGE_FLOAT32_H
+#define STD_MSGS_MESSAGE_FLOAT32_H
+
+
+#include 
+#include 
+#include 
+
+#include 
+#include 
+#include 
+#include 
+
+
+namespace std_msgs
+{
+template 
+struct Float32_
+{
+  typedef Float32_ Type;
+
+  Float32_()
+    : data(0.0)  {
+    }
+  Float32_(const ContainerAllocator& _alloc)
+    : data(0.0)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef float _data_type;
+  _data_type data;
+
+
+
+
+  typedef std::shared_ptr< ::std_msgs::Float32_ > Ptr;
+  typedef std::shared_ptr< ::std_msgs::Float32_ const> ConstPtr;
+
+}; // struct Float32_
+
+typedef ::std_msgs::Float32_ > Float32;
+
+typedef std::shared_ptr< ::std_msgs::Float32 > Float32Ptr;
+typedef std::shared_ptr< ::std_msgs::Float32 const> Float32ConstPtr;
+
+// constants requiring out of line definition
+
+
+
+template
+std::ostream& operator<<(std::ostream& s, const ::std_msgs::Float32_ & v)
+{
+ros::message_operations::Printer< ::std_msgs::Float32_ >::stream(s, "", v);
+return s;
+}
+
+} // namespace std_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+// BOOLTRAITS {'IsFixedSize': True, 'IsMessage': True, 'HasHeader': False}
+// {'std_msgs': ['/tmp/binarydeb/ros-kinetic-std-msgs-0.5.10/msg']}
+
+// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types']
+
+
+
+
+template 
+struct IsFixedSize< ::std_msgs::Float32_ >
+  : TrueType
+  { };
+
+template 
+struct IsFixedSize< ::std_msgs::Float32_ const>
+  : TrueType
+  { };
+
+template 
+struct IsMessage< ::std_msgs::Float32_ >
+  : TrueType
+  { };
+
+template 
+struct IsMessage< ::std_msgs::Float32_ const>
+  : TrueType
+  { };
+
+template 
+struct HasHeader< ::std_msgs::Float32_ >
+  : FalseType
+  { };
+
+template 
+struct HasHeader< ::std_msgs::Float32_ const>
+  : FalseType
+  { };
+
+
+template
+struct MD5Sum< ::std_msgs::Float32_ >
+{
+  static const char* value()
+  {
+    return "73fcbf46b49191e672908e50842a83d4";
+  }
+
+  static const char* value(const ::std_msgs::Float32_&) { return value(); }
+  static const uint64_t static_value1 = 0x73fcbf46b49191e6ULL;
+  static const uint64_t static_value2 = 0x72908e50842a83d4ULL;
+};
+
+template
+struct DataType< ::std_msgs::Float32_ >
+{
+  static const char* value()
+  {
+    return "std_msgs/Float32";
+  }
+
+  static const char* value(const ::std_msgs::Float32_&) { return value(); }
+};
+
+template
+struct Definition< ::std_msgs::Float32_ >
+{
+  static const char* value()
+  {
+    return "float32 data\n\
+";
+  }
+
+  static const char* value(const ::std_msgs::Float32_&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template struct Serializer< ::std_msgs::Float32_ >
+  {
+    template inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.data);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER;
+  }; // struct Float32_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template
+struct Printer< ::std_msgs::Float32_ >
+{
+  template static void stream(Stream& s, const std::string& indent, const ::std_msgs::Float32_& v)
+  {
+    s << indent << "data: ";
+    Printer::stream(s, indent + "  ", v.data);
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // STD_MSGS_MESSAGE_FLOAT32_H
diff --git a/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/Float32MultiArray.h b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/Float32MultiArray.h
new file mode 100644
index 0000000000..c2b4219e07
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/Float32MultiArray.h
@@ -0,0 +1,240 @@
+// Generated by gencpp from file std_msgs/Float32MultiArray.msg
+// DO NOT EDIT!
+
+
+#ifndef STD_MSGS_MESSAGE_FLOAT32MULTIARRAY_H
+#define STD_MSGS_MESSAGE_FLOAT32MULTIARRAY_H
+
+
+#include 
+#include 
+#include 
+
+#include 
+#include 
+#include 
+#include 
+
+#include 
+
+namespace std_msgs
+{
+template 
+struct Float32MultiArray_
+{
+  typedef Float32MultiArray_ Type;
+
+  Float32MultiArray_()
+    : layout()
+    , data()  {
+    }
+  Float32MultiArray_(const ContainerAllocator& _alloc)
+    : layout(_alloc)
+    , data(_alloc)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef  ::std_msgs::MultiArrayLayout_  _layout_type;
+  _layout_type layout;
+
+   typedef std::vector::other >  _data_type;
+  _data_type data;
+
+
+
+
+  typedef boost::shared_ptr< ::std_msgs::Float32MultiArray_ > Ptr;
+  typedef boost::shared_ptr< ::std_msgs::Float32MultiArray_ const> ConstPtr;
+
+}; // struct Float32MultiArray_
+
+typedef ::std_msgs::Float32MultiArray_ > Float32MultiArray;
+
+typedef boost::shared_ptr< ::std_msgs::Float32MultiArray > Float32MultiArrayPtr;
+typedef boost::shared_ptr< ::std_msgs::Float32MultiArray const> Float32MultiArrayConstPtr;
+
+// constants requiring out of line definition
+
+
+
+template
+std::ostream& operator<<(std::ostream& s, const ::std_msgs::Float32MultiArray_ & v)
+{
+ros::message_operations::Printer< ::std_msgs::Float32MultiArray_ >::stream(s, "", v);
+return s;
+}
+
+} // namespace std_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': False}
+// {'std_msgs': ['/tmp/binarydeb/ros-kinetic-std-msgs-0.5.10/msg']}
+
+// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types']
+
+
+
+
+template 
+struct IsFixedSize< ::std_msgs::Float32MultiArray_ >
+  : FalseType
+  { };
+
+template 
+struct IsFixedSize< ::std_msgs::Float32MultiArray_ const>
+  : FalseType
+  { };
+
+template 
+struct IsMessage< ::std_msgs::Float32MultiArray_ >
+  : TrueType
+  { };
+
+template 
+struct IsMessage< ::std_msgs::Float32MultiArray_ const>
+  : TrueType
+  { };
+
+template 
+struct HasHeader< ::std_msgs::Float32MultiArray_ >
+  : FalseType
+  { };
+
+template 
+struct HasHeader< ::std_msgs::Float32MultiArray_ const>
+  : FalseType
+  { };
+
+
+template
+struct MD5Sum< ::std_msgs::Float32MultiArray_ >
+{
+  static const char* value()
+  {
+    return "6a40e0ffa6a17a503ac3f8616991b1f6";
+  }
+
+  static const char* value(const ::std_msgs::Float32MultiArray_&) { return value(); }
+  static const uint64_t static_value1 = 0x6a40e0ffa6a17a50ULL;
+  static const uint64_t static_value2 = 0x3ac3f8616991b1f6ULL;
+};
+
+template
+struct DataType< ::std_msgs::Float32MultiArray_ >
+{
+  static const char* value()
+  {
+    return "std_msgs/Float32MultiArray";
+  }
+
+  static const char* value(const ::std_msgs::Float32MultiArray_&) { return value(); }
+};
+
+template
+struct Definition< ::std_msgs::Float32MultiArray_ >
+{
+  static const char* value()
+  {
+    return "# Please look at the MultiArrayLayout message definition for\n\
+# documentation on all multiarrays.\n\
+\n\
+MultiArrayLayout  layout        # specification of data layout\n\
+float32[]         data          # array of data\n\
+\n\
+\n\
+================================================================================\n\
+MSG: std_msgs/MultiArrayLayout\n\
+# The multiarray declares a generic multi-dimensional array of a\n\
+# particular data type.  Dimensions are ordered from outer most\n\
+# to inner most.\n\
+\n\
+MultiArrayDimension[] dim # Array of dimension properties\n\
+uint32 data_offset        # padding elements at front of data\n\
+\n\
+# Accessors should ALWAYS be written in terms of dimension stride\n\
+# and specified outer-most dimension first.\n\
+# \n\
+# multiarray(i,j,k) = data[data_offset + dim_stride[1]*i + dim_stride[2]*j + k]\n\
+#\n\
+# A standard, 3-channel 640x480 image with interleaved color channels\n\
+# would be specified as:\n\
+#\n\
+# dim[0].label  = \"height\"\n\
+# dim[0].size   = 480\n\
+# dim[0].stride = 3*640*480 = 921600  (note dim[0] stride is just size of image)\n\
+# dim[1].label  = \"width\"\n\
+# dim[1].size   = 640\n\
+# dim[1].stride = 3*640 = 1920\n\
+# dim[2].label  = \"channel\"\n\
+# dim[2].size   = 3\n\
+# dim[2].stride = 3\n\
+#\n\
+# multiarray(i,j,k) refers to the ith row, jth column, and kth channel.\n\
+\n\
+================================================================================\n\
+MSG: std_msgs/MultiArrayDimension\n\
+string label   # label of given dimension\n\
+uint32 size    # size of given dimension (in type units)\n\
+uint32 stride  # stride of given dimension\n\
+";
+  }
+
+  static const char* value(const ::std_msgs::Float32MultiArray_&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template struct Serializer< ::std_msgs::Float32MultiArray_ >
+  {
+    template inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.layout);
+      stream.next(m.data);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER;
+  }; // struct Float32MultiArray_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template
+struct Printer< ::std_msgs::Float32MultiArray_ >
+{
+  template static void stream(Stream& s, const std::string& indent, const ::std_msgs::Float32MultiArray_& v)
+  {
+    s << indent << "layout: ";
+    s << std::endl;
+    Printer< ::std_msgs::MultiArrayLayout_ >::stream(s, indent + "  ", v.layout);
+    s << indent << "data[]" << std::endl;
+    for (size_t i = 0; i < v.data.size(); ++i)
+    {
+      s << indent << "  data[" << i << "]: ";
+      Printer::stream(s, indent + "  ", v.data[i]);
+    }
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // STD_MSGS_MESSAGE_FLOAT32MULTIARRAY_H
diff --git a/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/Float64.h b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/Float64.h
new file mode 100644
index 0000000000..ba5d84abb9
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/Float64.h
@@ -0,0 +1,186 @@
+// Generated by gencpp from file std_msgs/Float64.msg
+// DO NOT EDIT!
+
+
+#ifndef STD_MSGS_MESSAGE_FLOAT64_H
+#define STD_MSGS_MESSAGE_FLOAT64_H
+
+#include 
+#include 
+#include 
+#include 
+
+#include 
+#include 
+#include 
+#include 
+
+
+namespace std_msgs
+{
+template 
+struct Float64_
+{
+  typedef Float64_ Type;
+
+  Float64_()
+    : data(0.0)  {
+    }
+  Float64_(const ContainerAllocator& _alloc)
+    : data(0.0)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef double _data_type;
+  _data_type data;
+
+
+
+
+  typedef std::shared_ptr< ::std_msgs::Float64_ > Ptr;
+  typedef std::shared_ptr< ::std_msgs::Float64_ const> ConstPtr;
+
+}; // struct Float64_
+
+typedef ::std_msgs::Float64_ > Float64;
+
+typedef std::shared_ptr< ::std_msgs::Float64 > Float64Ptr;
+typedef std::shared_ptr< ::std_msgs::Float64 const> Float64ConstPtr;
+
+// constants requiring out of line definition
+
+
+
+template
+std::ostream& operator<<(std::ostream& s, const ::std_msgs::Float64_ & v)
+{
+ros::message_operations::Printer< ::std_msgs::Float64_ >::stream(s, "", v);
+return s;
+}
+
+} // namespace std_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+// BOOLTRAITS {'IsFixedSize': True, 'IsMessage': True, 'HasHeader': False}
+// {'std_msgs': ['/tmp/binarydeb/ros-kinetic-std-msgs-0.5.10/msg']}
+
+// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types']
+
+
+
+
+template 
+struct IsFixedSize< ::std_msgs::Float64_ >
+  : TrueType
+  { };
+
+template 
+struct IsFixedSize< ::std_msgs::Float64_ const>
+  : TrueType
+  { };
+
+template 
+struct IsMessage< ::std_msgs::Float64_ >
+  : TrueType
+  { };
+
+template 
+struct IsMessage< ::std_msgs::Float64_ const>
+  : TrueType
+  { };
+
+template 
+struct HasHeader< ::std_msgs::Float64_ >
+  : FalseType
+  { };
+
+template 
+struct HasHeader< ::std_msgs::Float64_ const>
+  : FalseType
+  { };
+
+
+template
+struct MD5Sum< ::std_msgs::Float64_ >
+{
+  static const char* value()
+  {
+    return "fdb28210bfa9d7c91146260178d9a584";
+  }
+
+  static const char* value(const ::std_msgs::Float64_&) { return value(); }
+  static const uint64_t static_value1 = 0xfdb28210bfa9d7c9ULL;
+  static const uint64_t static_value2 = 0x1146260178d9a584ULL;
+};
+
+template
+struct DataType< ::std_msgs::Float64_ >
+{
+  static const char* value()
+  {
+    return "std_msgs/Float64";
+  }
+
+  static const char* value(const ::std_msgs::Float64_&) { return value(); }
+};
+
+template
+struct Definition< ::std_msgs::Float64_ >
+{
+  static const char* value()
+  {
+    return "float64 data\n\
+";
+  }
+
+  static const char* value(const ::std_msgs::Float64_&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template struct Serializer< ::std_msgs::Float64_ >
+  {
+    template inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.data);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER;
+  }; // struct Float64_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template
+struct Printer< ::std_msgs::Float64_ >
+{
+  template static void stream(Stream& s, const std::string& indent, const ::std_msgs::Float64_& v)
+  {
+    s << indent << "data: ";
+    Printer::stream(s, indent + "  ", v.data);
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // STD_MSGS_MESSAGE_FLOAT64_H
diff --git a/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/Float64MultiArray.h b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/Float64MultiArray.h
new file mode 100644
index 0000000000..a74424c373
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/Float64MultiArray.h
@@ -0,0 +1,240 @@
+// Generated by gencpp from file std_msgs/Float64MultiArray.msg
+// DO NOT EDIT!
+
+
+#ifndef STD_MSGS_MESSAGE_FLOAT64MULTIARRAY_H
+#define STD_MSGS_MESSAGE_FLOAT64MULTIARRAY_H
+
+
+#include 
+#include 
+#include 
+
+#include 
+#include 
+#include 
+#include 
+
+#include 
+
+namespace std_msgs
+{
+template 
+struct Float64MultiArray_
+{
+  typedef Float64MultiArray_ Type;
+
+  Float64MultiArray_()
+    : layout()
+    , data()  {
+    }
+  Float64MultiArray_(const ContainerAllocator& _alloc)
+    : layout(_alloc)
+    , data(_alloc)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef  ::std_msgs::MultiArrayLayout_  _layout_type;
+  _layout_type layout;
+
+   typedef std::vector::other >  _data_type;
+  _data_type data;
+
+
+
+
+  typedef boost::shared_ptr< ::std_msgs::Float64MultiArray_ > Ptr;
+  typedef boost::shared_ptr< ::std_msgs::Float64MultiArray_ const> ConstPtr;
+
+}; // struct Float64MultiArray_
+
+typedef ::std_msgs::Float64MultiArray_ > Float64MultiArray;
+
+typedef boost::shared_ptr< ::std_msgs::Float64MultiArray > Float64MultiArrayPtr;
+typedef boost::shared_ptr< ::std_msgs::Float64MultiArray const> Float64MultiArrayConstPtr;
+
+// constants requiring out of line definition
+
+
+
+template
+std::ostream& operator<<(std::ostream& s, const ::std_msgs::Float64MultiArray_ & v)
+{
+ros::message_operations::Printer< ::std_msgs::Float64MultiArray_ >::stream(s, "", v);
+return s;
+}
+
+} // namespace std_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': False}
+// {'std_msgs': ['/tmp/binarydeb/ros-kinetic-std-msgs-0.5.10/msg']}
+
+// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types']
+
+
+
+
+template 
+struct IsFixedSize< ::std_msgs::Float64MultiArray_ >
+  : FalseType
+  { };
+
+template 
+struct IsFixedSize< ::std_msgs::Float64MultiArray_ const>
+  : FalseType
+  { };
+
+template 
+struct IsMessage< ::std_msgs::Float64MultiArray_ >
+  : TrueType
+  { };
+
+template 
+struct IsMessage< ::std_msgs::Float64MultiArray_ const>
+  : TrueType
+  { };
+
+template 
+struct HasHeader< ::std_msgs::Float64MultiArray_ >
+  : FalseType
+  { };
+
+template 
+struct HasHeader< ::std_msgs::Float64MultiArray_ const>
+  : FalseType
+  { };
+
+
+template
+struct MD5Sum< ::std_msgs::Float64MultiArray_ >
+{
+  static const char* value()
+  {
+    return "4b7d974086d4060e7db4613a7e6c3ba4";
+  }
+
+  static const char* value(const ::std_msgs::Float64MultiArray_&) { return value(); }
+  static const uint64_t static_value1 = 0x4b7d974086d4060eULL;
+  static const uint64_t static_value2 = 0x7db4613a7e6c3ba4ULL;
+};
+
+template
+struct DataType< ::std_msgs::Float64MultiArray_ >
+{
+  static const char* value()
+  {
+    return "std_msgs/Float64MultiArray";
+  }
+
+  static const char* value(const ::std_msgs::Float64MultiArray_&) { return value(); }
+};
+
+template
+struct Definition< ::std_msgs::Float64MultiArray_ >
+{
+  static const char* value()
+  {
+    return "# Please look at the MultiArrayLayout message definition for\n\
+# documentation on all multiarrays.\n\
+\n\
+MultiArrayLayout  layout        # specification of data layout\n\
+float64[]         data          # array of data\n\
+\n\
+\n\
+================================================================================\n\
+MSG: std_msgs/MultiArrayLayout\n\
+# The multiarray declares a generic multi-dimensional array of a\n\
+# particular data type.  Dimensions are ordered from outer most\n\
+# to inner most.\n\
+\n\
+MultiArrayDimension[] dim # Array of dimension properties\n\
+uint32 data_offset        # padding elements at front of data\n\
+\n\
+# Accessors should ALWAYS be written in terms of dimension stride\n\
+# and specified outer-most dimension first.\n\
+# \n\
+# multiarray(i,j,k) = data[data_offset + dim_stride[1]*i + dim_stride[2]*j + k]\n\
+#\n\
+# A standard, 3-channel 640x480 image with interleaved color channels\n\
+# would be specified as:\n\
+#\n\
+# dim[0].label  = \"height\"\n\
+# dim[0].size   = 480\n\
+# dim[0].stride = 3*640*480 = 921600  (note dim[0] stride is just size of image)\n\
+# dim[1].label  = \"width\"\n\
+# dim[1].size   = 640\n\
+# dim[1].stride = 3*640 = 1920\n\
+# dim[2].label  = \"channel\"\n\
+# dim[2].size   = 3\n\
+# dim[2].stride = 3\n\
+#\n\
+# multiarray(i,j,k) refers to the ith row, jth column, and kth channel.\n\
+\n\
+================================================================================\n\
+MSG: std_msgs/MultiArrayDimension\n\
+string label   # label of given dimension\n\
+uint32 size    # size of given dimension (in type units)\n\
+uint32 stride  # stride of given dimension\n\
+";
+  }
+
+  static const char* value(const ::std_msgs::Float64MultiArray_&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template struct Serializer< ::std_msgs::Float64MultiArray_ >
+  {
+    template inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.layout);
+      stream.next(m.data);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER;
+  }; // struct Float64MultiArray_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template
+struct Printer< ::std_msgs::Float64MultiArray_ >
+{
+  template static void stream(Stream& s, const std::string& indent, const ::std_msgs::Float64MultiArray_& v)
+  {
+    s << indent << "layout: ";
+    s << std::endl;
+    Printer< ::std_msgs::MultiArrayLayout_ >::stream(s, indent + "  ", v.layout);
+    s << indent << "data[]" << std::endl;
+    for (size_t i = 0; i < v.data.size(); ++i)
+    {
+      s << indent << "  data[" << i << "]: ";
+      Printer::stream(s, indent + "  ", v.data[i]);
+    }
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // STD_MSGS_MESSAGE_FLOAT64MULTIARRAY_H
diff --git a/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/Header.h b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/Header.h
new file mode 100644
index 0000000000..c7328d1eee
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/Header.h
@@ -0,0 +1,216 @@
+// Generated by gencpp from file std_msgs/Header.msg
+// DO NOT EDIT!
+
+
+#ifndef STD_MSGS_MESSAGE_HEADER_H
+#define STD_MSGS_MESSAGE_HEADER_H
+
+#include 
+#include 
+#include 
+#include 
+
+#include 
+#include 
+#include 
+#include 
+
+
+namespace std_msgs
+{
+template 
+struct Header_
+{
+  typedef Header_ Type;
+
+  Header_()
+    : seq(0)
+    , stamp()
+    , frame_id()  {
+    }
+  Header_(const ContainerAllocator& _alloc)
+    : seq(0)
+    , stamp()
+    , frame_id(_alloc)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef uint32_t _seq_type;
+  _seq_type seq;
+
+   typedef ros::Time _stamp_type;
+  _stamp_type stamp;
+
+   typedef std::basic_string, typename ContainerAllocator::template rebind::other >  _frame_id_type;
+  _frame_id_type frame_id;
+
+
+
+
+  typedef std::shared_ptr< ::std_msgs::Header_ > Ptr;
+  typedef std::shared_ptr< ::std_msgs::Header_ const> ConstPtr;
+
+}; // struct Header_
+
+typedef ::std_msgs::Header_ > Header;
+
+typedef std::shared_ptr< ::std_msgs::Header > HeaderPtr;
+typedef std::shared_ptr< ::std_msgs::Header const> HeaderConstPtr;
+
+// constants requiring out of line definition
+
+
+
+template
+std::ostream& operator<<(std::ostream& s, const ::std_msgs::Header_ & v)
+{
+ros::message_operations::Printer< ::std_msgs::Header_ >::stream(s, "", v);
+return s;
+}
+
+} // namespace std_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': False}
+// {'std_msgs': ['/tmp/binarydeb/ros-kinetic-std-msgs-0.5.10/msg']}
+
+// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types']
+
+
+
+
+template 
+struct IsFixedSize< ::std_msgs::Header_ >
+  : FalseType
+  { };
+
+template 
+struct IsFixedSize< ::std_msgs::Header_ const>
+  : FalseType
+  { };
+
+template 
+struct IsMessage< ::std_msgs::Header_ >
+  : TrueType
+  { };
+
+template 
+struct IsMessage< ::std_msgs::Header_ const>
+  : TrueType
+  { };
+
+template 
+struct HasHeader< ::std_msgs::Header_ >
+  : FalseType
+  { };
+
+template 
+struct HasHeader< ::std_msgs::Header_ const>
+  : FalseType
+  { };
+
+
+template
+struct MD5Sum< ::std_msgs::Header_ >
+{
+  static const char* value()
+  {
+    return "2176decaecbce78abc3b96ef049fabed";
+  }
+
+  static const char* value(const ::std_msgs::Header_&) { return value(); }
+  static const uint64_t static_value1 = 0x2176decaecbce78aULL;
+  static const uint64_t static_value2 = 0xbc3b96ef049fabedULL;
+};
+
+template
+struct DataType< ::std_msgs::Header_ >
+{
+  static const char* value()
+  {
+    return "std_msgs/Header";
+  }
+
+  static const char* value(const ::std_msgs::Header_&) { return value(); }
+};
+
+template
+struct Definition< ::std_msgs::Header_ >
+{
+  static const char* value()
+  {
+    return "# Standard metadata for higher-level stamped data types.\n\
+# This is generally used to communicate timestamped data \n\
+# in a particular coordinate frame.\n\
+# \n\
+# sequence ID: consecutively increasing ID \n\
+uint32 seq\n\
+#Two-integer timestamp that is expressed as:\n\
+# * stamp.sec: seconds (stamp_secs) since epoch (in Python the variable is called 'secs')\n\
+# * stamp.nsec: nanoseconds since stamp_secs (in Python the variable is called 'nsecs')\n\
+# time-handling sugar is provided by the client library\n\
+time stamp\n\
+#Frame this data is associated with\n\
+# 0: no frame\n\
+# 1: global frame\n\
+string frame_id\n\
+";
+  }
+
+  static const char* value(const ::std_msgs::Header_&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template struct Serializer< ::std_msgs::Header_ >
+  {
+    template inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.seq);
+      stream.next(m.stamp);
+      stream.next(m.frame_id);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER;
+  }; // struct Header_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template
+struct Printer< ::std_msgs::Header_ >
+{
+  template static void stream(Stream& s, const std::string& indent, const ::std_msgs::Header_& v)
+  {
+    s << indent << "seq: ";
+    Printer::stream(s, indent + "  ", v.seq);
+    s << indent << "stamp: ";
+    Printer::stream(s, indent + "  ", v.stamp);
+    s << indent << "frame_id: ";
+    Printer, typename ContainerAllocator::template rebind::other > >::stream(s, indent + "  ", v.frame_id);
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // STD_MSGS_MESSAGE_HEADER_H
diff --git a/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/Int16.h b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/Int16.h
new file mode 100644
index 0000000000..920af60b97
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/Int16.h
@@ -0,0 +1,186 @@
+// Generated by gencpp from file std_msgs/Int16.msg
+// DO NOT EDIT!
+
+
+#ifndef STD_MSGS_MESSAGE_INT16_H
+#define STD_MSGS_MESSAGE_INT16_H
+
+
+#include 
+#include 
+#include 
+
+#include 
+#include 
+#include 
+#include 
+
+
+namespace std_msgs
+{
+template 
+struct Int16_
+{
+  typedef Int16_ Type;
+
+  Int16_()
+    : data(0)  {
+    }
+  Int16_(const ContainerAllocator& _alloc)
+    : data(0)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef int16_t _data_type;
+  _data_type data;
+
+
+
+
+  typedef boost::shared_ptr< ::std_msgs::Int16_ > Ptr;
+  typedef boost::shared_ptr< ::std_msgs::Int16_ const> ConstPtr;
+
+}; // struct Int16_
+
+typedef ::std_msgs::Int16_ > Int16;
+
+typedef boost::shared_ptr< ::std_msgs::Int16 > Int16Ptr;
+typedef boost::shared_ptr< ::std_msgs::Int16 const> Int16ConstPtr;
+
+// constants requiring out of line definition
+
+
+
+template
+std::ostream& operator<<(std::ostream& s, const ::std_msgs::Int16_ & v)
+{
+ros::message_operations::Printer< ::std_msgs::Int16_ >::stream(s, "", v);
+return s;
+}
+
+} // namespace std_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+// BOOLTRAITS {'IsFixedSize': True, 'IsMessage': True, 'HasHeader': False}
+// {'std_msgs': ['/tmp/binarydeb/ros-kinetic-std-msgs-0.5.10/msg']}
+
+// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types']
+
+
+
+
+template 
+struct IsFixedSize< ::std_msgs::Int16_ >
+  : TrueType
+  { };
+
+template 
+struct IsFixedSize< ::std_msgs::Int16_ const>
+  : TrueType
+  { };
+
+template 
+struct IsMessage< ::std_msgs::Int16_ >
+  : TrueType
+  { };
+
+template 
+struct IsMessage< ::std_msgs::Int16_ const>
+  : TrueType
+  { };
+
+template 
+struct HasHeader< ::std_msgs::Int16_ >
+  : FalseType
+  { };
+
+template 
+struct HasHeader< ::std_msgs::Int16_ const>
+  : FalseType
+  { };
+
+
+template
+struct MD5Sum< ::std_msgs::Int16_ >
+{
+  static const char* value()
+  {
+    return "8524586e34fbd7cb1c08c5f5f1ca0e57";
+  }
+
+  static const char* value(const ::std_msgs::Int16_&) { return value(); }
+  static const uint64_t static_value1 = 0x8524586e34fbd7cbULL;
+  static const uint64_t static_value2 = 0x1c08c5f5f1ca0e57ULL;
+};
+
+template
+struct DataType< ::std_msgs::Int16_ >
+{
+  static const char* value()
+  {
+    return "std_msgs/Int16";
+  }
+
+  static const char* value(const ::std_msgs::Int16_&) { return value(); }
+};
+
+template
+struct Definition< ::std_msgs::Int16_ >
+{
+  static const char* value()
+  {
+    return "int16 data\n\
+";
+  }
+
+  static const char* value(const ::std_msgs::Int16_&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template struct Serializer< ::std_msgs::Int16_ >
+  {
+    template inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.data);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER;
+  }; // struct Int16_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template
+struct Printer< ::std_msgs::Int16_ >
+{
+  template static void stream(Stream& s, const std::string& indent, const ::std_msgs::Int16_& v)
+  {
+    s << indent << "data: ";
+    Printer::stream(s, indent + "  ", v.data);
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // STD_MSGS_MESSAGE_INT16_H
diff --git a/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/Int16MultiArray.h b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/Int16MultiArray.h
new file mode 100644
index 0000000000..5964ffdfa4
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/Int16MultiArray.h
@@ -0,0 +1,240 @@
+// Generated by gencpp from file std_msgs/Int16MultiArray.msg
+// DO NOT EDIT!
+
+
+#ifndef STD_MSGS_MESSAGE_INT16MULTIARRAY_H
+#define STD_MSGS_MESSAGE_INT16MULTIARRAY_H
+
+
+#include 
+#include 
+#include 
+
+#include 
+#include 
+#include 
+#include 
+
+#include 
+
+namespace std_msgs
+{
+template 
+struct Int16MultiArray_
+{
+  typedef Int16MultiArray_ Type;
+
+  Int16MultiArray_()
+    : layout()
+    , data()  {
+    }
+  Int16MultiArray_(const ContainerAllocator& _alloc)
+    : layout(_alloc)
+    , data(_alloc)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef  ::std_msgs::MultiArrayLayout_  _layout_type;
+  _layout_type layout;
+
+   typedef std::vector::other >  _data_type;
+  _data_type data;
+
+
+
+
+  typedef boost::shared_ptr< ::std_msgs::Int16MultiArray_ > Ptr;
+  typedef boost::shared_ptr< ::std_msgs::Int16MultiArray_ const> ConstPtr;
+
+}; // struct Int16MultiArray_
+
+typedef ::std_msgs::Int16MultiArray_ > Int16MultiArray;
+
+typedef boost::shared_ptr< ::std_msgs::Int16MultiArray > Int16MultiArrayPtr;
+typedef boost::shared_ptr< ::std_msgs::Int16MultiArray const> Int16MultiArrayConstPtr;
+
+// constants requiring out of line definition
+
+
+
+template
+std::ostream& operator<<(std::ostream& s, const ::std_msgs::Int16MultiArray_ & v)
+{
+ros::message_operations::Printer< ::std_msgs::Int16MultiArray_ >::stream(s, "", v);
+return s;
+}
+
+} // namespace std_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': False}
+// {'std_msgs': ['/tmp/binarydeb/ros-kinetic-std-msgs-0.5.10/msg']}
+
+// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types']
+
+
+
+
+template 
+struct IsFixedSize< ::std_msgs::Int16MultiArray_ >
+  : FalseType
+  { };
+
+template 
+struct IsFixedSize< ::std_msgs::Int16MultiArray_ const>
+  : FalseType
+  { };
+
+template 
+struct IsMessage< ::std_msgs::Int16MultiArray_ >
+  : TrueType
+  { };
+
+template 
+struct IsMessage< ::std_msgs::Int16MultiArray_ const>
+  : TrueType
+  { };
+
+template 
+struct HasHeader< ::std_msgs::Int16MultiArray_ >
+  : FalseType
+  { };
+
+template 
+struct HasHeader< ::std_msgs::Int16MultiArray_ const>
+  : FalseType
+  { };
+
+
+template
+struct MD5Sum< ::std_msgs::Int16MultiArray_ >
+{
+  static const char* value()
+  {
+    return "d9338d7f523fcb692fae9d0a0e9f067c";
+  }
+
+  static const char* value(const ::std_msgs::Int16MultiArray_&) { return value(); }
+  static const uint64_t static_value1 = 0xd9338d7f523fcb69ULL;
+  static const uint64_t static_value2 = 0x2fae9d0a0e9f067cULL;
+};
+
+template
+struct DataType< ::std_msgs::Int16MultiArray_ >
+{
+  static const char* value()
+  {
+    return "std_msgs/Int16MultiArray";
+  }
+
+  static const char* value(const ::std_msgs::Int16MultiArray_&) { return value(); }
+};
+
+template
+struct Definition< ::std_msgs::Int16MultiArray_ >
+{
+  static const char* value()
+  {
+    return "# Please look at the MultiArrayLayout message definition for\n\
+# documentation on all multiarrays.\n\
+\n\
+MultiArrayLayout  layout        # specification of data layout\n\
+int16[]           data          # array of data\n\
+\n\
+\n\
+================================================================================\n\
+MSG: std_msgs/MultiArrayLayout\n\
+# The multiarray declares a generic multi-dimensional array of a\n\
+# particular data type.  Dimensions are ordered from outer most\n\
+# to inner most.\n\
+\n\
+MultiArrayDimension[] dim # Array of dimension properties\n\
+uint32 data_offset        # padding elements at front of data\n\
+\n\
+# Accessors should ALWAYS be written in terms of dimension stride\n\
+# and specified outer-most dimension first.\n\
+# \n\
+# multiarray(i,j,k) = data[data_offset + dim_stride[1]*i + dim_stride[2]*j + k]\n\
+#\n\
+# A standard, 3-channel 640x480 image with interleaved color channels\n\
+# would be specified as:\n\
+#\n\
+# dim[0].label  = \"height\"\n\
+# dim[0].size   = 480\n\
+# dim[0].stride = 3*640*480 = 921600  (note dim[0] stride is just size of image)\n\
+# dim[1].label  = \"width\"\n\
+# dim[1].size   = 640\n\
+# dim[1].stride = 3*640 = 1920\n\
+# dim[2].label  = \"channel\"\n\
+# dim[2].size   = 3\n\
+# dim[2].stride = 3\n\
+#\n\
+# multiarray(i,j,k) refers to the ith row, jth column, and kth channel.\n\
+\n\
+================================================================================\n\
+MSG: std_msgs/MultiArrayDimension\n\
+string label   # label of given dimension\n\
+uint32 size    # size of given dimension (in type units)\n\
+uint32 stride  # stride of given dimension\n\
+";
+  }
+
+  static const char* value(const ::std_msgs::Int16MultiArray_&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template struct Serializer< ::std_msgs::Int16MultiArray_ >
+  {
+    template inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.layout);
+      stream.next(m.data);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER;
+  }; // struct Int16MultiArray_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template
+struct Printer< ::std_msgs::Int16MultiArray_ >
+{
+  template static void stream(Stream& s, const std::string& indent, const ::std_msgs::Int16MultiArray_& v)
+  {
+    s << indent << "layout: ";
+    s << std::endl;
+    Printer< ::std_msgs::MultiArrayLayout_ >::stream(s, indent + "  ", v.layout);
+    s << indent << "data[]" << std::endl;
+    for (size_t i = 0; i < v.data.size(); ++i)
+    {
+      s << indent << "  data[" << i << "]: ";
+      Printer::stream(s, indent + "  ", v.data[i]);
+    }
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // STD_MSGS_MESSAGE_INT16MULTIARRAY_H
diff --git a/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/Int32.h b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/Int32.h
new file mode 100644
index 0000000000..ad889a4ef1
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/Int32.h
@@ -0,0 +1,186 @@
+// Generated by gencpp from file std_msgs/Int32.msg
+// DO NOT EDIT!
+
+
+#ifndef STD_MSGS_MESSAGE_INT32_H
+#define STD_MSGS_MESSAGE_INT32_H
+
+
+#include 
+#include 
+#include 
+
+#include 
+#include 
+#include 
+#include 
+
+
+namespace std_msgs
+{
+template 
+struct Int32_
+{
+  typedef Int32_ Type;
+
+  Int32_()
+    : data(0)  {
+    }
+  Int32_(const ContainerAllocator& _alloc)
+    : data(0)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef int32_t _data_type;
+  _data_type data;
+
+
+
+
+  typedef boost::shared_ptr< ::std_msgs::Int32_ > Ptr;
+  typedef boost::shared_ptr< ::std_msgs::Int32_ const> ConstPtr;
+
+}; // struct Int32_
+
+typedef ::std_msgs::Int32_ > Int32;
+
+typedef boost::shared_ptr< ::std_msgs::Int32 > Int32Ptr;
+typedef boost::shared_ptr< ::std_msgs::Int32 const> Int32ConstPtr;
+
+// constants requiring out of line definition
+
+
+
+template
+std::ostream& operator<<(std::ostream& s, const ::std_msgs::Int32_ & v)
+{
+ros::message_operations::Printer< ::std_msgs::Int32_ >::stream(s, "", v);
+return s;
+}
+
+} // namespace std_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+// BOOLTRAITS {'IsFixedSize': True, 'IsMessage': True, 'HasHeader': False}
+// {'std_msgs': ['/tmp/binarydeb/ros-kinetic-std-msgs-0.5.10/msg']}
+
+// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types']
+
+
+
+
+template 
+struct IsFixedSize< ::std_msgs::Int32_ >
+  : TrueType
+  { };
+
+template 
+struct IsFixedSize< ::std_msgs::Int32_ const>
+  : TrueType
+  { };
+
+template 
+struct IsMessage< ::std_msgs::Int32_ >
+  : TrueType
+  { };
+
+template 
+struct IsMessage< ::std_msgs::Int32_ const>
+  : TrueType
+  { };
+
+template 
+struct HasHeader< ::std_msgs::Int32_ >
+  : FalseType
+  { };
+
+template 
+struct HasHeader< ::std_msgs::Int32_ const>
+  : FalseType
+  { };
+
+
+template
+struct MD5Sum< ::std_msgs::Int32_ >
+{
+  static const char* value()
+  {
+    return "da5909fbe378aeaf85e547e830cc1bb7";
+  }
+
+  static const char* value(const ::std_msgs::Int32_&) { return value(); }
+  static const uint64_t static_value1 = 0xda5909fbe378aeafULL;
+  static const uint64_t static_value2 = 0x85e547e830cc1bb7ULL;
+};
+
+template
+struct DataType< ::std_msgs::Int32_ >
+{
+  static const char* value()
+  {
+    return "std_msgs/Int32";
+  }
+
+  static const char* value(const ::std_msgs::Int32_&) { return value(); }
+};
+
+template
+struct Definition< ::std_msgs::Int32_ >
+{
+  static const char* value()
+  {
+    return "int32 data\n\
+";
+  }
+
+  static const char* value(const ::std_msgs::Int32_&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template struct Serializer< ::std_msgs::Int32_ >
+  {
+    template inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.data);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER;
+  }; // struct Int32_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template
+struct Printer< ::std_msgs::Int32_ >
+{
+  template static void stream(Stream& s, const std::string& indent, const ::std_msgs::Int32_& v)
+  {
+    s << indent << "data: ";
+    Printer::stream(s, indent + "  ", v.data);
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // STD_MSGS_MESSAGE_INT32_H
diff --git a/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/Int32MultiArray.h b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/Int32MultiArray.h
new file mode 100644
index 0000000000..7b01c5d590
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/Int32MultiArray.h
@@ -0,0 +1,240 @@
+// Generated by gencpp from file std_msgs/Int32MultiArray.msg
+// DO NOT EDIT!
+
+
+#ifndef STD_MSGS_MESSAGE_INT32MULTIARRAY_H
+#define STD_MSGS_MESSAGE_INT32MULTIARRAY_H
+
+
+#include 
+#include 
+#include 
+
+#include 
+#include 
+#include 
+#include 
+
+#include 
+
+namespace std_msgs
+{
+template 
+struct Int32MultiArray_
+{
+  typedef Int32MultiArray_ Type;
+
+  Int32MultiArray_()
+    : layout()
+    , data()  {
+    }
+  Int32MultiArray_(const ContainerAllocator& _alloc)
+    : layout(_alloc)
+    , data(_alloc)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef  ::std_msgs::MultiArrayLayout_  _layout_type;
+  _layout_type layout;
+
+   typedef std::vector::other >  _data_type;
+  _data_type data;
+
+
+
+
+  typedef boost::shared_ptr< ::std_msgs::Int32MultiArray_ > Ptr;
+  typedef boost::shared_ptr< ::std_msgs::Int32MultiArray_ const> ConstPtr;
+
+}; // struct Int32MultiArray_
+
+typedef ::std_msgs::Int32MultiArray_ > Int32MultiArray;
+
+typedef boost::shared_ptr< ::std_msgs::Int32MultiArray > Int32MultiArrayPtr;
+typedef boost::shared_ptr< ::std_msgs::Int32MultiArray const> Int32MultiArrayConstPtr;
+
+// constants requiring out of line definition
+
+
+
+template
+std::ostream& operator<<(std::ostream& s, const ::std_msgs::Int32MultiArray_ & v)
+{
+ros::message_operations::Printer< ::std_msgs::Int32MultiArray_ >::stream(s, "", v);
+return s;
+}
+
+} // namespace std_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': False}
+// {'std_msgs': ['/tmp/binarydeb/ros-kinetic-std-msgs-0.5.10/msg']}
+
+// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types']
+
+
+
+
+template 
+struct IsFixedSize< ::std_msgs::Int32MultiArray_ >
+  : FalseType
+  { };
+
+template 
+struct IsFixedSize< ::std_msgs::Int32MultiArray_ const>
+  : FalseType
+  { };
+
+template 
+struct IsMessage< ::std_msgs::Int32MultiArray_ >
+  : TrueType
+  { };
+
+template 
+struct IsMessage< ::std_msgs::Int32MultiArray_ const>
+  : TrueType
+  { };
+
+template 
+struct HasHeader< ::std_msgs::Int32MultiArray_ >
+  : FalseType
+  { };
+
+template 
+struct HasHeader< ::std_msgs::Int32MultiArray_ const>
+  : FalseType
+  { };
+
+
+template
+struct MD5Sum< ::std_msgs::Int32MultiArray_ >
+{
+  static const char* value()
+  {
+    return "1d99f79f8b325b44fee908053e9c945b";
+  }
+
+  static const char* value(const ::std_msgs::Int32MultiArray_&) { return value(); }
+  static const uint64_t static_value1 = 0x1d99f79f8b325b44ULL;
+  static const uint64_t static_value2 = 0xfee908053e9c945bULL;
+};
+
+template
+struct DataType< ::std_msgs::Int32MultiArray_ >
+{
+  static const char* value()
+  {
+    return "std_msgs/Int32MultiArray";
+  }
+
+  static const char* value(const ::std_msgs::Int32MultiArray_&) { return value(); }
+};
+
+template
+struct Definition< ::std_msgs::Int32MultiArray_ >
+{
+  static const char* value()
+  {
+    return "# Please look at the MultiArrayLayout message definition for\n\
+# documentation on all multiarrays.\n\
+\n\
+MultiArrayLayout  layout        # specification of data layout\n\
+int32[]           data          # array of data\n\
+\n\
+\n\
+================================================================================\n\
+MSG: std_msgs/MultiArrayLayout\n\
+# The multiarray declares a generic multi-dimensional array of a\n\
+# particular data type.  Dimensions are ordered from outer most\n\
+# to inner most.\n\
+\n\
+MultiArrayDimension[] dim # Array of dimension properties\n\
+uint32 data_offset        # padding elements at front of data\n\
+\n\
+# Accessors should ALWAYS be written in terms of dimension stride\n\
+# and specified outer-most dimension first.\n\
+# \n\
+# multiarray(i,j,k) = data[data_offset + dim_stride[1]*i + dim_stride[2]*j + k]\n\
+#\n\
+# A standard, 3-channel 640x480 image with interleaved color channels\n\
+# would be specified as:\n\
+#\n\
+# dim[0].label  = \"height\"\n\
+# dim[0].size   = 480\n\
+# dim[0].stride = 3*640*480 = 921600  (note dim[0] stride is just size of image)\n\
+# dim[1].label  = \"width\"\n\
+# dim[1].size   = 640\n\
+# dim[1].stride = 3*640 = 1920\n\
+# dim[2].label  = \"channel\"\n\
+# dim[2].size   = 3\n\
+# dim[2].stride = 3\n\
+#\n\
+# multiarray(i,j,k) refers to the ith row, jth column, and kth channel.\n\
+\n\
+================================================================================\n\
+MSG: std_msgs/MultiArrayDimension\n\
+string label   # label of given dimension\n\
+uint32 size    # size of given dimension (in type units)\n\
+uint32 stride  # stride of given dimension\n\
+";
+  }
+
+  static const char* value(const ::std_msgs::Int32MultiArray_&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template struct Serializer< ::std_msgs::Int32MultiArray_ >
+  {
+    template inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.layout);
+      stream.next(m.data);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER;
+  }; // struct Int32MultiArray_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template
+struct Printer< ::std_msgs::Int32MultiArray_ >
+{
+  template static void stream(Stream& s, const std::string& indent, const ::std_msgs::Int32MultiArray_& v)
+  {
+    s << indent << "layout: ";
+    s << std::endl;
+    Printer< ::std_msgs::MultiArrayLayout_ >::stream(s, indent + "  ", v.layout);
+    s << indent << "data[]" << std::endl;
+    for (size_t i = 0; i < v.data.size(); ++i)
+    {
+      s << indent << "  data[" << i << "]: ";
+      Printer::stream(s, indent + "  ", v.data[i]);
+    }
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // STD_MSGS_MESSAGE_INT32MULTIARRAY_H
diff --git a/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/Int64.h b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/Int64.h
new file mode 100644
index 0000000000..e96b16c9ab
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/Int64.h
@@ -0,0 +1,186 @@
+// Generated by gencpp from file std_msgs/Int64.msg
+// DO NOT EDIT!
+
+
+#ifndef STD_MSGS_MESSAGE_INT64_H
+#define STD_MSGS_MESSAGE_INT64_H
+
+
+#include 
+#include 
+#include 
+
+#include 
+#include 
+#include 
+#include 
+
+
+namespace std_msgs
+{
+template 
+struct Int64_
+{
+  typedef Int64_ Type;
+
+  Int64_()
+    : data(0)  {
+    }
+  Int64_(const ContainerAllocator& _alloc)
+    : data(0)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef int64_t _data_type;
+  _data_type data;
+
+
+
+
+  typedef boost::shared_ptr< ::std_msgs::Int64_ > Ptr;
+  typedef boost::shared_ptr< ::std_msgs::Int64_ const> ConstPtr;
+
+}; // struct Int64_
+
+typedef ::std_msgs::Int64_ > Int64;
+
+typedef boost::shared_ptr< ::std_msgs::Int64 > Int64Ptr;
+typedef boost::shared_ptr< ::std_msgs::Int64 const> Int64ConstPtr;
+
+// constants requiring out of line definition
+
+
+
+template
+std::ostream& operator<<(std::ostream& s, const ::std_msgs::Int64_ & v)
+{
+ros::message_operations::Printer< ::std_msgs::Int64_ >::stream(s, "", v);
+return s;
+}
+
+} // namespace std_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+// BOOLTRAITS {'IsFixedSize': True, 'IsMessage': True, 'HasHeader': False}
+// {'std_msgs': ['/tmp/binarydeb/ros-kinetic-std-msgs-0.5.10/msg']}
+
+// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types']
+
+
+
+
+template 
+struct IsFixedSize< ::std_msgs::Int64_ >
+  : TrueType
+  { };
+
+template 
+struct IsFixedSize< ::std_msgs::Int64_ const>
+  : TrueType
+  { };
+
+template 
+struct IsMessage< ::std_msgs::Int64_ >
+  : TrueType
+  { };
+
+template 
+struct IsMessage< ::std_msgs::Int64_ const>
+  : TrueType
+  { };
+
+template 
+struct HasHeader< ::std_msgs::Int64_ >
+  : FalseType
+  { };
+
+template 
+struct HasHeader< ::std_msgs::Int64_ const>
+  : FalseType
+  { };
+
+
+template
+struct MD5Sum< ::std_msgs::Int64_ >
+{
+  static const char* value()
+  {
+    return "34add168574510e6e17f5d23ecc077ef";
+  }
+
+  static const char* value(const ::std_msgs::Int64_&) { return value(); }
+  static const uint64_t static_value1 = 0x34add168574510e6ULL;
+  static const uint64_t static_value2 = 0xe17f5d23ecc077efULL;
+};
+
+template
+struct DataType< ::std_msgs::Int64_ >
+{
+  static const char* value()
+  {
+    return "std_msgs/Int64";
+  }
+
+  static const char* value(const ::std_msgs::Int64_&) { return value(); }
+};
+
+template
+struct Definition< ::std_msgs::Int64_ >
+{
+  static const char* value()
+  {
+    return "int64 data\n\
+";
+  }
+
+  static const char* value(const ::std_msgs::Int64_&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template struct Serializer< ::std_msgs::Int64_ >
+  {
+    template inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.data);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER;
+  }; // struct Int64_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template
+struct Printer< ::std_msgs::Int64_ >
+{
+  template static void stream(Stream& s, const std::string& indent, const ::std_msgs::Int64_& v)
+  {
+    s << indent << "data: ";
+    Printer::stream(s, indent + "  ", v.data);
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // STD_MSGS_MESSAGE_INT64_H
diff --git a/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/Int64MultiArray.h b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/Int64MultiArray.h
new file mode 100644
index 0000000000..70df38a0ce
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/Int64MultiArray.h
@@ -0,0 +1,240 @@
+// Generated by gencpp from file std_msgs/Int64MultiArray.msg
+// DO NOT EDIT!
+
+
+#ifndef STD_MSGS_MESSAGE_INT64MULTIARRAY_H
+#define STD_MSGS_MESSAGE_INT64MULTIARRAY_H
+
+
+#include 
+#include 
+#include 
+
+#include 
+#include 
+#include 
+#include 
+
+#include 
+
+namespace std_msgs
+{
+template 
+struct Int64MultiArray_
+{
+  typedef Int64MultiArray_ Type;
+
+  Int64MultiArray_()
+    : layout()
+    , data()  {
+    }
+  Int64MultiArray_(const ContainerAllocator& _alloc)
+    : layout(_alloc)
+    , data(_alloc)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef  ::std_msgs::MultiArrayLayout_  _layout_type;
+  _layout_type layout;
+
+   typedef std::vector::other >  _data_type;
+  _data_type data;
+
+
+
+
+  typedef boost::shared_ptr< ::std_msgs::Int64MultiArray_ > Ptr;
+  typedef boost::shared_ptr< ::std_msgs::Int64MultiArray_ const> ConstPtr;
+
+}; // struct Int64MultiArray_
+
+typedef ::std_msgs::Int64MultiArray_ > Int64MultiArray;
+
+typedef boost::shared_ptr< ::std_msgs::Int64MultiArray > Int64MultiArrayPtr;
+typedef boost::shared_ptr< ::std_msgs::Int64MultiArray const> Int64MultiArrayConstPtr;
+
+// constants requiring out of line definition
+
+
+
+template
+std::ostream& operator<<(std::ostream& s, const ::std_msgs::Int64MultiArray_ & v)
+{
+ros::message_operations::Printer< ::std_msgs::Int64MultiArray_ >::stream(s, "", v);
+return s;
+}
+
+} // namespace std_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': False}
+// {'std_msgs': ['/tmp/binarydeb/ros-kinetic-std-msgs-0.5.10/msg']}
+
+// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types']
+
+
+
+
+template 
+struct IsFixedSize< ::std_msgs::Int64MultiArray_ >
+  : FalseType
+  { };
+
+template 
+struct IsFixedSize< ::std_msgs::Int64MultiArray_ const>
+  : FalseType
+  { };
+
+template 
+struct IsMessage< ::std_msgs::Int64MultiArray_ >
+  : TrueType
+  { };
+
+template 
+struct IsMessage< ::std_msgs::Int64MultiArray_ const>
+  : TrueType
+  { };
+
+template 
+struct HasHeader< ::std_msgs::Int64MultiArray_ >
+  : FalseType
+  { };
+
+template 
+struct HasHeader< ::std_msgs::Int64MultiArray_ const>
+  : FalseType
+  { };
+
+
+template
+struct MD5Sum< ::std_msgs::Int64MultiArray_ >
+{
+  static const char* value()
+  {
+    return "54865aa6c65be0448113a2afc6a49270";
+  }
+
+  static const char* value(const ::std_msgs::Int64MultiArray_&) { return value(); }
+  static const uint64_t static_value1 = 0x54865aa6c65be044ULL;
+  static const uint64_t static_value2 = 0x8113a2afc6a49270ULL;
+};
+
+template
+struct DataType< ::std_msgs::Int64MultiArray_ >
+{
+  static const char* value()
+  {
+    return "std_msgs/Int64MultiArray";
+  }
+
+  static const char* value(const ::std_msgs::Int64MultiArray_&) { return value(); }
+};
+
+template
+struct Definition< ::std_msgs::Int64MultiArray_ >
+{
+  static const char* value()
+  {
+    return "# Please look at the MultiArrayLayout message definition for\n\
+# documentation on all multiarrays.\n\
+\n\
+MultiArrayLayout  layout        # specification of data layout\n\
+int64[]           data          # array of data\n\
+\n\
+\n\
+================================================================================\n\
+MSG: std_msgs/MultiArrayLayout\n\
+# The multiarray declares a generic multi-dimensional array of a\n\
+# particular data type.  Dimensions are ordered from outer most\n\
+# to inner most.\n\
+\n\
+MultiArrayDimension[] dim # Array of dimension properties\n\
+uint32 data_offset        # padding elements at front of data\n\
+\n\
+# Accessors should ALWAYS be written in terms of dimension stride\n\
+# and specified outer-most dimension first.\n\
+# \n\
+# multiarray(i,j,k) = data[data_offset + dim_stride[1]*i + dim_stride[2]*j + k]\n\
+#\n\
+# A standard, 3-channel 640x480 image with interleaved color channels\n\
+# would be specified as:\n\
+#\n\
+# dim[0].label  = \"height\"\n\
+# dim[0].size   = 480\n\
+# dim[0].stride = 3*640*480 = 921600  (note dim[0] stride is just size of image)\n\
+# dim[1].label  = \"width\"\n\
+# dim[1].size   = 640\n\
+# dim[1].stride = 3*640 = 1920\n\
+# dim[2].label  = \"channel\"\n\
+# dim[2].size   = 3\n\
+# dim[2].stride = 3\n\
+#\n\
+# multiarray(i,j,k) refers to the ith row, jth column, and kth channel.\n\
+\n\
+================================================================================\n\
+MSG: std_msgs/MultiArrayDimension\n\
+string label   # label of given dimension\n\
+uint32 size    # size of given dimension (in type units)\n\
+uint32 stride  # stride of given dimension\n\
+";
+  }
+
+  static const char* value(const ::std_msgs::Int64MultiArray_&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template struct Serializer< ::std_msgs::Int64MultiArray_ >
+  {
+    template inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.layout);
+      stream.next(m.data);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER;
+  }; // struct Int64MultiArray_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template
+struct Printer< ::std_msgs::Int64MultiArray_ >
+{
+  template static void stream(Stream& s, const std::string& indent, const ::std_msgs::Int64MultiArray_& v)
+  {
+    s << indent << "layout: ";
+    s << std::endl;
+    Printer< ::std_msgs::MultiArrayLayout_ >::stream(s, indent + "  ", v.layout);
+    s << indent << "data[]" << std::endl;
+    for (size_t i = 0; i < v.data.size(); ++i)
+    {
+      s << indent << "  data[" << i << "]: ";
+      Printer::stream(s, indent + "  ", v.data[i]);
+    }
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // STD_MSGS_MESSAGE_INT64MULTIARRAY_H
diff --git a/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/Int8.h b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/Int8.h
new file mode 100644
index 0000000000..b36007c74a
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/Int8.h
@@ -0,0 +1,186 @@
+// Generated by gencpp from file std_msgs/Int8.msg
+// DO NOT EDIT!
+
+
+#ifndef STD_MSGS_MESSAGE_INT8_H
+#define STD_MSGS_MESSAGE_INT8_H
+
+
+#include 
+#include 
+#include 
+
+#include 
+#include 
+#include 
+#include 
+
+
+namespace std_msgs
+{
+template 
+struct Int8_
+{
+  typedef Int8_ Type;
+
+  Int8_()
+    : data(0)  {
+    }
+  Int8_(const ContainerAllocator& _alloc)
+    : data(0)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef int8_t _data_type;
+  _data_type data;
+
+
+
+
+  typedef boost::shared_ptr< ::std_msgs::Int8_ > Ptr;
+  typedef boost::shared_ptr< ::std_msgs::Int8_ const> ConstPtr;
+
+}; // struct Int8_
+
+typedef ::std_msgs::Int8_ > Int8;
+
+typedef boost::shared_ptr< ::std_msgs::Int8 > Int8Ptr;
+typedef boost::shared_ptr< ::std_msgs::Int8 const> Int8ConstPtr;
+
+// constants requiring out of line definition
+
+
+
+template
+std::ostream& operator<<(std::ostream& s, const ::std_msgs::Int8_ & v)
+{
+ros::message_operations::Printer< ::std_msgs::Int8_ >::stream(s, "", v);
+return s;
+}
+
+} // namespace std_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+// BOOLTRAITS {'IsFixedSize': True, 'IsMessage': True, 'HasHeader': False}
+// {'std_msgs': ['/tmp/binarydeb/ros-kinetic-std-msgs-0.5.10/msg']}
+
+// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types']
+
+
+
+
+template 
+struct IsFixedSize< ::std_msgs::Int8_ >
+  : TrueType
+  { };
+
+template 
+struct IsFixedSize< ::std_msgs::Int8_ const>
+  : TrueType
+  { };
+
+template 
+struct IsMessage< ::std_msgs::Int8_ >
+  : TrueType
+  { };
+
+template 
+struct IsMessage< ::std_msgs::Int8_ const>
+  : TrueType
+  { };
+
+template 
+struct HasHeader< ::std_msgs::Int8_ >
+  : FalseType
+  { };
+
+template 
+struct HasHeader< ::std_msgs::Int8_ const>
+  : FalseType
+  { };
+
+
+template
+struct MD5Sum< ::std_msgs::Int8_ >
+{
+  static const char* value()
+  {
+    return "27ffa0c9c4b8fb8492252bcad9e5c57b";
+  }
+
+  static const char* value(const ::std_msgs::Int8_&) { return value(); }
+  static const uint64_t static_value1 = 0x27ffa0c9c4b8fb84ULL;
+  static const uint64_t static_value2 = 0x92252bcad9e5c57bULL;
+};
+
+template
+struct DataType< ::std_msgs::Int8_ >
+{
+  static const char* value()
+  {
+    return "std_msgs/Int8";
+  }
+
+  static const char* value(const ::std_msgs::Int8_&) { return value(); }
+};
+
+template
+struct Definition< ::std_msgs::Int8_ >
+{
+  static const char* value()
+  {
+    return "int8 data\n\
+";
+  }
+
+  static const char* value(const ::std_msgs::Int8_&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template struct Serializer< ::std_msgs::Int8_ >
+  {
+    template inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.data);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER;
+  }; // struct Int8_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template
+struct Printer< ::std_msgs::Int8_ >
+{
+  template static void stream(Stream& s, const std::string& indent, const ::std_msgs::Int8_& v)
+  {
+    s << indent << "data: ";
+    Printer::stream(s, indent + "  ", v.data);
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // STD_MSGS_MESSAGE_INT8_H
diff --git a/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/Int8MultiArray.h b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/Int8MultiArray.h
new file mode 100644
index 0000000000..3ff6b71082
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/Int8MultiArray.h
@@ -0,0 +1,240 @@
+// Generated by gencpp from file std_msgs/Int8MultiArray.msg
+// DO NOT EDIT!
+
+
+#ifndef STD_MSGS_MESSAGE_INT8MULTIARRAY_H
+#define STD_MSGS_MESSAGE_INT8MULTIARRAY_H
+
+
+#include 
+#include 
+#include 
+
+#include 
+#include 
+#include 
+#include 
+
+#include 
+
+namespace std_msgs
+{
+template 
+struct Int8MultiArray_
+{
+  typedef Int8MultiArray_ Type;
+
+  Int8MultiArray_()
+    : layout()
+    , data()  {
+    }
+  Int8MultiArray_(const ContainerAllocator& _alloc)
+    : layout(_alloc)
+    , data(_alloc)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef  ::std_msgs::MultiArrayLayout_  _layout_type;
+  _layout_type layout;
+
+   typedef std::vector::other >  _data_type;
+  _data_type data;
+
+
+
+
+  typedef boost::shared_ptr< ::std_msgs::Int8MultiArray_ > Ptr;
+  typedef boost::shared_ptr< ::std_msgs::Int8MultiArray_ const> ConstPtr;
+
+}; // struct Int8MultiArray_
+
+typedef ::std_msgs::Int8MultiArray_ > Int8MultiArray;
+
+typedef boost::shared_ptr< ::std_msgs::Int8MultiArray > Int8MultiArrayPtr;
+typedef boost::shared_ptr< ::std_msgs::Int8MultiArray const> Int8MultiArrayConstPtr;
+
+// constants requiring out of line definition
+
+
+
+template
+std::ostream& operator<<(std::ostream& s, const ::std_msgs::Int8MultiArray_ & v)
+{
+ros::message_operations::Printer< ::std_msgs::Int8MultiArray_ >::stream(s, "", v);
+return s;
+}
+
+} // namespace std_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': False}
+// {'std_msgs': ['/tmp/binarydeb/ros-kinetic-std-msgs-0.5.10/msg']}
+
+// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types']
+
+
+
+
+template 
+struct IsFixedSize< ::std_msgs::Int8MultiArray_ >
+  : FalseType
+  { };
+
+template 
+struct IsFixedSize< ::std_msgs::Int8MultiArray_ const>
+  : FalseType
+  { };
+
+template 
+struct IsMessage< ::std_msgs::Int8MultiArray_ >
+  : TrueType
+  { };
+
+template 
+struct IsMessage< ::std_msgs::Int8MultiArray_ const>
+  : TrueType
+  { };
+
+template 
+struct HasHeader< ::std_msgs::Int8MultiArray_ >
+  : FalseType
+  { };
+
+template 
+struct HasHeader< ::std_msgs::Int8MultiArray_ const>
+  : FalseType
+  { };
+
+
+template
+struct MD5Sum< ::std_msgs::Int8MultiArray_ >
+{
+  static const char* value()
+  {
+    return "d7c1af35a1b4781bbe79e03dd94b7c13";
+  }
+
+  static const char* value(const ::std_msgs::Int8MultiArray_&) { return value(); }
+  static const uint64_t static_value1 = 0xd7c1af35a1b4781bULL;
+  static const uint64_t static_value2 = 0xbe79e03dd94b7c13ULL;
+};
+
+template
+struct DataType< ::std_msgs::Int8MultiArray_ >
+{
+  static const char* value()
+  {
+    return "std_msgs/Int8MultiArray";
+  }
+
+  static const char* value(const ::std_msgs::Int8MultiArray_&) { return value(); }
+};
+
+template
+struct Definition< ::std_msgs::Int8MultiArray_ >
+{
+  static const char* value()
+  {
+    return "# Please look at the MultiArrayLayout message definition for\n\
+# documentation on all multiarrays.\n\
+\n\
+MultiArrayLayout  layout        # specification of data layout\n\
+int8[]            data          # array of data\n\
+\n\
+\n\
+================================================================================\n\
+MSG: std_msgs/MultiArrayLayout\n\
+# The multiarray declares a generic multi-dimensional array of a\n\
+# particular data type.  Dimensions are ordered from outer most\n\
+# to inner most.\n\
+\n\
+MultiArrayDimension[] dim # Array of dimension properties\n\
+uint32 data_offset        # padding elements at front of data\n\
+\n\
+# Accessors should ALWAYS be written in terms of dimension stride\n\
+# and specified outer-most dimension first.\n\
+# \n\
+# multiarray(i,j,k) = data[data_offset + dim_stride[1]*i + dim_stride[2]*j + k]\n\
+#\n\
+# A standard, 3-channel 640x480 image with interleaved color channels\n\
+# would be specified as:\n\
+#\n\
+# dim[0].label  = \"height\"\n\
+# dim[0].size   = 480\n\
+# dim[0].stride = 3*640*480 = 921600  (note dim[0] stride is just size of image)\n\
+# dim[1].label  = \"width\"\n\
+# dim[1].size   = 640\n\
+# dim[1].stride = 3*640 = 1920\n\
+# dim[2].label  = \"channel\"\n\
+# dim[2].size   = 3\n\
+# dim[2].stride = 3\n\
+#\n\
+# multiarray(i,j,k) refers to the ith row, jth column, and kth channel.\n\
+\n\
+================================================================================\n\
+MSG: std_msgs/MultiArrayDimension\n\
+string label   # label of given dimension\n\
+uint32 size    # size of given dimension (in type units)\n\
+uint32 stride  # stride of given dimension\n\
+";
+  }
+
+  static const char* value(const ::std_msgs::Int8MultiArray_&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template struct Serializer< ::std_msgs::Int8MultiArray_ >
+  {
+    template inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.layout);
+      stream.next(m.data);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER;
+  }; // struct Int8MultiArray_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template
+struct Printer< ::std_msgs::Int8MultiArray_ >
+{
+  template static void stream(Stream& s, const std::string& indent, const ::std_msgs::Int8MultiArray_& v)
+  {
+    s << indent << "layout: ";
+    s << std::endl;
+    Printer< ::std_msgs::MultiArrayLayout_ >::stream(s, indent + "  ", v.layout);
+    s << indent << "data[]" << std::endl;
+    for (size_t i = 0; i < v.data.size(); ++i)
+    {
+      s << indent << "  data[" << i << "]: ";
+      Printer::stream(s, indent + "  ", v.data[i]);
+    }
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // STD_MSGS_MESSAGE_INT8MULTIARRAY_H
diff --git a/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/MultiArrayDimension.h b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/MultiArrayDimension.h
new file mode 100644
index 0000000000..e81a8cf8d4
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/MultiArrayDimension.h
@@ -0,0 +1,204 @@
+// Generated by gencpp from file std_msgs/MultiArrayDimension.msg
+// DO NOT EDIT!
+
+
+#ifndef STD_MSGS_MESSAGE_MULTIARRAYDIMENSION_H
+#define STD_MSGS_MESSAGE_MULTIARRAYDIMENSION_H
+
+
+#include 
+#include 
+#include 
+
+#include 
+#include 
+#include 
+#include 
+
+
+namespace std_msgs
+{
+template 
+struct MultiArrayDimension_
+{
+  typedef MultiArrayDimension_ Type;
+
+  MultiArrayDimension_()
+    : label()
+    , size(0)
+    , stride(0)  {
+    }
+  MultiArrayDimension_(const ContainerAllocator& _alloc)
+    : label(_alloc)
+    , size(0)
+    , stride(0)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef std::basic_string, typename ContainerAllocator::template rebind::other >  _label_type;
+  _label_type label;
+
+   typedef uint32_t _size_type;
+  _size_type size;
+
+   typedef uint32_t _stride_type;
+  _stride_type stride;
+
+
+
+
+  typedef boost::shared_ptr< ::std_msgs::MultiArrayDimension_ > Ptr;
+  typedef boost::shared_ptr< ::std_msgs::MultiArrayDimension_ const> ConstPtr;
+
+}; // struct MultiArrayDimension_
+
+typedef ::std_msgs::MultiArrayDimension_ > MultiArrayDimension;
+
+typedef boost::shared_ptr< ::std_msgs::MultiArrayDimension > MultiArrayDimensionPtr;
+typedef boost::shared_ptr< ::std_msgs::MultiArrayDimension const> MultiArrayDimensionConstPtr;
+
+// constants requiring out of line definition
+
+
+
+template
+std::ostream& operator<<(std::ostream& s, const ::std_msgs::MultiArrayDimension_ & v)
+{
+ros::message_operations::Printer< ::std_msgs::MultiArrayDimension_ >::stream(s, "", v);
+return s;
+}
+
+} // namespace std_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': False}
+// {'std_msgs': ['/tmp/binarydeb/ros-kinetic-std-msgs-0.5.10/msg']}
+
+// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types']
+
+
+
+
+template 
+struct IsFixedSize< ::std_msgs::MultiArrayDimension_ >
+  : FalseType
+  { };
+
+template 
+struct IsFixedSize< ::std_msgs::MultiArrayDimension_ const>
+  : FalseType
+  { };
+
+template 
+struct IsMessage< ::std_msgs::MultiArrayDimension_ >
+  : TrueType
+  { };
+
+template 
+struct IsMessage< ::std_msgs::MultiArrayDimension_ const>
+  : TrueType
+  { };
+
+template 
+struct HasHeader< ::std_msgs::MultiArrayDimension_ >
+  : FalseType
+  { };
+
+template 
+struct HasHeader< ::std_msgs::MultiArrayDimension_ const>
+  : FalseType
+  { };
+
+
+template
+struct MD5Sum< ::std_msgs::MultiArrayDimension_ >
+{
+  static const char* value()
+  {
+    return "4cd0c83a8683deae40ecdac60e53bfa8";
+  }
+
+  static const char* value(const ::std_msgs::MultiArrayDimension_&) { return value(); }
+  static const uint64_t static_value1 = 0x4cd0c83a8683deaeULL;
+  static const uint64_t static_value2 = 0x40ecdac60e53bfa8ULL;
+};
+
+template
+struct DataType< ::std_msgs::MultiArrayDimension_ >
+{
+  static const char* value()
+  {
+    return "std_msgs/MultiArrayDimension";
+  }
+
+  static const char* value(const ::std_msgs::MultiArrayDimension_&) { return value(); }
+};
+
+template
+struct Definition< ::std_msgs::MultiArrayDimension_ >
+{
+  static const char* value()
+  {
+    return "string label   # label of given dimension\n\
+uint32 size    # size of given dimension (in type units)\n\
+uint32 stride  # stride of given dimension\n\
+";
+  }
+
+  static const char* value(const ::std_msgs::MultiArrayDimension_&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template struct Serializer< ::std_msgs::MultiArrayDimension_ >
+  {
+    template inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.label);
+      stream.next(m.size);
+      stream.next(m.stride);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER;
+  }; // struct MultiArrayDimension_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template
+struct Printer< ::std_msgs::MultiArrayDimension_ >
+{
+  template static void stream(Stream& s, const std::string& indent, const ::std_msgs::MultiArrayDimension_& v)
+  {
+    s << indent << "label: ";
+    Printer, typename ContainerAllocator::template rebind::other > >::stream(s, indent + "  ", v.label);
+    s << indent << "size: ";
+    Printer::stream(s, indent + "  ", v.size);
+    s << indent << "stride: ";
+    Printer::stream(s, indent + "  ", v.stride);
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // STD_MSGS_MESSAGE_MULTIARRAYDIMENSION_H
diff --git a/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/MultiArrayLayout.h b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/MultiArrayLayout.h
new file mode 100644
index 0000000000..13e008daf5
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/MultiArrayLayout.h
@@ -0,0 +1,232 @@
+// Generated by gencpp from file std_msgs/MultiArrayLayout.msg
+// DO NOT EDIT!
+
+
+#ifndef STD_MSGS_MESSAGE_MULTIARRAYLAYOUT_H
+#define STD_MSGS_MESSAGE_MULTIARRAYLAYOUT_H
+
+
+#include 
+#include 
+#include 
+
+#include 
+#include 
+#include 
+#include 
+
+#include 
+
+namespace std_msgs
+{
+template 
+struct MultiArrayLayout_
+{
+  typedef MultiArrayLayout_ Type;
+
+  MultiArrayLayout_()
+    : dim()
+    , data_offset(0)  {
+    }
+  MultiArrayLayout_(const ContainerAllocator& _alloc)
+    : dim(_alloc)
+    , data_offset(0)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef std::vector< ::std_msgs::MultiArrayDimension_ , typename ContainerAllocator::template rebind< ::std_msgs::MultiArrayDimension_ >::other >  _dim_type;
+  _dim_type dim;
+
+   typedef uint32_t _data_offset_type;
+  _data_offset_type data_offset;
+
+
+
+
+  typedef boost::shared_ptr< ::std_msgs::MultiArrayLayout_ > Ptr;
+  typedef boost::shared_ptr< ::std_msgs::MultiArrayLayout_ const> ConstPtr;
+
+}; // struct MultiArrayLayout_
+
+typedef ::std_msgs::MultiArrayLayout_ > MultiArrayLayout;
+
+typedef boost::shared_ptr< ::std_msgs::MultiArrayLayout > MultiArrayLayoutPtr;
+typedef boost::shared_ptr< ::std_msgs::MultiArrayLayout const> MultiArrayLayoutConstPtr;
+
+// constants requiring out of line definition
+
+
+
+template
+std::ostream& operator<<(std::ostream& s, const ::std_msgs::MultiArrayLayout_ & v)
+{
+ros::message_operations::Printer< ::std_msgs::MultiArrayLayout_ >::stream(s, "", v);
+return s;
+}
+
+} // namespace std_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': False}
+// {'std_msgs': ['/tmp/binarydeb/ros-kinetic-std-msgs-0.5.10/msg']}
+
+// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types']
+
+
+
+
+template 
+struct IsFixedSize< ::std_msgs::MultiArrayLayout_ >
+  : FalseType
+  { };
+
+template 
+struct IsFixedSize< ::std_msgs::MultiArrayLayout_ const>
+  : FalseType
+  { };
+
+template 
+struct IsMessage< ::std_msgs::MultiArrayLayout_ >
+  : TrueType
+  { };
+
+template 
+struct IsMessage< ::std_msgs::MultiArrayLayout_ const>
+  : TrueType
+  { };
+
+template 
+struct HasHeader< ::std_msgs::MultiArrayLayout_ >
+  : FalseType
+  { };
+
+template 
+struct HasHeader< ::std_msgs::MultiArrayLayout_ const>
+  : FalseType
+  { };
+
+
+template
+struct MD5Sum< ::std_msgs::MultiArrayLayout_ >
+{
+  static const char* value()
+  {
+    return "0fed2a11c13e11c5571b4e2a995a91a3";
+  }
+
+  static const char* value(const ::std_msgs::MultiArrayLayout_&) { return value(); }
+  static const uint64_t static_value1 = 0x0fed2a11c13e11c5ULL;
+  static const uint64_t static_value2 = 0x571b4e2a995a91a3ULL;
+};
+
+template
+struct DataType< ::std_msgs::MultiArrayLayout_ >
+{
+  static const char* value()
+  {
+    return "std_msgs/MultiArrayLayout";
+  }
+
+  static const char* value(const ::std_msgs::MultiArrayLayout_&) { return value(); }
+};
+
+template
+struct Definition< ::std_msgs::MultiArrayLayout_ >
+{
+  static const char* value()
+  {
+    return "# The multiarray declares a generic multi-dimensional array of a\n\
+# particular data type.  Dimensions are ordered from outer most\n\
+# to inner most.\n\
+\n\
+MultiArrayDimension[] dim # Array of dimension properties\n\
+uint32 data_offset        # padding elements at front of data\n\
+\n\
+# Accessors should ALWAYS be written in terms of dimension stride\n\
+# and specified outer-most dimension first.\n\
+# \n\
+# multiarray(i,j,k) = data[data_offset + dim_stride[1]*i + dim_stride[2]*j + k]\n\
+#\n\
+# A standard, 3-channel 640x480 image with interleaved color channels\n\
+# would be specified as:\n\
+#\n\
+# dim[0].label  = \"height\"\n\
+# dim[0].size   = 480\n\
+# dim[0].stride = 3*640*480 = 921600  (note dim[0] stride is just size of image)\n\
+# dim[1].label  = \"width\"\n\
+# dim[1].size   = 640\n\
+# dim[1].stride = 3*640 = 1920\n\
+# dim[2].label  = \"channel\"\n\
+# dim[2].size   = 3\n\
+# dim[2].stride = 3\n\
+#\n\
+# multiarray(i,j,k) refers to the ith row, jth column, and kth channel.\n\
+\n\
+================================================================================\n\
+MSG: std_msgs/MultiArrayDimension\n\
+string label   # label of given dimension\n\
+uint32 size    # size of given dimension (in type units)\n\
+uint32 stride  # stride of given dimension\n\
+";
+  }
+
+  static const char* value(const ::std_msgs::MultiArrayLayout_&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template struct Serializer< ::std_msgs::MultiArrayLayout_ >
+  {
+    template inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.dim);
+      stream.next(m.data_offset);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER;
+  }; // struct MultiArrayLayout_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template
+struct Printer< ::std_msgs::MultiArrayLayout_ >
+{
+  template static void stream(Stream& s, const std::string& indent, const ::std_msgs::MultiArrayLayout_& v)
+  {
+    s << indent << "dim[]" << std::endl;
+    for (size_t i = 0; i < v.dim.size(); ++i)
+    {
+      s << indent << "  dim[" << i << "]: ";
+      s << std::endl;
+      s << indent;
+      Printer< ::std_msgs::MultiArrayDimension_ >::stream(s, indent + "    ", v.dim[i]);
+    }
+    s << indent << "data_offset: ";
+    Printer::stream(s, indent + "  ", v.data_offset);
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // STD_MSGS_MESSAGE_MULTIARRAYLAYOUT_H
diff --git a/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/String.h b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/String.h
new file mode 100644
index 0000000000..ca1fc7a0b2
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/String.h
@@ -0,0 +1,186 @@
+// Generated by gencpp from file std_msgs/String.msg
+// DO NOT EDIT!
+
+
+#ifndef STD_MSGS_MESSAGE_STRING_H
+#define STD_MSGS_MESSAGE_STRING_H
+
+#include 
+#include 
+#include 
+#include 
+
+#include 
+#include 
+#include 
+#include 
+
+
+namespace std_msgs
+{
+template 
+struct String_
+{
+  typedef String_ Type;
+
+  String_()
+    : data()  {
+    }
+  String_(const ContainerAllocator& _alloc)
+    : data(_alloc)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef std::basic_string, typename ContainerAllocator::template rebind::other >  _data_type;
+  _data_type data;
+
+
+
+
+  typedef std::shared_ptr< ::std_msgs::String_ > Ptr;
+  typedef std::shared_ptr< ::std_msgs::String_ const> ConstPtr;
+
+}; // struct String_
+
+typedef ::std_msgs::String_ > String;
+
+typedef std::shared_ptr< ::std_msgs::String > StringPtr;
+typedef std::shared_ptr< ::std_msgs::String const> StringConstPtr;
+
+// constants requiring out of line definition
+
+
+
+template
+std::ostream& operator<<(std::ostream& s, const ::std_msgs::String_ & v)
+{
+ros::message_operations::Printer< ::std_msgs::String_ >::stream(s, "", v);
+return s;
+}
+
+} // namespace std_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': False}
+// {'std_msgs': ['/tmp/binarydeb/ros-kinetic-std-msgs-0.5.10/msg']}
+
+// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types']
+
+
+
+
+template 
+struct IsFixedSize< ::std_msgs::String_ >
+  : FalseType
+  { };
+
+template 
+struct IsFixedSize< ::std_msgs::String_ const>
+  : FalseType
+  { };
+
+template 
+struct IsMessage< ::std_msgs::String_ >
+  : TrueType
+  { };
+
+template 
+struct IsMessage< ::std_msgs::String_ const>
+  : TrueType
+  { };
+
+template 
+struct HasHeader< ::std_msgs::String_ >
+  : FalseType
+  { };
+
+template 
+struct HasHeader< ::std_msgs::String_ const>
+  : FalseType
+  { };
+
+
+template
+struct MD5Sum< ::std_msgs::String_ >
+{
+  static const char* value()
+  {
+    return "992ce8a1687cec8c8bd883ec73ca41d1";
+  }
+
+  static const char* value(const ::std_msgs::String_&) { return value(); }
+  static const uint64_t static_value1 = 0x992ce8a1687cec8cULL;
+  static const uint64_t static_value2 = 0x8bd883ec73ca41d1ULL;
+};
+
+template
+struct DataType< ::std_msgs::String_ >
+{
+  static const char* value()
+  {
+    return "std_msgs/String";
+  }
+
+  static const char* value(const ::std_msgs::String_&) { return value(); }
+};
+
+template
+struct Definition< ::std_msgs::String_ >
+{
+  static const char* value()
+  {
+    return "string data\n\
+";
+  }
+
+  static const char* value(const ::std_msgs::String_&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template struct Serializer< ::std_msgs::String_ >
+  {
+    template inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.data);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER;
+  }; // struct String_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template
+struct Printer< ::std_msgs::String_ >
+{
+  template static void stream(Stream& s, const std::string& indent, const ::std_msgs::String_& v)
+  {
+    s << indent << "data: ";
+    Printer, typename ContainerAllocator::template rebind::other > >::stream(s, indent + "  ", v.data);
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // STD_MSGS_MESSAGE_STRING_H
diff --git a/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/Time.h b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/Time.h
new file mode 100644
index 0000000000..319aabc0c9
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/Time.h
@@ -0,0 +1,186 @@
+// Generated by gencpp from file std_msgs/Time.msg
+// DO NOT EDIT!
+
+
+#ifndef STD_MSGS_MESSAGE_TIME_H
+#define STD_MSGS_MESSAGE_TIME_H
+
+
+#include 
+#include 
+#include 
+
+#include 
+#include 
+#include 
+#include 
+
+
+namespace std_msgs
+{
+template 
+struct Time_
+{
+  typedef Time_ Type;
+
+  Time_()
+    : data()  {
+    }
+  Time_(const ContainerAllocator& _alloc)
+    : data()  {
+  (void)_alloc;
+    }
+
+
+
+   typedef ros::Time _data_type;
+  _data_type data;
+
+
+
+
+  typedef boost::shared_ptr< ::std_msgs::Time_ > Ptr;
+  typedef boost::shared_ptr< ::std_msgs::Time_ const> ConstPtr;
+
+}; // struct Time_
+
+typedef ::std_msgs::Time_ > Time;
+
+typedef boost::shared_ptr< ::std_msgs::Time > TimePtr;
+typedef boost::shared_ptr< ::std_msgs::Time const> TimeConstPtr;
+
+// constants requiring out of line definition
+
+
+
+template
+std::ostream& operator<<(std::ostream& s, const ::std_msgs::Time_ & v)
+{
+ros::message_operations::Printer< ::std_msgs::Time_ >::stream(s, "", v);
+return s;
+}
+
+} // namespace std_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+// BOOLTRAITS {'IsFixedSize': True, 'IsMessage': True, 'HasHeader': False}
+// {'std_msgs': ['/tmp/binarydeb/ros-kinetic-std-msgs-0.5.10/msg']}
+
+// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types']
+
+
+
+
+template 
+struct IsFixedSize< ::std_msgs::Time_ >
+  : TrueType
+  { };
+
+template 
+struct IsFixedSize< ::std_msgs::Time_ const>
+  : TrueType
+  { };
+
+template 
+struct IsMessage< ::std_msgs::Time_ >
+  : TrueType
+  { };
+
+template 
+struct IsMessage< ::std_msgs::Time_ const>
+  : TrueType
+  { };
+
+template 
+struct HasHeader< ::std_msgs::Time_ >
+  : FalseType
+  { };
+
+template 
+struct HasHeader< ::std_msgs::Time_ const>
+  : FalseType
+  { };
+
+
+template
+struct MD5Sum< ::std_msgs::Time_ >
+{
+  static const char* value()
+  {
+    return "cd7166c74c552c311fbcc2fe5a7bc289";
+  }
+
+  static const char* value(const ::std_msgs::Time_&) { return value(); }
+  static const uint64_t static_value1 = 0xcd7166c74c552c31ULL;
+  static const uint64_t static_value2 = 0x1fbcc2fe5a7bc289ULL;
+};
+
+template
+struct DataType< ::std_msgs::Time_ >
+{
+  static const char* value()
+  {
+    return "std_msgs/Time";
+  }
+
+  static const char* value(const ::std_msgs::Time_&) { return value(); }
+};
+
+template
+struct Definition< ::std_msgs::Time_ >
+{
+  static const char* value()
+  {
+    return "time data\n\
+";
+  }
+
+  static const char* value(const ::std_msgs::Time_&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template struct Serializer< ::std_msgs::Time_ >
+  {
+    template inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.data);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER;
+  }; // struct Time_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template
+struct Printer< ::std_msgs::Time_ >
+{
+  template static void stream(Stream& s, const std::string& indent, const ::std_msgs::Time_& v)
+  {
+    s << indent << "data: ";
+    Printer::stream(s, indent + "  ", v.data);
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // STD_MSGS_MESSAGE_TIME_H
diff --git a/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/UInt16.h b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/UInt16.h
new file mode 100644
index 0000000000..02edfa5126
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/UInt16.h
@@ -0,0 +1,186 @@
+// Generated by gencpp from file std_msgs/UInt16.msg
+// DO NOT EDIT!
+
+
+#ifndef STD_MSGS_MESSAGE_UINT16_H
+#define STD_MSGS_MESSAGE_UINT16_H
+
+
+#include 
+#include 
+#include 
+
+#include 
+#include 
+#include 
+#include 
+
+
+namespace std_msgs
+{
+template 
+struct UInt16_
+{
+  typedef UInt16_ Type;
+
+  UInt16_()
+    : data(0)  {
+    }
+  UInt16_(const ContainerAllocator& _alloc)
+    : data(0)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef uint16_t _data_type;
+  _data_type data;
+
+
+
+
+  typedef boost::shared_ptr< ::std_msgs::UInt16_ > Ptr;
+  typedef boost::shared_ptr< ::std_msgs::UInt16_ const> ConstPtr;
+
+}; // struct UInt16_
+
+typedef ::std_msgs::UInt16_ > UInt16;
+
+typedef boost::shared_ptr< ::std_msgs::UInt16 > UInt16Ptr;
+typedef boost::shared_ptr< ::std_msgs::UInt16 const> UInt16ConstPtr;
+
+// constants requiring out of line definition
+
+
+
+template
+std::ostream& operator<<(std::ostream& s, const ::std_msgs::UInt16_ & v)
+{
+ros::message_operations::Printer< ::std_msgs::UInt16_ >::stream(s, "", v);
+return s;
+}
+
+} // namespace std_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+// BOOLTRAITS {'IsFixedSize': True, 'IsMessage': True, 'HasHeader': False}
+// {'std_msgs': ['/tmp/binarydeb/ros-kinetic-std-msgs-0.5.10/msg']}
+
+// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types']
+
+
+
+
+template 
+struct IsFixedSize< ::std_msgs::UInt16_ >
+  : TrueType
+  { };
+
+template 
+struct IsFixedSize< ::std_msgs::UInt16_ const>
+  : TrueType
+  { };
+
+template 
+struct IsMessage< ::std_msgs::UInt16_ >
+  : TrueType
+  { };
+
+template 
+struct IsMessage< ::std_msgs::UInt16_ const>
+  : TrueType
+  { };
+
+template 
+struct HasHeader< ::std_msgs::UInt16_ >
+  : FalseType
+  { };
+
+template 
+struct HasHeader< ::std_msgs::UInt16_ const>
+  : FalseType
+  { };
+
+
+template
+struct MD5Sum< ::std_msgs::UInt16_ >
+{
+  static const char* value()
+  {
+    return "1df79edf208b629fe6b81923a544552d";
+  }
+
+  static const char* value(const ::std_msgs::UInt16_&) { return value(); }
+  static const uint64_t static_value1 = 0x1df79edf208b629fULL;
+  static const uint64_t static_value2 = 0xe6b81923a544552dULL;
+};
+
+template
+struct DataType< ::std_msgs::UInt16_ >
+{
+  static const char* value()
+  {
+    return "std_msgs/UInt16";
+  }
+
+  static const char* value(const ::std_msgs::UInt16_&) { return value(); }
+};
+
+template
+struct Definition< ::std_msgs::UInt16_ >
+{
+  static const char* value()
+  {
+    return "uint16 data\n\
+";
+  }
+
+  static const char* value(const ::std_msgs::UInt16_&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template struct Serializer< ::std_msgs::UInt16_ >
+  {
+    template inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.data);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER;
+  }; // struct UInt16_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template
+struct Printer< ::std_msgs::UInt16_ >
+{
+  template static void stream(Stream& s, const std::string& indent, const ::std_msgs::UInt16_& v)
+  {
+    s << indent << "data: ";
+    Printer::stream(s, indent + "  ", v.data);
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // STD_MSGS_MESSAGE_UINT16_H
diff --git a/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/UInt16MultiArray.h b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/UInt16MultiArray.h
new file mode 100644
index 0000000000..8c6eca9775
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/UInt16MultiArray.h
@@ -0,0 +1,240 @@
+// Generated by gencpp from file std_msgs/UInt16MultiArray.msg
+// DO NOT EDIT!
+
+
+#ifndef STD_MSGS_MESSAGE_UINT16MULTIARRAY_H
+#define STD_MSGS_MESSAGE_UINT16MULTIARRAY_H
+
+
+#include 
+#include 
+#include 
+
+#include 
+#include 
+#include 
+#include 
+
+#include 
+
+namespace std_msgs
+{
+template 
+struct UInt16MultiArray_
+{
+  typedef UInt16MultiArray_ Type;
+
+  UInt16MultiArray_()
+    : layout()
+    , data()  {
+    }
+  UInt16MultiArray_(const ContainerAllocator& _alloc)
+    : layout(_alloc)
+    , data(_alloc)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef  ::std_msgs::MultiArrayLayout_  _layout_type;
+  _layout_type layout;
+
+   typedef std::vector::other >  _data_type;
+  _data_type data;
+
+
+
+
+  typedef boost::shared_ptr< ::std_msgs::UInt16MultiArray_ > Ptr;
+  typedef boost::shared_ptr< ::std_msgs::UInt16MultiArray_ const> ConstPtr;
+
+}; // struct UInt16MultiArray_
+
+typedef ::std_msgs::UInt16MultiArray_ > UInt16MultiArray;
+
+typedef boost::shared_ptr< ::std_msgs::UInt16MultiArray > UInt16MultiArrayPtr;
+typedef boost::shared_ptr< ::std_msgs::UInt16MultiArray const> UInt16MultiArrayConstPtr;
+
+// constants requiring out of line definition
+
+
+
+template
+std::ostream& operator<<(std::ostream& s, const ::std_msgs::UInt16MultiArray_ & v)
+{
+ros::message_operations::Printer< ::std_msgs::UInt16MultiArray_ >::stream(s, "", v);
+return s;
+}
+
+} // namespace std_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': False}
+// {'std_msgs': ['/tmp/binarydeb/ros-kinetic-std-msgs-0.5.10/msg']}
+
+// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types']
+
+
+
+
+template 
+struct IsFixedSize< ::std_msgs::UInt16MultiArray_ >
+  : FalseType
+  { };
+
+template 
+struct IsFixedSize< ::std_msgs::UInt16MultiArray_ const>
+  : FalseType
+  { };
+
+template 
+struct IsMessage< ::std_msgs::UInt16MultiArray_ >
+  : TrueType
+  { };
+
+template 
+struct IsMessage< ::std_msgs::UInt16MultiArray_ const>
+  : TrueType
+  { };
+
+template 
+struct HasHeader< ::std_msgs::UInt16MultiArray_ >
+  : FalseType
+  { };
+
+template 
+struct HasHeader< ::std_msgs::UInt16MultiArray_ const>
+  : FalseType
+  { };
+
+
+template
+struct MD5Sum< ::std_msgs::UInt16MultiArray_ >
+{
+  static const char* value()
+  {
+    return "52f264f1c973c4b73790d384c6cb4484";
+  }
+
+  static const char* value(const ::std_msgs::UInt16MultiArray_&) { return value(); }
+  static const uint64_t static_value1 = 0x52f264f1c973c4b7ULL;
+  static const uint64_t static_value2 = 0x3790d384c6cb4484ULL;
+};
+
+template
+struct DataType< ::std_msgs::UInt16MultiArray_ >
+{
+  static const char* value()
+  {
+    return "std_msgs/UInt16MultiArray";
+  }
+
+  static const char* value(const ::std_msgs::UInt16MultiArray_&) { return value(); }
+};
+
+template
+struct Definition< ::std_msgs::UInt16MultiArray_ >
+{
+  static const char* value()
+  {
+    return "# Please look at the MultiArrayLayout message definition for\n\
+# documentation on all multiarrays.\n\
+\n\
+MultiArrayLayout  layout        # specification of data layout\n\
+uint16[]            data        # array of data\n\
+\n\
+\n\
+================================================================================\n\
+MSG: std_msgs/MultiArrayLayout\n\
+# The multiarray declares a generic multi-dimensional array of a\n\
+# particular data type.  Dimensions are ordered from outer most\n\
+# to inner most.\n\
+\n\
+MultiArrayDimension[] dim # Array of dimension properties\n\
+uint32 data_offset        # padding elements at front of data\n\
+\n\
+# Accessors should ALWAYS be written in terms of dimension stride\n\
+# and specified outer-most dimension first.\n\
+# \n\
+# multiarray(i,j,k) = data[data_offset + dim_stride[1]*i + dim_stride[2]*j + k]\n\
+#\n\
+# A standard, 3-channel 640x480 image with interleaved color channels\n\
+# would be specified as:\n\
+#\n\
+# dim[0].label  = \"height\"\n\
+# dim[0].size   = 480\n\
+# dim[0].stride = 3*640*480 = 921600  (note dim[0] stride is just size of image)\n\
+# dim[1].label  = \"width\"\n\
+# dim[1].size   = 640\n\
+# dim[1].stride = 3*640 = 1920\n\
+# dim[2].label  = \"channel\"\n\
+# dim[2].size   = 3\n\
+# dim[2].stride = 3\n\
+#\n\
+# multiarray(i,j,k) refers to the ith row, jth column, and kth channel.\n\
+\n\
+================================================================================\n\
+MSG: std_msgs/MultiArrayDimension\n\
+string label   # label of given dimension\n\
+uint32 size    # size of given dimension (in type units)\n\
+uint32 stride  # stride of given dimension\n\
+";
+  }
+
+  static const char* value(const ::std_msgs::UInt16MultiArray_&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template struct Serializer< ::std_msgs::UInt16MultiArray_ >
+  {
+    template inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.layout);
+      stream.next(m.data);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER;
+  }; // struct UInt16MultiArray_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template
+struct Printer< ::std_msgs::UInt16MultiArray_ >
+{
+  template static void stream(Stream& s, const std::string& indent, const ::std_msgs::UInt16MultiArray_& v)
+  {
+    s << indent << "layout: ";
+    s << std::endl;
+    Printer< ::std_msgs::MultiArrayLayout_ >::stream(s, indent + "  ", v.layout);
+    s << indent << "data[]" << std::endl;
+    for (size_t i = 0; i < v.data.size(); ++i)
+    {
+      s << indent << "  data[" << i << "]: ";
+      Printer::stream(s, indent + "  ", v.data[i]);
+    }
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // STD_MSGS_MESSAGE_UINT16MULTIARRAY_H
diff --git a/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/UInt32.h b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/UInt32.h
new file mode 100644
index 0000000000..f99379bb4a
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/UInt32.h
@@ -0,0 +1,186 @@
+// Generated by gencpp from file std_msgs/UInt32.msg
+// DO NOT EDIT!
+
+
+#ifndef STD_MSGS_MESSAGE_UINT32_H
+#define STD_MSGS_MESSAGE_UINT32_H
+
+#include 
+#include 
+#include 
+#include 
+
+#include 
+#include 
+#include 
+#include 
+
+
+namespace std_msgs
+{
+template 
+struct UInt32_
+{
+  typedef UInt32_ Type;
+
+  UInt32_()
+    : data(0)  {
+    }
+  UInt32_(const ContainerAllocator& _alloc)
+    : data(0)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef uint32_t _data_type;
+  _data_type data;
+
+
+
+
+  typedef std::shared_ptr< ::std_msgs::UInt32_ > Ptr;
+  typedef std::shared_ptr< ::std_msgs::UInt32_ const> ConstPtr;
+
+}; // struct UInt32_
+
+typedef ::std_msgs::UInt32_ > UInt32;
+
+typedef std::shared_ptr< ::std_msgs::UInt32 > UInt32Ptr;
+typedef std::shared_ptr< ::std_msgs::UInt32 const> UInt32ConstPtr;
+
+// constants requiring out of line definition
+
+
+
+template
+std::ostream& operator<<(std::ostream& s, const ::std_msgs::UInt32_ & v)
+{
+ros::message_operations::Printer< ::std_msgs::UInt32_ >::stream(s, "", v);
+return s;
+}
+
+} // namespace std_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+// BOOLTRAITS {'IsFixedSize': True, 'IsMessage': True, 'HasHeader': False}
+// {'std_msgs': ['/tmp/binarydeb/ros-kinetic-std-msgs-0.5.10/msg']}
+
+// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types']
+
+
+
+
+template 
+struct IsFixedSize< ::std_msgs::UInt32_ >
+  : TrueType
+  { };
+
+template 
+struct IsFixedSize< ::std_msgs::UInt32_ const>
+  : TrueType
+  { };
+
+template 
+struct IsMessage< ::std_msgs::UInt32_ >
+  : TrueType
+  { };
+
+template 
+struct IsMessage< ::std_msgs::UInt32_ const>
+  : TrueType
+  { };
+
+template 
+struct HasHeader< ::std_msgs::UInt32_ >
+  : FalseType
+  { };
+
+template 
+struct HasHeader< ::std_msgs::UInt32_ const>
+  : FalseType
+  { };
+
+
+template
+struct MD5Sum< ::std_msgs::UInt32_ >
+{
+  static const char* value()
+  {
+    return "304a39449588c7f8ce2df6e8001c5fce";
+  }
+
+  static const char* value(const ::std_msgs::UInt32_&) { return value(); }
+  static const uint64_t static_value1 = 0x304a39449588c7f8ULL;
+  static const uint64_t static_value2 = 0xce2df6e8001c5fceULL;
+};
+
+template
+struct DataType< ::std_msgs::UInt32_ >
+{
+  static const char* value()
+  {
+    return "std_msgs/UInt32";
+  }
+
+  static const char* value(const ::std_msgs::UInt32_&) { return value(); }
+};
+
+template
+struct Definition< ::std_msgs::UInt32_ >
+{
+  static const char* value()
+  {
+    return "uint32 data\n\
+";
+  }
+
+  static const char* value(const ::std_msgs::UInt32_&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template struct Serializer< ::std_msgs::UInt32_ >
+  {
+    template inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.data);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER;
+  }; // struct UInt32_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template
+struct Printer< ::std_msgs::UInt32_ >
+{
+  template static void stream(Stream& s, const std::string& indent, const ::std_msgs::UInt32_& v)
+  {
+    s << indent << "data: ";
+    Printer::stream(s, indent + "  ", v.data);
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // STD_MSGS_MESSAGE_UINT32_H
diff --git a/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/UInt32MultiArray.h b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/UInt32MultiArray.h
new file mode 100644
index 0000000000..9dc98723fc
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/UInt32MultiArray.h
@@ -0,0 +1,240 @@
+// Generated by gencpp from file std_msgs/UInt32MultiArray.msg
+// DO NOT EDIT!
+
+
+#ifndef STD_MSGS_MESSAGE_UINT32MULTIARRAY_H
+#define STD_MSGS_MESSAGE_UINT32MULTIARRAY_H
+
+
+#include 
+#include 
+#include 
+
+#include 
+#include 
+#include 
+#include 
+
+#include 
+
+namespace std_msgs
+{
+template 
+struct UInt32MultiArray_
+{
+  typedef UInt32MultiArray_ Type;
+
+  UInt32MultiArray_()
+    : layout()
+    , data()  {
+    }
+  UInt32MultiArray_(const ContainerAllocator& _alloc)
+    : layout(_alloc)
+    , data(_alloc)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef  ::std_msgs::MultiArrayLayout_  _layout_type;
+  _layout_type layout;
+
+   typedef std::vector::other >  _data_type;
+  _data_type data;
+
+
+
+
+  typedef boost::shared_ptr< ::std_msgs::UInt32MultiArray_ > Ptr;
+  typedef boost::shared_ptr< ::std_msgs::UInt32MultiArray_ const> ConstPtr;
+
+}; // struct UInt32MultiArray_
+
+typedef ::std_msgs::UInt32MultiArray_ > UInt32MultiArray;
+
+typedef boost::shared_ptr< ::std_msgs::UInt32MultiArray > UInt32MultiArrayPtr;
+typedef boost::shared_ptr< ::std_msgs::UInt32MultiArray const> UInt32MultiArrayConstPtr;
+
+// constants requiring out of line definition
+
+
+
+template
+std::ostream& operator<<(std::ostream& s, const ::std_msgs::UInt32MultiArray_ & v)
+{
+ros::message_operations::Printer< ::std_msgs::UInt32MultiArray_ >::stream(s, "", v);
+return s;
+}
+
+} // namespace std_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': False}
+// {'std_msgs': ['/tmp/binarydeb/ros-kinetic-std-msgs-0.5.10/msg']}
+
+// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types']
+
+
+
+
+template 
+struct IsFixedSize< ::std_msgs::UInt32MultiArray_ >
+  : FalseType
+  { };
+
+template 
+struct IsFixedSize< ::std_msgs::UInt32MultiArray_ const>
+  : FalseType
+  { };
+
+template 
+struct IsMessage< ::std_msgs::UInt32MultiArray_ >
+  : TrueType
+  { };
+
+template 
+struct IsMessage< ::std_msgs::UInt32MultiArray_ const>
+  : TrueType
+  { };
+
+template 
+struct HasHeader< ::std_msgs::UInt32MultiArray_ >
+  : FalseType
+  { };
+
+template 
+struct HasHeader< ::std_msgs::UInt32MultiArray_ const>
+  : FalseType
+  { };
+
+
+template
+struct MD5Sum< ::std_msgs::UInt32MultiArray_ >
+{
+  static const char* value()
+  {
+    return "4d6a180abc9be191b96a7eda6c8a233d";
+  }
+
+  static const char* value(const ::std_msgs::UInt32MultiArray_&) { return value(); }
+  static const uint64_t static_value1 = 0x4d6a180abc9be191ULL;
+  static const uint64_t static_value2 = 0xb96a7eda6c8a233dULL;
+};
+
+template
+struct DataType< ::std_msgs::UInt32MultiArray_ >
+{
+  static const char* value()
+  {
+    return "std_msgs/UInt32MultiArray";
+  }
+
+  static const char* value(const ::std_msgs::UInt32MultiArray_&) { return value(); }
+};
+
+template
+struct Definition< ::std_msgs::UInt32MultiArray_ >
+{
+  static const char* value()
+  {
+    return "# Please look at the MultiArrayLayout message definition for\n\
+# documentation on all multiarrays.\n\
+\n\
+MultiArrayLayout  layout        # specification of data layout\n\
+uint32[]          data          # array of data\n\
+\n\
+\n\
+================================================================================\n\
+MSG: std_msgs/MultiArrayLayout\n\
+# The multiarray declares a generic multi-dimensional array of a\n\
+# particular data type.  Dimensions are ordered from outer most\n\
+# to inner most.\n\
+\n\
+MultiArrayDimension[] dim # Array of dimension properties\n\
+uint32 data_offset        # padding elements at front of data\n\
+\n\
+# Accessors should ALWAYS be written in terms of dimension stride\n\
+# and specified outer-most dimension first.\n\
+# \n\
+# multiarray(i,j,k) = data[data_offset + dim_stride[1]*i + dim_stride[2]*j + k]\n\
+#\n\
+# A standard, 3-channel 640x480 image with interleaved color channels\n\
+# would be specified as:\n\
+#\n\
+# dim[0].label  = \"height\"\n\
+# dim[0].size   = 480\n\
+# dim[0].stride = 3*640*480 = 921600  (note dim[0] stride is just size of image)\n\
+# dim[1].label  = \"width\"\n\
+# dim[1].size   = 640\n\
+# dim[1].stride = 3*640 = 1920\n\
+# dim[2].label  = \"channel\"\n\
+# dim[2].size   = 3\n\
+# dim[2].stride = 3\n\
+#\n\
+# multiarray(i,j,k) refers to the ith row, jth column, and kth channel.\n\
+\n\
+================================================================================\n\
+MSG: std_msgs/MultiArrayDimension\n\
+string label   # label of given dimension\n\
+uint32 size    # size of given dimension (in type units)\n\
+uint32 stride  # stride of given dimension\n\
+";
+  }
+
+  static const char* value(const ::std_msgs::UInt32MultiArray_&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template struct Serializer< ::std_msgs::UInt32MultiArray_ >
+  {
+    template inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.layout);
+      stream.next(m.data);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER;
+  }; // struct UInt32MultiArray_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template
+struct Printer< ::std_msgs::UInt32MultiArray_ >
+{
+  template static void stream(Stream& s, const std::string& indent, const ::std_msgs::UInt32MultiArray_& v)
+  {
+    s << indent << "layout: ";
+    s << std::endl;
+    Printer< ::std_msgs::MultiArrayLayout_ >::stream(s, indent + "  ", v.layout);
+    s << indent << "data[]" << std::endl;
+    for (size_t i = 0; i < v.data.size(); ++i)
+    {
+      s << indent << "  data[" << i << "]: ";
+      Printer::stream(s, indent + "  ", v.data[i]);
+    }
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // STD_MSGS_MESSAGE_UINT32MULTIARRAY_H
diff --git a/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/UInt64.h b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/UInt64.h
new file mode 100644
index 0000000000..0fc6a3b52b
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/UInt64.h
@@ -0,0 +1,186 @@
+// Generated by gencpp from file std_msgs/UInt64.msg
+// DO NOT EDIT!
+
+
+#ifndef STD_MSGS_MESSAGE_UINT64_H
+#define STD_MSGS_MESSAGE_UINT64_H
+
+
+#include 
+#include 
+#include 
+
+#include 
+#include 
+#include 
+#include 
+
+
+namespace std_msgs
+{
+template 
+struct UInt64_
+{
+  typedef UInt64_ Type;
+
+  UInt64_()
+    : data(0)  {
+    }
+  UInt64_(const ContainerAllocator& _alloc)
+    : data(0)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef uint64_t _data_type;
+  _data_type data;
+
+
+
+
+  typedef boost::shared_ptr< ::std_msgs::UInt64_ > Ptr;
+  typedef boost::shared_ptr< ::std_msgs::UInt64_ const> ConstPtr;
+
+}; // struct UInt64_
+
+typedef ::std_msgs::UInt64_ > UInt64;
+
+typedef boost::shared_ptr< ::std_msgs::UInt64 > UInt64Ptr;
+typedef boost::shared_ptr< ::std_msgs::UInt64 const> UInt64ConstPtr;
+
+// constants requiring out of line definition
+
+
+
+template
+std::ostream& operator<<(std::ostream& s, const ::std_msgs::UInt64_ & v)
+{
+ros::message_operations::Printer< ::std_msgs::UInt64_ >::stream(s, "", v);
+return s;
+}
+
+} // namespace std_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+// BOOLTRAITS {'IsFixedSize': True, 'IsMessage': True, 'HasHeader': False}
+// {'std_msgs': ['/tmp/binarydeb/ros-kinetic-std-msgs-0.5.10/msg']}
+
+// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types']
+
+
+
+
+template 
+struct IsFixedSize< ::std_msgs::UInt64_ >
+  : TrueType
+  { };
+
+template 
+struct IsFixedSize< ::std_msgs::UInt64_ const>
+  : TrueType
+  { };
+
+template 
+struct IsMessage< ::std_msgs::UInt64_ >
+  : TrueType
+  { };
+
+template 
+struct IsMessage< ::std_msgs::UInt64_ const>
+  : TrueType
+  { };
+
+template 
+struct HasHeader< ::std_msgs::UInt64_ >
+  : FalseType
+  { };
+
+template 
+struct HasHeader< ::std_msgs::UInt64_ const>
+  : FalseType
+  { };
+
+
+template
+struct MD5Sum< ::std_msgs::UInt64_ >
+{
+  static const char* value()
+  {
+    return "1b2a79973e8bf53d7b53acb71299cb57";
+  }
+
+  static const char* value(const ::std_msgs::UInt64_&) { return value(); }
+  static const uint64_t static_value1 = 0x1b2a79973e8bf53dULL;
+  static const uint64_t static_value2 = 0x7b53acb71299cb57ULL;
+};
+
+template
+struct DataType< ::std_msgs::UInt64_ >
+{
+  static const char* value()
+  {
+    return "std_msgs/UInt64";
+  }
+
+  static const char* value(const ::std_msgs::UInt64_&) { return value(); }
+};
+
+template
+struct Definition< ::std_msgs::UInt64_ >
+{
+  static const char* value()
+  {
+    return "uint64 data\n\
+";
+  }
+
+  static const char* value(const ::std_msgs::UInt64_&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template struct Serializer< ::std_msgs::UInt64_ >
+  {
+    template inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.data);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER;
+  }; // struct UInt64_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template
+struct Printer< ::std_msgs::UInt64_ >
+{
+  template static void stream(Stream& s, const std::string& indent, const ::std_msgs::UInt64_& v)
+  {
+    s << indent << "data: ";
+    Printer::stream(s, indent + "  ", v.data);
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // STD_MSGS_MESSAGE_UINT64_H
diff --git a/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/UInt64MultiArray.h b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/UInt64MultiArray.h
new file mode 100644
index 0000000000..2b75d439b9
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/UInt64MultiArray.h
@@ -0,0 +1,240 @@
+// Generated by gencpp from file std_msgs/UInt64MultiArray.msg
+// DO NOT EDIT!
+
+
+#ifndef STD_MSGS_MESSAGE_UINT64MULTIARRAY_H
+#define STD_MSGS_MESSAGE_UINT64MULTIARRAY_H
+
+
+#include 
+#include 
+#include 
+
+#include 
+#include 
+#include 
+#include 
+
+#include 
+
+namespace std_msgs
+{
+template 
+struct UInt64MultiArray_
+{
+  typedef UInt64MultiArray_ Type;
+
+  UInt64MultiArray_()
+    : layout()
+    , data()  {
+    }
+  UInt64MultiArray_(const ContainerAllocator& _alloc)
+    : layout(_alloc)
+    , data(_alloc)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef  ::std_msgs::MultiArrayLayout_  _layout_type;
+  _layout_type layout;
+
+   typedef std::vector::other >  _data_type;
+  _data_type data;
+
+
+
+
+  typedef boost::shared_ptr< ::std_msgs::UInt64MultiArray_ > Ptr;
+  typedef boost::shared_ptr< ::std_msgs::UInt64MultiArray_ const> ConstPtr;
+
+}; // struct UInt64MultiArray_
+
+typedef ::std_msgs::UInt64MultiArray_ > UInt64MultiArray;
+
+typedef boost::shared_ptr< ::std_msgs::UInt64MultiArray > UInt64MultiArrayPtr;
+typedef boost::shared_ptr< ::std_msgs::UInt64MultiArray const> UInt64MultiArrayConstPtr;
+
+// constants requiring out of line definition
+
+
+
+template
+std::ostream& operator<<(std::ostream& s, const ::std_msgs::UInt64MultiArray_ & v)
+{
+ros::message_operations::Printer< ::std_msgs::UInt64MultiArray_ >::stream(s, "", v);
+return s;
+}
+
+} // namespace std_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': False}
+// {'std_msgs': ['/tmp/binarydeb/ros-kinetic-std-msgs-0.5.10/msg']}
+
+// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types']
+
+
+
+
+template 
+struct IsFixedSize< ::std_msgs::UInt64MultiArray_ >
+  : FalseType
+  { };
+
+template 
+struct IsFixedSize< ::std_msgs::UInt64MultiArray_ const>
+  : FalseType
+  { };
+
+template 
+struct IsMessage< ::std_msgs::UInt64MultiArray_ >
+  : TrueType
+  { };
+
+template 
+struct IsMessage< ::std_msgs::UInt64MultiArray_ const>
+  : TrueType
+  { };
+
+template 
+struct HasHeader< ::std_msgs::UInt64MultiArray_ >
+  : FalseType
+  { };
+
+template 
+struct HasHeader< ::std_msgs::UInt64MultiArray_ const>
+  : FalseType
+  { };
+
+
+template
+struct MD5Sum< ::std_msgs::UInt64MultiArray_ >
+{
+  static const char* value()
+  {
+    return "6088f127afb1d6c72927aa1247e945af";
+  }
+
+  static const char* value(const ::std_msgs::UInt64MultiArray_&) { return value(); }
+  static const uint64_t static_value1 = 0x6088f127afb1d6c7ULL;
+  static const uint64_t static_value2 = 0x2927aa1247e945afULL;
+};
+
+template
+struct DataType< ::std_msgs::UInt64MultiArray_ >
+{
+  static const char* value()
+  {
+    return "std_msgs/UInt64MultiArray";
+  }
+
+  static const char* value(const ::std_msgs::UInt64MultiArray_&) { return value(); }
+};
+
+template
+struct Definition< ::std_msgs::UInt64MultiArray_ >
+{
+  static const char* value()
+  {
+    return "# Please look at the MultiArrayLayout message definition for\n\
+# documentation on all multiarrays.\n\
+\n\
+MultiArrayLayout  layout        # specification of data layout\n\
+uint64[]          data          # array of data\n\
+\n\
+\n\
+================================================================================\n\
+MSG: std_msgs/MultiArrayLayout\n\
+# The multiarray declares a generic multi-dimensional array of a\n\
+# particular data type.  Dimensions are ordered from outer most\n\
+# to inner most.\n\
+\n\
+MultiArrayDimension[] dim # Array of dimension properties\n\
+uint32 data_offset        # padding elements at front of data\n\
+\n\
+# Accessors should ALWAYS be written in terms of dimension stride\n\
+# and specified outer-most dimension first.\n\
+# \n\
+# multiarray(i,j,k) = data[data_offset + dim_stride[1]*i + dim_stride[2]*j + k]\n\
+#\n\
+# A standard, 3-channel 640x480 image with interleaved color channels\n\
+# would be specified as:\n\
+#\n\
+# dim[0].label  = \"height\"\n\
+# dim[0].size   = 480\n\
+# dim[0].stride = 3*640*480 = 921600  (note dim[0] stride is just size of image)\n\
+# dim[1].label  = \"width\"\n\
+# dim[1].size   = 640\n\
+# dim[1].stride = 3*640 = 1920\n\
+# dim[2].label  = \"channel\"\n\
+# dim[2].size   = 3\n\
+# dim[2].stride = 3\n\
+#\n\
+# multiarray(i,j,k) refers to the ith row, jth column, and kth channel.\n\
+\n\
+================================================================================\n\
+MSG: std_msgs/MultiArrayDimension\n\
+string label   # label of given dimension\n\
+uint32 size    # size of given dimension (in type units)\n\
+uint32 stride  # stride of given dimension\n\
+";
+  }
+
+  static const char* value(const ::std_msgs::UInt64MultiArray_&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template struct Serializer< ::std_msgs::UInt64MultiArray_ >
+  {
+    template inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.layout);
+      stream.next(m.data);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER;
+  }; // struct UInt64MultiArray_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template
+struct Printer< ::std_msgs::UInt64MultiArray_ >
+{
+  template static void stream(Stream& s, const std::string& indent, const ::std_msgs::UInt64MultiArray_& v)
+  {
+    s << indent << "layout: ";
+    s << std::endl;
+    Printer< ::std_msgs::MultiArrayLayout_ >::stream(s, indent + "  ", v.layout);
+    s << indent << "data[]" << std::endl;
+    for (size_t i = 0; i < v.data.size(); ++i)
+    {
+      s << indent << "  data[" << i << "]: ";
+      Printer::stream(s, indent + "  ", v.data[i]);
+    }
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // STD_MSGS_MESSAGE_UINT64MULTIARRAY_H
diff --git a/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/UInt8.h b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/UInt8.h
new file mode 100644
index 0000000000..a7bef0e5c6
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/UInt8.h
@@ -0,0 +1,186 @@
+// Generated by gencpp from file std_msgs/UInt8.msg
+// DO NOT EDIT!
+
+
+#ifndef STD_MSGS_MESSAGE_UINT8_H
+#define STD_MSGS_MESSAGE_UINT8_H
+
+
+#include 
+#include 
+#include 
+
+#include 
+#include 
+#include 
+#include 
+
+
+namespace std_msgs
+{
+template 
+struct UInt8_
+{
+  typedef UInt8_ Type;
+
+  UInt8_()
+    : data(0)  {
+    }
+  UInt8_(const ContainerAllocator& _alloc)
+    : data(0)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef uint8_t _data_type;
+  _data_type data;
+
+
+
+
+  typedef boost::shared_ptr< ::std_msgs::UInt8_ > Ptr;
+  typedef boost::shared_ptr< ::std_msgs::UInt8_ const> ConstPtr;
+
+}; // struct UInt8_
+
+typedef ::std_msgs::UInt8_ > UInt8;
+
+typedef boost::shared_ptr< ::std_msgs::UInt8 > UInt8Ptr;
+typedef boost::shared_ptr< ::std_msgs::UInt8 const> UInt8ConstPtr;
+
+// constants requiring out of line definition
+
+
+
+template
+std::ostream& operator<<(std::ostream& s, const ::std_msgs::UInt8_ & v)
+{
+ros::message_operations::Printer< ::std_msgs::UInt8_ >::stream(s, "", v);
+return s;
+}
+
+} // namespace std_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+// BOOLTRAITS {'IsFixedSize': True, 'IsMessage': True, 'HasHeader': False}
+// {'std_msgs': ['/tmp/binarydeb/ros-kinetic-std-msgs-0.5.10/msg']}
+
+// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types']
+
+
+
+
+template 
+struct IsFixedSize< ::std_msgs::UInt8_ >
+  : TrueType
+  { };
+
+template 
+struct IsFixedSize< ::std_msgs::UInt8_ const>
+  : TrueType
+  { };
+
+template 
+struct IsMessage< ::std_msgs::UInt8_ >
+  : TrueType
+  { };
+
+template 
+struct IsMessage< ::std_msgs::UInt8_ const>
+  : TrueType
+  { };
+
+template 
+struct HasHeader< ::std_msgs::UInt8_ >
+  : FalseType
+  { };
+
+template 
+struct HasHeader< ::std_msgs::UInt8_ const>
+  : FalseType
+  { };
+
+
+template
+struct MD5Sum< ::std_msgs::UInt8_ >
+{
+  static const char* value()
+  {
+    return "7c8164229e7d2c17eb95e9231617fdee";
+  }
+
+  static const char* value(const ::std_msgs::UInt8_&) { return value(); }
+  static const uint64_t static_value1 = 0x7c8164229e7d2c17ULL;
+  static const uint64_t static_value2 = 0xeb95e9231617fdeeULL;
+};
+
+template
+struct DataType< ::std_msgs::UInt8_ >
+{
+  static const char* value()
+  {
+    return "std_msgs/UInt8";
+  }
+
+  static const char* value(const ::std_msgs::UInt8_&) { return value(); }
+};
+
+template
+struct Definition< ::std_msgs::UInt8_ >
+{
+  static const char* value()
+  {
+    return "uint8 data\n\
+";
+  }
+
+  static const char* value(const ::std_msgs::UInt8_&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template struct Serializer< ::std_msgs::UInt8_ >
+  {
+    template inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.data);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER;
+  }; // struct UInt8_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template
+struct Printer< ::std_msgs::UInt8_ >
+{
+  template static void stream(Stream& s, const std::string& indent, const ::std_msgs::UInt8_& v)
+  {
+    s << indent << "data: ";
+    Printer::stream(s, indent + "  ", v.data);
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // STD_MSGS_MESSAGE_UINT8_H
diff --git a/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/UInt8MultiArray.h b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/UInt8MultiArray.h
new file mode 100644
index 0000000000..8b5d1204eb
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/UInt8MultiArray.h
@@ -0,0 +1,240 @@
+// Generated by gencpp from file std_msgs/UInt8MultiArray.msg
+// DO NOT EDIT!
+
+
+#ifndef STD_MSGS_MESSAGE_UINT8MULTIARRAY_H
+#define STD_MSGS_MESSAGE_UINT8MULTIARRAY_H
+
+
+#include 
+#include 
+#include 
+
+#include 
+#include 
+#include 
+#include 
+
+#include 
+
+namespace std_msgs
+{
+template 
+struct UInt8MultiArray_
+{
+  typedef UInt8MultiArray_ Type;
+
+  UInt8MultiArray_()
+    : layout()
+    , data()  {
+    }
+  UInt8MultiArray_(const ContainerAllocator& _alloc)
+    : layout(_alloc)
+    , data(_alloc)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef  ::std_msgs::MultiArrayLayout_  _layout_type;
+  _layout_type layout;
+
+   typedef std::vector::other >  _data_type;
+  _data_type data;
+
+
+
+
+  typedef boost::shared_ptr< ::std_msgs::UInt8MultiArray_ > Ptr;
+  typedef boost::shared_ptr< ::std_msgs::UInt8MultiArray_ const> ConstPtr;
+
+}; // struct UInt8MultiArray_
+
+typedef ::std_msgs::UInt8MultiArray_ > UInt8MultiArray;
+
+typedef boost::shared_ptr< ::std_msgs::UInt8MultiArray > UInt8MultiArrayPtr;
+typedef boost::shared_ptr< ::std_msgs::UInt8MultiArray const> UInt8MultiArrayConstPtr;
+
+// constants requiring out of line definition
+
+
+
+template
+std::ostream& operator<<(std::ostream& s, const ::std_msgs::UInt8MultiArray_ & v)
+{
+ros::message_operations::Printer< ::std_msgs::UInt8MultiArray_ >::stream(s, "", v);
+return s;
+}
+
+} // namespace std_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': False}
+// {'std_msgs': ['/tmp/binarydeb/ros-kinetic-std-msgs-0.5.10/msg']}
+
+// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types']
+
+
+
+
+template 
+struct IsFixedSize< ::std_msgs::UInt8MultiArray_ >
+  : FalseType
+  { };
+
+template 
+struct IsFixedSize< ::std_msgs::UInt8MultiArray_ const>
+  : FalseType
+  { };
+
+template 
+struct IsMessage< ::std_msgs::UInt8MultiArray_ >
+  : TrueType
+  { };
+
+template 
+struct IsMessage< ::std_msgs::UInt8MultiArray_ const>
+  : TrueType
+  { };
+
+template 
+struct HasHeader< ::std_msgs::UInt8MultiArray_ >
+  : FalseType
+  { };
+
+template 
+struct HasHeader< ::std_msgs::UInt8MultiArray_ const>
+  : FalseType
+  { };
+
+
+template
+struct MD5Sum< ::std_msgs::UInt8MultiArray_ >
+{
+  static const char* value()
+  {
+    return "82373f1612381bb6ee473b5cd6f5d89c";
+  }
+
+  static const char* value(const ::std_msgs::UInt8MultiArray_&) { return value(); }
+  static const uint64_t static_value1 = 0x82373f1612381bb6ULL;
+  static const uint64_t static_value2 = 0xee473b5cd6f5d89cULL;
+};
+
+template
+struct DataType< ::std_msgs::UInt8MultiArray_ >
+{
+  static const char* value()
+  {
+    return "std_msgs/UInt8MultiArray";
+  }
+
+  static const char* value(const ::std_msgs::UInt8MultiArray_&) { return value(); }
+};
+
+template
+struct Definition< ::std_msgs::UInt8MultiArray_ >
+{
+  static const char* value()
+  {
+    return "# Please look at the MultiArrayLayout message definition for\n\
+# documentation on all multiarrays.\n\
+\n\
+MultiArrayLayout  layout        # specification of data layout\n\
+uint8[]           data          # array of data\n\
+\n\
+\n\
+================================================================================\n\
+MSG: std_msgs/MultiArrayLayout\n\
+# The multiarray declares a generic multi-dimensional array of a\n\
+# particular data type.  Dimensions are ordered from outer most\n\
+# to inner most.\n\
+\n\
+MultiArrayDimension[] dim # Array of dimension properties\n\
+uint32 data_offset        # padding elements at front of data\n\
+\n\
+# Accessors should ALWAYS be written in terms of dimension stride\n\
+# and specified outer-most dimension first.\n\
+# \n\
+# multiarray(i,j,k) = data[data_offset + dim_stride[1]*i + dim_stride[2]*j + k]\n\
+#\n\
+# A standard, 3-channel 640x480 image with interleaved color channels\n\
+# would be specified as:\n\
+#\n\
+# dim[0].label  = \"height\"\n\
+# dim[0].size   = 480\n\
+# dim[0].stride = 3*640*480 = 921600  (note dim[0] stride is just size of image)\n\
+# dim[1].label  = \"width\"\n\
+# dim[1].size   = 640\n\
+# dim[1].stride = 3*640 = 1920\n\
+# dim[2].label  = \"channel\"\n\
+# dim[2].size   = 3\n\
+# dim[2].stride = 3\n\
+#\n\
+# multiarray(i,j,k) refers to the ith row, jth column, and kth channel.\n\
+\n\
+================================================================================\n\
+MSG: std_msgs/MultiArrayDimension\n\
+string label   # label of given dimension\n\
+uint32 size    # size of given dimension (in type units)\n\
+uint32 stride  # stride of given dimension\n\
+";
+  }
+
+  static const char* value(const ::std_msgs::UInt8MultiArray_&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template struct Serializer< ::std_msgs::UInt8MultiArray_ >
+  {
+    template inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.layout);
+      stream.next(m.data);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER;
+  }; // struct UInt8MultiArray_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template
+struct Printer< ::std_msgs::UInt8MultiArray_ >
+{
+  template static void stream(Stream& s, const std::string& indent, const ::std_msgs::UInt8MultiArray_& v)
+  {
+    s << indent << "layout: ";
+    s << std::endl;
+    Printer< ::std_msgs::MultiArrayLayout_ >::stream(s, indent + "  ", v.layout);
+    s << indent << "data[]" << std::endl;
+    for (size_t i = 0; i < v.data.size(); ++i)
+    {
+      s << indent << "  data[" << i << "]: ";
+      Printer::stream(s, indent + "  ", v.data[i]);
+    }
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // STD_MSGS_MESSAGE_UINT8MULTIARRAY_H
diff --git a/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/builtin_bool.h b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/builtin_bool.h
new file mode 100644
index 0000000000..4b9b362d3f
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/builtin_bool.h
@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 2009, Willow Garage, Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *   * Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *   * Neither the names of Willow Garage, Inc. nor the names of its
+ *     contributors may be used to endorse or promote products derived from
+ *     this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef STD_MSGS_BUILTIN_BOOL_H
+#define STD_MSGS_BUILTIN_BOOL_H
+
+#include "trait_macros.h"
+#include 
+
+STD_MSGS_DEFINE_BUILTIN_TRAITS(bool, Bool, 0x8b94c1b53db61fb6ULL, 0xaed406028ad6332aULL);
+
+#endif
diff --git a/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/builtin_double.h b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/builtin_double.h
new file mode 100644
index 0000000000..fa63ff32be
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/builtin_double.h
@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 2009, Willow Garage, Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *   * Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *   * Neither the names of Willow Garage, Inc. nor the names of its
+ *     contributors may be used to endorse or promote products derived from
+ *     this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef STD_MSGS_BUILTIN_DOUBLE_H
+#define STD_MSGS_BUILTIN_DOUBLE_H
+
+#include "trait_macros.h"
+#include 
+
+STD_MSGS_DEFINE_BUILTIN_TRAITS(double, Float64, 0xfdb28210bfa9d7c9ULL, 0x1146260178d9a584ULL);
+
+#endif
diff --git a/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/builtin_float.h b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/builtin_float.h
new file mode 100644
index 0000000000..fba5495bec
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/builtin_float.h
@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 2009, Willow Garage, Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *   * Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *   * Neither the names of Willow Garage, Inc. nor the names of its
+ *     contributors may be used to endorse or promote products derived from
+ *     this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef STD_MSGS_BUILTIN_FLOAT_H
+#define STD_MSGS_BUILTIN_FLOAT_H
+
+#include "trait_macros.h"
+#include 
+
+STD_MSGS_DEFINE_BUILTIN_TRAITS(float, Float32, 0x73fcbf46b49191e6ULL, 0x72908e50842a83d4ULL);
+
+#endif
diff --git a/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/builtin_int16.h b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/builtin_int16.h
new file mode 100644
index 0000000000..1f371a8147
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/builtin_int16.h
@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 2009, Willow Garage, Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *   * Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *   * Neither the names of Willow Garage, Inc. nor the names of its
+ *     contributors may be used to endorse or promote products derived from
+ *     this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef STD_MSGS_BUILTIN_INT16_H
+#define STD_MSGS_BUILTIN_INT16_H
+
+#include "trait_macros.h"
+#include 
+
+STD_MSGS_DEFINE_BUILTIN_TRAITS(int16_t, Int16, 0x8524586e34fbd7cbULL, 0x1c08c5f5f1ca0e57ULL);
+
+#endif
diff --git a/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/builtin_int32.h b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/builtin_int32.h
new file mode 100644
index 0000000000..a3b81d0929
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/builtin_int32.h
@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 2009, Willow Garage, Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *   * Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *   * Neither the names of Willow Garage, Inc. nor the names of its
+ *     contributors may be used to endorse or promote products derived from
+ *     this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef STD_MSGS_BUILTIN_INT32_H
+#define STD_MSGS_BUILTIN_INT32_H
+
+#include "trait_macros.h"
+#include 
+
+STD_MSGS_DEFINE_BUILTIN_TRAITS(int32_t, Int32, 0xda5909fbe378aeafULL, 0x85e547e830cc1bb7ULL);
+
+#endif
diff --git a/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/builtin_int64.h b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/builtin_int64.h
new file mode 100644
index 0000000000..a138f7a274
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/builtin_int64.h
@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 2009, Willow Garage, Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *   * Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *   * Neither the names of Willow Garage, Inc. nor the names of its
+ *     contributors may be used to endorse or promote products derived from
+ *     this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef STD_MSGS_BUILTIN_INT64_H
+#define STD_MSGS_BUILTIN_INT64_H
+
+#include "trait_macros.h"
+#include 
+
+STD_MSGS_DEFINE_BUILTIN_TRAITS(int64_t, Int64, 0x34add168574510e6ULL, 0xe17f5d23ecc077efULL);
+
+#endif
diff --git a/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/builtin_int8.h b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/builtin_int8.h
new file mode 100644
index 0000000000..1a134de68b
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/builtin_int8.h
@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 2009, Willow Garage, Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *   * Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *   * Neither the names of Willow Garage, Inc. nor the names of its
+ *     contributors may be used to endorse or promote products derived from
+ *     this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef STD_MSGS_BUILTIN_INT8_H
+#define STD_MSGS_BUILTIN_INT8_H
+
+#include "trait_macros.h"
+#include 
+
+STD_MSGS_DEFINE_BUILTIN_TRAITS(int8_t, Int8, 0x27ffa0c9c4b8fb84ULL, 0x92252bcad9e5c57bULL);
+
+#endif
diff --git a/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/builtin_string.h b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/builtin_string.h
new file mode 100644
index 0000000000..1118849305
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/builtin_string.h
@@ -0,0 +1,86 @@
+/*
+ * Copyright (C) 2009, Willow Garage, Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *   * Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *   * Neither the names of Willow Garage, Inc. nor the names of its
+ *     contributors may be used to endorse or promote products derived from
+ *     this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef STD_MSGS_BUILTIN_STRING_H
+#define STD_MSGS_BUILTIN_STRING_H
+
+#include "trait_macros.h"
+#include 
+
+namespace ros
+{
+namespace message_traits
+{
+
+template
+struct MD5Sum, ContainerAllocator> >
+{
+  static const char* value()
+  {
+    ROS_STATIC_ASSERT(MD5Sum::static_value1 == 0x992ce8a1687cec8cULL);
+    ROS_STATIC_ASSERT(MD5Sum::static_value2 == 0x8bd883ec73ca41d1ULL);
+    return MD5Sum >::value();
+  }
+
+  static const char* value(const std::basic_string, ContainerAllocator>&)
+  {
+    return value();
+  }
+};
+
+template
+struct DataType, ContainerAllocator > >
+{
+  static const char* value()
+  {
+    return DataType >::value();
+  }
+
+  static const char* value(const std::basic_string, ContainerAllocator >&)
+  {
+    return value();
+  }
+};
+
+template
+struct Definition, ContainerAllocator > >
+{
+  static const char* value()
+  {
+    return Definition >::value();
+  }
+
+  static const char* value(const std::basic_string, ContainerAllocator >&)
+  {
+    return value();
+  }
+};
+
+}
+}
+
+#endif
diff --git a/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/builtin_uint16.h b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/builtin_uint16.h
new file mode 100644
index 0000000000..1c91d22b0d
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/builtin_uint16.h
@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 2009, Willow Garage, Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *   * Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *   * Neither the names of Willow Garage, Inc. nor the names of its
+ *     contributors may be used to endorse or promote products derived from
+ *     this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef STD_MSGS_BUILTIN_UINT16_H
+#define STD_MSGS_BUILTIN_UINT16_H
+
+#include "trait_macros.h"
+#include 
+
+STD_MSGS_DEFINE_BUILTIN_TRAITS(uint16_t, UInt16, 0x1df79edf208b629fULL, 0xe6b81923a544552dULL);
+
+#endif
diff --git a/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/builtin_uint32.h b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/builtin_uint32.h
new file mode 100644
index 0000000000..5be1c52227
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/builtin_uint32.h
@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 2009, Willow Garage, Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *   * Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *   * Neither the names of Willow Garage, Inc. nor the names of its
+ *     contributors may be used to endorse or promote products derived from
+ *     this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef STD_MSGS_BUILTIN_UINT32_H
+#define STD_MSGS_BUILTIN_UINT32_H
+
+#include "trait_macros.h"
+#include 
+
+STD_MSGS_DEFINE_BUILTIN_TRAITS(uint32_t, UInt32, 0x304a39449588c7f8ULL, 0xce2df6e8001c5fceULL);
+
+#endif
diff --git a/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/builtin_uint64.h b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/builtin_uint64.h
new file mode 100644
index 0000000000..9297ea6762
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/builtin_uint64.h
@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 2009, Willow Garage, Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *   * Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *   * Neither the names of Willow Garage, Inc. nor the names of its
+ *     contributors may be used to endorse or promote products derived from
+ *     this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef STD_MSGS_BUILTIN_UINT64_H
+#define STD_MSGS_BUILTIN_UINT64_H
+
+#include "trait_macros.h"
+#include 
+
+STD_MSGS_DEFINE_BUILTIN_TRAITS(uint64_t, UInt64, 0x1b2a79973e8bf53dULL, 0x7b53acb71299cb57ULL);
+
+#endif
diff --git a/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/builtin_uint8.h b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/builtin_uint8.h
new file mode 100644
index 0000000000..ea724450fc
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/builtin_uint8.h
@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 2009, Willow Garage, Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *   * Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *   * Neither the names of Willow Garage, Inc. nor the names of its
+ *     contributors may be used to endorse or promote products derived from
+ *     this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef STD_MSGS_BUILTIN_UINT8_H
+#define STD_MSGS_BUILTIN_UINT8_H
+
+#include "trait_macros.h"
+#include 
+
+STD_MSGS_DEFINE_BUILTIN_TRAITS(uint8_t, UInt8, 0x7c8164229e7d2c17ULL, 0xeb95e9231617fdeeULL);
+
+#endif
diff --git a/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/header_deprecated_def.h b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/header_deprecated_def.h
new file mode 100644
index 0000000000..6dbdd09a18
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/header_deprecated_def.h
@@ -0,0 +1,249 @@
+/*
+ * Copyright (C) 2009, Willow Garage, Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *   * Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *   * Neither the names of Willow Garage, Inc. nor the names of its
+ *     contributors may be used to endorse or promote products derived from
+ *     this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+ 
+#ifndef STD_MSGS_INCLUDING_HEADER_DEPRECATED_DEF
+#error("Do not include this file directly.  Instead, include std_msgs/Header.h")
+#endif
+
+namespace roslib
+{
+template 
+struct Header_ : public std_msgs::Header_
+{
+  typedef Header_ Type;
+
+  ROS_DEPRECATED Header_()
+  {
+  }
+
+  ROS_DEPRECATED Header_(const ContainerAllocator& _alloc)
+  : std_msgs::Header_(_alloc)
+  {
+  }
+
+  ROS_DEPRECATED Header_(const std_msgs::Header_& rhs)
+  {
+    *this = rhs;
+  }
+
+  ROS_DEPRECATED Type& operator=(const std_msgs::Header_& rhs)
+  {
+    if (this == &rhs)
+      return *this;
+    this->seq = rhs.seq;
+    this->stamp = rhs.stamp;
+    this->frame_id = rhs.frame_id;
+    return *this;
+  }
+
+  ROS_DEPRECATED operator std_msgs::Header_()
+  {
+    std_msgs::Header_ h;
+    h.seq = this->seq;
+    h.stamp = this->stamp;
+    h.frame_id = this->frame_id;
+    return h;
+  }
+
+private:
+  static const char* __s_getDataType_() { return "roslib/Header"; }
+public:
+   static const std::string __s_getDataType() { return __s_getDataType_(); }
+
+   const std::string __getDataType() const { return __s_getDataType_(); }
+
+private:
+  static const char* __s_getMD5Sum_() { return "2176decaecbce78abc3b96ef049fabed"; }
+public:
+   static const std::string __s_getMD5Sum() { return __s_getMD5Sum_(); }
+
+   const std::string __getMD5Sum() const { return __s_getMD5Sum_(); }
+
+private:
+  static const char* __s_getMessageDefinition_() { return "# Standard metadata for higher-level stamped data types.\n\
+# This is generally used to communicate timestamped data \n\
+# in a particular coordinate frame.\n\
+# \n\
+# sequence ID: consecutively increasing ID \n\
+uint32 seq\n\
+#Two-integer timestamp that is expressed as:\n\
+# * stamp.secs: seconds (stamp_secs) since epoch\n\
+# * stamp.nsecs: nanoseconds since stamp_secs\n\
+# time-handling sugar is provided by the client library\n\
+time stamp\n\
+#Frame this data is associated with\n\
+# 0: no frame\n\
+# 1: global frame\n\
+string frame_id\n\
+\n\
+"; }
+public:
+   static const std::string __s_getMessageDefinition() { return __s_getMessageDefinition_(); }
+
+   const std::string __getMessageDefinition() const { return __s_getMessageDefinition_(); }
+
+   virtual uint8_t *serialize(uint8_t *write_ptr, uint32_t seq) const
+  {
+    ros::serialization::OStream stream(write_ptr, 1000000000);
+    ros::serialization::serialize(stream, this->seq);
+    ros::serialization::serialize(stream, this->stamp);
+    ros::serialization::serialize(stream, this->frame_id);
+    return stream.getData();
+  }
+
+   virtual uint8_t *deserialize(uint8_t *read_ptr)
+  {
+    ros::serialization::IStream stream(read_ptr, 1000000000);
+    ros::serialization::deserialize(stream, this->seq);
+    ros::serialization::deserialize(stream, this->stamp);
+    ros::serialization::deserialize(stream, this->frame_id);
+    return stream.getData();
+  }
+
+   virtual uint32_t serializationLength() const
+  {
+    uint32_t size = 0;
+    size += ros::serialization::serializationLength(this->seq);
+    size += ros::serialization::serializationLength(this->stamp);
+    size += ros::serialization::serializationLength(this->frame_id);
+    return size;
+  }
+
+  typedef boost::shared_ptr< ::roslib::Header_ > Ptr;
+  typedef boost::shared_ptr< ::roslib::Header_  const> ConstPtr;
+}; // struct Header
+typedef  ::roslib::Header_ > Header;
+
+typedef boost::shared_ptr< ::roslib::Header> HeaderPtr;
+typedef boost::shared_ptr< ::roslib::Header const> HeaderConstPtr;
+
+
+template
+std::ostream& operator<<(std::ostream& s, const  ::roslib::Header_ & v)
+{
+  ros::message_operations::Printer< ::roslib::Header_ >::stream(s, "", v);
+  return s;}
+
+} // namespace roslib
+
+namespace ros
+{
+namespace message_traits
+{
+template
+struct MD5Sum< ::roslib::Header_ > {
+  static const char* value() 
+  {
+    return "2176decaecbce78abc3b96ef049fabed";
+  }
+
+  static const char* value(const  ::roslib::Header_ &) { return value(); } 
+  static const uint64_t static_value1 = 0x2176decaecbce78aULL;
+  static const uint64_t static_value2 = 0xbc3b96ef049fabedULL;
+};
+
+template
+struct DataType< ::roslib::Header_ > {
+  static const char* value() 
+  {
+    return "roslib/Header";
+  }
+
+  static const char* value(const  ::roslib::Header_ &) { return value(); } 
+};
+
+template
+struct Definition< ::roslib::Header_ > {
+  static const char* value() 
+  {
+    return "# Standard metadata for higher-level stamped data types.\n\
+# This is generally used to communicate timestamped data \n\
+# in a particular coordinate frame.\n\
+# \n\
+# sequence ID: consecutively increasing ID \n\
+uint32 seq\n\
+#Two-integer timestamp that is expressed as:\n\
+# * stamp.secs: seconds (stamp_secs) since epoch\n\
+# * stamp.nsecs: nanoseconds since stamp_secs\n\
+# time-handling sugar is provided by the client library\n\
+time stamp\n\
+#Frame this data is associated with\n\
+# 0: no frame\n\
+# 1: global frame\n\
+string frame_id\n\
+\n\
+";
+  }
+
+  static const char* value(const  ::roslib::Header_ &) { return value(); } 
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+template struct Serializer< ::roslib::Header_ >
+{
+  template inline static void allInOne(Stream& stream, T m)
+  {
+    stream.next(m.seq);
+    stream.next(m.stamp);
+    stream.next(m.frame_id);
+  }
+
+  ROS_DECLARE_ALLINONE_SERIALIZER;
+}; // struct Header_
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template
+struct Printer< ::roslib::Header_ >
+{
+  template static void stream(Stream& s, const std::string& indent, const  ::roslib::Header_ & v) 
+  {
+    s << indent << "seq: ";
+    Printer::stream(s, indent + "  ", v.seq);
+    s << indent << "stamp: ";
+    Printer::stream(s, indent + "  ", v.stamp);
+    s << indent << "frame_id: ";
+    Printer, typename ContainerAllocator::template rebind::other > >::stream(s, indent + "  ", v.frame_id);
+  }
+};
+
+
+} // namespace message_operations
+} // namespace ros
+
diff --git a/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/trait_macros.h b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/trait_macros.h
new file mode 100644
index 0000000000..3efa852fad
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/include/msgs/std_msgs/trait_macros.h
@@ -0,0 +1,80 @@
+
+/*
+ * Copyright (C) 2009, Willow Garage, Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *   * Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *   * Neither the names of Willow Garage, Inc. nor the names of its
+ *     contributors may be used to endorse or promote products derived from
+ *     this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef STD_MSGS_TRAIT_MACROS_H
+#define STD_MSGS_TRAIT_MACROS_H
+
+#define STD_MSGS_DEFINE_BUILTIN_TRAITS(builtin, msg, static_md5sum1, static_md5sum2) \
+  namespace ros \
+  { \
+  namespace message_traits \
+  { \
+    \
+    template<> struct MD5Sum \
+    { \
+      static const char* value() \
+      { \
+        return MD5Sum::value(); \
+      } \
+      \
+      static const char* value(const builtin&) \
+      { \
+        return value(); \
+      } \
+    }; \
+    \
+    template<> struct DataType \
+    { \
+      static const char* value() \
+      { \
+        return DataType::value(); \
+      } \
+     \
+      static const char* value(const builtin&) \
+      { \
+        return value(); \
+      } \
+    }; \
+    \
+    template<> struct Definition \
+    { \
+      static const char* value() \
+      { \
+        return Definition::value(); \
+      } \
+      \
+      static const char* value(const builtin&) \
+      { \
+        return value(); \
+      } \
+    }; \
+    \
+  } \
+  }
+
+#endif // STD_MSGS_TRAIT_MACROS_H
diff --git a/realsense-file/src/storage/realsense_file/rosbag/config.cmake b/realsense-file/src/storage/realsense_file/rosbag/config.cmake
new file mode 100644
index 0000000000..23eb0a15f6
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/rosbag/config.cmake
@@ -0,0 +1,44 @@
+cmake_minimum_required(VERSION 2.8)
+
+include(rosbag/console_bridge/config.cmake)
+include(rosbag/rosbag_storage/config.cmake)
+include(rosbag/roscpp_serialization/config.cmake)
+include(rosbag/roscpp_traits/config.cmake)
+include(rosbag/console_bridge/config.cmake)
+include(rosbag/rostime/config.cmake)
+include(rosbag/cpp_common/config.cmake)
+include(rosbag/roslz4/config.cmake)
+
+set(HEADER_FILES_ROSBAG
+
+  ${HEADER_FILES_ROSLZ4}
+)
+
+set(SOURCE_FILES_ROSBAG
+  ${HEADER_FILES_CONSOLE_BRIDGE}
+  ${HEADER_FILES_ROSBAG_STORAGE}
+  ${HEADER_FILES_ROSCPP_SERIALIZATION}
+  ${HEADER_FILES_ROSCPP_TRAITS}
+  ${HEADER_FILES_ROSTIME}
+  ${HEADER_FILES_CPP_COMMON}
+  ${SOURCE_FILES_CONSOLE_BRIDGE}
+  ${SOURCE_FILES_ROSBAG_STORAGE}
+  ${SOURCE_FILES_ROSCPP_SERIALIZATION}
+  ${SOURCE_FILES_ROSTIME}
+  ${SOURCE_FILES_CPP_COMMON}
+  ${SOURCE_FILES_ROSLZ4}
+)
+
+set(ROSBAG_HEADER_DIRS
+  ${ROOT_DIR}/src/storage/realsense_file/rosbag/console_bridge/include/
+  ${ROOT_DIR}/src/storage/realsense_file/rosbag/cpp_common/include/
+  ${ROOT_DIR}/src/storage/realsense_file/rosbag/rosbag_storage/include/
+  ${ROOT_DIR}/src/storage/realsense_file/rosbag/roscpp_serialization/include/
+  ${ROOT_DIR}/src/storage/realsense_file/rosbag/rostime/include/
+  ${ROOT_DIR}/src/storage/realsense_file/rosbag/roscpp_traits/include/
+  ${ROOT_DIR}/src/storage/realsense_file/rosbag/roslz4/include/
+  )
+
+
+
+
diff --git a/realsense-file/src/storage/realsense_file/rosbag/console_bridge/config.cmake b/realsense-file/src/storage/realsense_file/rosbag/console_bridge/config.cmake
new file mode 100644
index 0000000000..e893875282
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/rosbag/console_bridge/config.cmake
@@ -0,0 +1,13 @@
+cmake_minimum_required(VERSION 2.8)
+
+set(HEADER_FILES_CONSOLE_BRIDGE
+  rosbag/console_bridge/include/console_bridge/console.h
+  rosbag/console_bridge/include/console_bridge/exportdecl.h
+)
+
+set(SOURCE_FILES_CONSOLE_BRIDGE
+  rosbag/console_bridge/src/console.cpp
+)
+
+
+
diff --git a/realsense-file/src/storage/realsense_file/rosbag/console_bridge/include/console_bridge/console.h b/realsense-file/src/storage/realsense_file/rosbag/console_bridge/include/console_bridge/console.h
new file mode 100644
index 0000000000..9eb998851f
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/rosbag/console_bridge/include/console_bridge/console.h
@@ -0,0 +1,206 @@
+/*********************************************************************
+* Software License Agreement (BSD License)
+*
+*  Copyright (c) 2008, Willow Garage, Inc.
+*  All rights reserved.
+*
+*  Redistribution and use in source and binary forms, with or without
+*  modification, are permitted provided that the following conditions
+*  are met:
+*
+*   * Redistributions of source code must retain the above copyright
+*     notice, this list of conditions and the following disclaimer.
+*   * Redistributions in binary form must reproduce the above
+*     copyright notice, this list of conditions and the following
+*     disclaimer in the documentation and/or other materials provided
+*     with the distribution.
+*   * Neither the name of the Willow Garage nor the names of its
+*     contributors may be used to endorse or promote products derived
+*     from this software without specific prior written permission.
+*
+*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+*  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+*  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+*  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+*  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+*  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+*  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+*  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+*  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+*  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+*  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+*  POSSIBILITY OF SUCH DAMAGE.
+*********************************************************************/
+
+/* Author: Ryan Luna, Ioan Sucan */
+
+#ifndef CONSOLE_BRIDGE_CONSOLE_
+#define CONSOLE_BRIDGE_CONSOLE_
+
+#include 
+
+#include "exportdecl.h"
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#ifdef __GNUC__
+#define CONSOLE_BRIDGE_DEPRECATED __attribute__ ((deprecated))
+#elif defined(_MSC_VER)
+#define CONSOLE_BRIDGE_DEPRECATED __declspec(deprecated)
+#else
+#pragma message("WARNING: You need to implement DEPRECATED for this compiler")
+#define CONSOLE_BRIDGE_DEPRECATED
+#endif
+
+static inline void CONSOLE_BRIDGE_DEPRECATED console_bridge_deprecated() {}
+
+/** \file console.h
+    \defgroup logging Logging Macros
+    \{
+
+    \def logError(fmt, ...)
+    \brief Log a formatted error string.
+    \remarks This macro takes the same arguments as printf.
+
+    \def logWarn(fmt, ...)
+    \brief Log a formatted warning string.
+    \remarks This macro takes the same arguments as printf.
+
+    \def logInform(fmt, ...)
+    \brief Log a formatted information string.
+    \remarks This macro takes the same arguments as printf.
+
+    \def logDebug(fmt, ...)
+    \brief Log a formatted debugging string.
+    \remarks This macro takes the same arguments as printf.
+
+    \}
+*/
+#define CONSOLE_BRIDGE_logError(fmt, ...)  \
+  console_bridge::log(__FILE__, __LINE__, console_bridge::CONSOLE_BRIDGE_LOG_ERROR, fmt, ##__VA_ARGS__)
+
+#define CONSOLE_BRIDGE_logWarn(fmt, ...)   \
+  console_bridge::log(__FILE__, __LINE__, console_bridge::CONSOLE_BRIDGE_LOG_WARN,  fmt, ##__VA_ARGS__)
+
+#define CONSOLE_BRIDGE_logInform(fmt, ...) \
+  console_bridge::log(__FILE__, __LINE__, console_bridge::CONSOLE_BRIDGE_LOG_INFO,  fmt, ##__VA_ARGS__)
+
+#define CONSOLE_BRIDGE_logDebug(fmt, ...)  \
+  console_bridge::log(__FILE__, __LINE__, console_bridge::CONSOLE_BRIDGE_LOG_DEBUG, fmt, ##__VA_ARGS__)
+
+#define logError(fmt, ...)  \
+  console_bridge::log_deprecated(__FILE__, __LINE__, console_bridge::CONSOLE_BRIDGE_LOG_ERROR, fmt, ##__VA_ARGS__)
+
+#define logWarn(fmt, ...)   \
+  console_bridge::log_deprecated(__FILE__, __LINE__, console_bridge::CONSOLE_BRIDGE_LOG_WARN,  fmt, ##__VA_ARGS__)
+
+#define logInform(fmt, ...) \
+  console_bridge::log_deprecated(__FILE__, __LINE__, console_bridge::CONSOLE_BRIDGE_LOG_INFO,  fmt, ##__VA_ARGS__)
+
+#define logDebug(fmt, ...)  \
+  console_bridge::log_deprecated(__FILE__, __LINE__, console_bridge::CONSOLE_BRIDGE_LOG_DEBUG, fmt, ##__VA_ARGS__)
+
+
+/** \brief Message namespace. This contains classes needed to
+    output error messages (or logging) from within the library.
+    Message logging can be performed with \ref logging "logging macros" */
+namespace console_bridge
+{
+/** \brief The set of priorities for message logging */
+enum LogLevel
+  {
+    CONSOLE_BRIDGE_LOG_DEBUG = 0,
+    CONSOLE_BRIDGE_LOG_INFO,
+    CONSOLE_BRIDGE_LOG_WARN,
+    CONSOLE_BRIDGE_LOG_ERROR,
+    CONSOLE_BRIDGE_LOG_NONE
+  };
+
+/** \brief Generic class to handle output from a piece of
+    code.
+    
+    In order to handle output from the library in different
+    ways, an implementation of this class needs to be
+    provided. This instance can be set with the useOutputHandler
+    function. */
+class OutputHandler
+{
+public:
+  
+  OutputHandler(void)
+  {
+  }
+  
+  virtual ~OutputHandler(void)
+  {
+  }
+  
+  /** \brief log a message to the output handler with the given text
+      and logging level from a specific file and line number */
+  virtual void log(const std::string &text, LogLevel level, const char *filename, int line) = 0;
+};
+
+/** \brief Default implementation of OutputHandler. This sends
+    the information to the console. */
+class OutputHandlerSTD : public OutputHandler
+{
+public:
+  
+  OutputHandlerSTD(void) : OutputHandler()
+  {
+  }
+  
+  virtual void log(const std::string &text, LogLevel level, const char *filename, int line);
+  
+};
+
+/** \brief Implementation of OutputHandler that saves messages in a file. */
+class OutputHandlerFile : public OutputHandler
+{
+public:
+  
+  /** \brief The name of the file in which to save the message data */
+  OutputHandlerFile(const char *filename);
+  
+  virtual ~OutputHandlerFile(void);
+  
+  virtual void log(const std::string &text, LogLevel level, const char *filename, int line);
+  
+private:
+  
+  /** \brief The file to save to */
+  FILE *file_;
+  
+};
+
+/** \brief This function instructs ompl that no messages should be outputted. Equivalent to useOutputHandler(NULL) */
+void noOutputHandler(void);
+
+/** \brief Restore the output handler that was previously in use (if any) */
+void restorePreviousOutputHandler(void);
+
+/** \brief Specify the instance of the OutputHandler to use. By default, this is OutputHandlerSTD */
+void useOutputHandler(OutputHandler *oh);
+
+/** \brief Get the instance of the OutputHandler currently used. This is NULL in case there is no output handler. */
+OutputHandler* getOutputHandler(void);
+
+/** \brief Set the minimum level of logging data to output.  Messages
+    with lower logging levels will not be recorded. */
+void setLogLevel(LogLevel level);
+
+/** \brief Retrieve the current level of logging data.  Messages
+    with lower logging levels will not be recorded. */
+LogLevel getLogLevel(void);
+
+/** \brief Root level logging function.  This should not be invoked directly,
+    but rather used via a \ref logging "logging macro".  Formats the message
+    string given the arguments and forwards the string to the output handler */
+void log(const char *file, int line, LogLevel level, const char* m, ...);
+
+/** \brief Root level logging function.  This should not be invoked directly,
+    but rather used via a \ref logging "logging macro".  Formats the message
+    string given the arguments and forwards the string to the output handler */
+CONSOLE_BRIDGE_DEPRECATED void log_deprecated(const char *file, int line, LogLevel level, const char* m, ...);
+}
+
+
+#endif
diff --git a/realsense-file/src/storage/realsense_file/rosbag/console_bridge/include/console_bridge/exportdecl.h b/realsense-file/src/storage/realsense_file/rosbag/console_bridge/include/console_bridge/exportdecl.h
new file mode 100644
index 0000000000..57d5b0bcb7
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/rosbag/console_bridge/include/console_bridge/exportdecl.h
@@ -0,0 +1,84 @@
+/*********************************************************************
+* Software License Agreement (BSD License)
+*
+*  Copyright (c) 2008, Willow Garage, Inc.
+*  All rights reserved.
+*
+*  Redistribution and use in source and binary forms, with or without
+*  modification, are permitted provided that the following conditions
+*  are met:
+*
+*   * Redistributions of source code must retain the above copyright
+*     notice, this list of conditions and the following disclaimer.
+*   * Redistributions in binary form must reproduce the above
+*     copyright notice, this list of conditions and the following
+*     disclaimer in the documentation and/or other materials provided
+*     with the distribution.
+*   * Neither the name of the Willow Garage nor the names of its
+*     contributors may be used to endorse or promote products derived
+*     from this software without specific prior written permission.
+*
+*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+*  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+*  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+*  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+*  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+*  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+*  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+*  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+*  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+*  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+*  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+*  POSSIBILITY OF SUCH DAMAGE.
+*********************************************************************/
+
+/* Author: Thomas Moulard */
+
+#ifndef CONSOLE_BRIDGE_EXPORTDECL_H
+# define CONSOLE_BRIDGE_EXPORTDECL_H
+
+// Handle portable symbol export.
+// Defining manually which symbol should be exported is required
+// under Windows whether MinGW or MSVC is used.
+//
+// The headers then have to be able to work in two different modes:
+// - dllexport when one is building the library,
+// - dllimport for clients using the library.
+//
+// On Linux, set the visibility accordingly. If C++ symbol visibility
+// is handled by the compiler, see: http://gcc.gnu.org/wiki/Visibility
+# if defined _WIN32 || defined __CYGWIN__
+// On Microsoft Windows, use dllimport and dllexport to tag symbols.
+//#  define CONSOLE_BRIDGE_DLLIMPORT __declspec(dllimport)
+//#  define CONSOLE_BRIDGE_DLLEXPORT __declspec(dllexport)
+//#  define CONSOLE_BRIDGE_DLLLOCAL
+# else
+// On Linux, for GCC >= 4, tag symbols using GCC extension.
+#  if __GNUC__ >= 4
+#   define CONSOLE_BRIDGE_DLLIMPORT __attribute__ ((visibility("default")))
+#   define CONSOLE_BRIDGE_DLLEXPORT __attribute__ ((visibility("default")))
+#   define CONSOLE_BRIDGE_DLLLOCAL  __attribute__ ((visibility("hidden")))
+#  else
+// Otherwise (GCC < 4 or another compiler is used), export everything.
+#   define CONSOLE_BRIDGE_DLLIMPORT
+#   define CONSOLE_BRIDGE_DLLEXPORT
+#   define CONSOLE_BRIDGE_DLLLOCAL
+#  endif // __GNUC__ >= 4
+# endif // defined _WIN32 || defined __CYGWIN__
+
+# ifdef CONSOLE_BRIDGE_STATIC
+// If one is using the library statically, get rid of
+// extra information.
+#  define CONSOLE_BRIDGE_DLLAPI
+#  define CONSOLE_BRIDGE_LOCAL
+# else
+// Depending on whether one is building or using the
+// library define DLLAPI to import or export.
+#  ifdef console_bridge_EXPORTS
+#   define CONSOLE_BRIDGE_DLLAPI CONSOLE_BRIDGE_DLLEXPORT
+#  else
+#   define CONSOLE_BRIDGE_DLLAPI CONSOLE_BRIDGE_DLLIMPORT
+#  endif // CONSOLE_BRIDGE_EXPORTS
+#  define CONSOLE_BRIDGE_LOCAL CONSOLE_BRIDGE_DLLLOCAL
+# endif // CONSOLE_BRIDGE_STATIC
+#endif //! CONSOLE_BRIDGE_EXPORTDECL_H
diff --git a/realsense-file/src/storage/realsense_file/rosbag/console_bridge/src/console.cpp b/realsense-file/src/storage/realsense_file/rosbag/console_bridge/src/console.cpp
new file mode 100644
index 0000000000..36f8ec9eff
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/rosbag/console_bridge/src/console.cpp
@@ -0,0 +1,209 @@
+/*********************************************************************
+* Software License Agreement (BSD License)
+*
+*  Copyright (c) 2008, Willow Garage, Inc.
+*  All rights reserved.
+*
+*  Redistribution and use in source and binary forms, with or without
+*  modification, are permitted provided that the following conditions
+*  are met:
+*
+*   * Redistributions of source code must retain the above copyright
+*     notice, this list of conditions and the following disclaimer.
+*   * Redistributions in binary form must reproduce the above
+*     copyright notice, this list of conditions and the following
+*     disclaimer in the documentation and/or other materials provided
+*     with the distribution.
+*   * Neither the name of the Willow Garage nor the names of its
+*     contributors may be used to endorse or promote products derived
+*     from this software without specific prior written permission.
+*
+*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+*  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+*  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+*  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+*  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+*  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+*  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+*  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+*  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+*  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+*  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+*  POSSIBILITY OF SUCH DAMAGE.
+*********************************************************************/
+
+/* Author: Ryan Luna, Ioan Sucan */
+
+#include "console_bridge/console.h"
+
+#include 
+#include 
+
+#include 
+#include 
+
+/// @cond IGNORE
+
+struct DefaultOutputHandler
+{
+    DefaultOutputHandler(void)
+    {
+        output_handler_ = static_cast(&std_output_handler_);
+        previous_output_handler_ = output_handler_;
+        logLevel_ = console_bridge::CONSOLE_BRIDGE_LOG_WARN;
+    }
+
+    console_bridge::OutputHandlerSTD std_output_handler_;
+    console_bridge::OutputHandler   *output_handler_;
+    console_bridge::OutputHandler   *previous_output_handler_;
+    console_bridge::LogLevel         logLevel_;
+    std::mutex                       lock_; // it is likely the outputhandler does some I/O, so we serialize it
+};
+
+// we use this function because we want to handle static initialization correctly
+// however, the first run of this function is not thread safe, due to the use of a static
+// variable inside the function. For this reason, we ensure the first call happens during
+// static initialization using a proxy class
+static DefaultOutputHandler* getDOH(void)
+{
+    static DefaultOutputHandler DOH;
+    return &DOH;
+}
+
+#define USE_DOH                                                                \
+    DefaultOutputHandler *doh = getDOH();                                      \
+    std::lock_guard lock_guard(doh->lock_)
+
+#define MAX_BUFFER_SIZE 1024
+
+/// @endcond
+
+void console_bridge::noOutputHandler(void)
+{
+    USE_DOH;
+    doh->previous_output_handler_ = doh->output_handler_;
+    doh->output_handler_ = NULL;
+}
+
+void console_bridge::restorePreviousOutputHandler(void)
+{
+    USE_DOH;
+    std::swap(doh->previous_output_handler_, doh->output_handler_);
+}
+
+void console_bridge::useOutputHandler(OutputHandler *oh)
+{
+    USE_DOH;
+    doh->previous_output_handler_ = doh->output_handler_;
+    doh->output_handler_ = oh;
+}
+
+console_bridge::OutputHandler* console_bridge::getOutputHandler(void)
+{
+    return getDOH()->output_handler_;
+}
+
+void console_bridge::log_deprecated(const char *file, int line,
+                                    LogLevel level, const char* m, ...)
+{
+    /*
+     * Workaround: see bug ros/console 30
+     * Exact copy of console_bridge::log, please remove it once the
+     * deprecation time expires.
+     */
+    USE_DOH;
+    if (doh->output_handler_ && level >= doh->logLevel_)
+    {
+        va_list __ap;
+        va_start(__ap, m);
+        char buf[MAX_BUFFER_SIZE];
+#ifdef _MSC_VER
+        vsnprintf_s(buf, sizeof(buf), _TRUNCATE, m, __ap);
+#else
+        vsnprintf(buf, sizeof(buf), m, __ap);
+#endif
+        va_end(__ap);
+        buf[MAX_BUFFER_SIZE - 1] = '\0';
+
+        doh->output_handler_->log(buf, level, file, line);
+    }
+}
+
+void console_bridge::log(const char *file, int line, LogLevel level, const char* m, ...)
+{
+    USE_DOH;
+    if (doh->output_handler_ && level >= doh->logLevel_)
+    {
+        va_list __ap;
+        va_start(__ap, m);
+        char buf[MAX_BUFFER_SIZE];
+#ifdef _MSC_VER
+        vsnprintf_s(buf, sizeof(buf), _TRUNCATE, m, __ap);
+#else
+        vsnprintf(buf, sizeof(buf), m, __ap);
+#endif
+        va_end(__ap);
+        buf[MAX_BUFFER_SIZE - 1] = '\0';
+
+        doh->output_handler_->log(buf, level, file, line);
+    }
+}
+
+void console_bridge::setLogLevel(LogLevel level)
+{
+    USE_DOH;
+    doh->logLevel_ = level;
+}
+
+console_bridge::LogLevel console_bridge::getLogLevel(void)
+{
+    USE_DOH;
+    return doh->logLevel_;
+}
+
+static const char* LogLevelString[4] = {"Debug:   ", "Info:    ", "Warning: ", "Error:   "};
+
+void console_bridge::OutputHandlerSTD::log(const std::string &text, LogLevel level, const char *filename, int line)
+{
+    if (level >= CONSOLE_BRIDGE_LOG_WARN)
+    {
+        std::cerr << LogLevelString[level] << text << std::endl;
+        std::cerr << "         at line " << line << " in " << filename << std::endl;
+        std::cerr.flush();
+    }
+    else
+    {
+        std::cout << LogLevelString[level] << text << std::endl;
+        std::cout.flush();
+    }
+}
+
+console_bridge::OutputHandlerFile::OutputHandlerFile(const char *filename) : OutputHandler()
+{
+#ifdef _MSC_VER
+    errno_t err = fopen_s(&file_, filename, "a");
+    if (err != 0 || !file_)
+#else
+    file_ = fopen(filename, "a");
+    if (!file_)
+#endif
+        std::cerr << "Unable to open log file: '" << filename << "'" << std::endl;
+}
+
+console_bridge::OutputHandlerFile::~OutputHandlerFile(void)
+{
+    if (file_)
+        if (fclose(file_) != 0)
+            std::cerr << "Error closing logfile" << std::endl;
+}
+
+void console_bridge::OutputHandlerFile::log(const std::string &text, LogLevel level, const char *filename, int line)
+{
+    if (file_)
+    {
+        fprintf(file_, "%s%s\n", LogLevelString[level], text.c_str());
+        if(level >= CONSOLE_BRIDGE_LOG_WARN)
+            fprintf(file_, "         at line %d in %s\n", line, filename);
+        fflush(file_);
+    }
+}
diff --git a/realsense-file/src/storage/realsense_file/rosbag/cpp_common/config.cmake b/realsense-file/src/storage/realsense_file/rosbag/cpp_common/config.cmake
new file mode 100644
index 0000000000..60814bedd9
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/rosbag/cpp_common/config.cmake
@@ -0,0 +1,17 @@
+cmake_minimum_required(VERSION 2.8.3)
+
+set(HEADER_FILES_CPP_COMMON
+  rosbag/cpp_common/include/ros/cpp_common_decl.h
+  rosbag/cpp_common/include/ros/datatypes.h
+  rosbag/cpp_common/include/ros/debug.h
+  rosbag/cpp_common/include/ros/exception.h
+  rosbag/cpp_common/include/ros/header.h
+  rosbag/cpp_common/include/ros/macros.h
+  rosbag/cpp_common/include/ros/platform.h
+  rosbag/cpp_common/include/ros/types.h
+)
+
+set(SOURCE_FILES_CPP_COMMON
+  rosbag/cpp_common/src/debug.cpp
+  rosbag/cpp_common/src/header.cpp
+)
diff --git a/realsense-file/src/storage/realsense_file/rosbag/cpp_common/include/ros/cpp_common_decl.h b/realsense-file/src/storage/realsense_file/rosbag/cpp_common/include/ros/cpp_common_decl.h
new file mode 100644
index 0000000000..75bd174081
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/rosbag/cpp_common/include/ros/cpp_common_decl.h
@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2009, Willow Garage, Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *   * Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *   * Neither the names of Stanford University or Willow Garage, Inc. nor the names of its
+ *     contributors may be used to endorse or promote products derived from
+ *     this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef ROS_CPP_COMMON_DECL_H_INCLUDED
+#define ROS_CPP_COMMON_DECL_H_INCLUDED
+
+#include 
+
+#ifdef ROS_BUILD_SHARED_LIBS // ros is being built around shared libraries
+  #ifdef cpp_common_EXPORTS // we are building a shared lib/dll
+    #define CPP_COMMON_DECL ROS_HELPER_EXPORT
+  #else // we are using shared lib/dll
+    #define CPP_COMMON_DECL ROS_HELPER_IMPORT
+  #endif 
+#else // ros is being built around static libraries
+  #define CPP_COMMON_DECL
+#endif
+
+#endif
diff --git a/realsense-file/src/storage/realsense_file/rosbag/cpp_common/include/ros/datatypes.h b/realsense-file/src/storage/realsense_file/rosbag/cpp_common/include/ros/datatypes.h
new file mode 100644
index 0000000000..65bffe16c3
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/rosbag/cpp_common/include/ros/datatypes.h
@@ -0,0 +1,52 @@
+/*
+ * Copyright (C) 2008, Morgan Quigley and Willow Garage, Inc.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *   * Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *   * Neither the names of Stanford University or Willow Garage, Inc. nor the names of its
+ *     contributors may be used to endorse or promote products derived from
+ *     this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef CPP_CORE_TYPES_H
+#define CPP_CORE_TYPES_H
+
+#include 
+#include 
+#include 
+#include 
+#include 
+
+#include 
+
+
+namespace ros {
+
+typedef std::vector > VP_string;
+typedef std::vector V_string;
+typedef std::set S_string;
+typedef std::map M_string;
+typedef std::pair StringPair;
+
+typedef boost::shared_ptr M_stringPtr;
+
+}
+
+#endif // CPP_CORE_TYPES_H
diff --git a/realsense-file/src/storage/realsense_file/rosbag/cpp_common/include/ros/debug.h b/realsense-file/src/storage/realsense_file/rosbag/cpp_common/include/ros/debug.h
new file mode 100644
index 0000000000..e0c182ca87
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/rosbag/cpp_common/include/ros/debug.h
@@ -0,0 +1,54 @@
+/*
+ * Copyright (C) 2009, Willow Garage, Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *   * Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *   * Neither the names of Stanford University or Willow Garage, Inc. nor the names of its
+ *     contributors may be used to endorse or promote products derived from
+ *     this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef ROSLIB_DEBUG_H
+#define ROSLIB_DEBUG_H
+
+#include 
+#include 
+#include "cpp_common_decl.h"
+
+namespace ros
+{
+
+namespace debug
+{
+typedef std::vector V_void;
+typedef std::vector V_string;
+
+CPP_COMMON_DECL std::string getBacktrace();
+CPP_COMMON_DECL std::string backtraceToString(const V_void& addresses);
+CPP_COMMON_DECL void getBacktrace(V_void& addresses);
+CPP_COMMON_DECL void translateAddresses(const V_void& addresses, V_string& lines);
+CPP_COMMON_DECL void demangleBacktrace(const V_string& names, V_string& demangled);
+CPP_COMMON_DECL std::string demangleBacktrace(const V_string& names);
+CPP_COMMON_DECL std::string demangleName(const std::string& name);
+}
+
+}
+
+#endif
diff --git a/realsense-file/src/storage/realsense_file/rosbag/cpp_common/include/ros/exception.h b/realsense-file/src/storage/realsense_file/rosbag/cpp_common/include/ros/exception.h
new file mode 100644
index 0000000000..623c4b2b4c
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/rosbag/cpp_common/include/ros/exception.h
@@ -0,0 +1,50 @@
+/*
+ * Copyright (C) 2009, Willow Garage, Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *   * Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *   * Neither the names of Stanford University or Willow Garage, Inc. nor the names of its
+ *     contributors may be used to endorse or promote products derived from
+ *     this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef ROSLIB_EXCEPTION_H
+#define ROSLIB_EXCEPTION_H
+
+#include 
+
+namespace ros
+{
+
+/**
+ * \brief Base class for all exceptions thrown by ROS
+ */
+class Exception : public std::runtime_error
+{
+public:
+  Exception(const std::string& what)
+  : std::runtime_error(what)
+  {}
+};
+
+} // namespace ros
+
+#endif
+
diff --git a/realsense-file/src/storage/realsense_file/rosbag/cpp_common/include/ros/header.h b/realsense-file/src/storage/realsense_file/rosbag/cpp_common/include/ros/header.h
new file mode 100644
index 0000000000..d6edaa3409
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/rosbag/cpp_common/include/ros/header.h
@@ -0,0 +1,89 @@
+/*
+ * Software License Agreement (BSD License)
+ *
+ *  Copyright (c) 2008, Willow Garage, Inc.
+ *  Copyright (c) 2013, Open Source Robotics Foundation
+ *  All rights reserved.
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions
+ *  are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *   * Neither the name of Willow Garage, Inc. nor the names of its
+ *     contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ *  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ *  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ *  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ *  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ *  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ *  POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef CPP_CORE_HEADER_H
+#define CPP_CORE_HEADER_H
+
+#include 
+
+#include 
+
+#include "ros/datatypes.h"
+#include "cpp_common_decl.h"
+
+namespace ros
+{
+
+/**
+ * \brief Provides functionality to parse a connection header and retrieve values from it
+ */
+class CPP_COMMON_DECL Header
+{
+public:
+  Header();
+  ~Header();
+
+  /**
+   * \brief Get a value from a parsed header
+   * \param key Key value
+   * \param value OUT -- value corresponding to the key if there is one
+   * \return Returns true if the header had the specified key in it
+   */
+  bool getValue(const std::string& key, std::string& value) const;
+  /**
+   * \brief Returns a shared pointer to the internal map used
+   */
+  M_stringPtr getValues() { return read_map_; }
+
+  /**
+   * \brief Parse a header out of a buffer of data
+   */
+  bool parse(const boost::shared_array& buffer, uint32_t size, std::string& error_msg);
+
+  /**
+   * \brief Parse a header out of a buffer of data
+   */
+  bool parse(uint8_t* buffer, uint32_t size, std::string& error_msg);
+
+  static void write(const M_string& key_vals, boost::shared_array& buffer, uint32_t& size);
+
+private:
+
+  M_stringPtr read_map_;
+};
+
+}
+
+#endif // ROSCPP_HEADER_H
diff --git a/realsense-file/src/storage/realsense_file/rosbag/cpp_common/include/ros/macros.h b/realsense-file/src/storage/realsense_file/rosbag/cpp_common/include/ros/macros.h
new file mode 100644
index 0000000000..1dda4b14fb
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/rosbag/cpp_common/include/ros/macros.h
@@ -0,0 +1,67 @@
+/*
+ * Copyright (C) 2010, Willow Garage, Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *   * Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *   * Neither the names of Willow Garage, Inc. nor the names of its
+ *     contributors may be used to endorse or promote products derived from
+ *     this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef ROSLIB_MACROS_H_INCLUDED
+#define ROSLIB_MACROS_H_INCLUDED
+
+#if defined(__GNUC__)
+#define ROS_DEPRECATED __attribute__((deprecated))
+#define ROS_FORCE_INLINE __attribute__((always_inline))
+#elif defined(_MSC_VER)
+#define ROS_DEPRECATED
+#define ROS_FORCE_INLINE __forceinline
+#else
+#define ROS_DEPRECATED
+#define ROS_FORCE_INLINE inline
+#endif
+
+/*
+  Windows import/export and gnu http://gcc.gnu.org/wiki/Visibility
+  macros.
+ */
+#if defined(_MSC_VER)
+    #define ROS_HELPER_IMPORT __declspec(dllimport)
+    #define ROS_HELPER_EXPORT __declspec(dllexport)
+    #define ROS_HELPER_LOCAL
+#elif __GNUC__ >= 4
+    #define ROS_HELPER_IMPORT __attribute__ ((visibility("default")))
+    #define ROS_HELPER_EXPORT __attribute__ ((visibility("default")))
+    #define ROS_HELPER_LOCAL  __attribute__ ((visibility("hidden")))
+#else
+    #define ROS_HELPER_IMPORT
+    #define ROS_HELPER_EXPORT
+    #define ROS_HELPER_LOCAL
+#endif
+
+// Ignore warnings about import/exports when deriving from std classes.
+#ifdef _MSC_VER
+  #pragma warning(disable: 4251)
+  #pragma warning(disable: 4275)
+#endif
+
+#endif
+
diff --git a/realsense-file/src/storage/realsense_file/rosbag/cpp_common/include/ros/platform.h b/realsense-file/src/storage/realsense_file/rosbag/cpp_common/include/ros/platform.h
new file mode 100644
index 0000000000..32a24d80ec
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/rosbag/cpp_common/include/ros/platform.h
@@ -0,0 +1,84 @@
+/*
+ * Copyright (C) 2010, Willow Garage, Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *   * Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *   * Neither the names of Willow Garage, Inc. nor the names of its
+ *     contributors may be used to endorse or promote products derived from
+ *     this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+/*
+ * Some common cross platform utilities.
+ */
+#ifndef CPP_COMMON_PLATFORM_H_
+#define CPP_COMMON_PLATFORM_H_
+
+/******************************************************************************
+* Includes
+******************************************************************************/
+
+#ifdef WIN32
+  #ifdef _MSC_VER
+    #define WIN32_LEAN_AND_MEAN // slimmer compile times
+    #define _WINSOCKAPI_ // stops windows.h from including winsock.h (and lets us include winsock2.h)
+    #define NOMINMAX // windows c++ pollutes the environment like any factory
+  #endif
+  #include 
+#endif
+
+
+
+/******************************************************************************
+* Cross Platform Functions
+******************************************************************************/
+
+#ifndef _MSC_VER
+  #include  // getenv
+#endif
+#include 
+
+namespace ros {
+
+/**
+ * Convenient cross platform function for returning a std::string of an
+ * environment variable.
+ */
+inline bool get_environment_variable(std::string &str, const char* environment_variable) {
+	char* env_var_cstr = NULL;
+	#ifdef _MSC_VER
+	  _dupenv_s(&env_var_cstr, NULL,environment_variable);
+	#else
+	  env_var_cstr = getenv(environment_variable);
+	#endif
+	if ( env_var_cstr ) {
+		str = std::string(env_var_cstr);
+        #ifdef _MSC_VER
+		  free(env_var_cstr);
+        #endif
+		return true;
+	} else {
+		str = std::string("");
+		return false;
+	}
+}
+
+} // namespace ros
+
+#endif /* CPP_COMMON_PLATFORM_H_ */
diff --git a/realsense-file/src/storage/realsense_file/rosbag/cpp_common/include/ros/types.h b/realsense-file/src/storage/realsense_file/rosbag/cpp_common/include/ros/types.h
new file mode 100644
index 0000000000..826492dafb
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/rosbag/cpp_common/include/ros/types.h
@@ -0,0 +1,48 @@
+/*
+ * Copyright (C) 2008, Morgan Quigley and Willow Garage, Inc.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *   * Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *   * Neither the names of Stanford University or Willow Garage, Inc. nor the names of its
+ *     contributors may be used to endorse or promote products derived from
+ *     this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef ROSCPP_TYPES_H
+#define ROSCPP_TYPES_H
+
+// this is just for interoperability with visual studio, where the standard
+// integer types are not defined.
+
+#if defined(_MSC_VER) && (_MSC_VER < 1600 ) // MS express/studio 2008 or earlier
+  typedef          __int64  int64_t;
+  typedef unsigned __int64 uint64_t;
+  typedef          __int32  int32_t;
+  typedef unsigned __int32 uint32_t;
+  typedef          __int16  int16_t;
+  typedef unsigned __int16 uint16_t;
+  typedef          __int8    int8_t;
+  typedef unsigned __int8   uint8_t;
+#else
+  #include 
+#endif
+
+
+#endif // ROSCPP_TYPES_H
diff --git a/realsense-file/src/storage/realsense_file/rosbag/cpp_common/src/debug.cpp b/realsense-file/src/storage/realsense_file/rosbag/cpp_common/src/debug.cpp
new file mode 100644
index 0000000000..756c1faab4
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/rosbag/cpp_common/src/debug.cpp
@@ -0,0 +1,154 @@
+/*
+ * Copyright (C) 2009, Willow Garage, Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *   * Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *   * Neither the names of Stanford University or Willow Garage, Inc. nor the names of its
+ *     contributors may be used to endorse or promote products derived from
+ *     this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "ros/debug.h"
+
+#if defined(HAVE_EXECINFO_H)
+#include 
+#endif
+
+#if defined(HAVE_CXXABI_H)
+#include 
+#endif
+
+#include 
+#include 
+#include 
+
+namespace ros
+{
+namespace debug
+{
+
+void getBacktrace(V_void& addresses)
+{
+#if HAVE_GLIBC_BACKTRACE
+  void *array[64];
+
+  size_t size = backtrace(array, 64);
+  for (size_t i = 1; i < size; i++)
+  {
+    addresses.push_back(array[i]);
+  }
+#endif
+}
+
+void translateAddresses(const V_void& addresses, V_string& lines)
+{
+#if HAVE_GLIBC_BACKTRACE
+  if (addresses.empty())
+  {
+    return;
+  }
+
+  size_t size = addresses.size();
+  char **strings = backtrace_symbols(&addresses.front(), size);
+
+  for (size_t i = 0; i < size; ++i)
+  {
+    lines.push_back(strings[i]);
+  }
+
+  free(strings);
+#endif
+}
+
+std::string demangleName(const std::string& name)
+{
+#if HAVE_CXXABI_H
+  int status;
+  char* demangled = abi::__cxa_demangle(name, 0, 0, &status);
+  std::string out;
+  if (demangled)
+  {
+    out = demangled;
+    free(demangled);
+  }
+  else
+  {
+    out = name;
+  }
+
+  return out;
+#else
+  return name;
+#endif
+}
+
+std::string demangleBacktraceLine(const std::string& line)
+{
+  // backtrace_symbols outputs in the form:
+  // executable(function+offset) [address]
+  // We want everything between ( and + to send to demangleName()
+  size_t paren_pos = line.find('(');
+  size_t plus_pos = line.find('+');
+  if (paren_pos == std::string::npos || plus_pos == std::string::npos)
+  {
+    return line;
+  }
+
+  std::string name(line, paren_pos + 1, plus_pos - paren_pos - 1);
+  return line.substr(0, paren_pos + 1) + demangleName(name) + line.substr(plus_pos);
+}
+
+void demangleBacktrace(const V_string& lines, V_string& demangled)
+{
+  V_string::const_iterator it = lines.begin();
+  V_string::const_iterator end = lines.end();
+  for (; it != end; ++it)
+  {
+    demangled.push_back(demangleBacktraceLine(*it));
+  }
+}
+
+std::string backtraceToString(const V_void& addresses)
+{
+  V_string lines, demangled;
+  translateAddresses(addresses, lines);
+  demangleBacktrace(lines, demangled);
+
+  std::stringstream ss;
+  V_string::const_iterator it = demangled.begin();
+  V_string::const_iterator end = demangled.end();
+  for (; it != end; ++it)
+  {
+    ss << *it << std::endl;
+  }
+
+  return ss.str();
+}
+
+std::string getBacktrace()
+{
+  V_void addresses;
+  getBacktrace(addresses);
+  return backtraceToString(addresses);
+}
+
+}
+
+}
diff --git a/realsense-file/src/storage/realsense_file/rosbag/cpp_common/src/header.cpp b/realsense-file/src/storage/realsense_file/rosbag/cpp_common/src/header.cpp
new file mode 100644
index 0000000000..a90e728bbe
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/rosbag/cpp_common/src/header.cpp
@@ -0,0 +1,170 @@
+/*
+ * Software License Agreement (BSD License)
+ *
+ *  Copyright (c) 2008, Willow Garage, Inc.
+ *  All rights reserved.
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions
+ *  are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *   * Neither the name of Willow Garage, Inc. nor the names of its
+ *     contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ *  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ *  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ *  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ *  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ *  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ *  POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "ros/header.h"
+
+#include "console_bridge/console.h"
+
+#include 
+
+#include 
+#include 
+
+#define SROS_SERIALIZE_PRIMITIVE(ptr, data) { memcpy(ptr, &data, sizeof(data)); ptr += sizeof(data); }
+#define SROS_SERIALIZE_BUFFER(ptr, data, data_size) { if (data_size > 0) { memcpy(ptr, data, data_size); ptr += data_size; } }
+#define SROS_DESERIALIZE_PRIMITIVE(ptr, data) { memcpy(&data, ptr, sizeof(data)); ptr += sizeof(data); }
+#define SROS_DESERIALIZE_BUFFER(ptr, data, data_size) { if (data_size > 0) { memcpy(data, ptr, data_size); ptr += data_size; } }
+
+
+using namespace std;
+
+namespace ros
+{
+
+Header::Header()
+: read_map_(new M_string())
+{
+
+}
+
+Header::~Header()
+{
+
+}
+
+bool Header::parse(const boost::shared_array& buffer, uint32_t size, std::string& error_msg)
+{
+  return parse(buffer.get(), size, error_msg);
+}
+
+bool Header::parse(uint8_t* buffer, uint32_t size, std::string& error_msg)
+{
+  uint8_t* buf = buffer;
+  while (buf < buffer + size)
+  {
+    uint32_t len;
+    SROS_DESERIALIZE_PRIMITIVE(buf, len);
+
+    if (len > 1000000)
+    {
+      error_msg = "Received an invalid TCPROS header.  Each element must be prepended by a 4-byte length.";
+      logError("%s", error_msg);
+
+      return false;
+    }
+
+    std::string line((char*)buf, len);
+
+    buf += len;
+
+    //printf(":%s:\n", line);
+    size_t eqpos = line.find_first_of("=", 0);
+    if (eqpos == string::npos)
+    {
+      error_msg = "Received an invalid TCPROS header.  Each line must have an equals sign.";
+      logError("%s", error_msg);
+
+      return false;
+    }
+    string key = line.substr(0, eqpos);
+    string value = line.substr(eqpos+1);
+
+    (*read_map_)[key] = value;
+  }
+
+  return true;
+}
+
+bool Header::getValue(const std::string& key, std::string& value) const
+{
+  M_string::const_iterator it = read_map_->find(key);
+  if (it == read_map_->end())
+  {
+    return false;
+  }
+
+  value = it->second;
+
+  return true;
+}
+
+void Header::write(const M_string& key_vals, boost::shared_array& buffer, uint32_t& size)
+{
+  // Calculate the necessary size
+  size = 0;
+  {
+    M_string::const_iterator it = key_vals.begin();
+    M_string::const_iterator end = key_vals.end();
+    for (; it != end; ++it)
+    {
+      const std::string& key = it->first;
+      const std::string& value = it->second;
+
+      size += static_cast(key.length());
+      size += static_cast(value.length());
+      size += 1; // = sign
+      size += 4; // 4-byte length
+    }
+  }
+
+  if (size == 0)
+  {
+    return;
+  }
+
+  buffer.reset(new uint8_t[size]);
+  char* ptr = (char*)buffer.get();
+
+  // Write the data
+  {
+    M_string::const_iterator it = key_vals.begin();
+    M_string::const_iterator end = key_vals.end();
+    for (; it != end; ++it)
+    {
+      const std::string& key = it->first;
+      const std::string& value = it->second;
+
+      uint32_t len = static_cast(key.length() + value.length() + 1);
+      SROS_SERIALIZE_PRIMITIVE(ptr, len);
+      SROS_SERIALIZE_BUFFER(ptr, key.data(), key.length());
+      static const char equals = '=';
+      SROS_SERIALIZE_PRIMITIVE(ptr, equals);
+      SROS_SERIALIZE_BUFFER(ptr, value.data(), value.length());
+    }
+  }
+
+  assert(ptr == (char*)buffer.get() + size);
+}
+
+}
diff --git a/realsense-file/src/storage/realsense_file/rosbag/rosbag_storage/config.cmake b/realsense-file/src/storage/realsense_file/rosbag/rosbag_storage/config.cmake
new file mode 100644
index 0000000000..136c6f3234
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/rosbag/rosbag_storage/config.cmake
@@ -0,0 +1,29 @@
+cmake_minimum_required(VERSION 2.8.3)
+
+set(HEADER_FILES_ROSBAG_STORAGE
+  rosbag/rosbag_storage/include/rosbag/bag.h
+  rosbag/rosbag_storage/include/rosbag/bag_player.h
+  rosbag/rosbag_storage/include/rosbag/buffer.h
+  rosbag/rosbag_storage/include/rosbag/chunked_file.h
+  rosbag/rosbag_storage/include/rosbag/constants.h
+  rosbag/rosbag_storage/include/rosbag/exceptions.h
+  rosbag/rosbag_storage/include/rosbag/macros.h
+  rosbag/rosbag_storage/include/rosbag/message_instance.h
+  rosbag/rosbag_storage/include/rosbag/query.h
+  rosbag/rosbag_storage/include/rosbag/stream.h
+  rosbag/rosbag_storage/include/rosbag/structures.h
+  rosbag/rosbag_storage/include/rosbag/view.h
+)
+
+set(SOURCE_FILES_ROSBAG_STORAGE
+  rosbag/rosbag_storage/src/bag.cpp
+  rosbag/rosbag_storage/src/bag_player.cpp
+  rosbag/rosbag_storage/src/buffer.cpp
+  rosbag/rosbag_storage/src/chunked_file.cpp
+  rosbag/rosbag_storage/src/message_instance.cpp
+  rosbag/rosbag_storage/src/query.cpp
+  rosbag/rosbag_storage/src/stream.cpp
+  rosbag/rosbag_storage/src/uncompressed_stream.cpp
+  rosbag/rosbag_storage/src/view.cpp
+  rosbag/rosbag_storage/src/lz4_stream.cpp
+)
diff --git a/realsense-file/src/storage/realsense_file/rosbag/rosbag_storage/include/rosbag/bag.h b/realsense-file/src/storage/realsense_file/rosbag/rosbag_storage/include/rosbag/bag.h
new file mode 100644
index 0000000000..181b5c2808
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/rosbag/rosbag_storage/include/rosbag/bag.h
@@ -0,0 +1,626 @@
+/*********************************************************************
+* Software License Agreement (BSD License)
+*
+*  Copyright (c) 2008, Willow Garage, Inc.
+*  All rights reserved.
+*
+*  Redistribution and use in source and binary forms, with or without
+*  modification, are permitted provided that the following conditions
+*  are met:
+*
+*   * Redistributions of source code must retain the above copyright
+*     notice, this list of conditions and the following disclaimer.
+*   * Redistributions in binary form must reproduce the above
+*     copyright notice, this list of conditions and the following
+*     disclaimer in the documentation and/or other materials provided
+*     with the distribution.
+*   * Neither the name of Willow Garage, Inc. nor the names of its
+*     contributors may be used to endorse or promote products derived
+*     from this software without specific prior written permission.
+*
+*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+*  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+*  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+*  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+*  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+*  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+*  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+*  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+*  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+*  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+*  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+*  POSSIBILITY OF SUCH DAMAGE.
+*********************************************************************/
+
+#ifndef ROSBAG_BAG_H
+#define ROSBAG_BAG_H
+
+#include "rosbag/macros.h"
+
+#include "rosbag/buffer.h"
+#include "rosbag/chunked_file.h"
+#include "rosbag/constants.h"
+#include "rosbag/exceptions.h"
+#include "rosbag/structures.h"
+
+#include "ros/header.h"
+#include "ros/time.h"
+#include "ros/message_traits.h"
+#include "ros/message_event.h"
+#include "ros/serialization.h"
+
+//#include "ros/subscription_callback_helper.h"
+
+#include 
+#include 
+#include 
+#include 
+#include 
+
+#include 
+#include 
+
+#include "console_bridge/console.h"
+
+namespace rosbag {
+
+namespace bagmode
+{
+    //! The possible modes to open a bag in
+    enum BagMode
+    {
+        Write   = 1,
+        Read    = 2,
+        Append  = 4
+    };
+}
+typedef bagmode::BagMode BagMode;
+
+class MessageInstance;
+class View;
+class Query;
+
+class ROSBAG_DECL Bag
+{
+    friend class MessageInstance;
+    friend class View;
+
+public:
+    Bag();
+
+    //! Open a bag file
+    /*!
+     * \param filename The bag file to open
+     * \param mode     The mode to use (either read, write or append)
+     *
+     * Can throw BagException
+     */
+    explicit Bag(std::string const& filename, uint32_t mode = bagmode::Read);
+
+    ~Bag();
+
+    //! Open a bag file.
+    /*!
+     * \param filename The bag file to open
+     * \param mode     The mode to use (either read, write or append)
+     *
+     * Can throw BagException
+     */
+    void open(std::string const& filename, uint32_t mode = bagmode::Read);
+
+    //! Close the bag file
+    void close();
+
+    std::string     getFileName()     const;                      //!< Get the filename of the bag
+    BagMode         getMode()         const;                      //!< Get the mode the bag is in
+    uint32_t        getMajorVersion() const;                      //!< Get the major-version of the open bag file
+    uint32_t        getMinorVersion() const;                      //!< Get the minor-version of the open bag file
+    uint64_t        getSize()         const;                      //!< Get the current size of the bag file (a lower bound)
+
+    void            setCompression(CompressionType compression);  //!< Set the compression method to use for writing chunks
+    CompressionType getCompression() const;                       //!< Get the compression method to use for writing chunks
+    void            setChunkThreshold(uint32_t chunk_threshold);  //!< Set the threshold for creating new chunks
+    uint32_t        getChunkThreshold() const;                    //!< Get the threshold for creating new chunks
+
+    //! Write a message into the bag file
+    /*!
+     * \param topic The topic name
+     * \param event The message event to be added
+     *
+     * Can throw BagIOException
+     */
+    template
+    void write(std::string const& topic, ros::MessageEvent const& event);
+
+    //! Write a message into the bag file
+    /*!
+     * \param topic The topic name
+     * \param time  Timestamp of the message
+     * \param msg   The message to be added
+     * \param connection_header  A connection header.
+     *
+     * Can throw BagIOException
+     */
+    template
+    void write(std::string const& topic, ros::Time const& time, T const& msg,
+               boost::shared_ptr connection_header = boost::shared_ptr());
+
+    //! Write a message into the bag file
+    /*!
+     * \param topic The topic name
+     * \param time  Timestamp of the message
+     * \param msg   The message to be added
+     * \param connection_header  A connection header.
+     *
+     * Can throw BagIOException
+     */
+    template
+    void write(std::string const& topic, ros::Time const& time, boost::shared_ptr const& msg,
+               boost::shared_ptr connection_header = boost::shared_ptr());
+
+    //! Write a message into the bag file
+    /*!
+     * \param topic The topic name
+     * \param time  Timestamp of the message
+     * \param msg   The message to be added
+     * \param connection_header  A connection header.
+     *
+     * Can throw BagIOException
+     */
+    template
+    void write(std::string const& topic, ros::Time const& time, boost::shared_ptr const& msg,
+               boost::shared_ptr connection_header = boost::shared_ptr());
+
+private:
+    // This helper function actually does the write with an arbitrary serializable message
+    template
+    void doWrite(std::string const& topic, ros::Time const& time, T const& msg, boost::shared_ptr const& connection_header);
+
+    void openRead  (std::string const& filename);
+    void openWrite (std::string const& filename);
+    void openAppend(std::string const& filename);
+
+    void closeWrite();
+
+    template
+    boost::shared_ptr instantiateBuffer(IndexEntry const& index_entry) const;  //!< deserializes the message held in record_buffer_
+
+    void startWriting();
+    void stopWriting();
+
+    void startReadingVersion102();
+    void startReadingVersion200();
+
+    // Writing
+
+    void writeVersion();
+    void writeFileHeaderRecord();
+    void writeConnectionRecord(ConnectionInfo const* connection_info);
+    void appendConnectionRecordToBuffer(Buffer& buf, ConnectionInfo const* connection_info);
+    template
+    void writeMessageDataRecord(uint32_t conn_id, ros::Time const& time, T const& msg);
+    void writeIndexRecords();
+    void writeConnectionRecords();
+    void writeChunkInfoRecords();
+    void startWritingChunk(ros::Time time);
+    void writeChunkHeader(CompressionType compression, uint32_t compressed_size, uint32_t uncompressed_size);
+    void stopWritingChunk();
+
+    // Reading
+
+    void readVersion();
+    void readFileHeaderRecord();
+    void readConnectionRecord();
+    void readChunkHeader(ChunkHeader& chunk_header) const;
+    void readChunkInfoRecord();
+    void readConnectionIndexRecord200();
+
+    void readTopicIndexRecord102();
+    void readMessageDefinitionRecord102();
+    void readMessageDataRecord102(uint64_t offset, ros::Header& header) const;
+
+    ros::Header readMessageDataHeader(IndexEntry const& index_entry);
+    uint32_t    readMessageDataSize(IndexEntry const& index_entry) const;
+
+    template
+    void readMessageDataIntoStream(IndexEntry const& index_entry, Stream& stream) const;
+
+    void     decompressChunk(uint64_t chunk_pos) const;
+    void     decompressRawChunk(ChunkHeader const& chunk_header) const;
+    void     decompressBz2Chunk(ChunkHeader const& chunk_header) const;
+    void     decompressLz4Chunk(ChunkHeader const& chunk_header) const;
+    uint32_t getChunkOffset() const;
+
+    // Record header I/O
+
+    void writeHeader(ros::M_string const& fields);
+    void writeDataLength(uint32_t data_len);
+    void appendHeaderToBuffer(Buffer& buf, ros::M_string const& fields);
+    void appendDataLengthToBuffer(Buffer& buf, uint32_t data_len);
+
+    void readHeaderFromBuffer(Buffer& buffer, uint32_t offset, ros::Header& header, uint32_t& data_size, uint32_t& bytes_read) const;
+    void readMessageDataHeaderFromBuffer(Buffer& buffer, uint32_t offset, ros::Header& header, uint32_t& data_size, uint32_t& bytes_read) const;
+    bool readHeader(ros::Header& header) const;
+    bool readDataLength(uint32_t& data_size) const;
+    bool isOp(ros::M_string& fields, uint8_t reqOp) const;
+
+    // Header fields
+
+    template
+    std::string toHeaderString(T const* field) const;
+
+    std::string toHeaderString(ros::Time const* field) const;
+
+    template
+    bool readField(ros::M_string const& fields, std::string const& field_name, bool required, T* data) const;
+
+    bool readField(ros::M_string const& fields, std::string const& field_name, unsigned int min_len, unsigned int max_len, bool required, std::string& data) const;
+    bool readField(ros::M_string const& fields, std::string const& field_name, bool required, std::string& data) const;
+
+    bool readField(ros::M_string const& fields, std::string const& field_name, bool required, ros::Time& data) const;
+
+    ros::M_string::const_iterator checkField(ros::M_string const& fields, std::string const& field,
+                                             unsigned int min_len, unsigned int max_len, bool required) const;
+
+    // Low-level I/O
+
+    void write(char const* s, std::streamsize n);
+    void write(std::string const& s);
+    void read(char* b, std::streamsize n) const;
+    void seek(uint64_t pos, int origin = std::ios_base::beg) const;
+
+private:
+    BagMode             mode_;
+    mutable ChunkedFile file_;
+    int                 version_;
+    CompressionType     compression_;
+    uint32_t            chunk_threshold_;
+    uint32_t            bag_revision_;
+
+    uint64_t file_size_;
+    uint64_t file_header_pos_;
+    uint64_t index_data_pos_;
+    uint32_t connection_count_;
+    uint32_t chunk_count_;
+
+    // Current chunk
+    bool      chunk_open_;
+    ChunkInfo curr_chunk_info_;
+    uint64_t  curr_chunk_data_pos_;
+
+    std::map                topic_connection_ids_;
+    std::map              header_connection_ids_;
+    std::map            connections_;
+
+    std::vector                         chunks_;
+
+    std::map > connection_indexes_;
+    std::map > curr_chunk_connection_indexes_;
+
+    mutable Buffer   header_buffer_;           //!< reusable buffer in which to assemble the record header before writing to file
+    mutable Buffer   record_buffer_;           //!< reusable buffer in which to assemble the record data before writing to file
+
+    mutable Buffer   chunk_buffer_;            //!< reusable buffer to read chunk into
+    mutable Buffer   decompress_buffer_;       //!< reusable buffer to decompress chunks into
+
+    mutable Buffer   outgoing_chunk_buffer_;   //!< reusable buffer to read chunk into
+
+    mutable Buffer*  current_buffer_;
+
+    mutable uint64_t decompressed_chunk_;      //!< position of decompressed chunk
+};
+
+} // namespace rosbag
+
+#include "rosbag/message_instance.h"
+
+namespace rosbag {
+
+// Templated method definitions
+
+template
+void Bag::write(std::string const& topic, ros::MessageEvent const& event) {
+    doWrite(topic, event.getReceiptTime(), *event.getMessage(), event.getConnectionHeaderPtr());
+}
+
+template
+void Bag::write(std::string const& topic, ros::Time const& time, T const& msg, boost::shared_ptr connection_header) {
+    doWrite(topic, time, msg, connection_header);
+}
+
+template
+void Bag::write(std::string const& topic, ros::Time const& time, boost::shared_ptr const& msg, boost::shared_ptr connection_header) {
+    doWrite(topic, time, *msg, connection_header);
+}
+
+template
+void Bag::write(std::string const& topic, ros::Time const& time, boost::shared_ptr const& msg, boost::shared_ptr connection_header) {
+    doWrite(topic, time, *msg, connection_header);
+}
+
+template
+std::string Bag::toHeaderString(T const* field) const {
+    return std::string((char*) field, sizeof(T));
+}
+
+template
+bool Bag::readField(ros::M_string const& fields, std::string const& field_name, bool required, T* data) const {
+    ros::M_string::const_iterator i = checkField(fields, field_name, sizeof(T), sizeof(T), required);
+    if (i == fields.end())
+        return false;
+    memcpy(data, i->second.data(), sizeof(T));
+    return true;
+}
+
+template
+void Bag::readMessageDataIntoStream(IndexEntry const& index_entry, Stream& stream) const {
+    ros::Header header;
+    uint32_t data_size;
+    uint32_t bytes_read;
+    switch (version_)
+    {
+    case 200:
+    {
+        decompressChunk(index_entry.chunk_pos);
+        readMessageDataHeaderFromBuffer(*current_buffer_, index_entry.offset, header, data_size, bytes_read);
+        if (data_size > 0)
+            memcpy(stream.advance(data_size), current_buffer_->getData() + index_entry.offset + bytes_read, data_size);
+        break;
+    }
+    case 102:
+    {
+        readMessageDataRecord102(index_entry.chunk_pos, header);
+        data_size = record_buffer_.getSize();
+        if (data_size > 0)
+            memcpy(stream.advance(data_size), record_buffer_.getData(), data_size);
+        break;
+    }
+    default:
+        throw BagFormatException((boost::format("Unhandled version: %1%") % version_).str());
+    }
+}
+
+template
+boost::shared_ptr Bag::instantiateBuffer(IndexEntry const& index_entry) const {
+    switch (version_)
+    {
+    case 200:
+    {
+        decompressChunk(index_entry.chunk_pos);
+
+        // Read the message header
+        ros::Header header;
+        uint32_t data_size;
+        uint32_t bytes_read;
+        readMessageDataHeaderFromBuffer(*current_buffer_, index_entry.offset, header, data_size, bytes_read);
+
+        // Read the connection id from the header
+        uint32_t connection_id;
+        readField(*header.getValues(), CONNECTION_FIELD_NAME, true, &connection_id);
+
+        std::map::const_iterator connection_iter = connections_.find(connection_id);
+        if (connection_iter == connections_.end())
+            throw BagFormatException((boost::format("Unknown connection ID: %1%") % connection_id).str());
+        ConnectionInfo* connection_info = connection_iter->second;
+
+        boost::shared_ptr p = boost::make_shared();
+
+        ros::serialization::PreDeserializeParams predes_params;
+        predes_params.message = p;
+        predes_params.connection_header = connection_info->header;
+        ros::serialization::PreDeserialize::notify(predes_params);
+
+        // Deserialize the message
+        ros::serialization::IStream s(current_buffer_->getData() + index_entry.offset + bytes_read, data_size);
+        ros::serialization::deserialize(s, *p);
+
+        return p;
+    }
+    case 102:
+    {
+        // Read the message record
+        ros::Header header;
+        readMessageDataRecord102(index_entry.chunk_pos, header);
+
+        ros::M_string& fields = *header.getValues();
+
+        // Read the connection id from the header
+        std::string topic, latching("0"), callerid;
+        readField(fields, TOPIC_FIELD_NAME,    true,  topic);
+        readField(fields, LATCHING_FIELD_NAME, false, latching);
+        readField(fields, CALLERID_FIELD_NAME, false, callerid);
+
+        std::map::const_iterator topic_conn_id_iter = topic_connection_ids_.find(topic);
+        if (topic_conn_id_iter == topic_connection_ids_.end())
+            throw BagFormatException((boost::format("Unknown topic: %1%") % topic).str());
+        uint32_t connection_id = topic_conn_id_iter->second;
+
+        std::map::const_iterator connection_iter = connections_.find(connection_id);
+        if (connection_iter == connections_.end())
+            throw BagFormatException((boost::format("Unknown connection ID: %1%") % connection_id).str());
+        ConnectionInfo* connection_info = connection_iter->second;
+
+        boost::shared_ptr p = boost::make_shared();
+
+        // Create a new connection header, updated with the latching and callerid values
+        boost::shared_ptr message_header(boost::make_shared());
+        for (ros::M_string::const_iterator i = connection_info->header->begin(); i != connection_info->header->end(); i++)
+            (*message_header)[i->first] = i->second;
+        (*message_header)["latching"] = latching;
+        (*message_header)["callerid"] = callerid;
+
+        ros::serialization::PreDeserializeParams predes_params;
+        predes_params.message = p;
+        predes_params.connection_header = message_header;
+        ros::serialization::PreDeserialize::notify(predes_params);
+
+        // Deserialize the message
+        ros::serialization::IStream s(record_buffer_.getData(), record_buffer_.getSize());
+        ros::serialization::deserialize(s, *p);
+
+        return p;
+    }
+    default:
+        throw BagFormatException((boost::format("Unhandled version: %1%") % version_).str());
+    }
+}
+
+template
+void Bag::doWrite(std::string const& topic, ros::Time const& time, T const& msg, boost::shared_ptr const& connection_header) {
+
+    if (time < ros::TIME_MIN)
+    {
+        throw BagException("Tried to insert a message with time less than ros::TIME_MIN");
+    }
+
+    // Whenever we write we increment our revision
+    bag_revision_++;
+
+    // Get ID for connection header
+    ConnectionInfo* connection_info = NULL;
+    uint32_t conn_id = 0;
+    if (!connection_header) {
+        // No connection header: we'll manufacture one, and store by topic
+
+        std::map::iterator topic_connection_ids_iter = topic_connection_ids_.find(topic);
+        if (topic_connection_ids_iter == topic_connection_ids_.end()) {
+            conn_id = static_cast(connections_.size());
+            topic_connection_ids_[topic] = conn_id;
+        }
+        else {
+            conn_id = topic_connection_ids_iter->second;
+            connection_info = connections_[conn_id];
+        }
+    }
+    else {
+        // Store the connection info by the address of the connection header
+
+        // Add the topic name to the connection header, so that when we later search by
+        // connection header, we can disambiguate connections that differ only by topic name (i.e.,
+        // same callerid, same message type), #3755.  This modified connection header is only used
+        // for our bookkeeping, and will not appear in the resulting .bag.
+        ros::M_string connection_header_copy(*connection_header);
+        connection_header_copy["topic"] = topic;
+
+        std::map::iterator header_connection_ids_iter = header_connection_ids_.find(connection_header_copy);
+        if (header_connection_ids_iter == header_connection_ids_.end()) {
+            conn_id = static_cast(connections_.size());
+            header_connection_ids_[connection_header_copy] = conn_id;
+        }
+        else {
+            conn_id = header_connection_ids_iter->second;
+            connection_info = connections_[conn_id];
+        }
+    }
+
+    {
+        // Seek to the end of the file (needed in case previous operation was a read)
+        seek(0, std::ios::end);
+        file_size_ = file_.getOffset();
+
+        // Write the chunk header if we're starting a new chunk
+        if (!chunk_open_)
+            startWritingChunk(time);
+
+        // Write connection info record, if necessary
+        if (connection_info == NULL) {
+            connection_info = new ConnectionInfo();
+            connection_info->id       = conn_id;
+            connection_info->topic    = topic;
+            connection_info->datatype = std::string(ros::message_traits::datatype(msg));
+            connection_info->md5sum   = std::string(ros::message_traits::md5sum(msg));
+            connection_info->msg_def  = std::string(ros::message_traits::definition(msg));
+            if (connection_header != NULL) {
+                connection_info->header = connection_header;
+            }
+            else {
+                connection_info->header = boost::make_shared();
+                (*connection_info->header)["type"]               = connection_info->datatype;
+                (*connection_info->header)["md5sum"]             = connection_info->md5sum;
+                (*connection_info->header)["message_definition"] = connection_info->msg_def;
+            }
+            connections_[conn_id] = connection_info;
+
+            writeConnectionRecord(connection_info);
+            appendConnectionRecordToBuffer(outgoing_chunk_buffer_, connection_info);
+        }
+
+        // Add to topic indexes
+        IndexEntry index_entry;
+        index_entry.time      = time;
+        index_entry.chunk_pos = curr_chunk_info_.pos;
+        index_entry.offset    = getChunkOffset();
+
+        std::multiset& chunk_connection_index = curr_chunk_connection_indexes_[connection_info->id];
+        chunk_connection_index.insert(chunk_connection_index.end(), index_entry);
+        std::multiset& connection_index = connection_indexes_[connection_info->id];
+        connection_index.insert(connection_index.end(), index_entry);
+
+        // Increment the connection count
+        curr_chunk_info_.connection_counts[connection_info->id]++;
+
+        // Write the message data
+        writeMessageDataRecord(conn_id, time, msg);
+
+        // Check if we want to stop this chunk
+        uint32_t chunk_size = getChunkOffset();
+        logDebug("  curr_chunk_size=%d (threshold=%d)", chunk_size, chunk_threshold_);
+        if (chunk_size > chunk_threshold_) {
+            // Empty the outgoing chunk
+            stopWritingChunk();
+            outgoing_chunk_buffer_.setSize(0);
+
+            // We no longer have a valid curr_chunk_info
+            curr_chunk_info_.pos = -1;
+        }
+    }
+}
+
+template
+void Bag::writeMessageDataRecord(uint32_t conn_id, ros::Time const& time, T const& msg) {
+    ros::M_string header;
+    header[OP_FIELD_NAME]         = toHeaderString(&OP_MSG_DATA);
+    header[CONNECTION_FIELD_NAME] = toHeaderString(&conn_id);
+    header[TIME_FIELD_NAME]       = toHeaderString(&time);
+
+    // Assemble message in memory first, because we need to write its length
+    uint32_t msg_ser_len = ros::serialization::serializationLength(msg);
+
+    record_buffer_.setSize(msg_ser_len);
+
+    ros::serialization::OStream s(record_buffer_.getData(), msg_ser_len);
+
+    // todo: serialize into the outgoing_chunk_buffer & remove record_buffer_
+    ros::serialization::serialize(s, msg);
+
+    // We do an extra seek here since writing our data record may
+    // have indirectly moved our file-pointer if it was a
+    // MessageInstance for our own bag
+    seek(0, std::ios::end);
+    file_size_ = file_.getOffset();
+
+    logDebug("Writing MSG_DATA [%llu:%d]: conn=%d sec=%d nsec=%d data_len=%d",
+              (unsigned long long) file_.getOffset(), getChunkOffset(), conn_id, time.sec, time.nsec, msg_ser_len);
+
+    writeHeader(header);
+    writeDataLength(msg_ser_len);
+    write((char*) record_buffer_.getData(), msg_ser_len);
+
+    // todo: use better abstraction than appendHeaderToBuffer
+    appendHeaderToBuffer(outgoing_chunk_buffer_, header);
+    appendDataLengthToBuffer(outgoing_chunk_buffer_, msg_ser_len);
+
+    uint32_t offset = outgoing_chunk_buffer_.getSize();
+    outgoing_chunk_buffer_.setSize(outgoing_chunk_buffer_.getSize() + msg_ser_len);
+    memcpy(outgoing_chunk_buffer_.getData() + offset, record_buffer_.getData(), msg_ser_len);
+
+    // Update the current chunk time range
+    if (time > curr_chunk_info_.end_time)
+        curr_chunk_info_.end_time = time;
+    else if (time < curr_chunk_info_.start_time)
+        curr_chunk_info_.start_time = time;
+}
+
+} // namespace rosbag
+
+#endif
diff --git a/realsense-file/src/storage/realsense_file/rosbag/rosbag_storage/include/rosbag/bag_player.h b/realsense-file/src/storage/realsense_file/rosbag/rosbag_storage/include/rosbag/bag_player.h
new file mode 100644
index 0000000000..a3c6749ed8
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/rosbag/rosbag_storage/include/rosbag/bag_player.h
@@ -0,0 +1,135 @@
+/*********************************************************************
+* Software License Agreement (BSD License)
+*
+*  Copyright (c) 2013, Open Source Robotics Foundation
+*  All rights reserved.
+*
+*  Redistribution and use in source and binary forms, with or without
+*  modification, are permitted provided that the following conditions
+*  are met:
+*
+*   * Redistributions of source code must retain the above copyright
+*     notice, this list of conditions and the following disclaimer.
+*   * Redistributions in binary form must reproduce the above
+*     copyright notice, this list of conditions and the following
+*     disclaimer in the documentation and/or other materials provided
+*     with the distribution.
+*   * Neither the name of Willow Garage, Inc. nor the names of its
+*     contributors may be used to endorse or promote products derived
+*     from this software without specific prior written permission.
+*
+*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+*  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+*  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+*  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+*  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+*  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+*  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+*  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+*  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+*  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+*  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+*  POSSIBILITY OF SUCH DAMAGE.
+*********************************************************************/
+
+#ifndef ROSBAG_BAG_PLAYER_H
+#define ROSBAG_BAG_PLAYER_H
+
+#include 
+
+#include "rosbag/bag.h"
+#include "rosbag/view.h"
+
+namespace rosbag
+{
+
+
+// A helper struct
+struct BagCallback
+{
+    virtual ~BagCallback() {};
+    virtual void call(MessageInstance m) = 0;
+};
+
+// A helper class for the callbacks
+template
+class BagCallbackT : public BagCallback
+{
+public:
+    typedef boost::function&)> Callback;
+
+    BagCallbackT(Callback cb) :
+        cb_(cb)
+    {}
+
+    void call(MessageInstance m) {
+        cb_(m.instantiate());
+    }
+
+private:
+    Callback cb_;
+};
+
+
+/* A class for playing back bag files at an API level. It supports
+   relatime, as well as accelerated and slowed playback. */
+class BagPlayer
+{
+public:
+  /* Constructor expecting the filename of a bag */
+  BagPlayer(const std::string &filename) throw(BagException);
+
+  /* Register a callback for a specific topic and type */
+  template
+  void register_callback(const std::string &topic,
+                         typename BagCallbackT::Callback f);
+
+  /* Unregister a callback for a topic already registered */
+  void unregister_callback(const std::string &topic);
+
+  /* Set the time in the bag to start.  
+   * Default is the first message */
+  void set_start(const ros::Time &start);
+
+  /* Set the time in the bag to stop. 
+   * Default is the last message */
+  void set_end(const ros::Time &end);
+
+  /* Set the speed to playback.  1.0 is the default. 
+   * 2.0 would be twice as fast, 0.5 is half realtime.  */
+  void set_playback_speed(double scale);
+
+  /* Start playback of the bag file using the parameters previously
+     set */
+  void start_play();
+  
+  /* Get the current time of the playback */
+  ros::Time get_time();
+
+  // Destructor
+  virtual ~BagPlayer();
+  
+
+  // The bag file interface loaded in the constructor. 
+  Bag bag;
+  
+private:
+    ros::Time real_time(const ros::Time &msg_time);
+
+    std::map cbs_;
+    ros::Time bag_start_;
+    ros::Time bag_end_;
+    ros::Time last_message_time_;
+    double playback_speed_;
+    ros::Time play_start_;
+};
+
+template
+void BagPlayer::register_callback(const std::string &topic,
+        typename BagCallbackT::Callback cb) {
+    cbs_[topic] = new BagCallbackT(cb);
+}
+
+}
+
+#endif
diff --git a/realsense-file/src/storage/realsense_file/rosbag/rosbag_storage/include/rosbag/buffer.h b/realsense-file/src/storage/realsense_file/rosbag/rosbag_storage/include/rosbag/buffer.h
new file mode 100644
index 0000000000..5f9cf1a784
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/rosbag/rosbag_storage/include/rosbag/buffer.h
@@ -0,0 +1,66 @@
+/*********************************************************************
+* Software License Agreement (BSD License)
+*
+*  Copyright (c) 2008, Willow Garage, Inc.
+*  All rights reserved.
+*
+*  Redistribution and use in source and binary forms, with or without
+*  modification, are permitted provided that the following conditions
+*  are met:
+*
+*   * Redistributions of source code must retain the above copyright
+*     notice, this list of conditions and the following disclaimer.
+*   * Redistributions in binary form must reproduce the above
+*     copyright notice, this list of conditions and the following
+*     disclaimer in the documentation and/or other materials provided
+*     with the distribution.
+*   * Neither the name of Willow Garage, Inc. nor the names of its
+*     contributors may be used to endorse or promote products derived
+*     from this software without specific prior written permission.
+*
+*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+*  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+*  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+*  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+*  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+*  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+*  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+*  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+*  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+*  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+*  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+*  POSSIBILITY OF SUCH DAMAGE.
+********************************************************************/
+
+#ifndef ROSBAG_BUFFER_H
+#define ROSBAG_BUFFER_H
+
+#include 
+#include "macros.h"
+
+namespace rosbag {
+
+class ROSBAG_DECL Buffer
+{
+public:
+    Buffer();
+    ~Buffer();
+
+    uint8_t* getData();
+    uint32_t getCapacity() const;
+    uint32_t getSize()     const;
+
+    void setSize(uint32_t size);
+
+private:
+    void ensureCapacity(uint32_t capacity);
+
+private:
+    uint8_t* buffer_;
+    uint32_t capacity_;
+    uint32_t size_;
+};
+
+} // namespace rosbag
+
+#endif
diff --git a/realsense-file/src/storage/realsense_file/rosbag/rosbag_storage/include/rosbag/chunked_file.h b/realsense-file/src/storage/realsense_file/rosbag/rosbag_storage/include/rosbag/chunked_file.h
new file mode 100644
index 0000000000..18501fd7ce
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/rosbag/rosbag_storage/include/rosbag/chunked_file.h
@@ -0,0 +1,101 @@
+/*********************************************************************
+* Software License Agreement (BSD License)
+*
+*  Copyright (c) 2008, Willow Garage, Inc.
+*  All rights reserved.
+*
+*  Redistribution and use in source and binary forms, with or without
+*  modification, are permitted provided that the following conditions
+*  are met:
+*
+*   * Redistributions of source code must retain the above copyright
+*     notice, this list of conditions and the following disclaimer.
+*   * Redistributions in binary form must reproduce the above
+*     copyright notice, this list of conditions and the following
+*     disclaimer in the documentation and/or other materials provided
+*     with the distribution.
+*   * Neither the name of Willow Garage, Inc. nor the names of its
+*     contributors may be used to endorse or promote products derived
+*     from this software without specific prior written permission.
+*
+*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+*  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+*  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+*  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+*  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+*  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+*  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+*  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+*  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+*  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+*  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+*  POSSIBILITY OF SUCH DAMAGE.
+********************************************************************/
+
+#ifndef ROSBAG_CHUNKED_FILE_H
+#define ROSBAG_CHUNKED_FILE_H
+
+#include 
+#include 
+#include 
+#include "macros.h"
+#include 
+
+#include "rosbag/stream.h"
+
+namespace rosbag {
+
+//! ChunkedFile reads and writes files which contain interleaved chunks of compressed and uncompressed data.
+class ROSBAG_DECL ChunkedFile
+{
+    friend class Stream;
+
+public:
+    ChunkedFile();
+    ~ChunkedFile();
+
+    void openWrite    (std::string const& filename);            //!< open file for writing
+    void openRead     (std::string const& filename);            //!< open file for reading
+    void openReadWrite(std::string const& filename);            //!< open file for reading & writing
+
+    void close();                                               //!< close the file
+
+    std::string getFileName()          const;                   //!< return path of currently open file
+    uint64_t    getOffset()            const;                   //!< return current offset from the beginning of the file
+    uint32_t    getCompressedBytesIn() const;                   //!< return the number of bytes written to current compressed stream
+    bool        isOpen()               const;                   //!< return true if file is open for reading or writing
+    bool        good()                 const;                   //!< return true if hasn't reached end-of-file and no error
+
+    void        setReadMode(CompressionType type);
+    void        setWriteMode(CompressionType type);
+
+    // File I/O
+    void        write(std::string const& s);
+    void        write(void* ptr, size_t size);                          //!< write size bytes from ptr to the file
+    void        read(void* ptr, size_t size);                           //!< read size bytes from the file into ptr
+    std::string getline();
+    bool        truncate(uint64_t length);
+    void        seek(uint64_t offset, int origin = std::ios_base::beg); //!< seek to given offset from origin
+    void        decompress(CompressionType compression, uint8_t* dest, unsigned int dest_len, uint8_t* source, unsigned int source_len);
+
+private:
+    void open(std::string const& filename, std::string const& mode);
+    void clearUnused();
+
+private:
+    std::string filename_;       //!< path to file
+    FILE*       file_;           //!< file pointer
+    uint64_t    offset_;         //!< current position in the file
+    uint64_t    compressed_in_;  //!< number of bytes written to current compressed stream
+    char*       unused_;         //!< extra data read by compressed stream
+    int         nUnused_;        //!< number of bytes of extra data read by compressed stream
+
+    boost::shared_ptr stream_factory_;
+
+    boost::shared_ptr read_stream_;
+    boost::shared_ptr write_stream_;
+};
+
+} // namespace rosbag
+
+#endif
diff --git a/realsense-file/src/storage/realsense_file/rosbag/rosbag_storage/include/rosbag/constants.h b/realsense-file/src/storage/realsense_file/rosbag/rosbag_storage/include/rosbag/constants.h
new file mode 100644
index 0000000000..60f4998f61
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/rosbag/rosbag_storage/include/rosbag/constants.h
@@ -0,0 +1,101 @@
+/*********************************************************************
+* Software License Agreement (BSD License)
+*
+*  Copyright (c) 2008, Willow Garage, Inc.
+*  All rights reserved.
+*
+*  Redistribution and use in source and binary forms, with or without
+*  modification, are permitted provided that the following conditions
+*  are met:
+*
+*   * Redistributions of source code must retain the above copyright
+*     notice, this list of conditions and the following disclaimer.
+*   * Redistributions in binary form must reproduce the above
+*     copyright notice, this list of conditions and the following
+*     disclaimer in the documentation and/or other materials provided
+*     with the distribution.
+*   * Neither the name of Willow Garage, Inc. nor the names of its
+*     contributors may be used to endorse or promote products derived
+*     from this software without specific prior written permission.
+*
+*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+*  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+*  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+*  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+*  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+*  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+*  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+*  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+*  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+*  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+*  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+*  POSSIBILITY OF SUCH DAMAGE.
+*********************************************************************/
+
+#ifndef ROSBAG_CONSTANTS_H
+#define ROSBAG_CONSTANTS_H
+
+#include 
+#include 
+
+namespace rosbag {
+
+// Bag file version to write
+static const std::string VERSION = "2.0";
+
+// Header field delimiter
+static const unsigned char FIELD_DELIM = '=';
+
+// Current header fields
+static const std::string OP_FIELD_NAME               = "op";
+static const std::string TOPIC_FIELD_NAME            = "topic";
+static const std::string VER_FIELD_NAME              = "ver";
+static const std::string COUNT_FIELD_NAME            = "count";
+static const std::string INDEX_POS_FIELD_NAME        = "index_pos";     // 1.2+
+static const std::string CONNECTION_COUNT_FIELD_NAME = "conn_count";    // 2.0+
+static const std::string CHUNK_COUNT_FIELD_NAME      = "chunk_count";   // 2.0+
+static const std::string CONNECTION_FIELD_NAME       = "conn";          // 2.0+
+static const std::string COMPRESSION_FIELD_NAME      = "compression";   // 2.0+
+static const std::string SIZE_FIELD_NAME             = "size";          // 2.0+
+static const std::string TIME_FIELD_NAME             = "time";          // 2.0+
+static const std::string START_TIME_FIELD_NAME       = "start_time";    // 2.0+
+static const std::string END_TIME_FIELD_NAME         = "end_time";      // 2.0+
+static const std::string CHUNK_POS_FIELD_NAME        = "chunk_pos";     // 2.0+
+
+// Legacy header fields
+static const std::string MD5_FIELD_NAME      = "md5";           // <2.0
+static const std::string TYPE_FIELD_NAME     = "type";          // <2.0
+static const std::string DEF_FIELD_NAME      = "def";           // <2.0
+static const std::string SEC_FIELD_NAME      = "sec";           // <2.0
+static const std::string NSEC_FIELD_NAME     = "nsec";          // <2.0
+static const std::string LATCHING_FIELD_NAME = "latching";      // <2.0
+static const std::string CALLERID_FIELD_NAME = "callerid";      // <2.0
+
+// Current "op" field values
+static const unsigned char OP_MSG_DATA    = 0x02;
+static const unsigned char OP_FILE_HEADER = 0x03;
+static const unsigned char OP_INDEX_DATA  = 0x04;
+static const unsigned char OP_CHUNK       = 0x05;
+static const unsigned char OP_CHUNK_INFO  = 0x06;
+static const unsigned char OP_CONNECTION  = 0x07;
+
+// Legacy "op" field values
+static const unsigned char OP_MSG_DEF     = 0x01;
+
+// Bytes reserved for file header record (4KB)
+static const uint32_t FILE_HEADER_LENGTH = 4 * 1024;
+
+// Index data record version to write
+static const uint32_t INDEX_VERSION = 1;
+
+// Chunk info record version to write
+static const uint32_t CHUNK_INFO_VERSION = 1;
+
+// Compression types
+static const std::string COMPRESSION_NONE = "none";
+static const std::string COMPRESSION_BZ2  = "bz2";
+static const std::string COMPRESSION_LZ4  = "lz4";
+
+} // namespace rosbag
+
+#endif
diff --git a/realsense-file/src/storage/realsense_file/rosbag/rosbag_storage/include/rosbag/exceptions.h b/realsense-file/src/storage/realsense_file/rosbag/rosbag_storage/include/rosbag/exceptions.h
new file mode 100644
index 0000000000..b2ad153ded
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/rosbag/rosbag_storage/include/rosbag/exceptions.h
@@ -0,0 +1,72 @@
+/*********************************************************************
+* Software License Agreement (BSD License)
+*
+*  Copyright (c) 2008, Willow Garage, Inc.
+*  All rights reserved.
+*
+*  Redistribution and use in source and binary forms, with or without
+*  modification, are permitted provided that the following conditions
+*  are met:
+*
+*   * Redistributions of source code must retain the above copyright
+*     notice, this list of conditions and the following disclaimer.
+*   * Redistributions in binary form must reproduce the above
+*     copyright notice, this list of conditions and the following
+*     disclaimer in the documentation and/or other materials provided
+*     with the distribution.
+*   * Neither the name of Willow Garage, Inc. nor the names of its
+*     contributors may be used to endorse or promote products derived
+*     from this software without specific prior written permission.
+*
+*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+*  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+*  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+*  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+*  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+*  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+*  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+*  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+*  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+*  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+*  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+*  POSSIBILITY OF SUCH DAMAGE.
+*********************************************************************/
+
+#ifndef ROSBAG_EXCEPTIONS_H
+#define ROSBAG_EXCEPTIONS_H
+
+#include 
+
+namespace rosbag {
+
+//! Base class for rosbag exceptions
+class BagException : public ros::Exception
+{
+public:
+    BagException(std::string const& msg) : ros::Exception(msg) { }
+};
+
+//! Exception thrown when on IO problems
+class BagIOException : public BagException
+{
+public:
+    BagIOException(std::string const& msg) : BagException(msg) { }
+};
+
+//! Exception thrown on problems reading the bag format
+class BagFormatException : public BagException
+{
+public:
+    BagFormatException(std::string const& msg) : BagException(msg) { }
+};
+
+//! Exception thrown on problems reading the bag index
+class BagUnindexedException : public BagException
+{
+public:
+    BagUnindexedException() : BagException("Bag unindexed") { }
+};
+
+} // namespace rosbag
+
+#endif
diff --git a/realsense-file/src/storage/realsense_file/rosbag/rosbag_storage/include/rosbag/macros.h b/realsense-file/src/storage/realsense_file/rosbag/rosbag_storage/include/rosbag/macros.h
new file mode 100644
index 0000000000..967465f4ec
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/rosbag/rosbag_storage/include/rosbag/macros.h
@@ -0,0 +1,45 @@
+/*
+ * Copyright (C) 2008, Willow Garage, Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *   * Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *   * Neither the names of Stanford University or Willow Garage, Inc. nor the names of its
+ *     contributors may be used to endorse or promote products derived from
+ *     this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef ROSBAG_MACROS_H_
+#define ROSBAG_MACROS_H_
+
+#include  // for the DECL's
+
+// Import/export for windows dll's and visibility for gcc shared libraries.
+
+#ifdef ROS_BUILD_SHARED_LIBS // ros is being built around shared libraries
+  #ifdef rosbag_EXPORTS // we are building a shared lib/dll
+    #define ROSBAG_DECL ROS_HELPER_EXPORT
+  #else // we are using shared lib/dll
+    #define ROSBAG_DECL ROS_HELPER_IMPORT
+  #endif
+#else // ros is being built around static libraries
+  #define ROSBAG_DECL
+#endif
+
+#endif /* ROSBAG_MACROS_H_ */
diff --git a/realsense-file/src/storage/realsense_file/rosbag/rosbag_storage/include/rosbag/message_instance.h b/realsense-file/src/storage/realsense_file/rosbag/rosbag_storage/include/rosbag/message_instance.h
new file mode 100644
index 0000000000..7f18ec6fdc
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/rosbag/rosbag_storage/include/rosbag/message_instance.h
@@ -0,0 +1,175 @@
+/*********************************************************************
+* Software License Agreement (BSD License)
+*
+*  Copyright (c) 2008, Willow Garage, Inc.
+*  All rights reserved.
+*
+*  Redistribution and use in source and binary forms, with or without
+*  modification, are permitted provided that the following conditions
+*  are met:
+*
+*   * Redistributions of source code must retain the above copyright
+*     notice, this list of conditions and the following disclaimer.
+*   * Redistributions in binary form must reproduce the above
+*     copyright notice, this list of conditions and the following
+*     disclaimer in the documentation and/or other materials provided
+*     with the distribution.
+*   * Neither the name of Willow Garage, Inc. nor the names of its
+*     contributors may be used to endorse or promote products derived
+*     from this software without specific prior written permission.
+*
+*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+*  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+*  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+*  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+*  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+*  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+*  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+*  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+*  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+*  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+*  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+*  POSSIBILITY OF SUCH DAMAGE.
+*********************************************************************/
+
+#ifndef ROSBAG_MESSAGE_INSTANCE_H
+#define ROSBAG_MESSAGE_INSTANCE_H
+
+#include 
+#include 
+//#include 
+#include 
+
+#include "rosbag/structures.h"
+#include "rosbag/macros.h"
+
+namespace rosbag {
+
+class Bag;
+
+//! A class pointing into a bag file
+/*!
+ *  The MessageInstance class itself is fairly light weight.  It
+ *  simply contains a pointer to a bag-file and the index_entry
+ *  necessary to get access to the corresponding data.
+ *
+ *  It adheres to the necessary ros::message_traits to be directly
+ *  serializable.
+ */
+class ROSBAG_DECL MessageInstance
+{
+    friend class View;
+  
+public:
+    ros::Time   const& getTime()              const;
+    std::string const& getTopic()             const;
+    std::string const& getDataType()          const;
+    std::string const& getMD5Sum()            const;
+    std::string const& getMessageDefinition() const;
+
+    boost::shared_ptr getConnectionHeader() const;
+
+    std::string getCallerId() const;
+    bool        isLatching()  const;
+
+    //! Test whether the underlying message of the specified type.
+    /*!
+     * returns true iff the message is of the template type
+     */
+    template
+    bool isType() const;
+
+    //! Templated call to instantiate a message
+    /*!
+     * returns NULL pointer if incompatible
+     */
+    template
+    boost::shared_ptr instantiate() const;
+  
+    //! Write serialized message contents out to a stream
+    template
+    void write(Stream& stream) const;
+
+    //! Size of serialized message
+    uint32_t size() const;
+
+private:
+    MessageInstance(ConnectionInfo const* connection_info, IndexEntry const& index, Bag const& bag);
+
+    ConnectionInfo const* connection_info_;
+    IndexEntry const      index_entry_;
+    Bag const*            bag_;
+};
+
+
+} // namespace rosbag
+
+namespace ros {
+namespace message_traits {
+
+template<>
+struct MD5Sum
+{
+    static const char* value(const rosbag::MessageInstance& m) { return m.getMD5Sum().c_str(); }
+};
+
+template<>
+struct DataType
+{
+    static const char* value(const rosbag::MessageInstance& m) { return m.getDataType().c_str(); }
+};
+
+template<>
+struct Definition
+{
+    static const char* value(const rosbag::MessageInstance& m) { return m.getMessageDefinition().c_str(); }
+};
+
+} // namespace message_traits
+
+namespace serialization
+{
+
+template<>
+struct Serializer
+{
+    template
+    inline static void write(Stream& stream, const rosbag::MessageInstance& m) {
+        m.write(stream);
+    }
+
+    inline static uint32_t serializedLength(const rosbag::MessageInstance& m) {
+        return m.size();
+    }
+};
+
+} // namespace serialization
+
+} // namespace ros
+
+#include "rosbag/bag.h"
+
+namespace rosbag {
+
+template
+bool MessageInstance::isType() const {
+    char const* md5sum = ros::message_traits::MD5Sum::value();
+    return md5sum == std::string("*") || md5sum == getMD5Sum();
+}
+
+template
+boost::shared_ptr MessageInstance::instantiate() const {
+    if (!isType())
+        return boost::shared_ptr();
+
+    return bag_->instantiateBuffer(index_entry_);
+}
+
+template
+void MessageInstance::write(Stream& stream) const {
+    bag_->readMessageDataIntoStream(index_entry_, stream);
+}
+
+} // namespace rosbag
+
+#endif
diff --git a/realsense-file/src/storage/realsense_file/rosbag/rosbag_storage/include/rosbag/query.h b/realsense-file/src/storage/realsense_file/rosbag/rosbag_storage/include/rosbag/query.h
new file mode 100644
index 0000000000..fd43214c2f
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/rosbag/rosbag_storage/include/rosbag/query.h
@@ -0,0 +1,138 @@
+/*********************************************************************
+* Software License Agreement (BSD License)
+*
+*  Copyright (c) 2008, Willow Garage, Inc.
+*  All rights reserved.
+*
+*  Redistribution and use in source and binary forms, with or without
+*  modification, are permitted provided that the following conditions
+*  are met:
+*
+*   * Redistributions of source code must retain the above copyright
+*     notice, this list of conditions and the following disclaimer.
+*   * Redistributions in binary form must reproduce the above
+*     copyright notice, this list of conditions and the following
+*     disclaimer in the documentation and/or other materials provided
+*     with the distribution.
+*   * Neither the name of Willow Garage, Inc. nor the names of its
+*     contributors may be used to endorse or promote products derived
+*     from this software without specific prior written permission.
+*
+*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+*  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+*  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+*  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+*  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+*  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+*  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+*  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+*  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+*  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+*  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+*  POSSIBILITY OF SUCH DAMAGE.
+*********************************************************************/
+
+#ifndef ROSBAG_QUERY_H
+#define ROSBAG_QUERY_H
+
+#include "ros/time.h"
+
+#include 
+#include 
+#include 
+
+#include 
+#include "rosbag/macros.h"
+#include "rosbag/structures.h"
+
+namespace rosbag {
+
+class Bag;
+
+class ROSBAG_DECL Query
+{
+public:
+    //! The base query takes an optional time-range
+    /*!
+     * param start_time the beginning of the time_range for the query
+     * param end_time   the end of the time_range for the query
+     */
+    Query(boost::function& query,
+    	  ros::Time const& start_time = ros::TIME_MIN,
+          ros::Time const& end_time   = ros::TIME_MAX);
+
+    boost::function const& getQuery() const;  //!< Get the query functor
+
+    ros::Time const& getStartTime() const; //!< Get the start-time
+    ros::Time const& getEndTime()   const; //!< Get the end-time
+
+private:
+    boost::function query_;
+    ros::Time start_time_;
+    ros::Time end_time_;
+};
+
+class ROSBAG_DECL TopicQuery
+{
+public:
+    TopicQuery(std::string const& topic);
+    TopicQuery(std::vector const& topics);
+
+    bool operator()(ConnectionInfo const*) const;
+
+private:
+    std::vector topics_;
+};
+
+class ROSBAG_DECL TypeQuery
+{
+public:
+    TypeQuery(std::string const& type);
+    TypeQuery(std::vector const& types);
+
+    bool operator()(ConnectionInfo const*) const;
+
+private:
+    std::vector types_;
+};
+
+//! Pairs of queries and the bags they come from (used internally by View)
+struct ROSBAG_DECL BagQuery
+{
+    BagQuery(Bag const* _bag, Query const& _query, uint32_t _bag_revision);
+
+    Bag const* bag;
+    Query      query;
+    uint32_t   bag_revision;
+};
+
+struct ROSBAG_DECL MessageRange
+{
+    MessageRange(std::multiset::const_iterator const& _begin,
+                 std::multiset::const_iterator const& _end,
+                 ConnectionInfo const* _connection_info,
+                 BagQuery const* _bag_query);
+
+    std::multiset::const_iterator begin;
+    std::multiset::const_iterator end;
+    ConnectionInfo const* connection_info;
+    BagQuery const* bag_query;           //!< pointer to vector of queries in View
+};
+
+//! The actual iterator data structure
+struct ROSBAG_DECL ViewIterHelper
+{
+    ViewIterHelper(std::multiset::const_iterator _iter, MessageRange const* _range);
+
+    std::multiset::const_iterator iter;
+    MessageRange const* range;  //!< pointer to vector of ranges in View
+};
+
+struct ROSBAG_DECL ViewIterHelperCompare
+{
+    bool operator()(ViewIterHelper const& a, ViewIterHelper const& b);
+};
+
+} // namespace rosbag
+
+#endif
diff --git a/realsense-file/src/storage/realsense_file/rosbag/rosbag_storage/include/rosbag/stream.h b/realsense-file/src/storage/realsense_file/rosbag/rosbag_storage/include/rosbag/stream.h
new file mode 100644
index 0000000000..9cf528f2d2
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/rosbag/rosbag_storage/include/rosbag/stream.h
@@ -0,0 +1,156 @@
+/*********************************************************************
+* Software License Agreement (BSD License)
+*
+*  Copyright (c) 2008, Willow Garage, Inc.
+*  All rights reserved.
+*
+*  Redistribution and use in source and binary forms, with or without
+*  modification, are permitted provided that the following conditions
+*  are met:
+*
+*   * Redistributions of source code must retain the above copyright
+*     notice, this list of conditions and the following disclaimer.
+*   * Redistributions in binary form must reproduce the above
+*     copyright notice, this list of conditions and the following
+*     disclaimer in the documentation and/or other materials provided
+*     with the distribution.
+*   * Neither the name of Willow Garage, Inc. nor the names of its
+*     contributors may be used to endorse or promote products derived
+*     from this software without specific prior written permission.
+*
+*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+*  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+*  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+*  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+*  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+*  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+*  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+*  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+*  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+*  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+*  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+*  POSSIBILITY OF SUCH DAMAGE.
+********************************************************************/
+
+#ifndef ROSBAG_STREAM_H
+#define ROSBAG_STREAM_H
+
+#include 
+#include 
+#include 
+
+#include 
+
+#include 
+
+#include "rosbag/exceptions.h"
+#include "rosbag/macros.h"
+
+namespace rosbag {
+
+namespace compression
+{
+    enum CompressionType
+    {
+        Uncompressed = 0,
+        BZ2          = 1,
+        LZ4          = 2,
+    };
+}
+typedef compression::CompressionType CompressionType;
+
+class ChunkedFile;
+
+class ROSBAG_DECL Stream
+{
+public:
+    Stream(ChunkedFile* file);
+    virtual ~Stream();
+
+    virtual CompressionType getCompressionType() const = 0;
+
+    virtual void write(void* ptr, size_t size) = 0;
+    virtual void read (void* ptr, size_t size) = 0;
+
+    virtual void decompress(uint8_t* dest, unsigned int dest_len, uint8_t* source, unsigned int source_len) = 0;
+
+    virtual void startWrite();
+    virtual void stopWrite();
+
+    virtual void startRead();
+    virtual void stopRead();
+
+protected:
+    FILE*    getFilePointer();
+    uint64_t getCompressedIn();
+    void     setCompressedIn(uint64_t nbytes);
+    void     advanceOffset(uint64_t nbytes);
+    char*    getUnused();
+    int      getUnusedLength();
+    void     setUnused(char* unused);
+    void     setUnusedLength(int nUnused);
+    void     clearUnused();
+
+protected:
+    ChunkedFile* file_;
+};
+
+class ROSBAG_DECL StreamFactory
+{
+public:
+    StreamFactory(ChunkedFile* file);
+
+    boost::shared_ptr getStream(CompressionType type) const;
+
+private:
+    boost::shared_ptr uncompressed_stream_;
+    boost::shared_ptr lz4_stream_;
+};
+
+class ROSBAG_DECL UncompressedStream : public Stream
+{
+public:
+    UncompressedStream(ChunkedFile* file);
+
+    CompressionType getCompressionType() const;
+
+    void write(void* ptr, size_t size);
+    void read(void* ptr, size_t size);
+
+    void decompress(uint8_t* dest, unsigned int dest_len, uint8_t* source, unsigned int source_len);
+};
+
+// LZ4Stream reads/writes compressed datat in the LZ4 format
+// https://code.google.com/p/lz4/
+class ROSBAG_DECL LZ4Stream : public Stream
+{
+public:
+    LZ4Stream(ChunkedFile* file);
+    ~LZ4Stream();
+
+    CompressionType getCompressionType() const;
+
+    void startWrite();
+    void write(void* ptr, size_t size);
+    void stopWrite();
+
+    void startRead();
+    void read(void* ptr, size_t size);
+    void stopRead();
+
+    void decompress(uint8_t* dest, unsigned int dest_len, uint8_t* source, unsigned int source_len);
+
+private:
+    void writeStream(int action);
+
+    char *buff_;
+    int buff_size_;
+    int block_size_id_;
+    roslz4_stream lz4s_;
+};
+
+
+
+} // namespace rosbag
+
+#endif
diff --git a/realsense-file/src/storage/realsense_file/rosbag/rosbag_storage/include/rosbag/structures.h b/realsense-file/src/storage/realsense_file/rosbag/rosbag_storage/include/rosbag/structures.h
new file mode 100644
index 0000000000..ad75b1ee95
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/rosbag/rosbag_storage/include/rosbag/structures.h
@@ -0,0 +1,93 @@
+/*********************************************************************
+ * Software License Agreement (BSD License)
+ *
+ *  Copyright (c) 2008, Willow Garage, Inc.
+ *  All rights reserved.
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions
+ *  are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *   * Neither the name of Willow Garage, Inc. nor the names of its
+ *     contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ *  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ *  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ *  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ *  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ *  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ *  POSSIBILITY OF SUCH DAMAGE.
+ *********************************************************************/
+
+#ifndef ROSBAG_STRUCTURES_H
+#define ROSBAG_STRUCTURES_H
+
+#include 
+#include 
+
+#include "ros/time.h"
+#include "ros/datatypes.h"
+#include "macros.h"
+
+namespace rosbag {
+
+struct ROSBAG_DECL ConnectionInfo
+{
+    ConnectionInfo() : id(-1) { }
+
+    uint32_t    id;
+    std::string topic;
+    std::string datatype;
+    std::string md5sum;
+    std::string msg_def;
+
+    boost::shared_ptr header;
+};
+
+struct ChunkInfo
+{
+    ros::Time   start_time;    //! earliest timestamp of a message in the chunk
+    ros::Time   end_time;      //! latest timestamp of a message in the chunk
+    uint64_t    pos;           //! absolute byte offset of chunk record in bag file
+
+    std::map connection_counts;   //! number of messages in each connection stored in the chunk
+};
+
+struct ROSBAG_DECL ChunkHeader
+{
+    std::string compression;          //! chunk compression type, e.g. "none" or "bz2" (see constants.h)
+    uint32_t    compressed_size;      //! compressed size of the chunk in bytes
+    uint32_t    uncompressed_size;    //! uncompressed size of the chunk in bytes
+};
+
+struct ROSBAG_DECL IndexEntry
+{
+    ros::Time time;            //! timestamp of the message
+    uint64_t  chunk_pos;       //! absolute byte offset of the chunk record containing the message
+    uint32_t  offset;          //! relative byte offset of the message record (either definition or data) in the chunk
+
+    bool operator<(IndexEntry const& b) const { return time < b.time; }
+};
+
+struct ROSBAG_DECL IndexEntryCompare
+{
+    bool operator()(ros::Time const& a, IndexEntry const& b) const { return a < b.time; }
+    bool operator()(IndexEntry const& a, ros::Time const& b) const { return a.time < b; }
+};
+
+} // namespace rosbag
+
+#endif
diff --git a/realsense-file/src/storage/realsense_file/rosbag/rosbag_storage/include/rosbag/view.h b/realsense-file/src/storage/realsense_file/rosbag/rosbag_storage/include/rosbag/view.h
new file mode 100644
index 0000000000..ea9048adb9
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/rosbag/rosbag_storage/include/rosbag/view.h
@@ -0,0 +1,179 @@
+/*********************************************************************
+* Software License Agreement (BSD License)
+*
+*  Copyright (c) 2008, Willow Garage, Inc.
+*  All rights reserved.
+*
+*  Redistribution and use in source and binary forms, with or without
+*  modification, are permitted provided that the following conditions
+*  are met:
+*
+*   * Redistributions of source code must retain the above copyright
+*     notice, this list of conditions and the following disclaimer.
+*   * Redistributions in binary form must reproduce the above
+*     copyright notice, this list of conditions and the following
+*     disclaimer in the documentation and/or other materials provided
+*     with the distribution.
+*   * Neither the name of Willow Garage, Inc. nor the names of its
+*     contributors may be used to endorse or promote products derived
+*     from this software without specific prior written permission.
+*
+*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+*  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+*  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+*  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+*  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+*  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+*  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+*  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+*  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+*  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+*  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+*  POSSIBILITY OF SUCH DAMAGE.
+*********************************************************************/
+
+#ifndef ROSBAG_VIEW_H
+#define ROSBAG_VIEW_H
+
+#include 
+#include 
+
+#include "rosbag/message_instance.h"
+#include "rosbag/query.h"
+#include "rosbag/macros.h"
+#include "rosbag/structures.h"
+
+namespace rosbag {
+
+class ROSBAG_DECL View
+{
+    friend class Bag;
+
+public:
+    //! An iterator that points to a MessageInstance from a bag
+    /*!
+     * This iterator stores the MessageInstance that it is returning a
+     * reference to.  If you increment the iterator that
+     * MessageInstance is destroyed.  You should never store the
+     * pointer to this reference.
+     */
+    class iterator : public boost::iterator_facade
+    {
+    public:
+        iterator(iterator const& i);
+        iterator &operator=(iterator const& i);
+        iterator();
+        ~iterator();
+
+    protected:
+        iterator(View* view, bool end = false);
+
+    private:
+        friend class View;
+        friend class boost::iterator_core_access;
+
+		void populate();
+		void populateSeek(std::multiset::const_iterator iter);
+
+        bool equal(iterator const& other) const;
+
+        void increment();
+
+        MessageInstance& dereference() const;
+
+    private:
+        View* view_;
+        std::vector iters_;
+        uint32_t view_revision_;
+        mutable MessageInstance* message_instance_;
+    };
+
+    typedef iterator const_iterator;
+
+    struct TrueQuery {
+    	bool operator()(ConnectionInfo const*) const { return true; };
+    };
+
+    //! Create a view on a bag
+    /*!
+     * param reduce_overlap  If multiple views return the same messages, reduce them to a single message
+     */
+    View(bool const& reduce_overlap = false);
+
+    //! Create a view on a bag
+    /*!
+     * param bag             The bag file on which to run this query
+     * param start_time      The beginning of the time range for the query
+     * param end_time        The end of the time range for the query
+     * param reduce_overlap  If multiple views return the same messages, reduce them to a single message
+     */
+    View(Bag const& bag, ros::Time const& start_time = ros::TIME_MIN, ros::Time const& end_time = ros::TIME_MAX, bool const& reduce_overlap = false);
+
+    //! Create a view and add a query
+    /*!
+     * param bag             The bag file on which to run this query
+     * param query           The actual query to evaluate which connections to include
+     * param start_time      The beginning of the time range for the query
+     * param end_time        The end of the time range for the query
+     * param reduce_overlap  If multiple views return the same messages, reduce them to a single message
+     */
+    View(Bag const& bag, boost::function query,
+         ros::Time const& start_time = ros::TIME_MIN, ros::Time const& end_time = ros::TIME_MAX, bool const& reduce_overlap = false);
+
+    ~View();
+
+    iterator begin();
+    iterator end();
+    uint32_t size();
+
+    //! Add a query to a view
+    /*!
+     * param bag        The bag file on which to run this query
+     * param start_time The beginning of the time range for the query
+     * param end_time   The end of the time range for the query
+     */
+    void addQuery(Bag const& bag, ros::Time const& start_time = ros::TIME_MIN, ros::Time const& end_time = ros::TIME_MAX);
+
+    //! Add a query to a view
+    /*!
+     * param bag        The bag file on which to run this query
+     * param query      The actual query to evaluate which connections to include
+     * param start_time The beginning of the time range for the query
+     * param end_time   The end of the time range for the query
+     */
+    void addQuery(Bag const& bag, boost::function query,
+    		      ros::Time const& start_time = ros::TIME_MIN, ros::Time const& end_time = ros::TIME_MAX);
+
+    std::vector getConnections();
+
+    ros::Time getBeginTime();
+    ros::Time getEndTime();
+  
+protected:
+    friend class iterator;
+
+    void updateQueries(BagQuery* q);
+    void update();
+
+    MessageInstance* newMessageInstance(ConnectionInfo const* connection_info, IndexEntry const& index, Bag const& bag);
+
+private:
+    View(View const& view);
+    View& operator=(View const& view);
+
+protected:
+    std::vector ranges_;
+    std::vector     queries_;
+    uint32_t                   view_revision_;
+
+    uint32_t size_cache_;
+    uint32_t size_revision_;
+
+    bool reduce_overlap_;
+};
+
+} // namespace rosbag
+
+#endif
diff --git a/realsense-file/src/storage/realsense_file/rosbag/rosbag_storage/src/bag.cpp b/realsense-file/src/storage/realsense_file/rosbag/rosbag_storage/src/bag.cpp
new file mode 100644
index 0000000000..af7f2caced
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/rosbag/rosbag_storage/src/bag.cpp
@@ -0,0 +1,1119 @@
+// Copyright (c) 2009, Willow Garage, Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+//     * Redistributions of source code must retain the above copyright
+//       notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above copyright
+//       notice, this list of conditions and the following disclaimer in the
+//       documentation and/or other materials provided with the distribution.
+//     * Neither the name of Willow Garage, Inc. nor the names of its
+//       contributors may be used to endorse or promote products derived from
+//       this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+
+#include "rosbag/bag.h"
+#include "rosbag/message_instance.h"
+#include "rosbag/query.h"
+#include "rosbag/view.h"
+
+#if defined(_MSC_VER)
+  #include  // only on v2010 and later -> is this enough for msvc and linux?
+#else
+  #include 
+#endif
+#include 
+#include 
+#include 
+
+#include 
+
+#include "console_bridge/console.h"
+
+#define foreach BOOST_FOREACH
+
+using std::map;
+using std::priority_queue;
+using std::string;
+using std::vector;
+using std::multiset;
+using boost::format;
+using boost::shared_ptr;
+using ros::M_string;
+using ros::Time;
+
+namespace rosbag {
+
+Bag::Bag() :
+    mode_(bagmode::Write),
+    version_(0),
+    compression_(compression::Uncompressed),
+    chunk_threshold_(768 * 1024),  // 768KB chunks
+    bag_revision_(0),
+    file_size_(0),
+    file_header_pos_(0),
+    index_data_pos_(0),
+    connection_count_(0),
+    chunk_count_(0),
+    chunk_open_(false),
+    curr_chunk_data_pos_(0),
+    current_buffer_(0),
+    decompressed_chunk_(0)
+{
+}
+
+Bag::Bag(string const& filename, uint32_t mode) :
+    compression_(compression::Uncompressed),
+    chunk_threshold_(768 * 1024),  // 768KB chunks
+    bag_revision_(0),
+    file_size_(0),
+    file_header_pos_(0),
+    index_data_pos_(0),
+    connection_count_(0),
+    chunk_count_(0),
+    chunk_open_(false),
+    curr_chunk_data_pos_(0),
+    current_buffer_(0),
+    decompressed_chunk_(0)
+{
+    open(filename, mode);
+}
+
+Bag::~Bag() {
+    close();
+}
+
+void Bag::open(string const& filename, uint32_t mode) {
+    mode_ = (BagMode) mode;
+
+    if (mode_ & bagmode::Append)
+        openAppend(filename);
+    else if (mode_ & bagmode::Write)
+        openWrite(filename);
+    else if (mode_ & bagmode::Read)
+        openRead(filename);
+    else
+        throw BagException((format("Unknown mode: %1%") % (int) mode).str());
+
+    // Determine file size
+    uint64_t offset = file_.getOffset();
+    seek(0, std::ios::end);
+    file_size_ = file_.getOffset();
+    seek(offset);
+}
+
+void Bag::openRead(string const& filename) {
+    file_.openRead(filename);
+
+    readVersion();
+
+    switch (version_) {
+    case 102: startReadingVersion102(); break;
+    case 200: startReadingVersion200(); break;
+    default:
+        throw BagException((format("Unsupported bag file version: %1%.%2%") % getMajorVersion() % getMinorVersion()).str());
+    }
+}
+
+void Bag::openWrite(string const& filename) {
+    file_.openWrite(filename);
+
+    startWriting();
+}
+
+void Bag::openAppend(string const& filename) {
+    file_.openReadWrite(filename);
+
+    readVersion();
+
+    if (version_ != 200)
+        throw BagException((format("Bag file version %1%.%2% is unsupported for appending") % getMajorVersion() % getMinorVersion()).str());
+
+    startReadingVersion200();
+
+    // Truncate the file to chop off the index
+    file_.truncate(index_data_pos_);
+    index_data_pos_ = 0;
+
+    // Rewrite the file header, clearing the index position (so we know if the index is invalid)
+    seek(file_header_pos_);
+    writeFileHeaderRecord();
+
+    // Seek to the end of the file
+    seek(0, std::ios::end);
+}
+
+void Bag::close() {
+    if (!file_.isOpen())
+        return;
+
+    if (mode_ & bagmode::Write || mode_ & bagmode::Append)
+        closeWrite();
+
+    file_.close();
+
+    topic_connection_ids_.clear();
+    header_connection_ids_.clear();
+    for (map::iterator i = connections_.begin(); i != connections_.end(); i++)
+        delete i->second;
+    connections_.clear();
+    chunks_.clear();
+    connection_indexes_.clear();
+    curr_chunk_connection_indexes_.clear();
+}
+
+void Bag::closeWrite() {
+    stopWriting();
+}
+
+string   Bag::getFileName() const { return file_.getFileName(); }
+BagMode  Bag::getMode()     const { return mode_;               }
+uint64_t Bag::getSize()     const { return file_size_;          }
+
+uint32_t Bag::getChunkThreshold() const { return chunk_threshold_; }
+
+void Bag::setChunkThreshold(uint32_t chunk_threshold) {
+    if (file_.isOpen() && chunk_open_)
+        stopWritingChunk();
+
+    chunk_threshold_ = chunk_threshold;
+}
+
+CompressionType Bag::getCompression() const { return compression_; }
+
+void Bag::setCompression(CompressionType compression) {
+    if (file_.isOpen() && chunk_open_)
+        stopWritingChunk();
+
+    if (!(compression == compression::Uncompressed ||
+          compression == compression::BZ2 ||
+          compression == compression::LZ4)) {
+        throw BagException(
+            (format("Unknown compression type: %i")  % compression).str());
+    }
+
+    compression_ = compression;
+}
+
+// Version
+
+void Bag::writeVersion() {
+    string version = string("#ROSBAG V") + VERSION + string("\n");
+
+    logDebug("Writing VERSION [%llu]: %s", (unsigned long long) file_.getOffset(), version.c_str());
+
+    version_ = 200;
+
+    write(version);
+}
+
+void Bag::readVersion() {
+    string version_line = file_.getline();
+
+    file_header_pos_ = file_.getOffset();
+
+    char logtypename[100];
+    int version_major, version_minor;
+#if defined(_MSC_VER)
+    if (sscanf_s(version_line.c_str(), "#ROS%s V%d.%d", logtypename, sizeof(logtypename), &version_major, &version_minor) != 3)
+#else
+    if (sscanf(version_line.c_str(), "#ROS%s V%d.%d", logtypename, &version_major, &version_minor) != 3)
+#endif
+        throw BagIOException("Error reading version line");
+
+    version_ = version_major * 100 + version_minor;
+
+    logDebug("Read VERSION: version=%d", version_);
+}
+
+uint32_t Bag::getMajorVersion() const { return version_ / 100; }
+uint32_t Bag::getMinorVersion() const { return version_ % 100; }
+
+//
+
+void Bag::startWriting() {
+    writeVersion();
+    file_header_pos_ = file_.getOffset();
+    writeFileHeaderRecord();
+}
+
+void Bag::stopWriting() {
+    if (chunk_open_)
+        stopWritingChunk();
+
+    seek(0, std::ios::end);
+
+    index_data_pos_ = file_.getOffset();
+    writeConnectionRecords();
+    writeChunkInfoRecords();
+
+    seek(file_header_pos_);
+    writeFileHeaderRecord();
+}
+
+void Bag::startReadingVersion200() {
+    // Read the file header record, which points to the end of the chunks
+    readFileHeaderRecord();
+
+    // Seek to the end of the chunks
+    seek(index_data_pos_);
+
+    // Read the connection records (one for each connection)
+    for (uint32_t i = 0; i < connection_count_; i++)
+        readConnectionRecord();
+
+    // Read the chunk info records
+    for (uint32_t i = 0; i < chunk_count_; i++)
+        readChunkInfoRecord();
+
+    // Read the connection indexes for each chunk
+    foreach(ChunkInfo const& chunk_info, chunks_) {
+        curr_chunk_info_ = chunk_info;
+
+        seek(curr_chunk_info_.pos);
+
+        // Skip over the chunk data
+        ChunkHeader chunk_header;
+        readChunkHeader(chunk_header);
+        seek(chunk_header.compressed_size, std::ios::cur);
+
+        // Read the index records after the chunk
+        for (unsigned int i = 0; i < chunk_info.connection_counts.size(); i++)
+            readConnectionIndexRecord200();
+    }
+
+    // At this point we don't have a curr_chunk_info anymore so we reset it
+    curr_chunk_info_ = ChunkInfo();
+}
+
+void Bag::startReadingVersion102() {
+    try
+    {
+        // Read the file header record, which points to the start of the topic indexes
+        readFileHeaderRecord();
+    }
+    catch (BagFormatException ex) {
+        throw BagUnindexedException();
+    }
+
+    // Get the length of the file
+    seek(0, std::ios::end);
+    uint64_t filelength = file_.getOffset();
+
+    // Seek to the beginning of the topic index records
+    seek(index_data_pos_);
+
+    // Read the topic index records, which point to the offsets of each message in the file
+    while (file_.getOffset() < filelength)
+        readTopicIndexRecord102();
+
+    // Read the message definition records (which are the first entry in the topic indexes)
+    for (map >::const_iterator i = connection_indexes_.begin(); i != connection_indexes_.end(); i++) {
+        multiset const& index       = i->second;
+        IndexEntry const&           first_entry = *index.begin();
+
+        logDebug("Reading message definition for connection %d at %llu", i->first, (unsigned long long) first_entry.chunk_pos);
+
+        seek(first_entry.chunk_pos);
+
+        readMessageDefinitionRecord102();
+    }
+}
+
+// File header record
+
+void Bag::writeFileHeaderRecord() {
+    connection_count_ = static_cast(connections_.size());
+    chunk_count_      = static_cast(chunks_.size());
+
+    logDebug("Writing FILE_HEADER [%llu]: index_pos=%llu connection_count=%d chunk_count=%d",
+              (unsigned long long) file_.getOffset(), (unsigned long long) index_data_pos_, connection_count_, chunk_count_);
+
+    // Write file header record
+    M_string header;
+    header[OP_FIELD_NAME]               = toHeaderString(&OP_FILE_HEADER);
+    header[INDEX_POS_FIELD_NAME]        = toHeaderString(&index_data_pos_);
+    header[CONNECTION_COUNT_FIELD_NAME] = toHeaderString(&connection_count_);
+    header[CHUNK_COUNT_FIELD_NAME]      = toHeaderString(&chunk_count_);
+
+    boost::shared_array header_buffer;
+    uint32_t header_len;
+    ros::Header::write(header, header_buffer, header_len);
+    uint32_t data_len = 0;
+    if (header_len < FILE_HEADER_LENGTH)
+        data_len = FILE_HEADER_LENGTH - header_len;
+    write((char*) &header_len, 4);
+    write((char*) header_buffer.get(), header_len);
+    write((char*) &data_len, 4);
+
+    // Pad the file header record out
+    if (data_len > 0) {
+        string padding;
+        padding.resize(data_len, ' ');
+        write(padding);
+    }
+}
+
+void Bag::readFileHeaderRecord() {
+    ros::Header header;
+    uint32_t data_size;
+    if (!readHeader(header) || !readDataLength(data_size))
+        throw BagFormatException("Error reading FILE_HEADER record");
+
+    M_string& fields = *header.getValues();
+
+    if (!isOp(fields, OP_FILE_HEADER))
+        throw BagFormatException("Expected FILE_HEADER op not found");
+
+    // Read index position
+    readField(fields, INDEX_POS_FIELD_NAME, true, (uint64_t*) &index_data_pos_);
+
+    if (index_data_pos_ == 0)
+        throw BagUnindexedException();
+
+    // Read topic and chunks count
+    if (version_ >= 200) {
+        readField(fields, CONNECTION_COUNT_FIELD_NAME, true, &connection_count_);
+        readField(fields, CHUNK_COUNT_FIELD_NAME,      true, &chunk_count_);
+    }
+
+    logDebug("Read FILE_HEADER: index_pos=%llu connection_count=%d chunk_count=%d",
+              (unsigned long long) index_data_pos_, connection_count_, chunk_count_);
+
+    // Skip the data section (just padding)
+    seek(data_size, std::ios::cur);
+}
+
+uint32_t Bag::getChunkOffset() const {
+    if (compression_ == compression::Uncompressed)
+        return static_cast(file_.getOffset() - curr_chunk_data_pos_);
+    else
+        return file_.getCompressedBytesIn();
+}
+
+void Bag::startWritingChunk(Time time) {
+    // Initialize chunk info
+    curr_chunk_info_.pos        = file_.getOffset();
+    curr_chunk_info_.start_time = time;
+    curr_chunk_info_.end_time   = time;
+
+    // Write the chunk header, with a place-holder for the data sizes (we'll fill in when the chunk is finished)
+    writeChunkHeader(compression_, 0, 0);
+
+    // Turn on compressed writing
+    file_.setWriteMode(compression_);
+
+    // Record where the data section of this chunk started
+    curr_chunk_data_pos_ = file_.getOffset();
+
+    chunk_open_ = true;
+}
+
+void Bag::stopWritingChunk() {
+    // Add this chunk to the index
+    chunks_.push_back(curr_chunk_info_);
+
+    // Get the uncompressed and compressed sizes
+    uint32_t uncompressed_size = getChunkOffset();
+    file_.setWriteMode(compression::Uncompressed);
+    uint32_t compressed_size = static_cast(file_.getOffset() - curr_chunk_data_pos_);
+
+    // Rewrite the chunk header with the size of the chunk (remembering current offset)
+    uint64_t end_of_chunk_pos = file_.getOffset();
+
+    seek(curr_chunk_info_.pos);
+    writeChunkHeader(compression_, compressed_size, uncompressed_size);
+
+    // Write out the indexes and clear them
+    seek(end_of_chunk_pos);
+    writeIndexRecords();
+    curr_chunk_connection_indexes_.clear();
+
+    // Clear the connection counts
+    curr_chunk_info_.connection_counts.clear();
+
+    // Flag that we're starting a new chunk
+    chunk_open_ = false;
+}
+
+void Bag::writeChunkHeader(CompressionType compression, uint32_t compressed_size, uint32_t uncompressed_size) {
+    ChunkHeader chunk_header;
+    switch (compression) {
+    case compression::Uncompressed: chunk_header.compression = COMPRESSION_NONE; break;
+    case compression::BZ2:          chunk_header.compression = COMPRESSION_BZ2;  break;
+    case compression::LZ4:          chunk_header.compression = COMPRESSION_LZ4;
+    //case compression::ZLIB:         chunk_header.compression = COMPRESSION_ZLIB; break;
+    }
+    chunk_header.compressed_size   = compressed_size;
+    chunk_header.uncompressed_size = uncompressed_size;
+
+    logDebug("Writing CHUNK [%llu]: compression=%s compressed=%d uncompressed=%d",
+              (unsigned long long) file_.getOffset(), chunk_header.compression.c_str(), chunk_header.compressed_size, chunk_header.uncompressed_size);
+
+    M_string header;
+    header[OP_FIELD_NAME]          = toHeaderString(&OP_CHUNK);
+    header[COMPRESSION_FIELD_NAME] = chunk_header.compression;
+    header[SIZE_FIELD_NAME]        = toHeaderString(&chunk_header.uncompressed_size);
+    writeHeader(header);
+
+    writeDataLength(chunk_header.compressed_size);
+}
+
+void Bag::readChunkHeader(ChunkHeader& chunk_header) const {
+    ros::Header header;
+    if (!readHeader(header) || !readDataLength(chunk_header.compressed_size))
+        throw BagFormatException("Error reading CHUNK record");
+
+    M_string& fields = *header.getValues();
+
+    if (!isOp(fields, OP_CHUNK))
+        throw BagFormatException("Expected CHUNK op not found");
+
+    readField(fields, COMPRESSION_FIELD_NAME, true, chunk_header.compression);
+    readField(fields, SIZE_FIELD_NAME,        true, &chunk_header.uncompressed_size);
+
+    logDebug("Read CHUNK: compression=%s size=%d uncompressed=%d (%f)", chunk_header.compression.c_str(), chunk_header.compressed_size, chunk_header.uncompressed_size, 100 * ((double) chunk_header.compressed_size) / chunk_header.uncompressed_size);
+}
+
+// Index records
+
+void Bag::writeIndexRecords() {
+    for (map >::const_iterator i = curr_chunk_connection_indexes_.begin(); i != curr_chunk_connection_indexes_.end(); i++) {
+        uint32_t                    connection_id = i->first;
+        multiset const& index         = i->second;
+
+        // Write the index record header
+        uint32_t index_size = static_cast(index.size());
+        M_string header;
+        header[OP_FIELD_NAME]         = toHeaderString(&OP_INDEX_DATA);
+        header[CONNECTION_FIELD_NAME] = toHeaderString(&connection_id);
+        header[VER_FIELD_NAME]        = toHeaderString(&INDEX_VERSION);
+        header[COUNT_FIELD_NAME]      = toHeaderString(&index_size);
+        writeHeader(header);
+
+        writeDataLength(index_size * 12);
+
+        logDebug("Writing INDEX_DATA: connection=%d ver=%d count=%d", connection_id, INDEX_VERSION, index_size);
+
+        // Write the index record data (pairs of timestamp and position in file)
+        foreach(IndexEntry const& e, index) {
+            write((char*) &e.time.sec,  4);
+            write((char*) &e.time.nsec, 4);
+            write((char*) &e.offset,    4);
+
+            logDebug("  - %d.%d: %d", e.time.sec, e.time.nsec, e.offset);
+        }
+    }
+}
+
+void Bag::readTopicIndexRecord102() {
+    ros::Header header;
+    uint32_t data_size;
+    if (!readHeader(header) || !readDataLength(data_size))
+        throw BagFormatException("Error reading INDEX_DATA header");
+    M_string& fields = *header.getValues();
+
+    if (!isOp(fields, OP_INDEX_DATA))
+        throw BagFormatException("Expected INDEX_DATA record");
+
+    uint32_t index_version;
+    string topic;
+    uint32_t count = 0;
+    readField(fields, VER_FIELD_NAME,   true, &index_version);
+    readField(fields, TOPIC_FIELD_NAME, true, topic);
+    readField(fields, COUNT_FIELD_NAME, true, &count);
+
+    logDebug("Read INDEX_DATA: ver=%d topic=%s count=%d", index_version, topic.c_str(), count);
+
+    if (index_version != 0)
+        throw BagFormatException((format("Unsupported INDEX_DATA version: %1%") % index_version).str());
+
+    uint32_t connection_id;
+    map::const_iterator topic_conn_id_iter = topic_connection_ids_.find(topic);
+    if (topic_conn_id_iter == topic_connection_ids_.end()) {
+        connection_id = static_cast(connections_.size());
+
+        logDebug("Creating connection: id=%d topic=%s", connection_id, topic.c_str());
+        ConnectionInfo* connection_info = new ConnectionInfo();
+        connection_info->id       = connection_id;
+        connection_info->topic    = topic;
+        connections_[connection_id] = connection_info;
+
+        topic_connection_ids_[topic] = connection_id;
+    }
+    else
+        connection_id = topic_conn_id_iter->second;
+
+    multiset& connection_index = connection_indexes_[connection_id];
+
+    for (uint32_t i = 0; i < count; i++) {
+        IndexEntry index_entry;
+        uint32_t sec;
+        uint32_t nsec;
+        read((char*) &sec,                   4);
+        read((char*) &nsec,                  4);
+        read((char*) &index_entry.chunk_pos, 8);   // ros::TIME_MAX)
+        {
+          logError("Index entry for topic %s contains invalid time.", topic.c_str());
+        } else
+        {
+          connection_index.insert(connection_index.end(), index_entry);
+        }
+    }
+}
+
+void Bag::readConnectionIndexRecord200() {
+    ros::Header header;
+    uint32_t data_size;
+    if (!readHeader(header) || !readDataLength(data_size))
+        throw BagFormatException("Error reading INDEX_DATA header");
+    M_string& fields = *header.getValues();
+
+    if (!isOp(fields, OP_INDEX_DATA))
+        throw BagFormatException("Expected INDEX_DATA record");
+
+    uint32_t index_version;
+    uint32_t connection_id;
+    uint32_t count = 0;
+    readField(fields, VER_FIELD_NAME,        true, &index_version);
+    readField(fields, CONNECTION_FIELD_NAME, true, &connection_id);
+    readField(fields, COUNT_FIELD_NAME,      true, &count);
+
+    logDebug("Read INDEX_DATA: ver=%d connection=%d count=%d", index_version, connection_id, count);
+
+    if (index_version != 1)
+        throw BagFormatException((format("Unsupported INDEX_DATA version: %1%") % index_version).str());
+
+    uint64_t chunk_pos = curr_chunk_info_.pos;
+
+    multiset& connection_index = connection_indexes_[connection_id];
+
+    for (uint32_t i = 0; i < count; i++) {
+        IndexEntry index_entry;
+        index_entry.chunk_pos = chunk_pos;
+        uint32_t sec;
+        uint32_t nsec;
+        read((char*) &sec,                4);
+        read((char*) &nsec,               4);
+        read((char*) &index_entry.offset, 4);
+        index_entry.time = Time(sec, nsec);
+
+        logDebug("  - %d.%d: %llu+%d", sec, nsec, (unsigned long long) index_entry.chunk_pos, index_entry.offset);
+
+        if (index_entry.time < ros::TIME_MIN || index_entry.time > ros::TIME_MAX)
+        {
+          logError("Index entry for topic %s contains invalid time.  This message will not be loaded.", connections_[connection_id]->topic.c_str());
+        } else
+        {
+          connection_index.insert(connection_index.end(), index_entry);
+        }
+    }
+}
+
+// Connection records
+
+void Bag::writeConnectionRecords() {
+    for (map::const_iterator i = connections_.begin(); i != connections_.end(); i++) {
+        ConnectionInfo const* connection_info = i->second;
+        writeConnectionRecord(connection_info);
+    }
+}
+
+void Bag::writeConnectionRecord(ConnectionInfo const* connection_info) {
+    logDebug("Writing CONNECTION [%llu:%d]: topic=%s id=%d",
+              (unsigned long long) file_.getOffset(), getChunkOffset(), connection_info->topic.c_str(), connection_info->id);
+
+    M_string header;
+    header[OP_FIELD_NAME]         = toHeaderString(&OP_CONNECTION);
+    header[TOPIC_FIELD_NAME]      = connection_info->topic;
+    header[CONNECTION_FIELD_NAME] = toHeaderString(&connection_info->id);
+    writeHeader(header);
+
+    writeHeader(*connection_info->header);
+}
+
+void Bag::appendConnectionRecordToBuffer(Buffer& buf, ConnectionInfo const* connection_info) {
+    M_string header;
+    header[OP_FIELD_NAME]         = toHeaderString(&OP_CONNECTION);
+    header[TOPIC_FIELD_NAME]      = connection_info->topic;
+    header[CONNECTION_FIELD_NAME] = toHeaderString(&connection_info->id);
+    appendHeaderToBuffer(buf, header);
+
+    appendHeaderToBuffer(buf, *connection_info->header);
+}
+
+void Bag::readConnectionRecord() {
+    ros::Header header;
+    if (!readHeader(header))
+        throw BagFormatException("Error reading CONNECTION header");
+    M_string& fields = *header.getValues();
+
+    if (!isOp(fields, OP_CONNECTION))
+        throw BagFormatException("Expected CONNECTION op not found");
+
+    uint32_t id;
+    readField(fields, CONNECTION_FIELD_NAME, true, &id);
+    string topic;
+    readField(fields, TOPIC_FIELD_NAME,      true, topic);
+
+    ros::Header connection_header;
+    if (!readHeader(connection_header))
+        throw BagFormatException("Error reading connection header");
+
+    // If this is a new connection, update connections
+    map::iterator key = connections_.find(id);
+    if (key == connections_.end()) {
+        ConnectionInfo* connection_info = new ConnectionInfo();
+        connection_info->id       = id;
+        connection_info->topic    = topic;
+        connection_info->header = boost::make_shared();
+        for (M_string::const_iterator i = connection_header.getValues()->begin(); i != connection_header.getValues()->end(); i++)
+            (*connection_info->header)[i->first] = i->second;
+        connection_info->msg_def  = (*connection_info->header)["message_definition"];
+        connection_info->datatype = (*connection_info->header)["type"];
+        connection_info->md5sum   = (*connection_info->header)["md5sum"];
+        connections_[id] = connection_info;
+
+        logDebug("Read CONNECTION: topic=%s id=%d", topic.c_str(), id);
+    }
+}
+
+void Bag::readMessageDefinitionRecord102() {
+    ros::Header header;
+    uint32_t data_size;
+    if (!readHeader(header) || !readDataLength(data_size))
+        throw BagFormatException("Error reading message definition header");
+    M_string& fields = *header.getValues();
+
+    if (!isOp(fields, OP_MSG_DEF))
+        throw BagFormatException("Expected MSG_DEF op not found");
+
+    string topic, md5sum, datatype, message_definition;
+    readField(fields, TOPIC_FIELD_NAME,               true, topic);
+    readField(fields, MD5_FIELD_NAME,   32,       32, true, md5sum);
+    readField(fields, TYPE_FIELD_NAME,                true, datatype);
+    readField(fields, DEF_FIELD_NAME,    0, UINT_MAX, true, message_definition);
+
+    ConnectionInfo* connection_info;
+
+    map::const_iterator topic_conn_id_iter = topic_connection_ids_.find(topic);
+    if (topic_conn_id_iter == topic_connection_ids_.end()) {
+        uint32_t id = static_cast(connections_.size());
+
+        logDebug("Creating connection: topic=%s md5sum=%s datatype=%s", topic.c_str(), md5sum.c_str(), datatype.c_str());
+        connection_info = new ConnectionInfo();
+        connection_info->id       = id;
+        connection_info->topic    = topic;
+
+        connections_[id] = connection_info;
+        topic_connection_ids_[topic] = id;
+    }
+    else
+        connection_info = connections_[topic_conn_id_iter->second];
+
+    connection_info->msg_def  = message_definition;
+    connection_info->datatype = datatype;
+    connection_info->md5sum   = md5sum;
+    connection_info->header = boost::make_shared();
+    (*connection_info->header)["type"]               = connection_info->datatype;
+    (*connection_info->header)["md5sum"]             = connection_info->md5sum;
+    (*connection_info->header)["message_definition"] = connection_info->msg_def;
+
+    logDebug("Read MSG_DEF: topic=%s md5sum=%s datatype=%s", topic.c_str(), md5sum.c_str(), datatype.c_str());
+}
+
+void Bag::decompressChunk(uint64_t chunk_pos) const {
+    if (curr_chunk_info_.pos == chunk_pos) {
+        current_buffer_ = &outgoing_chunk_buffer_;
+        return;
+    }
+
+    current_buffer_ = &decompress_buffer_;
+
+    if (decompressed_chunk_ == chunk_pos)
+        return;
+
+    // Seek to the start of the chunk
+    seek(chunk_pos);
+
+    // Read the chunk header
+    ChunkHeader chunk_header;
+    readChunkHeader(chunk_header);
+
+    // Read and decompress the chunk.  These assume we are at the right place in the stream already
+    if (chunk_header.compression == COMPRESSION_NONE)
+        decompressRawChunk(chunk_header);
+    else if (chunk_header.compression == COMPRESSION_BZ2)
+        decompressBz2Chunk(chunk_header);
+    else if (chunk_header.compression == COMPRESSION_LZ4)
+        decompressLz4Chunk(chunk_header);
+    else
+        throw BagFormatException("Unknown compression: " + chunk_header.compression);
+
+    decompressed_chunk_ = chunk_pos;
+}
+
+void Bag::readMessageDataRecord102(uint64_t offset, ros::Header& header) const {
+    logDebug("readMessageDataRecord: offset=%llu", (unsigned long long) offset);
+
+    seek(offset);
+
+    uint32_t data_size;
+    uint8_t op;
+    do {
+        if (!readHeader(header) || !readDataLength(data_size))
+            throw BagFormatException("Error reading header");
+
+        readField(*header.getValues(), OP_FIELD_NAME, true, &op);
+    }
+    while (op == OP_MSG_DEF);
+
+    if (op != OP_MSG_DATA)
+        throw BagFormatException((format("Expected MSG_DATA op, got %d") % op).str());
+
+    record_buffer_.setSize(data_size);
+    file_.read((char*) record_buffer_.getData(), data_size);
+}
+
+// Reading this into a buffer isn't completely necessary, but we do it anyways for now
+void Bag::decompressRawChunk(ChunkHeader const& chunk_header) const {
+    assert(chunk_header.compression == COMPRESSION_NONE);
+    assert(chunk_header.compressed_size == chunk_header.uncompressed_size);
+
+    logDebug("compressed_size: %d uncompressed_size: %d", chunk_header.compressed_size, chunk_header.uncompressed_size);
+
+    decompress_buffer_.setSize(chunk_header.compressed_size);
+    file_.read((char*) decompress_buffer_.getData(), chunk_header.compressed_size);
+
+    // todo check read was successful
+}
+
+void Bag::decompressBz2Chunk(ChunkHeader const& chunk_header) const {
+    assert(chunk_header.compression == COMPRESSION_BZ2);
+
+    CompressionType compression = compression::BZ2;
+
+    logDebug("compressed_size: %d uncompressed_size: %d", chunk_header.compressed_size, chunk_header.uncompressed_size);
+
+    chunk_buffer_.setSize(chunk_header.compressed_size);
+    file_.read((char*) chunk_buffer_.getData(), chunk_header.compressed_size);
+
+    decompress_buffer_.setSize(chunk_header.uncompressed_size);
+    file_.decompress(compression, decompress_buffer_.getData(), decompress_buffer_.getSize(), chunk_buffer_.getData(), chunk_buffer_.getSize());
+
+    // todo check read was successful
+}
+
+void Bag::decompressLz4Chunk(ChunkHeader const& chunk_header) const {
+    assert(chunk_header.compression == COMPRESSION_LZ4);
+
+    CompressionType compression = compression::LZ4;
+
+    logDebug("lz4 compressed_size: %d uncompressed_size: %d",
+             chunk_header.compressed_size, chunk_header.uncompressed_size);
+
+    chunk_buffer_.setSize(chunk_header.compressed_size);
+    file_.read((char*) chunk_buffer_.getData(), chunk_header.compressed_size);
+
+    decompress_buffer_.setSize(chunk_header.uncompressed_size);
+    file_.decompress(compression, decompress_buffer_.getData(), decompress_buffer_.getSize(), chunk_buffer_.getData(), chunk_buffer_.getSize());
+
+    // todo check read was successful
+}
+
+ros::Header Bag::readMessageDataHeader(IndexEntry const& index_entry) {
+    ros::Header header;
+    uint32_t data_size;
+    uint32_t bytes_read;
+    switch (version_)
+    {
+    case 200:
+        decompressChunk(index_entry.chunk_pos);
+        readMessageDataHeaderFromBuffer(*current_buffer_, index_entry.offset, header, data_size, bytes_read);
+        return header;
+    case 102:
+        readMessageDataRecord102(index_entry.chunk_pos, header);
+        return header;
+    default:
+        throw BagFormatException((format("Unhandled version: %1%") % version_).str());
+    }
+}
+
+// NOTE: this loads the header, which is unnecessary
+uint32_t Bag::readMessageDataSize(IndexEntry const& index_entry) const {
+    ros::Header header;
+    uint32_t data_size;
+    uint32_t bytes_read;
+    switch (version_)
+    {
+    case 200:
+        decompressChunk(index_entry.chunk_pos);
+        readMessageDataHeaderFromBuffer(*current_buffer_, index_entry.offset, header, data_size, bytes_read);
+        return data_size;
+    case 102:
+        readMessageDataRecord102(index_entry.chunk_pos, header);
+        return record_buffer_.getSize();
+    default:
+        throw BagFormatException((format("Unhandled version: %1%") % version_).str());
+    }
+}
+
+void Bag::writeChunkInfoRecords() {
+    foreach(ChunkInfo const& chunk_info, chunks_) {
+        // Write the chunk info header
+        M_string header;
+        uint32_t chunk_connection_count = static_cast(chunk_info.connection_counts.size());
+        header[OP_FIELD_NAME]         = toHeaderString(&OP_CHUNK_INFO);
+        header[VER_FIELD_NAME]        = toHeaderString(&CHUNK_INFO_VERSION);
+        header[CHUNK_POS_FIELD_NAME]  = toHeaderString(&chunk_info.pos);
+        header[START_TIME_FIELD_NAME] = toHeaderString(&chunk_info.start_time);
+        header[END_TIME_FIELD_NAME]   = toHeaderString(&chunk_info.end_time);
+        header[COUNT_FIELD_NAME]      = toHeaderString(&chunk_connection_count);
+
+        logDebug("Writing CHUNK_INFO [%llu]: ver=%d pos=%llu start=%d.%d end=%d.%d",
+                  (unsigned long long) file_.getOffset(), CHUNK_INFO_VERSION, (unsigned long long) chunk_info.pos,
+                  chunk_info.start_time.sec, chunk_info.start_time.nsec,
+                  chunk_info.end_time.sec, chunk_info.end_time.nsec);
+
+        writeHeader(header);
+
+        writeDataLength(8 * chunk_connection_count);
+        // Write the topic names and counts
+        for (map::const_iterator i = chunk_info.connection_counts.begin(); i != chunk_info.connection_counts.end(); i++) {
+            uint32_t connection_id = i->first;
+            uint32_t count         = i->second;
+
+            write((char*) &connection_id, 4);
+            write((char*) &count, 4);
+
+            logDebug("  - %d: %d", connection_id, count);
+        }
+    }
+}
+
+void Bag::readChunkInfoRecord() {
+    // Read a CHUNK_INFO header
+    ros::Header header;
+    uint32_t data_size;
+    if (!readHeader(header) || !readDataLength(data_size))
+        throw BagFormatException("Error reading CHUNK_INFO record header");
+    M_string& fields = *header.getValues();
+    if (!isOp(fields, OP_CHUNK_INFO))
+        throw BagFormatException("Expected CHUNK_INFO op not found");
+
+    // Check that the chunk info version is current
+    uint32_t chunk_info_version;
+    readField(fields, VER_FIELD_NAME, true, &chunk_info_version);
+    if (chunk_info_version != CHUNK_INFO_VERSION)
+        throw BagFormatException((format("Expected CHUNK_INFO version %1%, read %2%") % CHUNK_INFO_VERSION % chunk_info_version).str());
+
+    // Read the chunk position, timestamp, and topic count fieldsstd_msgs::Float32
+    ChunkInfo chunk_info;
+    readField(fields, CHUNK_POS_FIELD_NAME,  true, &chunk_info.pos);
+    readField(fields, START_TIME_FIELD_NAME, true,  chunk_info.start_time);
+    readField(fields, END_TIME_FIELD_NAME,   true,  chunk_info.end_time);
+    uint32_t chunk_connection_count = 0;
+    readField(fields, COUNT_FIELD_NAME,      true, &chunk_connection_count);
+
+    logDebug("Read CHUNK_INFO: chunk_pos=%llu connection_count=%d start=%d.%d end=%d.%d",
+              (unsigned long long) chunk_info.pos, chunk_connection_count,
+              chunk_info.start_time.sec, chunk_info.start_time.nsec,
+              chunk_info.end_time.sec, chunk_info.end_time.nsec);
+
+    // Read the topic count entries
+    for (uint32_t i = 0; i < chunk_connection_count; i ++) {
+        uint32_t connection_id, connection_count;
+        read((char*) &connection_id,    4);
+        read((char*) &connection_count, 4);
+
+        logDebug("  %d: %d messages", connection_id, connection_count);
+
+        chunk_info.connection_counts[connection_id] = connection_count;
+    }
+
+    chunks_.push_back(chunk_info);
+}
+
+// Record I/O
+
+bool Bag::isOp(M_string& fields, uint8_t reqOp) const {
+    uint8_t op = 0xFF; // nonexistent op
+    readField(fields, OP_FIELD_NAME, true, &op);
+    return op == reqOp;
+}
+
+void Bag::writeHeader(M_string const& fields) {
+    boost::shared_array header_buffer;
+    uint32_t header_len;
+    ros::Header::write(fields, header_buffer, header_len);
+    write((char*) &header_len, 4);
+    write((char*) header_buffer.get(), header_len);
+}
+
+void Bag::writeDataLength(uint32_t data_len) {
+    write((char*) &data_len, 4);
+}
+
+void Bag::appendHeaderToBuffer(Buffer& buf, M_string const& fields) {
+    boost::shared_array header_buffer;
+    uint32_t header_len;
+    ros::Header::write(fields, header_buffer, header_len);
+
+    uint32_t offset = buf.getSize();
+
+    buf.setSize(buf.getSize() + 4 + header_len);
+
+    memcpy(buf.getData() + offset, &header_len, 4);
+    offset += 4;
+    memcpy(buf.getData() + offset, header_buffer.get(), header_len);
+}
+
+void Bag::appendDataLengthToBuffer(Buffer& buf, uint32_t data_len) {
+    uint32_t offset = buf.getSize();
+
+    buf.setSize(buf.getSize() + 4);
+
+    memcpy(buf.getData() + offset, &data_len, 4);
+}
+
+//! \todo clean this up
+void Bag::readHeaderFromBuffer(Buffer& buffer, uint32_t offset, ros::Header& header, uint32_t& data_size, uint32_t& bytes_read) const {
+    assert(buffer.getSize() > 8);
+
+    uint8_t* start = (uint8_t*) buffer.getData() + offset;
+
+    uint8_t* ptr = start;
+
+    // Read the header length
+    uint32_t header_len;
+    memcpy(&header_len, ptr, 4);
+    ptr += 4;
+
+    // Parse the header
+    string error_msg;
+    bool parsed = header.parse(ptr, header_len, error_msg);
+    if (!parsed)
+        throw BagFormatException("Error parsing header");
+    ptr += header_len;
+
+    // Read the data size
+    memcpy(&data_size, ptr, 4);
+    ptr += 4;
+
+    bytes_read = static_cast(ptr - start);
+}
+
+void Bag::readMessageDataHeaderFromBuffer(Buffer& buffer, uint32_t offset, ros::Header& header, uint32_t& data_size, uint32_t& total_bytes_read) const {
+    (void)buffer;
+    total_bytes_read = 0;
+    uint8_t op = 0xFF;
+    do {
+        logDebug("reading header from buffer: offset=%d", offset);
+        uint32_t bytes_read;
+        readHeaderFromBuffer(*current_buffer_, offset, header, data_size, bytes_read);
+
+        offset += bytes_read;
+        total_bytes_read += bytes_read;
+
+        readField(*header.getValues(), OP_FIELD_NAME, true, &op);
+    }
+    while (op == OP_MSG_DEF || op == OP_CONNECTION);
+
+    if (op != OP_MSG_DATA)
+        throw BagFormatException("Expected MSG_DATA op not found");
+}
+
+bool Bag::readHeader(ros::Header& header) const {
+    // Read the header length
+    uint32_t header_len;
+    read((char*) &header_len, 4);
+
+    // Read the header
+    header_buffer_.setSize(header_len);
+    read((char*) header_buffer_.getData(), header_len);
+
+    // Parse the header
+    string error_msg;
+    bool parsed = header.parse(header_buffer_.getData(), header_len, error_msg);
+    if (!parsed)
+        return false;
+
+    return true;
+}
+
+bool Bag::readDataLength(uint32_t& data_size) const {
+    read((char*) &data_size, 4);
+    return true;
+}
+
+M_string::const_iterator Bag::checkField(M_string const& fields, string const& field, unsigned int min_len, unsigned int max_len, bool required) const {
+    M_string::const_iterator fitr = fields.find(field);
+    if (fitr == fields.end()) {
+        if (required)
+            throw BagFormatException("Required '" + field + "' field missing");
+    }
+    else if ((fitr->second.size() < min_len) || (fitr->second.size() > max_len))
+        throw BagFormatException((format("Field '%1%' is wrong size (%2% bytes)") % field % (uint32_t) fitr->second.size()).str());
+
+    return fitr;
+}
+
+bool Bag::readField(M_string const& fields, string const& field_name, bool required, string& data) const {
+    return readField(fields, field_name, 1, UINT_MAX, required, data);
+}
+
+bool Bag::readField(M_string const& fields, string const& field_name, unsigned int min_len, unsigned int max_len, bool required, string& data) const {
+    M_string::const_iterator fitr = checkField(fields, field_name, min_len, max_len, required);
+    if (fitr == fields.end())
+        return false;
+
+    data = fitr->second;
+    return true;
+}
+
+bool Bag::readField(M_string const& fields, string const& field_name, bool required, Time& data) const {
+    uint64_t packed_time;
+    if (!readField(fields, field_name, required, &packed_time))
+        return false;
+
+    uint64_t bitmask = (1LL << 33) - 1;
+    data.sec  = (uint32_t) (packed_time & bitmask);
+    data.nsec = (uint32_t) (packed_time >> 32);
+
+    return true;
+}
+
+std::string Bag::toHeaderString(Time const* field) const {
+    uint64_t packed_time = (((uint64_t) field->nsec) << 32) + field->sec;
+    return toHeaderString(&packed_time);
+}
+
+
+// Low-level I/O
+
+void Bag::write(string const& s)                  { write(s.c_str(), s.length()); }
+void Bag::write(char const* s, std::streamsize n) { file_.write((char*) s, n);    }
+
+void Bag::read(char* b, std::streamsize n) const  { file_.read(b, n);             }
+void Bag::seek(uint64_t pos, int origin) const    { file_.seek(pos, origin);      }
+
+} // namespace rosbag
diff --git a/realsense-file/src/storage/realsense_file/rosbag/rosbag_storage/src/bag_player.cpp b/realsense-file/src/storage/realsense_file/rosbag/rosbag_storage/src/bag_player.cpp
new file mode 100644
index 0000000000..ae87e6a8e4
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/rosbag/rosbag_storage/src/bag_player.cpp
@@ -0,0 +1,71 @@
+#include "rosbag/bag_player.h"
+
+#define foreach BOOST_FOREACH
+
+namespace rosbag
+{
+
+BagPlayer::BagPlayer(const std::string &fname) throw(BagException) {
+    bag.open(fname, rosbag::bagmode::Read);
+    ros::Time::init();
+    View v(bag);
+    bag_start_ = v.getBeginTime();
+    bag_end_ = v.getEndTime();
+    last_message_time_ = ros::Time(0);
+    playback_speed_ = 1.0;
+}
+
+BagPlayer::~BagPlayer() {
+    bag.close();
+}
+
+ros::Time BagPlayer::get_time() {
+    return last_message_time_;
+}
+
+void BagPlayer::set_start(const ros::Time &start) {
+    bag_start_ = start;
+}
+
+void BagPlayer::set_end(const ros::Time &end) {
+    bag_end_ = end;
+}
+
+void BagPlayer::set_playback_speed(double scale) {
+  if (scale > 0.0)
+    playback_speed_ = scale;
+}
+
+ros::Time BagPlayer::real_time(const ros::Time &msg_time) {
+  return play_start_ + (msg_time - bag_start_) * (1 / playback_speed_);
+}
+
+void BagPlayer::start_play() {
+
+    std::vector topics;
+    std::pair cb;
+    foreach(cb, cbs_)
+        topics.push_back(cb.first);
+
+    View view(bag, TopicQuery(topics), bag_start_, bag_end_);
+    play_start_ = ros::Time::now();
+
+    foreach(MessageInstance const m, view)
+    {
+        if (cbs_.find(m.getTopic()) == cbs_.end())
+            continue;
+
+        ros::Time::sleepUntil(real_time(m.getTime()));
+
+        last_message_time_ = m.getTime(); /* this is the recorded time */
+        cbs_[m.getTopic()]->call(m);
+    }
+}
+
+void BagPlayer::unregister_callback(const std::string &topic) {
+    delete cbs_[topic];
+    cbs_.erase(topic);
+}
+
+}
+
diff --git a/realsense-file/src/storage/realsense_file/rosbag/rosbag_storage/src/buffer.cpp b/realsense-file/src/storage/realsense_file/rosbag/rosbag_storage/src/buffer.cpp
new file mode 100644
index 0000000000..b3d217a8fc
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/rosbag/rosbag_storage/src/buffer.cpp
@@ -0,0 +1,74 @@
+/*********************************************************************
+* Software License Agreement (BSD License)
+*
+*  Copyright (c) 2008, Willow Garage, Inc.
+*  All rights reserved.
+*
+*  Redistribution and use in source and binary forms, with or without
+*  modification, are permitted provided that the following conditions
+*  are met:
+*
+*   * Redistributions of source code must retain the above copyright
+*     notice, this list of conditions and the following disclaimer.
+*   * Redistributions in binary form must reproduce the above
+*     copyright notice, this list of conditions and the following
+*     disclaimer in the documentation and/or other materials provided
+*     with the distribution.
+*   * Neither the name of Willow Garage, Inc. nor the names of its
+*     contributors may be used to endorse or promote products derived
+*     from this software without specific prior written permission.
+*
+*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+*  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+*  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+*  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+*  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+*  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+*  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+*  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+*  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+*  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+*  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+*  POSSIBILITY OF SUCH DAMAGE.
+********************************************************************/
+
+#include 
+#include 
+
+#include "rosbag/buffer.h"
+
+//#include 
+
+namespace rosbag {
+
+Buffer::Buffer() : buffer_(NULL), capacity_(0), size_(0) { }
+
+Buffer::~Buffer() {
+    free(buffer_);
+}
+
+uint8_t* Buffer::getData()           { return buffer_;   }
+uint32_t Buffer::getCapacity() const { return capacity_; }
+uint32_t Buffer::getSize()     const { return size_;     }
+
+void Buffer::setSize(uint32_t size) {
+    size_ = size;
+    ensureCapacity(size);
+}
+
+void Buffer::ensureCapacity(uint32_t capacity) {
+    if (capacity <= capacity_)
+        return;
+
+    if (capacity_ == 0)
+        capacity_ = capacity;
+    else {
+        while (capacity_ < capacity)
+            capacity_ *= 2;
+    }
+
+    buffer_ = (uint8_t*) realloc(buffer_, capacity_);
+    assert(buffer_);
+}
+
+} // namespace rosbag
diff --git a/realsense-file/src/storage/realsense_file/rosbag/rosbag_storage/src/chunked_file.cpp b/realsense-file/src/storage/realsense_file/rosbag/rosbag_storage/src/chunked_file.cpp
new file mode 100644
index 0000000000..c7a6d5d5af
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/rosbag/rosbag_storage/src/chunked_file.cpp
@@ -0,0 +1,226 @@
+/*********************************************************************
+* Software License Agreement (BSD License)
+*
+*  Copyright (c) 2008, Willow Garage, Inc.
+*  All rights reserved.
+*
+*  Redistribution and use in source and binary forms, with or without
+*  modification, are permitted provided that the following conditions
+*  are met:
+*
+*   * Redistributions of source code must retain the above copyright
+*     notice, this list of conditions and the following disclaimer.
+*   * Redistributions in binary form must reproduce the above
+*     copyright notice, this list of conditions and the following
+*     disclaimer in the documentation and/or other materials provided
+*     with the distribution.
+*   * Neither the name of Willow Garage, Inc. nor the names of its
+*     contributors may be used to endorse or promote products derived
+*     from this software without specific prior written permission.
+*
+*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+*  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+*  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+*  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+*  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+*  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+*  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+*  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+*  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+*  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+*  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+*  POSSIBILITY OF SUCH DAMAGE.
+********************************************************************/
+
+#include "rosbag/chunked_file.h"
+
+#include 
+
+#include 
+#include 
+
+//#include 
+#ifdef _WIN32
+#    ifdef __MINGW32__
+#      define fseeko fseeko64
+#      define ftello ftello64
+//     not sure if we need a ftruncate here yet or not
+#    else
+#        include 
+#        define fseeko _fseeki64
+#        define ftello _ftelli64
+#        define fileno _fileno
+#        define ftruncate _chsize
+#    endif
+#endif
+
+using std::string;
+using boost::format;
+using boost::shared_ptr;
+using ros::Exception;
+
+namespace rosbag {
+
+ChunkedFile::ChunkedFile() :
+    file_(NULL),
+    offset_(0),
+    compressed_in_(0),
+    unused_(NULL),
+    nUnused_(0)
+{
+    stream_factory_ = boost::make_shared(this);
+}
+
+ChunkedFile::~ChunkedFile() {
+    close();
+}
+
+void ChunkedFile::openReadWrite(string const& filename) { open(filename, "r+b"); }
+void ChunkedFile::openWrite    (string const& filename) { open(filename, "w+b");  }
+void ChunkedFile::openRead     (string const& filename) { open(filename, "rb");  }
+
+void ChunkedFile::open(string const& filename, string const& mode) {
+    // Check if file is already open
+    if (file_)
+        throw BagIOException((format("File already open: %1%") % filename_.c_str()).str());
+
+    // Open the file
+    if (mode == "r+b") {
+        // check if file already exists
+        #if defined(_MSC_VER) && (_MSC_VER >= 1400 )
+            fopen_s( &file_, filename.c_str(), "r" );
+        #else
+            file_ = fopen(filename.c_str(), "r");
+        #endif
+        if (file_ == NULL)
+            // create an empty file and open it for update
+            #if defined(_MSC_VER) && (_MSC_VER >= 1400 )
+                fopen_s( &file_, filename.c_str(), "w+b" );
+            #else
+                file_ = fopen(filename.c_str(), "w+b");
+            #endif
+        else {
+            fclose(file_);
+            // open existing file for update
+            #if defined(_MSC_VER) && (_MSC_VER >= 1400 )
+                fopen_s( &file_, filename.c_str(), "r+b" );
+            #else
+                file_ = fopen(filename.c_str(), "r+b");
+            #endif
+        }
+    }
+    else
+        #if defined(_MSC_VER) && (_MSC_VER >= 1400 )
+            fopen_s( &file_, filename.c_str(), mode.c_str() );
+        #else
+            file_ = fopen(filename.c_str(), mode.c_str());
+        #endif
+
+    if (!file_)
+        throw BagIOException((format("Error opening file: %1%") % filename.c_str()).str());
+
+    read_stream_  = boost::make_shared(this);
+    write_stream_ = boost::make_shared(this);
+    filename_     = filename;
+    offset_       = ftello(file_);
+}
+
+bool ChunkedFile::good() const {
+    return feof(file_) == 0 && ferror(file_) == 0;
+}
+
+bool   ChunkedFile::isOpen()      const { return file_ != NULL; }
+string ChunkedFile::getFileName() const { return filename_;     }
+
+void ChunkedFile::close() {
+    if (!file_)
+        return;
+
+    // Close any compressed stream by changing to uncompressed mode
+    setWriteMode(compression::Uncompressed);
+
+    // Close the file
+    int success = fclose(file_);
+    if (success != 0)
+        throw BagIOException((format("Error closing file: %1%") % filename_.c_str()).str());
+
+    file_ = NULL;
+    filename_.clear();
+    
+    clearUnused();
+}
+
+// Read/write modes
+
+void ChunkedFile::setWriteMode(CompressionType type) {
+    if (!file_)
+        throw BagIOException("Can't set compression mode before opening a file");
+
+    if (type != write_stream_->getCompressionType()) {
+        write_stream_->stopWrite();
+        shared_ptr stream = stream_factory_->getStream(type);
+        stream->startWrite();
+        write_stream_ = stream;
+    }
+}
+
+void ChunkedFile::setReadMode(CompressionType type) {
+    if (!file_)
+        throw BagIOException("Can't set compression mode before opening a file");
+
+    if (type != read_stream_->getCompressionType()) {
+        read_stream_->stopRead();
+        shared_ptr stream = stream_factory_->getStream(type);
+        stream->startRead();
+        read_stream_ = stream;
+    }
+}
+
+void ChunkedFile::seek(uint64_t offset, int origin) {
+    if (!file_)
+        throw BagIOException("Can't seek - file not open");
+
+    setReadMode(compression::Uncompressed);
+
+    int success = fseeko(file_, offset, origin);
+    if (success != 0)
+        throw BagIOException("Error seeking");
+
+    offset_ = ftello(file_);
+}
+
+uint64_t ChunkedFile::getOffset()            const { return offset_;        }
+uint32_t ChunkedFile::getCompressedBytesIn() const { return static_cast(compressed_in_); }
+
+void ChunkedFile::write(string const& s)        { write((void*) s.c_str(), s.size()); }
+void ChunkedFile::write(void* ptr, size_t size) { write_stream_->write(ptr, size);    }
+void ChunkedFile::read(void* ptr, size_t size)  { read_stream_->read(ptr, size);      }
+
+bool ChunkedFile::truncate(uint64_t length) {
+    int fd = fileno(file_);
+    return ftruncate(fd, length) == 0;
+}
+
+//! \todo add error handling
+string ChunkedFile::getline() {
+    char buffer[1024];
+    if(fgets(buffer, 1024, file_))
+    {
+      string s(buffer);
+      offset_ += s.size();
+      return s;
+    }
+    else
+      return string("");
+}
+
+void ChunkedFile::decompress(CompressionType compression, uint8_t* dest, unsigned int dest_len, uint8_t* source, unsigned int source_len) {
+    stream_factory_->getStream(compression)->decompress(dest, dest_len, source, source_len);
+}
+
+void ChunkedFile::clearUnused() {
+    unused_ = NULL;
+    nUnused_ = 0;
+}
+
+} // namespace rosbag
diff --git a/realsense-file/src/storage/realsense_file/rosbag/rosbag_storage/src/lz4_stream.cpp b/realsense-file/src/storage/realsense_file/rosbag/rosbag_storage/src/lz4_stream.cpp
new file mode 100644
index 0000000000..ef7c2d0b73
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/rosbag/rosbag_storage/src/lz4_stream.cpp
@@ -0,0 +1,204 @@
+/*********************************************************************
+* Software License Agreement (BSD License)
+*
+*  Copyright (c) 2014, Ben Charrow
+*  All rights reserved.
+*
+*  Redistribution and use in source and binary forms, with or without
+*  modification, are permitted provided that the following conditions
+*  are met:
+*
+*   * Redistributions of source code must retain the above copyright
+*     notice, this list of conditions and the following disclaimer.
+*   * Redistributions in binary form must reproduce the above
+*     copyright notice, this list of conditions and the following
+*     disclaimer in the documentation and/or other materials provided
+*     with the distribution.
+*   * Neither the name of Willow Garage, Inc. nor the names of its
+*     contributors may be used to endorse or promote products derived
+*     from this software without specific prior written permission.
+*
+*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+*  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+*  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+*  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+*  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+*  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+*  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+*  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+*  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+*  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+*  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+*  POSSIBILITY OF SUCH DAMAGE.
+********************************************************************/
+
+#include "rosbag/chunked_file.h"
+
+#include 
+#include 
+#include "console_bridge/console.h"
+
+using std::string;
+
+namespace rosbag {
+
+LZ4Stream::LZ4Stream(ChunkedFile* file)
+    : Stream(file), block_size_id_(6) {
+    buff_size_ = roslz4_blockSizeFromIndex(block_size_id_) + 64;
+    buff_ = new char[buff_size_];
+}
+
+LZ4Stream::~LZ4Stream() {
+    delete[] buff_;
+}
+
+CompressionType LZ4Stream::getCompressionType() const {
+    return compression::LZ4;
+}
+
+void LZ4Stream::startWrite() {
+    setCompressedIn(0);
+
+    int ret = roslz4_compressStart(&lz4s_, block_size_id_);
+    switch(ret) {
+    case ROSLZ4_OK: break;
+    case ROSLZ4_MEMORY_ERROR: throw BagIOException("ROSLZ4_MEMORY_ERROR: insufficient memory available"); break;
+    case ROSLZ4_PARAM_ERROR: throw BagIOException("ROSLZ4_PARAM_ERROR: bad block size"); break;
+    default: throw BagException("Unhandled return code");
+    }
+    lz4s_.output_next = buff_;
+    lz4s_.output_left = buff_size_;
+}
+
+void LZ4Stream::write(void* ptr, size_t size) {
+    lz4s_.input_left = static_cast(size);
+    lz4s_.input_next = (char*) ptr;
+
+    writeStream(ROSLZ4_RUN);
+    setCompressedIn(getCompressedIn() + size);
+}
+
+void LZ4Stream::writeStream(int action) {
+    int ret = ROSLZ4_OK;
+    while (lz4s_.input_left > 0 ||
+           (action == ROSLZ4_FINISH && ret != ROSLZ4_STREAM_END)) {
+        ret = roslz4_compress(&lz4s_, action);
+        switch(ret) {
+        case ROSLZ4_OK: break;
+        case ROSLZ4_OUTPUT_SMALL:
+            if (lz4s_.output_next - buff_ == buff_size_) {
+                throw BagIOException("ROSLZ4_OUTPUT_SMALL: output buffer is too small");
+            } else {
+                // There's data to be written in buff_; this will free up space
+                break;
+            }
+        case ROSLZ4_STREAM_END: break;
+        case ROSLZ4_PARAM_ERROR: throw BagIOException("ROSLZ4_PARAM_ERROR: bad block size"); break;
+        case ROSLZ4_ERROR: throw BagIOException("ROSLZ4_ERROR: compression error"); break;
+        default: throw BagException("Unhandled return code");
+        }
+
+        // If output data is ready, write to disk
+        int to_write = static_cast(lz4s_.output_next - buff_);
+        if (to_write > 0) {
+            if (fwrite(buff_, 1, to_write, getFilePointer()) != static_cast(to_write)) {
+                throw BagException("Problem writing data to disk");
+            }
+            advanceOffset(to_write);
+            lz4s_.output_next = buff_;
+            lz4s_.output_left = buff_size_;
+        }
+    }
+}
+
+void LZ4Stream::stopWrite() {
+    writeStream(ROSLZ4_FINISH);
+    setCompressedIn(0);
+    roslz4_compressEnd(&lz4s_);
+}
+
+void LZ4Stream::startRead() {
+    int ret = static_cast(roslz4_decompressStart(&lz4s_));
+    switch(ret) {
+    case ROSLZ4_OK: break;
+    case ROSLZ4_MEMORY_ERROR: throw BagException("ROSLZ4_MEMORY_ERROR: insufficient memory available"); break;
+    default: throw BagException("Unhandled return code");
+    }
+
+    if (getUnusedLength() > buff_size_) {
+        throw BagException("Too many unused bytes to decompress");
+    }
+
+    // getUnused() could be pointing to part of buff_, so don't use memcpy
+    memmove(buff_, getUnused(), getUnusedLength());
+    lz4s_.input_next = buff_;
+    lz4s_.input_left = getUnusedLength();
+    clearUnused();
+}
+
+void LZ4Stream::read(void* ptr, size_t size) {
+    // Setup stream by filling buffer with data from file
+    int to_read = buff_size_ - lz4s_.input_left;
+    char *input_start = buff_ + lz4s_.input_left;
+    int nread = static_cast(fread(input_start, 1, to_read, getFilePointer()));
+    if (ferror(getFilePointer())) {
+        throw BagIOException("Problem reading from file");
+    }
+    lz4s_.input_next = buff_;
+    lz4s_.input_left += nread;
+    lz4s_.output_next = (char*) ptr;
+    lz4s_.output_left = static_cast(size);
+
+    // Decompress.  If reach end of stream, store unused data
+    int ret = roslz4_decompress(&lz4s_);
+    switch (ret) {
+    case ROSLZ4_OK: break;
+    case ROSLZ4_STREAM_END:
+        if (getUnused() || getUnusedLength() > 0)
+            logError("unused data already available");
+        else {
+            setUnused(lz4s_.input_next);
+            setUnusedLength(lz4s_.input_left);
+        }
+        return;
+    case ROSLZ4_ERROR: throw BagException("ROSLZ4_ERROR: decompression error"); break;
+    case ROSLZ4_MEMORY_ERROR: throw BagException("ROSLZ4_MEMORY_ERROR: insufficient memory available"); break;
+    case ROSLZ4_OUTPUT_SMALL: throw BagException("ROSLZ4_OUTPUT_SMALL: output buffer is too small"); break;
+    case ROSLZ4_DATA_ERROR: throw BagException("ROSLZ4_DATA_ERROR: malformed data to decompress"); break;
+    default: throw BagException("Unhandled return code");
+    }
+    if (feof(getFilePointer())) {
+        throw BagIOException("Reached end of file before reaching end of stream");
+    }
+
+    size_t total_out = lz4s_.output_next - (char*)ptr;
+    advanceOffset(total_out);
+
+    // Shift input buffer if there's unconsumed data
+    if (lz4s_.input_left > 0) {
+        memmove(buff_, lz4s_.input_next, lz4s_.input_left);
+    }
+}
+
+void LZ4Stream::stopRead() {
+    roslz4_decompressEnd(&lz4s_);
+}
+
+void LZ4Stream::decompress(uint8_t* dest, unsigned int dest_len, uint8_t* source, unsigned int source_len) {
+    unsigned int actual_dest_len = dest_len;
+    int ret = roslz4_buffToBuffDecompress((char*)source, source_len,
+                                          (char*)dest, &actual_dest_len);
+    switch(ret) {
+    case ROSLZ4_OK: break;
+    case ROSLZ4_ERROR: throw BagException("ROSLZ4_ERROR: decompression error"); break;
+    case ROSLZ4_MEMORY_ERROR: throw BagException("ROSLZ4_MEMORY_ERROR: insufficient memory available"); break;
+    case ROSLZ4_OUTPUT_SMALL: throw BagException("ROSLZ4_OUTPUT_SMALL: output buffer is too small"); break;
+    case ROSLZ4_DATA_ERROR: throw BagException("ROSLZ4_DATA_ERROR: malformed data to decompress"); break;
+    default: throw BagException("Unhandled return code");
+    }
+    if (actual_dest_len != dest_len) {
+        throw BagException("Decompression size mismatch in LZ4 chunk");
+    }
+}
+
+} // namespace rosbag
diff --git a/realsense-file/src/storage/realsense_file/rosbag/rosbag_storage/src/message_instance.cpp b/realsense-file/src/storage/realsense_file/rosbag/rosbag_storage/src/message_instance.cpp
new file mode 100644
index 0000000000..58702f9296
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/rosbag/rosbag_storage/src/message_instance.cpp
@@ -0,0 +1,65 @@
+// Copyright (c) 2009, Willow Garage, Inc.
+// All rights reserved.
+// 
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+// 
+//     * Redistributions of source code must retain the above copyright
+//       notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above copyright
+//       notice, this list of conditions and the following disclaimer in the
+//       documentation and/or other materials provided with the distribution.
+//     * Neither the name of Willow Garage, Inc. nor the names of its
+//       contributors may be used to endorse or promote products derived from
+//       this software without specific prior written permission.
+// 
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+
+#include "rosbag/message_instance.h"
+
+#include "ros/message_event.h"
+
+using std::string;
+using ros::Time;
+using boost::shared_ptr;
+
+namespace rosbag {
+
+MessageInstance::MessageInstance(ConnectionInfo const* connection_info, IndexEntry const& index_entry, Bag const& bag) :
+	connection_info_(connection_info), index_entry_(index_entry), bag_(&bag)
+{
+}
+
+Time const&   MessageInstance::getTime()              const { return index_entry_.time;          }
+string const& MessageInstance::getTopic()             const { return connection_info_->topic;    }
+string const& MessageInstance::getDataType()          const { return connection_info_->datatype; }
+string const& MessageInstance::getMD5Sum()            const { return connection_info_->md5sum;   }
+string const& MessageInstance::getMessageDefinition() const { return connection_info_->msg_def;  }
+
+shared_ptr MessageInstance::getConnectionHeader() const { return connection_info_->header; }
+
+string MessageInstance::getCallerId() const {
+    ros::M_string::const_iterator header_iter = connection_info_->header->find("callerid");
+    return header_iter != connection_info_->header->end() ? header_iter->second : string("");
+}
+
+bool MessageInstance::isLatching() const {
+    ros::M_string::const_iterator header_iter = connection_info_->header->find("latching");
+    return header_iter != connection_info_->header->end() && header_iter->second == "1";
+}
+
+uint32_t MessageInstance::size() const {
+    return bag_->readMessageDataSize(index_entry_);
+}
+
+} // namespace rosbag
diff --git a/realsense-file/src/storage/realsense_file/rosbag/rosbag_storage/src/query.cpp b/realsense-file/src/storage/realsense_file/rosbag/rosbag_storage/src/query.cpp
new file mode 100644
index 0000000000..6cd037d843
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/rosbag/rosbag_storage/src/query.cpp
@@ -0,0 +1,114 @@
+// Copyright (c) 2009, Willow Garage, Inc.
+// All rights reserved.
+// 
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+// 
+//     * Redistributions of source code must retain the above copyright
+//       notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above copyright
+//       notice, this list of conditions and the following disclaimer in the
+//       documentation and/or other materials provided with the distribution.
+//     * Neither the name of Willow Garage, Inc. nor the names of its
+//       contributors may be used to endorse or promote products derived from
+//       this software without specific prior written permission.
+// 
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+
+#include "rosbag/query.h"
+#include "rosbag/bag.h"
+
+#include 
+
+#define foreach BOOST_FOREACH
+
+using std::map;
+using std::string;
+using std::vector;
+using std::multiset;
+
+namespace rosbag {
+
+// Query
+
+Query::Query(boost::function& query, ros::Time const& start_time, ros::Time const& end_time)
+	: query_(query), start_time_(start_time), end_time_(end_time)
+{
+}
+
+boost::function const& Query::getQuery() const {
+	return query_;
+}
+
+ros::Time const& Query::getStartTime() const { return start_time_; }
+ros::Time const& Query::getEndTime()   const { return end_time_;   }
+
+// TopicQuery
+
+TopicQuery::TopicQuery(std::string const& topic) {
+    topics_.push_back(topic);
+}
+
+TopicQuery::TopicQuery(std::vector const& topics) : topics_(topics) { }
+
+bool TopicQuery::operator()(ConnectionInfo const* info) const {
+    foreach(string const& topic, topics_)
+        if (topic == info->topic)
+            return true;
+
+    return false;
+}
+
+// TypeQuery
+
+TypeQuery::TypeQuery(std::string const& type) {
+    types_.push_back(type);
+}
+
+TypeQuery::TypeQuery(std::vector const& types) : types_(types) { }
+
+bool TypeQuery::operator()(ConnectionInfo const* info) const {
+    foreach(string const& type, types_)
+        if (type == info->datatype)
+            return true;
+
+    return false;
+}
+
+// BagQuery
+
+BagQuery::BagQuery(Bag const* _bag, Query const& _query, uint32_t _bag_revision) : bag(_bag), query(_query), bag_revision(_bag_revision) {
+}
+
+// MessageRange
+
+MessageRange::MessageRange(std::multiset::const_iterator const& _begin,
+                           std::multiset::const_iterator const& _end,
+                           ConnectionInfo const* _connection_info,
+                           BagQuery const* _bag_query)
+	: begin(_begin), end(_end), connection_info(_connection_info), bag_query(_bag_query)
+{
+}
+
+// ViewIterHelper
+
+ViewIterHelper::ViewIterHelper(std::multiset::const_iterator _iter, MessageRange const* _range)
+	: iter(_iter), range(_range)
+{
+}
+
+bool ViewIterHelperCompare::operator()(ViewIterHelper const& a, ViewIterHelper const& b) {
+	return (a.iter)->time > (b.iter)->time;
+}
+
+} // namespace rosbag
diff --git a/realsense-file/src/storage/realsense_file/rosbag/rosbag_storage/src/stream.cpp b/realsense-file/src/storage/realsense_file/rosbag/rosbag_storage/src/stream.cpp
new file mode 100644
index 0000000000..df0a3346d4
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/rosbag/rosbag_storage/src/stream.cpp
@@ -0,0 +1,81 @@
+/*********************************************************************
+* Software License Agreement (BSD License)
+*
+*  Copyright (c) 2008, Willow Garage, Inc.
+*  All rights reserved.
+*
+*  Redistribution and use in source and binary forms, with or without
+*  modification, are permitted provided that the following conditions
+*  are met:
+*
+*   * Redistributions of source code must retain the above copyright
+*     notice, this list of conditions and the following disclaimer.
+*   * Redistributions in binary form must reproduce the above
+*     copyright notice, this list of conditions and the following
+*     disclaimer in the documentation and/or other materials provided
+*     with the distribution.
+*   * Neither the name of Willow Garage, Inc. nor the names of its
+*     contributors may be used to endorse or promote products derived
+*     from this software without specific prior written permission.
+*
+*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+*  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+*  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+*  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+*  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+*  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+*  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+*  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+*  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+*  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+*  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+*  POSSIBILITY OF SUCH DAMAGE.
+********************************************************************/
+
+#include "rosbag/stream.h"
+#include "rosbag/chunked_file.h"
+
+//#include 
+
+using boost::shared_ptr;
+
+namespace rosbag {
+
+// StreamFactory
+
+StreamFactory::StreamFactory(ChunkedFile* file) :
+    uncompressed_stream_(new UncompressedStream(file)),
+    lz4_stream_         (new LZ4Stream(file))
+{
+}
+
+shared_ptr StreamFactory::getStream(CompressionType type) const {
+    switch (type) {
+        case compression::Uncompressed: return uncompressed_stream_;
+        case compression::LZ4:          return lz4_stream_;
+        default:                        return shared_ptr();
+    }
+}
+
+// Stream
+
+Stream::Stream(ChunkedFile* file) : file_(file) { }
+
+Stream::~Stream() { }
+
+void Stream::startWrite() { }
+void Stream::stopWrite()  { }
+void Stream::startRead()  { }
+void Stream::stopRead()   { }
+
+FILE*    Stream::getFilePointer()                 { return file_->file_;            }
+uint64_t Stream::getCompressedIn()                { return file_->compressed_in_;   }
+void     Stream::setCompressedIn(uint64_t nbytes) { file_->compressed_in_ = nbytes; }
+void     Stream::advanceOffset(uint64_t nbytes)   { file_->offset_ += nbytes;       }
+char*    Stream::getUnused()                      { return file_->unused_;          }
+int      Stream::getUnusedLength()                { return file_->nUnused_;         }
+void     Stream::setUnused(char* unused)          { file_->unused_ = unused;        }
+void     Stream::setUnusedLength(int nUnused)     { file_->nUnused_ = nUnused;      }
+void     Stream::clearUnused()                    { file_->clearUnused();           }
+
+} // namespace rosbag
diff --git a/realsense-file/src/storage/realsense_file/rosbag/rosbag_storage/src/uncompressed_stream.cpp b/realsense-file/src/storage/realsense_file/rosbag/rosbag_storage/src/uncompressed_stream.cpp
new file mode 100644
index 0000000000..013ff63a1e
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/rosbag/rosbag_storage/src/uncompressed_stream.cpp
@@ -0,0 +1,114 @@
+/*********************************************************************
+* Software License Agreement (BSD License)
+*
+*  Copyright (c) 2008, Willow Garage, Inc.
+*  All rights reserved.
+*
+*  Redistribution and use in source and binary forms, with or without
+*  modification, are permitted provided that the following conditions
+*  are met:
+*
+*   * Redistributions of source code must retain the above copyright
+*     notice, this list of conditions and the following disclaimer.
+*   * Redistributions in binary form must reproduce the above
+*     copyright notice, this list of conditions and the following
+*     disclaimer in the documentation and/or other materials provided
+*     with the distribution.
+*   * Neither the name of Willow Garage, Inc. nor the names of its
+*     contributors may be used to endorse or promote products derived
+*     from this software without specific prior written permission.
+*
+*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+*  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+*  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+*  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+*  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+*  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+*  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+*  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+*  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+*  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+*  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+*  POSSIBILITY OF SUCH DAMAGE.
+********************************************************************/
+
+#include "rosbag/chunked_file.h"
+
+#include 
+#include 
+
+#include 
+
+using std::string;
+using boost::format;
+using ros::Exception;
+
+namespace rosbag {
+
+UncompressedStream::UncompressedStream(ChunkedFile* file) : Stream(file) { }
+
+CompressionType UncompressedStream::getCompressionType() const {
+    return compression::Uncompressed;
+}
+
+void UncompressedStream::write(void* ptr, size_t size) {
+    size_t result = fwrite(ptr, 1, size, getFilePointer());
+    if (result != size)
+        throw BagIOException((format("Error writing to file: writing %1% bytes, wrote %2% bytes") % size % result).str());
+
+    advanceOffset(size);
+}
+
+void UncompressedStream::read(void* ptr, size_t size) {
+    size_t nUnused = (size_t) getUnusedLength();
+    char* unused = getUnused();
+
+    if (nUnused > 0) {
+        // We have unused data from the last compressed read
+        if (nUnused == size) {
+            // Copy the unused data into the buffer
+            memcpy(ptr, unused, nUnused);
+
+            clearUnused();
+        }
+        else if (nUnused < size) {
+            // Copy the unused data into the buffer
+            memcpy(ptr, unused, nUnused);
+
+            // Still have data to read
+            size -= nUnused;
+
+            // Read the remaining data from the file
+            int result = static_cast(fread((char*) ptr + static_cast(nUnused), 1, static_cast(size), getFilePointer()));
+            if ((size_t) result != size)
+                throw BagIOException((format("Error reading from file + unused: wanted %1% bytes, read %2% bytes") % size % result).str());
+
+            advanceOffset(size);
+
+            clearUnused();
+        }
+        else {
+            // nUnused_ > size
+            memcpy(ptr, unused, size);
+
+            setUnused(unused + size);
+            setUnusedLength(static_cast(nUnused - size));
+        }
+    }
+    
+    // No unused data - read from stream
+    int result = static_cast(fread( ptr, 1, static_cast(size), getFilePointer()));
+    if ((size_t) result != size)
+        throw BagIOException((format("Error reading from file: wanted %1% bytes, read %2% bytes") % size % result).str());
+
+    advanceOffset(size);
+}
+
+void UncompressedStream::decompress(uint8_t* dest, unsigned int dest_len, uint8_t* source, unsigned int source_len) {
+    if (dest_len < source_len)
+        throw BagException("dest_len not large enough");
+
+    memcpy(dest, source, source_len);
+}
+
+} // namespace rosbag
diff --git a/realsense-file/src/storage/realsense_file/rosbag/rosbag_storage/src/view.cpp b/realsense-file/src/storage/realsense_file/rosbag/rosbag_storage/src/view.cpp
new file mode 100644
index 0000000000..fc969e383e
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/rosbag/rosbag_storage/src/view.cpp
@@ -0,0 +1,352 @@
+// Copyright (c) 2009, Willow Garage, Inc.
+// All rights reserved.
+// 
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+// 
+//     * Redistributions of source code must retain the above copyright
+//       notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above copyright
+//       notice, this list of conditions and the following disclaimer in the
+//       documentation and/or other materials provided with the distribution.
+//     * Neither the name of Willow Garage, Inc. nor the names of its
+//       contributors may be used to endorse or promote products derived from
+//       this software without specific prior written permission.
+// 
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+
+#include "rosbag/view.h"
+#include "rosbag/bag.h"
+#include "rosbag/message_instance.h"
+
+#include 
+#include 
+#include 
+
+#define foreach BOOST_FOREACH
+
+using std::map;
+using std::string;
+using std::vector;
+using std::multiset;
+
+namespace rosbag {
+
+// View::iterator
+
+View::iterator::iterator() : view_(NULL), view_revision_(0), message_instance_(NULL) { }
+
+View::iterator::~iterator()
+{
+  if (message_instance_ != NULL)
+    delete message_instance_;
+}
+
+View::iterator::iterator(View* view, bool end) : view_(view), view_revision_(0), message_instance_(NULL) {
+    if (view != NULL && !end)
+        populate();
+}
+
+View::iterator::iterator(const iterator& i) : view_(i.view_), iters_(i.iters_), view_revision_(i.view_revision_), message_instance_(NULL) { }
+
+View::iterator &View::iterator::operator=(iterator const& i) {
+    if (this != &i) {
+        view_ = i.view_;
+        iters_ = i.iters_;
+        view_revision_ = i.view_revision_;
+        if (message_instance_ != NULL) {
+            delete message_instance_;
+            message_instance_ = NULL;
+        }
+    }
+    return *this;
+}
+
+void View::iterator::populate() {
+    assert(view_ != NULL);
+
+    iters_.clear();
+    foreach(MessageRange const* range, view_->ranges_)
+        if (range->begin != range->end)
+            iters_.push_back(ViewIterHelper(range->begin, range));
+
+    std::sort(iters_.begin(), iters_.end(), ViewIterHelperCompare());
+    view_revision_ = view_->view_revision_;
+}
+
+void View::iterator::populateSeek(multiset::const_iterator iter) {
+    assert(view_ != NULL);
+
+    iters_.clear();
+    foreach(MessageRange const* range, view_->ranges_) {
+        multiset::const_iterator start = std::lower_bound(range->begin, range->end, iter->time, IndexEntryCompare());
+        if (start != range->end)
+            iters_.push_back(ViewIterHelper(start, range));
+    }
+
+    std::sort(iters_.begin(), iters_.end(), ViewIterHelperCompare());
+    while (iter != iters_.back().iter)
+        increment();
+
+    view_revision_ = view_->view_revision_;
+}
+
+bool View::iterator::equal(View::iterator const& other) const {
+    // We need some way of verifying these are actually talking about
+    // the same merge_queue data since we shouldn't be able to compare
+    // iterators from different Views.
+
+    if (iters_.empty())
+        return other.iters_.empty();
+    if (other.iters_.empty())
+        return false;
+
+    return iters_.back().iter == other.iters_.back().iter;
+}
+
+void View::iterator::increment() {
+    assert(view_ != NULL);
+
+    // Our message instance is no longer valid
+    if (message_instance_ != NULL)
+    {
+      delete message_instance_;
+      message_instance_ = NULL;
+    }
+
+    view_->update();
+
+    // Note, updating may have blown away our message-ranges and
+    // replaced them in general the ViewIterHelpers are no longer
+    // valid, but the iterator it stores should still be good.
+    if (view_revision_ != view_->view_revision_)
+        populateSeek(iters_.back().iter);
+
+    if (view_->reduce_overlap_)
+    {
+        std::multiset::const_iterator last_iter = iters_.back().iter;
+    
+        while (iters_.back().iter == last_iter)
+        {
+            iters_.back().iter++;
+            if (iters_.back().iter == iters_.back().range->end)
+                iters_.pop_back();
+      
+            std::sort(iters_.begin(), iters_.end(), ViewIterHelperCompare());
+        }
+
+    } else {
+
+        iters_.back().iter++;
+        if (iters_.back().iter == iters_.back().range->end)
+            iters_.pop_back();
+      
+        std::sort(iters_.begin(), iters_.end(), ViewIterHelperCompare());
+    }
+}
+
+MessageInstance& View::iterator::dereference() const {
+    ViewIterHelper const& i = iters_.back();
+
+    if (message_instance_ == NULL)
+      message_instance_ = view_->newMessageInstance(i.range->connection_info, *(i.iter), *(i.range->bag_query->bag));
+
+    return *message_instance_;
+}
+
+// View
+
+View::View(bool const& reduce_overlap) : view_revision_(0), size_cache_(0), size_revision_(0), reduce_overlap_(reduce_overlap) { }
+
+View::View(Bag const& bag, ros::Time const& start_time, ros::Time const& end_time, bool const& reduce_overlap) : view_revision_(0), size_cache_(0), size_revision_(0), reduce_overlap_(reduce_overlap) {
+	addQuery(bag, start_time, end_time);
+}
+
+View::View(Bag const& bag, boost::function query, ros::Time const& start_time, ros::Time const& end_time, bool const& reduce_overlap) : view_revision_(0), size_cache_(0), size_revision_(0), reduce_overlap_(reduce_overlap) {
+	addQuery(bag, query, start_time, end_time);
+}
+
+View::~View() {
+    foreach(MessageRange* range, ranges_)
+        delete range;
+    foreach(BagQuery* query, queries_)
+        delete query;
+}
+
+
+ros::Time View::getBeginTime()
+{
+  update();
+
+  ros::Time begin = ros::TIME_MAX;
+
+  foreach (rosbag::MessageRange* range, ranges_)
+  {
+    if (range->begin->time < begin)
+      begin = range->begin->time;
+  }
+
+  return begin;
+}
+
+ros::Time View::getEndTime()
+{
+  update();
+
+  ros::Time end = ros::TIME_MIN;
+
+  foreach (rosbag::MessageRange* range, ranges_)
+  {
+    std::multiset::const_iterator e = range->end;
+    e--;
+
+    if (e->time > end)
+      end = e->time;
+  }
+
+  return end;
+}
+
+//! Simply copy the merge_queue state into the iterator
+View::iterator View::begin() {
+    update();
+    return iterator(this);
+}
+
+//! Default constructed iterator signifies end
+View::iterator View::end() { return iterator(this, true); }
+
+uint32_t View::size() { 
+
+  update();
+
+  if (size_revision_ != view_revision_)
+  {
+    size_cache_ = 0;
+
+    foreach (MessageRange* range, ranges_)
+    {
+      size_cache_ += static_cast(std::distance(range->begin, range->end));
+    }
+
+    size_revision_ = view_revision_;
+  }
+
+  return size_cache_;
+}
+
+void View::addQuery(Bag const& bag, ros::Time const& start_time, ros::Time const& end_time) {
+    if ((bag.getMode() & bagmode::Read) != bagmode::Read)
+        throw BagException("Bag not opened for reading");
+
+	boost::function query = TrueQuery();
+
+    queries_.push_back(new BagQuery(&bag, Query(query, start_time, end_time), bag.bag_revision_));
+
+    updateQueries(queries_.back());
+}
+
+void View::addQuery(Bag const& bag, boost::function query, ros::Time const& start_time, ros::Time const& end_time) {
+    if ((bag.getMode() & bagmode::Read) != bagmode::Read)
+        throw BagException("Bag not opened for reading");
+
+    queries_.push_back(new BagQuery(&bag, Query(query, start_time, end_time), bag.bag_revision_));
+
+    updateQueries(queries_.back());
+}
+
+void View::updateQueries(BagQuery* q) {
+    for (map::const_iterator i = q->bag->connections_.begin(); i != q->bag->connections_.end(); i++) {
+        ConnectionInfo const* connection = i->second;
+
+        // Skip if the query doesn't evaluate to true
+        if (!q->query.getQuery()(connection))
+            continue;
+
+        map >::const_iterator j = q->bag->connection_indexes_.find(connection->id);
+
+        // Skip if the bag doesn't have the corresponding index
+        if (j == q->bag->connection_indexes_.end())
+            continue;
+        multiset const& index = j->second;
+
+        // lower_bound/upper_bound do a binary search to find the appropriate range of Index Entries given our time range
+
+        std::multiset::const_iterator begin = std::lower_bound(index.begin(), index.end(), q->query.getStartTime(), IndexEntryCompare());
+        std::multiset::const_iterator end   = std::upper_bound(index.begin(), index.end(), q->query.getEndTime(),   IndexEntryCompare());		
+
+        // Make sure we are at the right beginning
+        while (begin != index.begin())
+        {
+			if (begin != index.end() && begin->time >= q->query.getStartTime())
+				break;
+
+          begin--;
+          if (begin->time < q->query.getStartTime())
+          {
+            begin++;
+            break;
+          }
+        }
+
+        if (begin != end)
+        {
+            // todo: make faster with a map of maps
+            bool found = false;
+            for (vector::iterator k = ranges_.begin(); k != ranges_.end(); k++) {
+                MessageRange* r = *k;
+                
+                // If the topic and query are already in our ranges, we update
+                if (r->bag_query == q && r->connection_info->id == connection->id) {
+                    r->begin = begin;
+                    r->end   = end;
+                    found    = true;
+                    break;
+                }
+            }
+            if (!found)
+                ranges_.push_back(new MessageRange(begin, end, connection, q));
+        }
+    }
+
+    view_revision_++;
+}
+
+void View::update() {
+    foreach(BagQuery* query, queries_) {
+        if (query->bag->bag_revision_ != query->bag_revision) {
+            updateQueries(query);
+            query->bag_revision = query->bag->bag_revision_;
+        }
+    }
+}
+
+std::vector View::getConnections()
+{
+  std::vector connections;
+
+  foreach(MessageRange* range, ranges_)
+  {
+    connections.push_back(range->connection_info);
+  }
+
+  return connections;
+}
+
+MessageInstance* View::newMessageInstance(ConnectionInfo const* connection_info, IndexEntry const& index, Bag const& bag)
+{
+  return new MessageInstance(connection_info, index, bag);
+}
+
+
+} // namespace rosbag
diff --git a/realsense-file/src/storage/realsense_file/rosbag/roscpp_serialization/config.cmake b/realsense-file/src/storage/realsense_file/rosbag/roscpp_serialization/config.cmake
new file mode 100644
index 0000000000..d824b95700
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/rosbag/roscpp_serialization/config.cmake
@@ -0,0 +1,13 @@
+cmake_minimum_required(VERSION 2.8.3)
+
+set(HEADER_FILES_ROSCPP_SERIALIZATION
+  rosbag/roscpp_serialization/include/ros/roscpp_serialization_macros.h
+  rosbag/roscpp_serialization/include/ros/serialization.h
+  rosbag/roscpp_serialization/include/ros/serialized_message.h
+)
+
+set(SOURCE_FILES_ROSCPP_SERIALIZATION
+  rosbag/roscpp_serialization/src/serialization.cpp
+)
+
+
diff --git a/realsense-file/src/storage/realsense_file/rosbag/roscpp_serialization/include/ros/roscpp_serialization_macros.h b/realsense-file/src/storage/realsense_file/rosbag/roscpp_serialization/include/ros/roscpp_serialization_macros.h
new file mode 100644
index 0000000000..271bc241fb
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/rosbag/roscpp_serialization/include/ros/roscpp_serialization_macros.h
@@ -0,0 +1,55 @@
+/*********************************************************************
+*
+* Software License Agreement (BSD License)
+*
+*  Copyright (c) 2009, Willow Garage, Inc.
+*  All rights reserved.
+*
+*  Redistribution and use in source and binary forms, with or without
+*  modification, are permitted provided that the following conditions
+*  are met:
+*
+*   * Redistributions of source code must retain the above copyright
+*     notice, this list of conditions and the following disclaimer.
+*   * Redistributions in binary form must reproduce the above
+*     copyright notice, this list of conditions and the following
+*     disclaimer in the documentation and/or other materials provided
+*     with the distribution.
+*   * Neither the name of the Willow Garage nor the names of its
+*     contributors may be used to endorse or promote products derived
+*     from this software without specific prior written permission.
+*
+*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+*  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+*  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+*  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+*  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+*  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+*  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+*  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+*  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+*  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+*  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+*  POSSIBILITY OF SUCH DAMAGE.
+*
+*********************************************************************/
+/*
+ * Cross platform macros.
+ *
+ */
+#ifndef ROSCPP_SERIALIZATION_MACROS_HPP_
+#define ROSCPP_SERIALIZATION_MACROS_HPP_
+
+#include 
+
+#ifdef ROS_BUILD_SHARED_LIBS // ros is being built around shared libraries
+  #ifdef roscpp_serialization_EXPORTS // we are building a shared lib/dll
+    #define ROSCPP_SERIALIZATION_DECL ROS_HELPER_EXPORT
+  #else // we are using shared lib/dll
+    #define ROSCPP_SERIALIZATION_DECL ROS_HELPER_IMPORT
+  #endif
+#else // ros is being built around static libraries
+  #define ROSCPP_SERIALIZATION_DECL
+#endif
+
+#endif /* ROSCPP_SERIALIZATION_MACROS_HPP_ */
diff --git a/realsense-file/src/storage/realsense_file/rosbag/roscpp_serialization/include/ros/serialization.h b/realsense-file/src/storage/realsense_file/rosbag/roscpp_serialization/include/ros/serialization.h
new file mode 100644
index 0000000000..06b668ac24
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/rosbag/roscpp_serialization/include/ros/serialization.h
@@ -0,0 +1,927 @@
+/*
+ * Copyright (C) 2009, Willow Garage, Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *   * Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *   * Neither the names of Willow Garage, Inc. nor the names of its
+ *     contributors may be used to endorse or promote products derived from
+ *     this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef ROSCPP_SERIALIZATION_H
+#define ROSCPP_SERIALIZATION_H
+
+#include "roscpp_serialization_macros.h"
+
+#include 
+#include 
+
+#include "serialized_message.h"
+#include "ros/message_traits.h"
+#include "ros/builtin_message_traits.h"
+#include "ros/exception.h"
+#include "ros/datatypes.h"
+
+#include 
+#include 
+
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+
+#include 
+
+#define ROS_NEW_SERIALIZATION_API 1
+
+/**
+ * \brief Declare your serializer to use an allInOne member instead of requiring 3 different serialization
+ * functions.
+ *
+ * The allinone method has the form:
+\verbatim
+template
+inline static void allInOne(Stream& stream, T t)
+{
+  stream.next(t.a);
+  stream.next(t.b);
+  ...
+}
+\endverbatim
+ *
+ * The only guarantee given is that Stream::next(T) is defined.
+ */
+#define ROS_DECLARE_ALLINONE_SERIALIZER \
+  template \
+  inline static void write(Stream& stream, const T& t) \
+  { \
+    allInOne(stream, t); \
+  } \
+  \
+  template \
+  inline static void read(Stream& stream, T& t) \
+  { \
+    allInOne(stream, t); \
+  } \
+  \
+  template \
+  inline static uint32_t serializedLength(const T& t) \
+  { \
+    LStream stream; \
+    allInOne(stream, t); \
+    return stream.getLength(); \
+  }
+
+namespace ros
+{
+namespace serialization
+{
+namespace mt = message_traits;
+namespace mpl = boost::mpl;
+
+class ROSCPP_SERIALIZATION_DECL StreamOverrunException : public ros::Exception
+{
+public:
+  StreamOverrunException(const std::string& what)
+  : Exception(what)
+  {}
+};
+
+ROSCPP_SERIALIZATION_DECL void throwStreamOverrun();
+
+/**
+ * \brief Templated serialization class.  Default implementation provides backwards compatibility with
+ * old message types.
+ *
+ * Specializing the Serializer class is the only thing you need to do to get the ROS serialization system
+ * to work with a type.
+ */
+template
+struct Serializer
+{
+  /**
+   * \brief Write an object to the stream.  Normally the stream passed in here will be a ros::serialization::OStream
+   */
+  template
+  inline static void write(Stream& stream, typename boost::call_traits::param_type t)
+  {
+    t.serialize(stream.getData(), 0);
+  }
+
+  /**
+   * \brief Read an object from the stream.  Normally the stream passed in here will be a ros::serialization::IStream
+   */
+  template
+  inline static void read(Stream& stream, typename boost::call_traits::reference t)
+  {
+    t.deserialize(stream.getData());
+  }
+
+  /**
+   * \brief Determine the serialized length of an object.
+   */
+  inline static uint32_t serializedLength(typename boost::call_traits::param_type t)
+  {
+    return t.serializationLength();
+  }
+};
+
+/**
+ * \brief Serialize an object.  Stream here should normally be a ros::serialization::OStream
+ */
+template
+inline void serialize(Stream& stream, const T& t)
+{
+  Serializer::write(stream, t);
+}
+
+/**
+ * \brief Deserialize an object.  Stream here should normally be a ros::serialization::IStream
+ */
+template
+inline void deserialize(Stream& stream, T& t)
+{
+  Serializer::read(stream, t);
+}
+
+/**
+ * \brief Determine the serialized length of an object
+ */
+template
+inline uint32_t serializationLength(const T& t)
+{
+  return Serializer::serializedLength(t);
+}
+
+#define ROS_CREATE_SIMPLE_SERIALIZER(Type) \
+  template<> struct Serializer \
+  { \
+    template inline static void write(Stream& stream, const Type v) \
+    { \
+      *reinterpret_cast(stream.advance(sizeof(v))) = v; \
+    } \
+    \
+    template inline static void read(Stream& stream, Type& v) \
+    { \
+      v = *reinterpret_cast(stream.advance(sizeof(v))); \
+    } \
+    \
+    inline static uint32_t serializedLength(const Type&) \
+    { \
+      return sizeof(Type); \
+    } \
+  };
+
+#define ROS_CREATE_SIMPLE_SERIALIZER_ARM(Type) \
+  template<> struct Serializer \
+  { \
+    template inline static void write(Stream& stream, const Type v) \
+    { \
+      memcpy(stream.advance(sizeof(v)), &v, sizeof(v) ); \
+    } \
+    \
+    template inline static void read(Stream& stream, Type& v) \
+    { \
+      memcpy(&v, stream.advance(sizeof(v)), sizeof(v) ); \
+    } \
+    \
+    inline static uint32_t serializedLength(const Type&) \
+      { \
+      return sizeof(Type); \
+    } \
+};
+
+#if defined(__arm__) || defined(__arm)
+    ROS_CREATE_SIMPLE_SERIALIZER_ARM(uint8_t)
+    ROS_CREATE_SIMPLE_SERIALIZER_ARM(int8_t)
+    ROS_CREATE_SIMPLE_SERIALIZER_ARM(uint16_t)
+    ROS_CREATE_SIMPLE_SERIALIZER_ARM(int16_t)
+    ROS_CREATE_SIMPLE_SERIALIZER_ARM(uint32_t)
+    ROS_CREATE_SIMPLE_SERIALIZER_ARM(int32_t)
+    ROS_CREATE_SIMPLE_SERIALIZER_ARM(uint64_t)
+    ROS_CREATE_SIMPLE_SERIALIZER_ARM(int64_t)
+    ROS_CREATE_SIMPLE_SERIALIZER_ARM(float)
+    ROS_CREATE_SIMPLE_SERIALIZER_ARM(double)
+#else
+    ROS_CREATE_SIMPLE_SERIALIZER(uint8_t)
+    ROS_CREATE_SIMPLE_SERIALIZER(int8_t)
+    ROS_CREATE_SIMPLE_SERIALIZER(uint16_t)
+    ROS_CREATE_SIMPLE_SERIALIZER(int16_t)
+    ROS_CREATE_SIMPLE_SERIALIZER(uint32_t)
+    ROS_CREATE_SIMPLE_SERIALIZER(int32_t)
+    ROS_CREATE_SIMPLE_SERIALIZER(uint64_t)
+    ROS_CREATE_SIMPLE_SERIALIZER(int64_t)
+    ROS_CREATE_SIMPLE_SERIALIZER(float)
+    ROS_CREATE_SIMPLE_SERIALIZER(double)
+#endif
+
+/**
+ * \brief Serializer specialized for bool (serialized as uint8)
+ */
+template<> struct Serializer
+{
+  template inline static void write(Stream& stream, const bool v)
+  {
+    uint8_t b = (uint8_t)v;
+#if defined(__arm__) || defined(__arm)
+    memcpy(stream.advance(1), &b, 1 );
+#else
+    *reinterpret_cast(stream.advance(1)) = b;
+#endif
+  }
+
+  template inline static void read(Stream& stream, bool& v)
+  {
+    uint8_t b;
+#if defined(__arm__) || defined(__arm)
+    memcpy(&b, stream.advance(1), 1 );
+#else
+    b = *reinterpret_cast(stream.advance(1));
+#endif
+    v = (bool)b;
+  }
+
+  inline static uint32_t serializedLength(bool)
+  {
+    return 1;
+  }
+};
+
+/**
+ * \brief  Serializer specialized for std::string
+ */
+template
+struct Serializer, ContainerAllocator> >
+{
+  typedef std::basic_string, ContainerAllocator> StringType;
+
+  template
+  inline static void write(Stream& stream, const StringType& str)
+  {
+    size_t len = str.size();
+    stream.next((uint32_t)len);
+
+    if (len > 0)
+    {
+      memcpy(stream.advance((uint32_t)len), str.data(), len);
+    }
+  }
+
+  template
+  inline static void read(Stream& stream, StringType& str)
+  {
+    uint32_t len;
+    stream.next(len);
+    if (len > 0)
+    {
+      str = StringType((char*)stream.advance(len), len);
+    }
+    else
+    {
+      str.clear();
+    }
+  }
+
+  inline static uint32_t serializedLength(const StringType& str)
+  {
+    return 4 + (uint32_t)str.size();
+  }
+};
+
+/**
+ * \brief Serializer specialized for ros::Time
+ */
+template<>
+struct Serializer
+{
+  template
+  inline static void write(Stream& stream, const ros::Time& v)
+  {
+    stream.next(v.sec);
+    stream.next(v.nsec);
+  }
+
+  template
+  inline static void read(Stream& stream, ros::Time& v)
+  {
+    stream.next(v.sec);
+    stream.next(v.nsec);
+  }
+
+  inline static uint32_t serializedLength(const ros::Time&)
+  {
+    return 8;
+  }
+};
+
+/**
+ * \brief Serializer specialized for ros::Duration
+ */
+template<>
+struct Serializer
+{
+  template
+  inline static void write(Stream& stream, const ros::Duration& v)
+  {
+    stream.next(v.sec);
+    stream.next(v.nsec);
+  }
+
+  template
+  inline static void read(Stream& stream, ros::Duration& v)
+  {
+    stream.next(v.sec);
+    stream.next(v.nsec);
+  }
+
+  inline static uint32_t serializedLength(const ros::Duration&)
+  {
+    return 8;
+  }
+};
+
+/**
+ * \brief Vector serializer.  Default implementation does nothing
+ */
+template
+struct VectorSerializer
+{};
+
+/**
+ * \brief Vector serializer, specialized for non-fixed-size, non-simple types
+ */
+template
+struct VectorSerializer >::type >
+{
+  typedef std::vector::other> VecType;
+  typedef typename VecType::iterator IteratorType;
+  typedef typename VecType::const_iterator ConstIteratorType;
+
+  template
+  inline static void write(Stream& stream, const VecType& v)
+  {
+    stream.next((uint32_t)v.size());
+    ConstIteratorType it = v.begin();
+    ConstIteratorType end = v.end();
+    for (; it != end; ++it)
+    {
+      stream.next(*it);
+    }
+  }
+
+  template
+  inline static void read(Stream& stream, VecType& v)
+  {
+    uint32_t len;
+    stream.next(len);
+    v.resize(len);
+    IteratorType it = v.begin();
+    IteratorType end = v.end();
+    for (; it != end; ++it)
+    {
+      stream.next(*it);
+    }
+  }
+
+  inline static uint32_t serializedLength(const VecType& v)
+  {
+    uint32_t size = 4;
+    ConstIteratorType it = v.begin();
+    ConstIteratorType end = v.end();
+    for (; it != end; ++it)
+    {
+      size += serializationLength(*it);
+    }
+
+    return size;
+  }
+};
+
+/**
+ * \brief Vector serializer, specialized for fixed-size simple types
+ */
+template
+struct VectorSerializer >::type >
+{
+  typedef std::vector::other> VecType;
+  typedef typename VecType::iterator IteratorType;
+  typedef typename VecType::const_iterator ConstIteratorType;
+
+  template
+  inline static void write(Stream& stream, const VecType& v)
+  {
+    uint32_t len = (uint32_t)v.size();
+    stream.next(len);
+    if (!v.empty())
+    {
+      const uint32_t data_len = len * (uint32_t)sizeof(T);
+      memcpy(stream.advance(data_len), &v.front(), data_len);
+    }
+  }
+
+  template
+  inline static void read(Stream& stream, VecType& v)
+  {
+    uint32_t len;
+    stream.next(len);
+    v.resize(len);
+
+    if (len > 0)
+    {
+      const uint32_t data_len = (uint32_t)sizeof(T) * len;
+      memcpy(&v.front(), stream.advance(data_len), data_len);
+    }
+  }
+
+  inline static uint32_t serializedLength(const VecType& v)
+  {
+    return 4 + (uint32_t)v.size() * (uint32_t)sizeof(T);
+  }
+};
+
+/**
+ * \brief Vector serializer, specialized for fixed-size non-simple types
+ */
+template
+struct VectorSerializer, mpl::not_ > > >::type >
+{
+  typedef std::vector::other> VecType;
+  typedef typename VecType::iterator IteratorType;
+  typedef typename VecType::const_iterator ConstIteratorType;
+
+  template
+  inline static void write(Stream& stream, const VecType& v)
+  {
+    stream.next((uint32_t)v.size());
+    ConstIteratorType it = v.begin();
+    ConstIteratorType end = v.end();
+    for (; it != end; ++it)
+    {
+      stream.next(*it);
+    }
+  }
+
+  template
+  inline static void read(Stream& stream, VecType& v)
+  {
+    uint32_t len;
+    stream.next(len);
+    v.resize(len);
+    IteratorType it = v.begin();
+    IteratorType end = v.end();
+    for (; it != end; ++it)
+    {
+      stream.next(*it);
+    }
+  }
+
+  inline static uint32_t serializedLength(const VecType& v)
+  {
+    uint32_t size = 4;
+    if (!v.empty())
+    {
+      uint32_t len_each = serializationLength(v.front());
+      size += len_each * (uint32_t)v.size();
+    }
+
+    return size;
+  }
+};
+
+/**
+ * \brief serialize version for std::vector
+ */
+template
+inline void serialize(Stream& stream, const std::vector& t)
+{
+  VectorSerializer::write(stream, t);
+}
+
+/**
+ * \brief deserialize version for std::vector
+ */
+template
+inline void deserialize(Stream& stream, std::vector& t)
+{
+  VectorSerializer::read(stream, t);
+}
+
+/**
+ * \brief serializationLength version for std::vector
+ */
+template
+inline uint32_t serializationLength(const std::vector& t)
+{
+  return VectorSerializer::serializedLength(t);
+}
+
+/**
+ * \brief Array serializer, default implementation does nothing
+ */
+template
+struct ArraySerializer
+{};
+
+/**
+ * \brief Array serializer, specialized for non-fixed-size, non-simple types
+ */
+template
+struct ArraySerializer >::type>
+{
+  typedef boost::array ArrayType;
+  typedef typename ArrayType::iterator IteratorType;
+  typedef typename ArrayType::const_iterator ConstIteratorType;
+
+  template
+  inline static void write(Stream& stream, const ArrayType& v)
+  {
+    ConstIteratorType it = v.begin();
+    ConstIteratorType end = v.end();
+    for (; it != end; ++it)
+    {
+      stream.next(*it);
+    }
+  }
+
+  template
+  inline static void read(Stream& stream, ArrayType& v)
+  {
+    IteratorType it = v.begin();
+    IteratorType end = v.end();
+    for (; it != end; ++it)
+    {
+      stream.next(*it);
+    }
+  }
+
+  inline static uint32_t serializedLength(const ArrayType& v)
+  {
+    uint32_t size = 0;
+    ConstIteratorType it = v.begin();
+    ConstIteratorType end = v.end();
+    for (; it != end; ++it)
+    {
+      size += serializationLength(*it);
+    }
+
+    return size;
+  }
+};
+
+/**
+ * \brief Array serializer, specialized for fixed-size, simple types
+ */
+template
+struct ArraySerializer >::type>
+{
+  typedef boost::array ArrayType;
+  typedef typename ArrayType::iterator IteratorType;
+  typedef typename ArrayType::const_iterator ConstIteratorType;
+
+  template
+  inline static void write(Stream& stream, const ArrayType& v)
+  {
+    const uint32_t data_len = N * sizeof(T);
+    memcpy(stream.advance(data_len), &v.front(), data_len);
+  }
+
+  template
+  inline static void read(Stream& stream, ArrayType& v)
+  {
+    const uint32_t data_len = N * sizeof(T);
+    memcpy(&v.front(), stream.advance(data_len), data_len);
+  }
+
+  inline static uint32_t serializedLength(const ArrayType&)
+  {
+    return N * sizeof(T);
+  }
+};
+
+/**
+ * \brief Array serializer, specialized for fixed-size, non-simple types
+ */
+template
+struct ArraySerializer, mpl::not_ > > >::type>
+{
+  typedef boost::array ArrayType;
+  typedef typename ArrayType::iterator IteratorType;
+  typedef typename ArrayType::const_iterator ConstIteratorType;
+
+  template
+  inline static void write(Stream& stream, const ArrayType& v)
+  {
+    ConstIteratorType it = v.begin();
+    ConstIteratorType end = v.end();
+    for (; it != end; ++it)
+    {
+      stream.next(*it);
+    }
+  }
+
+  template
+  inline static void read(Stream& stream, ArrayType& v)
+  {
+    IteratorType it = v.begin();
+    IteratorType end = v.end();
+    for (; it != end; ++it)
+    {
+      stream.next(*it);
+    }
+  }
+
+  inline static uint32_t serializedLength(const ArrayType& v)
+  {
+    return serializationLength(v.front()) * N;
+  }
+};
+
+/**
+ * \brief serialize version for boost::array
+ */
+template
+inline void serialize(Stream& stream, const boost::array& t)
+{
+  ArraySerializer::write(stream, t);
+}
+
+/**
+ * \brief deserialize version for boost::array
+ */
+template
+inline void deserialize(Stream& stream, boost::array& t)
+{
+  ArraySerializer::read(stream, t);
+}
+
+/**
+ * \brief serializationLength version for boost::array
+ */
+template
+inline uint32_t serializationLength(const boost::array& t)
+{
+  return ArraySerializer::serializedLength(t);
+}
+
+/**
+ * \brief Enum
+ */
+namespace stream_types
+{
+enum StreamType
+{
+  Input,
+  Output,
+  Length
+};
+}
+typedef stream_types::StreamType StreamType;
+
+/**
+ * \brief Stream base-class, provides common functionality for IStream and OStream
+ */
+struct ROSCPP_SERIALIZATION_DECL Stream
+{
+  /*
+   * \brief Returns a pointer to the current position of the stream
+   */
+  inline uint8_t* getData() { return data_; }
+  /**
+   * \brief Advances the stream, checking bounds, and returns a pointer to the position before it
+   * was advanced.
+   * \throws StreamOverrunException if len would take this stream past the end of its buffer
+   */
+  ROS_FORCE_INLINE uint8_t* advance(uint32_t len)
+  {
+    uint8_t* old_data = data_;
+    data_ += len;
+    if (data_ > end_)
+    {
+      // Throwing directly here causes a significant speed hit due to the extra code generated
+      // for the throw statement
+      throwStreamOverrun();
+    }
+    return old_data;
+  }
+
+  /**
+   * \brief Returns the amount of space left in the stream
+   */
+  inline uint32_t getLength() { return (uint32_t)(end_ - data_); }
+
+protected:
+  Stream(uint8_t* _data, uint32_t _count)
+  : data_(_data)
+  , end_(_data + _count)
+  {}
+
+private:
+  uint8_t* data_;
+  uint8_t* end_;
+};
+
+/**
+ * \brief Input stream
+ */
+struct ROSCPP_SERIALIZATION_DECL IStream : public Stream
+{
+  static const StreamType stream_type = stream_types::Input;
+
+  IStream(uint8_t* data, uint32_t count)
+  : Stream(data, count)
+  {}
+
+  /**
+   * \brief Deserialize an item from this input stream
+   */
+  template
+  ROS_FORCE_INLINE void next(T& t)
+  {
+    deserialize(*this, t);
+  }
+
+  template
+  ROS_FORCE_INLINE IStream& operator>>(T& t)
+  {
+    deserialize(*this, t);
+    return *this;
+  }
+};
+
+/**
+ * \brief Output stream
+ */
+struct ROSCPP_SERIALIZATION_DECL OStream : public Stream
+{
+  static const StreamType stream_type = stream_types::Output;
+
+  OStream(uint8_t* data, uint32_t count)
+  : Stream(data, count)
+  {}
+
+  /**
+   * \brief Serialize an item to this output stream
+   */
+  template
+  ROS_FORCE_INLINE void next(const T& t)
+  {
+    serialize(*this, t);
+  }
+
+  template
+  ROS_FORCE_INLINE OStream& operator<<(const T& t)
+  {
+    serialize(*this, t);
+    return *this;
+  }
+};
+
+
+/**
+ * \brief Length stream
+ *
+ * LStream is not what you would normally think of as a stream, but it is used in order to support
+ * allinone serializers.
+ */
+struct ROSCPP_SERIALIZATION_DECL LStream
+{
+  static const StreamType stream_type = stream_types::Length;
+
+  LStream()
+  : count_(0)
+  {}
+
+  /**
+   * \brief Add the length of an item to this length stream
+   */
+  template
+  ROS_FORCE_INLINE void next(const T& t)
+  {
+    count_ += serializationLength(t);
+  }
+
+  /**
+   * \brief increment the length by len
+   */
+  ROS_FORCE_INLINE uint32_t advance(uint32_t len)
+  {
+    uint32_t old = count_;
+    count_ += len;
+    return old;
+  }
+
+  /**
+   * \brief Get the total length of this tream
+   */
+  inline uint32_t getLength() { return count_; }
+
+private:
+  uint32_t count_;
+};
+
+/**
+ * \brief Serialize a message
+ */
+template
+inline SerializedMessage serializeMessage(const M& message)
+{
+  SerializedMessage m;
+  uint32_t len = serializationLength(message);
+  m.num_bytes = len + 4;
+  m.buf.reset(new uint8_t[m.num_bytes]);
+
+  OStream s(m.buf.get(), (uint32_t)m.num_bytes);
+  serialize(s, (uint32_t)m.num_bytes - 4);
+  m.message_start = s.getData();
+  serialize(s, message);
+
+  return m;
+}
+
+/**
+ * \brief Serialize a service response
+ */
+template
+inline SerializedMessage serializeServiceResponse(bool ok, const M& message)
+{
+  SerializedMessage m;
+
+  if (ok)
+  {
+    uint32_t len = serializationLength(message);
+    m.num_bytes = len + 5;
+    m.buf.reset(new uint8_t[m.num_bytes]);
+
+    OStream s(m.buf.get(), (uint32_t)m.num_bytes);
+    serialize(s, (uint8_t)ok);
+    serialize(s, (uint32_t)m.num_bytes - 5);
+    serialize(s, message);
+  }
+  else
+  {
+    uint32_t len = serializationLength(message);
+    m.num_bytes = len + 1;
+    m.buf.reset(new uint8_t[m.num_bytes]);
+
+    OStream s(m.buf.get(), (uint32_t)m.num_bytes);
+    serialize(s, (uint8_t)ok);
+    serialize(s, message);
+  }
+
+  return m;
+}
+
+/**
+ * \brief Deserialize a message.  If includes_length is true, skips the first 4 bytes
+ */
+template
+inline void deserializeMessage(const SerializedMessage& m, M& message)
+{
+  IStream s(m.message_start, m.num_bytes - (m.message_start - m.buf.get()));
+  deserialize(s, message);
+}
+
+
+// Additional serialization traits
+
+template
+struct PreDeserializeParams
+{
+  boost::shared_ptr message;
+  boost::shared_ptr > connection_header;
+};
+
+/**
+ * \brief called by the SubscriptionCallbackHelper after a message is
+ * instantiated but before that message is deserialized
+ */
+template
+struct PreDeserialize
+{
+  static void notify(const PreDeserializeParams&) { }
+};
+
+} // namespace serialization
+
+} // namespace ros
+
+#endif // ROSCPP_SERIALIZATION_H
diff --git a/realsense-file/src/storage/realsense_file/rosbag/roscpp_serialization/include/ros/serialized_message.h b/realsense-file/src/storage/realsense_file/rosbag/roscpp_serialization/include/ros/serialized_message.h
new file mode 100644
index 0000000000..325083c0ea
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/rosbag/roscpp_serialization/include/ros/serialized_message.h
@@ -0,0 +1,66 @@
+/*
+ * Copyright (C) 2009, Willow Garage, Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *   * Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *   * Neither the names of Willow Garage, Inc. nor the names of its
+ *     contributors may be used to endorse or promote products derived from
+ *     this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef ROSLIB_SERIALIZED_MESSAGE_H
+#define ROSLIB_SERIALIZED_MESSAGE_H
+
+#include "roscpp_serialization_macros.h"
+
+#include 
+#include 
+
+namespace ros
+{
+
+class ROSCPP_SERIALIZATION_DECL SerializedMessage
+{
+public:
+  boost::shared_array buf;
+  size_t num_bytes;
+  uint8_t* message_start;
+
+  boost::shared_ptr message;
+  const std::type_info* type_info;
+
+  SerializedMessage()
+  : buf(boost::shared_array())
+  , num_bytes(0)
+  , message_start(0)
+  , type_info(0)
+  {}
+
+  SerializedMessage(boost::shared_array buf, size_t num_bytes)
+  : buf(buf)
+  , num_bytes(num_bytes)
+  , message_start(buf ? buf.get() : 0)
+  , type_info(0)
+  { }
+};
+
+} // namespace ros
+
+#endif // ROSLIB_SERIALIZED_MESSAGE_H
diff --git a/realsense-file/src/storage/realsense_file/rosbag/roscpp_serialization/src/serialization.cpp b/realsense-file/src/storage/realsense_file/rosbag/roscpp_serialization/src/serialization.cpp
new file mode 100644
index 0000000000..72a16c41fd
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/rosbag/roscpp_serialization/src/serialization.cpp
@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2009, Willow Garage, Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *   * Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *   * Neither the names of Stanford University or Willow Garage, Inc. nor the names of its
+ *     contributors may be used to endorse or promote products derived from
+ *     this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include 
+
+namespace ros
+{
+namespace serialization
+{
+void throwStreamOverrun()
+{
+  throw StreamOverrunException("Buffer Overrun");
+}
+}
+}
diff --git a/realsense-file/src/storage/realsense_file/rosbag/roscpp_traits/config.cmake b/realsense-file/src/storage/realsense_file/rosbag/roscpp_traits/config.cmake
new file mode 100644
index 0000000000..e32019a21d
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/rosbag/roscpp_traits/config.cmake
@@ -0,0 +1,12 @@
+cmake_minimum_required(VERSION 2.8.3)
+
+set(HEADER_FILES_ROSCPP_TRAITS
+  rosbag/roscpp_traits/include/ros/builtin_message_traits.h  
+  rosbag/roscpp_traits/include/ros/message_event.h  
+  rosbag/roscpp_traits/include/ros/message_forward.h  
+  rosbag/roscpp_traits/include/ros/message_operations.h  
+  rosbag/roscpp_traits/include/ros/message_traits.h  
+  rosbag/roscpp_traits/include/ros/service_traits.h
+)
+
+
diff --git a/realsense-file/src/storage/realsense_file/rosbag/roscpp_traits/include/ros/builtin_message_traits.h b/realsense-file/src/storage/realsense_file/rosbag/roscpp_traits/include/ros/builtin_message_traits.h
new file mode 100644
index 0000000000..c9496e21ae
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/rosbag/roscpp_traits/include/ros/builtin_message_traits.h
@@ -0,0 +1,63 @@
+/*
+ * Copyright (C) 2009, Willow Garage, Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *   * Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *   * Neither the names of Willow Garage, Inc. nor the names of its
+ *     contributors may be used to endorse or promote products derived from
+ *     this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef ROSLIB_BUILTIN_MESSAGE_TRAITS_H
+#define ROSLIB_BUILTIN_MESSAGE_TRAITS_H
+
+#include "message_traits.h"
+#include "ros/time.h"
+
+namespace ros
+{
+namespace message_traits
+{
+
+#define ROSLIB_CREATE_SIMPLE_TRAITS(Type) \
+    template<> struct IsSimple : public TrueType {}; \
+    template<> struct IsFixedSize : public TrueType {};
+
+ROSLIB_CREATE_SIMPLE_TRAITS(uint8_t)
+ROSLIB_CREATE_SIMPLE_TRAITS(int8_t)
+ROSLIB_CREATE_SIMPLE_TRAITS(uint16_t)
+ROSLIB_CREATE_SIMPLE_TRAITS(int16_t)
+ROSLIB_CREATE_SIMPLE_TRAITS(uint32_t)
+ROSLIB_CREATE_SIMPLE_TRAITS(int32_t)
+ROSLIB_CREATE_SIMPLE_TRAITS(uint64_t)
+ROSLIB_CREATE_SIMPLE_TRAITS(int64_t)
+ROSLIB_CREATE_SIMPLE_TRAITS(float)
+ROSLIB_CREATE_SIMPLE_TRAITS(double)
+ROSLIB_CREATE_SIMPLE_TRAITS(Time)
+ROSLIB_CREATE_SIMPLE_TRAITS(Duration)
+
+// because std::vector is not a true vector, bool is not a simple type
+template<> struct IsFixedSize : public TrueType {};
+
+} // namespace message_traits
+} // namespace ros
+
+#endif // ROSLIB_BUILTIN_MESSAGE_TRAITS_H
+
diff --git a/realsense-file/src/storage/realsense_file/rosbag/roscpp_traits/include/ros/message_event.h b/realsense-file/src/storage/realsense_file/rosbag/roscpp_traits/include/ros/message_event.h
new file mode 100644
index 0000000000..9d79526dd9
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/rosbag/roscpp_traits/include/ros/message_event.h
@@ -0,0 +1,256 @@
+
+/*
+ * Copyright (C) 2010, Willow Garage, Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *   * Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *   * Neither the names of Stanford University or Willow Garage, Inc. nor the names of its
+ *     contributors may be used to endorse or promote products derived from
+ *     this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef ROSCPP_MESSAGE_EVENT_H
+#define ROSCPP_MESSAGE_EVENT_H
+
+#include "ros/time.h"
+#include 
+#include 
+
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+
+namespace ros
+{
+
+template
+struct DefaultMessageCreator
+{
+  boost::shared_ptr operator()()
+  {
+    return boost::make_shared();
+  }
+};
+
+template
+ROS_DEPRECATED inline boost::shared_ptr defaultMessageCreateFunction()
+{
+  return DefaultMessageCreator()();
+}
+
+/**
+ * \brief Event type for subscriptions, const ros::MessageEvent& can be used in your callback instead of const boost::shared_ptr&
+ *
+ * Useful if you need to retrieve meta-data about the message, such as the full connection header, or the publisher's node name
+ */
+template
+class MessageEvent
+{
+public:
+  typedef typename boost::add_const::type ConstMessage;
+  typedef typename boost::remove_const::type Message;
+  typedef boost::shared_ptr MessagePtr;
+  typedef boost::shared_ptr ConstMessagePtr;
+  typedef boost::function CreateFunction;
+
+  MessageEvent()
+  : nonconst_need_copy_(true)
+  {}
+
+  MessageEvent(const MessageEvent& rhs)
+  {
+    *this = rhs;
+  }
+
+  MessageEvent(const MessageEvent& rhs)
+  {
+    *this = rhs;
+  }
+
+  MessageEvent(const MessageEvent& rhs, bool nonconst_need_copy)
+  {
+    *this = rhs;
+    nonconst_need_copy_ = nonconst_need_copy;
+  }
+
+  MessageEvent(const MessageEvent& rhs, bool nonconst_need_copy)
+  {
+    *this = rhs;
+    nonconst_need_copy_ = nonconst_need_copy;
+  }
+
+  MessageEvent(const MessageEvent& rhs, const CreateFunction& create)
+  {
+    init(boost::const_pointer_cast(boost::static_pointer_cast(rhs.getMessage())), rhs.getConnectionHeaderPtr(), rhs.getReceiptTime(), rhs.nonConstWillCopy(), create);
+  }
+
+  /**
+   * \todo Make this explicit in ROS 2.0.  Keep as auto-converting for now to maintain backwards compatibility in some places (message_filters)
+   */
+  MessageEvent(const ConstMessagePtr& message)
+  {
+    init(message, boost::shared_ptr(), ros::Time::now(), true, ros::DefaultMessageCreator());
+  }
+
+  MessageEvent(const ConstMessagePtr& message, const boost::shared_ptr& connection_header, ros::Time receipt_time)
+  {
+    init(message, connection_header, receipt_time, true, ros::DefaultMessageCreator());
+  }
+
+  MessageEvent(const ConstMessagePtr& message, ros::Time receipt_time)
+  {
+    init(message, boost::shared_ptr(), receipt_time, true, ros::DefaultMessageCreator());
+  }
+
+  MessageEvent(const ConstMessagePtr& message, const boost::shared_ptr& connection_header, ros::Time receipt_time, bool nonconst_need_copy, const CreateFunction& create)
+  {
+    init(message, connection_header, receipt_time, nonconst_need_copy, create);
+  }
+
+  void init(const ConstMessagePtr& message, const boost::shared_ptr& connection_header, ros::Time receipt_time, bool nonconst_need_copy, const CreateFunction& create)
+  {
+    message_ = message;
+    connection_header_ = connection_header;
+    receipt_time_ = receipt_time;
+    nonconst_need_copy_ = nonconst_need_copy;
+    create_ = create;
+  }
+
+  void operator=(const MessageEvent& rhs)
+  {
+    init(boost::static_pointer_cast(rhs.getMessage()), rhs.getConnectionHeaderPtr(), rhs.getReceiptTime(), rhs.nonConstWillCopy(), rhs.getMessageFactory());
+    message_copy_.reset();
+  }
+
+  void operator=(const MessageEvent& rhs)
+  {
+    init(boost::const_pointer_cast(boost::static_pointer_cast(rhs.getMessage())), rhs.getConnectionHeaderPtr(), rhs.getReceiptTime(), rhs.nonConstWillCopy(), rhs.getMessageFactory());
+    message_copy_.reset();
+  }
+
+  /**
+   * \brief Retrieve the message.  If M is const, this returns a reference to it.  If M is non const
+   * and this event requires it, returns a copy.  Note that it caches this copy for later use, so it will
+   * only every make the copy once
+   */
+  boost::shared_ptr getMessage() const
+  {
+    return copyMessageIfNecessary();
+  }
+
+  /**
+   * \brief Retrieve a const version of the message
+   */
+  const boost::shared_ptr& getConstMessage() const { return message_; }
+  /**
+   * \brief Retrieve the connection header
+   */
+  M_string& getConnectionHeader() const { return *connection_header_; }
+  const boost::shared_ptr& getConnectionHeaderPtr() const { return connection_header_; }
+
+  /**
+   * \brief Returns the name of the node which published this message
+   */
+  const std::string& getPublisherName() const { return connection_header_ ? (*connection_header_)["callerid"] : s_unknown_publisher_string_; }
+
+  /**
+   * \brief Returns the time at which this message was received
+   */
+  ros::Time getReceiptTime() const { return receipt_time_; }
+
+  bool nonConstWillCopy() const { return nonconst_need_copy_; }
+  bool getMessageWillCopy() const { return !boost::is_const::value && nonconst_need_copy_; }
+
+  bool operator<(const MessageEvent& rhs)
+  {
+    if (message_ != rhs.message_)
+    {
+      return message_ < rhs.message_;
+    }
+
+    if (receipt_time_ != rhs.receipt_time_)
+    {
+      return receipt_time_ < rhs.receipt_time_;
+    }
+
+    return nonconst_need_copy_ < rhs.nonconst_need_copy_;
+  }
+
+  bool operator==(const MessageEvent& rhs)
+  {
+    return message_ = rhs.message_ && receipt_time_ == rhs.receipt_time_ && nonconst_need_copy_ == rhs.nonconst_need_copy_;
+  }
+
+  bool operator!=(const MessageEvent& rhs)
+  {
+    return !(*this == rhs);
+  }
+
+  const CreateFunction& getMessageFactory() const { return create_; }
+
+private:
+  template
+  typename boost::disable_if, boost::shared_ptr >::type copyMessageIfNecessary() const
+  {
+    if (boost::is_const::value || !nonconst_need_copy_)
+    {
+      return boost::const_pointer_cast(message_);
+    }
+
+    if (message_copy_)
+    {
+      return message_copy_;
+    }
+
+    assert(create_);
+    message_copy_ = create_();
+    *message_copy_ = *message_;
+
+    return message_copy_;
+  }
+
+  template
+  typename boost::enable_if, boost::shared_ptr >::type copyMessageIfNecessary() const
+  {
+    return boost::const_pointer_cast(message_);
+  }
+
+  ConstMessagePtr message_;
+  // Kind of ugly to make this mutable, but it means we can pass a const MessageEvent to a callback and not worry about other things being modified
+  mutable MessagePtr message_copy_;
+  boost::shared_ptr connection_header_;
+  ros::Time receipt_time_;
+  bool nonconst_need_copy_;
+  CreateFunction create_;
+
+  static const std::string s_unknown_publisher_string_;
+};
+
+template const std::string MessageEvent::s_unknown_publisher_string_("unknown_publisher");
+
+
+}
+
+#endif // ROSCPP_MESSAGE_EVENT_H
diff --git a/realsense-file/src/storage/realsense_file/rosbag/roscpp_traits/include/ros/message_forward.h b/realsense-file/src/storage/realsense_file/rosbag/roscpp_traits/include/ros/message_forward.h
new file mode 100644
index 0000000000..a8203a399f
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/rosbag/roscpp_traits/include/ros/message_forward.h
@@ -0,0 +1,71 @@
+/*
+ * Copyright (C) 2009, Willow Garage, Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *   * Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *   * Neither the names of Willow Garage, Inc. nor the names of its
+ *     contributors may be used to endorse or promote products derived from
+ *     this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef ROSLIB_MESSAGE_FORWARD_H
+#define ROSLIB_MESSAGE_FORWARD_H
+
+// Make sure that either __GLIBCXX__ or _LIBCPP_VERSION is defined.
+#include 
+
+// C++ standard section 17.4.3.1/1 states that forward declarations of STL types
+// that aren't specializations involving user defined types results in undefined
+// behavior. Apparently only libc++ has a problem with this and won't compile it.
+#ifndef _LIBCPP_VERSION
+namespace std
+{
+template class allocator;
+}
+#else
+#include 
+#endif
+
+namespace boost
+{
+template class shared_ptr;
+}
+
+/**
+ * \brief Forward-declare a message, including Ptr and ConstPtr types, with an allocator
+ *
+ * \param ns The namespace the message should be declared inside
+ * \param m The "base" message type, i.e. the name of the .msg file
+ * \param new_name The name you'd like the message to have
+ * \param alloc The allocator to use, e.g. std::allocator
+ */
+#define ROS_DECLARE_MESSAGE_WITH_ALLOCATOR(msg, new_name, alloc) \
+  template struct msg##_; \
+  typedef msg##_ > new_name; \
+  typedef boost::shared_ptr new_name##Ptr; \
+  typedef boost::shared_ptr new_name##ConstPtr;
+
+/**
+ * \brief Forward-declare a message, including Ptr and ConstPtr types, using std::allocator
+ * \param msg The "base" message type, i.e. the name of the .msg file
+ */
+#define ROS_DECLARE_MESSAGE(msg) ROS_DECLARE_MESSAGE_WITH_ALLOCATOR(msg, msg, std::allocator)
+
+#endif // ROSLIB_MESSAGE_FORWARD_H
diff --git a/realsense-file/src/storage/realsense_file/rosbag/roscpp_traits/include/ros/message_operations.h b/realsense-file/src/storage/realsense_file/rosbag/roscpp_traits/include/ros/message_operations.h
new file mode 100644
index 0000000000..f5b4079b66
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/rosbag/roscpp_traits/include/ros/message_operations.h
@@ -0,0 +1,77 @@
+/*
+ * Copyright (C) 2010, Willow Garage, Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *   * Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *   * Neither the names of Willow Garage, Inc. nor the names of its
+ *     contributors may be used to endorse or promote products derived from
+ *     this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef ROSLIB_MESSAGE_OPERATIONS_H
+#define ROSLIB_MESSAGE_OPERATIONS_H
+
+#include 
+
+namespace ros
+{
+namespace message_operations
+{
+
+template
+struct Printer
+{
+  template
+  static void stream(Stream& s, const std::string& indent, const M& value)
+  {
+    (void)indent;
+    s << value << "\n";
+  }
+};
+
+// Explicitly specialize for uint8_t/int8_t because otherwise it thinks it's a char, and treats
+// the value as a character code
+template<>
+struct Printer
+{
+  template
+  static void stream(Stream& s, const std::string& indent, int8_t value)
+  {
+    (void)indent;
+    s << static_cast(value) << "\n";
+  }
+};
+
+template<>
+struct Printer
+{
+  template
+  static void stream(Stream& s, const std::string& indent, uint8_t value)
+  {
+    (void)indent;
+    s << static_cast(value) << "\n";
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // ROSLIB_MESSAGE_OPERATIONS_H
+
diff --git a/realsense-file/src/storage/realsense_file/rosbag/roscpp_traits/include/ros/message_traits.h b/realsense-file/src/storage/realsense_file/rosbag/roscpp_traits/include/ros/message_traits.h
new file mode 100644
index 0000000000..b21ce70b09
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/rosbag/roscpp_traits/include/ros/message_traits.h
@@ -0,0 +1,360 @@
+/*
+ * Copyright (C) 2009, Willow Garage, Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *   * Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *   * Neither the names of Willow Garage, Inc. nor the names of its
+ *     contributors may be used to endorse or promote products derived from
+ *     this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef ROSLIB_MESSAGE_TRAITS_H
+#define ROSLIB_MESSAGE_TRAITS_H
+
+#include "message_forward.h"
+
+#include 
+
+#include 
+#include 
+#include 
+#include 
+
+namespace std_msgs
+{
+  ROS_DECLARE_MESSAGE(Header)
+}
+
+#define ROS_IMPLEMENT_SIMPLE_TOPIC_TRAITS(msg, md5sum, datatype, definition) \
+  namespace ros \
+  { \
+  namespace message_traits \
+  { \
+  template<> struct MD5Sum \
+  { \
+    static const char* value() { return md5sum; } \
+    static const char* value(const msg&) { return value(); } \
+  }; \
+  template<> struct DataType \
+  { \
+    static const char* value() { return datatype; } \
+    static const char* value(const msg&) { return value(); } \
+  }; \
+  template<> struct Definition \
+  { \
+    static const char* value() { return definition; } \
+    static const char* value(const msg&) { return value(); } \
+  }; \
+  } \
+  }
+
+
+namespace ros
+{
+namespace message_traits
+{
+
+/**
+ * \brief Base type for compile-type true/false tests.  Compatible with Boost.MPL.  classes inheriting from this type
+ * are \b true values.
+ */
+struct TrueType
+{
+  static const bool value = true;
+  typedef TrueType type;
+};
+
+/**
+ * \brief Base type for compile-type true/false tests.  Compatible with Boost.MPL.  classes inheriting from this type
+ * are \b false values.
+ */
+struct FalseType
+{
+  static const bool value = false;
+  typedef FalseType type;
+};
+
+/**
+ * \brief A simple datatype is one that can be memcpy'd directly in array form, i.e. it's a POD, fixed-size type and
+ * sizeof(M) == sum(serializationLength(M:a...))
+ */
+template struct IsSimple : public FalseType {};
+/**
+ * \brief A fixed-size datatype is one whose size is constant, i.e. it has no variable-length arrays or strings
+ */
+template struct IsFixedSize : public FalseType {};
+/**
+ * \brief HasHeader informs whether or not there is a header that gets serialized as the first thing in the message
+ */
+template struct HasHeader : public FalseType {};
+
+/**
+ * \brief Am I message or not
+ */
+template struct IsMessage : public FalseType {};
+
+/**
+ * \brief Specialize to provide the md5sum for a message
+ */
+template
+struct MD5Sum
+{
+  static const char* value()
+  {
+    return M::__s_getMD5Sum();
+  }
+
+  static const char* value(const M& m)
+  {
+    return m.__getMD5Sum();
+  }
+};
+
+/**
+ * \brief Specialize to provide the datatype for a message
+ */
+template
+struct DataType
+{
+  static const char* value()
+  {
+    return M::__s_getDataType();
+  }
+
+  static const char* value(const M& m)
+  {
+    return m.__getDataType();
+  }
+};
+
+/**
+ * \brief Specialize to provide the definition for a message
+ */
+template
+struct Definition
+{
+  static const char* value()
+  {
+    return M::__s_getMessageDefinition();
+  }
+
+  static const char* value(const M& m)
+  {
+    return m.__getMessageDefinition();
+  }
+};
+
+/**
+ * \brief Header trait.  In the default implementation pointer()
+ * returns &m.header if HasHeader::value is true, otherwise returns NULL
+ */
+template
+struct Header
+{
+  static std_msgs::Header* pointer(M& m) { (void)m; return 0; }
+  static std_msgs::Header const* pointer(const M& m) { (void)m; return 0; }
+};
+
+template
+struct Header >::type >
+{
+  static std_msgs::Header* pointer(M& m) { return &m.header; }
+  static std_msgs::Header const* pointer(const M& m) { return &m.header; }
+};
+
+/**
+ * \brief FrameId trait.  In the default implementation pointer()
+ * returns &m.header.frame_id if HasHeader::value is true, otherwise returns NULL.  value()
+ * does not exist, and causes a compile error
+ */
+template
+struct FrameId
+{
+  static std::string* pointer(M& m) { (void)m; return 0; }
+  static std::string const* pointer(const M& m) { (void)m; return 0; }
+};
+
+template
+struct FrameId >::type >
+{
+  static std::string* pointer(M& m) { return &m.header.frame_id; }
+  static std::string const* pointer(const M& m) { return &m.header.frame_id; }
+  static std::string value(const M& m) { return m.header.frame_id; }
+};
+
+/**
+ * \brief TimeStamp trait.  In the default implementation pointer()
+ * returns &m.header.stamp if HasHeader::value is true, otherwise returns NULL.  value()
+ * does not exist, and causes a compile error
+ */
+template
+struct TimeStamp
+{
+  static ros::Time* pointer(M& m) { (void)m; return 0; }
+  static ros::Time const* pointer(const M& m) { (void)m; return 0; }
+};
+
+template
+struct TimeStamp >::type >
+{
+  static ros::Time* pointer(typename boost::remove_const::type &m) { return &m.header.stamp; }
+  static ros::Time const* pointer(const M& m) { return &m.header.stamp; }
+  static ros::Time value(const M& m) { return m.header.stamp; }
+};
+
+/**
+ * \brief returns MD5Sum::value();
+ */
+template
+inline const char* md5sum()
+{
+  return MD5Sum::type>::type>::value();
+}
+
+/**
+ * \brief returns DataType::value();
+ */
+template
+inline const char* datatype()
+{
+  return DataType::type>::type>::value();
+}
+
+/**
+ * \brief returns Definition::value();
+ */
+template
+inline const char* definition()
+{
+  return Definition::type>::type>::value();
+}
+
+/**
+ * \brief returns MD5Sum::value(m);
+ */
+template
+inline const char* md5sum(const M& m)
+{
+  return MD5Sum::type>::type>::value(m);
+}
+
+/**
+ * \brief returns DataType::value(m);
+ */
+template
+inline const char* datatype(const M& m)
+{
+  return DataType::type>::type>::value(m);
+}
+
+/**
+ * \brief returns Definition::value(m);
+ */
+template
+inline const char* definition(const M& m)
+{
+  return Definition::type>::type>::value(m);
+}
+
+/**
+ * \brief returns Header::pointer(m);
+ */
+template
+inline std_msgs::Header* header(M& m)
+{
+  return Header::type>::type>::pointer(m);
+}
+
+/**
+ * \brief returns Header::pointer(m);
+ */
+template
+inline std_msgs::Header const* header(const M& m)
+{
+  return Header::type>::type>::pointer(m);
+}
+
+/**
+ * \brief returns FrameId::pointer(m);
+ */
+template
+inline std::string* frameId(M& m)
+{
+  return FrameId::type>::type>::pointer(m);
+}
+
+/**
+ * \brief returns FrameId::pointer(m);
+ */
+template
+inline std::string const* frameId(const M& m)
+{
+  return FrameId::type>::type>::pointer(m);
+}
+
+/**
+ * \brief returns TimeStamp::pointer(m);
+ */
+template
+inline ros::Time* timeStamp(M& m)
+{
+  return TimeStamp::type>::type>::pointer(m);
+}
+
+/**
+ * \brief returns TimeStamp::pointer(m);
+ */
+template
+inline ros::Time const* timeStamp(const M& m)
+{
+  return TimeStamp::type>::type>::pointer(m);
+}
+
+/**
+ * \brief returns IsSimple::value;
+ */
+template
+inline bool isSimple()
+{
+  return IsSimple::type>::type>::value;
+}
+
+/**
+ * \brief returns IsFixedSize::value;
+ */
+template
+inline bool isFixedSize()
+{
+  return IsFixedSize::type>::type>::value;
+}
+
+/**
+ * \brief returns HasHeader::value;
+ */
+template
+inline bool hasHeader()
+{
+  return HasHeader::type>::type>::value;
+}
+
+} // namespace message_traits
+} // namespace ros
+
+#endif // ROSLIB_MESSAGE_TRAITS_H
diff --git a/realsense-file/src/storage/realsense_file/rosbag/roscpp_traits/include/ros/service_traits.h b/realsense-file/src/storage/realsense_file/rosbag/roscpp_traits/include/ros/service_traits.h
new file mode 100644
index 0000000000..cb88e150d1
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/rosbag/roscpp_traits/include/ros/service_traits.h
@@ -0,0 +1,112 @@
+/*
+ * Copyright (C) 2009, Willow Garage, Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *   * Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *   * Neither the names of Willow Garage, Inc. nor the names of its
+ *     contributors may be used to endorse or promote products derived from
+ *     this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef ROSCPP_SERVICE_TRAITS_H
+#define ROSCPP_SERVICE_TRAITS_H
+
+#include 
+#include 
+
+namespace ros
+{
+namespace service_traits
+{
+
+/**
+ * \brief Specialize to provide the md5sum for a service
+ */
+template
+struct MD5Sum
+{
+  static const char* value()
+  {
+    return M::__s_getServerMD5Sum();
+  }
+
+  static const char* value(const M& m)
+  {
+    return m.__getServerMD5Sum();
+  }
+};
+
+/**
+ * \brief Specialize to provide the datatype for a service
+ */
+template
+struct DataType
+{
+  static const char* value()
+  {
+    return M::__s_getServiceDataType();
+  }
+
+  static const char* value(const M& m)
+  {
+    return m.__getServiceDataType();
+  }
+};
+
+/**
+ * \brief return MD5Sum::value();
+ */
+template
+inline const char* md5sum()
+{
+  return MD5Sum::type>::type>::value();
+}
+
+/**
+ * \brief return DataType::value();
+ */
+template
+inline const char* datatype()
+{
+  return DataType::type>::type>::value();
+}
+
+/**
+ * \brief return MD5Sum::value(m);
+ */
+template
+inline const char* md5sum(const M& m)
+{
+  return MD5Sum::type>::type>::value(m);
+}
+
+/**
+ * \brief return DataType::value();
+ */
+template
+inline const char* datatype(const M& m)
+{
+  return DataType::type>::type>::value(m);
+}
+
+} // namespace service_traits
+} // namespace ros
+
+#endif // ROSCPP_SERVICE_TRAITS_H
diff --git a/realsense-file/src/storage/realsense_file/rosbag/roslz4/config.cmake b/realsense-file/src/storage/realsense_file/rosbag/roslz4/config.cmake
new file mode 100644
index 0000000000..8ac806bd38
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/rosbag/roslz4/config.cmake
@@ -0,0 +1,12 @@
+cmake_minimum_required(VERSION 2.8.3)
+
+set(HEADER_FILES_ROSLZ4
+  rosbag/roslz4/include/roslz4/lz4s.h
+)
+
+set(SOURCE_FILES_ROSLZ4
+  rosbag/roslz4/src/lz4s.c
+#  rosbag/roslz4/src/_roslz4module.c
+  rosbag/roslz4/src/xxhash.c
+  rosbag/roslz4/src/xxhash.h
+)
diff --git a/realsense-file/src/storage/realsense_file/rosbag/roslz4/include/roslz4/lz4s.h b/realsense-file/src/storage/realsense_file/rosbag/roslz4/include/roslz4/lz4s.h
new file mode 100644
index 0000000000..6d8dd271c0
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/rosbag/roslz4/include/roslz4/lz4s.h
@@ -0,0 +1,95 @@
+/*********************************************************************
+* Software License Agreement (BSD License)
+*
+*  Copyright (c) 2014, Ben Charrow
+*  All rights reserved.
+*
+*  Redistribution and use in source and binary forms, with or without
+*  modification, are permitted provided that the following conditions
+*  are met:
+*
+*   * Redistributions of source code must retain the above copyright
+*     notice, this list of conditions and the following disclaimer.
+*   * Redistributions in binary form must reproduce the above
+*     copyright notice, this list of conditions and the following
+*     disclaimer in the documentation and/or other materials provided
+*     with the distribution.
+*   * Neither the name of Willow Garage, Inc. nor the names of its
+*     contributors may be used to endorse or promote products derived
+*     from this software without specific prior written permission.
+*
+*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+*  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+*  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+*  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+*  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+*  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+*  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+*  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+*  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+*  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+*  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+*  POSSIBILITY OF SUCH DAMAGE.
+********************************************************************/
+
+#ifndef ROSLZ4_LZ4S_H
+#define ROSLZ4_LZ4S_H
+
+#include 
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Return codes
+const int ROSLZ4_MEMORY_ERROR = -5;
+const int ROSLZ4_PARAM_ERROR = -4;
+const int ROSLZ4_DATA_ERROR = -3;
+const int ROSLZ4_OUTPUT_SMALL = -2;
+const int ROSLZ4_ERROR = -1;
+const int ROSLZ4_OK = 0;
+const int ROSLZ4_STREAM_END = 2;
+
+// Actions
+const int ROSLZ4_RUN = 0;
+const int ROSLZ4_FINISH = 1;
+
+typedef struct {
+  char *input_next;
+  int input_left;
+
+  char *output_next;
+  int output_left;
+
+  int total_in;
+  int total_out;
+
+  int block_size_id;
+
+  // Internal use
+  void *state;
+} roslz4_stream;
+
+// Low level functions
+int roslz4_blockSizeFromIndex(int block_id);
+
+int roslz4_compressStart(roslz4_stream *stream, int block_size_id);
+int roslz4_compress(roslz4_stream *stream, int action);
+void roslz4_compressEnd(roslz4_stream *stream);
+
+int roslz4_decompressStart(roslz4_stream *stream);
+int roslz4_decompress(roslz4_stream *stream);
+void roslz4_decompressEnd(roslz4_stream *str);
+
+// Oneshot compression / decompression
+int roslz4_buffToBuffCompress(char *input, unsigned int input_size,
+                              char *output, unsigned int *output_size,
+                              int block_size_id);
+int roslz4_buffToBuffDecompress(char *input, unsigned int input_size,
+                                char *output, unsigned int *output_size);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // ROSLZ4_LZ4S_H
diff --git a/realsense-file/src/storage/realsense_file/rosbag/roslz4/src/_roslz4module.c b/realsense-file/src/storage/realsense_file/rosbag/roslz4/src/_roslz4module.c
new file mode 100644
index 0000000000..6be1ae99ff
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/rosbag/roslz4/src/_roslz4module.c
@@ -0,0 +1,452 @@
+/*********************************************************************
+* Software License Agreement (BSD License)
+*
+*  Copyright (c) 2014, Ben Charrow
+*  All rights reserved.
+*
+*  Redistribution and use in source and binary forms, with or without
+*  modification, are permitted provided that the following conditions
+*  are met:
+*
+*   * Redistributions of source code must retain the above copyright
+*     notice, this list of conditions and the following disclaimer.
+*   * Redistributions in binary form must reproduce the above
+*     copyright notice, this list of conditions and the following
+*     disclaimer in the documentation and/or other materials provided
+*     with the distribution.
+*   * Neither the name of Willow Garage, Inc. nor the names of its
+*     contributors may be used to endorse or promote products derived
+*     from this software without specific prior written permission.
+*
+*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+*  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+*  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+*  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+*  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+*  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+*  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+*  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+*  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+*  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+*  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+*  POSSIBILITY OF SUCH DAMAGE.
+********************************************************************/
+
+#include "Python.h"
+
+#include "roslz4/lz4s.h"
+
+struct module_state {
+  PyObject *error;
+};
+
+#if PY_MAJOR_VERSION >= 3
+#define GETSTATE(m) ((struct module_state*)PyModule_GetState(m))
+#else
+#define GETSTATE(m) (&_state)
+static struct module_state _state;
+#endif
+
+/* Taken from Python's _bz2module.c */
+static int
+grow_buffer(PyObject **buf)
+{
+    /* Expand the buffer by an amount proportional to the current size,
+       giving us amortized linear-time behavior. Use a less-than-double
+       growth factor to avoid excessive allocation. */
+    size_t size = PyBytes_GET_SIZE(*buf);
+    size_t new_size = size + (size >> 3) + 6;
+    if (new_size > size) {
+        return _PyBytes_Resize(buf, new_size);
+    } else {  /* overflow */
+        PyErr_SetString(PyExc_OverflowError,
+                        "Unable to allocate buffer - output too large");
+        return -1;
+    }
+}
+
+/*============================== LZ4Compressor ==============================*/
+
+typedef struct {
+    PyObject_HEAD
+    roslz4_stream stream;
+} LZ4Compressor;
+
+static void
+LZ4Compressor_dealloc(LZ4Compressor *self)
+{
+  roslz4_compressEnd(&self->stream);
+  Py_TYPE(self)->tp_free((PyObject*)self);
+}
+
+static int
+LZ4Compressor_init(LZ4Compressor *self, PyObject *args, PyObject *kwds)
+{
+  (void)kwds;
+  if (!PyArg_ParseTuple(args, ":__init__")) {
+    return -1;
+  }
+
+  int ret = roslz4_compressStart(&self->stream, 6);
+  if (ret != ROSLZ4_OK) {
+    PyErr_SetString(PyExc_RuntimeError, "error initializing roslz4 stream");
+    return -1;
+  }
+  return 0;
+}
+
+static PyObject *
+compress_impl(LZ4Compressor *self, Py_buffer *input, PyObject *output)
+{
+  /* Allocate output string */
+  int initial_size = roslz4_blockSizeFromIndex(self->stream.block_size_id) + 64;
+  output = PyBytes_FromStringAndSize(NULL, initial_size);
+  if (!output) {
+    if (input != NULL) { PyBuffer_Release(input); }
+    return NULL;
+  }
+
+  /* Setup stream */
+  int action;
+  if (input != NULL) {
+    action = ROSLZ4_RUN;
+    self->stream.input_next = input->buf;
+    self->stream.input_left = input->len;
+  } else {
+    action = ROSLZ4_FINISH;
+    self->stream.input_next = NULL;
+    self->stream.input_left = 0;
+  }
+  self->stream.output_next = PyBytes_AS_STRING(output);
+  self->stream.output_left = PyBytes_GET_SIZE(output);
+
+  /* Compress data */
+  int status;
+  int output_written = 0;
+  while ((action == ROSLZ4_FINISH) ||
+         (action == ROSLZ4_RUN && self->stream.input_left > 0)) {
+    int out_start = self->stream.total_out;
+    status = roslz4_compress(&self->stream, action);
+    output_written += self->stream.total_out - out_start;
+    if (status == ROSLZ4_OK) {
+      continue;
+    } else if (status == ROSLZ4_STREAM_END) {
+      break;
+    } else if (status == ROSLZ4_OUTPUT_SMALL) {
+      if (grow_buffer(&output) < 0) {
+        goto error;
+      }
+      self->stream.output_next = PyBytes_AS_STRING(output) + output_written;
+      self->stream.output_left = PyBytes_GET_SIZE(output) - output_written;
+    } else if (status == ROSLZ4_PARAM_ERROR) {
+      PyErr_SetString(PyExc_IOError, "bad block size parameter");
+      goto error;
+    } else if (status == ROSLZ4_ERROR) {
+      PyErr_SetString(PyExc_IOError, "error compressing");
+      goto error;
+    } else {
+      PyErr_Format(PyExc_RuntimeError, "unhandled return code %i", status);
+      goto error;
+    }
+  }
+
+  /* Shrink return buffer */
+  if (output_written != PyBytes_GET_SIZE(output)) {
+    _PyBytes_Resize(&output, output_written);
+  }
+
+  if (input != NULL) { PyBuffer_Release(input); }
+  return output;
+
+error:
+  if (input != NULL) { PyBuffer_Release(input); }
+  Py_XDECREF(output);
+  return NULL;
+}
+
+static PyObject *
+LZ4Compressor_compress(LZ4Compressor *self, PyObject *args)
+{
+  Py_buffer input;
+  PyObject *output = NULL;
+
+  /* TODO: Keyword argument */
+  if (!PyArg_ParseTuple(args, "s*:compress", &input)) {
+    return NULL;
+  }
+
+  return compress_impl(self, &input, output);
+}
+
+static PyObject *
+LZ4Compressor_flush(LZ4Compressor *self, PyObject *args)
+{
+  PyObject *output = NULL;
+
+  if (!PyArg_ParseTuple(args, ":flush")) {
+    return NULL;
+  }
+
+  return compress_impl(self, NULL, output);
+}
+
+
+static PyMethodDef LZ4Compressor_methods[] = {
+  {"compress", (PyCFunction)LZ4Compressor_compress, METH_VARARGS, "method doc"},
+  {"flush", (PyCFunction)LZ4Compressor_flush, METH_VARARGS, "method doc"},
+  {NULL} /* Sentinel */
+};
+
+static PyTypeObject LZ4Compressor_Type = {
+    PyVarObject_HEAD_INIT(NULL, 0)
+    "_roslz4.LZ4Compressor",           /* tp_name */
+    sizeof(LZ4Compressor),             /* tp_basicsize */
+    0,                                 /* tp_itemsize */
+    (destructor)LZ4Compressor_dealloc, /* tp_dealloc */
+    0,                                 /* tp_print */
+    0,                                 /* tp_getattr */
+    0,                                 /* tp_setattr */
+    0,                                 /* tp_compare */
+    0,                                 /* tp_repr */
+    0,                                 /* tp_as_number */
+    0,                                 /* tp_as_sequence */
+    0,                                 /* tp_as_mapping */
+    0,                                 /* tp_hash */
+    0,                                 /* tp_call */
+    0,                                 /* tp_str */
+    0,                                 /* tp_getattro */
+    0,                                 /* tp_setattro */
+    0,                                 /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT,                /* tp_flags */
+    "LZ4Compressor objects",           /* tp_doc */
+    0,                                 /* tp_traverse */
+    0,                                 /* tp_clear */
+    0,                                 /* tp_richcompare */
+    0,                                 /* tp_weaklistoffset */
+    0,                                 /* tp_iter */
+    0,                                 /* tp_iternext */
+    LZ4Compressor_methods,             /* tp_methods */
+    0,                                 /* tp_members */
+    0,                                 /* tp_getset */
+    0,                                 /* tp_base */
+    0,                                 /* tp_dict */
+    0,                                 /* tp_descr_get */
+    0,                                 /* tp_descr_set */
+    0,                                 /* tp_dictoffset */
+    (initproc)LZ4Compressor_init       /* tp_init */
+};
+
+/*============================= LZ4Decompressor =============================*/
+
+typedef struct {
+    PyObject_HEAD
+    roslz4_stream stream;
+} LZ4Decompressor;
+
+static void
+LZ4Decompressor_dealloc(LZ4Decompressor *self)
+{
+  roslz4_decompressEnd(&self->stream);
+  Py_TYPE(self)->tp_free((PyObject*)self);
+}
+
+static int
+LZ4Decompressor_init(LZ4Decompressor *self, PyObject *args, PyObject *kwds)
+{
+  (void)kwds;
+  if (!PyArg_ParseTuple(args, ":__init__")) {
+    return -1;
+  }
+
+  int ret = roslz4_decompressStart(&self->stream);
+  if (ret != ROSLZ4_OK) {
+    PyErr_SetString(PyExc_RuntimeError, "error initializing roslz4 stream");
+    return -1;
+  }
+  return 0;
+}
+
+static PyObject *
+LZ4Decompressor_decompress(LZ4Decompressor *self, PyObject *args)
+{
+  Py_buffer input;
+  PyObject *output = NULL;
+
+  /* TODO: Keyword argument */
+  if (!PyArg_ParseTuple(args, "s*:decompress", &input)) {
+    return NULL;
+  }
+
+  /* Allocate 1 output block. If header not read, use compression block size */
+  int block_size;
+  if (self->stream.block_size_id == -1 ) {
+    block_size = roslz4_blockSizeFromIndex(6);
+  } else {
+    block_size = roslz4_blockSizeFromIndex(self->stream.block_size_id);
+  }
+
+  output = PyBytes_FromStringAndSize(NULL, block_size);
+  if (!output) {
+    PyBuffer_Release(&input);
+    return NULL;
+  }
+
+  /* Setup stream */
+  self->stream.input_next = input.buf;
+  self->stream.input_left = input.len;
+  self->stream.output_next = PyBytes_AS_STRING(output);
+  self->stream.output_left = PyBytes_GET_SIZE(output);
+
+  int output_written = 0;
+  while (self->stream.input_left > 0) {
+    int out_start = self->stream.total_out;
+    int status = roslz4_decompress(&self->stream);
+    output_written += self->stream.total_out - out_start;
+    if (status == ROSLZ4_OK) {
+      continue;
+    } else if (status == ROSLZ4_STREAM_END) {
+      break;
+    } else if (status == ROSLZ4_OUTPUT_SMALL) {
+      if (grow_buffer(&output) < 0) {
+        goto error;
+      }
+      self->stream.output_next = PyBytes_AS_STRING(output) + output_written;
+      self->stream.output_left = PyBytes_GET_SIZE(output) - output_written;
+    } else if (status == ROSLZ4_ERROR) {
+      PyErr_SetString(PyExc_IOError, "error decompressing");
+      goto error;
+    } else if (status == ROSLZ4_DATA_ERROR) {
+      PyErr_SetString(PyExc_IOError, "malformed data to decompress");
+      goto error;
+    } else {
+      PyErr_Format(PyExc_RuntimeError, "unhandled return code %i", status);
+      goto error;
+    }
+  }
+
+  if (output_written != PyBytes_GET_SIZE(output)) {
+    _PyBytes_Resize(&output, output_written);
+  }
+
+  PyBuffer_Release(&input);
+  return output;
+
+error:
+  PyBuffer_Release(&input);
+  Py_XDECREF(output);
+  return NULL;
+}
+
+static PyMethodDef LZ4Decompressor_methods[] = {
+  {"decompress", (PyCFunction)LZ4Decompressor_decompress, METH_VARARGS, "method doc"},
+  {NULL} /* Sentinel */
+};
+
+static PyTypeObject LZ4Decompressor_Type = {
+    PyVarObject_HEAD_INIT(NULL, 0)
+    "_roslz4.LZ4Decompressor",           /* tp_name */
+    sizeof(LZ4Decompressor),             /* tp_basicsize */
+    0,                                   /* tp_itemsize */
+    (destructor)LZ4Decompressor_dealloc, /* tp_dealloc */
+    0,                                   /* tp_print */
+    0,                                   /* tp_getattr */
+    0,                                   /* tp_setattr */
+    0,                                   /* tp_compare */
+    0,                                   /* tp_repr */
+    0,                                   /* tp_as_number */
+    0,                                   /* tp_as_sequence */
+    0,                                   /* tp_as_mapping */
+    0,                                   /* tp_hash */
+    0,                                   /* tp_call */
+    0,                                   /* tp_str */
+    0,                                   /* tp_getattro */
+    0,                                   /* tp_setattro */
+    0,                                   /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT,                  /* tp_flags */
+    "LZ4Decompressor objects",           /* tp_doc */
+    0,                                   /* tp_traverse */
+    0,                                   /* tp_clear */
+    0,                                   /* tp_richcompare */
+    0,                                   /* tp_weaklistoffset */
+    0,                                   /* tp_iter */
+    0,                                   /* tp_iternext */
+    LZ4Decompressor_methods,             /* tp_methods */
+    0,                                   /* tp_members */
+    0,                                   /* tp_getset */
+    0,                                   /* tp_base */
+    0,                                   /* tp_dict */
+    0,                                   /* tp_descr_get */
+    0,                                   /* tp_descr_set */
+    0,                                   /* tp_dictoffset */
+    (initproc)LZ4Decompressor_init       /* tp_init */
+};
+
+
+/*========================== Module initialization ==========================*/
+
+#if PY_MAJOR_VERSION >= 3
+
+static int roslz4_traverse(PyObject *m, visitproc visit, void *arg) {
+  Py_VISIT(GETSTATE(m)->error);
+  return 0;
+}
+
+static int roslz4_clear(PyObject *m) {
+  Py_CLEAR(GETSTATE(m)->error);
+  return 0;
+}
+
+static struct PyModuleDef moduledef = {
+  PyModuleDef_HEAD_INIT,
+  "_roslz4",
+  NULL,
+  sizeof(struct module_state),
+  NULL,
+  NULL,
+  roslz4_traverse,
+  roslz4_clear,
+  NULL
+};
+#define INITERROR return NULL
+
+PyObject *
+PyInit__roslz4(void)
+
+#else
+#define INITERROR return
+
+void
+init_roslz4(void)
+#endif
+{
+  PyObject *m;
+
+  LZ4Compressor_Type.tp_new = PyType_GenericNew;
+  if (PyType_Ready(&LZ4Compressor_Type) < 0) {
+    INITERROR;
+  }
+
+  LZ4Decompressor_Type.tp_new = PyType_GenericNew;
+  if (PyType_Ready(&LZ4Decompressor_Type) < 0) {
+    INITERROR;
+  }
+
+#if PY_MAJOR_VERSION >= 3
+  m = PyModule_Create(&moduledef);
+#else
+  m = Py_InitModule("_roslz4", NULL);
+#endif
+
+  if (m == NULL) {
+    INITERROR;
+  }
+
+  Py_INCREF(&LZ4Compressor_Type);
+  PyModule_AddObject(m, "LZ4Compressor", (PyObject *)&LZ4Compressor_Type);
+  Py_INCREF(&LZ4Decompressor_Type);
+  PyModule_AddObject(m, "LZ4Decompressor", (PyObject *)&LZ4Decompressor_Type);
+
+#if PY_MAJOR_VERSION >= 3
+  return m;
+#endif
+}
diff --git a/realsense-file/src/storage/realsense_file/rosbag/roslz4/src/lz4s.c b/realsense-file/src/storage/realsense_file/rosbag/roslz4/src/lz4s.c
new file mode 100644
index 0000000000..32fb1fc8fc
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/rosbag/roslz4/src/lz4s.c
@@ -0,0 +1,624 @@
+/*********************************************************************
+* Software License Agreement (BSD License)
+*
+*  Copyright (c) 2014, Ben Charrow
+*  All rights reserved.
+*
+*  Redistribution and use in source and binary forms, with or without
+*  modification, are permitted provided that the following conditions
+*  are met:
+*
+*   * Redistributions of source code must retain the above copyright
+*     notice, this list of conditions and the following disclaimer.
+*   * Redistributions in binary form must reproduce the above
+*     copyright notice, this list of conditions and the following
+*     disclaimer in the documentation and/or other materials provided
+*     with the distribution.
+*   * Neither the name of Willow Garage, Inc. nor the names of its
+*     contributors may be used to endorse or promote products derived
+*     from this software without specific prior written permission.
+*
+*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+*  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+*  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+*  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+*  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+*  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+*  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+*  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+*  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+*  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+*  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+*  POSSIBILITY OF SUCH DAMAGE.
+********************************************************************/
+
+#include "roslz4/lz4s.h"
+
+#include "xxhash.h"
+
+#include 
+#include 
+#include 
+#include 
+
+#if 0
+#define DEBUG(...) fprintf(stderr, __VA_ARGS__)
+#else
+#define DEBUG(...)
+#endif
+
+// magic numbers
+const uint32_t kMagicNumber = 0x184D2204;
+const uint32_t kEndOfStream = 0x00000000;
+
+// Bitmasks
+const uint8_t k1Bits = 0x01;
+const uint8_t k2Bits = 0x03;
+const uint8_t k3Bits = 0x07;
+const uint8_t k4Bits = 0x0F;
+const uint8_t k8Bits = 0xFF;
+
+uint32_t readUInt32(unsigned char *buffer) {
+  return ((buffer[0] <<  0) | (buffer[1] <<  8) |
+          (buffer[2] << 16) | (buffer[3] << 24));
+}
+
+void writeUInt32(unsigned char *buffer, uint32_t val) {
+  buffer[0] = val & 0xFF;
+  buffer[1] = (val >> 8) & 0xFF;
+  buffer[2] = (val >> 16) & 0xFF;
+  buffer[3] = (val >> 24) & 0xFF;
+}
+#undef min
+int min(int a, int b) {
+  return a < b ? a : b;
+}
+
+/*========================== Low level compression ==========================*/
+
+typedef struct {
+  int block_independence_flag;
+  int block_checksum_flag;
+  int stream_checksum_flag;
+
+  char *buffer;
+  int buffer_size;
+  int buffer_offset;
+
+  int finished; // 1 if done compressing/decompressing; 0 otherwise
+
+  void* xxh32_state;
+
+  // Compression state
+  int wrote_header;
+
+  // Decompression state
+  char header[10];
+  uint32_t block_size; // Size of current block
+  int block_size_read; // # of bytes read for current block_size
+  int block_uncompressed; // 1 if block is uncompressed, 0 otherwise
+  uint32_t stream_checksum; // Storage for checksum
+  int stream_checksum_read; // # of bytes read for stream_checksum
+} stream_state;
+
+void advanceInput(roslz4_stream *str, int nbytes) {
+  str->input_next += nbytes;
+  str->input_left -= nbytes;
+  str->total_in += nbytes;
+}
+
+void advanceOutput(roslz4_stream *str, int nbytes) {
+  str->output_next += nbytes;
+  str->output_left -= nbytes;
+  str->total_out += nbytes;
+}
+
+void fillUInt32(roslz4_stream *str, uint32_t *dest_val, int *offset) {
+  char *dest = (char*) dest_val;
+  int to_copy = min(4 - *offset, str->input_left);
+  memcpy(dest + *offset, str->input_next, to_copy);
+  advanceInput(str, to_copy);
+  *offset += to_copy;
+}
+
+int writeHeader(roslz4_stream *str) {
+  if (str->output_left < 7) {
+    return ROSLZ4_OUTPUT_SMALL; // Output must have 7 bytes
+  }
+
+  stream_state *state = str->state;
+  writeUInt32((unsigned char*) str->output_next, kMagicNumber);
+  int version = 1;
+  char *out = str->output_next;
+  *(out+4)  = ((unsigned)version                        & k2Bits) << 6;
+  *(out+4) |= ((unsigned)state->block_independence_flag & k1Bits) << 5;
+  *(out+4) |= ((unsigned)state->block_checksum_flag     & k1Bits) << 4;
+  *(out+4) |= ((unsigned)state->stream_checksum_flag    & k1Bits) << 2;
+  *(out+5)  = ((unsigned)str->block_size_id             & k3Bits) << 4;
+
+  // Checksum: 2nd byte of hash of header flags
+  unsigned char checksum = (XXH32(str->output_next + 4, 2, 0) >> 8) & k8Bits;
+  *(str->output_next+6) = checksum;
+
+  advanceOutput(str, 7);
+  DEBUG("writeHeader() Put 7 bytes in output\n");
+
+  return ROSLZ4_OK;
+}
+
+int writeEOS(roslz4_stream *str) {
+  if (str->output_left < 8) {
+    return ROSLZ4_OUTPUT_SMALL;
+  }
+
+  stream_state *state = str->state;
+  state->finished = 1;
+  writeUInt32((unsigned char*) str->output_next, kEndOfStream);
+  advanceOutput(str, 4);
+
+  uint32_t stream_checksum = XXH32_digest(state->xxh32_state);
+  writeUInt32((unsigned char*) str->output_next, stream_checksum);
+  advanceOutput(str, 4);
+  state->xxh32_state = NULL;
+
+  DEBUG("writeEOS() Wrote 8 bytes to output %i\n", str->output_left);
+  return ROSLZ4_STREAM_END;
+}
+
+// If successfull, number of bytes written to output
+// If error, LZ4 return code
+int bufferToOutput(roslz4_stream *str) {
+  stream_state *state = str->state;
+  uint32_t uncomp_size = state->buffer_offset;
+  if (state->buffer_offset == 0) {
+    return 0; // No data to flush
+  } else if (str->output_left - 4 < uncomp_size) {
+    DEBUG("bufferToOutput() Not enough space left in output\n");
+    return ROSLZ4_OUTPUT_SMALL;
+  }
+
+  DEBUG("bufferToOutput() Flushing %i bytes, %i left in output\n",
+        state->buffer_offset, str->output_left);
+
+  // Shrink output by 1 to detect if data is not compressible
+  uint32_t comp_size = LZ4_compress_limitedOutput(state->buffer,
+                                                  str->output_next + 4,
+                                                  (int) state->buffer_offset,
+                                                  (int) uncomp_size - 1);
+  uint32_t wrote;
+  if (comp_size > 0) {
+    DEBUG("bufferToOutput() Compressed to %i bytes\n", comp_size);
+    // Write compressed data size
+    wrote = 4 + comp_size;
+    writeUInt32((unsigned char*)str->output_next, comp_size);
+  } else {
+    // Write uncompressed data
+    DEBUG("bufferToOutput() Can't compress, copying input\n");
+    memcpy(str->output_next + 4, state->buffer, uncomp_size);
+    // Write uncompressed data size.  Signal data is uncompressed with high
+    // order bit; won't confuse decompression because max block size is < 2GB
+    wrote = 4 + uncomp_size;
+    writeUInt32((unsigned char*) str->output_next, uncomp_size | 0x80000000);
+  }
+
+  advanceOutput(str, wrote);
+  state->buffer_offset -= uncomp_size;
+
+  DEBUG("bufferToOutput() Ate %i from buffer, wrote %i to output (%i)\n",
+        uncomp_size, wrote, str->output_left);
+  return wrote;
+}
+
+// Copy as much data as possible from input to internal buffer
+// Return number of bytes written if successful, LZ4 error code on error
+int inputToBuffer(roslz4_stream *str) {
+  stream_state *state = str->state;
+  if (str->input_left == 0 ||
+      state->buffer_size == state->buffer_offset) {
+    return 0;
+  }
+  int buffer_left = state->buffer_size - state->buffer_offset;
+  int to_copy = min(str->input_left, buffer_left);
+
+  int ret = XXH32_update(state->xxh32_state, str->input_next, to_copy);
+  if (ret == XXH_ERROR) { return ROSLZ4_ERROR; }
+
+  memcpy(state->buffer + state->buffer_offset, str->input_next, to_copy);
+  advanceInput(str, to_copy);
+  state->buffer_offset += to_copy;
+
+  DEBUG("inputToBuffer() Wrote % 5i bytes to buffer (size=% 5i)\n",
+        to_copy, state->buffer_offset);
+  return to_copy;
+}
+
+int streamStateAlloc(roslz4_stream *str) {
+  stream_state *state = (stream_state*) malloc(sizeof(stream_state));
+  if (state == NULL) {
+    return ROSLZ4_MEMORY_ERROR; // Allocation of state failed
+  }
+  str->state = state;
+
+  str->block_size_id = -1;
+  state->block_independence_flag = 1;
+  state->block_checksum_flag = 0;
+  state->stream_checksum_flag = 1;
+
+  state->finished = 0;
+
+  state->xxh32_state = XXH32_init(0);
+  state->stream_checksum = 0;
+  state->stream_checksum_read = 0;
+
+  state->wrote_header = 0;
+
+  state->buffer_offset = 0;
+  state->buffer_size = 0;
+  state->buffer = NULL;
+
+  state->block_size = 0;
+  state->block_size_read = 0;
+  state->block_uncompressed = 0;
+
+  str->total_in = 0;
+  str->total_out = 0;
+
+  return ROSLZ4_OK;
+}
+
+int streamResizeBuffer(roslz4_stream *str, int block_size_id) {
+  stream_state *state = str->state;
+  if (!(4 <= block_size_id && block_size_id <= 7)) {
+    return ROSLZ4_PARAM_ERROR; // Invalid block size
+  }
+
+  str->block_size_id = block_size_id;
+  state->buffer_offset = 0;
+  state->buffer_size = roslz4_blockSizeFromIndex(str->block_size_id);
+  state->buffer = (char*) malloc(sizeof(char) * state->buffer_size);
+  if (state->buffer == NULL) {
+    return ROSLZ4_MEMORY_ERROR; // Allocation of buffer failed
+  }
+  return ROSLZ4_OK;
+}
+
+void streamStateFree(roslz4_stream *str) {
+  stream_state *state = str->state;
+  if (state != NULL) {
+    if (state->buffer != NULL) {
+      free(state->buffer);
+    }
+    if (state->xxh32_state != NULL) {
+      XXH32_digest(state->xxh32_state);
+    }
+    free(state);
+    str->state = NULL;
+  }
+}
+
+int roslz4_blockSizeFromIndex(int block_id) {
+  return (1 << (8 + (2 * block_id)));
+}
+
+int roslz4_compressStart(roslz4_stream *str, int block_size_id) {
+  int ret = streamStateAlloc(str);
+  if (ret < 0) { return ret; }
+  return streamResizeBuffer(str, block_size_id);
+}
+
+int roslz4_compress(roslz4_stream *str, int action) {
+  int ret;
+  stream_state *state = str->state;
+  if (action != ROSLZ4_RUN && action != ROSLZ4_FINISH) {
+    return ROSLZ4_PARAM_ERROR; // Unrecognized compression action
+  } else if (state->finished) {
+    return ROSLZ4_ERROR; // Cannot call action on finished stream
+  }
+
+  if (!state->wrote_header) {
+    ret = writeHeader(str);
+    if (ret < 0) { return ret; }
+    state->wrote_header = 1;
+  }
+
+  // Copy input to internal buffer, compressing when full or finishing stream
+  int read = 0, wrote = 0;
+  do {
+    read = inputToBuffer(str);
+    if (read < 0) { return read; }
+
+    wrote = 0;
+    if (action == ROSLZ4_FINISH || state->buffer_offset == state->buffer_size) {
+      wrote = bufferToOutput(str);
+      if (wrote < 0) { return wrote; }
+    }
+  } while (read > 0 || wrote > 0);
+
+  // Signal end of stream if finishing up, otherwise done
+  if (action == ROSLZ4_FINISH) {
+    return writeEOS(str);
+  } else {
+    return ROSLZ4_OK;
+  }
+}
+
+void roslz4_compressEnd(roslz4_stream *str) {
+  streamStateFree(str);
+}
+
+/*========================= Low level decompression =========================*/
+
+int roslz4_decompressStart(roslz4_stream *str) {
+  return streamStateAlloc(str);
+  // Can't allocate internal buffer, block size is unknown until header is read
+}
+
+// Return 1 if header is present, 0 if more data is needed,
+// LZ4 error code (< 0) if error
+int processHeader(roslz4_stream *str) {
+  stream_state *state = str->state;
+  if (str->total_in >= 7) {
+    return 1;
+  }
+  // Populate header buffer
+  int to_copy = min(7 - str->total_in, str->input_left);
+  memcpy(state->header + str->total_in, str->input_next, to_copy);
+  advanceInput(str, to_copy);
+  if (str->total_in < 7) {
+    return 0;
+  }
+
+  // Parse header buffer
+  unsigned char *header = (unsigned char*) state->header;
+  uint32_t magic_number = readUInt32(header);
+  if (magic_number != kMagicNumber) {
+    return ROSLZ4_DATA_ERROR; // Stream does not start with magic number
+  }
+  // Check descriptor flags
+  int version                 = (header[4] >> 6) & k2Bits;
+  int block_independence_flag = (header[4] >> 5) & k1Bits;
+  int block_checksum_flag     = (header[4] >> 4) & k1Bits;
+  int stream_size_flag        = (header[4] >> 3) & k1Bits;
+  int stream_checksum_flag    = (header[4] >> 2) & k1Bits;
+  int reserved1               = (header[4] >> 1) & k1Bits;
+  int preset_dictionary_flag  = (header[4] >> 0) & k1Bits;
+
+  int reserved2               = (header[5] >> 7) & k1Bits;
+  int block_max_id            = (header[5] >> 4) & k3Bits;
+  int reserved3               = (header[5] >> 0) & k4Bits;
+
+  // LZ4 standard requirements
+  if (version != 1) {
+    return ROSLZ4_DATA_ERROR; // Wrong version number
+  }
+  if (reserved1 != 0 || reserved2 != 0 || reserved3 != 0) {
+    return ROSLZ4_DATA_ERROR; // Reserved bits must be 0
+  }
+  if (!(4 <= block_max_id && block_max_id <= 7)) {
+    return ROSLZ4_DATA_ERROR; // Invalid block size
+  }
+
+  // Implementation requirements
+  if (stream_size_flag != 0) {
+    return ROSLZ4_DATA_ERROR; // Stream size not supported
+  }
+  if (preset_dictionary_flag != 0) {
+    return ROSLZ4_DATA_ERROR; // Dictionary not supported
+  }
+  if (block_independence_flag != 1) {
+    return ROSLZ4_DATA_ERROR; // Block dependence not supported
+  }
+  if (block_checksum_flag != 0) {
+    return ROSLZ4_DATA_ERROR; // Block checksums not supported
+  }
+  if (stream_checksum_flag != 1) {
+    return ROSLZ4_DATA_ERROR; // Must have stream checksum
+  }
+
+  int header_checksum = (XXH32(header + 4, 2, 0) >> 8) & k8Bits;
+  int stored_header_checksum = (header[6] >> 0) & k8Bits;
+  if (header_checksum != stored_header_checksum) {
+    return ROSLZ4_DATA_ERROR; // Header checksum doesn't match
+  }
+
+  int ret = streamResizeBuffer(str, block_max_id);
+  if (ret == ROSLZ4_OK) {
+    return 1;
+  } else {
+    return ret;
+  }
+}
+
+// Read block size, return 1 if value is stored in state->block_size 0 otherwise
+int readBlockSize(roslz4_stream *str) {
+  stream_state *state = str->state;
+  if (state->block_size_read < 4) {
+    fillUInt32(str, &state->block_size, &state->block_size_read);
+    if (state->block_size_read == 4) {
+      state->block_size = readUInt32((unsigned char*)&state->block_size);
+      state->block_uncompressed = ((unsigned)state->block_size >> 31) & k1Bits;
+      state->block_size &= 0x7FFFFFFF;
+      DEBUG("readBlockSize() Block size = %i uncompressed = %i\n",
+            state->block_size, state->block_uncompressed);
+      return 1;
+    } else {
+      return 0;
+    }
+  }
+  return 1;
+}
+
+// Copy at most one blocks worth of data from input to internal buffer.
+// Return 1 if whole block has been read, 0 if not, LZ4 error otherwise
+int readBlock(roslz4_stream *str) {
+  stream_state *state = str->state;
+  if (state->block_size_read != 4 || state->block_size == kEndOfStream) {
+    return ROSLZ4_ERROR;
+  }
+
+  int block_left = state->block_size - state->buffer_offset;
+  int to_copy = min(str->input_left, block_left);
+  memcpy(state->buffer + state->buffer_offset, str->input_next, to_copy);
+  advanceInput(str, to_copy);
+  state->buffer_offset += to_copy;
+  DEBUG("readBlock() Read %i bytes from input (block = %i/%i)\n",
+        to_copy, state->buffer_offset, state->block_size);
+  return state->buffer_offset == state->block_size;
+}
+
+int decompressBlock(roslz4_stream *str) {
+  stream_state *state = str->state;
+  if (state->block_size_read != 4 || state->block_size != state->buffer_offset) {
+    // Internal error: Can't decompress block, it's not in buffer
+    return ROSLZ4_ERROR;
+  }
+
+  if (state->block_uncompressed) {
+    if (str->output_left >= state->block_size) {
+      memcpy(str->output_next, state->buffer, state->block_size);
+      int ret = XXH32_update(state->xxh32_state, str->output_next,
+                             state->block_size);
+      if (ret == XXH_ERROR) { return ROSLZ4_ERROR; }
+      advanceOutput(str, state->block_size);
+      state->block_size_read = 0;
+      state->buffer_offset = 0;
+      return ROSLZ4_OK;
+    } else {
+      return ROSLZ4_OUTPUT_SMALL;
+    }
+  } else {
+    int decomp_size;
+    decomp_size = LZ4_decompress_safe(state->buffer, str->output_next,
+                                      state->block_size, str->output_left);
+    if (decomp_size < 0) {
+      if (str->output_left >= state->buffer_size) {
+        return ROSLZ4_DATA_ERROR; // Must be a problem with the data stream
+      } else {
+        // Data error or output is small; increase output to disambiguate
+        return ROSLZ4_OUTPUT_SMALL;
+      }
+    } else {
+      int ret = XXH32_update(state->xxh32_state, str->output_next, decomp_size);
+      if (ret == XXH_ERROR) { return ROSLZ4_ERROR; }
+      advanceOutput(str, decomp_size);
+      state->block_size_read = 0;
+      state->buffer_offset = 0;
+      return ROSLZ4_OK;
+    }
+  }
+}
+
+int readChecksum(roslz4_stream *str) {
+  stream_state *state = str->state;
+  fillUInt32(str, &state->stream_checksum, &state->stream_checksum_read);
+  if (state->stream_checksum_read == 4) {
+    state->finished = 1;
+    state->stream_checksum = readUInt32((unsigned char*)&state->stream_checksum);
+    uint32_t checksum = XXH32_digest(state->xxh32_state);
+    state->xxh32_state = NULL;
+    if (checksum == state->stream_checksum) {
+      return ROSLZ4_STREAM_END;
+    } else {
+      return ROSLZ4_DATA_ERROR;
+    }
+  }
+  return ROSLZ4_OK;
+}
+
+int roslz4_decompress(roslz4_stream *str) {
+  stream_state *state = str->state;
+  if (state->finished) {
+    return ROSLZ4_ERROR; // Already reached end of stream
+  }
+
+  // Return if header isn't present or error was encountered
+  int ret = processHeader(str);
+  if (ret <= 0) {
+    return ret;
+  }
+
+  // Read in blocks and decompress them as long as there's data to be processed
+  while (str->input_left > 0) {
+    ret = readBlockSize(str);
+    if (ret == 0) { return ROSLZ4_OK; }
+
+    if (state->block_size == kEndOfStream) {
+      return readChecksum(str);
+    }
+
+    ret = readBlock(str);
+    if (ret == 0) { return ROSLZ4_OK; }
+    else if (ret < 0) { return ret; }
+
+    ret = decompressBlock(str);
+    if (ret < 0) { return ret; }
+  }
+  return ROSLZ4_OK;
+}
+
+void roslz4_decompressEnd(roslz4_stream *str) {
+  streamStateFree(str);
+}
+
+/*=================== Oneshot compression / decompression ===================*/
+
+int roslz4_buffToBuffCompress(char *input, unsigned int input_size,
+                              char *output, unsigned int *output_size,
+                              int block_size_id) {
+  roslz4_stream stream;
+  stream.input_next = input;
+  stream.input_left = input_size;
+  stream.output_next = output;
+  stream.output_left = *output_size;
+
+  int ret;
+  ret = roslz4_compressStart(&stream, block_size_id);
+  if (ret != ROSLZ4_OK) { return ret; }
+
+  while (stream.input_left > 0 && ret != ROSLZ4_STREAM_END) {
+    ret = roslz4_compress(&stream, ROSLZ4_FINISH);
+    if (ret == ROSLZ4_ERROR || ret == ROSLZ4_OUTPUT_SMALL) {
+      roslz4_compressEnd(&stream);
+      return ret;
+    }
+  }
+
+  *output_size = *output_size - stream.output_left;
+  roslz4_compressEnd(&stream);
+
+  if (stream.input_left == 0 && ret == ROSLZ4_STREAM_END) {
+    return ROSLZ4_OK; // Success
+  } else {
+    return ROSLZ4_ERROR; // User did not provide exact buffer
+  }
+}
+
+int roslz4_buffToBuffDecompress(char *input, unsigned int input_size,
+                                char *output, unsigned int *output_size) {
+  roslz4_stream stream;
+  stream.input_next = input;
+  stream.input_left = input_size;
+  stream.output_next = output;
+  stream.output_left = *output_size;
+
+  int ret;
+  ret = roslz4_decompressStart(&stream);
+  if (ret != ROSLZ4_OK) { return ret; }
+
+  while (stream.input_left > 0 && ret != ROSLZ4_STREAM_END) {
+    ret = roslz4_decompress(&stream);
+    if (ret < 0) {
+      roslz4_decompressEnd(&stream);
+      return ret;
+    }
+  }
+
+  *output_size = *output_size - stream.output_left;
+  roslz4_decompressEnd(&stream);
+
+  if (stream.input_left == 0 && ret == ROSLZ4_STREAM_END) {
+    return ROSLZ4_OK; // Success
+  } else {
+    return ROSLZ4_ERROR; // User did not provide exact buffer
+  }
+}
diff --git a/realsense-file/src/storage/realsense_file/rosbag/roslz4/src/xxhash.c b/realsense-file/src/storage/realsense_file/rosbag/roslz4/src/xxhash.c
new file mode 100644
index 0000000000..8304ec21c0
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/rosbag/roslz4/src/xxhash.c
@@ -0,0 +1,475 @@
+/*
+xxHash - Fast Hash algorithm
+Copyright (C) 2012-2014, Yann Collet.
+BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+* Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+* Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the following disclaimer
+in the documentation and/or other materials provided with the
+distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+You can contact the author at :
+- xxHash source repository : http://code.google.com/p/xxhash/
+*/
+
+
+//**************************************
+// Tuning parameters
+//**************************************
+// Unaligned memory access is automatically enabled for "common" CPU, such as x86.
+// For others CPU, the compiler will be more cautious, and insert extra code to ensure aligned access is respected.
+// If you know your target CPU supports unaligned memory access, you want to force this option manually to improve performance.
+// You can also enable this parameter if you know your input data will always be aligned (boundaries of 4, for U32).
+#if defined(__ARM_FEATURE_UNALIGNED) || defined(__i386) || defined(_M_IX86) || defined(__x86_64__) || defined(_M_X64)
+#  define XXH_USE_UNALIGNED_ACCESS 1
+#endif
+
+// XXH_ACCEPT_NULL_INPUT_POINTER :
+// If the input pointer is a null pointer, xxHash default behavior is to trigger a memory access error, since it is a bad pointer.
+// When this option is enabled, xxHash output for null input pointers will be the same as a null-length input.
+// This option has a very small performance cost (only measurable on small inputs).
+// By default, this option is disabled. To enable it, uncomment below define :
+//#define XXH_ACCEPT_NULL_INPUT_POINTER 1
+
+// XXH_FORCE_NATIVE_FORMAT :
+// By default, xxHash library provides endian-independant Hash values, based on little-endian convention.
+// Results are therefore identical for little-endian and big-endian CPU.
+// This comes at a performance cost for big-endian CPU, since some swapping is required to emulate little-endian format.
+// Should endian-independance be of no importance for your application, you may set the #define below to 1.
+// It will improve speed for Big-endian CPU.
+// This option has no impact on Little_Endian CPU.
+#define XXH_FORCE_NATIVE_FORMAT 0
+
+
+//**************************************
+// Compiler Specific Options
+//**************************************
+// Disable some Visual warning messages
+#ifdef _MSC_VER  // Visual Studio
+#  pragma warning(disable : 4127)      // disable: C4127: conditional expression is constant
+#endif
+
+#ifdef _MSC_VER    // Visual Studio
+#  define FORCE_INLINE static __forceinline
+#else 
+#  ifdef __GNUC__
+#    define FORCE_INLINE static inline __attribute__((always_inline))
+#  else
+#    define FORCE_INLINE static inline
+#  endif
+#endif
+
+
+//**************************************
+// Includes & Memory related functions
+//**************************************
+#include "xxhash.h"
+// Modify the local functions below should you wish to use some other memory related routines
+// for malloc(), free()
+#include 
+FORCE_INLINE void* XXH_malloc(size_t s) { return malloc(s); }
+FORCE_INLINE void  XXH_free  (void* p)  { free(p); }
+// for memcpy()
+#include 
+FORCE_INLINE void* XXH_memcpy(void* dest, const void* src, size_t size) { return memcpy(dest,src,size); }
+
+
+//**************************************
+// Basic Types
+//**************************************
+#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L   // C99
+# include 
+  typedef uint8_t  BYTE;
+  typedef uint16_t U16;
+  typedef uint32_t U32;
+  typedef  int32_t S32;
+  typedef uint64_t U64;
+#else
+  typedef unsigned char      BYTE;
+  typedef unsigned short     U16;
+  typedef unsigned int       U32;
+  typedef   signed int       S32;
+  typedef unsigned long long U64;
+#endif
+
+#if defined(__GNUC__)  && !defined(XXH_USE_UNALIGNED_ACCESS)
+#  define _PACKED __attribute__ ((packed))
+#else
+#  define _PACKED
+#endif
+
+#if !defined(XXH_USE_UNALIGNED_ACCESS) && !defined(__GNUC__)
+#  ifdef __IBMC__
+#    pragma pack(1)
+#  else
+#    pragma pack(push, 1)
+#  endif
+#endif
+
+typedef struct _U32_S { U32 v; } _PACKED U32_S;
+
+#if !defined(XXH_USE_UNALIGNED_ACCESS) && !defined(__GNUC__)
+#  pragma pack(pop)
+#endif
+
+#define A32(x) (((U32_S *)(x))->v)
+
+
+//***************************************
+// Compiler-specific Functions and Macros
+//***************************************
+#define GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)
+
+// Note : although _rotl exists for minGW (GCC under windows), performance seems poor
+#if defined(_MSC_VER)
+#  define XXH_rotl32(x,r) _rotl(x,r)
+#else
+#  define XXH_rotl32(x,r) ((x << r) | (x >> (32 - r)))
+#endif
+
+#if defined(_MSC_VER)     // Visual Studio
+#  define XXH_swap32 _byteswap_ulong
+#elif GCC_VERSION >= 403
+#  define XXH_swap32 __builtin_bswap32
+#else
+static inline U32 XXH_swap32 (U32 x) {
+    return  ((x << 24) & 0xff000000 ) |
+        ((x <<  8) & 0x00ff0000 ) |
+        ((x >>  8) & 0x0000ff00 ) |
+        ((x >> 24) & 0x000000ff );}
+#endif
+
+
+//**************************************
+// Constants
+//**************************************
+#define PRIME32_1   2654435761U
+#define PRIME32_2   2246822519U
+#define PRIME32_3   3266489917U
+#define PRIME32_4    668265263U
+#define PRIME32_5    374761393U
+
+
+//**************************************
+// Architecture Macros
+//**************************************
+typedef enum { XXH_bigEndian=0, XXH_littleEndian=1 } XXH_endianess;
+#ifndef XXH_CPU_LITTLE_ENDIAN   // It is possible to define XXH_CPU_LITTLE_ENDIAN externally, for example using a compiler switch
+    static const int one = 1;
+#   define XXH_CPU_LITTLE_ENDIAN   (*(char*)(&one))
+#endif
+
+
+//**************************************
+// Macros
+//**************************************
+#define XXH_STATIC_ASSERT(c)   { enum { XXH_static_assert = 1/(!!(c)) }; }    // use only *after* variable declarations
+
+
+//****************************
+// Memory reads
+//****************************
+typedef enum { XXH_aligned, XXH_unaligned } XXH_alignment;
+
+FORCE_INLINE U32 XXH_readLE32_align(const U32* ptr, XXH_endianess endian, XXH_alignment align)
+{ 
+    if (align==XXH_unaligned)
+        return endian==XXH_littleEndian ? A32(ptr) : XXH_swap32(A32(ptr)); 
+    else
+        return endian==XXH_littleEndian ? *ptr : XXH_swap32(*ptr); 
+}
+
+FORCE_INLINE U32 XXH_readLE32(const U32* ptr, XXH_endianess endian) { return XXH_readLE32_align(ptr, endian, XXH_unaligned); }
+
+
+//****************************
+// Simple Hash Functions
+//****************************
+FORCE_INLINE U32 XXH32_endian_align(const void* input, int len, U32 seed, XXH_endianess endian, XXH_alignment align)
+{
+    const BYTE* p = (const BYTE*)input;
+    const BYTE* const bEnd = p + len;
+    U32 h32;
+
+#ifdef XXH_ACCEPT_NULL_INPUT_POINTER
+    if (p==NULL) { len=0; p=(const BYTE*)(size_t)16; }
+#endif
+
+    if (len>=16)
+    {
+        const BYTE* const limit = bEnd - 16;
+        U32 v1 = seed + PRIME32_1 + PRIME32_2;
+        U32 v2 = seed + PRIME32_2;
+        U32 v3 = seed + 0;
+        U32 v4 = seed - PRIME32_1;
+
+        do
+        {
+            v1 += XXH_readLE32_align((const U32*)p, endian, align) * PRIME32_2; v1 = XXH_rotl32(v1, 13); v1 *= PRIME32_1; p+=4;
+            v2 += XXH_readLE32_align((const U32*)p, endian, align) * PRIME32_2; v2 = XXH_rotl32(v2, 13); v2 *= PRIME32_1; p+=4;
+            v3 += XXH_readLE32_align((const U32*)p, endian, align) * PRIME32_2; v3 = XXH_rotl32(v3, 13); v3 *= PRIME32_1; p+=4;
+            v4 += XXH_readLE32_align((const U32*)p, endian, align) * PRIME32_2; v4 = XXH_rotl32(v4, 13); v4 *= PRIME32_1; p+=4;
+        } while (p<=limit);
+
+        h32 = XXH_rotl32(v1, 1) + XXH_rotl32(v2, 7) + XXH_rotl32(v3, 12) + XXH_rotl32(v4, 18);
+    }
+    else
+    {
+        h32  = seed + PRIME32_5;
+    }
+
+    h32 += (U32) len;
+
+    while (p<=bEnd-4)
+    {
+        h32 += XXH_readLE32_align((const U32*)p, endian, align) * PRIME32_3;
+        h32  = XXH_rotl32(h32, 17) * PRIME32_4 ;
+        p+=4;
+    }
+
+    while (p> 15;
+    h32 *= PRIME32_2;
+    h32 ^= h32 >> 13;
+    h32 *= PRIME32_3;
+    h32 ^= h32 >> 16;
+
+    return h32;
+}
+
+
+U32 XXH32(const void* input, int len, U32 seed)
+{
+#if 0
+    // Simple version, good for code maintenance, but unfortunately slow for small inputs
+    void* state = XXH32_init(seed);
+    XXH32_update(state, input, len);
+    return XXH32_digest(state);
+#else
+    XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN;
+
+#  if !defined(XXH_USE_UNALIGNED_ACCESS)
+    if ((((size_t)input) & 3))   // Input is aligned, let's leverage the speed advantage
+    {
+        if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
+            return XXH32_endian_align(input, len, seed, XXH_littleEndian, XXH_aligned);
+        else
+            return XXH32_endian_align(input, len, seed, XXH_bigEndian, XXH_aligned);
+    }
+#  endif
+
+    if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
+        return XXH32_endian_align(input, len, seed, XXH_littleEndian, XXH_unaligned);
+    else
+        return XXH32_endian_align(input, len, seed, XXH_bigEndian, XXH_unaligned);
+#endif
+}
+
+
+//****************************
+// Advanced Hash Functions
+//****************************
+
+struct XXH_state32_t
+{
+    U64 total_len;
+    U32 seed;
+    U32 v1;
+    U32 v2;
+    U32 v3;
+    U32 v4;
+    int memsize;
+    char memory[16];
+};
+
+
+int XXH32_sizeofState() 
+{
+    XXH_STATIC_ASSERT(XXH32_SIZEOFSTATE >= sizeof(struct XXH_state32_t));   // A compilation error here means XXH32_SIZEOFSTATE is not large enough
+    return sizeof(struct XXH_state32_t); 
+}
+
+
+XXH_errorcode XXH32_resetState(void* state_in, U32 seed)
+{ 
+    struct XXH_state32_t * state = (struct XXH_state32_t *) state_in;
+    state->seed = seed;
+    state->v1 = seed + PRIME32_1 + PRIME32_2;
+    state->v2 = seed + PRIME32_2;
+    state->v3 = seed + 0;
+    state->v4 = seed - PRIME32_1;
+    state->total_len = 0;
+    state->memsize = 0;
+    return XXH_OK;
+}
+
+
+void* XXH32_init (U32 seed)
+{
+    void* state = XXH_malloc (sizeof(struct XXH_state32_t));
+    XXH32_resetState(state, seed);
+    return state;
+}
+
+
+FORCE_INLINE XXH_errorcode XXH32_update_endian (void* state_in, const void* input, int len, XXH_endianess endian)
+{
+    struct XXH_state32_t * state = (struct XXH_state32_t *) state_in;
+    const BYTE* p = (const BYTE*)input;
+    const BYTE* const bEnd = p + len;
+
+#ifdef XXH_ACCEPT_NULL_INPUT_POINTER
+    if (input==NULL) return XXH_ERROR;
+#endif
+
+    state->total_len += len;
+
+    if (state->memsize + len < 16)   // fill in tmp buffer
+    {
+        XXH_memcpy(state->memory + state->memsize, input, len);
+        state->memsize +=  len;
+        return XXH_OK;
+    }
+
+    if (state->memsize)   // some data left from previous update
+    {
+        XXH_memcpy(state->memory + state->memsize, input, 16-state->memsize);
+        {
+            const U32* p32 = (const U32*)state->memory;
+            state->v1 += XXH_readLE32(p32, endian) * PRIME32_2; state->v1 = XXH_rotl32(state->v1, 13); state->v1 *= PRIME32_1; p32++;
+            state->v2 += XXH_readLE32(p32, endian) * PRIME32_2; state->v2 = XXH_rotl32(state->v2, 13); state->v2 *= PRIME32_1; p32++; 
+            state->v3 += XXH_readLE32(p32, endian) * PRIME32_2; state->v3 = XXH_rotl32(state->v3, 13); state->v3 *= PRIME32_1; p32++;
+            state->v4 += XXH_readLE32(p32, endian) * PRIME32_2; state->v4 = XXH_rotl32(state->v4, 13); state->v4 *= PRIME32_1; p32++;
+        }
+        p += 16-state->memsize;
+        state->memsize = 0;
+    }
+
+    if (p <= bEnd-16)
+    {
+        const BYTE* const limit = bEnd - 16;
+        U32 v1 = state->v1;
+        U32 v2 = state->v2;
+        U32 v3 = state->v3;
+        U32 v4 = state->v4;
+
+        do
+        {
+            v1 += XXH_readLE32((const U32*)p, endian) * PRIME32_2; v1 = XXH_rotl32(v1, 13); v1 *= PRIME32_1; p+=4;
+            v2 += XXH_readLE32((const U32*)p, endian) * PRIME32_2; v2 = XXH_rotl32(v2, 13); v2 *= PRIME32_1; p+=4;
+            v3 += XXH_readLE32((const U32*)p, endian) * PRIME32_2; v3 = XXH_rotl32(v3, 13); v3 *= PRIME32_1; p+=4;
+            v4 += XXH_readLE32((const U32*)p, endian) * PRIME32_2; v4 = XXH_rotl32(v4, 13); v4 *= PRIME32_1; p+=4;
+        } while (p<=limit);
+
+        state->v1 = v1;
+        state->v2 = v2;
+        state->v3 = v3;
+        state->v4 = v4;
+    }
+
+    if (p < bEnd)
+    {
+        XXH_memcpy(state->memory, p, bEnd-p);
+        state->memsize = (int)(bEnd-p);
+    }
+
+    return XXH_OK;
+}
+
+XXH_errorcode XXH32_update (void* state_in, const void* input, int len)
+{
+    XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN;
+    
+    if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
+        return XXH32_update_endian(state_in, input, len, XXH_littleEndian);
+    else
+        return XXH32_update_endian(state_in, input, len, XXH_bigEndian);
+}
+
+
+
+FORCE_INLINE U32 XXH32_intermediateDigest_endian (void* state_in, XXH_endianess endian)
+{
+    struct XXH_state32_t * state = (struct XXH_state32_t *) state_in;
+    const BYTE * p = (const BYTE*)state->memory;
+    BYTE* bEnd = (BYTE*)state->memory + state->memsize;
+    U32 h32;
+
+    if (state->total_len >= 16)
+    {
+        h32 = XXH_rotl32(state->v1, 1) + XXH_rotl32(state->v2, 7) + XXH_rotl32(state->v3, 12) + XXH_rotl32(state->v4, 18);
+    }
+    else
+    {
+        h32  = state->seed + PRIME32_5;
+    }
+
+    h32 += (U32) state->total_len;
+
+    while (p<=bEnd-4)
+    {
+        h32 += XXH_readLE32((const U32*)p, endian) * PRIME32_3;
+        h32  = XXH_rotl32(h32, 17) * PRIME32_4;
+        p+=4;
+    }
+
+    while (p> 15;
+    h32 *= PRIME32_2;
+    h32 ^= h32 >> 13;
+    h32 *= PRIME32_3;
+    h32 ^= h32 >> 16;
+
+    return h32;
+}
+
+
+U32 XXH32_intermediateDigest (void* state_in)
+{
+    XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN;
+    
+    if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
+        return XXH32_intermediateDigest_endian(state_in, XXH_littleEndian);
+    else
+        return XXH32_intermediateDigest_endian(state_in, XXH_bigEndian);
+}
+
+
+U32 XXH32_digest (void* state_in)
+{
+    U32 h32 = XXH32_intermediateDigest(state_in);
+
+    XXH_free(state_in);
+
+    return h32;
+}
diff --git a/realsense-file/src/storage/realsense_file/rosbag/roslz4/src/xxhash.h b/realsense-file/src/storage/realsense_file/rosbag/roslz4/src/xxhash.h
new file mode 100644
index 0000000000..a319bcc9b3
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/rosbag/roslz4/src/xxhash.h
@@ -0,0 +1,164 @@
+/*
+   xxHash - Fast Hash algorithm
+   Header File
+   Copyright (C) 2012-2014, Yann Collet.
+   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+  
+       * Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+       * Redistributions in binary form must reproduce the above
+   copyright notice, this list of conditions and the following disclaimer
+   in the documentation and/or other materials provided with the
+   distribution.
+  
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+   You can contact the author at :
+   - xxHash source repository : http://code.google.com/p/xxhash/
+*/
+
+/* Notice extracted from xxHash homepage :
+
+xxHash is an extremely fast Hash algorithm, running at RAM speed limits.
+It also successfully passes all tests from the SMHasher suite.
+
+Comparison (single thread, Windows Seven 32 bits, using SMHasher on a Core 2 Duo @3GHz)
+
+Name            Speed       Q.Score   Author
+xxHash          5.4 GB/s     10
+CrapWow         3.2 GB/s      2       Andrew
+MumurHash 3a    2.7 GB/s     10       Austin Appleby
+SpookyHash      2.0 GB/s     10       Bob Jenkins
+SBox            1.4 GB/s      9       Bret Mulvey
+Lookup3         1.2 GB/s      9       Bob Jenkins
+SuperFastHash   1.2 GB/s      1       Paul Hsieh
+CityHash64      1.05 GB/s    10       Pike & Alakuijala
+FNV             0.55 GB/s     5       Fowler, Noll, Vo
+CRC32           0.43 GB/s     9
+MD5-32          0.33 GB/s    10       Ronald L. Rivest
+SHA1-32         0.28 GB/s    10
+
+Q.Score is a measure of quality of the hash function. 
+It depends on successfully passing SMHasher test set. 
+10 is a perfect score.
+*/
+
+#pragma once
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+
+//****************************
+// Type
+//****************************
+typedef enum { XXH_OK=0, XXH_ERROR } XXH_errorcode;
+
+
+
+//****************************
+// Simple Hash Functions
+//****************************
+
+unsigned int XXH32 (const void* input, int len, unsigned int seed);
+
+/*
+XXH32() :
+    Calculate the 32-bits hash of sequence of length "len" stored at memory address "input".
+    The memory between input & input+len must be valid (allocated and read-accessible).
+    "seed" can be used to alter the result predictably.
+    This function successfully passes all SMHasher tests.
+    Speed on Core 2 Duo @ 3 GHz (single thread, SMHasher benchmark) : 5.4 GB/s
+    Note that "len" is type "int", which means it is limited to 2^31-1.
+    If your data is larger, use the advanced functions below.
+*/
+
+
+
+//****************************
+// Advanced Hash Functions
+//****************************
+
+void*         XXH32_init   (unsigned int seed);
+XXH_errorcode XXH32_update (void* state, const void* input, int len);
+unsigned int  XXH32_digest (void* state);
+
+/*
+These functions calculate the xxhash of an input provided in several small packets,
+as opposed to an input provided as a single block.
+
+It must be started with :
+void* XXH32_init()
+The function returns a pointer which holds the state of calculation.
+
+This pointer must be provided as "void* state" parameter for XXH32_update().
+XXH32_update() can be called as many times as necessary.
+The user must provide a valid (allocated) input.
+The function returns an error code, with 0 meaning OK, and any other value meaning there is an error.
+Note that "len" is type "int", which means it is limited to 2^31-1. 
+If your data is larger, it is recommended to chunk your data into blocks 
+of size for example 2^30 (1GB) to avoid any "int" overflow issue.
+
+Finally, you can end the calculation anytime, by using XXH32_digest().
+This function returns the final 32-bits hash.
+You must provide the same "void* state" parameter created by XXH32_init().
+Memory will be freed by XXH32_digest().
+*/
+
+
+int           XXH32_sizeofState();
+XXH_errorcode XXH32_resetState(void* state, unsigned int seed);
+
+#define       XXH32_SIZEOFSTATE 48
+typedef struct { long long ll[(XXH32_SIZEOFSTATE+(sizeof(long long)-1))/sizeof(long long)]; } XXH32_stateSpace_t;
+/*
+These functions allow user application to make its own allocation for state.
+
+XXH32_sizeofState() is used to know how much space must be allocated for the xxHash 32-bits state.
+Note that the state must be aligned to access 'long long' fields. Memory must be allocated and referenced by a pointer.
+This pointer must then be provided as 'state' into XXH32_resetState(), which initializes the state.
+
+For static allocation purposes (such as allocation on stack, or freestanding systems without malloc()),
+use the structure XXH32_stateSpace_t, which will ensure that memory space is large enough and correctly aligned to access 'long long' fields.
+*/
+
+
+unsigned int XXH32_intermediateDigest (void* state);
+/*
+This function does the same as XXH32_digest(), generating a 32-bit hash,
+but preserve memory context.
+This way, it becomes possible to generate intermediate hashes, and then continue feeding data with XXH32_update().
+To free memory context, use XXH32_digest(), or free().
+*/
+
+
+
+//****************************
+// Deprecated function names
+//****************************
+// The following translations are provided to ease code transition
+// You are encouraged to no longer this function names
+#define XXH32_feed   XXH32_update
+#define XXH32_result XXH32_digest
+#define XXH32_getIntermediateResult XXH32_intermediateDigest
+
+
+
+#if defined (__cplusplus)
+}
+#endif
diff --git a/realsense-file/src/storage/realsense_file/rosbag/rostime/config.cmake b/realsense-file/src/storage/realsense_file/rosbag/rostime/config.cmake
new file mode 100644
index 0000000000..9489ee3918
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/rosbag/rostime/config.cmake
@@ -0,0 +1,17 @@
+cmake_minimum_required(VERSION 2.8.3)
+
+set(HEADER_FILES_ROSTIME
+  rosbag/rostime/include/ros/duration.h
+  rosbag/rostime/include/ros/impl
+  rosbag/rostime/include/ros/rate.h
+  rosbag/rostime/include/ros/rostime_decl.h
+  rosbag/rostime/include/ros/time.h
+  rosbag/rostime/include/ros/impl/time.h
+  rosbag/rostime/include/ros/impl/duration.h
+)
+
+set(SOURCE_FILES_ROSTIME
+  rosbag/rostime/src/duration.cpp
+  rosbag/rostime/src/rate.cpp
+  rosbag/rostime/src/time.cpp
+)
diff --git a/realsense-file/src/storage/realsense_file/rosbag/rostime/include/ros/duration.h b/realsense-file/src/storage/realsense_file/rosbag/rostime/include/ros/duration.h
new file mode 100644
index 0000000000..8485fd8f5f
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/rosbag/rostime/include/ros/duration.h
@@ -0,0 +1,164 @@
+/*********************************************************************
+* Software License Agreement (BSD License)
+*
+*  Copyright (c) 2008, Willow Garage, Inc.
+*  All rights reserved.
+*
+*  Redistribution and use in source and binary forms, with or without
+*  modification, are permitted provided that the following conditions
+*  are met:
+*
+*   * Redistributions of source code must retain the above copyright
+*     notice, this list of conditions and the following disclaimer.
+*   * Redistributions in binary form must reproduce the above
+*     copyright notice, this list of conditions and the following
+*     disclaimer in the documentation and/or other materials provided
+*     with the distribution.
+*   * Neither the name of Willow Garage, Inc. nor the names of its
+*     contributors may be used to endorse or promote products derived
+*     from this software without specific prior written permission.
+*
+*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+*  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+*  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+*  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+*  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+*  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+*  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+*  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+*  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+*  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+*  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+*  POSSIBILITY OF SUCH DAMAGE.
+*********************************************************************/
+
+#ifndef ROS_DURATION_H
+#define ROS_DURATION_H
+
+/*********************************************************************
+ ** Pragmas
+ *********************************************************************/
+
+#ifdef _MSC_VER
+  // Rostime has some magic interface that doesn't directly include
+  // its implementation, this just disbales those warnings.
+  #pragma warning(disable: 4244)
+  #pragma warning(disable: 4661)
+#endif
+
+#include 
+#include 
+#include 
+#include 
+#include 
+#include "rostime_decl.h"
+
+namespace boost {
+  namespace posix_time {
+    class time_duration;
+  }
+}
+
+namespace ros
+{
+ROSTIME_DECL void normalizeSecNSecSigned(int64_t& sec, int64_t& nsec);
+ROSTIME_DECL void normalizeSecNSecSigned(int32_t& sec, int32_t& nsec);
+
+/**
+ * \brief Base class for Duration implementations.  Provides storage, common functions and operator overloads.
+ * This should not need to be used directly.
+ */
+template 
+class DurationBase
+{
+public:
+  int32_t sec, nsec;
+  DurationBase() : sec(0), nsec(0) { }
+  DurationBase(int32_t _sec, int32_t _nsec);
+  explicit DurationBase(double t){fromSec(t);};
+  ~DurationBase() {}
+  T operator+(const T &rhs) const;
+  T operator-(const T &rhs) const;
+  T operator-() const;
+  T operator*(double scale) const;
+  T& operator+=(const T &rhs);
+  T& operator-=(const T &rhs);
+  T& operator*=(double scale);
+  bool operator==(const T &rhs) const;
+  inline bool operator!=(const T &rhs) const { return !(*static_cast(this) == rhs); }
+  bool operator>(const T &rhs) const;
+  bool operator<(const T &rhs) const;
+  bool operator>=(const T &rhs) const;
+  bool operator<=(const T &rhs) const;
+  double toSec() const { return (double)sec + 1e-9*(double)nsec; };
+  int64_t toNSec() const {return (int64_t)sec*1000000000ll + (int64_t)nsec;  };
+  T& fromSec(double t);
+  T& fromNSec(int64_t t);
+  bool isZero() const;
+  boost::posix_time::time_duration toBoost() const;
+};
+
+class Rate;
+
+/**
+ * \brief Duration representation for use with the Time class.
+ *
+ * ros::DurationBase provides most of its functionality.
+ */
+class ROSTIME_DECL Duration : public DurationBase
+{
+public:
+  Duration()
+  : DurationBase()
+  { }
+
+  Duration(int32_t _sec, int32_t _nsec)
+  : DurationBase(_sec, _nsec)
+  {}
+
+  explicit Duration(double t) { fromSec(t); }
+  explicit Duration(const Rate&);
+  /**
+   * \brief sleep for the amount of time specified by this Duration.  If a signal interrupts the sleep, resleeps for the time remaining.
+   * @return True if the desired sleep duration was met, false otherwise.
+   */
+  bool sleep() const;
+};
+
+extern ROSTIME_DECL const Duration DURATION_MAX;
+extern ROSTIME_DECL const Duration DURATION_MIN;
+
+/**
+ * \brief Duration representation for use with the WallTime class.
+ *
+ * ros::DurationBase provides most of its functionality.
+ */
+class ROSTIME_DECL WallDuration : public DurationBase
+{
+public:
+  WallDuration()
+  : DurationBase()
+  { }
+
+  WallDuration(int32_t _sec, int32_t _nsec)
+  : DurationBase(_sec, _nsec)
+  {}
+
+  explicit WallDuration(double t) { fromSec(t); }
+  explicit WallDuration(const Rate&);
+  /**
+   * \brief sleep for the amount of time specified by this Duration.  If a signal interrupts the sleep, resleeps for the time remaining.
+   * @return True if the desired sleep duration was met, false otherwise.
+   */
+  bool sleep() const;
+};
+
+std::ostream &operator <<(std::ostream &os, const Duration &rhs);
+std::ostream &operator <<(std::ostream &os, const WallDuration &rhs);
+
+
+}
+
+#endif // ROS_DURATION_H
+
+
diff --git a/realsense-file/src/storage/realsense_file/rosbag/rostime/include/ros/impl/duration.h b/realsense-file/src/storage/realsense_file/rosbag/rostime/include/ros/impl/duration.h
new file mode 100644
index 0000000000..54ff76271b
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/rosbag/rostime/include/ros/impl/duration.h
@@ -0,0 +1,180 @@
+/*********************************************************************
+ * Software License Agreement (BSD License)
+ *
+ *  Copyright (c) 2010, Willow Garage, Inc.
+ *  All rights reserved.
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions
+ *  are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *   * Neither the name of Willow Garage, Inc. nor the names of its
+ *     contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ *  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ *  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ *  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ *  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ *  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ *  POSSIBILITY OF SUCH DAMAGE.
+ *********************************************************************/
+#ifndef ROSTIME_IMPL_DURATION_H_INCLUDED
+#define ROSTIME_IMPL_DURATION_H_INCLUDED
+
+#include 
+#include 
+#include 
+
+namespace ros {
+  //
+  // DurationBase template member function implementation
+  //
+  template
+  DurationBase::DurationBase(int32_t _sec, int32_t _nsec)
+  : sec(_sec), nsec(_nsec)
+  {
+    normalizeSecNSecSigned(sec, nsec);
+  }
+
+  template
+  T& DurationBase::fromSec(double d)
+  {
+    sec = (int32_t)floor(d);
+    nsec = (int32_t)((d - (double)sec)*1000000000);
+    return *static_cast(this);
+  }
+
+  template
+  T& DurationBase::fromNSec(int64_t t)
+  {
+    sec  = (int32_t)(t / 1000000000);
+    nsec = (int32_t)(t % 1000000000);
+
+    normalizeSecNSecSigned(sec, nsec);
+
+    return *static_cast(this);
+  }
+
+  template
+  T DurationBase::operator+(const T &rhs) const
+  {
+    return T(sec + rhs.sec, nsec + rhs.nsec);
+  }
+
+  template
+  T DurationBase::operator*(double scale) const
+  {
+    return T(toSec() * scale);
+  }
+
+  template
+  T DurationBase::operator-(const T &rhs) const
+  {
+    return T(sec - rhs.sec, nsec - rhs.nsec);
+  }
+
+  template
+  T DurationBase::operator-() const
+  {
+    return T(-sec , -nsec);
+  }
+
+  template
+  T& DurationBase::operator+=(const T &rhs)
+  {
+    *this = *this + rhs;
+    return *static_cast(this);
+  }
+
+  template
+  T& DurationBase::operator-=(const T &rhs)
+  {
+    *this += (-rhs);
+    return *static_cast(this);
+  }
+
+  template
+  T& DurationBase::operator*=(double scale)
+  {
+    fromSec(toSec() * scale);
+    return *static_cast(this);
+  }
+
+  template
+  bool DurationBase::operator<(const T &rhs) const
+  {
+    if (sec < rhs.sec)
+      return true;
+    else if (sec == rhs.sec && nsec < rhs.nsec)
+      return true;
+    return false;
+  }
+
+  template
+  bool DurationBase::operator>(const T &rhs) const
+  {
+    if (sec > rhs.sec)
+      return true;
+    else if (sec == rhs.sec && nsec > rhs.nsec)
+      return true;
+    return false;
+  }
+
+  template
+  bool DurationBase::operator<=(const T &rhs) const
+  {
+    if (sec < rhs.sec)
+      return true;
+    else if (sec == rhs.sec && nsec <= rhs.nsec)
+      return true;
+    return false;
+  }
+
+  template
+  bool DurationBase::operator>=(const T &rhs) const
+  {
+    if (sec > rhs.sec)
+      return true;
+    else if (sec == rhs.sec && nsec >= rhs.nsec)
+      return true;
+    return false;
+  }
+
+  template
+  bool DurationBase::operator==(const T &rhs) const
+  {
+    return sec == rhs.sec && nsec == rhs.nsec;
+  }
+
+  template
+  bool DurationBase::isZero() const
+  {
+    return sec == 0 && nsec == 0;
+  }
+
+  template 
+  boost::posix_time::time_duration
+  DurationBase::toBoost() const
+  {
+    namespace bt = boost::posix_time;
+#if defined(BOOST_DATE_TIME_HAS_NANOSECONDS)
+    return bt::seconds(sec) + bt::nanoseconds(nsec);
+#else
+    return bt::seconds(static_cast(sec)) + bt::microseconds(static_cast(nsec/1000.0));
+#endif
+  }
+}
+#endif
diff --git a/realsense-file/src/storage/realsense_file/rosbag/rostime/include/ros/impl/time.h b/realsense-file/src/storage/realsense_file/rosbag/rostime/include/ros/impl/time.h
new file mode 100644
index 0000000000..92d9605ffa
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/rosbag/rostime/include/ros/impl/time.h
@@ -0,0 +1,178 @@
+/*********************************************************************
+* Software License Agreement (BSD License)
+*
+*  Copyright (c) 2008, Willow Garage, Inc.
+*  All rights reserved.
+*
+*  Redistribution and use in source and binary forms, with or without
+*  modification, are permitted provided that the following conditions
+*  are met:
+*
+*   * Redistributions of source code must retain the above copyright
+*     notice, this list of conditions and the following disclaimer.
+*   * Redistributions in binary form must reproduce the above
+*     copyright notice, this list of conditions and the following
+*     disclaimer in the documentation and/or other materials provided
+*     with the distribution.
+*   * Neither the name of Willow Garage, Inc. nor the names of its
+*     contributors may be used to endorse or promote products derived
+*     from this software without specific prior written permission.
+*
+*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+*  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+*  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+*  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+*  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+*  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+*  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+*  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+*  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+*  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+*  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+*  POSSIBILITY OF SUCH DAMAGE.
+*********************************************************************/
+
+#ifndef ROS_TIME_IMPL_H_INCLUDED
+#define ROS_TIME_IMPL_H_INCLUDED
+
+/*********************************************************************
+** Headers
+*********************************************************************/
+
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+
+/*********************************************************************
+** Cross Platform Headers
+*********************************************************************/
+
+#ifdef WIN32
+  #include 
+#else
+  #include 
+#endif
+
+namespace ros
+{
+
+  template
+  T& TimeBase::fromNSec(uint64_t t)
+  {
+    uint64_t sec64 = 0;
+    uint64_t nsec64 = t;
+
+    normalizeSecNSec(sec64, nsec64);
+
+    sec = (uint32_t)sec64;
+    nsec = (uint32_t)nsec64;
+
+    return *static_cast(this);
+  }
+
+  template
+  D TimeBase::operator-(const T &rhs) const
+  {
+    return D((int32_t)sec -  (int32_t)rhs.sec,
+             (int32_t)nsec - (int32_t)rhs.nsec); // carry handled in ctor
+  }
+
+  template
+  T TimeBase::operator-(const D &rhs) const
+  {
+    return *static_cast(this) + ( -rhs);
+  }
+
+  template
+  T TimeBase::operator+(const D &rhs) const
+  {
+    int64_t sec_sum  = (int64_t)sec  + (int64_t)rhs.sec;
+    int64_t nsec_sum = (int64_t)nsec + (int64_t)rhs.nsec;
+
+    // Throws an exception if we go out of 32-bit range
+    normalizeSecNSecUnsigned(sec_sum, nsec_sum);
+
+    // now, it's safe to downcast back to uint32 bits
+    return T((uint32_t)sec_sum, (uint32_t)nsec_sum);
+  }
+
+  template
+  T& TimeBase::operator+=(const D &rhs)
+  {
+    *this = *this + rhs;
+    return *static_cast(this);
+  }
+
+  template
+  T& TimeBase::operator-=(const D &rhs)
+  {
+    *this += (-rhs);
+    return *static_cast(this);
+  }
+
+  template
+  bool TimeBase::operator==(const T &rhs) const
+  {
+    return sec == rhs.sec && nsec == rhs.nsec;
+  }
+
+  template
+  bool TimeBase::operator<(const T &rhs) const
+  {
+    if (sec < rhs.sec)
+      return true;
+    else if (sec == rhs.sec && nsec < rhs.nsec)
+      return true;
+    return false;
+  }
+
+  template
+  bool TimeBase::operator>(const T &rhs) const
+  {
+    if (sec > rhs.sec)
+      return true;
+    else if (sec == rhs.sec && nsec > rhs.nsec)
+      return true;
+    return false;
+  }
+
+  template
+  bool TimeBase::operator<=(const T &rhs) const
+  {
+    if (sec < rhs.sec)
+      return true;
+    else if (sec == rhs.sec && nsec <= rhs.nsec)
+      return true;
+    return false;
+  }
+
+  template
+  bool TimeBase::operator>=(const T &rhs) const
+  {
+    if (sec > rhs.sec)
+      return true;
+    else if (sec == rhs.sec && nsec >= rhs.nsec)
+      return true;
+    return false;
+  }
+
+  template
+  boost::posix_time::ptime
+  TimeBase::toBoost() const
+  {
+    namespace pt = boost::posix_time;
+#if defined(BOOST_DATE_TIME_HAS_NANOSECONDS)
+    return pt::from_time_t(sec) + pt::nanoseconds(nsec);
+#else
+    return pt::from_time_t(static_cast(sec)) + pt::microseconds(static_cast(nsec/1000.0));
+#endif
+  }
+
+
+}
+
+#endif // ROS_IMPL_TIME_H_INCLUDED
+
diff --git a/realsense-file/src/storage/realsense_file/rosbag/rostime/include/ros/rate.h b/realsense-file/src/storage/realsense_file/rosbag/rostime/include/ros/rate.h
new file mode 100644
index 0000000000..ddee3a710f
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/rosbag/rostime/include/ros/rate.h
@@ -0,0 +1,131 @@
+/*********************************************************************
+*
+* Software License Agreement (BSD License)
+*
+*  Copyright (c) 2009, Willow Garage, Inc.
+*  All rights reserved.
+*
+*  Redistribution and use in source and binary forms, with or without
+*  modification, are permitted provided that the following conditions
+*  are met:
+*
+*   * Redistributions of source code must retain the above copyright
+*     notice, this list of conditions and the following disclaimer.
+*   * Redistributions in binary form must reproduce the above
+*     copyright notice, this list of conditions and the following
+*     disclaimer in the documentation and/or other materials provided
+*     with the distribution.
+*   * Neither the name of the Willow Garage nor the names of its
+*     contributors may be used to endorse or promote products derived
+*     from this software without specific prior written permission.
+*
+*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+*  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+*  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+*  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+*  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+*  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+*  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+*  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+*  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+*  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+*  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+*  POSSIBILITY OF SUCH DAMAGE.
+*
+* Author: Eitan Marder-Eppstein
+*********************************************************************/
+#ifndef ROSLIB_RATE_H
+#define ROSLIB_RATE_H
+
+#include "ros/time.h"
+#include "rostime_decl.h"
+
+namespace ros
+{
+class Duration;
+
+/**
+ * @class Rate
+ * @brief Class to help run loops at a desired frequency
+ */
+class ROSTIME_DECL Rate
+{
+public:
+  /**
+   * @brief  Constructor, creates a Rate
+   * @param  frequency The desired rate to run at in Hz
+   */
+  Rate(double frequency);
+  explicit Rate(const Duration&);
+
+  /**
+   * @brief  Sleeps for any leftover time in a cycle. Calculated from the last time sleep, reset, or the constructor was called.
+   * @return True if the desired rate was met for the cycle, false otherwise.
+   */
+  bool sleep();
+
+  /**
+   * @brief  Sets the start time for the rate to now
+   */
+  void reset();
+
+  /**
+   * @brief  Get the actual run time of a cycle from start to sleep
+   * @return The runtime of the cycle
+   */
+  Duration cycleTime() const;
+
+  /**
+   * @brief Get the expected cycle time -- one over the frequency passed in to the constructor
+   */
+  Duration expectedCycleTime() const { return expected_cycle_time_; }
+
+private:
+  Time start_;
+  Duration expected_cycle_time_, actual_cycle_time_;
+};
+
+/**
+ * @class WallRate
+ * @brief Class to help run loops at a desired frequency.  This version always uses wall-clock time.
+ */
+class ROSTIME_DECL WallRate
+{
+public:
+  /**
+   * @brief  Constructor, creates a Rate
+   * @param  frequency The desired rate to run at in Hz
+   */
+  WallRate(double frequency);
+  explicit WallRate(const Duration&);
+
+  /**
+   * @brief  Sleeps for any leftover time in a cycle. Calculated from the last time sleep, reset, or the constructor was called.
+   * @return Passes through the return value from WallDuration::sleep() if it slept, false otherwise.
+   */
+  bool sleep();
+
+  /**
+   * @brief  Sets the start time for the rate to now
+   */
+  void reset();
+
+  /**
+   * @brief  Get the actual run time of a cycle from start to sleep
+   * @return The runtime of the cycle
+   */
+  WallDuration cycleTime() const;
+
+  /**
+   * @brief Get the expected cycle time -- one over the frequency passed in to the constructor
+   */
+  WallDuration expectedCycleTime() const { return expected_cycle_time_; }
+
+private:
+  WallTime start_;
+  WallDuration expected_cycle_time_, actual_cycle_time_;
+};
+
+}
+
+#endif
diff --git a/realsense-file/src/storage/realsense_file/rosbag/rostime/include/ros/rostime_decl.h b/realsense-file/src/storage/realsense_file/rosbag/rostime/include/ros/rostime_decl.h
new file mode 100644
index 0000000000..8f873914a4
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/rosbag/rostime/include/ros/rostime_decl.h
@@ -0,0 +1,55 @@
+/*********************************************************************
+*
+* Software License Agreement (BSD License)
+*
+*  Copyright (c) 2009, Willow Garage, Inc.
+*  All rights reserved.
+*
+*  Redistribution and use in source and binary forms, with or without
+*  modification, are permitted provided that the following conditions
+*  are met:
+*
+*   * Redistributions of source code must retain the above copyright
+*     notice, this list of conditions and the following disclaimer.
+*   * Redistributions in binary form must reproduce the above
+*     copyright notice, this list of conditions and the following
+*     disclaimer in the documentation and/or other materials provided
+*     with the distribution.
+*   * Neither the name of the Willow Garage nor the names of its
+*     contributors may be used to endorse or promote products derived
+*     from this software without specific prior written permission.
+*
+*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+*  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+*  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+*  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+*  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+*  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+*  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+*  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+*  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+*  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+*  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+*  POSSIBILITY OF SUCH DAMAGE.
+*
+*********************************************************************/
+/*
+ * Cross platform macros.
+ *
+ */
+#ifndef ROSTIME_DECL_HPP_INCLUDED
+#define ROSTIME_DECL_HPP_INCLUDED
+
+#include 
+
+#ifdef ROS_BUILD_SHARED_LIBS // ros is being built around shared libraries
+  #ifdef rostime_EXPORTS // we are building a shared lib/dll
+    #define ROSTIME_DECL ROS_HELPER_EXPORT
+  #else // we are using shared lib/dll
+    #define ROSTIME_DECL ROS_HELPER_IMPORT
+  #endif
+#else // ros is being built around static libraries
+  #define ROSTIME_DECL
+#endif
+
+#endif /* ROSTIME_DECL_HPP_INCLUDED */
diff --git a/realsense-file/src/storage/realsense_file/rosbag/rostime/include/ros/time.h b/realsense-file/src/storage/realsense_file/rosbag/rostime/include/ros/time.h
new file mode 100644
index 0000000000..3080a5d017
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/rosbag/rostime/include/ros/time.h
@@ -0,0 +1,264 @@
+/*********************************************************************
+ * Software License Agreement (BSD License)
+ *
+ *  Copyright (c) 2010, Willow Garage, Inc.
+ *  All rights reserved.
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions
+ *  are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *   * Neither the name of Willow Garage, Inc. nor the names of its
+ *     contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ *  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ *  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ *  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ *  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ *  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ *  POSSIBILITY OF SUCH DAMAGE.
+ *********************************************************************/
+
+#ifndef ROS_TIME_H_INCLUDED
+#define ROS_TIME_H_INCLUDED
+
+/*********************************************************************
+ ** Pragmas
+ *********************************************************************/
+
+#ifdef _MSC_VER
+  // Rostime has some magic interface that doesn't directly include
+  // its implementation, this just disables those warnings.
+  #pragma warning(disable: 4244)
+  #pragma warning(disable: 4661)
+#endif
+
+/*********************************************************************
+ ** Headers
+ *********************************************************************/
+
+#include 
+#include 
+#include 
+#include 
+#include "duration.h"
+#include 
+#include "rostime_decl.h"
+
+/*********************************************************************
+ ** Cross Platform Headers
+ *********************************************************************/
+
+#ifdef WIN32
+  #include 
+#else
+  #include 
+#endif
+
+namespace boost {
+  namespace posix_time {
+    class ptime;
+    class time_duration;
+  }
+}
+
+namespace ros
+{
+
+  /*********************************************************************
+   ** Exceptions
+   *********************************************************************/
+
+  /**
+   * @brief Thrown if the ros subsystem hasn't been initialised before use.
+   */
+  class ROSTIME_DECL TimeNotInitializedException : public Exception
+  {
+  public:
+    TimeNotInitializedException()
+      : Exception("Cannot use ros::Time::now() before the first NodeHandle has been created or ros::start() has been called.  "
+                  "If this is a standalone app or test that just uses ros::Time and does not communicate over ROS, you may also call ros::Time::init()")
+    {}
+  };
+
+  /**
+   * @brief Thrown if windoze high perf. timestamping is unavailable.
+   *
+   * @sa getWallTime
+   */
+  class ROSTIME_DECL NoHighPerformanceTimersException : public Exception
+  {
+  public:
+    NoHighPerformanceTimersException()
+      : Exception("This windows platform does not "
+                  "support the high-performance timing api.")
+    {}
+  };
+
+  /*********************************************************************
+   ** Functions
+   *********************************************************************/
+
+  ROSTIME_DECL void normalizeSecNSec(uint64_t& sec, uint64_t& nsec);
+  ROSTIME_DECL void normalizeSecNSec(uint32_t& sec, uint32_t& nsec);
+  ROSTIME_DECL void normalizeSecNSecUnsigned(int64_t& sec, int64_t& nsec);
+
+  /*********************************************************************
+   ** Time Classes
+   *********************************************************************/
+
+  /**
+   * \brief Base class for Time implementations.  Provides storage, common functions and operator overloads.
+   * This should not need to be used directly.
+   */
+  template
+  class TimeBase
+  {
+  public:
+    uint32_t sec, nsec;
+
+    TimeBase() : sec(0), nsec(0) { }
+    TimeBase(uint32_t _sec, uint32_t _nsec) : sec(_sec), nsec(_nsec)
+    {
+      normalizeSecNSec(sec, nsec);
+    }
+    explicit TimeBase(double t) { fromSec(t); }
+    ~TimeBase() {}
+    D operator-(const T &rhs) const;
+    T operator+(const D &rhs) const;
+    T operator-(const D &rhs) const;
+    T& operator+=(const D &rhs);
+    T& operator-=(const D &rhs);
+    bool operator==(const T &rhs) const;
+    inline bool operator!=(const T &rhs) const { return !(*static_cast(this) == rhs); }
+    bool operator>(const T &rhs) const;
+    bool operator<(const T &rhs) const;
+    bool operator>=(const T &rhs) const;
+    bool operator<=(const T &rhs) const;
+
+    double toSec()  const { return (double)sec + 1e-9*(double)nsec; };
+    T& fromSec(double t) {
+      sec = static_cast(floor(t));
+      nsec = static_cast(boost::math::round((t-sec) * 1e9));
+      // avoid rounding errors
+      sec += static_cast((nsec / 1000000000ul));
+      nsec %= 1000000000ul;
+      return *static_cast(this);
+    }
+
+    uint64_t toNSec() const {return (uint64_t)sec*1000000000ull + (uint64_t)nsec;  }
+    T& fromNSec(uint64_t t);
+
+    inline bool isZero() const { return sec == 0 && nsec == 0; }
+    inline bool is_zero() const { return isZero(); }
+    boost::posix_time::ptime toBoost() const;
+
+  };
+
+  /**
+   * \brief Time representation.  May either represent wall clock time or ROS clock time.
+   *
+   * ros::TimeBase provides most of its functionality.
+   */
+  class ROSTIME_DECL Time : public TimeBase
+  {
+  public:
+    Time()
+      : TimeBase()
+    {}
+
+    Time(uint32_t _sec, uint32_t _nsec)
+      : TimeBase(_sec, _nsec)
+    {}
+
+    explicit Time(double t) { fromSec(t); }
+
+    /**
+     * \brief Retrieve the current time.  If ROS clock time is in use, this returns the time according to the
+     * ROS clock.  Otherwise returns the current wall clock time.
+     */
+    static Time now();
+    /**
+     * \brief Sleep until a specific time has been reached.
+     * @return True if the desired sleep time was met, false otherwise.
+     */
+    static bool sleepUntil(const Time& end);
+
+    static void init();
+    static void shutdown();
+    static void setNow(const Time& new_now);
+    static bool useSystemTime();
+    static bool isSimTime();
+    static bool isSystemTime();
+
+    /**
+     * \brief Returns whether or not the current time is valid.  Time is valid if it is non-zero.
+     */
+    static bool isValid();
+    /**
+     * \brief Wait for time to become valid
+     */
+    static bool waitForValid();
+    /**
+     * \brief Wait for time to become valid, with timeout
+     */
+    static bool waitForValid(const ros::WallDuration& timeout);
+
+    static Time fromBoost(const boost::posix_time::ptime& t);
+    static Time fromBoost(const boost::posix_time::time_duration& d);
+  };
+
+  extern ROSTIME_DECL const Time TIME_MAX;
+  extern ROSTIME_DECL const Time TIME_MIN;
+
+  /**
+   * \brief Time representation.  Always wall-clock time.
+   *
+   * ros::TimeBase provides most of its functionality.
+   */
+  class ROSTIME_DECL WallTime : public TimeBase
+  {
+  public:
+    WallTime()
+      : TimeBase()
+    {}
+
+    WallTime(uint32_t _sec, uint32_t _nsec)
+      : TimeBase(_sec, _nsec)
+    {}
+
+    explicit WallTime(double t) { fromSec(t); }
+
+    /**
+     * \brief Returns the current wall clock time.
+     */
+    static WallTime now();
+
+    /**
+     * \brief Sleep until a specific time has been reached.
+     * @return True if the desired sleep time was met, false otherwise.
+     */
+    static bool sleepUntil(const WallTime& end);
+
+    static bool isSystemTime() { return true; }
+  };
+
+  ROSTIME_DECL std::ostream &operator <<(std::ostream &os, const Time &rhs);
+  ROSTIME_DECL std::ostream &operator <<(std::ostream &os, const WallTime &rhs);
+}
+
+#endif // ROS_TIME_H
+
diff --git a/realsense-file/src/storage/realsense_file/rosbag/rostime/src/duration.cpp b/realsense-file/src/storage/realsense_file/rosbag/rostime/src/duration.cpp
new file mode 100644
index 0000000000..72857c6bb3
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/rosbag/rostime/src/duration.cpp
@@ -0,0 +1,78 @@
+/*********************************************************************
+ * Software License Agreement (BSD License)
+ *
+ *  Copyright (c) 2010, Willow Garage, Inc.
+ *  All rights reserved.
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions
+ *  are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *   * Neither the name of Willow Garage, Inc. nor the names of its
+ *     contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ *  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ *  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ *  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ *  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ *  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ *  POSSIBILITY OF SUCH DAMAGE.
+ *********************************************************************/
+ #include 
+#include 
+
+namespace ros {
+
+  Duration::Duration(const Rate& rate)
+    : DurationBase(rate.expectedCycleTime().sec, rate.expectedCycleTime().nsec)
+  { }
+
+  WallDuration::WallDuration(const Rate& rate)
+    : DurationBase(rate.expectedCycleTime().sec, rate.expectedCycleTime().nsec)
+  { }
+
+  void normalizeSecNSecSigned(int64_t& sec, int64_t& nsec)
+  {
+    int64_t nsec_part = nsec % 1000000000L;
+    int64_t sec_part = sec + nsec / 1000000000L;
+    if (nsec_part < 0)
+      {
+        nsec_part += 1000000000L;
+        --sec_part;
+      }
+
+    if (sec_part < INT_MIN || sec_part > INT_MAX)
+      throw std::runtime_error("Duration is out of dual 32-bit range");
+
+    sec = sec_part;
+    nsec = nsec_part;
+  }
+
+  void normalizeSecNSecSigned(int32_t& sec, int32_t& nsec)
+  {
+    int64_t sec64 = sec;
+    int64_t nsec64 = nsec;
+
+    normalizeSecNSecSigned(sec64, nsec64);
+
+    sec = (int32_t)sec64;
+    nsec = (int32_t)nsec64;
+  }
+
+  template class DurationBase;
+  template class DurationBase;
+}
+
diff --git a/realsense-file/src/storage/realsense_file/rosbag/rostime/src/rate.cpp b/realsense-file/src/storage/realsense_file/rosbag/rostime/src/rate.cpp
new file mode 100644
index 0000000000..cdd0313a3a
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/rosbag/rostime/src/rate.cpp
@@ -0,0 +1,162 @@
+/*********************************************************************
+ *
+ * Software License Agreement (BSD License)
+ *
+ *  Copyright (c) 2009, Willow Garage, Inc.
+ *  All rights reserved.
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions
+ *  are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *   * Neither the name of the Willow Garage nor the names of its
+ *     contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ *  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ *  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ *  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ *  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ *  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ *  POSSIBILITY OF SUCH DAMAGE.
+ *
+ * Author: Eitan Marder-Eppstein
+ *********************************************************************/
+#include 
+
+namespace ros
+{
+
+Rate::Rate(double frequency)
+: start_(Time::now())
+, expected_cycle_time_(1.0 / frequency)
+, actual_cycle_time_(0.0)
+{ }
+
+Rate::Rate(const Duration& d)
+  : start_(Time::now())
+  , expected_cycle_time_(d.sec, d.nsec)
+  , actual_cycle_time_(0.0)
+{ }
+
+
+
+bool Rate::sleep()
+{
+  Time expected_end = start_ + expected_cycle_time_;
+
+  Time actual_end = Time::now();
+
+  // detect backward jumps in time
+  if (actual_end < start_)
+  {
+    expected_end = actual_end + expected_cycle_time_;
+  }
+
+  //calculate the time we'll sleep for
+  Duration sleep_time = expected_end - actual_end;
+
+  //set the actual amount of time the loop took in case the user wants to know
+  actual_cycle_time_ = actual_end - start_;
+
+  //make sure to reset our start time
+  start_ = expected_end;
+
+  //if we've taken too much time we won't sleep
+  if(sleep_time <= Duration(0.0))
+  {
+    // if we've jumped forward in time, or the loop has taken more than a full extra
+    // cycle, reset our cycle
+    if (actual_end > expected_end + expected_cycle_time_)
+    {
+      start_ = actual_end;
+    }
+    // return false to show that the desired rate was not met
+    return false;
+  }
+
+  return sleep_time.sleep();
+}
+
+void Rate::reset()
+{
+  start_ = Time::now();
+}
+
+Duration Rate::cycleTime() const
+{
+  return actual_cycle_time_;
+}
+
+WallRate::WallRate(double frequency)
+: start_(WallTime::now())
+, expected_cycle_time_(1.0 / frequency)
+, actual_cycle_time_(0.0)
+{}
+
+WallRate::WallRate(const Duration& d)
+: start_(WallTime::now())
+, expected_cycle_time_(d.sec, d.nsec)
+, actual_cycle_time_(0.0)
+{}
+
+bool WallRate::sleep()
+{
+  WallTime expected_end = start_ + expected_cycle_time_;
+
+  WallTime actual_end = WallTime::now();
+
+  // detect backward jumps in time
+  if (actual_end < start_)
+  {
+    expected_end = actual_end + expected_cycle_time_;
+  }
+
+  //calculate the time we'll sleep for
+  WallDuration sleep_time = expected_end - actual_end;
+
+  //set the actual amount of time the loop took in case the user wants to know
+  actual_cycle_time_ = actual_end - start_;
+
+  //make sure to reset our start time
+  start_ = expected_end;
+
+  //if we've taken too much time we won't sleep
+  if(sleep_time <= WallDuration(0.0))
+  {
+    // if we've jumped forward in time, or the loop has taken more than a full extra
+    // cycle, reset our cycle
+    if (actual_end > expected_end + expected_cycle_time_)
+    {
+      start_ = actual_end;
+    }
+    return false;
+  }
+
+  return sleep_time.sleep();
+}
+
+void WallRate::reset()
+{
+  start_ = WallTime::now();
+}
+
+WallDuration WallRate::cycleTime() const
+{
+  return actual_cycle_time_;
+}
+
+
+}
diff --git a/realsense-file/src/storage/realsense_file/rosbag/rostime/src/time.cpp b/realsense-file/src/storage/realsense_file/rosbag/rostime/src/time.cpp
new file mode 100644
index 0000000000..13da634065
--- /dev/null
+++ b/realsense-file/src/storage/realsense_file/rosbag/rostime/src/time.cpp
@@ -0,0 +1,510 @@
+/*********************************************************************
+ * Software License Agreement (BSD License)
+ *
+ *  Copyright (c) 2010, Willow Garage, Inc.
+ *  All rights reserved.
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions
+ *  are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *   * Neither the name of Willow Garage, Inc. nor the names of its
+ *     contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ *  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ *  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ *  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ *  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ *  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ *  POSSIBILITY OF SUCH DAMAGE.
+ *********************************************************************/
+#ifdef _MSC_VER
+  #ifndef NOMINMAX
+    #define NOMINMAX
+  #endif
+#endif
+
+#include "ros/time.h"
+#include "ros/impl/time.h"
+#include 
+#include 
+#include 
+#include 
+#include 
+
+#include 
+#include 
+#include 
+
+/*********************************************************************
+ ** Preprocessor
+ *********************************************************************/
+
+// Could probably do some better and more elaborate checking
+// and definition here.
+#define HAS_CLOCK_GETTIME (_POSIX_C_SOURCE >= 199309L)
+
+/*********************************************************************
+ ** Namespaces
+ *********************************************************************/
+
+namespace ros
+{
+
+  /*********************************************************************
+   ** Variables
+   *********************************************************************/
+
+  const Duration DURATION_MAX(std::numeric_limits::max(), 999999999);
+  const Duration DURATION_MIN(std::numeric_limits::min(), 0);
+
+  const Time TIME_MAX(std::numeric_limits::max(), 999999999);
+  const Time TIME_MIN(0, 1);
+
+  // This is declared here because it's set from the Time class but read from
+  // the Duration class, and need not be exported to users of either.
+  static bool g_stopped(false);
+
+  // I assume that this is declared here, instead of time.h, to keep users
+  // of time.h from including boost/thread/mutex.hpp
+  static boost::mutex g_sim_time_mutex;
+
+  static bool g_initialized(false);
+  static bool g_use_sim_time(true);
+  static Time g_sim_time(0, 0);
+
+  /*********************************************************************
+   ** Cross Platform Functions
+   *********************************************************************/
+  /*
+   * These have only internal linkage to this translation unit.
+   * (i.e. not exposed to users of the time classes)
+   */
+  void ros_walltime(uint32_t& sec, uint32_t& nsec) 
+#ifndef WIN32    
+    throw(NoHighPerformanceTimersException)
+#endif
+  {
+#ifndef WIN32
+#if HAS_CLOCK_GETTIME
+    timespec start;
+    clock_gettime(CLOCK_REALTIME, &start);
+    sec  = static_cast(start.tv_sec);
+    nsec = static_cast(start.tv_nsec);
+#else
+    struct timeval timeofday;
+    gettimeofday(&timeofday,NULL);
+    sec  = timeofday.tv_sec;
+    nsec = timeofday.tv_usec * 1000;
+#endif
+#else
+    // Win32 implementation
+    // unless I've missed something obvious, the only way to get high-precision
+    // time on Windows is via the QueryPerformanceCounter() call. However,
+    // this is somewhat problematic in Windows XP on some processors, especially
+    // AMD, because the Windows implementation can freak out when the CPU clocks
+    // down to save power. Time can jump or even go backwards. Microsoft has
+    // fixed this bug for most systems now, but it can still show up if you have
+    // not installed the latest CPU drivers (an oxymoron). They fixed all these
+    // problems in Windows Vista, and this API is by far the most accurate that
+    // I know of in Windows, so I'll use it here despite all these caveats
+    static LARGE_INTEGER cpu_freq, init_cpu_time;
+    static uint32_t start_sec = 0;
+    static uint32_t start_nsec = 0;
+    if ( ( start_sec == 0 ) && ( start_nsec == 0 ) )
+      {
+        QueryPerformanceFrequency(&cpu_freq);
+        if (cpu_freq.QuadPart == 0) {
+          throw NoHighPerformanceTimersException();
+        }
+        QueryPerformanceCounter(&init_cpu_time);
+        // compute an offset from the Epoch using the lower-performance timer API
+        FILETIME ft;
+        GetSystemTimeAsFileTime(&ft);
+        LARGE_INTEGER start_li;
+        start_li.LowPart = ft.dwLowDateTime;
+        start_li.HighPart = ft.dwHighDateTime;
+        // why did they choose 1601 as the time zero, instead of 1970?
+        // there were no outstanding hard rock bands in 1601.
+#ifdef _MSC_VER
+    	start_li.QuadPart -= 116444736000000000Ui64;
+#else
+    	start_li.QuadPart -= 116444736000000000ULL;
+#endif
+        start_sec = (uint32_t)(start_li.QuadPart / 10000000); // 100-ns units. odd.
+        start_nsec = (start_li.LowPart % 10000000) * 100;
+      }
+    LARGE_INTEGER cur_time;
+    QueryPerformanceCounter(&cur_time);
+    LARGE_INTEGER delta_cpu_time;
+    delta_cpu_time.QuadPart = cur_time.QuadPart - init_cpu_time.QuadPart;
+    // todo: how to handle cpu clock drift. not sure it's a big deal for us.
+    // also, think about clock wraparound. seems extremely unlikey, but possible
+    double d_delta_cpu_time = delta_cpu_time.QuadPart / (double) cpu_freq.QuadPart;
+    uint32_t delta_sec = (uint32_t) floor(d_delta_cpu_time);
+    uint32_t delta_nsec = (uint32_t) boost::math::round((d_delta_cpu_time-delta_sec) * 1e9);
+
+    int64_t sec_sum  = (int64_t)start_sec  + (int64_t)delta_sec;
+    int64_t nsec_sum = (int64_t)start_nsec + (int64_t)delta_nsec;
+
+    // Throws an exception if we go out of 32-bit range
+    normalizeSecNSecUnsigned(sec_sum, nsec_sum);
+
+    sec = sec_sum;
+    nsec = nsec_sum;
+#endif
+  }
+  /**
+   * @brief Simple representation of the rt library nanosleep function.
+   */
+  int ros_nanosleep(const uint32_t &sec, const uint32_t &nsec)
+  {
+#if defined(WIN32)
+    HANDLE timer = NULL;
+    LARGE_INTEGER sleepTime;
+    sleepTime.QuadPart = -
+      static_cast(sec)*10000000LL -
+      static_cast(nsec) / 100LL;
+
+    timer = CreateWaitableTimer(NULL, TRUE, NULL);
+    if (timer == NULL)
+      {
+        return -1;
+      }
+
+    if (!SetWaitableTimer (timer, &sleepTime, 0, NULL, NULL, 0))
+      {
+        return -1;
+      }
+
+    if (WaitForSingleObject (timer, INFINITE) != WAIT_OBJECT_0)
+      {
+        return -1;
+      }
+    return 0;
+#else
+    timespec req = { sec, nsec };
+    return nanosleep(&req, NULL);
+#endif
+  }
+
+  /**
+   * @brief Go to the wall!
+   *
+   * @todo Fully implement the win32 parts, currently just like a regular sleep.
+   */
+  bool ros_wallsleep(uint32_t sec, uint32_t nsec)
+  {
+#if defined(WIN32)
+    ros_nanosleep(sec,nsec);
+#else
+    timespec req = { sec, nsec };
+    timespec rem = {0, 0};
+    while (nanosleep(&req, &rem) && !g_stopped)
+      {
+        req = rem;
+      }
+#endif
+    return !g_stopped;
+  }
+
+  /*********************************************************************
+   ** Class Methods
+   *********************************************************************/
+
+  bool Time::useSystemTime()
+  {
+    return !g_use_sim_time;
+  }
+
+  bool Time::isSimTime()
+  {
+    return g_use_sim_time;
+  }
+
+  bool Time::isSystemTime()
+  {
+    return !isSimTime();
+  }
+
+  Time Time::now()
+  {
+    if (!g_initialized)
+      {
+        throw TimeNotInitializedException();
+      }
+
+    if (g_use_sim_time)
+      {
+        boost::mutex::scoped_lock lock(g_sim_time_mutex);
+        Time t = g_sim_time;
+        return t;
+      }
+
+    Time t;
+    ros_walltime(t.sec, t.nsec);
+
+    return t;
+  }
+
+  void Time::setNow(const Time& new_now)
+  {
+    boost::mutex::scoped_lock lock(g_sim_time_mutex);
+
+    g_sim_time = new_now;
+    g_use_sim_time = true;
+  }
+
+  void Time::init()
+  {
+    g_stopped = false;
+    g_use_sim_time = false;
+    g_initialized = true;
+  }
+
+  void Time::shutdown()
+  {
+    g_stopped = true;
+  }
+
+  bool Time::isValid()
+  {
+    return (!g_use_sim_time) || !g_sim_time.isZero();
+  }
+
+  bool Time::waitForValid()
+  {
+    return waitForValid(ros::WallDuration());
+  }
+
+  bool Time::waitForValid(const ros::WallDuration& timeout)
+  {
+    ros::WallTime start = ros::WallTime::now();
+    while (!isValid() && !g_stopped)
+      {
+        ros::WallDuration(0.01).sleep();
+
+        if (timeout > ros::WallDuration(0, 0) && (ros::WallTime::now() - start > timeout))
+          {
+            return false;
+          }
+      }
+
+    if (g_stopped)
+      {
+        return false;
+      }
+
+    return true;
+  }
+
+  Time Time::fromBoost(const boost::posix_time::ptime& t)
+  {
+   boost::posix_time::time_duration diff = t - boost::posix_time::from_time_t(0);
+   return Time::fromBoost(diff);
+  }
+
+  Time Time::fromBoost(const boost::posix_time::time_duration& d)
+  {
+    Time t;
+    t.sec = d.total_seconds();
+#if defined(BOOST_DATE_TIME_HAS_NANOSECONDS)
+    t.nsec = d.fractional_seconds();
+#else
+    t.nsec = static_cast(d.fractional_seconds()*1000);
+#endif
+    return t;
+  }
+
+  std::ostream& operator<<(std::ostream& os, const Time &rhs)
+  {
+    boost::io::ios_all_saver s(os);
+    os << rhs.sec << "." << std::setw(9) << std::setfill('0') << rhs.nsec;
+    return os;
+  }
+
+  std::ostream& operator<<(std::ostream& os, const Duration& rhs)
+  {
+    boost::io::ios_all_saver s(os);
+    if (rhs.sec >= 0 || rhs.nsec == 0)
+    {
+      os << rhs.sec << "." << std::setw(9) << std::setfill('0') << rhs.nsec;
+    }
+    else
+    {
+      os << (rhs.sec == -1 ? "-" : "") << (rhs.sec + 1) << "." << std::setw(9) << std::setfill('0') << (1000000000 - rhs.nsec);
+    }
+    return os;
+  }
+
+  bool Time::sleepUntil(const Time& end)
+  {
+    if (Time::useSystemTime())
+      {
+        Duration d(end - Time::now());
+        if (d > Duration(0))
+          {
+            return d.sleep();
+          }
+
+        return true;
+      }
+    else
+      {
+        Time start = Time::now();
+        while (!g_stopped && (Time::now() < end))
+          {
+            ros_nanosleep(0,1000000);
+            if (Time::now() < start)
+              {
+                return false;
+              }
+          }
+
+        return true;
+      }
+  }
+
+  bool WallTime::sleepUntil(const WallTime& end)
+  {
+    WallDuration d(end - WallTime::now());
+    if (d > WallDuration(0))
+      {
+        return d.sleep();
+      }
+
+    return true;
+  }
+
+  bool Duration::sleep() const
+  {
+    if (Time::useSystemTime())
+      {
+        return ros_wallsleep(sec, nsec);
+      }
+    else
+      {
+        Time start = Time::now();
+        Time end = start + *this;
+        if (start.isZero())
+          {
+            end = TIME_MAX;
+          }
+
+        bool rc = false;
+        while (!g_stopped && (Time::now() < end))
+          {
+            ros_wallsleep(0, 1000000);
+            rc = true;
+
+            // If we started at time 0 wait for the first actual time to arrive before starting the timer on
+            // our sleep
+            if (start.isZero())
+              {
+                start = Time::now();
+                end = start + *this;
+              }
+
+            // If time jumped backwards from when we started sleeping, return immediately
+            if (Time::now() < start)
+              {
+                return false;
+              }
+          }
+
+        return rc && !g_stopped;
+      }
+  }
+
+  std::ostream &operator<<(std::ostream& os, const WallTime &rhs)
+  {
+    boost::io::ios_all_saver s(os);
+    os << rhs.sec << "." << std::setw(9) << std::setfill('0') << rhs.nsec;
+    return os;
+  }
+
+  WallTime WallTime::now()
+  {
+    WallTime t;
+    ros_walltime(t.sec, t.nsec);
+
+    return t;
+  }
+
+  std::ostream &operator<<(std::ostream& os, const WallDuration& rhs)
+  {
+    boost::io::ios_all_saver s(os);
+    if (rhs.sec >= 0 || rhs.nsec == 0)
+    {
+      os << rhs.sec << "." << std::setw(9) << std::setfill('0') << rhs.nsec;
+    }
+    else
+    {
+      os << (rhs.sec == -1 ? "-" : "") << (rhs.sec + 1) << "." << std::setw(9) << std::setfill('0') << (1000000000 - rhs.nsec);
+    }
+    return os;
+  }
+
+  bool WallDuration::sleep() const
+  {
+    return ros_wallsleep(sec, nsec);
+  }
+
+  void normalizeSecNSec(uint64_t& sec, uint64_t& nsec)
+  {
+    uint64_t nsec_part = nsec % 1000000000UL;
+    uint64_t sec_part = nsec / 1000000000UL;
+
+    if (sec + sec_part > UINT_MAX)
+      throw std::runtime_error("Time is out of dual 32-bit range");
+
+    sec += sec_part;
+    nsec = nsec_part;
+  }
+
+  void normalizeSecNSec(uint32_t& sec, uint32_t& nsec)
+  {
+    uint64_t sec64 = sec;
+    uint64_t nsec64 = nsec;
+
+    normalizeSecNSec(sec64, nsec64);
+
+    sec = (uint32_t)sec64;
+    nsec = (uint32_t)nsec64;
+  }
+
+  void normalizeSecNSecUnsigned(int64_t& sec, int64_t& nsec)
+  {
+    int64_t nsec_part = nsec % 1000000000L;
+    int64_t sec_part = sec + nsec / 1000000000L;
+    if (nsec_part < 0)
+      {
+        nsec_part += 1000000000L;
+        --sec_part;
+      }
+
+    if (sec_part < 0 || sec_part > UINT_MAX)
+      throw std::runtime_error("Time is out of dual 32-bit range");
+
+    sec = sec_part;
+    nsec = nsec_part;
+  }
+
+  template class TimeBase;
+  template class TimeBase;
+}
+
+