parse.h

Go to the documentation of this file.

/******************************************************************************
 * Copyright 2022 Kristiyan Manev (University of Manchester)
 *
 * Licensed under the Apache License, Version 2.0(the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *****************************************************************************/
 
#ifndef STR_PARSE_H
#define STR_PARSE_H
 
#include<cstdint> //uint
#include<string>
#include<iomanip> //quoted
#include<sstream>
 
/**************************************************************************/
namespace str{
    namespace parse {
        inline std::string nthStringWord(std::string s, int n)  
        {
            std::stringstream ss(s);
            std::string temp;
            int intFound, i = 0;
            while (!ss.eof()) {
                ss >> quoted(temp);
                if(temp.empty()) break;
                try{
                    size_t sz;
                    intFound = stoi(temp, &sz, 0);
                    if(temp.size() != sz)
                        throw std::exception();
                } catch (const std::exception &e) {
                    if(i == n)
                        return temp;
                    i++;
                    e;
                }
                temp.clear();
            }
            return std::string("");
        }
        inline std::string allStringWords(std::string s)    
        {
            std::stringstream ss(s);
            std::string temp, ret = "";
            int intFound;
            while (!ss.eof()) {
                ss >> quoted(temp);
                if(temp.empty()) break;
                try{
                    size_t sz;
                    intFound = stoi(temp, &sz, 0);
                    if(temp.size() != sz)
                        throw std::exception();
                } catch (const std::exception &e) {
                    if(!ret.empty())
                        ret.append(" ");
                    ret.append(temp);
                    e;
                }
                temp.clear();
            }
            return ret;
        }
        inline std::string lastStringWord(std::string s)    
        {
            std::stringstream ss(s);
            std::string ret;
            ret.clear();
            std::string temp;
            int intFound;
            while (!ss.eof()) {
                ss >> quoted(temp);
                if(temp.empty()) break;
                try{
                    size_t sz;
                    intFound = stoi(temp, &sz, 0);
                    if(temp.size() != sz)
                        throw std::exception();
                } catch (const std::exception &e) {
                    ret = temp;
                    e;
                }
                temp.clear();
            }
            return ret;
        }
        inline std::string allStringWordsWithoutLastStringWord(std::string s)   
        {
            std::stringstream ss(s);
            std::string ret;
            ret.clear();
            std::string temp;
            std::string temp2;
            int intFound;
            while (!ss.eof()) {
                ss >> quoted(temp);
                if(temp.empty()) break;
                try{
                    size_t sz;
                    intFound = stoi(temp, &sz, 0);
                    if(temp.size() != sz)
                        throw std::exception();
                } catch (const std::exception &e) {
                    if(!ret.empty())
                        ret.append(" ");
                    ret.append(temp2);
                    temp2 = temp;
                    e;
                }
                temp.clear();
            }
            return ret;
        }
        inline bool nthInteger(std::string s, int n, int &x)    
        {
            std::stringstream ss(s);
            std::string temp;
            int intFound;
            int i = 0;
            while (!ss.eof()) {
                ss >> quoted(temp);
                if(temp.empty()) break;
                try{
                    size_t sz;
                    intFound = stoi(temp, &sz, 0);
                    if(temp.size() != sz)
                        throw std::exception();
                    if(i == n) {
                        x = intFound;
                        return true;
                    }
                    i++;
                } catch (const std::exception &e) {
                    e;
                }
                temp.clear();
            }
            return false;
        }
        inline bool arrayOfUints(std::string s, int arrsize, uint32_t* arr) 
        {
            if (arrsize == 0)
                return true;
            std::stringstream ss(s);
            std::string temp;
            uint32_t intFound;
            bool intWasFound = false;
            for (int i = 0 ; i < arrsize ; i++)
            {
                intWasFound = false;
                while ((!ss.eof()) && (!intWasFound)) {
                    ss >> quoted(temp);
                    if(temp.empty()) break;
                    try{
                        size_t sz;
                        intFound = (uint32_t)(stoll(temp, &sz, 0));
                        if(temp.size() != sz)
                            throw std::exception();
                        arr[i] = intFound;
                        intWasFound = true;
                    } catch (const std::exception &e) {
                        e;
                    }
                    temp.clear();
                }
                if(ss.eof() && (!intWasFound))
                    return false;
            }
            return true;   //success
        }
        
        template<typename ... Rest> inline bool multipleInts(std::stringstream & ss)
        {
            return true;
        }
        template<typename ... Rest> inline bool multipleInts(std::stringstream & ss, int & x, Rest & ... args)  
        {
            int numArgs = sizeof...(args);
            std::string temp;
            int intFound;
            bool intWasFound = false;
            while ((!ss.eof()) && (!intWasFound)) {
                ss >> quoted(temp);
                if(temp.empty()) break;
                try{
                    size_t sz;
                    intFound = stoi(temp, &sz, 0);
                    if(temp.size() != sz)
                        throw std::exception();
                    x = intFound;
                    intWasFound = true;
                } catch (const std::exception &e) {
                    e;
                }
                temp.clear();
            }
            if(ss.eof() && (!intWasFound))
                return false;
            return multipleInts(ss, args...);
        }
        template<typename ... Args> inline bool multipleInts(std::string s, Args & ... args)    
        {
            std::stringstream ss(s);
            return multipleInts(ss, args...);
        }
        
        template<typename ... Rest> inline bool multipleUints(std::stringstream & ss)
        {
            return true;
        }
        template<typename ... Rest> inline bool multipleUints(std::stringstream & ss, uint32_t & x, Rest & ... args)    
        {
            int numArgs = sizeof...(args);
            std::string temp;
            unsigned long uintFound;
            bool intWasFound = false;
            while ((!ss.eof()) && (!intWasFound)) {
                ss >> quoted(temp);
                if(temp.empty()) break;
                try{
                    size_t sz;
                    uintFound = stoul(temp, &sz, 0);
                    if(temp.size() != sz)
                        throw std::exception();
                    x = (uint32_t)uintFound;
                    intWasFound = true;
                } catch (const std::exception &e) {
                    e;
                }
                temp.clear();
            }
            if(ss.eof() && (!intWasFound))
                return false;
            return multipleUints(ss, args...);
        }
        template<typename ... Args> inline bool multipleUints(std::string s, Args & ... args)   
        {
            std::stringstream ss(s);
            return multipleUints(ss, args...);
        }
    }
}
#endif //STR_PARSE_H