fork download
copy 
  1. #include <string>                                                                                                                                                                                      
  2. #include <memory>                                                                                                                                                                                      
  3. #include <iostream>                                                                                                                                                                                     
  4.  
  5. namespace console                                                                                                                                                                                      
  6. {                                                                                                                                                                                                      
  7.  
  8. class Logger                                                                                                                                                                                           
  9. {                                                                                                                                                                                                      
  10. public:                                                                                                                                                                                                
  11.     Logger();                                                                                                                                                                                          
  12.     Logger(std::shared_ptr<std::ostream>);                                                                                                                                                             
  13.  
  14.     Logger& replace(std::string);                                                                                                                                                                      
  15.     Logger& append(std::string);                                                                                                                                                                       
  16.     Logger& newline();                                                                                                                                                                                 
  17.  
  18. private:                                                                                                                                                                                               
  19.     void erase(size_t);                                                                                                                                                                                
  20.  
  21.     std::shared_ptr<std::ostream> _out;                                                                                                                                                                
  22.     size_t _lineLength = 0;                                                                                                                                                                            
  23. };                                                                                                                                                                                                     
  24.  
  25. }                                                                                                                                                                    
  26.  
  27.  
  28. console::Logger::Logger()                                                                                                                                                                              
  29.     : _out(std::shared_ptr<std::ostream>(&std::cout, [](void*) {}))                                                                                                                                    
  30. {                                                                                                                                                                                                      
  31. }                                                                                                                                                                                                      
  32.  
  33.  
  34. console::Logger::Logger(std::shared_ptr<std::ostream> out)                                                                                                                                             
  35.     : _out(out)                                                                                                                                                                                        
  36. {                                                                                                                                                                                                      
  37. }                                                                                                                                                                                                      
  38.  
  39.  
  40. console::Logger& console::Logger::replace(std::string str)                                                                                                                                             
  41. {                                                                                                                                                                                                      
  42.     erase(_lineLength);                                                                                                                                                                                
  43.     _lineLength = 0;                                                                                                                                                                                   
  44.     append(str);                                                                                                                                                                                       
  45.     return *this;                                                                                                                                                                                      
  46. }                                                                                                                                                                                                      
  47.  
  48.  
  49. console::Logger& console::Logger::append(std::string str)                                                                                                                                              
  50. {                                                                                                                                                                                                      
  51.     *_out.get() << str << std::flush;                                                                                                                                                                  
  52.     _lineLength += str.size();                                                                                                                                                                         
  53.     return *this;                                                                                                                                                                                      
  54. }                                                                                                                                                                                                      
  55.  
  56.  
  57. console::Logger& console::Logger::newline()                                                                                                                                                            
  58. {                                                                                                                                                                                                      
  59.     *_out.get() << std::endl;                                                                                                                                                                          
  60.     _lineLength = 0;                                                                                                                                                                                   
  61.     return *this;                                                                                                                                                                                      
  62. }                                                                                                                                                                                                      
  63.  
  64.  
  65. void console::Logger::erase(size_t size)                                                                                                                                                               
  66. {                                                                                                                                                                                                      
  67.     // go back                                                                                                                                                                                         
  68.     for (size_t i = 0; i < size; ++i) {                                                                                                                                                                
  69.         *_out.get() << '\b';                                                                                                                                                                           
  70.     }                                                                                                                                                                                                  
  71.     // replace by space                                                                                                                                                                                
  72.     for (size_t i = 0; i < size; ++i) {                                                                                                                                                                
  73.         *_out.get() << ' ';                                                                                                                                                                            
  74.     }                                                                                                                                                                                                  
  75.     // go back again                                                                                                                                                                                   
  76.     for (size_t i = 0; i < size; ++i) {                                                                                                                                                                
  77.         *_out.get() << '\b';                                                                                                                                                                           
  78.     }                                                                                                                                                                                                  
  79. }
  80.  
  81.  
  82.  
  83. int main() {
  84. 	console::Logger log;
  85. 	log.append("hello").replace("hi").newline().append("hey");
  86. 	return 0;
  87. }
Success #stdin #stdout 0s 3416KB
comments (?)
stdin
copy 
Standard input is empty
stdout
copy 
hello     hi
hey
https://ideone.com/1MJPkV
language:
C++14 (gcc 8.3)
created:
10 years ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!