symbol.hpp

Go to the documentation of this file.

/*
  SYMBOL.hpp  -  symbolic constant datatype
 
   Copyright (C)
     2008,2017        Hermann Vosseler <Ichthyostega@web.de>
 
 **Lumiera** is free software; you can redistribute it and/or modify it
 under the terms of the GNU General Public License as published by the
 Free Software Foundation; either version 2 of the License, or (at your
 option) any later version. See the file COPYING for further details.
 
*/
 
#ifndef LIB_SYMBOL_H
#define LIB_SYMBOL_H
 
#include "lib/hash-standard.hpp"
 
#include <string>
#include <cstring>
 
using CStr = const char*;
 
inline CStr
cStr (std::string const& rendered)
{
  return rendered.c_str();
}
 
 
namespace lib {
  
  class Literal
    {
      CStr str_;
      
    public:
      constexpr Literal()  noexcept;
      
      constexpr Literal (CStr literal) noexcept
        : str_(literal)
        { }
      
      constexpr Literal (Literal const&)            noexcept = default;
      constexpr Literal& operator= (Literal const&) noexcept = default;
      
      constexpr operator CStr()  const { return str_; }
      constexpr const char* c()  const { return str_; }
      
      constexpr bool
      empty()  const
        {
          return not str_ or 0 == std::strlen(str_);
        }
      
      constexpr bool operator== (CStr cString)  const;
      constexpr size_t length()  const;
 
    protected:
      Literal& operator= (CStr newStr) noexcept
        {
          str_ = newStr;
          return *this;
        }
    };
  
  
  class Symbol
    : public Literal
    {
    public:
      static Symbol ANY;
      static Symbol EMPTY;
      static Symbol BOTTOM;
      static Symbol FAILURE;
      
      Symbol (CStr lit =NULL)
        : Symbol{std::string(lit? lit : BOTTOM.c())}
        { }
      
      explicit
      Symbol (std::string&& definition);
      
      Symbol (std::string const& str)
        : Symbol{std::string(str)}
        { }
      
      Symbol (Literal const& base, std::string const& ext)
        : Symbol{std::string(base)+"."+ext}
        { }
      
      Symbol (Literal const& base, CStr ext)
        : Symbol{base, std::string(ext)}
        { }
      
      Symbol (Symbol const&) = default;
      Symbol (Symbol &&)     = default;
      
      Symbol& operator= (Symbol const&) = default;
      Symbol& operator= (Symbol &&)     = default;
      
      explicit operator bool()  const { return not empty(); }
      bool empty()              const { return *this == BOTTOM.c() or *this == EMPTY.c(); }
    };
  
  
  constexpr inline Literal::Literal() noexcept : str_(Symbol::EMPTY) { }
 
  namespace{
    constexpr inline int
    strNcmp (CStr a, CStr b, size_t len)
    {
      return a == b ? 0 : std::strncmp (a?a:"", b?b:"", len);
    }
  }
  
  extern const size_t STRING_MAX_RELEVANT;
  
  constexpr inline bool
  Literal::operator== (CStr charPtr)  const
  {
    return 0 == strNcmp (this->str_, charPtr, STRING_MAX_RELEVANT);
  }
  
  constexpr inline size_t
  Literal::length()  const
  {
    return std::strlen(c());
  }
  
  
  
  
  
  /* ===== to be picked up by ADL ===== */
  
  HashVal hash_value (Literal);
  HashVal hash_value (Symbol);
  
 
  /* === equality comparisons === */
 
  constexpr inline bool operator== (Literal const& s1, Literal const& s2) { return s1.operator== (s2.c()); }
  constexpr inline bool operator== (Symbol const& s1,  Symbol const& s2)  { return s1.c() == s2.c(); } 
  
  /* === mixed comparisons === */
  
  constexpr inline bool operator== (CStr    s1,            Literal s2)    { return s2.operator== (s1); }
  constexpr inline bool operator== (Symbol  s1,               CStr s2)    { return s1.operator== (s2); }
  constexpr inline bool operator== (Literal s1,             Symbol s2)    { return s1.operator== (s2.c()); }
  constexpr inline bool operator== (Literal s1, std::string const& s2)    { return s1.operator== (s2.c_str()); }
  constexpr inline bool operator== (Symbol  s1, std::string const& s2)    { return s1.operator== (s2.c_str()); }
  
  
  
  inline std::string
  operator+ (std::string str, Literal const& sym)
  {
    CStr symP (sym);
    return str + symP;
  }
  
  inline std::string
  operator+ (Literal const& sym, std::string str)
  {
    CStr symP (sym);
    return symP + str;
  }
  
  
  
} // namespace lib
#endif /*LIB_SYMBOL_H*/