lo-traits.h

Go to the documentation of this file.

////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2009-2024 The Octave Project Developers
//
// See the file COPYRIGHT.md in the top-level directory of this
// distribution or <https://octave.org/copyright/>.
//
// This file is part of Octave.
//
// Octave is free software: you can redistribute it and/or modify it
// under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Octave is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Octave; see the file COPYING.  If not, see
// <https://www.gnu.org/licenses/>.
//
////////////////////////////////////////////////////////////////////////
 
#if ! defined (octave_lo_traits_h)
#define octave_lo_traits_h 1
 
#include "octave-config.h"
 
// Ideas for these classes taken from C++ Templates, The Complete
// Guide by David Vandevoorde and Nicolai M. Josuttis, Addison-Wesley
// (2003).
 
// Select a type based on the value of a constant expression.
 
template <bool cond, typename T1, typename T2>
class if_then_else;
 
template <typename T1, typename T2>
class if_then_else<true, T1, T2>
{
public:
 
  typedef T1 result;
};
 
template <typename T1, typename T2>
class if_then_else<false, T1, T2>
{
public:
 
  typedef T2 result;
};
 
// Determine whether two types are equal.
template <typename T1, typename T2>
class equal_types
{
public:
 
  static const bool value = false;
};
 
template <typename T>
class equal_types <T, T>
{
public:
 
  static const bool value = true;
};
 
// Determine whether a type is an instance of a template.
 
template <template <typename> class Template, typename T>
class is_instance
{
public:
 
  static const bool value = false;
};
 
template <template <typename> class Template, typename T>
class is_instance <Template, Template<T>>
{
public:
 
  static const bool value = true;
};
 
// Determine whether a template parameter is a class type.
 
template <typename T1>
class is_class_type
{
private:
 
  typedef char one;
  typedef struct { char c[2]; } two;
 
  // Classes can have pointers to members.
  template <typename T2> static one is_class_type_test (int T2::*);
 
  // Catch everything else.
  template <typename T2> static two is_class_type_test (...);
 
public:
 
  enum { yes = sizeof (is_class_type_test<T1> (0)) == 1 };
  enum { no = ! yes };
};
 
// Define typename ref_param<T>::type as T const& if T is a class
// type.  Otherwise, define it to be T.
 
template <typename T>
class ref_param
{
public:
 
  typedef typename if_then_else<is_class_type<T>::no, T, T const&>::result type;
};
 
// Will turn TemplatedClass<T> to T, leave T otherwise.
// Useful for stripping wrapper classes, like octave_int.
 
template <template <typename> class TemplatedClass, typename T>
class strip_template_param
{
public:
  typedef T type;
};
 
template <template <typename> class TemplatedClass, typename T>
class strip_template_param<TemplatedClass, TemplatedClass<T>>
{
public:
  typedef T type;
};
 
// Will turn TemplatedClass<T> to TemplatedClass<S>, T to S otherwise.
// Useful for generic promotions.
 
template <template <typename> class TemplatedClass, typename T, typename S>
class subst_template_param
{
public:
  typedef S type;
};
 
template <template <typename> class TemplatedClass, typename T, typename S>
class subst_template_param<TemplatedClass, TemplatedClass<T>, S>
{
public:
  typedef TemplatedClass<S> type;
};
 
#endif