Come aggiungere l'indentazione all'operatore dello streaming

Question

Nel nostro progetto usiamo l'operatore di flusso C++ (< <) nel nostro modello a oggetti per stampare un formato dei dati facilmente leggibile. Un esempio semplificato è questo:

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

Con conseguente questo nella registrazione:

[SomeMember1: foo] 
[SomeMember2: bar] 

Quello che vogliamo ora è quello di essere in grado di rientrare il risultato di tale operatore. Alcune classi chiamanti potrebbero non volere il risultato in questo modo, ma vogliono aggiungere 2 indention di spazi prima di ogni riga. Potremmo aggiungere un membro alla nostra classe specificando l'indention, ma non sembra essere una soluzione elegante.

Ovviamente questo non è un grosso problema, ma il nostro registro sarebbe molto più bello se funzionasse.

Grazie

Answer 1

La soluzione più semplice è quella di inserire uno streambuf filtraggio tra ostream e lo streambuf effettivo. Qualcosa di simile:

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); 
     } 
    } 
}; 

Per inserire, basta creare un'istanza della streambuf:

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

Quando indent va fuori portata, tutto torna alla normalità.

(Per la registrazione, Ho uno che è un po 'più complesso: il LoggingOStreambuf prende __FILE__ e __LINE__ come argomenti, imposta myIndent ad una stringa formattata con questi argomenti, più un timestamp , resetta ad una rientranza stringa dopo ogni uscita, raccoglie tutto l'output in un std::ostringstream, e l'emette atomicamente a myDest nel distruttore.)

Answer 2

Non così buon modo per farlo è quello di aggiungere una variabile globale, che racconta il rientro. Qualcosa del genere:

E quindi impostare come appropriato.

Answer 3

È possibile creare una propria classe di stream con una variabile di indentazione e sovrascrivere l'endl per quella classe, inserendo il rientro.

Answer 4

Questo può essere fatto utilizzando un manipolatore di flusso personalizzato che memorizza il livello di indentazione desiderato in una parola della matrice interna estensibile del flusso. È possibile richiedere una parola di questo tipo utilizzando la funzione ios_base::xalloc. Questa funzione ti darà l'indice della tua parola. È possibile accedervi utilizzando ios_base::iword. Un modo per attuare tale sarebbe questa:

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"; 
} 

Dovresti capire dove memorizzare il index. Ciò consente effettivamente di aggiungere uno stato personalizzato allo stream (si noti che questo non sarebbe sicuro per i thread pronto all'uso). Ogni funzione che richiede il rientro dovrebbe aggiungere il rientro richiesto allo stream e sottrarlo di nuovo quando viene eseguito. Si potrebbe fare in modo che questo accada sempre utilizzando una guardia per aggiungere/sottrarre il trattino desiderato (IMHO questo è più elegante rispetto all'utilizzo di un manipolatore):

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; 
}; 

si potrebbe usare in questo modo:

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 
}