RaString.hpp

/*
 * RaString.hpp
 * 
 * Copyright 2018 Fernando Pujaico Rivera <fernando.pujaico.rivera@gmail.com>
 * 
 * This program 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.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
 * MA 02110-1301, USA.
 * 
 */
 
#ifndef __PDS_RASTRING_HPP__
#define __PDS_RASTRING_HPP__
    
#include <string>
#include <list>
#include <Pds/Grid>
#include <vector>
 
 
namespace Pds{
 
namespace Ra{
 
namespace Sort{
 
    struct NaturalStdString
    {
        // cstr1 < cstr2
        // constexpr // enable only in c++14
        // https://en.cppreference.com/w/cpp/utility/functional/less
        bool operator()(const std::string &cstr1,const std::string &cstr2) const
        {
            unsigned int id1=0;
            unsigned int id2=0;
            unsigned int N1=cstr1.size();
            unsigned int N2=cstr2.size();
            
            std::string s1="";
            std::string s2="";
            
            id1=0;id2=0;
            
            while((id1<N1)&&(id2<N2))
            {
                // Si es un número
                if( (isdigit(cstr1[id1])!=0)&&(isdigit(cstr2[id2])!=0) )
                {
                    s1="";
                    s2="";
                    
                    while( isdigit(cstr1[id1])!=0 )  { s1=s1+cstr1[id1]; id1++; }
                    while( isdigit(cstr2[id2])!=0 )  { s2=s2+cstr2[id2]; id2++; }
                    
                    if(atoi(s1.c_str())<atoi(s2.c_str()))   return true;
                    if(atoi(s1.c_str())>atoi(s2.c_str()))   return false;
                }
                else
                {
                    if( cstr1[id1]<cstr2[id2] )   return true;
                    if( cstr1[id1]>cstr2[id2] )   return false;
                    
                    id1++;
                    id2++;
                }
                
            }
            
            if(N1<N2)   return true;
            else        return false;
        }
    };
}// Sort  
 
    std::vector<std::string> SubsInString(const std::string &str,char DelL,char DelR);
    
    std::vector<std::string> SubsInString(  const std::string &str,
                                            const std::string &DelL,
                                            const std::string &DelR,
                                            bool Full=false);
    
    std::string FirstSubInString(   const std::string &str,
                                    const std::string &DelL,
                                    const std::string &DelR,
                                    bool Full=false);
    
    std::vector<unsigned long int> FirstSubIdsInString( const std::string &str,
                                                        const std::string &DelL,
                                                        const std::string &DelR,
                                                        bool Full=false);
    
    std::vector<std::string> SubsXmlInString(   const std::string &str,
                                                bool Full,
                                                std::vector<std::string> &Tag);
    
    bool IsInteger(const std::string& str);
    
    bool IsReal(const std::string& str);
 
    int ElementsInString(const std::string &str);
 
 
    bool ArraySizeInString(std::string str,unsigned int &Nlin,unsigned int &Ncol);
    
    std::list<std::string> ListSplitString(std::string str, std::string delimeters);
 
    std::vector<std::string> VectorSplitString(std::string str, std::string delimeters);
    
    std::vector<std::string> VectorSplitString(std::string str, std::string delimiter,bool include_void);
    
    std::vector<std::string> SplitSingleTagAndData(const std::string &str, char wrap, char Eq);
    
    std::vector<std::string> SplitMultipleTagAndSeparator(const std::string &str, char wrap, char sep, char dc);
    
    std::vector<std::string> SplitMultipleObjectsAndSeparator(  const std::string &str,
                                                                char DelL,
                                                                char DelR,
                                                                char sep);
    bool NaturalCompare(const std::string &str1,const std::string &str2);
 
    bool IsSpacesString(const std::string &str);
 
    std::string Trim(const std::string &str);
    
 
    std::string ToLower(const std::string &str);
    
    int CiCompare(const std::string &str1,const std::string &str2);
    
    std::string Repeat(const std::string &str,unsigned int N);
    
    std::string ReplaceAll(std::string str, const std::string& from, const std::string& to);
    
    template  <typename T>
    extern std::string ToString(T val);
 
    bool SaveString(const std::string &filepath, const std::string &str);
    
    bool LoadString(const std::string &filepath, std::string &str);
    
    
    bool SaveVectorString(const std::string &filepath, const std::vector<std::string> &str);
    
 
    bool PrintVectorString(const std::vector<std::string> &str);
    
    bool PrintVectorString( const std::vector<std::string> &str,
                            std::string delim_elem,
                            std::string delim_end);
 
 
    bool PrintGridString(   const Pds::Grid<std::string> &str,
                            std::string delim_elem,
                            std::string delim_end);
                            
 
    std::string ExportOctaveCellString(const std::vector<std::string> &X,const std::string &pname);
} // namespace Ra
} // namespace Pds
 
 
#endif /* __PDS_RASTRING_HPP__ */