scheme.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__SCHEME__SCHEME_HPP_ )
#define _OESS_1__SCHEME__SCHEME_HPP_

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

#include <oess_1/scheme/h/types.hpp>

namespace oess_1 {

namespace scheme {

/*
  Средства представления и манипуляции схемой данных.

  Пример занесения типа в схему:

  try {
    scheme_auto_ptr_t scheme_ptr;

    {
      type_editor_auto_ptr_t type_editor_ptr(
        *scheme_ptr, "my_type_t" );

      type_editor_ptr->cpp_mapping().set_name(
        "my_prj::my_type_t" );

      {
        attr_editor_auto_ptr_t attr_editor_ptr(
          *type_editor_ptr, "m_names", "std::string" );
        attr_editor_ptr->make_stl_set_kind();
        attr_editor_ptr.commit();
      }

      type_editor_ptr.commit();
    }
  }
  catch( oess_1::impl::ex_t & x ) {
    // Oops!?
    std::cerr << x.query_err_code() << std::endl;
  }
*/

//
// attr_editor_t
//

class OESS_1__SCHEME__TYPE  attr_editor_t
{
  public :
    virtual ~attr_editor_t();


    virtual void
    make_ptr_kind() = 0;


    virtual void
    make_extension_kind() = 0;

    // По умолчанию разновидность контейнера - single_obj_kind.
    virtual void
    make_single_obj_kind() = 0;

    virtual void
    make_stl_vector_kind() = 0;

    virtual void
    make_stl_list_kind() = 0;

    virtual void
    make_stl_deque_kind() = 0;

    virtual void
    make_stl_set_kind() = 0;

    virtual void
    make_stl_multiset_kind() = 0;

    // В случае ошибки порождается исключение.
    virtual void
    make_stl_map_kind(
      const std::string & key_type_name ) = 0;

    // В случае ошибки порождается исключение.
    virtual void
    make_stl_multimap_kind(
      const std::string & key_type_name ) = 0;

    virtual void
    make_fixed_vector_kind(
      size_t capacity ) = 0;

    virtual void
    set_default_existence(
      bool is_optional ) = 0;

    virtual void
    set_cpp_default(
      const std::string & expr ) = 0;

    virtual void
    set_cpp_present_if(
      const std::string & expr ) = 0;
};

//
// cpp_mapping_editor_t
//

class OESS_1__SCHEME__TYPE  cpp_mapping_editor_t {
  public :
    virtual ~cpp_mapping_editor_t();

    virtual void
    set_name( const std::string & name ) = 0;
};

//
// type_editor_t
//

class OESS_1__SCHEME__TYPE  type_editor_t {
  public :
    virtual ~type_editor_t();

    virtual void
    make_abstract() = 0;

    virtual void
    make_extensible() = 0;


    virtual void
    add_base(
      const std::string & name,
      bool is_virtual ) = 0;


    virtual void
    add_base_as_extension(
      const std::string & name ) = 0;


    virtual attr_editor_t &
    start_attr_def(
      const std::string & attr_name,
      const std::string & type_name ) = 0;


    virtual void
    commit_attr_def() = 0;


    virtual void
    rollback_attr_def() = 0;

    virtual cpp_mapping_editor_t &
    cpp_mapping() = 0;

    virtual void
    start_extension() = 0;

    virtual void
    turn_subclassing_by_extension_on() = 0;
};

//
// scheme_t
//

class OESS_1__SCHEME__TYPE  scheme_t {
  public :
    virtual ~scheme_t();

    virtual size_t
    query_type_count() const = 0;

    virtual const type_t &
    query_type( size_t index ) const = 0;

    virtual const type_t *
    find_type( const std::string & name ) const = 0;

    virtual type_editor_t &
    start_type_def(
      const std::string & name ) = 0;

    virtual void
    commit_type_def() = 0;

    virtual void
    rollback_type_def() = 0;
};

//
// pseudo_type_list_t
//
class pseudo_type_list_t {
  private :
    const scheme_t &  m_scheme;

  public :
    inline
    pseudo_type_list_t( const scheme_t & sch ) :
      m_scheme( sch )
    {
    }

    class const_iterator 
      : public std::iterator< std::forward_iterator_tag, type_t > {
      friend class pseudo_type_list_t;
      private :
        const scheme_t *  m_scheme;
        size_t  m_index;

        inline
        const_iterator(
          const scheme_t & sch,
          size_t index ) :
          m_scheme( &sch ),
          m_index( index )
        {
        }

      public :
        inline
        const_iterator() :
          m_scheme( 0 ),
          m_index( 0 )
        {
        }

        inline
        const_iterator(
          const const_iterator & o ) :
          m_scheme( o.m_scheme ),
          m_index( o.m_index )
        {
        }

        inline const type_t &
        operator*() const {
          return m_scheme->query_type( m_index );
        }

        bool
        operator==( const const_iterator & o ) const {
          return ( m_scheme == o.m_scheme && m_index == o.m_index );
        }

        bool
        operator!=( const const_iterator & o ) const {
          return ( m_scheme != o.m_scheme || m_index != o.m_index );
        }

        const_iterator&
        operator++() {
          ++m_index;
          return *this;
        }

        const_iterator
        operator++( int ) {
          return const_iterator( *m_scheme, m_index++ );
        }
    };

    inline const_iterator
    begin() const {
      return const_iterator( m_scheme, 0 );
    }

    inline const_iterator
    end() const {
      return const_iterator( m_scheme, m_scheme.query_type_count() );
    }
};

//
// scheme_auto_ptr_t
//

class OESS_1__SCHEME__TYPE  scheme_auto_ptr_t {
  public :
    scheme_auto_ptr_t();
    ~scheme_auto_ptr_t();

    scheme_t &
    operator*();

    const scheme_t &
    operator*() const;

    scheme_t *
    operator->();

    const scheme_t *
    operator->() const;

    scheme_t *
    query();

    const scheme_t *
    query() const;

  private :
    scheme_t *  m_scheme;
};

//
// attr_editor_auto_ptr_t
//

class OESS_1__SCHEME__TYPE  attr_editor_auto_ptr_t {
  public :
    attr_editor_auto_ptr_t(
      type_editor_t & type_editor,
      const std::string & attr_name,
      const std::string & type_name );
    ~attr_editor_auto_ptr_t();

    attr_editor_t &
    operator*();

    const attr_editor_t &
    operator*() const;

    attr_editor_t *
    operator->();

    const attr_editor_t *
    operator->() const;

    attr_editor_t *
    query();

    const attr_editor_t *
    query() const;

    void
    commit();

    void
    rollback();

  private :
    type_editor_t & m_type_editor;
    attr_editor_t * m_attr_editor;
};

//
// type_editor_auto_ptr_t
//

class OESS_1__SCHEME__TYPE  type_editor_auto_ptr_t {
  public :
    type_editor_auto_ptr_t(
      scheme_t & scheme,
      const std::string & type_name );
    ~type_editor_auto_ptr_t();

    type_editor_t &
    operator*();

    const type_editor_t &
    operator*() const;

    type_editor_t *
    operator->();

    const type_editor_t *
    operator->() const;

    type_editor_t *
    query();

    const type_editor_t *
    query() const;

    void
    commit();

    void
    rollback();

  private :
    scheme_t &  m_scheme;
    type_editor_t * m_type_editor;
};

} /* scheme */

} /* namespace oess_1 */

#endif

---