---

init.h

Go to the documentation of this file.

#ifndef init_h
#define init_h

#include "tag.h"

class Init : private Tag
{
 public:
  enum Type  
    {
      INITOPEN,
      INITCLOSE,
      INCLUDE,
      MACROS,
      MENU,
      IMAGE,
      FILELINK,
      FILELIST,
      INTERPRETER,
      FUNCTIONS,
      LOCALE,
      CHARSET,
      DELETE,
      DEFINE,
      USER       
    };

  struct Range
  {
    enum Type
      {
        FROM_TO,
        LEVEL
      };

    Type type;

    int lower;
    int upper;
    int level;

    Range( int lower, int upper ) : type( FROM_TO ), lower( lower ), upper( upper ) {}
    Range( int level ) : type( LEVEL), level( level ) {}
    Range() {}

    bool in_range( int n );
  };

  typedef std::list<Range> range_list;
  typedef range_list::iterator range_list_it;

 private:
  Type type;

  mutable range_list ral;

  std::string user_name; 

  bool insert;           
  bool append;
  bool del;

  bool ignore; // recognice an init tag only once

 public:
  Init( Line line );

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

  Type get_type() const { return type; }

  bool has_range() const { return !ral.empty(); }

  bool has_one_range() const { return get_elements( ral ) == 1; }

  Range get_first() const { return *ral.begin(); }

  range_list get_range() const { return ral; }

/*
  std::string get_tag() { return ""; }
*/

  Line get_line() { return Tag::get_line(); }

  std::string get_user_name() const { return user_name; }

  bool is_insert() const { return insert; }
  
  bool is_append() const { return append; }

  bool is_delete() const { return del; }

  bool is_ignore() const { return ignore; }

  bool is_ignore( bool t ) { ignore = t; set_option("ignore", t ); }

  std::string get_tag();

private:
  void extract_range( const std::string& level );
  void strip_list( Strings::string_list& sl );

#if __GNUC__ == 2
  // gcc 2.x.x has problems with template template parameters

  int get_elements( Strings::string_list& sl ) const
  {
    if( sl.empty() )
      return 0;

    int i = 0;
    for( Strings::string_list_it it = sl.begin(); it != sl.end(); ++it )
      ++i;

    return i;
  }

  int get_elements( range_list& sl ) const
  {
    if( sl.empty() )
      return 0;

    int i = 0;
    for( range_list_it it = sl.begin(); it != sl.end(); ++it )
      ++i;

    return i;
  }
  
#else

  template <class A> int get_elements( std::list<A>& sl ) const
  {
    if( sl.empty() )
      return 0;

    int i = 0;
    for( std::list<A>::iterator it = sl.begin(); it != sl.end(); ++it )
      ++i;

    return i;
  }

#endif

};

std::string get_init_name( const Init::Type type );

struct InitTableEntry
{
  Init::Type type;
  bool was_detected;
  Init::range_list ranges;
  bool has_range;
  bool has_one_range;
  std::string user_name;

  InitTableEntry( Init::Type t, bool wd = false )
    : type( t ), 
      was_detected( wd ), 
      has_range( false ), 
      has_one_range( false ),
      user_name( get_init_name( t ) )
  {
    
  }

  InitTableEntry( Init::Type t, bool wd, const Init::range_list& rl, bool hr, bool hor ) 
    : type( t ), 
      was_detected( wd ), 
      ranges( rl ),
      has_range( hr ), 
      has_one_range( hor ),
      user_name( get_init_name( t ) )
  {}
};

inline bool operator==( const Init::Range& range, Init::Range::Type type )
{
  return range.type == type;
}

Init::Type get_init_type( const std::string type );

std::string get_init_name( const Init::Type type );

#endif

---