1  // <cast.h> -*- C++ -*-
       2  
       3  // Copyright (C) 2008-2023 Free Software Foundation, Inc.
       4  //
       5  // This file is part of the GNU ISO C++ Library.  This library is free
       6  // software; you can redistribute it and/or modify it under the
       7  // terms of the GNU General Public License as published by the
       8  // Free Software Foundation; either version 3, or (at your option)
       9  // any later version.
      10  
      11  // This library is distributed in the hope that it will be useful,
      12  // but WITHOUT ANY WARRANTY; without even the implied warranty of
      13  // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      14  // GNU General Public License for more details.
      15  
      16  // Under Section 7 of GPL version 3, you are granted additional
      17  // permissions described in the GCC Runtime Library Exception, version
      18  // 3.1, as published by the Free Software Foundation.
      19  
      20  // You should have received a copy of the GNU General Public License and
      21  // a copy of the GCC Runtime Library Exception along with this program;
      22  // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
      23  // <http://www.gnu.org/licenses/>.
      24  
      25  /** @file ext/cast.h
      26   *  This is an internal header file, included by other library headers.
      27   *  Do not attempt to use it directly. @headername{ext/pointer.h}
      28   */
      29  
      30  #ifndef _GLIBCXX_CAST_H
      31  #define _GLIBCXX_CAST_H 1
      32  
      33  namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
      34  {
      35  _GLIBCXX_BEGIN_NAMESPACE_VERSION
      36  
      37    /**
      38     * These functions are here to allow containers to support non standard
      39     * pointer types.  For normal pointers, these resolve to the use of the
      40     * standard cast operation.  For other types the functions will perform
      41     * the appropriate cast to/from the custom pointer class so long as that
      42     * class meets the following conditions:
      43     * 1) has a typedef element_type which names tehe type it points to.
      44     * 2) has a get() const method which returns element_type*.
      45     * 3) has a constructor which can take one element_type* argument.
      46     */
      47  
      48    /**
      49     * This type supports the semantics of the pointer cast operators (below.)
      50     */
      51    template<typename _ToType>
      52      struct _Caster
      53      { typedef typename _ToType::element_type*  type; };
      54  
      55    template<typename _ToType>
      56      struct _Caster<_ToType*>
      57      { typedef _ToType*  type; };
      58  
      59    /**
      60     * Casting operations for cases where _FromType is not a standard pointer.
      61     * _ToType can be a standard or non-standard pointer.  Given that _FromType
      62     * is not a pointer, it must have a get() method that returns the standard
      63     * pointer equivalent of the address it points to, and must have an
      64     * element_type typedef which names the type it points to.
      65     */
      66    template<typename _ToType, typename _FromType>
      67      inline _ToType
      68      __static_pointer_cast(const _FromType& __arg)
      69      { return _ToType(static_cast<typename _Caster<_ToType>::
      70  		     type>(__arg.get())); }
      71  
      72    template<typename _ToType, typename _FromType>
      73      inline _ToType
      74      __dynamic_pointer_cast(const _FromType& __arg)
      75      { return _ToType(dynamic_cast<typename _Caster<_ToType>::
      76  		     type>(__arg.get())); }
      77  
      78    template<typename _ToType, typename _FromType>
      79      inline _ToType
      80      __const_pointer_cast(const _FromType& __arg)
      81      { return _ToType(const_cast<typename _Caster<_ToType>::
      82  		     type>(__arg.get())); }
      83  
      84    template<typename _ToType, typename _FromType>
      85      inline _ToType
      86      __reinterpret_pointer_cast(const _FromType& __arg)
      87      { return _ToType(reinterpret_cast<typename _Caster<_ToType>::
      88  		     type>(__arg.get())); }
      89  
      90    /**
      91     * Casting operations for cases where _FromType is a standard pointer.
      92     * _ToType can be a standard or non-standard pointer.
      93     */
      94    template<typename _ToType, typename _FromType>
      95      inline _ToType
      96      __static_pointer_cast(_FromType* __arg)
      97      { return _ToType(static_cast<typename _Caster<_ToType>::
      98  		     type>(__arg)); }
      99  
     100    template<typename _ToType, typename _FromType>
     101      inline _ToType
     102      __dynamic_pointer_cast(_FromType* __arg)
     103      { return _ToType(dynamic_cast<typename _Caster<_ToType>::
     104  		     type>(__arg)); }
     105  
     106    template<typename _ToType, typename _FromType>
     107      inline _ToType
     108      __const_pointer_cast(_FromType* __arg)
     109      { return _ToType(const_cast<typename _Caster<_ToType>::
     110  		     type>(__arg)); }
     111  
     112    template<typename _ToType, typename _FromType>
     113      inline _ToType
     114      __reinterpret_pointer_cast(_FromType* __arg)
     115      { return _ToType(reinterpret_cast<typename _Caster<_ToType>::
     116  		     type>(__arg)); }
     117  
     118  _GLIBCXX_END_NAMESPACE_VERSION
     119  } // namespace
     120  
     121  #endif // _GLIBCXX_CAST_H