cls_tags.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__CLS_TAGS_HPP_ )
#define _OESS_1__SCHEME__IMPL__CLS_TAGS_HPP_

#include <cls_2/h/tag_no_value.hpp>
#include <cls_2/h/tag_vector_of_tags.hpp>
#include <cls_2/h/tag_text.hpp>
#include <cls_2/scalar/h/tag_scalar.hpp>
#include <cls_2/scalar/h/nonspace_format.hpp>
#include <cls_2/scalar/h/min_max.hpp>

namespace oess_1 {

namespace scheme {

namespace impl {

/*
  Средства для разбора текстового описания схемы данных.
*/

//
// tag_base_t
//

class tag_base_t :
  public cls_2::tag_scalar_t< std::string,
    cls_2::scalar_nonspace_format_t >
{
  typedef cls_2::tag_scalar_t< std::string,
    cls_2::scalar_nonspace_format_t > base_type_t;

  public :
    tag_base_t();
    // Конструктор такого формата необходим
    // для tag_vector_of_tags_t
    tag_base_t(
      const char * tag_name,
      bool is_mandatory );
    virtual ~tag_base_t();

    // Определить имя базового типа.
    const std::string &
    query_type_name() const;

    // Виртуальный ли тип?
    bool
    is_virtual() const;

    // Определить тег.
    void
    make_defined(
      const std::string & name,
      bool is_virtual );

  private :
    cls_2::tag_no_value_t m_tag_virtual;

    // На будущее. Пока никак не интерпритируется.
    cls_2::tag_no_value_t m_tag_public;
};

//
// tag_cpp_mapping_t
//

/*
  Тег для описания отображения в C++.
*/
class tag_cpp_mapping_t :
  public cls_2::tag_no_value_t
{
  typedef cls_2::tag_no_value_t base_type_t;
  public :
    tag_cpp_mapping_t(
      cls_2::tag_t & owner );
    virtual ~tag_cpp_mapping_t();

    // Было ли определено имя для C++.
    bool
    is_name_defined() const;

    // Имя типа в C++.
    const std::string &
    query_type_name() const;

    // Определить тег.
    void
    make_defined(
      const std::string & name );

  private :
    cls_2::tag_scalar_t< std::string,
      cls_2::scalar_nonspace_format_t >
      m_tag_name;
};

//
// tag_attr_type_t
//

class tag_attr_type_t :
  public cls_2::tag_scalar_t< std::string,
    cls_2::scalar_nonspace_format_t >
{
  typedef cls_2::tag_scalar_t< std::string,
    cls_2::scalar_nonspace_format_t > base_type_t;
  public :
    tag_attr_type_t(
      cls_2::tag_t & owner );
    virtual ~tag_attr_type_t();


    virtual int
    on_finish( cls_2::parser_context_t & context );

    const std::string &
    query_type_name() const;

    bool
    is_ptr() const;


    bool
    is_extension() const;

    void
    make_defined_as_value(
      const std::string & name );

    void
    make_defined_as_ptr(
      const std::string & name );


    void
    make_defined_as_extension(
      const std::string & name );

  private :
    cls_2::tag_no_value_t m_tag_ptr;

    cls_2::tag_no_value_t m_extension;
};

//
// tag_attr_present_if_t
//

class tag_attr_present_if_t
: public cls_2::tag_no_value_t
{
  typedef cls_2::tag_no_value_t base_type_t;
  public :
    tag_attr_present_if_t(
      cls_2::tag_t & owner );
    virtual ~tag_attr_present_if_t();

    bool
    is_cpp() const;


    std::string
    cpp() const;


    void
    make_cpp(
      const std::string & value );

  private :
    cls_2::tag_text_t m_cpp;
};

//
// tag_attr_default_t
//

class tag_attr_default_t
: public cls_2::tag_no_value_t
{
  typedef cls_2::tag_no_value_t base_type_t;
  public :
    tag_attr_default_t(
      cls_2::tag_t & owner );
    virtual ~tag_attr_default_t();

    bool
    is_cpp() const;


    std::string
    cpp() const;


    void
    make_cpp(
      const std::string & value );

    const tag_attr_present_if_t &
    present_if() const;


    tag_attr_present_if_t &
    changeable_present_if();

  private :
    cls_2::tag_text_t m_cpp;

    tag_attr_present_if_t m_present_if;
};

//
// tag_attr_t
//

/*
  Тег для описания атрибута.
*/
class tag_attr_t :
  public cls_2::tag_scalar_t< std::string,
    cls_2::scalar_nonspace_format_t >
{
  typedef cls_2::tag_scalar_t< std::string,
    cls_2::scalar_nonspace_format_t > base_type_t;
  public :
    tag_attr_t();
    // Такой конструктор нужен для tag_vector_of_tags_t
    tag_attr_t(
      const char * tag_name,
      bool is_mandatory );
    virtual ~tag_attr_t();

    // Имя атрибута.
    const std::string &
    query_attr_name() const;

    // Доступ к типу атрибута.
    const tag_attr_type_t &
    query_attr_type() const;

    tag_attr_type_t &
    query_attr_type();

//FIX ME: необходимо контролировать количество
//указанных дочерних тегов.

    // Определить атрибут как одиночный объект.
    void
    make_defined_as_single_obj(
      const std::string & name );

    // Является ли stl-вектором?
    bool
    is_stl_vector() const;

    void
    make_defined_as_stl_vector(
      const std::string & name );

    // Является ли stl-списком?
    bool
    is_stl_list() const;

    void
    make_defined_as_stl_list(
      const std::string & name );

    // Является ли stl-деком?
    bool
    is_stl_deque() const;

    void
    make_defined_as_stl_deque(
      const std::string & name );

    // Является ли stl-множеством?
    bool
    is_stl_set() const;

    void
    make_defined_as_stl_set(
      const std::string & name );

    // Является ли stl-мультимножеством?
    bool
    is_stl_multiset() const;

    void
    make_defined_as_stl_multiset(
      const std::string & name );

    // Является ли stl-словарем?
    bool
    is_stl_map() const;

    void
    make_defined_as_stl_map(
      const std::string & name,
      const std::string & key_type );

    // Является ли stl-мультисловарем?
    bool
    is_stl_multimap() const;

    void
    make_defined_as_stl_multimap(
      const std::string & name,
      const std::string & key_type );

    // Является ли фиксированным вектором?
    bool
    is_fixed_vector() const;

    void
    make_defined_as_fixed_vector(
      const std::string & name,
      size_t capacity );

    // Определить тип ключа для словаря.
    const std::string &
    query_map_key() const;

    // Определить размерность фиксированного вектора.
    size_t
    query_fixed_vector_size() const;


    const tag_attr_default_t &
    query_default() const;


    tag_attr_default_t &
    query_default();

  private :
    typedef cls_2::tag_scalar_t< std::string,
      cls_2::scalar_nonspace_format_t >
      tag_nonspaced_string_t;

    tag_attr_type_t m_tag_type;

    cls_2::tag_no_value_t m_tag_stl_vector;
    cls_2::tag_no_value_t m_tag_stl_list;
    cls_2::tag_no_value_t m_tag_stl_deque;
    cls_2::tag_no_value_t m_tag_stl_set;
    cls_2::tag_no_value_t m_tag_stl_map;

    cls_2::tag_no_value_t m_tag_is_multiset;
    cls_2::tag_no_value_t m_tag_is_multimap;

    tag_nonspaced_string_t  m_tag_map_key;

    cls_2::scalar_constraint::min_max_t< unsigned long >
      m_fixed_vector_constr;
    cls_2::tag_scalar_t< unsigned long >
      m_tag_fixed_vector;


    tag_attr_default_t  m_default;

    void
    init_tags();
};

class tag_extension_t;

//
// tag_extension_wrapper_t
//

class tag_extension_wrapper_t
: public cls_2::tag_no_value_t
{
  typedef cls_2::tag_no_value_t base_type_t;
  public :
    tag_extension_wrapper_t(
      cls_2::tag_t & owner,
      const char * name,
      bool is_mandatory );
    virtual ~tag_extension_wrapper_t();


    const tag_extension_t *
    get() const;

    tag_extension_t &
    make_extension();


    virtual int
    on_start( cls_2::parser_context_t & ctx );

    virtual int
    on_finish( cls_2::parser_context_t & context );

    virtual int
    on_tag( cls_2::parser_context_t & context,
      cls_2::tag_t & tag );

    virtual int
    on_tok_space(
      cls_2::parser_context_t & context,
      const char * tok_value );

    virtual int
    on_tok_nonspace(
      cls_2::parser_context_t & context,
      const char * tok_value );

    virtual int
    on_tok_string(
      cls_2::parser_context_t & context,
      const char * tok_value );

    virtual cls_2::tag_t **
    query_tags();

    virtual void
    reset();

    virtual void
    format(
      cls_2::tag_formatter_t & fmt );

  private :
    auto_ptr_3::obj_ptr_t< tag_extension_t >  m_extension;
};

//
// tag_extension_t
//

class tag_extension_t
: public cls_2::tag_no_value_t
{
  typedef cls_2::tag_no_value_t base_type_t;
  public :
    tag_extension_t();
    virtual ~tag_extension_t();


    const tag_extension_t *
    extension() const;

    tag_extension_t &
    make_extension();

    const cls_2::tag_vector_of_tags_t< tag_attr_t > &
    query_attrs() const;

    cls_2::tag_vector_of_tags_t< tag_attr_t > &
    query_attrs();

  private :
    cls_2::tag_vector_of_tags_t< tag_attr_t >
      m_attrs;

    tag_extension_wrapper_t m_extension;
};

//
// tag_type_t
//

class tag_type_t
: public cls_2::tag_scalar_t< std::string,
    cls_2::scalar_nonspace_format_t >
{
  typedef cls_2::tag_scalar_t< std::string,
    cls_2::scalar_nonspace_format_t > base_type_t;
  public :
    tag_type_t();
    tag_type_t(
      const char * tag_name,
      bool is_mandatory );
    virtual ~tag_type_t();

    const std::string &
    query_type_name() const;

    bool
    is_abstract() const;

    bool
    is_extensible() const;

    bool
    is_subclassing_by_extension() const;

    void
    make_defined(
      const std::string & name,
      bool is_abstract,
      bool is_extensible );

    const cls_2::tag_vector_of_tags_t< tag_base_t > &
    query_bases() const;

    cls_2::tag_vector_of_tags_t< tag_base_t > &
    query_bases();

    const cls_2::tag_vector_of_tags_t< tag_attr_t > &
    query_attrs() const;

    cls_2::tag_vector_of_tags_t< tag_attr_t > &
    query_attrs();

    const tag_cpp_mapping_t &
    query_cpp_mapping() const;

    tag_cpp_mapping_t &
    query_cpp_mapping();


    const tag_extension_t *
    extension() const;


    tag_extension_t &
    make_extension();


    void
    turn_subclassing_by_extension_on();


    bool
    is_extension_of(
      std::string & class_name ) const;

    void
    derive_as_extension_of( const std::string & name );

  private :
    cls_2::tag_no_value_t m_tag_abstract;

    cls_2::tag_no_value_t m_extensible;

    cls_2::tag_no_value_t m_subclassing_by_extension;

    cls_2::tag_scalar_t< std::string,
        cls_2::scalar_nonspace_format_t >
      m_extension_of;

    cls_2::tag_vector_of_tags_t< tag_base_t >
      m_tag_base;

    cls_2::tag_vector_of_tags_t< tag_attr_t >
      m_tag_attr;

    tag_cpp_mapping_t m_tag_cpp_mapping;

    tag_extension_wrapper_t m_extension;
};

//
// cls_parse
//


bool
cls_parse(
  std::istream & in,
  const char * opt_stream_name,
  cls_2::tag_vector_of_tags_t< tag_type_t > & tag,
  std::string & error_desc );

} /* namespace impl */

} /* namespace scheme */

} /* namespace oess_1 */

#endif

---