---

locale.h

Go to the documentation of this file.

#ifndef locale_h
#define locale_h

#include "tag.h"

class ostream;

class Locale : private Tag
{
 private:
  std::string language;

  bool is_valid_tag;
  bool isdefault;

 public:
  Locale( Line& line );
  Locale() : Tag() {}

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

  std::string get_language() const { return language; }

  bool is_default() const { return isdefault; };

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

class LocaleClose : private Tag
{
 private:
  
  bool is_valid_tag;
 public:
  LocaleClose( Line& line );
  LocaleClose() : Tag() {}

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


/*** the locale tags are used like this:
 *
 *     <locale>
 *       <locale language="de">
 *         Hallo Welt!
 *       </locale>
 *       <locale language="en">
 *         Hello world!
 *       </locale>
 *     </locale>
*/
class LocaleSwitcher
{
 public:
  typedef enum What
    {
      LOCALE_OPEN,  
      LOCALE_LANG,  
      LOCALE_CLOSE, 
      OTHERS        
    };

  typedef struct Tag
  {
    Locale locale;
    Locale locale_lang;
    LocaleClose locale_close;
    std::string other;

    What what;

    Tag(): what( OTHERS ) {}

    Tag( Locale l ) : locale( l ), locale_lang( l )
    { if( l.get_language().empty() ) what = LOCALE_OPEN;  else what = LOCALE_LANG; }

    Tag( std::string o ) : other( o ), what( OTHERS ) {}

    Tag( LocaleClose lc ) : locale_close( lc ), what( LOCALE_CLOSE ) {}
  };

  typedef std::list<Tag> tag_list;
  typedef tag_list::iterator tag_list_it;

public:
  struct Error
  {
    enum Type 
      {
        OK = 0,
        NOT_SANE,
        LANG_LIST,
        LANG_NOT_FOUND,
        MULTIPLE_DEFAULTS,
        DOUBLE_LOCALE,
        DEFAULT_LANG
      };

    Type type;
    std::string err;

    Error() : type( OK ) {}

    Error( Type t, std::string e )
      : type( t ), err( e ) {}

    void operator = ( const Error e )
    { 
      if( type == OK )
        {
          type = e.type;
          err = e.err;
        }
      else
        err += "; " + e.err; 
    }
  };

 private:

  struct Language
  {
    Locale locale; 
    
    typedef std::list<std::string> string_list;
    typedef string_list::iterator string_list_it;

    string_list others; 
    
    std::string get_language() const { return locale.get_language(); }
    void add( std::string s ) { others.push_back( s ); }
    bool is_default() const { return locale.is_default(); }
  };

  Language lang;

  typedef std::list<Language> language_list;
  typedef language_list::iterator language_list_it;

  language_list langs;

  tag_list tlist;

  bool is_valid; 
  std::string language; 
  
  Error error;

 public:

  LocaleSwitcher( tag_list tlist, std::string language, bool no_lang_warn = true );

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

  std::string get_locale(); 

  Error get_error() const { return error; }

 private:

  /*** returns true if the system is sane */
  bool create_lang_list(); 

  bool is_sane(); 


  bool find_language(); 

  friend  std::ostream& operator << ( std::ostream& , const LocaleSwitcher::Tag& t );

  bool compare_language( std::string loc_lang, std::string lang );
};

std::ostream& operator << ( std::ostream& , const LocaleSwitcher::Tag& t );

#endif

---