StringTools.hh

Go to the documentation of this file.

#ifndef __DIADES__UTILS__STRINGTOOLS__HH
#define __DIADES__UTILS__STRINGTOOLS__HH

#include<string>
#include<numeric>
#include<diades/utils/Verbose.hh>


namespace Diades
{
   namespace Utils
   {


     struct StringHash
      {

         inline size_t operator()(const std::string & s) const
         {
            size_t hash = 5381;
            int c;
            for(unsigned i = 0; i < std::string::npos; ++i)
            {
               c = s[i];
               hash = ((hash << 5) + hash) + c;
            }
            return hash;
         }
      };

      template<class CharType, class CharTraits, class InputIterator>
      InputIterator
      getFileExtension(const std::basic_string<CharType, CharTraits> & fileName,
                       InputIterator begin, InputIterator end)
      {
         typedef std::basic_string<CharType, CharTraits> String;
         size_t idx;
         idx = fileName.find_last_of('.');
         if(idx != String::npos)
         {
            String suffix = fileName.substr(idx + 1);
            bool found = false;
            while((!found) && (begin != end))
            {
               found = (suffix == *begin);
               if(!found)
               {
                  ++begin;
               }
            }
         }
         else
         {
            begin = end;
         }
         return begin;
      }

      template<class CharType, class CharTraits>
      bool
      hasOnlyWhiteSpaces(const std::basic_string<CharType, CharTraits> & sequence,
                         typename std::basic_string<CharType, CharTraits>::size_type & index)
      {
         index = 0;
         bool foundSomething = false;
         while(!foundSomething && index != sequence.size())
         {
            foundSomething = (sequence.at(index) != ' ')
                    &&
                    (sequence.at(index) != '\t');
            if(!foundSomething)
            {
               ++index;
            }
         }
         if(!foundSomething)
         {
            index = std::basic_string<CharType, CharTraits>::npos;
         }
         return !foundSomething;
      }

      template< typename CharT,
      CharT separator,
      typename Traits,
      typename Alloc>
      class StringBinaryCombination
      {
      public:
         typedef std::basic_string<CharT, Traits, Alloc> String;
         
         String operator()(String str1, const String & str2) const
         {
            return std::move(str1) + separator + str2;
         }
      };

      template< typename CharT,
      CharT left,
      CharT right,
      typename Traits,
      typename Alloc
      >
      class StringDelimiter
      {
      public:
         typedef std::basic_string<CharT, Traits, Alloc> String;
         
         String operator()(String str) const
         {
            return left + std::move(str) + right;
         }
      };

      template< typename CharT,
      typename Traits,
      typename Alloc
      >
      class NoDelimiter
      {
      public:
         typedef std::basic_string<CharT, Traits, Alloc> String;
         
         String operator()(String str) const
         {
            return std::move(str);
         }
      };
      
      template<typename _Property, typename BinaryDisjunction, typename Delimiter>
      class Disjunction
      {
      public:
         using Property = _Property;

         template<typename PropertyIterator>
         Property operator()(PropertyIterator begin, PropertyIterator end) const
         {
            Property result;
            if(begin != end)
            {
               result = std::accumulate(++begin, end, *begin, BinaryDisjunction());
            }
            return Delimiter()(result);
         }
      };

      template<typename _Property, typename BinaryConjunction, typename Delimiter>
      class Conjunction
      {
      public:
         using Property = _Property;

         template<typename PropertyIterator>
         Property operator()(PropertyIterator begin, PropertyIterator end)
         {
            Property result;
            if(begin != end)
            {
               result = std::accumulate(++begin, end, *begin, BinaryConjunction());
            }
            return Delimiter()(result);
         }
      };



   };
};
#endif