---

tag.h

Go to the documentation of this file.

#ifndef tag_h
#define tag_h

#include <string>
#include <map>
#include <list>
#include "strings.h"

typedef struct Line 
{
  std::string directory;
  std::string file_name;
  std::string tag;      
  std::string orig_tag; 


  std::string tag_type;

  int line_number;
  int cursor_pos;
  
  std::string line; 

  Line() 
  { line_number = -1; cursor_pos = -1; }

  Line( std::string directory, 
        std::string file_name,
        std::string tag,
        std::string tag_type,
        int line_number=-1,
        int cursor_pos=-1 ) :
    directory( directory ),
    file_name( file_name ),
    tag( tag ),
    tag_type( tag_type ),
    line_number( line_number ),
    cursor_pos( cursor_pos )
  {}

  Line( std::string& directory, 
        std::string& file_name,
        std::string& tag,
        std::string& tag_type,
        int line_number=-1,
        int cursor_pos=-1 ) :
    directory( directory ),
    file_name( file_name ),
    tag( tag ),
    tag_type( tag_type ),
    line_number( line_number ),
    cursor_pos( cursor_pos )
  {}
       
};



class Tag
{
 private:
  std::string tag_type;
  //  string tag;
  Line line;
  bool got_line; // tag created with line constructor

  bool searched_level;
  int level;

 protected:


  struct Option
  {
    std::string first;  
    std::string second; 

    Option( std::string name, std::string value )
      : first( name ), second( value )
    {}
  };

  typedef std::list<Option> options_list;
  typedef options_list::iterator options_list_it;

  mutable options_list options;
  bool is_valid_tag;

  bool options_extracted; 
  

  bool no_warning_check;   
  bool nowarning;

 public:
  Tag( std::string tag, bool no_warning_check = false );
  Tag( Line& line, bool no_warning_check = false );
  Tag() { is_valid_tag = false; }

  bool operator!() const
    { return !is_valid_tag; }


  bool get_option( const std::string which, std::string &result );

  template<class T> bool get_option( const std::string which, T &result )
    { 
      std::string dummy;
      if( get_option( which, dummy ) )
        {
          result = Strings::s2x<T>( dummy );
          return true;
        }
      return false;
    }

  bool get_option( const std::string which )
    {
      std::string dummy;
      return get_option( which, dummy );
    }

  template <class T> bool set_option( const std::string o, const T f, bool ff=false )
    { return set_option( o, Strings::x2s( f ), ff ); }

  bool set_option( const std::string option, const std::string flag="", bool fail_if_set=false );

  std::string get_tag() const
    { return line.tag; }

  std::string get_tag_type() const
    { return tag_type; }


  void set_tag_type( std::string type )
    { tag_type = type; }

  Line get_line() const 
    { return line; }

  /*** 
       If you manipulated the tag with set_option() you
       have to call this function that the tag will be 
       regenerated and you can get it via the get_tag()
       function
  */
  void rebuild_tag();

  void delete_option( const std::string option );

  void delete_default_options()
    { delete_option( "nowarning" ); }

  std::string get_options();

  int get_number_of_options()
  {
    if( !options_extracted )
      {
        extract_options();
        options_extracted = true;
      }

    if( options.empty() )
      return 0;

    int i=0;
    for( options_list_it it = options.begin(); it != options.end(); ++it )
      i++;
      
    return i;
  }

  bool get_option( int number, std::string &option, std::string &value )
  {
    int n = 0;
    for( options_list_it it = options.begin(); it != options.end(); ++it )
      {
        if( n == number )
          {
            value = it->second;
            option = it->first;
            return true;
          }

        if( n > number )
          return false;

        ++n;
      }
    
    return false;
  }

  bool get_option( int number, std::string &value )
  {
    std::string dummy;
    return get_option( number, dummy, value );
  }

  int get_level( bool guess_it = false );

 private:

  bool is_tag();

  void extract_options();

  void extract_type();

  void split_option( std::string option, std::string &name, std::string &value );

  inline bool check_if_valid();
};


#endif

---