Colorizer+ConsoleUtils Classes Version 1 (new) - Color the commandline

src/openms/include/OpenMS/APPLICATIONS/ConsoleUtils.h

@@ -35,46 +35,211 @@
 #pragma once
 
 #include <OpenMS/DATASTRUCTURES/String.h>
+#include <OpenMS/DATASTRUCTURES/StringListUtils.h>
+#include <OpenMS/CONCEPT/Colorizer.h>
+#include <iostream>
 
 namespace OpenMS
 {
 
   class OPENMS_DLLAPI ConsoleUtils
   {
-public:
+  public:
     /// make a string console friendly
     /// by breaking it into multiple lines according to the console width
     /// The 'indentation' gives the number of spaces which is prepended beginning at the second (!)
     /// line, so one gets a left aligned block which has some space to the left.
     /// An indentation of 0 results in the native console's default behaviour: just break at the end of
     /// its width and start a new line.
-    /// but usually one wants nicely intended blocks, which the console does not support
-    /// 'max_lines' gives the upper limit of lines returned after breaking is finished. 
+    /// but usually one wants nicely indented blocks, which the console does not support
+    /// 'max_lines' gives the upper limit of lines returned after breaking is finished.
     /// Excess lines are removed and replaced by '...', BUT the last line will be preserved.
     /// @param input String to be split
     /// @param indentation Number of spaces to use for lines 2 until last line.
     /// @param max_lines Limit of output lines (all others are removed)
-    static String breakString(const String& input, const Size indentation, const Size max_lines);
+        /// C'tor
+    ConsoleUtils();
+
+    /// Copy C'tor
+    ConsoleUtils(const ConsoleUtils&);
+
+    /// Destructor
+    ~ConsoleUtils();
+
+    static OpenMS::String breakString(const String& input,
+                                          const Size indentation, 
+                                          const Size max_lines, 
+                                          const Size curser_pos = 0);
+
+    static OpenMS::StringList breakStringList(const String& input,
+                                          const Size indentation, 
+                                          const Size max_lines, 
+                                          const Size curser_pos = 0);
+
+    int getConsoleSize() //deleted const here
+  {
+    return console_width_;
+  }
+
+  static ConsoleUtils getInstance()
+  {
+    return getInstance_();
+  }
+
+
+//#ifdef OPENMS_WINDOWSPLATFORM
+
+    // /// reset the color of the windows output handle
+    // void resetCoutColor();
+    // /// reset the color of the windows error handle
+    // void resetCerrColor();
+
+    /// reset the color of both output streams
+    void resetConsoleColor();
 
-private:
-    /// width of console we are currently in (if not determinable, set to 80 as default)
+    void setCoutColor(int color_code);
+
+    void setCerrColor(int color_code);
+
+    int getCoutColor();
+
+    int getCerrColor();
+
+//#endif
+
+  private:
+    /// width of console we are currently in 
+    ///(if not determinable, set to 80 as default)
     int console_width_;
 
     /// read console settings for output shaping
     int readConsoleSize_();
 
+
+    static ConsoleUtils& getInstance_();
+
     /// returns a console friendly version of input
-    String breakString_(const String& input, const Size indentation, const Size max_lines);
+    OpenMS::StringList breakString_(const String& input,
+                                    const Size indentation, 
+                                    const Size max_lines, 
+                                    const Size curser_pos);
 
-    /// C'tor
-    ConsoleUtils();
 
-    /// Copy C'tor
-    ConsoleUtils(const ConsoleUtils &);
+
+    // /// Destructor
+    // ~ConsoleUtils();
 
     /// Assignment operator
     void operator=(ConsoleUtils const&);
+
+//#ifdef OPENMS_WINDOWSPLATFORM
+
+    /// Default console color for output stream
+    int default_cout_;
+
+    /// Default console color for error stream
+    int default_cerr_;
+
+
+//#endif
   };
 
+  class ColorizerMethods: public Colorizer
+    {
+
+    public:
+
+    ///Constructor
+    ColorizerMethods(const Color color);
+
+    /// Default destructor
+    ~ColorizerMethods();
+
+    void outputToStream_(std::ostream& o_stream){this->outputToStream(o_stream);}
+
+    void colorStream_(std::ostream& stream) const{this->colorStream(stream);}
+
+    void resetColor_(std::ostream& stream){this->resetColor(stream);}
+
+    bool getReset_(){return this->getReset();}
+
+    std::string getDataAsString_(){return this->getDataAsString();}
+    };
+
+  class IndentedStringStream
+  {
+  public:
+    IndentedStringStream(std::ostream& stream, 
+                              const Size indentation, 
+                              const Size max_lines) : stream_(&stream), 
+                              indentation_(indentation), 
+                              max_lines_(max_lines), 
+                              current_column_pos_(0)
+    {
+      max_line_width_ = ConsoleUtils::getInstance().getConsoleSize();
+    }
+
+
+    template<typename T>
+    IndentedStringStream& operator<<(const T& data)
+    {
+
+      std::stringstream s;
+      s << data;
+      const std::string& string_to_print = s.str();
+
+      //wie viele zeilen sind es / viel viele zeichen in letrzter zeile
+
+      OpenMS::StringList result = ConsoleUtils::breakStringList(string_to_print,
+                                                            indentation_,
+                                                            max_lines_,
+                                                            current_column_pos_);
+
+      if (result.size()>=2)
+      { // we completed the previous line, so start counting from the latest incomplete line
+        current_column_pos_ = result.back().size();
+       }
+       else
+       { // only one line; simply forward the column position
+         current_column_pos_ += result.back().size();
+       }
+
+
+
+        *stream_ << ListUtils::concatenate(result, '\n');
+
+      return *this;
+
+    }
+///741 = offset
+///763 = indent
+
+
+    // IndentedStringStream& operator<<(ColorizerMethods& colorizer);
+
+  private:
+    std::ostream* stream_;
+    int indentation_;
+    int max_lines_;
+    int max_line_width_;
+    int current_column_pos_;
+
+
+  IndentedStringStream& operator<<(ColorizerMethods& colorizer)   
+{ 
+  colorizer.colorStream_(*stream_);
+  this->operator<<(colorizer.getDataAsString_());
+
+  if(colorizer.getReset_())
+  {
+    colorizer.resetColor_(*stream_);
+
+  }
+
+  return *this;
+}
+
+};
+
 } // namespace OpenMS