serializable.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__SERIALIZABLE_HPP_ )
#define _OESS_1__STDSN__SERIALIZABLE_HPP_

#include <list>

#include <cpp_util_2/h/nocopy.hpp>

#include <auto_ptr_3/h/obj_ptr.hpp>

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

#include <oess_1/stdsn/h/ent.hpp>
#include <oess_1/stdsn/h/macro.hpp>

namespace oess_1 {

namespace stdsn {

//
// unknown_extension_t
//

class OESS_1__STDSN__TYPE unknown_extension_t
  {
    private :
      std::string m_data;

    public :
      unknown_extension_t();
      explicit unknown_extension_t(
        const std::string & data );

      const std::string &
      get() const;


      void
      clear();
  };

//
// all_unknown_extension_t
//

struct  all_unknown_extensions_data_t;

class OESS_1__STDSN__TYPE all_unknown_extensions_t
  {
    public :
      all_unknown_extensions_t();
      all_unknown_extensions_t(
        const all_unknown_extensions_t & o );
      ~all_unknown_extensions_t();

      all_unknown_extensions_t &
      operator=(
        const all_unknown_extensions_t & o );


      const unknown_extension_t &
      get( const std::string & type_name ) const;


      unknown_extension_t &
      get( const std::string & type_name );

      void
      drop();

    private :
      auto_ptr_3::obj_ptr_t< all_unknown_extensions_data_t >  m_data;
  };

//
// subclass_extension_path_t
//

class OESS_1__STDSN__TYPE
subclass_extension_path_t
  {
    public :
      struct OESS_1__STDSN__TYPE
      item_t
        {
          std::string m_type_name;
          std::string m_scheme;

          item_t();
          item_t(
            const std::string & type_name,
            const std::string & scheme );
          item_t(
            const item_t & o );

          item_t &
          operator=( const item_t & o );
        };

      typedef std::list< item_t > list_t;
      typedef list_t::const_iterator  const_iterator;

      subclass_extension_path_t();
      subclass_extension_path_t(
        const subclass_extension_path_t & o );
      ~subclass_extension_path_t();

      subclass_extension_path_t &
      operator=(
        const subclass_extension_path_t & o );

      void
      push_back(
        const std::string & type_name,
        const std::string & type_scheme );

      oess_1::uint_t
      size() const;

      const_iterator
      begin() const;


      const_iterator
      end() const;

      bool
      operator==( const subclass_extension_path_t & o ) const;

    private :
      list_t  m_list;
  };

//
// serializable_t
//

class OESS_1__STDSN__TYPE serializable_t
  {
    // То, что скрывается за макросом OESS_SERIALIZER
    // в базовом классе должно быть реализовано явно.
    public :
      class OESS_1__STDSN__TYPE oess_serializer_t
        {
          public :
            static const std::string &  type_name();
            static oess_1::stdsn::serializable_t *  factory();
            static const std::string &  scheme();
        };
      friend class  oess_serializer_t;

    public :
      serializable_t();
      serializable_t(
        const serializable_t & o );
      virtual ~serializable_t();

      serializable_t &
      operator=( const serializable_t & o );

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

      virtual void
      oess_unpack( 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;


      static std::string &
      oess_serializable_t_name();

    protected :

      virtual void
      oess_pre_pack() const;


      virtual void
      oess_post_pack() const;


      virtual void
      oess_pre_unpack();


      virtual void
      oess_post_unpack();

      public :
        void
        oess_store_unknown_subclass_extension_path(
          const subclass_extension_path_t & path );

        const subclass_extension_path_t *
        oess_unknown_subclass_extension_path() const;

        void
        oess_drop_unknown_extensions();

      protected :
        const unknown_extension_t &
        oess_unknown_subclass_extension() const;

        unknown_extension_t &
        oess_writeable_unknown_subclass_extension();

        const unknown_extension_t &
        oess_lo_unknown_extension(
          const std::string & type_name ) const;

        unknown_extension_t &
        oess_lo_writeable_unknown_extension(
          const std::string & type_name );

      private :
        auto_ptr_3::obj_ptr_t<
            subclass_extension_path_t >
          m_oess_unknown_subclass_extension_path;

        unknown_extension_t m_oess_unknown_subclass_extension;
        all_unknown_extensions_t  m_oess_unknown_extensions;
  };

OESS_1__STDSN__FUNC( oent_t & )
operator<<( oent_t & writter, const serializable_t & o );

OESS_1__STDSN__FUNC( ient_t & )
operator>>( ient_t & reader, serializable_t & o );

//
// pfn_factory
//
typedef serializable_t * (*pfn_factory_t)();

//
// factory_registrator_t
//

class OESS_1__STDSN__TYPE factory_registrator_t {
  public :
    factory_registrator_t(
      const char * type_name,
      pfn_factory_t factory );
    ~factory_registrator_t();

  private :
    std::string m_type_name;
    pfn_factory_t m_factory;
};

//
// obj_factory_t
//

class OESS_1__STDSN__TYPE obj_factory_t {
  public :
    enum no_factory_action_t
    {
      throw_exception,
      no_throw_exception
    };

    static void
    reg(
      const std::string & type_name,
      pfn_factory_t factory );

    static void
    dereg(
      const std::string & type_name,
      pfn_factory_t factory );

    static serializable_t *
    create(
      const std::string & type_to_create,
      const std::string & type_to_cast,
      const no_factory_action_t & no_factory_action =
        throw_exception );
};

} /* namespace stdsn */

} /* namespace oess_1 */

#endif

---