Label.hh

Go to the documentation of this file.

#ifndef __DIADES__UTILS__LABEL__HH
#define __DIADES__UTILS__LABEL__HH
#include<iostream>
#include<istream>
#include<string>
#include <locale>
#include <algorithm>  
#include <diades/utils/IdGenerators.hh>
#include <diades/utils/Enumerators.hh>

namespace Diades
{
   namespace Utils
   {

      template < typename CharT,
      typename Traits,
      typename Alloc>
      class GenericLabel
      {
      protected:
         typedef std::basic_string<CharT, Traits, Alloc> BasicString;
      private:
         BasicString _label;

      public:

         const BasicString &
         toString() const
         {
            return _label;
         }

         bool
         isNull() const
         {
            return _label.empty();
         }

         GenericLabel & operator=(const GenericLabel & label)
         {
            if(this != &label)
            {
               setLabel(label._label);
            }
            return *this;
         }

      protected:

         void
         setLabel(const BasicString & label)
         {
            _label = label;
         }

      };

      template < typename CharT, typename Traits, typename Alloc >
      class QuotedLabel : public GenericLabel<CharT, Traits, Alloc>
      {
      public:
         QuotedLabel() = default;
         QuotedLabel(const QuotedLabel & label) = default;
         QuotedLabel(QuotedLabel && label) = default;

         QuotedLabel(std::basic_istream<CharT> & is) : GenericLabel<CharT, Traits, Alloc>()
         {
            checkQuotedLabel(is);
         }

         QuotedLabel & operator=(const QuotedLabel & label)
         {
            GenericLabel<CharT, Traits, Alloc>::operator=(label);
            return *this;
         }

         typename GenericLabel<CharT, Traits, Alloc>::BasicString
         nudeString() const
         {
            if(GenericLabel<CharT, Traits, Alloc>::toString().size() >= 2)
            {
               return GenericLabel<CharT, Traits, Alloc>::toString().substr(1, GenericLabel<CharT, Traits, Alloc>::toString().size() - 2);
            }
            return "";
         }

      private:

         void
         checkQuotedLabel(std::basic_istream<CharT> & is)
         {
            typename GenericLabel<CharT, Traits, Alloc>::BasicString label;
            CharT c;
            is.get(c);
            int counter = 1;
            while(std::isspace<CharT>(c, is.getloc()) && is.get(c))
            {
               ++counter;
            }

            if(c != '\"')
            {
               is.seekg(-counter, std::ios_base::cur);
               return;
            }
            label += c;
            bool stop = false;

            while(!(stop) && is.get(c))
            {
               ++counter;
               if(c == '\"')
               {
                  stop = true;
                  label += c;
               }
               else
               {
                  label += c;
               }
            }
            if(label.size() == 1)
            {
               is.seekg(-counter, std::ios_base::cur);
               return;
            }
            if(label.back() != '\"')
            {
               is.seekg(-counter, std::ios_base::cur);
               return;
            }

            this->setLabel(label);
         }
      };


      template<typename CharT, typename Traits, typename Alloc>
      class LabelGenerator;

      template < typename CharT, typename Traits, typename Alloc >
      class UnquotedLabel : public GenericLabel<CharT, Traits, Alloc>
      {
      public:
         friend LabelGenerator<CharT, Traits, Alloc>;

      public:
         using GL = GenericLabel<CharT, Traits, Alloc>;
         using BasicString = typename GL::BasicString;
      public:
         UnquotedLabel() = default;
         UnquotedLabel(const UnquotedLabel & label) = default;
         UnquotedLabel(UnquotedLabel && label) = default;

         UnquotedLabel(const BasicString & s) : GL()
         {
            checkUnquotedLabel(s);
         }

         UnquotedLabel(std::basic_istream<CharT> & is) : GL()
         {
            checkUnquotedLabel(is);
         }

         UnquotedLabel & operator=(const UnquotedLabel & label)
         {
            GenericLabel<CharT, Traits, Alloc>::operator=(label);
            return *this;
         }

      private:

         void
         checkUnquotedLabel(const BasicString & s)
         {
            if(std::find_if(s.begin(), s.end(), [&](CharT c) -> bool
               {
                  return c == ' ';
               }) == s.end())
         {

            std::basic_stringstream<CharT> stream;
            stream << s;

            checkUnquotedLabel(stream);
         }
         }

         void
         checkUnquotedLabel(std::basic_istream<CharT> & is)
         {
            typename GenericLabel<CharT, Traits, Alloc>::BasicString label;
            CharT c;
            is.get(c);
            //std::cout << "reading first character '" << c << "'\n";
            int counter = 1;
            while(std::isspace<CharT>(c, is.getloc()) && is.get(c))
            {
               //std::cout << "is a space, reading a new one '" << c << "'\n";
               ++counter;
            }
            //std::cout << "'" << c << "' is not a space\n";
            if(!(std::isalpha(c) || c == '_'))
            {
               //std::cout << "'" << c << "' is neither alpha nor _, give up\n";
               is.seekg(-counter, std::ios_base::cur);
               return;
            }
            label += c;

            bool stop = false;

            while(!(stop) && is.get(c))
            {
               ++counter;
               if(std::isalnum<CharT>(c, is.getloc()) || (c == '_'))
               {
                  label += c;
               }
               else
               {
                  if(std::isspace<CharT>(c, is.getloc()))
                  {
                     stop = true;
                     is.seekg(-1, std::ios_base::cur);
                  }
                  else
                  {
                     is.seekg(-counter, std::ios_base::cur);
                     return;
                  }
               }
            }
            this->setLabel(label);
         }
      };

      template < typename CharT,
      typename Traits,
      typename Alloc>
      bool
      readLabel(std::basic_istream<CharT> & stream,
                std::basic_string<CharT, Traits, Alloc> & label)
      {
         UnquotedLabel<CharT, Traits, Alloc> unqLabel(stream);
         if(unqLabel.isNull())
         {

            QuotedLabel<CharT, Traits, Alloc> qLabel(stream);
            if(qLabel.isNull())
            {

               return false;
            }
            else
            {

               /* quoted label
                * consists of a character string starting with a 
                * double quote and ending with a double quote. Between these two 
                * double quotes, there can be zero, one or many printable 
                * characters; the meaning of "printable" is given by the POSIX 
                * isprint() function with locale "C" (namely, ASCII characters 
                * with decimal codes in the range from 32 to 126, bounds included). 
                * No other assumption should be made about the characters present 
                * between these two double quotes. In particular, the double quote 
                * character itself may be present, and may not necessarily be 
                * "escaped" in some way (e.g., preceded by a backslash, as in C).
                */

               label = qLabel.nudeString();

            }
         }
         else
         {

            /* unquoted label
             * consists of a character string starting with a 
             * letter, and followed by zero, one, or many letters, digits, or 
             * underscore characters.
             */
            label = unqLabel.toString();

         }
         return true;
      }





      typedef UnquotedLabel<char, std::char_traits<char>, std::allocator<char> > UnquotedStringLabel;
      typedef UnquotedLabel<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> > UnquotedWideStringLabel;
      typedef QuotedLabel<char, std::char_traits<char>, std::allocator<char> > QuotedStringLabel;
      typedef QuotedLabel<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> > QuotedWideStringLabel;



      template<typename CharT, typename Traits, typename Alloc>
      class
      LabelGenerator : public IdGenerator<Diades::Utils::UnquotedLabel<CharT, Traits, Alloc>>
      {
         public:

         using Label = Diades::Utils::UnquotedLabel<CharT, Traits, Alloc>;
         using Gen = IdGenerator<Label>;

         private:
         const std::array<CharT, 26>
                 _characters = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'};
         Diades::Utils::RangesEnumeration<size_t> _enumerator;
         Label _prefix;


         public:


         LabelGenerator() = default;


         LabelGenerator(LabelGenerator const& other) = default;
         LabelGenerator& operator=(LabelGenerator const& other) = default;
         LabelGenerator(LabelGenerator && other) = default;
         LabelGenerator& operator=(LabelGenerator && other) = default;

         virtual ~LabelGenerator() = default;

         LabelGenerator(const Label & prefix) : Gen(), _enumerator(), _prefix(prefix)
         {
            init();
         };

         void init()
         {
            _enumerator.setup({0},
            {
                              _characters.size()
            });
            _enumerator.start();
         }

         Label another()
         {
            Label result = getLabel();
            if(!_enumerator.hasNext())
            {
               std::vector<size_t> start(_enumerator.current().size() + 1);
               std::vector<size_t> last(_enumerator.current().size() + 1);
               std::fill(start.begin(), start.end(), 0);
               std::fill(last.begin(), last.end(), _characters.size());
               _enumerator.setup(std::move(start), std::move(last));
               _enumerator.start();
            }
            return result;
         }

         private:

         Label getLabel()
         {
            Label result;
            typename Label::BasicString configuration;
            std::for_each(_enumerator.current().rbegin(), _enumerator.current().rend(),
                          [&](size_t i)
                          {
                             configuration += _characters[i];
                          });
            result.setLabel(_prefix.toString() + configuration);
            return result;
         }



      };
      
      
      typedef LabelGenerator<char, std::char_traits<char>, std::allocator<char> > UnquotedStringLabelGenerator;
      typedef LabelGenerator<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> > UnquotedWideStringLabelGenerator;
   }
}


#endif /* LABEL_HH */