shptr.hpp

См. документацию.

/*

Copyright (c) 2002-2005, Yauheni Akhotnikau
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.

- The name of the author may not be used to endorse or promote products derived
from this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.

*/

#if !defined( _OESS_1__STDSN__SHPTR_HPP_ )
#define _OESS_1__STDSN__SHPTR_HPP_

#include <memory>

#include <oess_1/defs/h/ex.hpp>

#include <oess_1/stdsn/h/declspec.hpp>

#include <oess_1/stdsn/h/serializable.hpp>
#include <oess_1/stdsn/h/errno.hpp>

namespace oess_1 {

namespace stdsn {

template< class T >
class refcountable_policy_t
  : private cpp_util_2::nocopy_t
  {
  private :
    typedef unsigned long ref_count_t;

    ref_count_t * m_ref_count;

    T * & m_pointer_holder;

  public :

    explicit refcountable_policy_t( T * & pointer_holder )
      : m_ref_count( 0 )
      , m_pointer_holder( pointer_holder )
      {
        m_pointer_holder = 0;
      }


    refcountable_policy_t(
      T * & pointer_holder, T * pointer )
      : m_ref_count( 0 )
      , m_pointer_holder( pointer_holder )
      {
        assign( pointer );
      }

    ~refcountable_policy_t()
      {
        release();
      }


    void
    assign( T * ptr )
      {
        release();

        if( ptr )
          {
            m_ref_count = new ref_count_t( 1 );
            m_pointer_holder = ptr;
          }
      }


    void
    reassign()
      {
        // Счетчик ссылок должен быть нулевым!
        if( m_ref_count )
          OESS_THROW_PHYSIC(
              err::c_invalid_policy_state_for_reassignment,
              "reassignment when m_ref_count != null!" )

        m_ref_count = new ref_count_t( 1 );
      }


    void
    link(
      const refcountable_policy_t< T > & owner_policy )
      {
        if( &owner_policy != this )
          {
            release();

            if( 0 != ( m_ref_count = owner_policy.m_ref_count ) )
              {
                ++( *m_ref_count );
                m_pointer_holder = owner_policy.m_pointer_holder;
              }
          }
      }


    std::auto_ptr< T >
    release()
      {
        std::auto_ptr< T > result;
        if( m_ref_count )
          {
            if( 0 == ( --(*m_ref_count) ) )
              {
                ref_count_t * to_be_destroyed = m_ref_count;
                m_ref_count = 0;

                delete to_be_destroyed;

                result = std::auto_ptr< T >( m_pointer_holder );
                m_pointer_holder = 0;
              }
            else
              // Кто-то другой уничтожит m_ref_count.
              m_ref_count = 0;
          }

        return result;
      }
  };

template< class T >
class cloneable_policy_t
  : private cpp_util_2::nocopy_t
  {
  private :
    T * & m_pointer_holder;

  public :
    explicit cloneable_policy_t( T * & pointer_holder )
      : m_pointer_holder( pointer_holder )
      {
        m_pointer_holder = 0;
      }


    cloneable_policy_t(
      T * & pointer_holder, T * pointer )
      : m_pointer_holder( pointer_holder )
      {
        m_pointer_holder = 0;
        assign( pointer );
      }

    ~cloneable_policy_t()
      {
        release();
      }


    void
    assign( T * ptr )
      {
        release();

        m_pointer_holder = ptr;
      }


    void
    reassign()
      {
      }


    void
    link(
      const cloneable_policy_t< T > & owner_policy )
      {
        if( &owner_policy != this )
          {
            release();

            if( owner_policy.m_pointer_holder )
              {
                std::auto_ptr< T > clone(
                    owner_policy.m_pointer_holder->clone() );
                m_pointer_holder = clone.release();
              }
          }
      }


    std::auto_ptr< T >
    release()
      {
        std::auto_ptr< T > result( m_pointer_holder );
        m_pointer_holder = 0;

        return result;
      }
  };

template< class T >
struct shptr_type_tag {};

template<
    class T,
    class Own_policy = refcountable_policy_t< T > >
class shptr_skeleton_t
  : public oess_1::stdsn::serializable_t
  {
    typedef shptr_skeleton_t< T, Own_policy > self_type_t;

  protected :
    T * m_ptr;

  private :
    Own_policy  m_own_policy;

  public :

    shptr_skeleton_t()
      : m_ptr( 0 )
      , m_own_policy( m_ptr )
      {}

    shptr_skeleton_t(
      T * ptr )
      : m_ptr( 0 )
      , m_own_policy( m_ptr, ptr )
      {}

    shptr_skeleton_t(
      const self_type_t & o )
      : m_ptr( 0 )
      , m_own_policy( m_ptr )
      {
        (*this) = o;
      }
    virtual ~shptr_skeleton_t()
      {}

    self_type_t &
    operator=(
      const self_type_t & o )
      {
        m_own_policy.link( o.m_own_policy );
        return *this;
      }


    virtual void
    oess_pack( oess_1::stdsn::oent_t & writter ) const = 0;

    virtual void
    oess_unpack( oess_1::stdsn::ient_t & reader ) = 0;

    virtual void *
    oess_cast( const std::string & type_name ) = 0;

    virtual const std::string &
    oess_type_name() const = 0;

    virtual const std::string &
    oess_scheme() const = 0;

    virtual void
    oess_get_subclass_extension_path(
      oess_1::stdsn::subclass_extension_path_t & path,
      const std::string & terminator ) const = 0;


    template< class Y >
    Y *
    cast_to( const shptr_type_tag< Y > & )
      {
        typedef typename Y::oess_serializer_t serializer_t;
        if( m_ptr )
          {
            Y * p = reinterpret_cast< Y * >(
                m_ptr->oess_cast( serializer_t::type_name() ) );
            if( !p )
              OESS_THROW_LOGIC( err::c_cast_failed,
                  "unable cast from '" << m_ptr->oess_type_name()
                  << "' to '" << serializer_t::type_name() )
            return p;
          }

        return 0;
      }


    template< class Y >
    const Y *
    cast_to( const shptr_type_tag< Y > & ) const
      {
        typedef typename Y::oess_serializer_t serializer_t;
        if( m_ptr )
          {
            const Y * p = reinterpret_cast< const Y * >(
                m_ptr->oess_cast( serializer_t::type_name() ) );
            if( !p )
              OESS_THROW_LOGIC( err::c_cast_failed,
                  "unable cast from '" << m_ptr->oess_type_name()
                  << "' to '" << serializer_t::type_name() )
            return p;
          }

        return 0;
      }




    void *
    cast_to( const std::string & type_name )
      {
        if( m_ptr )
          return m_ptr->oess_cast( type_name );
        return 0;
      }


    const void *
    cast_to( const std::string & type_name ) const
      {
        if( m_ptr )
          return m_ptr->oess_cast( type_name );
        return 0;
      }



    void
    destroy()
      {
        m_own_policy.release();
      }

  protected :
    virtual void
    oess_pre_unpack()
      {
        // После десериализации m_ptr примет новое значение.
        // Поэтому старый контролируемый объект должен быть
        // уничтожен.
        destroy();
      }

    virtual void
    oess_post_unpack()
      {
        m_own_policy.reassign();
      }

    Own_policy &
    own_policy()
      {
        return m_own_policy;
      }

    const Own_policy &
    own_policy() const 
      {
        return m_own_policy;
      }
  };

//
// shptr_t
//

class OESS_1__STDSN__TYPE shptr_t
  : public shptr_skeleton_t< oess_1::stdsn::serializable_t >
  {
  typedef shptr_skeleton_t< oess_1::stdsn::serializable_t > base_type_t;
  OESS_SERIALIZER_EX( shptr_t, OESS_1__STDSN__TYPE )
  public :

    shptr_t();
    shptr_t(
      serializable_t * ptr );
    shptr_t(
      const shptr_t & o );
    virtual ~shptr_t();


    shptr_t &
    operator=( const shptr_t & o );

  protected :


    virtual void
    oess_shptr_assign(
      const shptr_t & o );


    void
    oess_reset(
      serializable_t * ptr = 0 );
};


#define OESS_1_SHPTR_IFACE(shptr_type, referred_type, base_type) \
private : \
  typedef base_type base_type_typedef__; \
  typedef base_type base_type_t; \
public : \
  shptr_type() {} \
  shptr_type( referred_type * p ) : base_type_typedef__( p ) {} \
  shptr_type( const shptr_type & o ) : base_type_typedef__( o ) {} \
  virtual ~shptr_type() {} \
  shptr_type & \
  operator=( const shptr_type & o ) \
  { base_type_typedef__::operator=( o ); return *this; } \
  referred_type * \
  get() { return cast_to( oess_1::stdsn::shptr_type_tag< referred_type >() ); } \
  const referred_type * \
  get() const { return cast_to( oess_1::stdsn::shptr_type_tag< referred_type >() ); } \
  referred_type * \
  operator->() { return get(); } \
  const referred_type * \
  operator->() const { return get(); } \
  referred_type & \
  operator*() { return *get(); } \
  const referred_type & \
  operator*() const { return *get(); } \
private :

} /* namespace stdsn */

} /* namespace oess_1 */

#endif

---