github.com/searKing/golang/go@v1.2.74/os/signal/cgo/include/boost/array.hpp (about)

     1  /* The following code declares class array,
     2   * an STL container (as wrapper) for arrays of constant size.
     3   *
     4   * See
     5   *      http://www.boost.org/libs/array/
     6   * for documentation.
     7   *
     8   * The original author site is at: http://www.josuttis.com/
     9   *
    10   * (C) Copyright Nicolai M. Josuttis 2001.
    11   *
    12   * Distributed under the Boost Software License, Version 1.0. (See
    13   * accompanying file LICENSE_1_0.txt or copy at
    14   * http://www.boost.org/LICENSE_1_0.txt)
    15   *
    16   *  9 Jan 2013 - (mtc) Added constexpr
    17   * 14 Apr 2012 - (mtc) Added support for boost::hash
    18   * 28 Dec 2010 - (mtc) Added cbegin and cend (and crbegin and crend) for C++Ox compatibility.
    19   * 10 Mar 2010 - (mtc) fill method added, matching resolution of the standard library working group.
    20   *      See <http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#776> or Trac issue #3168
    21   *      Eventually, we should remove "assign" which is now a synonym for "fill" (Marshall Clow)
    22   * 10 Mar 2010 - added workaround for SUNCC and !STLPort [trac #3893] (Marshall Clow)
    23   * 29 Jan 2004 - c_array() added, BOOST_NO_PRIVATE_IN_AGGREGATE removed (Nico Josuttis)
    24   * 23 Aug 2002 - fix for Non-MSVC compilers combined with MSVC libraries.
    25   * 05 Aug 2001 - minor update (Nico Josuttis)
    26   * 20 Jan 2001 - STLport fix (Beman Dawes)
    27   * 29 Sep 2000 - Initial Revision (Nico Josuttis)
    28   *
    29   * Jan 29, 2004
    30   */
    31  #ifndef BOOST_ARRAY_HPP
    32  #define BOOST_ARRAY_HPP
    33  
    34  #include <boost/detail/workaround.hpp>
    35  
    36  #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)  
    37  # pragma warning(push)  
    38  # pragma warning(disable:4996) // 'std::equal': Function call with parameters that may be unsafe
    39  # pragma warning(disable:4510) // boost::array<T,N>' : default constructor could not be generated 
    40  # pragma warning(disable:4610) // warning C4610: class 'boost::array<T,N>' can never be instantiated - user defined constructor required 
    41  #endif
    42  
    43  #include <cstddef>
    44  #include <stdexcept>
    45  #include <boost/assert.hpp>
    46  #include <boost/static_assert.hpp>
    47  #include <boost/swap.hpp>
    48  
    49  // Handles broken standard libraries better than <iterator>
    50  #include <boost/detail/iterator.hpp>
    51  #include <boost/throw_exception.hpp>
    52  #include <algorithm>
    53  
    54  // FIXES for broken compilers
    55  #include <boost/config.hpp>
    56  
    57  
    58  namespace boost {
    59  
    60      template<class T, std::size_t N>
    61      class array {
    62        public:
    63          T elems[N];    // fixed-size array of elements of type T
    64  
    65        public:
    66          // type definitions
    67          typedef T              value_type;
    68          typedef T*             iterator;
    69          typedef const T*       const_iterator;
    70          typedef T&             reference;
    71          typedef const T&       const_reference;
    72          typedef std::size_t    size_type;
    73          typedef std::ptrdiff_t difference_type;
    74  
    75          // iterator support
    76          iterator        begin()       { return elems; }
    77          const_iterator  begin() const { return elems; }
    78          const_iterator cbegin() const { return elems; }
    79          
    80          iterator        end()       { return elems+N; }
    81          const_iterator  end() const { return elems+N; }
    82          const_iterator cend() const { return elems+N; }
    83  
    84          // reverse iterator support
    85  #if !defined(BOOST_MSVC_STD_ITERATOR) && !defined(BOOST_NO_STD_ITERATOR_TRAITS)
    86          typedef std::reverse_iterator<iterator> reverse_iterator;
    87          typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
    88  #elif defined(_RWSTD_NO_CLASS_PARTIAL_SPEC) 
    89          typedef std::reverse_iterator<iterator, std::random_access_iterator_tag, 
    90                value_type, reference, iterator, difference_type> reverse_iterator; 
    91          typedef std::reverse_iterator<const_iterator, std::random_access_iterator_tag,
    92                value_type, const_reference, const_iterator, difference_type> const_reverse_iterator;
    93  #else
    94          // workaround for broken reverse_iterator implementations
    95          typedef std::reverse_iterator<iterator,T> reverse_iterator;
    96          typedef std::reverse_iterator<const_iterator,T> const_reverse_iterator;
    97  #endif
    98  
    99          reverse_iterator rbegin() { return reverse_iterator(end()); }
   100          const_reverse_iterator rbegin() const {
   101              return const_reverse_iterator(end());
   102          }
   103          const_reverse_iterator crbegin() const {
   104              return const_reverse_iterator(end());
   105          }
   106  
   107          reverse_iterator rend() { return reverse_iterator(begin()); }
   108          const_reverse_iterator rend() const {
   109              return const_reverse_iterator(begin());
   110          }
   111          const_reverse_iterator crend() const {
   112              return const_reverse_iterator(begin());
   113          }
   114  
   115          // operator[]
   116          reference operator[](size_type i) 
   117          { 
   118              return BOOST_ASSERT_MSG( i < N, "out of range" ), elems[i]; 
   119          }
   120          
   121          /*BOOST_CONSTEXPR*/ const_reference operator[](size_type i) const 
   122          {     
   123              return BOOST_ASSERT_MSG( i < N, "out of range" ), elems[i]; 
   124          }
   125  
   126          // at() with range check
   127          reference                           at(size_type i)       { return rangecheck(i), elems[i]; }
   128          /*BOOST_CONSTEXPR*/ const_reference at(size_type i) const { return rangecheck(i), elems[i]; }
   129      
   130          // front() and back()
   131          reference front() 
   132          { 
   133              return elems[0]; 
   134          }
   135          
   136          BOOST_CONSTEXPR const_reference front() const 
   137          {
   138              return elems[0];
   139          }
   140          
   141          reference back() 
   142          { 
   143              return elems[N-1]; 
   144          }
   145          
   146          BOOST_CONSTEXPR const_reference back() const 
   147          { 
   148              return elems[N-1]; 
   149          }
   150  
   151          // size is constant
   152          static BOOST_CONSTEXPR size_type size() { return N; }
   153          static BOOST_CONSTEXPR bool empty() { return false; }
   154          static BOOST_CONSTEXPR size_type max_size() { return N; }
   155          enum { static_size = N };
   156  
   157          // swap (note: linear complexity)
   158          void swap (array<T,N>& y) {
   159              for (size_type i = 0; i < N; ++i)
   160                  boost::swap(elems[i],y.elems[i]);
   161          }
   162  
   163          // direct access to data (read-only)
   164          const T* data() const { return elems; }
   165          T* data() { return elems; }
   166  
   167          // use array as C array (direct read/write access to data)
   168          T* c_array() { return elems; }
   169  
   170          // assignment with type conversion
   171          template <typename T2>
   172          array<T,N>& operator= (const array<T2,N>& rhs) {
   173              std::copy(rhs.begin(),rhs.end(), begin());
   174              return *this;
   175          }
   176  
   177          // assign one value to all elements
   178          void assign (const T& value) { fill ( value ); }    // A synonym for fill
   179          void fill   (const T& value)
   180          {
   181              std::fill_n(begin(),size(),value);
   182          }
   183  
   184          // check range (may be private because it is static)
   185          static BOOST_CONSTEXPR bool rangecheck (size_type i) {
   186              return i >= size() ? boost::throw_exception(std::out_of_range ("array<>: index out of range")), true : true;
   187          }
   188  
   189      };
   190  
   191      template< class T >
   192      class array< T, 0 > {
   193  
   194        public:
   195          // type definitions
   196          typedef T              value_type;
   197          typedef T*             iterator;
   198          typedef const T*       const_iterator;
   199          typedef T&             reference;
   200          typedef const T&       const_reference;
   201          typedef std::size_t    size_type;
   202          typedef std::ptrdiff_t difference_type;
   203  
   204          // iterator support
   205          iterator        begin()       { return       iterator( reinterpret_cast<       T * >( this ) ); }
   206          const_iterator  begin() const { return const_iterator( reinterpret_cast< const T * >( this ) ); }
   207          const_iterator cbegin() const { return const_iterator( reinterpret_cast< const T * >( this ) ); }
   208  
   209          iterator        end()       { return  begin(); }
   210          const_iterator  end() const { return  begin(); }
   211          const_iterator cend() const { return cbegin(); }
   212  
   213          // reverse iterator support
   214  #if !defined(BOOST_MSVC_STD_ITERATOR) && !defined(BOOST_NO_STD_ITERATOR_TRAITS)
   215          typedef std::reverse_iterator<iterator> reverse_iterator;
   216          typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
   217  #elif defined(_RWSTD_NO_CLASS_PARTIAL_SPEC) 
   218          typedef std::reverse_iterator<iterator, std::random_access_iterator_tag, 
   219                value_type, reference, iterator, difference_type> reverse_iterator; 
   220          typedef std::reverse_iterator<const_iterator, std::random_access_iterator_tag,
   221                value_type, const_reference, const_iterator, difference_type> const_reverse_iterator;
   222  #else
   223          // workaround for broken reverse_iterator implementations
   224          typedef std::reverse_iterator<iterator,T> reverse_iterator;
   225          typedef std::reverse_iterator<const_iterator,T> const_reverse_iterator;
   226  #endif
   227  
   228          reverse_iterator rbegin() { return reverse_iterator(end()); }
   229          const_reverse_iterator rbegin() const {
   230              return const_reverse_iterator(end());
   231          }
   232          const_reverse_iterator crbegin() const {
   233              return const_reverse_iterator(end());
   234          }
   235  
   236          reverse_iterator rend() { return reverse_iterator(begin()); }
   237          const_reverse_iterator rend() const {
   238              return const_reverse_iterator(begin());
   239          }
   240          const_reverse_iterator crend() const {
   241              return const_reverse_iterator(begin());
   242          }
   243  
   244          // operator[]
   245          reference operator[](size_type /*i*/)
   246          {
   247              return failed_rangecheck();
   248          }
   249  
   250          /*BOOST_CONSTEXPR*/ const_reference operator[](size_type /*i*/) const
   251          {
   252              return failed_rangecheck();
   253          }
   254  
   255          // at() with range check
   256          reference at(size_type /*i*/)               {   return failed_rangecheck(); }
   257          /*BOOST_CONSTEXPR*/ const_reference at(size_type /*i*/) const   { return failed_rangecheck(); }
   258  
   259          // front() and back()
   260          reference front()
   261          {
   262              return failed_rangecheck();
   263          }
   264  
   265          BOOST_CONSTEXPR const_reference front() const
   266          {
   267              return failed_rangecheck();
   268          }
   269  
   270          reference back()
   271          {
   272              return failed_rangecheck();
   273          }
   274  
   275          BOOST_CONSTEXPR const_reference back() const
   276          {
   277              return failed_rangecheck();
   278          }
   279  
   280          // size is constant
   281          static BOOST_CONSTEXPR size_type size() { return 0; }
   282          static BOOST_CONSTEXPR bool empty() { return true; }
   283          static BOOST_CONSTEXPR size_type max_size() { return 0; }
   284          enum { static_size = 0 };
   285  
   286          void swap (array<T,0>& /*y*/) {
   287          }
   288  
   289          // direct access to data (read-only)
   290          const T* data() const { return 0; }
   291          T* data() { return 0; }
   292  
   293          // use array as C array (direct read/write access to data)
   294          T* c_array() { return 0; }
   295  
   296          // assignment with type conversion
   297          template <typename T2>
   298          array<T,0>& operator= (const array<T2,0>& ) {
   299              return *this;
   300          }
   301  
   302          // assign one value to all elements
   303          void assign (const T& value) { fill ( value ); }
   304          void fill   (const T& ) {}
   305          
   306          // check range (may be private because it is static)
   307          static reference failed_rangecheck () {
   308                  std::out_of_range e("attempt to access element of an empty array");
   309                  boost::throw_exception(e);
   310  #if defined(BOOST_NO_EXCEPTIONS) || (!defined(BOOST_MSVC) && !defined(__PATHSCALE__))
   311                  //
   312                  // We need to return something here to keep
   313                  // some compilers happy: however we will never
   314                  // actually get here....
   315                  //
   316                  static T placeholder;
   317                  return placeholder;
   318  #endif
   319              }
   320      };
   321  
   322      // comparisons
   323      template<class T, std::size_t N>
   324      bool operator== (const array<T,N>& x, const array<T,N>& y) {
   325          return std::equal(x.begin(), x.end(), y.begin());
   326      }
   327      template<class T, std::size_t N>
   328      bool operator< (const array<T,N>& x, const array<T,N>& y) {
   329          return std::lexicographical_compare(x.begin(),x.end(),y.begin(),y.end());
   330      }
   331      template<class T, std::size_t N>
   332      bool operator!= (const array<T,N>& x, const array<T,N>& y) {
   333          return !(x==y);
   334      }
   335      template<class T, std::size_t N>
   336      bool operator> (const array<T,N>& x, const array<T,N>& y) {
   337          return y<x;
   338      }
   339      template<class T, std::size_t N>
   340      bool operator<= (const array<T,N>& x, const array<T,N>& y) {
   341          return !(y<x);
   342      }
   343      template<class T, std::size_t N>
   344      bool operator>= (const array<T,N>& x, const array<T,N>& y) {
   345          return !(x<y);
   346      }
   347  
   348      // global swap()
   349      template<class T, std::size_t N>
   350      inline void swap (array<T,N>& x, array<T,N>& y) {
   351          x.swap(y);
   352      }
   353  
   354  #if defined(__SUNPRO_CC)
   355  //  Trac ticket #4757; the Sun Solaris compiler can't handle
   356  //  syntax like 'T(&get_c_array(boost::array<T,N>& arg))[N]'
   357  //  
   358  //  We can't just use this for all compilers, because the 
   359  //      borland compilers can't handle this form. 
   360      namespace detail {
   361         template <typename T, std::size_t N> struct c_array
   362         {
   363             typedef T type[N];
   364         };
   365      }
   366      
   367     // Specific for boost::array: simply returns its elems data member.
   368     template <typename T, std::size_t N>
   369     typename detail::c_array<T,N>::type& get_c_array(boost::array<T,N>& arg)
   370     {
   371         return arg.elems;
   372     }
   373  
   374     // Specific for boost::array: simply returns its elems data member.
   375     template <typename T, std::size_t N>
   376     typename detail::c_array<T,N>::type const& get_c_array(const boost::array<T,N>& arg)
   377     {
   378         return arg.elems;
   379     }
   380  #else
   381  // Specific for boost::array: simply returns its elems data member.
   382      template <typename T, std::size_t N>
   383      T(&get_c_array(boost::array<T,N>& arg))[N]
   384      {
   385          return arg.elems;
   386      }
   387      
   388      // Const version.
   389      template <typename T, std::size_t N>
   390      const T(&get_c_array(const boost::array<T,N>& arg))[N]
   391      {
   392          return arg.elems;
   393      }
   394  #endif
   395      
   396  #if 0
   397      // Overload for std::array, assuming that std::array will have
   398      // explicit conversion functions as discussed at the WG21 meeting
   399      // in Summit, March 2009.
   400      template <typename T, std::size_t N>
   401      T(&get_c_array(std::array<T,N>& arg))[N]
   402      {
   403          return static_cast<T(&)[N]>(arg);
   404      }
   405      
   406      // Const version.
   407      template <typename T, std::size_t N>
   408      const T(&get_c_array(const std::array<T,N>& arg))[N]
   409      {
   410          return static_cast<T(&)[N]>(arg);
   411      }
   412  #endif
   413  
   414      template <class It> std::size_t hash_range(It, It);
   415  
   416      template<class T, std::size_t N>
   417      std::size_t hash_value(const array<T,N>& arr)
   418      {
   419          return boost::hash_range(arr.begin(), arr.end());
   420      }
   421  
   422     template <size_t Idx, typename T, size_t N>
   423     T &get(boost::array<T,N> &arr) BOOST_NOEXCEPT {
   424         BOOST_STATIC_ASSERT_MSG ( Idx < N, "boost::get<>(boost::array &) index out of range" );
   425         return arr[Idx];
   426         }
   427      
   428     template <size_t Idx, typename T, size_t N>
   429     const T &get(const boost::array<T,N> &arr) BOOST_NOEXCEPT {
   430         BOOST_STATIC_ASSERT_MSG ( Idx < N, "boost::get<>(const boost::array &) index out of range" );
   431         return arr[Idx];
   432         }
   433  
   434  } /* namespace boost */
   435  
   436  #ifndef BOOST_NO_CXX11_HDR_ARRAY
   437  //  If we don't have std::array, I'm assuming that we don't have std::get
   438  namespace std {
   439     template <size_t Idx, typename T, size_t N>
   440     T &get(boost::array<T,N> &arr) BOOST_NOEXCEPT {
   441         BOOST_STATIC_ASSERT_MSG ( Idx < N, "std::get<>(boost::array &) index out of range" );
   442         return arr[Idx];
   443         }
   444      
   445     template <size_t Idx, typename T, size_t N>
   446     const T &get(const boost::array<T,N> &arr) BOOST_NOEXCEPT {
   447         BOOST_STATIC_ASSERT_MSG ( Idx < N, "std::get<>(const boost::array &) index out of range" );
   448         return arr[Idx];
   449         }
   450  }
   451  #endif
   452  
   453  #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)  
   454  # pragma warning(pop)  
   455  #endif 
   456  
   457  #endif /*BOOST_ARRAY_HPP*/