---

more/gen/utility.h

Go to the documentation of this file.

//  more/utility.h -- various utilities
//  Copyright (C) 1998--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: utility.h,v 1.4 2002/08/24 13:59:27 petter_urkedal Exp $


#ifndef MORE_GEN_UTILITY_H
#define MORE_GEN_UTILITY_H

#include <utility>
#include <functional>
#include <string>
#include <typeinfo>
#include <stdexcept>
#include <cassert>
#include <more/bits/config.h>


namespace more {
namespace gen {

  struct instance_counter
  {
      instance_counter()
          : ic(new int)
      {
          *ic = 0;
      }

      instance_counter(const instance_counter& x)
          : ic(x.ic)
      {
          ++*ic;
      }

      ~instance_counter()
      {
          if (!*ic)
              delete ic;
          else
              --*ic;
      }

      instance_counter& operator=(const instance_counter& x)
      {
          if (!*ic)
              delete ic;
          ic = x.ic;
          ++*ic;
          return *this;
      }

      bool is_unique() const { return !*ic; }

  private:
      mutable int* ic;
  };

  //  --- handle ---
  //

  template<typename T> class handle;

  /** \class handle_base utility.h more/gen/utility.h
   ** Base class for the template argument of a \c handle. */
  struct handle_data
  {
      handle_data() : m_refcnt(1) {}
      void              ref()   const { ++m_refcnt; }
      unsigned int      unref() const { return --m_refcnt; }

  private:
      template<typename T> friend class handle;
      mutable int m_refcnt;
  };

  /** \class handle utility.h more/gen/utility.h
   ** Utility class to deal with reference counting.  This class can
   ** be used as a base class for the user-visible class, whereas the
   ** data members are placed in a separate type, given as the
   ** template argument \a T.  The handle can also be a data-member.
   ** In any case, the copy constructor, the assigment operator and
   ** the destructor shall be invoked when the superclass or containing
   ** class is copied, assigned to ar destructed, respectively.
   **
   ** A const handle is treated as a constant object referring to
   ** <i>mutable</i> data, since constness of the data is anyway violated
   ** when a non-constant handle to the same data also exists.  But
   ** the member functions of the object derived from the handle
   ** should nevertheless reflect the constness of the data.  The
   ** important consequence of this semanic, is that the
   ** copy-constructor can be declared `const&', and thus the classes
   ** will interact more normally with STL headers, and in particular
   ** the extensions in `more/lambda.h'. */
  template<typename T>
  struct handle
  {
      handle() : m_ptr(0) {}

      explicit handle(T* p) : m_ptr(p) {}

      handle(handle const& x)
          : m_ptr(x.m_ptr)
      {
          if (m_ptr)
              ++m_ptr->m_refcnt;
      }

      handle& operator=(handle const& x)
      {
          if (m_ptr && !--m_ptr->m_refcnt)
              delete m_ptr;
          m_ptr = x.m_ptr;
          if (m_ptr)
              ++m_ptr->m_refcnt;
          return *this;
      }

      ~handle()
      {
          if (m_ptr && !--m_ptr->m_refcnt)
              delete m_ptr;
      }

      operator bool() const { return m_ptr; }

      bool is_owner() const { return m_ptr->m_refcnt == 1; }

      void check_data() const
      {
#ifndef MORE_DEBUG
          if (!m_ptr)
              throw std::logic_error(
                  std::string("more::gen::handle: "
                              "Accessing invalid object, typeid = ")
                  + typeid(*this).name());
#endif
      }

      T* datachk() const
      {
          check_data();
          return m_ptr;
      }

      T* data() const { return m_ptr; }

      T* data_ref() const { m_ptr->ref(); return m_ptr; }

//       T* operator()() const { return m_ptr; }

      /** Set the handle to point to \a ptr.  The caller looses
       ** ownership of \a ptr. */
      void set_data(T* ptr)
      {
          if (m_ptr && !--m_ptr->m_refcnt)
              delete m_ptr;
          m_ptr = ptr;
      }

    private:
      mutable T *m_ptr;
  };

  /** \class noncopyable utility.h more/utility.h
   **
   ** Classes derived from this can not be copied or assigned.  Since
   ** C++ provies a default copy constructor and copy assignment
   ** operator for classes which does not define them, it is necessary
   ** to explicitely state that copying is not allow; which is done
   ** with this common ideom.  */
  struct noncopyable
  {
      noncopyable() {}
    private:
      noncopyable(noncopyable const&) {}
      noncopyable const& operator=(noncopyable const&) { return *this; }
  };

  /** \class refpair utility.h more/gen/utility.h
   **
   ** Like a pair, but contains references which can be assigned to. */
  template<typename T, typename U>
    struct refpair
    {
        /** The type of the first component. */
        typedef T first_type;
        /** The type of the second component. */
        typedef U second_type;
        /** Construct a pair of references to \c x and \c y. */
        refpair(T& x, U& y) : first(x), second(y) {}
        /** Construct a copy. */
        refpair(refpair const& rp) : first(rp.first), second(rp.second) {}
        /** Assign the values of \c p to the references in this pair. */
        refpair& operator=(std::pair<T, U> const& p)
        {
            first = p.first;
            second = p.second;
            return *this;
        }
        /** The first member of the pair. */
        T& first;
        /** The second member of the pair. */
        U& second;
    };

  /** Creates a refpair. */
  template<typename T, typename U>
    inline refpair<T, U> tie(T& x, U& y) { return refpair<T, U>(x, y); }


  /** \class select1st utility.h more/gen/utility.h
   **
   ** A functional which returns a reference to the first component of
   ** a pair-like type.  */
  template<typename Pair>
    struct select1st : std::unary_function<Pair, typename Pair::first_type>
    {
        typename Pair::first_type&
        operator()(Pair& x) const
        {
            return x.first;
        }
    };

  /** \class select2nd utility.h more/gen/utility.h
   **
   ** A functional which returns a reference to the second component
   ** of a pair-like type.  */
  template<typename Pair>
    struct select2nd : std::unary_function<Pair, typename Pair::second_type>
    {
        typename Pair::second_type&
        operator()(Pair& x) const
        {
            return x.second;
        }
    };

}} // more::gen

#endif

---