Added ANSIColor constexpr ctor.

ansicolor.cpp

@@ -1,6 +1,7 @@
-#include "door.h"
 #include <string>
 
+#include "door.h"
+
 /**
  * @file
  * @brief ANSIColor
@@ -13,9 +14,7 @@ namespace door {
  * with sensible defaults (White on Black).
  *
  */
-ANSIColor::ANSIColor()
-    : fg(COLOR::WHITE), bg(COLOR::BLACK), reset(0), bold(0), blink(0),
-      inverse(0) {}
+ANSIColor::ANSIColor() : fg(COLOR::WHITE), bg(COLOR::BLACK), attr(0) {}
 
 /**
  * Construct a new ANSIColor::ANSIColor object
@@ -111,18 +110,18 @@ ANSIColor::ANSIColor(COLOR f, COLOR b, ATTR a1, ATTR a2) : ANSIColor() {
  */
 ANSIColor &ANSIColor::Attr(ATTR a) {
   switch (a) {
-  case ATTR::RESET:
-    reset = 1;
-    break;
-  case ATTR::BOLD:
-    bold = 1;
-    break;
-  case ATTR::BLINK:
-    blink = 1;
-    break;
-  case ATTR::INVERSE:
-    inverse = 1;
-    break;
+    case ATTR::RESET:
+      attr |= ATTR_RESET;
+      break;
+    case ATTR::BOLD:
+      attr |= ATTR_BOLD;
+      break;
+    case ATTR::BLINK:
+      attr |= ATTR_BLINK;
+      break;
+    case ATTR::INVERSE:
+      attr |= ATTR_INVERSE;
+      break;
   }
   return *this;
 }
@@ -136,8 +135,9 @@ ANSIColor &ANSIColor::Attr(ATTR a) {
  * @return bool
  */
 bool ANSIColor::operator==(const ANSIColor &c) const {
-  return ((fg == c.fg) and (bg == c.bg) and (bold == c.bold) and
-          (blink == c.blink) and (inverse == c.inverse));
+  return ((fg == c.fg) and (bg == c.bg) and
+          ((attr & (ATTR_BOLD | ATTR_BLINK | ATTR_INVERSE)) ==
+           ((c.attr & (ATTR_BOLD | ATTR_BLINK | ATTR_INVERSE)))));
 }
 
 /**
@@ -149,8 +149,9 @@ bool ANSIColor::operator==(const ANSIColor &c) const {
  * @return bool
  */
 bool ANSIColor::operator!=(const ANSIColor &c) const {
-  return !((fg == c.fg) and (bg == c.bg) and (bold == c.bold) and
-           (blink == c.blink) and (inverse == c.inverse));
+  return !((fg == c.fg) and (bg == c.bg) and
+           ((attr & (ATTR_BOLD | ATTR_BLINK | ATTR_INVERSE)) ==
+            ((c.attr & (ATTR_BOLD | ATTR_BLINK | ATTR_INVERSE)))));
 }
 
 /**
@@ -160,10 +161,7 @@ bool ANSIColor::operator!=(const ANSIColor &c) const {
  */
 void ANSIColor::setFg(COLOR f) {
   fg = f;
-  reset = 0;
-  bold = 0;
-  blink = 0;
-  inverse = 0;
+  attr = 0;
 }
 
 /**
@@ -174,7 +172,7 @@ void ANSIColor::setFg(COLOR f) {
  */
 void ANSIColor::setFg(COLOR f, ATTR a) {
   fg = f;
-  attr(a);
+  setAttr(a);
 }
 
 /**
@@ -191,12 +189,9 @@ void ANSIColor::setBg(COLOR b) { bg = b; }
  *
  * @param[in] a ATTR
  */
-void ANSIColor::attr(ATTR a) {
+void ANSIColor::setAttr(ATTR a) {
   // first, clear all attributes
-  reset = 0;
-  bold = 0;
-  blink = 0;
-  inverse = 0;
+  attr = 0;
   Attr(a);
 }
 
@@ -208,29 +203,30 @@ std::string ANSIColor::output(void) const {
   std::string clr(CSI);
 
   // check for special cases
-  if (reset and (fg == COLOR::BLACK) and (bg == COLOR::BLACK)) {
+  if (((attr & ATTR_RESET) == ATTR_RESET) and (fg == COLOR::BLACK) and
+      (bg == COLOR::BLACK)) {
     clr += "0m";
     return clr;
   }
 
-  if (reset and (fg == COLOR::WHITE) and (bg == COLOR::BLACK)) {
+  if (((attr & ATTR_RESET) == ATTR_RESET) and (fg == COLOR::WHITE) and
+      (bg == COLOR::BLACK)) {
     clr += "0m";
     return clr;
   }
 
-  if (reset) {
+  if ((attr & ATTR_RESET) == ATTR_RESET) {
     clr += "0;";
   }
 
-  if (bold) {
-    if (blink) {
+  if ((attr & ATTR_BOLD) == ATTR_BOLD) {
+    if ((attr & ATTR_BLINK) == ATTR_BLINK) {
       clr += "5;";
     }
     clr += "1;";
   } else {
-    if (!reset)
-      clr += "0;";
-    if (blink) {
+    if (!((attr & ATTR_RESET) == ATTR_RESET)) clr += "0;";
+    if ((attr & ATTR_BLINK) == ATTR_BLINK) {
       clr += "5;";
     }
   }
@@ -253,9 +249,9 @@ std::string ANSIColor::debug(void) {
   output += ", BG";
   output += std::to_string((int)bg);
   output += ", B";
-  output += std::to_string(bold);
+  output += std::to_string((attr & ATTR_BOLD) == ATTR_BOLD);
   output += ", R";
-  output += std::to_string(reset);
+  output += std::to_string((attr & ATTR_RESET) == ATTR_RESET);
 
   return output;
 }
@@ -272,27 +268,29 @@ std::string ANSIColor::output(ANSIColor &previous) const {
   // color output optimization
 
   // check for special cases
-  if (reset and (fg == COLOR::BLACK) and (bg == COLOR::BLACK)) {
+  if (((attr & ATTR_RESET) == ATTR_RESET) and (fg == COLOR::BLACK) and
+      (bg == COLOR::BLACK)) {
     clr += "0m";
     previous = *this;
-    previous.reset = 0;
+    previous.attr &= ~ATTR_RESET;  // reset = 0;
     return clr;
   }
 
   bool temp_reset = false;
-  if ((!blink) and (blink != previous.blink)) {
+  if ((!((attr & ATTR_BLINK) == ATTR_BLINK)) and
+      (((attr & ATTR_BLINK) == ATTR_BLINK) !=
+       ((previous.attr & ATTR_BLINK) == ATTR_BLINK))) {
     temp_reset = true;
   }
 
-  if ((reset) or (temp_reset)) {
+  if (((attr & ATTR_RESET) == ATTR_RESET) or (temp_reset)) {
     // current has RESET, so default to always sending colors.
     if (temp_reset) {
       clr += "0m";
     }
 
     // this fixes the extra \x1b that shows up with reset.
-    if (clr.compare(CSI) == 0)
-      clr.clear();
+    if (clr.compare(CSI) == 0) clr.clear();
     clr += output();
 
     /*
@@ -303,7 +301,7 @@ std::string ANSIColor::output(ANSIColor &previous) const {
     */
 
     previous = *this;
-    previous.reset = 0;
+    previous.attr &= ~ATTR_RESET;
     return clr;
   }
 
@@ -314,38 +312,33 @@ std::string ANSIColor::output(ANSIColor &previous) const {
 
   // resume "optimization"
 
-  if (bold != previous.bold) {
+  if (((attr & ATTR_BOLD) == ATTR_BOLD) !=
+      ((previous.attr & ATTR_BOLD) == ATTR_BOLD)) {
     // not the same, so handle this.
-    if (bold) {
-      if (blink) {
+    if ((attr & ATTR_BOLD) == ATTR_BOLD) {
+      if ((attr & ATTR_BLINK) == ATTR_BLINK) {
         clr += "5;";
       }
       clr += "1;";
-      if (fg != previous.fg)
-        clr += std::to_string((int)fg + 30) + ";";
-      if (bg != previous.bg)
-        clr += std::to_string((int)bg + 40) + ";";
+      if (fg != previous.fg) clr += std::to_string((int)fg + 30) + ";";
+      if (bg != previous.bg) clr += std::to_string((int)bg + 40) + ";";
     } else {
       clr += "0;";
-      if (blink) {
+      if ((attr & ATTR_BLINK) == ATTR_BLINK) {
         clr += "5;";
       }
 
       // RESET to turn OFF BOLD, clears previous
-      if (fg != COLOR::WHITE)
-        clr += std::to_string((int)fg + 30) + ";";
-      if (bg != COLOR::BLACK)
-        clr += std::to_string((int)bg + 40) + ";";
+      if (fg != COLOR::WHITE) clr += std::to_string((int)fg + 30) + ";";
+      if (bg != COLOR::BLACK) clr += std::to_string((int)bg + 40) + ";";
     }
   } else {
     // not bold.
-    if (blink) {
+    if ((attr & ATTR_BLINK) == ATTR_BLINK) {
       clr += "5;";
     }
-    if (fg != previous.fg)
-      clr += std::to_string((int)fg + 30) + ";";
-    if (bg != previous.bg)
-      clr += std::to_string((int)bg + 40) + ";";
+    if (fg != previous.fg) clr += std::to_string((int)fg + 30) + ";";
+    if (bg != previous.bg) clr += std::to_string((int)bg + 40) + ";";
   };
 
   // Remove ';' if last character
@@ -376,8 +369,7 @@ std::ostream &operator<<(std::ostream &os, const ANSIColor &c) {
     d->track = false;
     out = c.output(d->previous);
     // if (!out.empty())
-    if (out.compare("\x1b[") == 0)
-      std::abort();
+    if (out.compare("\x1b[") == 0) std::abort();
 
     *d << out;
     d->track = true;
@@ -392,4 +384,4 @@ std::ostream &operator<<(std::ostream &os, const ANSIColor &c) {
 
 ANSIColor reset(ATTR::RESET);
 
-} // namespace door
+}  // namespace door

door.h

@@ -1,7 +1,6 @@
 #ifndef DOOR_H
 #define DOOR_H
 
-#include "anyoption.h"
 #include <cstdint>
 #include <ctime>
 #include <fstream>
@@ -13,6 +12,8 @@
 #include <ostream>
 #include <vector>
 
+#include "anyoption.h"
+
 // raw mode
 #include <termios.h>
 #include <unistd.h>
@@ -124,6 +125,26 @@ enum class ATTR : std::int8_t {
   INVERSE = 7
 };
 
+constexpr long strhash(const char *txt) {
+  long result = 0;
+
+  for (int x = 0; x < 3; ++x) {
+    if (txt[x] == 0) break;
+    result = (result << 8) | txt[x];
+  }
+
+  return result;
+};
+
+enum Attribute {
+  ATTR_NONE = 0x00,
+  ATTR_BOLD = 0x01,
+  ATTR_BRIGHT = 0x01,
+  ATTR_INVERSE = 0x02,
+  ATTR_BLINK = 0x04,
+  ATTR_RESET = 0x08,
+};
+
 /**
  * @class ANSIColor
  * This holds foreground, background and ANSI-BBS attribute
@@ -135,22 +156,119 @@ enum class ATTR : std::int8_t {
  *
  */
 class ANSIColor {
+ public:
   /** Foreground color */
   COLOR fg;
   /** Background color */
   COLOR bg;
   // Track attributes (ATTR)
+  unsigned char attr;
+
   /** reset flag / always send color and attributes */
-  unsigned int reset : 1;
+  // unsigned int reset : 1;
   /** bold / bright flag */
-  unsigned int bold : 1;
+  // unsigned int bold : 1;
   /** blink slow blinking text */
-  unsigned int blink : 1;
+  // unsigned int blink : 1;
   /** inverse */
-  unsigned int inverse : 1;
+  // unsigned int inverse : 1;
 
-public:
+ public:
   ANSIColor();
+  constexpr ANSIColor(const char *text)
+      : fg{COLOR::WHITE}, bg{COLOR::BLACK}, attr{0} {
+    const char *cp = text;
+    bool use_on = false;
+
+    while (*cp != 0) {
+      long key = strhash(cp);
+
+      switch (key) {
+        case strhash("BRI"):
+          attr |= ATTR_BOLD;
+          break;
+        case strhash("BOL"):
+          attr |= ATTR_BOLD;
+          break;
+        case strhash("BLI"):
+          attr |= ATTR_BLINK;
+          break;
+        case strhash("INV"):
+          attr |= ATTR_INVERSE;
+          break;
+        case strhash("RES"):
+          attr |= ATTR_RESET;
+          break;
+        case strhash("ON "):
+          use_on = true;
+          break;
+
+        case strhash("BLU"):
+          if (use_on)
+            bg = COLOR::BLUE;
+          else
+            fg = COLOR::BLUE;
+          break;
+        case strhash("RED"):
+          if (use_on)
+            bg = COLOR::RED;
+          else
+            fg = COLOR::RED;
+          break;
+        case strhash("GRE"):
+          if (use_on)
+            bg = COLOR::GREEN;
+          else
+            fg = COLOR::GREEN;
+          break;
+        case strhash("YEL"):
+          if (use_on)
+            bg = COLOR::YELLOW;
+          else {
+            fg = COLOR::YELLOW;
+            attr |= ATTR_BOLD;
+          }
+          // if (use_on) throw error!
+          break;
+        case strhash("BRO"):
+          if (use_on)
+            bg = COLOR::BROWN;
+          else
+            fg = COLOR::BROWN;
+          break;
+        case strhash("CYA"):
+          if (use_on)
+            bg = COLOR::CYAN;
+          else
+            fg = COLOR::CYAN;
+          break;
+        case strhash("MAG"):
+          if (use_on)
+            bg = COLOR::MAGENTA;
+          else
+            fg = COLOR::MAGENTA;
+          break;
+        case strhash("BLA"):
+          if (use_on)
+            bg = COLOR::BLACK;
+          else
+            fg = COLOR::BLACK;
+          break;
+        case strhash("WHI"):
+          if (use_on)
+            bg = COLOR::WHITE;
+          else
+            fg = COLOR::WHITE;
+          break;
+      }
+
+      // skip to the space character
+      while ((*cp != ' ') && (*cp != 0)) ++cp;
+      // skip past the space character
+      while (*cp == ' ') ++cp;
+    }
+  };
+
   ANSIColor(ATTR a);
   ANSIColor(COLOR f);
   ANSIColor(COLOR f, ATTR a);
@@ -174,7 +292,7 @@ public:
    * @return COLOR
    */
   COLOR getBg() { return bg; };
-  void attr(ATTR a);
+  void setAttr(ATTR a);
 
   std::string output(void) const;
   std::string debug(void);
@@ -188,8 +306,7 @@ public:
  * This handles output to the caller, via ostream.
  */
 class Door : public std::ostream, private std::streambuf {
-
-private:
+ private:
   std::streamsize xsputn(const char *s, std::streamsize n) override;
   int overflow(int c) override;
   /** The name used for logfile */
@@ -220,7 +337,7 @@ private:
   /** Thread used to update time_left and time_used. */
   std::thread time_thread;
 
-public:
+ public:
   Door(std::string dname, int argc, char *argv[]);
   Door(Door &) = delete;
   virtual ~Door();
@@ -289,7 +406,7 @@ public:
  *
  */
 class ColorOutput {
-public:
+ public:
   ColorOutput();
   void reset(void);
 
@@ -320,7 +437,7 @@ class Render {
   /// Complete text to be rendered.
   std::string text;
 
-public:
+ public:
   Render(const std::string txt);
 
   /// Vector of ColorOutput object.
@@ -379,7 +496,7 @@ typedef std::function<std::string(void)> updateFunction;
  * @brief Clear the screen
  */
 class Clrscr {
-public:
+ public:
   Clrscr(void);
   friend std::ostream &operator<<(std::ostream &os, const Clrscr &clr);
 };
@@ -396,7 +513,7 @@ extern Clrscr cls;
  * @brief CR+LF
  */
 class NewLine {
-public:
+ public:
   NewLine(void);
   friend std::ostream &operator<<(std::ostream &os, const NewLine &nl);
 };
@@ -428,7 +545,7 @@ class Goto {
   /// Y-Position
   int y;
 
-public:
+ public:
   Goto(int xpos, int ypos);
   /**
    * Default Goto constructor copier
@@ -447,14 +564,14 @@ extern const char RestoreCursor[];
  * multilines? */
 
 class LineBase {
-public:
+ public:
   virtual ~LineBase() = default;
   virtual bool update(void) = 0;
   // friend std::ostream &operator<<(std::ostream &os, const LineBase &lb) = 0;
 };
 
 class BasicLine {
-protected:
+ protected:
   std::string text;
   bool hasColor;
   ANSIColor color;
@@ -463,7 +580,7 @@ protected:
   /// updateFunction to use when updating.
   updateFunction updater;
 
-public:
+ public:
   BasicLine(std::string txt);
   BasicLine(std::string txt, ANSIColor c);
   BasicLine(const BasicLine &rhs) = default;
@@ -480,10 +597,10 @@ public:
 };
 
 class MultiLine {
-protected:
+ protected:
   std::vector<std::shared_ptr<BasicLine>> lines;
 
-public:
+ public:
   MultiLine();
   void append(std::shared_ptr<BasicLine> bl);
 
@@ -500,7 +617,7 @@ public:
  * @brief Text and ANSIColor
  */
 class Line {
-protected:
+ protected:
   /// Text of the line
   std::string text;
 
@@ -525,7 +642,7 @@ protected:
    */
   // void makeWidth(int width);
 
-public:
+ public:
   Line(const std::string &txt, int width = 0);
   Line(const char *txt, int width = 0);
   Line(const std::string &txt, int width, ANSIColor c);
@@ -537,7 +654,7 @@ public:
   // ~Line();
 
   bool hasRender(void);
-  int length(void); //  const;
+  int length(void);  //  const;
   void fit(void);
   /**
    * @param padstring std::string &
@@ -590,7 +707,7 @@ enum class BarStyle { SOLID, HALF_STEP, GRADIENT, PERCENTAGE, PERCENT_SPACE };
 
 /**
  * BarColorRange
- * 
+ *
  * vector<door::BarColorRange> colorRange = {
  *     {2500, door::ANSIColor(door::COLOR::RED)},
  *     {5000, door::ANSIColor(door::COLOR::BROWN)},
@@ -598,7 +715,7 @@ enum class BarStyle { SOLID, HALF_STEP, GRADIENT, PERCENTAGE, PERCENT_SPACE };
  *     {9500, door::ANSIColor(door::COLOR::GREEN)},
  *     {10100, door::ANSIColor(door::COLOR::GREEN, door::ATTR::BOLD)}};
  * BarLine.setColorRange(colorRange);
- * 
+ *
  */
 struct BarColorRange {
   unsigned long percent;
@@ -606,7 +723,7 @@ struct BarColorRange {
 };
 
 class BarLine : public Line {
-protected:
+ protected:
   BarStyle barstyle;
   unsigned long current_percent;
   void init(void);
@@ -614,14 +731,14 @@ protected:
   int length;
   vector<BarColorRange> colorRange;
 
-public:
+ public:
   BarLine(int width);
   BarLine(int width, BarStyle style);
   BarLine(int width, BarStyle style, ANSIColor c);
-  
+
   void watch(float &percent);
   void watch(int &value, int &max);
-  
+
   void setStyle(BarStyle s);
   void set(int value, int max);
   void set(float percent);
@@ -630,7 +747,6 @@ public:
   // friend std::ostream &operator<<(std::ostream &os, const BarLine &b);
 };
 
-
 /**
  * The different Borders supported by Panel.
  *
@@ -651,10 +767,10 @@ enum class BorderStyle {
 };
 
 class Panel {
-protected:
+ protected:
   int x;
   int y;
-  int width; // or padding ?
+  int width;  // or padding ?
   BorderStyle border_style;
   ANSIColor border_color;
   /**
@@ -667,16 +783,16 @@ protected:
   bool hidden;
   // when you show panel, should it mark it as
   // redisplay everything??  maybe??
-  bool shown_once; // ?? maybe  shown_once_already ?
+  bool shown_once;  // ?? maybe  shown_once_already ?
   std::unique_ptr<Line> title;
   int offset;
 
-public:
+ public:
   Panel(int x, int y, int width);
   Panel(int width);
 
   // Panel(const Panel &);
-  Panel(Panel &) = delete; // default;
+  Panel(Panel &) = delete;  // default;
   Panel(Panel &&ref);
 
   void set(int x, int y);
@@ -738,7 +854,7 @@ Remaining LC text = c4
  */
 
 class Menu : public Panel {
-protected:
+ protected:
   unsigned int chosen;
   std::vector<char> options;
   renderFunction selectedRender;
@@ -748,7 +864,7 @@ protected:
   std::function<void(Door &d, std::string &)> unselectedColorizer;
   */
 
-public:
+ public:
   static renderFunction defaultSelectedRender;
   static renderFunction defaultUnselectedRender;
   /*
@@ -775,14 +891,14 @@ public:
 };
 
 class Screen {
-protected:
+ protected:
   // bool hidden;
   /**
    * @brief vector of panels.
    */
   std::vector<std::unique_ptr<Panel>> panels;
 
-public:
+ public:
   Screen(void);
   Screen(Screen &) = default;
   void addPanel(std::unique_ptr<Panel> p);
@@ -846,5 +962,5 @@ lightline - text, changes format/coloring if focus/nofocus is set?
 
  */
 
-} // namespace door
+}  // namespace door
 #endif

test-door.cpp

@@ -4,7 +4,7 @@
 namespace {
 
 class DoorTest : public ::testing::Test {
-protected:
+ protected:
   void SetUp() override {
     int argc = 5;
     char argv0[] = "./test";
@@ -25,7 +25,7 @@ protected:
     d = nullptr;
   }
 
-public:
+ public:
   door::Door *d;
 };
 
@@ -34,14 +34,32 @@ TEST_F(DoorTest, BasicColorOut1) {
   char BLUE_ON_YELLOW[] = "\x1b[34;43m";
   *d << BonY;
   EXPECT_STREQ(d->debug_buffer.c_str(), BLUE_ON_YELLOW);
+  *d << door::reset;  
   d->debug_buffer.clear();
 
+  door::ANSIColor BlueOnYellow("BLUE ON YELLOW");
+  *d << BlueOnYellow;
+  EXPECT_STREQ(d->debug_buffer.c_str(), BLUE_ON_YELLOW);
+  *d << door::reset;
+  d->debug_buffer.clear();
+  EXPECT_EQ(BlueOnYellow.fg, BonY.fg);
+  EXPECT_EQ(BlueOnYellow.bg, BonY.bg);
+
   door::ANSIColor YonB(door::COLOR::YELLOW, door::COLOR::BLUE,
                        door::ATTR::BOLD);
   char Y_ON_B[] = "\x1b[1;33;44m";
   *d << YonB;
+  EXPECT_STREQ(d->debug_buffer.c_str(), Y_ON_B);
+  *d << door::reset;
+  d->debug_buffer.clear();
 
+  door::ANSIColor YellowOnBlue("YELLOW ON BLUE");
+  *d << YellowOnBlue;
   EXPECT_STREQ(d->debug_buffer.c_str(), Y_ON_B);
+  *d << door::reset;  
+  d->debug_buffer.clear();
+  EXPECT_EQ(YellowOnBlue.fg, YonB.fg);
+  EXPECT_EQ(YellowOnBlue.bg, YonB.bg);
 
   *d << door::reset;
   d->debug_buffer.clear();
@@ -173,4 +191,4 @@ TEST_F(DoorTest, LineOutput) {
   d->debug_buffer.clear();
 }
 
-} // namespace
+}  // namespace