Cómo agregar indention al operador de secuencia

Question

En nuestro proyecto utilizamos el operador de secuencia C++ (< <) en nuestro modelo de objetos para imprimir un formato de datos fácil de leer. Un ejemplo simplificado es la siguiente:

std::ostream& operator<<(std::ostream & oStream, const OwnClass& iOwnClass) { 
    oStream << "[SomeMember1: " << iOwnClass._ownMember1 << "]\n"; 
    oStream << "[SomeMember2: " << iOwnClass._ownMember2 << "]\n"; 
} 

Resultando en esto en el registro:

[SomeMember1: foo] 
[SomeMember2: bar] 

Lo que queremos ahora es ser capaz de sangrar el resultado de ese operador. Algunas clases de llamadas pueden no desear el resultado de esta manera, pero desean agregar 2 espacios de sangría antes de cada línea. Podríamos agregar un miembro a nuestra clase especificando la sangría, pero esa no parece ser una solución elegante.

Por supuesto, este no es un gran problema, pero nuestro registro sería mucho mejor si esto funcionara.

Gracias

Answer 1

La solución más simple es deslizar un streambuf de filtrado entre el ostream y el streambuf real. Algo así como:

class IndentingOStreambuf : public std::streambuf 
{ 
    std::streambuf*  myDest; 
    bool    myIsAtStartOfLine; 
    std::string   myIndent; 
    std::ostream*  myOwner; 
protected: 
    virtual int   overflow(int ch) 
    { 
     if (myIsAtStartOfLine && ch != '\n') { 
      myDest->sputn(myIndent.data(), myIndent.size()); 
     } 
     myIsAtStartOfLine = ch == '\n'; 
     return myDest->sputc(ch); 
    } 
public: 
    explicit   IndentingOStreambuf( 
          std::streambuf* dest, int indent = 4) 
     : myDest(dest) 
     , myIsAtStartOfLine(true) 
     , myIndent(indent, ' ') 
     , myOwner(NULL) 
    { 
    } 
    explicit   IndentingOStreambuf(
          std::ostream& dest, int indent = 4) 
     : myDest(dest.rdbuf()) 
     , myIsAtStartOfLine(true) 
     , myIndent(indent, ' ') 
     , myOwner(&dest) 
    { 
     myOwner->rdbuf(this); 
    } 
    virtual    ~IndentingOStreambuf() 
    { 
     if (myOwner != NULL) { 
      myOwner->rdbuf(myDest); 
     } 
    } 
}; 

Para insertar, basta con crear una instancia de la streambuf:

IndentingOStreambuf indent(std::cout); 
// Indented output... 

Cuando indent sale del ámbito, todo vuelve a la normalidad.

(Para el registro, tengo uno que es un poco más complejo: la LoggingOStreambuf toma __FILE__ y __LINE__ como argumentos, establece myIndent a una cadena con formato con estos argumentos, además de un sello de tiempo , restablece a una muesca cadena después de cada salida, recoge toda la producción en un std::ostringstream, y la envía a atómicamente myDest en el destructor.)

Answer 2

No tan buena manera de hacer esto es añadir una variable global, que cuenta la sangría. Algo como esto:

std::string OwnClassIndentation; 
std::ostream& operator<<(std::ostream & oStream, const OwnClass& iOwnClass) { 
    oStream << "[SomeMember1:" << OwnClassIndentation << iOwnClass._ownMember1 << "]\n"; 
    oStream << "[SomeMember2:" << OwnClassIndentation << iOwnClass._ownMember2 << "]\n"; 
} 

Y luego configúrelo según corresponda.

Answer 3

Puede crear su propia clase de flujo que tenga una variable de sangría y anular el endl para esa clase, insertando la sangría.

Answer 4

Esto se puede hacer utilizando un manipulador de flujo personalizado que almacena el nivel de sangría deseado en una palabra de la matriz interna extensible de la secuencia. Puede solicitar tal palabra usando la función ios_base::xalloc. Esta función te dará el índice de tu palabra. Puede acceder usando ios_base::iword. Una forma de implementar esto sería la siguiente:

struct indent { 
    indent(int level) : level(level) {} 
private: 
    friend std::ostream& operator<<(std::ostream& stream, const indent& val); 

    int level; 
}; 

std::ostream& operator<<(std::ostream& stream, const indent& val) { 
    for(int i = 0; i < val.level; i++) { 
     stream << " "; 
    } 
    return stream; 
} 

std::ostream& operator<<(std::ostream & oStream, const OwnClass& iOwnClass) { 
    oStream << indent(oStream.iword(index)) << "[SomeMember1: " << 
       iOwnClass._ownMember1 << "]\n"; 
    oStream << indent(oStream.iword(index)) << "[SomeMember2: " << 
       iOwnClass._ownMember2 << "]\n"; 
} 

Habría que averiguar dónde almacenar el index. De hecho, esto le permite agregar un estado personalizado a la transmisión (tenga en cuenta que esto no sería seguro para subprocesos desde el primer momento). Cada función que desee una sangría debería agregar la sangría solicitada a la transmisión y restarla cuando esté terminada. Se podría asegurarse siempre pasa esto mediante el uso de un protector de añadir/restar el guión deseado (en mi humilde opinión esto es más elegante que el uso de un manipulador):

class indent_guard { 
public: 
    indent_guard(int level, std::ostream& stream, int index) 
    : level(level), 
     stream(stream), 
     index(index) 
    { 
     stream.iword(index) += level; 
    } 

    ~indent_guard() { 
     stream.iword(index) -= level; 
    } 

private: 
    int level; 
    std::ostream& stream; 
    int index; 
}; 

Usted puede utilizar de esta manera:

void some_func() { 
    indent_guard(2, std::cout, index); 

    // all output inside this function will be indented by 2 spaces 

    some_func(); // recursive call - output will be indented by 4 spaces 

    // here it will be 2 spaces again 
}