---

more/gen/generic.h

Go to the documentation of this file.

//  Copyright (C) 2001--2002  Petter Urkedal
//
//  This file 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.
//
//  This file 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 this program; if not, write to the Free Software
//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
//  As a special exception, you may use this file as part of a free
//  software library without restriction.  Specifically, if other files
//  instantiate templates or use macros or inline functions from this
//  file, or you compile this file and link it with other files to
//  produce an executable, this file does not by itself cause the
//  resulting executable to be covered by the GNU General Public
//  License.  This exception does not however invalidate any other
//  reasons why the executable file might be covered by the GNU General
//  Public License.
//
//  $Id: generic.h,v 1.2 2002/08/24 13:57:38 petter_urkedal Exp $


#ifndef MORE_GENERIC_H
#define MORE_GENERIC_H

#include <utility>
#include <iterator>
#include <new>
#include <memory>

namespace more {
namespace gen {

  class generic;

  // These should be private types of generic, but we can't
  // specialize templates there.
  ///\if bits
  namespace bits_generic {

    struct vt_type
    {
        void (*construct_copy)(generic* dest, generic const& src);
        void (*destruct)(generic* dest);
    };

    template<typename T>
      struct scalar_vt
      {
          static void
          construct_copy(generic* obj, generic const& src)
          {
              if (sizeof(T) <= sizeof(void*))
                  new(&reinterpret_cast<T&>(obj->p))
                      T(reinterpret_cast<T const&>(src.p));
              else
                  obj->p = new T(*static_cast<T const*>(src.p));
          }

          static void
          destruct(generic* obj)
          {
              if (sizeof(T) <= sizeof(void*))
                  reinterpret_cast<T&>(obj->p).~T();
              else
                  delete static_cast<T*>(obj->p);
          }

          static vt_type et;
      };

    template<>
      struct scalar_vt<void>
      {
          static void construct_copy(generic* obj, generic const& src) {}
          static void destruct(generic* obj) {}
          static vt_type et;
      };

    template<typename T>
      struct vector_vt
      {
          struct layout {
              T* end;
              T x[1];
          };
          static T* begin(generic* x) {
              return static_cast<layout*>(x->p)->x;
          }
          static T* end(generic* x) {
              return static_cast<layout*>(x->p)->end;
          }
          static T const* begin(generic const* x) {
              return static_cast<layout const*>(x->p)->x;
          }
          static T const* end(generic const* x) {
              return static_cast<layout const*>(x->p)->end;
          }
          template<typename InputIterator>
            static void
            construct(generic* obj,
                      InputIterator first, InputIterator last) {
                std::size_t n = std::distance(first, last);
                layout* p = static_cast<layout*>
                    (::operator new(sizeof(layout) + sizeof(T)*(n-1)));
                p->end = p->x + n;
                obj->p = p;
                std::uninitialized_copy(first, last, p->x);
            }
          static void
          construct_copy(generic* obj, generic const& src) {
              T const* first = begin(&src);
              T const* last = end(&src);
              std::size_t n = last - first;
              layout* p = static_cast<layout*>
                  (::operator new(sizeof(layout) + sizeof(T)*(n-1)));
              p->end = p->x + n;
              obj->p = p;
              std::uninitialized_copy(first, last, p->x);
          }
          static void
          destruct(generic* obj) {
              T* first = begin(obj);
              T* last = end(obj);
              while (first != last) {
                  first->~T();
                  ++first;
              }
              ::operator delete(obj->p);
          }
          static vt_type et;
      };

    template<typename T>
      vt_type scalar_vt<T>::et = { construct_copy, destruct };
    template<typename T>
      vt_type vector_vt<T>::et = { construct_copy, destruct };

  }
  ///\endif

  /** \class generic generic.h more/gen/generic.h
      A type which can hold an object or a range of any other copyable
      type.  The space overhead is one pointer for objects smaller or
      equal to sizeof(void*), and two pointers plus an allocation for
      bigger objects.  The time overhead, assuming optimalization,
      should be none for accessing small objects and a pointer
      dereference for accessing larger objects. Checking the object
      type is a pointer comparison.  */
  struct generic
  {
      generic()
          : m_vt(&bits_generic::scalar_vt<void>::et) {}

      generic(generic const& x)
          : m_vt(x.m_vt) { m_vt->construct_copy(this, x); }

      ~generic() { m_vt->destruct(this); }

      generic& operator=(generic const& rhs)
      {
          this->~generic();
          new(this) generic(rhs);
          return *this;
      }

      template<typename T>
        generic(T const& x)
        {
            m_vt = &bits_generic::scalar_vt<T>::et;
            if (sizeof(T) <= sizeof(void*))
                new(&reinterpret_cast<T&>(p)) T(x);
            else
                p = new T(x);
        }

      template<typename InputIterator>
        generic(InputIterator first, InputIterator last)
        {
            typedef typename std::iterator_traits<InputIterator>::value_type
                    value_type;
            m_vt = &bits_generic::vector_vt<value_type>::et;
            bits_generic::vector_vt<value_type>::construct(this, first, last);
        }

      template<typename T>
        bool is()
        {
            return m_vt == &bits_generic::scalar_vt<T>::et;
        }

      template<typename T>
        T&
        to()
        {
            if (sizeof(T) <= sizeof(void*))
                return reinterpret_cast<T&>(p);
            else
                return *static_cast<T*>(p);
        }

      template<typename T>
        T const&
        to() const
        {
            if (sizeof(T) <= sizeof(void*))
                return reinterpret_cast<T const&>(p);
            else
                return *static_cast<T const*>(p);
        }

      template<typename T>
        std::pair<T*, T*>
        to_range()
        {
            return std::pair<T*, T*>(bits_generic::vector_vt<T>::begin(this),
                                     bits_generic::vector_vt<T>::end(this));
        }

      template<typename T>
        std::pair<T const*, T const*>
        to_range() const
        {
            return std::pair<T const*, T const*>(
                bits_generic::vector_vt<T>::begin(this),
                bits_generic::vector_vt<T>::end(this));
        }

    private:
      bits_generic::vt_type* m_vt;
      void* p;

      template<typename T> friend class bits_generic::scalar_vt;
      template<typename T> friend class bits_generic::vector_vt;
  };

}} // more::gen

#endif

---