traits.h

Go to the documentation of this file.

//
// Copyright (c) 2001-2004 California Institute of Technology
// Copyright (c) 2004-2007 University of Southern California
// Rob Peters <rjpeters at usc dot edu>
//
// created: Fri May 18 16:13:27 2001
// commit: $Id: traits.h 10065 2007-04-12 05:54:56Z rjpeters $
// $HeadURL: file:///lab/rjpeters/svnrepo/code/trunk/groovx/src/rutz/traits.h $
//
// --------------------------------------------------------------------
//
// This file is part of GroovX.
//   [http://ilab.usc.edu/rjpeters/groovx/]
//
// GroovX 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 2 of the License, or
// (at your option) any later version.
//
// GroovX 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 GroovX; if not, write to the Free Software Foundation,
// Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
//

#ifndef GROOVX_RUTZ_TRAITS_H_UTC20050626084021_DEFINED
#define GROOVX_RUTZ_TRAITS_H_UTC20050626084021_DEFINED

namespace rutz
{
  template <class T>
  struct type_traits
  {
    typedef T deref_t;
    typedef T stack_t;
  };

  template <class T>
  struct type_traits<T*>
  {
    typedef T pointee_t;
    typedef T deref_t;
  };

  template <class T>
  struct type_traits<T&>
  {
    typedef T stack_t;
  };

  template <class T>
  struct type_traits<const T&>
  {
    typedef T stack_t;
  };

  template <bool test, class if_true, class if_false>
  struct select_if
  {
    typedef if_true result_t;
  };

  template <class if_true, class if_false>
  struct select_if<false, if_true, if_false>
  {
    typedef if_false result_t;
  };

  namespace traits
  { struct yes_type { char x; }; struct no_type  { yes_type x[2]; };
  }

  template <class T>
  struct type_match
  {
    static traits::yes_type foo(T* p);
    static traits::no_type  foo(...);
  };

  template <class sub, class super>
  struct is_sub_super
  {
    enum { sz = sizeof(type_match<super>::foo(static_cast<sub*>(0))) };

    enum
      {
        result = ((sz == sizeof(traits::yes_type)) ? 1 : 0)
      };
  };


  // From boost/type_traits/is_class.hpp:
  template <class U> traits::yes_type is_class_tester(void(U::*)(void));
  template <class U> traits::no_type  is_class_tester(...);

  template <typename T>
  struct is_class
  {
    enum
      {
        value = (sizeof(is_class_tester<T>(0))
                 == sizeof(traits::yes_type))
      };
  };


  template <class T>
  struct is_polymorphic_imp1
  {
    typedef T ncvT;

    struct d1 : public ncvT
    {
      d1();
      ~d1()throw();
      char padding[256];
    };

    struct d2 : public ncvT
    {
      d2();
      virtual ~d2() throw();

      struct unique{};
      virtual void unique_name_to_invt200507011541(unique*);

      char padding[256];
    };

    enum { value = (sizeof(d2) == sizeof(d1)) };
  };

  template <class T>
  struct is_polymorphic_imp2
  {
    enum { value = false };
  };

  template <bool is_class>
  struct is_polymorphic_selector
  {
    template <class T>
    struct rebind
    {
      typedef is_polymorphic_imp2<T> type;
    };
  };

  template <>
  struct is_polymorphic_selector<true>
  {
    template <class T>
    struct rebind
    {
      typedef is_polymorphic_imp1<T> type;
    };
  };

  template <class T>
  struct is_polymorphic
  {
    typedef is_polymorphic_selector<is_class<T>::value> selector;
    typedef typename selector::template rebind<T> binder;
    typedef typename binder::type imp_type;
    enum { value = imp_type::value };
  };

  template <class T, bool polymorphic = is_polymorphic<T>::value >
  struct full_object_caster;

  template <class T>
  struct full_object_caster<T, false>
  {
    static const void* cast(const T* p) { return static_cast<const void*>(p); }
  };

  template <class T>
  struct full_object_caster<T, true>
  {
    static const void* cast(const T* p) { return dynamic_cast<const void*>(p); }
  };


  template <class T>
  inline const void* full_object_cast(const T* p)
  {
    return full_object_caster<T>::cast(p);
  }

}

static const char __attribute__((used)) vcid_groovx_rutz_traits_h_utc20050626084021[] = "$Id: traits.h 10065 2007-04-12 05:54:56Z rjpeters $ $HeadURL: file:
#endif // !GROOVX_RUTZ_TRAITS_H_UTC20050626084021_DEFINED

---

The software described here is Copyright (c) 1998-2005, Rob Peters.
This page was generated Wed Dec 3 06:49:41 2008 by Doxygen version 1.5.5.