Vc++: Problema Con Std::map Y El Operador '<'

[ALRAZ]

 Wenas

aquí vengo con otra de esas intrigantes preguntillas del mundo de C++.
Sucede que estoy modificando la clase IniFile de ZaelSiuS; y en aras de hacerla non-case-sensitive, me puse a escribir una clase con sobrecargas de operadores y cosas raras que presento a continuación:

Código [Seleccionar] Expand


class caselessstr
{
private:
  inline string UPPERCASE (const string Str)
  {
     string Tmp;
#ifdef WIN32
     std::transform( Str.begin(), Str.end(), Tmp.begin(), toupper);
#else
     std::transform( Str.begin(), Str.end(), Tmp.begin(), std::toupper);
#endif

     return Tmp;
  };
public:
  std::string Data;

  caselessstr () {};
  caselessstr (const caselessstr &Src) {Data = Src.Data;};
  caselessstr (const std::string &Src) {Data = Src;};
  caselessstr (const char *Src)        {Data = Src;};

  ~caselessstr () {Data.clear ();};

  std::ostream &operator << (std::ostream &O) { O << Data; return O;};

  //con  Case-lessStr
  caselessstr &operator = (const caselessstr &Src) {Data = Src.Data; return *this;};
  bool operator == (const caselessstr &Src) {return (UPPERCASE (Data) == UPPERCASE (Src.Data));};
  bool operator != (const caselessstr &Src) {return !(operator== (Src));};
  bool operator <  (const caselessstr &Src) {return (UPPERCASE (Data) <  UPPERCASE (Src.Data));};
  bool operator >  (const caselessstr &Src) {return (UPPERCASE (Data) >  UPPERCASE (Src.Data));};
  bool operator <= (const caselessstr &Src) {return (UPPERCASE (Data) <= UPPERCASE (Src.Data));};
  bool operator >= (const caselessstr &Src) {return (UPPERCASE (Data) >= UPPERCASE (Src.Data));};

  //con std::string
  caselessstr &operator = (const std::string &Str) {Data = Str.c_str (); return *this;};
  bool operator == (const std::string &Src) {return (UPPERCASE (Data) == UPPERCASE (Src));};
  bool operator != (const std::string &Src) {return !(operator== (Src));};
  bool operator <  (const std::string &Src) {return (UPPERCASE (Data) < UPPERCASE (Src));};
  bool operator >  (const std::string &Src) {return (UPPERCASE (Data) > UPPERCASE (Src));};
  bool operator <= (const std::string &Src) {return (UPPERCASE (Data) <=UPPERCASE (Src));};
  bool operator >= (const std::string &Src) {return (UPPERCASE (Data) >=UPPERCASE (Src));};

  //con const char *
  caselessstr &operator = (const char *Src)  {Data = Src; return *this;};
  bool operator == (const char *Src) {return (UPPERCASE (Data) == UPPERCASE (Src));};
  bool operator != (const char *Src) {return !(operator== (Src));};
  bool operator <  (const char *Src) {return (UPPERCASE (Data) < UPPERCASE (Src));};
  bool operator >  (const char *Src) {return (UPPERCASE (Data) > UPPERCASE (Src));};
  bool operator <= (const char *Src) {return (UPPERCASE (Data) <=UPPERCASE (Src));};
  bool operator >= (const char *Src) {return (UPPERCASE (Data) >=UPPERCASE (Src));};

};


dicha clase se usa de la siguiente manera:

Código [Seleccionar] Expand


typedef std::map< caselessstr, std::map< std::string, std::string> > IniMap;
typedef std::map< std::string, std::string> IniPair;


ahora, en realidad tengo 2 problemas:
1- al hacer algo como:

Código [Seleccionar] Expand


  std::ofstream Archivo ("algo.txt",  std::ios_base::trunc);
  IniMap X;
  //...
  Archivo <<  X;
  //...

El compilador me dice que NO existe un operador para "<<" que acepte un caselessstr del lado derecho.
No parece importarle el hecho de que la clase en realidad contiene una sobrecarga para tal efecto >_>

bien. Eso lo "solucioné" poniendo una sobrecarga del operador global "<<"

Código [Seleccionar] Expand


std::ostream &operator << (std::ostream &O, const caselessstr &Src)
{
  O << Src.Data;
  return O;
}


2-Luego de eso, esta cosa me marca error en el operador "<", alegando que
"no existe un operador que tome un operando del lado izquierdo del tipo caselessstr"
cuando en realidad la clase tiene el tan mencionado operador.
El error lo marca en el include (que imagino es parte del estandar)

Código [Seleccionar] Expand


template<class _Ty>
struct less
 : public binary_function<_Ty, _Ty, bool>
{ // functor for operator<
bool operator()(const _Ty& _Left, const _Ty& _Right) const
 { // apply operator< to operands
 return (_Left < _Right);
 }
};

en ese "return (_Left < _Right)"

sugerencias?

[ALRAZ]

 bueno, pero no me ayuden todos a la vez T_T

[Zaelsius]

 El primer error/problema me parece lógico:

Código [Seleccionar] Expand


std::ofstream Archivo ("algo.txt",  std::ios_base::trunc);
IniMap X;

Archivo <<  X;

// lo de arriba es lo mismo que

Archivo.operator<<( X );   // Meeec!, la clase std::ofstream no acepta IniMap en la sobrecarga de <<


Del segundo problema no me he enterado muy bien. ¿es un error de compilación?

Edit: ya lo he pillado. (pensando...)


A vore, ese error deberia venir de alguna llamada a función de la STL, tipo Sort o Transform, a la que le pasas un tipo no estándar sin operador < definido. Pero por más que miro tu código no sé qué llamada lo puede estar provocando, ya que empleas tipos std::string para std::transform, y no ccaseless.

[ALRAZ]

 
y qué tal Find?

Código [Seleccionar] Expand


if ( m_map.find( section ) != m_map.end() && m_map[section].find( key ) != m_map[section].end() )


recuerdas?  :P

-------------------------------------------------------------------
por cierto (Nota Aparte): encontré un leve problemilla en tu código
cuando en un .ini hay algo  esto:

[Personaje]
Nombre = Juan Perez
...

Si le das un GetString a Nombre, sólo re regresa "Juan" y le importa un bledo el Perez

intenté arreglarlo, pero me salió peor el remedio que la enfermedad
y esque le he meneado tanto que ya no sé ni donde está el problema XD
(luego paso más detalles, cuando logre solucionarlo  (nooo) )

[Zaelsius]

 

por cierto (Nota Aparte): encontré un leve problemilla en tu código
cuando en un .ini hay algo  esto:

[Personaje]
Nombre = Juan Perez

Valep, arreglado(aunque un poco chapucero, volveré sobre ello alguna tarde).

Tambien he añadido las funciones para consulta sobre secciones disponibles y sus nombres.

Descargar

Envíame todo el código de tu versión, a ver si logro arreglar el tema del operador < (o pon un enlace aquí). Quizá al compilar con Gcc me de alguna pista más.

[ALRAZ]

 perdona que no haya escrito nada todavía

ando un poco liao con esto y con la escuela
lo he hecho tantos ajustes (y sobretodo desajustes) que ya no sé si funciona o no XD


dame algo de tiempo