types_impl.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__IMPL__TYPES_IMPL_HPP_ )
#define _OESS_1__SCHEME__IMPL__TYPES_IMPL_HPP_

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

#include <deque>
#include <map>

#include <auto_ptr_3/h/obj_ptr.hpp>

#include <smart_ref_3/h/smart_ref.hpp>

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

#include <oess_1/scheme/impl/h/iface_refs.hpp>

namespace oess_1 {

namespace scheme {

namespace impl {

//
// std_base_t
//
class std_base_t :
  public base_t
{
  public :

    enum subclassing_mode_t
    {
      normal_subclassing,
      subclassing_by_extension
    };

    std_base_t(
      const type_t & type,
      bool is_virtual );

    std_base_t(
      const type_t & type,
      const subclassing_mode_t & subclassing_mode );

    virtual ~std_base_t();

    virtual const type_t &
    query_type() const;

    virtual bool
    is_virtual() const;

    virtual bool
    is_extension_of() const;

  private :
    const type_t &  m_type;
    bool  m_is_virtual;
    subclassing_mode_t  m_subclassing_mode;
};

//
// std_cpp_mapping_t
//
class std_cpp_mapping_t :
  public cpp_mapping_t {
  public :
    std_cpp_mapping_t(
      const std::string & ddl_type_name );
    virtual ~std_cpp_mapping_t();

    // Установить имя типа в C++.
    void
    set_name( const std::string & name );

    // Имя типа в C++.
    // Если имя не было определено в описании типа,
    // то возвращается имя типа из DDL.
    virtual const std::string &
    query_name() const;

  private :
    // Имя типа в С++.
    // Изначально делается равным имени типа в DDL.
    std::string m_name;
};

//
// std_attr_type_t
//
class std_attr_type_t :
  public attr_type_t {
  public :
    std_attr_type_t(
      const type_t & type );
    virtual ~std_attr_type_t();

    // Тип атрибута.
    virtual const type_t &
    query_type() const;

    // Установить разновидность типа.
    void
    set_type_kind(
      type_kind_t kind_id );

    virtual type_kind_t
    query_type_kind() const;

    // Установить разновидность типа контейнера.
    void
    set_cont_kind(
      const ref_attr_cont_kind_t & ref_kind );

    // Разновидность типа контейнера.
    virtual const attr_cont_kind_t &
    query_cont_kind() const;

  private :
    const type_t &  m_type;

    // По умолчанию равен e_value.
    type_kind_t m_type_kind;

    // По умолчанию равен single_obj_kind_t.
    ref_attr_cont_kind_t  m_ref_cont_kind;
};

//
// std_attr_present_if_t
//

class std_attr_present_if_t
: public attr_present_if_t
{
  public :
    std_attr_present_if_t();
    virtual ~std_attr_present_if_t();

    void
    set_cpp( const std::string & expr );

    virtual const std::string &
    cpp() const
    throw( std::exception );

    virtual bool
    is_cpp() const;

  private :

    std::string m_cpp;
};

//
// std_attr_default_t
//

class std_attr_default_t
: public attr_default_t
{
  public :

    std_attr_default_t(
      bool is_optional );
    virtual ~std_attr_default_t();

    void
    set_cpp(
      const std::string & expr );


    std_attr_present_if_t &
    std_present_if()
    throw( std::exception );

    virtual const std::string &
    cpp() const
    throw( std::exception );

    virtual bool
    is_cpp() const;

    virtual bool
    is_optional() const;

    virtual const attr_present_if_t &
    present_if() const;

  private :

    std::string m_cpp;


    auto_ptr_3::obj_ptr_t< std_attr_present_if_t >
      m_present_if;
};

//
// attr_t
//

class std_attr_t :
  public attr_t {
  public :
    std_attr_t(
      // Имя атрибута.
      const std::string & name,
      // Тип атрибута.
      const type_t & type,
      unsigned int extension_level );
    virtual ~std_attr_t();

    virtual const std::string &
    query_name() const;

    virtual const attr_type_t &
    query_attr_type() const;

    virtual const attr_default_t *
    query_attr_default() const;

    virtual unsigned int
    extension_level() const;

    // Установить разновидность типа.
    void
    set_type_kind(
      attr_type_t::type_kind_t kind_id );

    // Установить разновидность типа контейнера.
    void
    set_cont_kind(
      const ref_attr_cont_kind_t & ref_kind );

    void
    make_std_attr_default(
      bool is_optional );

    std_attr_default_t &
    std_attr_default();

  private :
    std::string m_name;

    std_attr_type_t m_type;

    unsigned int  m_extension_level;

    auto_ptr_3::obj_ptr_t< std_attr_default_t > m_default;
};

//
// ref_std_attr_t
//
SMART_REF_3_DECL_DERIVED_REF( std_attr_t, attr_t, class )

//
// std_type_t
//


class std_type_t :
  public type_t
{
  public :
    std_type_t(
      const std::string & name,
      // Является ли тип встроенным?
      bool is_builtin = false );
    virtual ~std_type_t();

    virtual const std::string &
    query_name() const;

    virtual bool
    is_defined() const;

    void
    make_defined();

    virtual bool
    is_builtin() const;

    virtual bool
    is_abstract() const;

    void
    make_abstract();

    virtual bool
    is_extensible() const;


    void
    make_extensible();

    virtual bool
    is_subclassing_by_extension() const;

    void
    turn_subclassing_by_extension_on();

    virtual bool
    is_derived_as_extension() const;


    void
    add_base(
      const ref_base_t & ref_base );


    void
    add_base_as_extension(
      const ref_base_t & base );

    virtual size_t
    query_base_count() const;

    virtual const base_t &
    query_base( size_t index ) const;

    virtual const base_t *
    find_base( const std::string & name ) const;


    void
    add_attr(
      const ref_attr_t & ref_attr,
      unsigned int extension_level );

    virtual size_t
    query_attr_count() const;

    virtual const attr_t &
    query_attr( size_t index ) const;

    virtual const attr_t *
    find_attr( const std::string & name ) const;

    virtual const cpp_mapping_t &
    query_cpp_mapping() const;

    virtual unsigned int
    extension_deep() const;

    virtual unsigned int
    extension_attr_count( unsigned int extension ) const;

    virtual const attr_t &
    extension_attr( unsigned int extension,
      unsigned int attr_index ) const;

    std_cpp_mapping_t &
    query_cpp_mapping();

    void
    start_extension();

  public :
    std::string m_name;

    bool  m_is_defined;

    bool  m_is_builtin;

    bool  m_is_abstract;

    bool  m_is_extensible;

    bool  m_is_subclassing_by_extension;

    typedef std::deque< ref_base_t >
      ref_base_deque_t;
    ref_base_deque_t  m_bases;

    typedef std::map< std::string, const base_t *,
      std::less< std::string > >
      bases_map_t;
    bases_map_t m_bases_map;

    typedef std::deque< ref_attr_t >
      ref_attr_deque_t;

    typedef std::deque< ref_attr_deque_t >
      attr_extension_deque_t;


    ref_attr_deque_t  m_attrs;


    attr_extension_deque_t  m_attr_extensions;

    typedef std::map< std::string, const attr_t *,
      std::less< std::string > >
      attrs_map_t;
    attrs_map_t m_attrs_map;

    std_cpp_mapping_t m_cpp_mapping;

    bool  m_is_derived_as_extension;
};

//
// ref_std_type_t
//
SMART_REF_3_DECL_DERIVED_REF( std_type_t, type_t, class )

//
// map_base_kind_impl_t
//

/*
  Вспомогательный класс для реализации
  stl_map_kind_t и stl_multimap_kind_t.
*/
class map_base_kind_impl_t {
  public :
    map_base_kind_impl_t(
      const type_t & type );
    virtual ~map_base_kind_impl_t();

    // Тип ключа для map.
    virtual const type_t &
    query_key_type() const;

  private :
    const type_t &  m_type;
};

//
// std_stl_map_kind_t
//
class std_stl_map_kind_t :
  public stl_map_kind_t,
  public map_base_kind_impl_t {
  public :
    std_stl_map_kind_t(
      const type_t & type );
    virtual ~std_stl_map_kind_t();

    // Тип ключа для map.
    // В качестве типа значения используется тип
    // атрибута.
    virtual const type_t &
    query_key_type() const;
};

//
// std_stl_multimap_kind_t
//
class std_stl_multimap_kind_t :
  public stl_multimap_kind_t,
  public map_base_kind_impl_t {
  public :
    std_stl_multimap_kind_t(
      const type_t & type );
    virtual ~std_stl_multimap_kind_t();

    // Тип ключа для map.
    // В качестве типа значения используется тип
    // атрибута.
    virtual const type_t &
    query_key_type() const;
};

//
// std_fixed_vector_kind_t
//
class std_fixed_vector_kind_t :
  public fixed_vector_kind_t {
  public :
    std_fixed_vector_kind_t(
      size_t capacity );
    virtual ~std_fixed_vector_kind_t();

    // Размерность вектора в элементах.
    virtual size_t
    query_capacity() const;

  private :
    size_t  m_capacity;
};

} /* namespace impl */

} /* namespace scheme */

} /* namespace oess_1 */

#endif

---