summaryrefslogtreecommitdiff
path: root/inference-engine/thirdparty/clDNN/common/boost/1.64.0/include/boost-1_64/boost/concept_archetype.hpp
diff options
context:
space:
mode:
Diffstat (limited to 'inference-engine/thirdparty/clDNN/common/boost/1.64.0/include/boost-1_64/boost/concept_archetype.hpp')
-rw-r--r--inference-engine/thirdparty/clDNN/common/boost/1.64.0/include/boost-1_64/boost/concept_archetype.hpp669
1 files changed, 0 insertions, 669 deletions
diff --git a/inference-engine/thirdparty/clDNN/common/boost/1.64.0/include/boost-1_64/boost/concept_archetype.hpp b/inference-engine/thirdparty/clDNN/common/boost/1.64.0/include/boost-1_64/boost/concept_archetype.hpp
deleted file mode 100644
index f21c81738..000000000
--- a/inference-engine/thirdparty/clDNN/common/boost/1.64.0/include/boost-1_64/boost/concept_archetype.hpp
+++ /dev/null
@@ -1,669 +0,0 @@
-//
-// (C) Copyright Jeremy Siek 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)
-//
-// Revision History:
-//
-// 17 July 2001: Added const to some member functions. (Jeremy Siek)
-// 05 May 2001: Removed static dummy_cons object. (Jeremy Siek)
-
-// See http://www.boost.org/libs/concept_check for documentation.
-
-#ifndef BOOST_CONCEPT_ARCHETYPES_HPP
-#define BOOST_CONCEPT_ARCHETYPES_HPP
-
-#include <boost/config.hpp>
-#include <boost/iterator.hpp>
-#include <boost/mpl/identity.hpp>
-#include <functional>
-
-namespace boost {
-
- //===========================================================================
- // Basic Archetype Classes
-
- namespace detail {
- class dummy_constructor { };
- }
-
- // A type that models no concept. The template parameter
- // is only there so that null_archetype types can be created
- // that have different type.
- template <class T = int>
- class null_archetype {
- private:
- null_archetype() { }
- null_archetype(const null_archetype&) { }
- null_archetype& operator=(const null_archetype&) { return *this; }
- public:
- null_archetype(detail::dummy_constructor) { }
-#ifndef __MWERKS__
- template <class TT>
- friend void dummy_friend(); // just to avoid warnings
-#endif
- };
-
- // This is a helper class that provides a way to get a reference to
- // an object. The get() function will never be called at run-time
- // (nothing in this file will) so this seemingly very bad function
- // is really quite innocent. The name of this class needs to be
- // changed.
- template <class T>
- class static_object
- {
- public:
- static T& get()
- {
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
- return *reinterpret_cast<T*>(0);
-#else
- static char d[sizeof(T)];
- return *reinterpret_cast<T*>(d);
-#endif
- }
- };
-
- template <class Base = null_archetype<> >
- class default_constructible_archetype : public Base {
- public:
- default_constructible_archetype()
- : Base(static_object<detail::dummy_constructor>::get()) { }
- default_constructible_archetype(detail::dummy_constructor x) : Base(x) { }
- };
-
- template <class Base = null_archetype<> >
- class assignable_archetype : public Base {
- assignable_archetype() { }
- assignable_archetype(const assignable_archetype&) { }
- public:
- assignable_archetype& operator=(const assignable_archetype&) {
- return *this;
- }
- assignable_archetype(detail::dummy_constructor x) : Base(x) { }
- };
-
- template <class Base = null_archetype<> >
- class copy_constructible_archetype : public Base {
- public:
- copy_constructible_archetype()
- : Base(static_object<detail::dummy_constructor>::get()) { }
- copy_constructible_archetype(const copy_constructible_archetype&)
- : Base(static_object<detail::dummy_constructor>::get()) { }
- copy_constructible_archetype(detail::dummy_constructor x) : Base(x) { }
- };
-
- template <class Base = null_archetype<> >
- class sgi_assignable_archetype : public Base {
- public:
- sgi_assignable_archetype(const sgi_assignable_archetype&)
- : Base(static_object<detail::dummy_constructor>::get()) { }
- sgi_assignable_archetype& operator=(const sgi_assignable_archetype&) {
- return *this;
- }
- sgi_assignable_archetype(const detail::dummy_constructor& x) : Base(x) { }
- };
-
- struct default_archetype_base {
- default_archetype_base(detail::dummy_constructor) { }
- };
-
- // Careful, don't use same type for T and Base. That results in the
- // conversion operator being invalid. Since T is often
- // null_archetype, can't use null_archetype for Base.
- template <class T, class Base = default_archetype_base>
- class convertible_to_archetype : public Base {
- private:
- convertible_to_archetype() { }
- convertible_to_archetype(const convertible_to_archetype& ) { }
- convertible_to_archetype& operator=(const convertible_to_archetype&)
- { return *this; }
- public:
- convertible_to_archetype(detail::dummy_constructor x) : Base(x) { }
- operator const T&() const { return static_object<T>::get(); }
- };
-
- template <class T, class Base = default_archetype_base>
- class convertible_from_archetype : public Base {
- private:
- convertible_from_archetype() { }
- convertible_from_archetype(const convertible_from_archetype& ) { }
- convertible_from_archetype& operator=(const convertible_from_archetype&)
- { return *this; }
- public:
- convertible_from_archetype(detail::dummy_constructor x) : Base(x) { }
- convertible_from_archetype(const T&) { }
- convertible_from_archetype& operator=(const T&)
- { return *this; }
- };
-
- class boolean_archetype {
- public:
- boolean_archetype(const boolean_archetype&) { }
- operator bool() const { return true; }
- boolean_archetype(detail::dummy_constructor) { }
- private:
- boolean_archetype() { }
- boolean_archetype& operator=(const boolean_archetype&) { return *this; }
- };
-
- template <class Base = null_archetype<> >
- class equality_comparable_archetype : public Base {
- public:
- equality_comparable_archetype(detail::dummy_constructor x) : Base(x) { }
- };
- template <class Base>
- boolean_archetype
- operator==(const equality_comparable_archetype<Base>&,
- const equality_comparable_archetype<Base>&)
- {
- return boolean_archetype(static_object<detail::dummy_constructor>::get());
- }
- template <class Base>
- boolean_archetype
- operator!=(const equality_comparable_archetype<Base>&,
- const equality_comparable_archetype<Base>&)
- {
- return boolean_archetype(static_object<detail::dummy_constructor>::get());
- }
-
-
- template <class Base = null_archetype<> >
- class equality_comparable2_first_archetype : public Base {
- public:
- equality_comparable2_first_archetype(detail::dummy_constructor x)
- : Base(x) { }
- };
- template <class Base = null_archetype<> >
- class equality_comparable2_second_archetype : public Base {
- public:
- equality_comparable2_second_archetype(detail::dummy_constructor x)
- : Base(x) { }
- };
- template <class Base1, class Base2>
- boolean_archetype
- operator==(const equality_comparable2_first_archetype<Base1>&,
- const equality_comparable2_second_archetype<Base2>&)
- {
- return boolean_archetype(static_object<detail::dummy_constructor>::get());
- }
- template <class Base1, class Base2>
- boolean_archetype
- operator!=(const equality_comparable2_first_archetype<Base1>&,
- const equality_comparable2_second_archetype<Base2>&)
- {
- return boolean_archetype(static_object<detail::dummy_constructor>::get());
- }
-
-
- template <class Base = null_archetype<> >
- class less_than_comparable_archetype : public Base {
- public:
- less_than_comparable_archetype(detail::dummy_constructor x) : Base(x) { }
- };
- template <class Base>
- boolean_archetype
- operator<(const less_than_comparable_archetype<Base>&,
- const less_than_comparable_archetype<Base>&)
- {
- return boolean_archetype(static_object<detail::dummy_constructor>::get());
- }
-
-
-
- template <class Base = null_archetype<> >
- class comparable_archetype : public Base {
- public:
- comparable_archetype(detail::dummy_constructor x) : Base(x) { }
- };
- template <class Base>
- boolean_archetype
- operator<(const comparable_archetype<Base>&,
- const comparable_archetype<Base>&)
- {
- return boolean_archetype(static_object<detail::dummy_constructor>::get());
- }
- template <class Base>
- boolean_archetype
- operator<=(const comparable_archetype<Base>&,
- const comparable_archetype<Base>&)
- {
- return boolean_archetype(static_object<detail::dummy_constructor>::get());
- }
- template <class Base>
- boolean_archetype
- operator>(const comparable_archetype<Base>&,
- const comparable_archetype<Base>&)
- {
- return boolean_archetype(static_object<detail::dummy_constructor>::get());
- }
- template <class Base>
- boolean_archetype
- operator>=(const comparable_archetype<Base>&,
- const comparable_archetype<Base>&)
- {
- return boolean_archetype(static_object<detail::dummy_constructor>::get());
- }
-
-
- // The purpose of the optags is so that one can specify
- // exactly which types the operator< is defined between.
- // This is useful for allowing the operations:
- //
- // A a; B b;
- // a < b
- // b < a
- //
- // without also allowing the combinations:
- //
- // a < a
- // b < b
- //
- struct optag1 { };
- struct optag2 { };
- struct optag3 { };
-
-#define BOOST_DEFINE_BINARY_PREDICATE_ARCHETYPE(OP, NAME) \
- template <class Base = null_archetype<>, class Tag = optag1 > \
- class NAME##_first_archetype : public Base { \
- public: \
- NAME##_first_archetype(detail::dummy_constructor x) : Base(x) { } \
- }; \
- \
- template <class Base = null_archetype<>, class Tag = optag1 > \
- class NAME##_second_archetype : public Base { \
- public: \
- NAME##_second_archetype(detail::dummy_constructor x) : Base(x) { } \
- }; \
- \
- template <class BaseFirst, class BaseSecond, class Tag> \
- boolean_archetype \
- operator OP (const NAME##_first_archetype<BaseFirst, Tag>&, \
- const NAME##_second_archetype<BaseSecond, Tag>&) \
- { \
- return boolean_archetype(static_object<detail::dummy_constructor>::get()); \
- }
-
- BOOST_DEFINE_BINARY_PREDICATE_ARCHETYPE(==, equal_op)
- BOOST_DEFINE_BINARY_PREDICATE_ARCHETYPE(!=, not_equal_op)
- BOOST_DEFINE_BINARY_PREDICATE_ARCHETYPE(<, less_than_op)
- BOOST_DEFINE_BINARY_PREDICATE_ARCHETYPE(<=, less_equal_op)
- BOOST_DEFINE_BINARY_PREDICATE_ARCHETYPE(>, greater_than_op)
- BOOST_DEFINE_BINARY_PREDICATE_ARCHETYPE(>=, greater_equal_op)
-
-#define BOOST_DEFINE_OPERATOR_ARCHETYPE(OP, NAME) \
- template <class Base = null_archetype<> > \
- class NAME##_archetype : public Base { \
- public: \
- NAME##_archetype(detail::dummy_constructor x) : Base(x) { } \
- NAME##_archetype(const NAME##_archetype&) \
- : Base(static_object<detail::dummy_constructor>::get()) { } \
- NAME##_archetype& operator=(const NAME##_archetype&) { return *this; } \
- }; \
- template <class Base> \
- NAME##_archetype<Base> \
- operator OP (const NAME##_archetype<Base>&,\
- const NAME##_archetype<Base>&) \
- { \
- return \
- NAME##_archetype<Base>(static_object<detail::dummy_constructor>::get()); \
- }
-
- BOOST_DEFINE_OPERATOR_ARCHETYPE(+, addable)
- BOOST_DEFINE_OPERATOR_ARCHETYPE(-, subtractable)
- BOOST_DEFINE_OPERATOR_ARCHETYPE(*, multipliable)
- BOOST_DEFINE_OPERATOR_ARCHETYPE(/, dividable)
- BOOST_DEFINE_OPERATOR_ARCHETYPE(%, modable)
-
- // As is, these are useless because of the return type.
- // Need to invent a better way...
-#define BOOST_DEFINE_BINARY_OPERATOR_ARCHETYPE(OP, NAME) \
- template <class Return, class Base = null_archetype<> > \
- class NAME##_first_archetype : public Base { \
- public: \
- NAME##_first_archetype(detail::dummy_constructor x) : Base(x) { } \
- }; \
- \
- template <class Return, class Base = null_archetype<> > \
- class NAME##_second_archetype : public Base { \
- public: \
- NAME##_second_archetype(detail::dummy_constructor x) : Base(x) { } \
- }; \
- \
- template <class Return, class BaseFirst, class BaseSecond> \
- Return \
- operator OP (const NAME##_first_archetype<Return, BaseFirst>&, \
- const NAME##_second_archetype<Return, BaseSecond>&) \
- { \
- return Return(static_object<detail::dummy_constructor>::get()); \
- }
-
- BOOST_DEFINE_BINARY_OPERATOR_ARCHETYPE(+, plus_op)
- BOOST_DEFINE_BINARY_OPERATOR_ARCHETYPE(*, time_op)
- BOOST_DEFINE_BINARY_OPERATOR_ARCHETYPE(/, divide_op)
- BOOST_DEFINE_BINARY_OPERATOR_ARCHETYPE(-, subtract_op)
- BOOST_DEFINE_BINARY_OPERATOR_ARCHETYPE(%, mod_op)
-
- //===========================================================================
- // Function Object Archetype Classes
-
- template <class Return>
- class generator_archetype {
- public:
- const Return& operator()() {
- return static_object<Return>::get();
- }
- };
-
- class void_generator_archetype {
- public:
- void operator()() { }
- };
-
- template <class Arg, class Return>
- class unary_function_archetype {
- private:
- unary_function_archetype() { }
- public:
- unary_function_archetype(detail::dummy_constructor) { }
- const Return& operator()(const Arg&) const {
- return static_object<Return>::get();
- }
- };
-
- template <class Arg1, class Arg2, class Return>
- class binary_function_archetype {
- private:
- binary_function_archetype() { }
- public:
- binary_function_archetype(detail::dummy_constructor) { }
- const Return& operator()(const Arg1&, const Arg2&) const {
- return static_object<Return>::get();
- }
- };
-
- template <class Arg>
- class unary_predicate_archetype {
- typedef boolean_archetype Return;
- unary_predicate_archetype() { }
- public:
- unary_predicate_archetype(detail::dummy_constructor) { }
- const Return& operator()(const Arg&) const {
- return static_object<Return>::get();
- }
- };
-
- template <class Arg1, class Arg2, class Base = null_archetype<> >
- class binary_predicate_archetype {
- typedef boolean_archetype Return;
- binary_predicate_archetype() { }
- public:
- binary_predicate_archetype(detail::dummy_constructor) { }
- const Return& operator()(const Arg1&, const Arg2&) const {
- return static_object<Return>::get();
- }
- };
-
- //===========================================================================
- // Iterator Archetype Classes
-
- template <class T, int I = 0>
- class input_iterator_archetype
- {
- private:
- typedef input_iterator_archetype self;
- public:
- typedef std::input_iterator_tag iterator_category;
- typedef T value_type;
- struct reference {
- operator const value_type&() const { return static_object<T>::get(); }
- };
- typedef const T* pointer;
- typedef std::ptrdiff_t difference_type;
- self& operator=(const self&) { return *this; }
- bool operator==(const self&) const { return true; }
- bool operator!=(const self&) const { return true; }
- reference operator*() const { return reference(); }
- self& operator++() { return *this; }
- self operator++(int) { return *this; }
- };
-
- template <class T>
- class input_iterator_archetype_no_proxy
- {
- private:
- typedef input_iterator_archetype_no_proxy self;
- public:
- typedef std::input_iterator_tag iterator_category;
- typedef T value_type;
- typedef const T& reference;
- typedef const T* pointer;
- typedef std::ptrdiff_t difference_type;
- self& operator=(const self&) { return *this; }
- bool operator==(const self&) const { return true; }
- bool operator!=(const self&) const { return true; }
- reference operator*() const { return static_object<T>::get(); }
- self& operator++() { return *this; }
- self operator++(int) { return *this; }
- };
-
- template <class T>
- struct output_proxy {
- output_proxy& operator=(const T&) { return *this; }
- };
-
- template <class T>
- class output_iterator_archetype
- {
- public:
- typedef output_iterator_archetype self;
- public:
- typedef std::output_iterator_tag iterator_category;
- typedef output_proxy<T> value_type;
- typedef output_proxy<T> reference;
- typedef void pointer;
- typedef void difference_type;
- output_iterator_archetype(detail::dummy_constructor) { }
- output_iterator_archetype(const self&) { }
- self& operator=(const self&) { return *this; }
- bool operator==(const self&) const { return true; }
- bool operator!=(const self&) const { return true; }
- reference operator*() const { return output_proxy<T>(); }
- self& operator++() { return *this; }
- self operator++(int) { return *this; }
- private:
- output_iterator_archetype() { }
- };
-
- template <class T>
- class input_output_iterator_archetype
- {
- private:
- typedef input_output_iterator_archetype self;
- struct in_out_tag : public std::input_iterator_tag, public std::output_iterator_tag { };
- public:
- typedef in_out_tag iterator_category;
- typedef T value_type;
- struct reference {
- reference& operator=(const T&) { return *this; }
- operator value_type() { return static_object<T>::get(); }
- };
- typedef const T* pointer;
- typedef std::ptrdiff_t difference_type;
- input_output_iterator_archetype() { }
- self& operator=(const self&) { return *this; }
- bool operator==(const self&) const { return true; }
- bool operator!=(const self&) const { return true; }
- reference operator*() const { return reference(); }
- self& operator++() { return *this; }
- self operator++(int) { return *this; }
- };
-
- template <class T>
- class forward_iterator_archetype
- {
- public:
- typedef forward_iterator_archetype self;
- public:
- typedef std::forward_iterator_tag iterator_category;
- typedef T value_type;
- typedef const T& reference;
- typedef T const* pointer;
- typedef std::ptrdiff_t difference_type;
- forward_iterator_archetype() { }
- self& operator=(const self&) { return *this; }
- bool operator==(const self&) const { return true; }
- bool operator!=(const self&) const { return true; }
- reference operator*() const { return static_object<T>::get(); }
- self& operator++() { return *this; }
- self operator++(int) { return *this; }
- };
-
- template <class T>
- class mutable_forward_iterator_archetype
- {
- public:
- typedef mutable_forward_iterator_archetype self;
- public:
- typedef std::forward_iterator_tag iterator_category;
- typedef T value_type;
- typedef T& reference;
- typedef T* pointer;
- typedef std::ptrdiff_t difference_type;
- mutable_forward_iterator_archetype() { }
- self& operator=(const self&) { return *this; }
- bool operator==(const self&) const { return true; }
- bool operator!=(const self&) const { return true; }
- reference operator*() const { return static_object<T>::get(); }
- self& operator++() { return *this; }
- self operator++(int) { return *this; }
- };
-
- template <class T>
- class bidirectional_iterator_archetype
- {
- public:
- typedef bidirectional_iterator_archetype self;
- public:
- typedef std::bidirectional_iterator_tag iterator_category;
- typedef T value_type;
- typedef const T& reference;
- typedef T* pointer;
- typedef std::ptrdiff_t difference_type;
- bidirectional_iterator_archetype() { }
- self& operator=(const self&) { return *this; }
- bool operator==(const self&) const { return true; }
- bool operator!=(const self&) const { return true; }
- reference operator*() const { return static_object<T>::get(); }
- self& operator++() { return *this; }
- self operator++(int) { return *this; }
- self& operator--() { return *this; }
- self operator--(int) { return *this; }
- };
-
- template <class T>
- class mutable_bidirectional_iterator_archetype
- {
- public:
- typedef mutable_bidirectional_iterator_archetype self;
- public:
- typedef std::bidirectional_iterator_tag iterator_category;
- typedef T value_type;
- typedef T& reference;
- typedef T* pointer;
- typedef std::ptrdiff_t difference_type;
- mutable_bidirectional_iterator_archetype() { }
- self& operator=(const self&) { return *this; }
- bool operator==(const self&) const { return true; }
- bool operator!=(const self&) const { return true; }
- reference operator*() const { return static_object<T>::get(); }
- self& operator++() { return *this; }
- self operator++(int) { return *this; }
- self& operator--() { return *this; }
- self operator--(int) { return *this; }
- };
-
- template <class T>
- class random_access_iterator_archetype
- {
- public:
- typedef random_access_iterator_archetype self;
- public:
- typedef std::random_access_iterator_tag iterator_category;
- typedef T value_type;
- typedef const T& reference;
- typedef T* pointer;
- typedef std::ptrdiff_t difference_type;
- random_access_iterator_archetype() { }
- self& operator=(const self&) { return *this; }
- bool operator==(const self&) const { return true; }
- bool operator!=(const self&) const { return true; }
- reference operator*() const { return static_object<T>::get(); }
- self& operator++() { return *this; }
- self operator++(int) { return *this; }
- self& operator--() { return *this; }
- self operator--(int) { return *this; }
- reference operator[](difference_type) const
- { return static_object<T>::get(); }
- self& operator+=(difference_type) { return *this; }
- self& operator-=(difference_type) { return *this; }
- difference_type operator-(const self&) const
- { return difference_type(); }
- self operator+(difference_type) const { return *this; }
- self operator-(difference_type) const { return *this; }
- bool operator<(const self&) const { return true; }
- bool operator<=(const self&) const { return true; }
- bool operator>(const self&) const { return true; }
- bool operator>=(const self&) const { return true; }
- };
- template <class T>
- random_access_iterator_archetype<T>
- operator+(typename random_access_iterator_archetype<T>::difference_type,
- const random_access_iterator_archetype<T>& x)
- { return x; }
-
-
- template <class T>
- class mutable_random_access_iterator_archetype
- {
- public:
- typedef mutable_random_access_iterator_archetype self;
- public:
- typedef std::random_access_iterator_tag iterator_category;
- typedef T value_type;
- typedef T& reference;
- typedef T* pointer;
- typedef std::ptrdiff_t difference_type;
- mutable_random_access_iterator_archetype() { }
- self& operator=(const self&) { return *this; }
- bool operator==(const self&) const { return true; }
- bool operator!=(const self&) const { return true; }
- reference operator*() const { return static_object<T>::get(); }
- self& operator++() { return *this; }
- self operator++(int) { return *this; }
- self& operator--() { return *this; }
- self operator--(int) { return *this; }
- reference operator[](difference_type) const
- { return static_object<T>::get(); }
- self& operator+=(difference_type) { return *this; }
- self& operator-=(difference_type) { return *this; }
- difference_type operator-(const self&) const
- { return difference_type(); }
- self operator+(difference_type) const { return *this; }
- self operator-(difference_type) const { return *this; }
- bool operator<(const self&) const { return true; }
- bool operator<=(const self&) const { return true; }
- bool operator>(const self&) const { return true; }
- bool operator>=(const self&) const { return true; }
- };
- template <class T>
- mutable_random_access_iterator_archetype<T>
- operator+
- (typename mutable_random_access_iterator_archetype<T>::difference_type,
- const mutable_random_access_iterator_archetype<T>& x)
- { return x; }
-
-} // namespace boost
-
-#endif // BOOST_CONCEPT_ARCHETYPES_H
generated by cgit v1.2.3 (git 2.25.1) at 2024-06-25 02:40:19 +0000