clang format apply

utils/common/genericparser.h

@@ -15,32 +15,29 @@
    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
    MA 02110-1301, USA. */
 
-
 #pragma once
 
 #include "conststring.h"
 
-
 namespace genericparser
 {
-
 using utils::ConstString;
 
-
 class Tokenizer
 {
-protected:
-  const char *mStr;
-  const char *mEnd;
-public:
-  explicit Tokenizer(const char *str, size_t length)
-   :mStr(str), mEnd(str + length)
-  { }
+ protected:
+  const char* mStr;
+  const char* mEnd;
+
+ public:
+  explicit Tokenizer(const char* str, size_t length) : mStr(str), mEnd(str + length)
+  {
+  }
   size_t length() const
   {
     return mEnd - mStr;
   }
-  const char *ptr() const
+  const char* ptr() const
   {
     return mStr;
   }
@@ -65,18 +62,20 @@ public:
   {
     if (!isSpace())
       return ConstString(nullptr, 0);
-    const char *start = mStr;
-    for ( ; isSpace() ; mStr++)
-    { }
+    const char* start = mStr;
+    for (; isSpace(); mStr++)
+    {
+    }
     return ConstString(start, mStr - start);
   }
   ConstString tokenDigits()
   {
     if (!isDigit())
       return ConstString(nullptr, 0);
-    const char *start = mStr;
-    for ( ; isDigit() ; mStr++)
-    { }
+    const char* start = mStr;
+    for (; isDigit(); mStr++)
+    {
+    }
     return ConstString(start, mStr - start);
   }
   ConstString tokenChar(char chr)
@@ -93,19 +92,19 @@ public:
   }
 };
 
-
-class Parser: public Tokenizer
+class Parser : public Tokenizer
 {
-protected:
+ protected:
   bool mSyntaxError;
-public:
-  explicit Parser(const char *str, size_t length)
-   :Tokenizer(str, length), mSyntaxError(false)
-  { }
-  explicit Parser(const std::string & str)
-   :Parser(str.data(), str.length())
-  { }
-  Parser & skipLeadingSpaces()
+
+ public:
+  explicit Parser(const char* str, size_t length) : Tokenizer(str, length), mSyntaxError(false)
+  {
+  }
+  explicit Parser(const std::string& str) : Parser(str.data(), str.length())
+  {
+  }
+  Parser& skipLeadingSpaces()
   {
     tokenSpaces();
     return *this;
@@ -119,7 +118,7 @@ public:
     mSyntaxError = true;
     return false;
   }
-  const char *tokStart() const
+  const char* tokStart() const
   {
     return mStr;
   }
@@ -128,16 +127,14 @@ public:
     return ConstString(mStr, 0);
   }
 
-
   // A helper class template to set the parser syntax error
   // if A returned isNull() after parsing.
 
-  template<class A>
-  class SetSyntaxErrorOnNull :public A
+  template <class A>
+  class SetSyntaxErrorOnNull : public A
   {
-  public:
-    SetSyntaxErrorOnNull(Parser *p)
-      :A(p)
+   public:
+    SetSyntaxErrorOnNull(Parser* p) : A(p)
     {
       if (A::isNull())
         p->setSyntaxError();
@@ -146,15 +143,14 @@ public:
 
   // A helper class template for a rule in the form:        <res> := [ <a> ]
 
-  template<class A>
-  class Opt: public A
+  template <class A>
+  class Opt : public A
   {
-  public:
-    explicit Opt(const A &rhs)
-     :A(rhs)
-    { }
-    explicit Opt(Parser *p)
-     :A(p)
+   public:
+    explicit Opt(const A& rhs) : A(rhs)
+    {
+    }
+    explicit Opt(Parser* p) : A(p)
     {
       if (A::isNull() && !p->syntaxError())
         A::operator=(A::empty(p));
@@ -169,7 +165,6 @@ public:
   // M - mandatory - this part is required during parse time
   // O - optional  - this part is optional during parse time
 
-
   // A helper class template for a rule in the form:        <res> := <a> <b>
   // i.e. both parts are mandatory at parse time
   // The value of <a> is not important, and is created
@@ -178,53 +173,52 @@ public:
   // Example:
   //    <period> <unsigned integer>
 
-  template<class A, class B>
-  class UD2MM: public B
+  template <class A, class B>
+  class UD2MM : public B
   {
-  public:
-    explicit UD2MM(Parser *p)
-     :B(A(p).isNull() ? B() :SetSyntaxErrorOnNull<B>(p))
-    { }
-    explicit UD2MM(const B & b)
-     :B(b)
-    { }
-    explicit UD2MM()
-     :B()
-    { }
-    bool isNull() const { return B::isNull(); }
+   public:
+    explicit UD2MM(Parser* p) : B(A(p).isNull() ? B() : SetSyntaxErrorOnNull<B>(p))
+    {
+    }
+    explicit UD2MM(const B& b) : B(b)
+    {
+    }
+    explicit UD2MM() : B()
+    {
+    }
+    bool isNull() const
+    {
+      return B::isNull();
+    }
   };
 
   // A helper class template for a rule in the form:       <res> := <a> <b>
   // i.e. both parts are mandatory at parse time.
-  template<class A, class B>
-  class DD2MM: public A,
-               public B
+  template <class A, class B>
+  class DD2MM : public A, public B
   {
-  public:
+   public:
     // Sets syntax error if <a> was not followed by <b>
-    explicit DD2MM(Parser *p)
-     :A(p),
-      B(A::isNull() ? B() : SetSyntaxErrorOnNull<B>(p))
-    { }
-    explicit DD2MM(const A & a, const B &b)
-     :A(b), B(b)
-    { }
+    explicit DD2MM(Parser* p) : A(p), B(A::isNull() ? B() : SetSyntaxErrorOnNull<B>(p))
+    {
+    }
+    explicit DD2MM(const A& a, const B& b) : A(b), B(b)
+    {
+    }
   };
 
   // A helper class template for a rule in the form:       <res> := <a> [ <b> ]
   // i.e. <a> is mandatory, <b> is optional at parse time.
-  template<class A, class B>
-  class DD2MO: public A,
-               public B
+  template <class A, class B>
+  class DD2MO : public A, public B
   {
-  public:
-    explicit DD2MO(Parser *p)
-     :A(p),
-      B(A::isNull() ? B() : B(p))
-    { }
-    explicit DD2MO(const A &a, const B &b)
-     :A(a), B(b)
-    { }
+   public:
+    explicit DD2MO(Parser* p) : A(p), B(A::isNull() ? B() : B(p))
+    {
+    }
+    explicit DD2MO(const A& a, const B& b) : A(a), B(b)
+    {
+    }
   };
 
   // A helper class template for a rule in the form:       <res> := <a> [ <b> ]
@@ -232,73 +226,68 @@ public:
   // The value of <a> is not important and is not included
   // into the target class, e.g.
   // <period> [ <unsigned integer> ]
-  template<class A, class B>
-  class UD2MO: public B
+  template <class A, class B>
+  class UD2MO : public B
   {
-  public:
-    explicit UD2MO(Parser *p)
-     :B(A(p).isNull() ? B() : B(p))
-    { }
-    explicit UD2MO(const B &b)
-     :B(b)
-    { }
-    explicit UD2MO()
-     :B()
-    { }
+   public:
+    explicit UD2MO(Parser* p) : B(A(p).isNull() ? B() : B(p))
+    {
+    }
+    explicit UD2MO(const B& b) : B(b)
+    {
+    }
+    explicit UD2MO() : B()
+    {
+    }
   };
 
-
   // A helper class template for a rule in the form:       <res> := <a> [ <b> ]
   // i.e. <a> is mandatory, <b> is optional at parse time.
   // The result class derives from "A".
   // The result class puts "B" as a member.
-  template<class A, class B>
-  class DM2MO: public A
+  template <class A, class B>
+  class DM2MO : public A
   {
-  protected:
+   protected:
     B mB;
-  public:
-    explicit DM2MO(Parser *p)
-     :A(p),
-      mB(A::isNull() ? B() : B(p))
-    { }
-  };
 
+   public:
+    explicit DM2MO(Parser* p) : A(p), mB(A::isNull() ? B() : B(p))
+    {
+    }
+  };
 
   // A helper class template for a rule in the form:       <res> := [ <a> ] <b>
   // i.e. <a> is optional, <b> is mandatory at parse time.
-  template<class A,class B>
-  class DD2OM: public Opt<A>,
-               public B
+  template <class A, class B>
+  class DD2OM : public Opt<A>, public B
   {
-  public:
-    explicit DD2OM(Parser *p)
-     :Opt<A>(p), B(p)
+   public:
+    explicit DD2OM(Parser* p) : Opt<A>(p), B(p)
     {
       if (B::isNull())
         p->setSyntaxError();
     }
-    explicit DD2OM()
-     :Opt<A>(A())
-    { }
-    explicit DD2OM(const A & a, const B & b)
-     :Opt<A>(a), B(b)
-    { }
+    explicit DD2OM() : Opt<A>(A())
+    {
+    }
+    explicit DD2OM(const A& a, const B& b) : Opt<A>(a), B(b)
+    {
+    }
   };
 
   // A helper class template for a rule in the form:       <res> := a | b
-  template<class Container, class A, class B>
-  class Choice2: public Container
+  template <class Container, class A, class B>
+  class Choice2 : public Container
   {
-  public:
-    explicit Choice2(const A & a)
-     :Container(a)
-    { }
-    explicit Choice2(const B & b)
-     :Container(b)
-    { }
-    explicit Choice2(Parser *p)
-     :Container(A(p))
+   public:
+    explicit Choice2(const A& a) : Container(a)
+    {
+    }
+    explicit Choice2(const B& b) : Container(b)
+    {
+    }
+    explicit Choice2(Parser* p) : Container(A(p))
     {
       if (Container::isNull() && !p->syntaxError())
         *this = Choice2(B(p));
@@ -306,6 +295,4 @@ public:
   };
 };
 
-
-} // namespace genericparser
-
+}  // namespace genericparser