text: /* /////////////////////////////////////////////////////////////////////////////
   * File:        stlsoft_explicit_cast_specialisations.h
   *
   * Purpose:     Specialisations of explicit_cast
   *
   * Created:     13th August 2003
   * Updated:     11th September 2004
   *
   * Home:        http://stlsoft.org/
   *
   * Copyright (c) 2003-2004, Matthew Wilson and Synesis Software
   * 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(s) of Matthew Wilson and Synesis Software nor the names of
   *   any 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 STLSOFT_INCL_H_STLSOFT_EXPLICIT_CAST
  # error This file is included from within stlsoft_explicit_cast.h, and cannot be included directly
  #else
  
  #ifndef __STLSOFT_DOCUMENTATION_SKIP_SECTION
  # define STLSOFT_VER_H_EXPLICIT_CAST_SPECIALISATIONS_MAJOR      2
  # define STLSOFT_VER_H_EXPLICIT_CAST_SPECIALISATIONS_MINOR      0
  # define STLSOFT_VER_H_EXPLICIT_CAST_SPECIALISATIONS_REVISION   1
  # define STLSOFT_VER_H_EXPLICIT_CAST_SPECIALISATIONS_EDIT       8
  #endif /* !__STLSOFT_DOCUMENTATION_SKIP_SECTION */
  
  /* /////////////////////////////////////////////////////////////////////////////
   * Auto-generation and compatibility
   */
  
  /*
  [<[STLSOFT-AUTO:NO-UNITTEST]>]
  [<[STLSOFT-AUTO:NO-DOCFILELABEL]>]
  */
  
  /* /////////////////////////////////////////////////////////////////////////////
   * Specialisations
   */
  
  STLSOFT_TEMPLATE_SPECIALISATION
  class explicit_cast<char const &>
  {
  public:
      typedef char                value_type;
      typedef explicit_cast<char> class_type;
  
  // Construction
  public:
      explicit_cast(char const &t)
          : m_t(t)
      {}
  
  // Conversions
  public:
      operator char const & () const
      {
          return m_t;
      }
  
  // Members
  private:
      char const &m_t;
  };
  
  #ifdef __STLSOFT_CF_NATIVE_WCHAR_T_SUPPORT
  
  STLSOFT_TEMPLATE_SPECIALISATION
  class explicit_cast<wchar_t const &>
  {
  public:
      typedef wchar_t                value_type;
      typedef explicit_cast<wchar_t> class_type;
  
  // Construction
  public:
      explicit_cast(wchar_t const &t)
          : m_t(t)
      {}
  
  // Conversions
  public:
      operator wchar_t const & () const
      {
          return m_t;
      }
  
  // Members
  private:
      wchar_t const &m_t;
  };
  
  #endif /* __STLSOFT_CF_NATIVE_WCHAR_T_SUPPORT */
  
  STLSOFT_TEMPLATE_SPECIALISATION
  class explicit_cast<unsigned char const &>
  {
  public:
      typedef unsigned char                value_type;
      typedef explicit_cast<unsigned char> class_type;
  
  // Construction
  public:
      explicit_cast(unsigned char const &t)
          : m_t(t)
      {}
  
  // Conversions
  public:
      operator unsigned char const & () const
      {
          return m_t;
      }
  
  // Members
  private:
      unsigned char const &m_t;
  };
  
  STLSOFT_TEMPLATE_SPECIALISATION
  class explicit_cast<signed char const &>
  {
  public:
      typedef signed char                value_type;
      typedef explicit_cast<signed char> class_type;
  
  // Construction
  public:
      explicit_cast(signed char const &t)
          : m_t(t)
      {}
  
  // Conversions
  public:
      operator signed char const & () const
      {
          return m_t;
      }
  
  // Members
  private:
      signed char const &m_t;
  };
  
  STLSOFT_TEMPLATE_SPECIALISATION
  class explicit_cast<signed short const &>
  {
  public:
      typedef signed short                value_type;
      typedef explicit_cast<signed short> class_type;
  
  // Construction
  public:
      explicit_cast(signed short const &t)
          : m_t(t)
      {}
  
  // Conversions
  public:
      operator signed short const & () const
      {
          return m_t;
      }
  
  // Members
  private:
      signed short const &m_t;
  };
  
  STLSOFT_TEMPLATE_SPECIALISATION
  class explicit_cast<unsigned short const &>
  {
  public:
      typedef unsigned short                value_type;
      typedef explicit_cast<unsigned short> class_type;
  
  // Construction
  public:
      explicit_cast(unsigned short const &t)
          : m_t(t)
      {}
  
  // Conversions
  public:
      operator unsigned short const & () const
      {
          return m_t;
      }
  
  // Members
  private:
      unsigned short const &m_t;
  };
  
  STLSOFT_TEMPLATE_SPECIALISATION
  class explicit_cast<signed int const &>
  {
  public:
      typedef signed int                value_type;
      typedef explicit_cast<signed int> class_type;
  
  // Construction
  public:
      explicit_cast(signed int const &t)
          : m_t(t)
      {}
  
  // Conversions
  public:
      operator signed int const & () const
      {
          return m_t;
      }
  
  // Members
  private:
      signed int const &m_t;
  };
  
  STLSOFT_TEMPLATE_SPECIALISATION
  class explicit_cast<unsigned int const &>
  {
  public:
      typedef unsigned int                value_type;
      typedef explicit_cast<unsigned int> class_type;
  
  // Construction
  public:
      explicit_cast(unsigned int const &t)
          : m_t(t)
      {}
  
  // Conversions
  public:
      operator unsigned int const & () const
      {
          return m_t;
      }
  
  // Members
  private:
      unsigned int const &m_t;
  };
  
  STLSOFT_TEMPLATE_SPECIALISATION
  class explicit_cast<signed long const &>
  {
  public:
      typedef signed long                value_type;
      typedef explicit_cast<signed long> class_type;
  
  // Construction
  public:
      explicit_cast(signed long const &t)
          : m_t(t)
      {}
  
  // Conversions
  public:
      operator signed long const & () const
      {
          return m_t;
      }
  
  // Members
  private:
      signed long const &m_t;
  };
  
  STLSOFT_TEMPLATE_SPECIALISATION
  class explicit_cast<unsigned long const &>
  {
  public:
      typedef unsigned long                value_type;
      typedef explicit_cast<unsigned long> class_type;
  
  // Construction
  public:
      explicit_cast(unsigned long const &t)
          : m_t(t)
      {}
  
  // Conversions
  public:
      operator unsigned long const & () const
      {
          return m_t;
      }
  
  // Members
  private:
      unsigned long const &m_t;
  };
  
  #ifdef STLSOFT_CF_64BIT_INT_IS_long_long
  
  STLSOFT_TEMPLATE_SPECIALISATION
  class explicit_cast<signed long long const &>
  {
  public:
      typedef signed long long                value_type;
      typedef explicit_cast<signed long long> class_type;
  
  // Construction
  public:
      explicit_cast(signed long long const &t)
          : m_t(t)
      {}
  
  // Conversions
  public:
      operator signed long long const & () const
      {
          return m_t;
      }
  
  // Members
  private:
      signed long long const &m_t;
  };
  
  STLSOFT_TEMPLATE_SPECIALISATION
  class explicit_cast<unsigned long long const &>
  {
  public:
      typedef unsigned long long                value_type;
      typedef explicit_cast<unsigned long long> class_type;
  
  // Construction
  public:
      explicit_cast(unsigned long long const &t)
          : m_t(t)
      {}
  
  // Conversions
  public:
      operator unsigned long long const & () const
      {
          return m_t;
      }
  
  // Members
  private:
      unsigned long long const &m_t;
  };
  
  #elif defined(STLSOFT_CF_64BIT_INT_IS___int64)
  
  STLSOFT_TEMPLATE_SPECIALISATION
  class explicit_cast<signed __int64 const &>
  {
  public:
      typedef signed __int64                value_type;
      typedef explicit_cast<signed __int64> class_type;
  
  // Construction
  public:
      explicit_cast(signed __int64 const &t)
          : m_t(t)
      {}
  
  // Conversions
  public:
      operator signed __int64 const & () const
      {
          return m_t;
      }
  
  // Members
  private:
      signed __int64 const &m_t;
  };
  
  STLSOFT_TEMPLATE_SPECIALISATION
  class explicit_cast<unsigned __int64 const &>
  {
  public:
      typedef unsigned __int64                value_type;
      typedef explicit_cast<unsigned __int64> class_type;
  
  // Construction
  public:
      explicit_cast(unsigned __int64 const &t)
          : m_t(t)
      {}
  
  // Conversions
  public:
      operator unsigned __int64 const & () const
      {
          return m_t;
      }
  
  // Members
  private:
      unsigned __int64 const &m_t;
  };
  
  #else
  
  # error 64-bit discrimination not handled correctly
  
  #endif /* 64-bit */
  
  STLSOFT_TEMPLATE_SPECIALISATION
  class explicit_cast<float const &>
  {
  public:
      typedef float                value_type;
      typedef explicit_cast<float> class_type;
  
  // Construction
  public:
      explicit_cast(float const &t)
          : m_t(t)
      {}
  
  // Conversions
  public:
      operator float const & () const
      {
          return m_t;
      }
  
  // Members
  private:
      float const &m_t;
  };
  
  STLSOFT_TEMPLATE_SPECIALISATION
  class explicit_cast<double const &>
  {
  public:
      typedef double                value_type;
      typedef explicit_cast<double> class_type;
  
  // Construction
  public:
      explicit_cast(double const &t)
          : m_t(t)
      {}
  
  // Conversions
  public:
      operator double const & () const
      {
          return m_t;
      }
  
  // Members
  private:
      double const &m_t;
  };
  
  STLSOFT_TEMPLATE_SPECIALISATION
  class explicit_cast<long double const &>
  {
  public:
      typedef long double                value_type;
      typedef explicit_cast<long double> class_type;
  
  // Construction
  public:
      explicit_cast(long double const &t)
          : m_t(t)
      {}
  
  // Conversions
  public:
      operator long double const & () const
      {
          return m_t;
      }
  
  // Members
  private:
      long double const &m_t;
  };
  
  #ifdef __STLSOFT_CF_NATIVE_BOOL_SUPPORT
  
  STLSOFT_TEMPLATE_SPECIALISATION
  class explicit_cast<bool const &>
  {
  public:
      typedef bool                value_type;
      typedef explicit_cast<bool> class_type;
  
  // Construction
  public:
      explicit_cast(bool const &t)
          : m_t(t)
      {}
  
  // Conversions
  public:
      operator bool const & () const
      {
          return m_t;
      }
  
  // Members
  private:
      bool const &m_t;
  };
  
  #endif /* __STLSOFT_CF_NATIVE_BOOL_SUPPORT */
  
  /* ////////////////////////////////////////////////////////////////////////// */
  
  #endif /* !STLSOFT_INCL_H_STLSOFT_EXPLICIT_CAST */
  
  /* ////////////////////////////////////////////////////////////////////////// */
  