clean

flagarde · flagarde · commit f4fc26eff4d3 · 2024-11-02T03:58:42.000+08:00
diff --git a/.gitignore b/.gitignore
@@ -1,2 +1,3 @@
 build/
-.vscode/
+.vscode/
+.build/
diff --git a/apps/parser.cpp b/apps/parser.cpp
@@ -128,21 +128,21 @@ int main(int argc, char* argv[])
 
   if(parser.hasUnknown())
   {
-    for(std::map<std::string, Terminfo::Capability::Type>::const_iterator it = parser.getUnknown().cbegin(); it != parser.getUnknown().cend(); ++it)
+    for(std::map<std::string, Terminfo::Parser::Type>::const_iterator it = parser.getUnknown().cbegin(); it != parser.getUnknown().cend(); ++it)
     {
       switch(it->second)
       {
-        case Terminfo::Capability::Type::boolean:
+        case Terminfo::Parser::Type::Boolean:
         {
           std::cout << "boolean capability " << it->first << " unknown !" << std::endl;
           break;
         }
-        case Terminfo::Capability::Type::integer:
+        case Terminfo::Parser::Type::Integer:
         {
           std::cout << "integer capability " << it->first << " unknown !" << std::endl;
           break;
         }
-        case Terminfo::Capability::Type::string:
+        case Terminfo::Parser::Type::String:
         {
           std::cout << "string capability " << it->first << " unknown !" << std::endl;
           break;
diff --git a/include/cpp-terminfo/Capabilities.hpp b/include/cpp-terminfo/Capabilities.hpp
@@ -21,33 +21,27 @@ namespace Terminfo
 class Capabilities
 {
 private:
-  static const constexpr std::size_t                    m_booleans_size{37};
-  static const std::array<Capability, m_booleans_size>  m_booleans;
-  static const constexpr std::size_t                    m_intergers_size{33};
-  static const std::array<Capability, m_intergers_size> m_integers;
-  static const constexpr std::size_t                    m_strings_size{405};
-  static const std::array<Capability, m_strings_size>   m_strings;
+  static const constexpr std::size_t                           m_booleans_size{37};
+  static const std::array<BooleanCapability, m_booleans_size>  m_booleans;
+  static const constexpr std::size_t                           m_intergers_size{33};
+  static const std::array<IntegerCapability, m_intergers_size> m_integers;
+  static const constexpr std::size_t                           m_strings_size{405};
+  static const std::array<StringCapability, m_strings_size>    m_strings;
 
 public:
-  using boolean_const_iterator = std::array<Capability, m_booleans_size>::const_iterator;
-  using integer_const_iterator = std::array<Capability, m_intergers_size>::const_iterator;
-  using string_const_iterator  = std::array<Capability, m_strings_size>::const_iterator;
-  Boolean                 getBoolean(const std::string& str);
-  Integer                 getInteger(const std::string& str);
-  String                  getString(const std::string& str);
-  Capability              get(const Boolean& boolean) const { return m_booleans[static_cast<std::size_t>(boolean)]; }
-  Capability              get(const Integer& integer) const { return m_integers[static_cast<std::size_t>(integer)]; }
-  Capability              get(const String& string) const { return m_strings[static_cast<std::size_t>(string)]; }
-  inline bool             know(const std::string& name) const noexcept { return std::find(m_booleans.begin(), m_booleans.end(), name) != m_booleans.end() || std::find(m_integers.begin(), m_integers.end(), name) != m_integers.end() || std::find(m_strings.begin(), m_strings.end(), name) != m_strings.end(); }
-  inline Capability::Type type(const std::string& name)
-  {
-    if(std::find(m_booleans.begin(), m_booleans.end(), name) != m_booleans.end()) return Capability::Type::boolean;
-    else if(std::find(m_integers.begin(), m_integers.end(), name) != m_integers.end())
-      return Capability::Type::integer;
-    else if(std::find(m_strings.begin(), m_strings.end(), name) != m_strings.end())
-      return Capability::Type::string;
-    else
-      return Capability::Type::not_yet;
-  }
+  using boolean_const_iterator = std::array<BooleanCapability, m_booleans_size>::const_iterator;
+  using integer_const_iterator = std::array<IntegerCapability, m_intergers_size>::const_iterator;
+  using string_const_iterator  = std::array<StringCapability, m_strings_size>::const_iterator;
+  bool              isBoolean(const std::string& name) const noexcept { return std::find(m_booleans.begin(), m_booleans.end(), name) != m_booleans.end(); }
+  bool              isInteger(const std::string& name) const noexcept { return std::find(m_integers.begin(), m_integers.end(), name) != m_integers.end(); }
+  bool              isString(const std::string& name) const noexcept { return std::find(m_strings.begin(), m_strings.end(), name) != m_strings.end(); }
+  Boolean           getBoolean(const std::string& str);
+  Integer           getInteger(const std::string& str);
+  String            getString(const std::string& str);
+  BooleanCapability get(const Boolean& boolean) const { return m_booleans[static_cast<std::size_t>(boolean)]; }
+  IntegerCapability get(const Integer& integer) const { return m_integers[static_cast<std::size_t>(integer)]; }
+  StringCapability  get(const String& string) const { return m_strings[static_cast<std::size_t>(string)]; }
+  inline bool       know(const std::string& name) const noexcept { return isBoolean(name) || isInteger(name) || isString(name); }
 };
+
 }  // namespace Terminfo
diff --git a/include/cpp-terminfo/Capability.hpp b/include/cpp-terminfo/Capability.hpp
@@ -12,40 +12,29 @@
 #include "cpp-terminfo/Integer.hpp"
 #include "cpp-terminfo/String.hpp"
 
-#include <cstdint>
 #include <string>
 
 namespace Terminfo
 {
-class Capability
+
+template<typename type_id> class Capability
 {
 public:
-  enum class Type : std::uint8_t
-  {
-    boolean,
-    integer,
-    string,
-    not_yet  // ##FIXME
-  };
   Capability() = default;
-  inline explicit Capability(const Boolean& val, const std::string& name, const std::string& desc) : m_name(name), m_description(desc), m_type(Type::boolean), m_value(static_cast<std::uint8_t>(val)) {};
-  inline explicit Capability(const Integer& val, const std::string& name, const std::string& desc) : m_name(name), m_description(desc), m_type(Type::integer), m_value(static_cast<std::uint8_t>(val)) {};
-  inline explicit Capability(const String& val, const std::string& name, const std::string& desc) : m_name(name), m_description(desc), m_type(Type::string), m_value(static_cast<std::uint16_t>(val)) {};
-  inline std::string   description() const noexcept { return m_description; }
-  inline std::string   name() const noexcept { return m_name; }
-  inline std::uint16_t value() const noexcept { return m_value; }
-  inline Type          type() const noexcept { return m_type; }
-  inline bool          operator==(const std::string& str) const noexcept
-  {
-    if(m_name == str) return true;
-    else
-      return false;
-  }
+  inline explicit Capability(const type_id& id, const std::string& name, const std::string& description) : m_id(id), m_name(name), m_description(description) {};
+  inline std::string description() const noexcept { return m_description; }
+  inline std::string name() const noexcept { return m_name; }
+  inline type_id     id() const noexcept { return m_id; }
+  inline bool        operator==(const std::string& str) const noexcept { return m_name == str; }
 
 private:
-  std::string   m_name;
-  std::string   m_description;
-  Type          m_type;
-  std::uint16_t m_value;
+  std::string m_name;
+  std::string m_description;
+  type_id     m_id;
 };
+
+using BooleanCapability = Capability<Boolean>;
+using IntegerCapability = Capability<Integer>;
+using StringCapability  = Capability<String>;
+
 }  // namespace Terminfo
diff --git a/include/cpp-terminfo/Parser.hpp b/include/cpp-terminfo/Parser.hpp
@@ -22,12 +22,18 @@ namespace Terminfo
 class Parser
 {
 public:
+  enum class Type : std::uint8_t
+  {
+    Boolean,
+    Integer,
+    String,
+  };
   Parser() { m_infos.reserve(2 << 10); }  // 1833 but use 2^x
   Parser(const std::string& file) : m_file(file) {};
-  void                                           parse();
-  std::vector<Terminfo>                          getTerminfos() { return m_infos; }
-  bool                                           hasUnknown() { return !m_unknown.empty(); }
-  const std::map<std::string, Capability::Type>& getUnknown() const noexcept { return m_unknown; };
+  void                               parse();
+  std::vector<Terminfo>              getTerminfos() { return m_infos; }
+  bool                               hasUnknown() { return !m_unknown.empty(); }
+  const std::map<std::string, Type>& getUnknown() const noexcept { return m_unknown; };
 
 private:
   void parseType(const std::string& line);
@@ -45,6 +51,6 @@ class Parser
   std::map<std::string, std::vector<std::string>> m_need_reparse;
   std::map<std::string, std::vector<std::string>> m_need_delete;
   std::vector<Terminfo>                           m_infos;
-  std::map<std::string, Capability::Type>         m_unknown;
+  std::map<std::string, Type>                     m_unknown;
 };
 }  // namespace Terminfo
diff --git a/include/cpp-terminfo/Type.hpp b/include/cpp-terminfo/Type.hpp
@@ -29,12 +29,7 @@ class Type
     ret.erase(ret.begin());
     return ret;
   }
-  bool isAlias(const std::string& str) const noexcept
-  {
-    if(std::find(m_aliases.begin(), m_aliases.end(), str) != m_aliases.end()) return true;
-    else
-      return false;
-  }
+  bool isAlias(const std::string& str) const noexcept { return std::find(m_aliases.begin(), m_aliases.end(), str) != m_aliases.end(); }
 
 private:
   std::string              m_descritpion;
diff --git a/src/Capabilities.cpp b/src/Capabilities.cpp
@@ -9,11 +9,13 @@
 
 #include "cpp-terminfo/Capabilities.hpp"
 
+#include "cpp-terminfo/Boolean.hpp"
+
 #include <algorithm>
 #include <iostream>
 #include <stdexcept>
 
-const std::array<Terminfo::Capability, Terminfo::Capabilities::m_booleans_size> Terminfo::Capabilities::m_booleans{
+const std::array<Terminfo::BooleanCapability, Terminfo::Capabilities::m_booleans_size> Terminfo::Capabilities::m_booleans{
   // Booleans
   Capability{Boolean::auto_left_margin, "bw", "cub1 wraps from column 0 to last column"},
   Capability{Boolean::auto_right_margin, "am", "terminal has automatic margins"},
@@ -54,7 +56,7 @@ const std::array<Terminfo::Capability, Terminfo::Capabilities::m_booleans_size>
   Capability{Boolean::lpi_changes_res, "lpix", "changing line pitch changes resolution"},
 };
 
-const std::array<Terminfo::Capability, Terminfo::Capabilities::m_intergers_size> Terminfo::Capabilities::m_integers{
+const std::array<Terminfo::IntegerCapability, Terminfo::Capabilities::m_intergers_size> Terminfo::Capabilities::m_integers{
   // Integers
   Capability{Integer::columns, "cols", "number of columns in a line"},
   Capability{Integer::init_tabs, "it", "tabs initially every # spaces"},
@@ -91,7 +93,7 @@ const std::array<Terminfo::Capability, Terminfo::Capabilities::m_intergers_size>
   Capability{Integer::bit_image_type, "bitype", "type of bit-image device"},
 };
 
-const std::array<Terminfo::Capability, Terminfo::Capabilities::m_strings_size> Terminfo::Capabilities::m_strings = {
+const std::array<Terminfo::StringCapability, Terminfo::Capabilities::m_strings_size> Terminfo::Capabilities::m_strings = {
   // Strings
   Capability{String::back_tab, "cbt", "back tab (P)"},
   Capability{String::bell, "bel", "audible signal (bell) (P)"},
@@ -504,20 +506,20 @@ const std::array<Terminfo::Capability, Terminfo::Capabilities::m_strings_size> T
 Terminfo::Boolean Terminfo::Capabilities::getBoolean(const std::string& str)
 {
   const boolean_const_iterator found = std::find(m_booleans.begin(), m_booleans.end(), str);
-  if(found != m_booleans.end()) return static_cast<Terminfo::Boolean>(found->value());
+  if(found != m_booleans.end()) return static_cast<Terminfo::Boolean>(found->id());
   throw std::out_of_range(str);
 }
 
 Terminfo::Integer Terminfo::Capabilities::getInteger(const std::string& str)
 {
   const integer_const_iterator found = std::find(m_integers.begin(), m_integers.end(), str);
-  if(std::find(m_integers.begin(), m_integers.end(), str) != m_integers.end()) return static_cast<Terminfo::Integer>(found->value());
+  if(std::find(m_integers.begin(), m_integers.end(), str) != m_integers.end()) return static_cast<Terminfo::Integer>(found->id());
   throw std::out_of_range(str);
 }
 
 Terminfo::String Terminfo::Capabilities::getString(const std::string& str)
 {
   const string_const_iterator found = std::find(m_strings.begin(), m_strings.end(), str);
-  if(found != m_strings.end()) return static_cast<Terminfo::String>(found->value());
+  if(found != m_strings.end()) return static_cast<Terminfo::String>(found->id());
   throw std::out_of_range(str);
 }
diff --git a/src/Parser.cpp b/src/Parser.cpp
@@ -136,7 +136,7 @@ void Terminfo::Parser::parseCapability(const std::string& line)
         m_infos[m_infos.size() - 1].addString(string, value);
       }
       else
-        m_unknown[key] = Capability::Type::string;
+        m_unknown[key] = Type::String;
       return;
     }
     pos = line.find('#');
@@ -150,7 +150,7 @@ void Terminfo::Parser::parseCapability(const std::string& line)
         m_infos[m_infos.size() - 1].addInteger(integer, stoi(value));
       }
       else
-        m_unknown[key] = Capability::Type::integer;
+        m_unknown[key] = Type::Integer;
       return;
     }
     pos = line.find('@');  // is a removed capability
@@ -162,7 +162,7 @@ void Terminfo::Parser::parseCapability(const std::string& line)
     // is a boolean
     if(capabilities.know(line)) m_infos[m_infos.size() - 1].addBoolean(capabilities.getBoolean(line));
     else
-      m_unknown[line] = Capability::Type::string;
+      m_unknown[line] = Type::Boolean;
   }
   catch(const std::out_of_range& exception)
   {
@@ -198,25 +198,11 @@ void Terminfo::Parser::resolveDeletes()
     {
       for(std::size_t j = 0; j != find->second.size(); ++j)
       {
-        switch(capabilities.type(find->second[j]))
-        {
-          case Capability::Type::boolean:
-          {
-            m_infos[i].remove(capabilities.getBoolean(find->second[j]));
-            break;
-          }
-          case Capability::Type::integer:
-          {
-            m_infos[i].remove(capabilities.getInteger(find->second[j]));
-            break;
-          }
-          case Capability::Type::string:
-          {
-            m_infos[i].remove(capabilities.getString(find->second[j]));
-            break;
-          }
-          default: break;
-        }
+        if(capabilities.isBoolean(find->second[j])) m_infos[i].remove(capabilities.getBoolean(find->second[j]));
+        else if(capabilities.isInteger(find->second[j]))
+          m_infos[i].remove(capabilities.getInteger(find->second[j]));
+        else
+          m_infos[i].remove(capabilities.getString(find->second[j]));
       }
     }
   }

Original file line number	Diff line number	Diff line change
`@@ -128,21 +128,21 @@ int main(int argc, char* argv[])`
`128`	`128`
`129`	`129`	`if(parser.hasUnknown())`
`130`	`130`	`{`
`131`		`- for(std::map<std::string, Terminfo::Capability::Type>::const_iterator it = parser.getUnknown().cbegin(); it != parser.getUnknown().cend(); ++it)`
	`131`	`+ for(std::map<std::string, Terminfo::Parser::Type>::const_iterator it = parser.getUnknown().cbegin(); it != parser.getUnknown().cend(); ++it)`
`132`	`132`	`{`
`133`	`133`	`switch(it->second)`
`134`	`134`	`{`
`135`		`- case Terminfo::Capability::Type::boolean:`
	`135`	`+ case Terminfo::Parser::Type::Boolean:`
`136`	`136`	`{`
`137`	`137`	`std::cout << "boolean capability " << it->first << " unknown !" << std::endl;`
`138`	`138`	`break;`
`139`	`139`	`}`
`140`		`- case Terminfo::Capability::Type::integer:`
	`140`	`+ case Terminfo::Parser::Type::Integer:`
`141`	`141`	`{`
`142`	`142`	`std::cout << "integer capability " << it->first << " unknown !" << std::endl;`
`143`	`143`	`break;`
`144`	`144`	`}`
`145`		`- case Terminfo::Capability::Type::string:`
	`145`	`+ case Terminfo::Parser::Type::String:`
`146`	`146`	`{`
`147`	`147`	`std::cout << "string capability " << it->first << " unknown !" << std::endl;`
`148`	`148`	`break;`
Original file line number	Diff line number	Diff line change
`@@ -136,7 +136,7 @@ void Terminfo::Parser::parseCapability(const std::string& line)`
`136`	`136`	`m_infos[m_infos.size() - 1].addString(string, value);`
`137`	`137`	`}`
`138`	`138`	`else`
`139`		`- m_unknown[key] = Capability::Type::string;`
	`139`	`+ m_unknown[key] = Type::String;`
`140`	`140`	`return;`
`141`	`141`	`}`
`142`	`142`	`pos = line.find('#');`
`@@ -150,7 +150,7 @@ void Terminfo::Parser::parseCapability(const std::string& line)`
`150`	`150`	`m_infos[m_infos.size() - 1].addInteger(integer, stoi(value));`
`151`	`151`	`}`
`152`	`152`	`else`
`153`		`- m_unknown[key] = Capability::Type::integer;`
	`153`	`+ m_unknown[key] = Type::Integer;`
`154`	`154`	`return;`
`155`	`155`	`}`
`156`	`156`	`pos = line.find('@'); // is a removed capability`
`@@ -162,7 +162,7 @@ void Terminfo::Parser::parseCapability(const std::string& line)`
`162`	`162`	`// is a boolean`
`163`	`163`	`if(capabilities.know(line)) m_infos[m_infos.size() - 1].addBoolean(capabilities.getBoolean(line));`
`164`	`164`	`else`
`165`		`- m_unknown[line] = Capability::Type::string;`
	`165`	`+ m_unknown[line] = Type::Boolean;`
`166`	`166`	`}`
`167`	`167`	`catch(const std::out_of_range& exception)`
`168`	`168`	`{`
`@@ -198,25 +198,11 @@ void Terminfo::Parser::resolveDeletes()`
`198`	`198`	`{`
`199`	`199`	`for(std::size_t j = 0; j != find->second.size(); ++j)`
`200`	`200`	`{`
`201`		`- switch(capabilities.type(find->second[j]))`
`202`		`- {`
`203`		`- case Capability::Type::boolean:`
`204`		`- {`
`205`		`- m_infos[i].remove(capabilities.getBoolean(find->second[j]));`
`206`		`- break;`
`207`		`- }`
`208`		`- case Capability::Type::integer:`
`209`		`- {`
`210`		`- m_infos[i].remove(capabilities.getInteger(find->second[j]));`
`211`		`- break;`
`212`		`- }`
`213`		`- case Capability::Type::string:`
`214`		`- {`
`215`		`- m_infos[i].remove(capabilities.getString(find->second[j]));`
`216`		`- break;`
`217`		`- }`
`218`		`- default: break;`
`219`		`- }`
	`201`	`+ if(capabilities.isBoolean(find->second[j])) m_infos[i].remove(capabilities.getBoolean(find->second[j]));`
	`202`	`+ else if(capabilities.isInteger(find->second[j]))`
	`203`	`+ m_infos[i].remove(capabilities.getInteger(find->second[j]));`
	`204`	`+ else`
	`205`	`+ m_infos[i].remove(capabilities.getString(find->second[j]));`
`220`	`206`	`}`
`221`	`207`	`}`
`222`	`208`	`}`