util.hpp

Go to the documentation of this file.

/*
  UTIL.hpp  -  collection of small helper functions used "everywhere"

   Copyright (C)
     2008,            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_UTIL_H
#define LIB_UTIL_H

#include "include/limits.hpp"
#include "lib/hash-standard.hpp"

#include <string>

namespace std {// forward declarations to avoid pervasive includes
  
  template<typename T>
  class allocator;
  template<typename K, typename CMP, class ALLO>
  class set;
  
  template<typename IT, typename V>
  IT find (IT, IT, V const&);
  template<typename IT, typename V>
  IT remove (IT, IT, V const&);
}


const char* cStr (std::string  const&);



namespace util {
  
  using std::string;
  using CStr = const char*;
  
  
  template <class NUM>
  inline int constexpr
  sgn (NUM n)
  {
    return (n==0)? 0 :((n<0)? -1:+1 );
  }
  
  template <class N1, class N2>
  inline N1 constexpr
  min (N1 n1, N2 n2)
  {
    return n2 < n1? N1(n2) : n1;
  }
  
  template <class N1, class N2>
  inline N1 constexpr
  max (N1 n1, N2 n2)
  {
    return n1 < n2? N1(n2) : n1;
  }
  
  template <typename NUM>
  inline NUM constexpr
  noneg (NUM val)
  {
    return (0<val? val : 0);
  }
  
  template <typename NUM, typename NB>
  inline NUM constexpr
  limited (NB lowerBound, NUM val, NB upperBound)
  {
    return min ( max (val, lowerBound)
               , upperBound);
  }
  
  template <typename NUM, typename NB>
  inline bool constexpr
  isLimited (NB lowerBound, NUM val, NB upperBound)
  {
    return lowerBound <= val
       and val <= upperBound;
  }
  
  template <typename UN, typename N2>
  inline UN constexpr
  positiveDiff (N2 newVal, UN refVal)
  {
    return UN(newVal) > refVal? UN(newVal) - refVal
                              : UN(0);
  }
  
  inline uint
  uNum (CStr charPtr)
  {
    if (!charPtr) return 0;
    int parsedNumber (std::atoi (charPtr));
    return limited (0, parsedNumber, LUMIERA_MAX_ORDINAL_NUMBER);
  }
  
  inline int
  sNum (CStr charPtr)
  {
    if (!charPtr) return 0;
    int parsedNumber (std::atoi (charPtr));
    return limited (-LUMIERA_MAX_ORDINAL_NUMBER, parsedNumber, LUMIERA_MAX_ORDINAL_NUMBER);
  }
  
  template<class OBJ>
  inline uint
  uNum (OBJ const& spec)
  {
    return uNum (cStr(spec));
  }
  
  template<class OBJ>
  inline int
  sNum (OBJ const& spec)
  {
    return sNum (cStr(spec));
  }
  
  
  
  /*  ======== generic empty check =========  */
  
  template <class CONT>
  inline bool
  isnil (const CONT& container)
  {
    return container.empty();
  }
  
  template <class CONT>
  inline bool
  isnil (const CONT* pContainer)
  {
    return !pContainer or pContainer->empty();
  }
  
  template <class CONT>
  inline bool
  isnil (CONT* pContainer)
  {
    return !pContainer or pContainer->empty();
  }
  
  inline bool
  isnil (CStr charPtr)
  {
    return !charPtr or !(*charPtr);
  }
  
  
  
  /*  ======== string and containment =========  */
  
  inline bool
  startsWith (string const& str, string const& prefix)
  {
    return 0 == str.rfind (prefix, 0);
  }
  
  inline bool
  startsWith (string const& str, CStr prefix)
  {
    return 0 == str.rfind (prefix, 0);
  }
  
  inline bool
  endsWith (string const& str, string const& suffix)
  {
    size_t l = suffix.length();
    if (l > str.length()) return false;
    size_t pos = str.length() - l;
    return pos == str.find (suffix, pos);
  }
  
  inline bool
  endsWith (string const& str, CStr suffix)
  {
    return endsWith (str, string(suffix));
  }
  
  inline void
  removePrefix (string& str, string const& prefix)
  {
    if (not startsWith (str,prefix)) return;
    str = str.substr (prefix.length());
  }
  
  inline void
  removeSuffix (string& str, string const& suffix)
  {
    if (not endsWith (str,suffix)) return;
    str.resize(str.length() - suffix.length());
  }
  
  
  template <typename MAP>
  inline bool
  contains (MAP& map, typename MAP::key_type const& key)
  {
    return map.find(key) != map.end();
  }
  
  template <typename T, class CMP, class ALO>
  inline bool
  contains (std::set<T,CMP,ALO> const& set, T const& val)
  {
    return set.end() != set.find (val);
  }
  
  template <typename T>
  inline bool
  contains (std::string const& str, const T& val)
  {
    return str.find (val) != std::string::npos;
  }
  
  template <typename SEQ>
  inline bool
  contains (SEQ const& cont, typename SEQ::const_reference val)
  {
    typename SEQ::const_iterator begin = cont.begin();
    typename SEQ::const_iterator end   = cont.end();
    
    return end != std::find(begin,end, val);
  }
  
  template <class IT>
  inline bool
  linearSearch (IT iter, typename IT::value_type const& val)
  {
    IT end{};
    return end != std::find (std::move (iter), end, val);
  }
  
  template <typename MAP>
  inline typename MAP::mapped_type
  getValue_or_default (MAP& map, typename MAP::key_type const& key
                               , typename MAP::mapped_type defaultVal)
  {
    typename MAP::const_iterator pos = map.find (key);
    if (pos != map.end())
      return pos->second;
    else
      return defaultVal;
  }
  
  template <typename MAP>
  inline typename MAP::mapped_type const &
  access_or_default (MAP& map, typename MAP::key_type const& key
                             , typename MAP::mapped_type const&  refDefault)
  {
    typename MAP::const_iterator pos = map.find (key);
    if (pos != map.end())
      return pos->second;
    else
      return refDefault;
  }
  
  template <typename SEQ>
  inline typename SEQ::iterator
  removeall (SEQ& coll, typename SEQ::value_type const& val)
  {
    typename SEQ::iterator collEnd = coll.end();
    return coll.erase (std::remove (coll.begin(), collEnd, val),
                       collEnd
                      );
  }
  
  
  template<class SET, typename FUN>
  bool remove_if (SET& set, FUN test)
    {
      typedef typename SET::iterator Itor;
      bool found = false;
      Itor   end = set.end();
      Itor begin = set.begin();
      Itor   pos = begin;
      while (pos!=end)
        {
          if (not test(*pos))
            ++pos;
          else
            {
              found = true;
              if (pos==begin)
                {
                  set.erase(pos);
                  pos = begin = set.begin();
                }
              else
                {
                  set.erase(pos--);
                  ++pos;
                }
              end = set.end();
        }   }
      return found;
    }
  
  
  
  
  template<class OBJ>
  inline OBJ*
  unConst (const OBJ* o)
  {
    return const_cast<OBJ*> (o);
  }
  
  template<class OBJ>
  inline OBJ&
  unConst (OBJ const& ro)
  {
    return const_cast<OBJ&> (ro);
  }
  
  
  
  /*  ======== address and identity =========  */
  
  template<class X>
  inline const void*
  getAdr (X& x)
  {
    return static_cast<const void*> (std::addressof(x));
  }
  template<class X>
  inline const void*
  getAdr (X* x)
  {
    return static_cast<const void*> (x);
  }
  
  template<class X>
  inline size_t
  addrID (X const& x)
  {
    return size_t(getAdr (x));
  }
  
  
  template<typename X>
  inline size_t
  slotNr (X const& x)
  {
    return addrID(x) / sizeof(size_t);
  }
  
  
  template<class A, class B>
  inline bool
  isSameAdr (A const& a, B const& b)
  {
    return getAdr(a) == getAdr(b);
  }
  
  template<class A, class B>
  inline bool
  isSameObject (A const& a, B const& b)
  {
    return static_cast<const void*> (std::addressof(a))
        == static_cast<const void*> (std::addressof(b));
  }
  
  template<typename A, typename B>
  inline bool
  isCloseBy (A&& a, B&& b, size_t consideredNearby =50)
  {
    size_t loc1 = slotNr (std::forward<A> (a));
    size_t loc2 = slotNr (std::forward<B> (b));
    size_t dist = loc2 > loc1? loc2-loc1:loc1-loc2;
    return dist < consideredNearby;
  }
  
  
  
  
  string sanitise (string const& org);
  
  
  string trim (string const& org);
  
  
  bool boolVal (string const&);
  
  
  bool isYes (string const&) noexcept;
  
  bool isNo (string const&) noexcept;
  
} // namespace util




 /* === some common macro definitions === */

#define SIDEEFFECT __attribute__ ((unused));

#define STRINGIFY(TOKEN) __STRNGFY(TOKEN)
#define __STRNGFY(TOKEN) #TOKEN

#define INSTANCEOF(CLASS, EXPR) (dynamic_cast<const CLASS*> (EXPR))

#ifndef MAX   // this is present to make this definition play nice with GLib
#define MAX(A,B) ((A < B) ?  (B) : (A))
#endif

#endif /*UTIL_HPP_*/