attribute.h

Go to the documentation of this file.

#ifndef ATTRIBUTE_DEFINED
#define ATTRIBUTE_DEFINED

namespace class_def {

  class attribute {
  protected:
    std::string _type;
    int         _reference;
    std::string _name;
    std::string _null_value; // functional or derived, if not defined on init
    int         _max_length; // 0 if not defined
    std::vector<std::string> _comments;
    
    static int _erno;
    static const char *_error_msg;
    static int _allow_custom_classes;
    static int _copy_constructor;
    static int _check_attributes;
    static const std::vector<std::string> _empty_string_vector;
  
  public:
    enum { 
      value=0, 
      containment=1, 
      reference=2, 
      shallow_pointer=3, 
      deep_pointer=4};
    
    static void put_allow_custom_classes( int newval);
    static void put_copy_constructor( int newval);
    static void put_check_attributes( int newval);
    static int  get_allow_custom_classes();
    static int  get_copy_constructor();
    static int  get_check_attributes();

    int is_custom_class() const;
    
    static  const char *_get_class_name() { return "class_def::attribute";}
    virtual const char *get_class_name() const = 0;
    
    void set_null() {
      _name = _type = _null_value = "";
      _reference = 0;
      _max_length = 0;
      if (_comments.size()>0) {
        _comments.erase( _comments.begin(), _comments.end());
      }
    }
    
    static int check_attributes(
                                const std::string& Type,
                                int                Reference,
                                const std::string& Name,
                                const std::string& Null_value,
                                int                Max_length,
                                const std::vector<std::string>& Comments);
    
    void init_calc_derived_attributes();
    
    void init(
              const std::string& Type,
              int                Reference,
              const std::string& Name,
              const std::string& Null_value,
              int                Max_length,
              const std::vector<std::string>& Comments)
    {
      const char *funcname = "attribute::init";
      
      check_attributes(
                       Type,
                       Reference,
                       Name,
                       Null_value,
                       Max_length,
                       Comments);
      
      if (_erno) {
        throw ( std::invalid_argument( error_message( 
                                                         get_class_name(), 
                                                         funcname, 
                                                         __FILE__,
                                                         _error_msg,
                                                         __LINE__, 
                                                         _erno   ,
                                                         lineno  ).what()));
      }
      
      _type = Type; 
      _reference = Reference;
      _name = Name;
      _null_value = Null_value;
      _max_length = Max_length;
      _comments = Comments;
      
      init_calc_derived_attributes();
    }
    
    attribute(
              const std::string& Type       = "",
              int                Reference  = 0 ,
              const std::string& Name       = "",
              const std::string& Null_value = "",
              int                Max_length = 0 ,
              std::vector<std::string> Comments = _empty_string_vector)
      {
        set_null();
        init(
             Type,
             Reference,
             Name,
             Null_value,
             Max_length,
             Comments);
        init_calc_derived_attributes();
      }
    
    virtual ~attribute() { set_null();}
    
    // get data functions
    attribute *get_this() { return this;}
    const std::string& get_type() const { return _type;}
    int   get_reference() const { return _reference;}
    const std::string& get_name() const { return _name;}
    const std::string& get_null_value() const { return _null_value;}
    int   get_max_length() const { return _max_length;}
    const std::vector<std::string>& get_comments() const { return _comments;}
    
    std::string input_format_of_name() const;
    std::string storage_format_of_name() const;
    std::string get_Name() const;
    
    // put data functions
    void put_type( const std::string& Type) {
      const char *funcname = "attribute::put_type";
      check_attributes(
                       Type,
                       _reference,
                       _name,
                       _null_value,
                       _max_length,
                       _comments);
      if (_erno) {
        throw ( std::invalid_argument( error_message( 
                                 get_class_name(), 
                                 funcname, 
                                 __FILE__,
                                 _error_msg,
                                 __LINE__, 
                                 _erno   ,
                                 lineno  ).what()));
      }
      _type = Type;
    }
    
    void put_reference( int  Reference) {
      const char *funcname = "attribute::put_reference";
      check_attributes(
                       _type    ,
                       Reference,
                       _name    ,
                       _null_value,
                       _max_length,
                       _comments);
      if (_erno) {
        throw ( std::invalid_argument( error_message( 
                                 get_class_name()   , 
                                 funcname, 
                                 __FILE__,
                                 _error_msg,
                                 __LINE__, 
                                 _erno   ,
                                 lineno  ).what()));
      }
      _reference = Reference;
    }
    
    void put_name( const std::string& Name) {
      const char *funcname = "attribute::put_name";
      check_attributes(
                       _type,
                       _reference,
                       Name,
                       _null_value,
                       _max_length,
                       _comments);
      if (_erno) {
        throw ( std::invalid_argument( error_message ( 
                                   get_class_name()   , 
                                   funcname, 
                                   __FILE__,
                                   _error_msg,
                                   __LINE__, 
                                   _erno   ,
                                   lineno  ).what()));
      }
      _name = Name;
    }
    
    void put_null_value( const std::string& Null_Value) {
      const char *funcname = "attribute::put_null_value";
      check_attributes(
                       _type     ,
                       _reference,
                       _name     ,
                       Null_Value,
                       _max_length,
                       _comments);
      if (_erno) {
        throw ( std::invalid_argument( error_message( 
                                  get_class_name()   , 
                                  funcname, 
                                  __FILE__,
                                  _error_msg,
                                  __LINE__, 
                                  _erno   ,
                                  lineno  ).what()));
      }
      _null_value = Null_Value;
    }
    
    void put_comments( const std::vector<std::string>& Comments) {
      const char *funcname = "attribute::put_comments";
      check_attributes(
                       _type     ,
                       _reference,
                       _name     ,
                       _null_value,
                       _max_length,
                       Comments   );
      if (_erno) {
        throw ( std::invalid_argument( error_message( 
                                  get_class_name(), 
                                  funcname, 
                                  __FILE__,
                                  _error_msg,
                                  __LINE__, 
                                  _erno   ,
                                  lineno  ).what()));
      }
      _comments = Comments;
    }
    
    friend std::istream& operator>>( std::istream& s, attribute& atr);
    friend std::ostream& operator<<( std::ostream& s, const attribute& atr);
    
    void print_comments( std::ostream& s) const {
      size_t j;
      for (j=0;j<_comments.size();j++) {
        s << _comments[j] << std::endl;
      }
    }
  };
}

#endif

---