StringTool.cpp

Go to the documentation of this file.

/*
 * StringTool.cpp
 *
 *  This file is part of the HausmiSEP project
 *
 *  Copyright (C) 2012, 2013 Marco Alvarado (malvcr@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 3 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, see <http://www.gnu.org/licenses/>.
 */

#include <HSEP/StringTool.h>

#include <string.h>

using namespace std;

namespace HSEP {

    ErrorCode StringTool::split(char* pSourcePtr, const char* pSepLevelsPtr, StringDictionary& pDestRef) {

        ErrorCode vResult = EC::IncompleteProcessing;

        if (strlen(pSepLevelsPtr) < 2) {
            vResult = EC::IncompleteParameter;
        }
        else {

            char   vThisName   [MAXTOKEN_SIZE+1];
            char   vThisValue  [MAXVALUE_SIZE+1];
            memset(vThisName ,0,MAXTOKEN_SIZE+1);
            memset(vThisValue,0,MAXVALUE_SIZE+1);

            int  vTokenIdx = 0;

            char vSepFirstLevel  = pSepLevelsPtr[0];
            char vSepSecondLevel = pSepLevelsPtr[1];

            bool vCheckingName  = true;
            bool vCheckingValue = false;

            size_t  vSourceLen     = strlen(pSourcePtr);

            for (size_t vIdx=0; vIdx<vSourceLen; vIdx++) {

                char vAt = pSourcePtr[vIdx];

                if (vCheckingName) {
                    if (vAt == vSepSecondLevel) {
                        vCheckingName  = false;
                        vCheckingValue = true;
                        vTokenIdx      = 0;
                    }
                    else {
                        if ((vTokenIdx >  MAXTOKEN_SIZE) && (vAt != '\0')) { // short circuit type of evaluation
                            vResult = EC::BufferOverflow;
                            break;
                        }
                        vThisName[vTokenIdx] = vAt;
                        vTokenIdx++;
                    }
                } // if (vCheckingName) {
                else if (vCheckingValue) {
                    if (vAt == vSepFirstLevel) {
                        vCheckingName  = true;
                        vCheckingValue = false;
                        vTokenIdx      = 0;

                        string vThisNameStr(vThisName);
                        string vThisValueStr(vThisValue);

                        pDestRef.put(vThisNameStr,vThisValueStr);

                        memset(vThisName ,0,MAXTOKEN_SIZE+1 );
                        memset(vThisValue,0,MAXVALUE_SIZE+1);
                    }
                    else {
                        if ((vTokenIdx >  MAXVALUE_SIZE) && (vAt != '\0')) { // short circuit type of evaluation
                            vResult = EC::BufferOverflow;
                            break;
                        }
                        vThisValue[vTokenIdx] = vAt;
                        vTokenIdx++;
                    }

                } // else if (vCheckingValue) {

            } // for (unsigned int vIdx=0; vIdx<pSource.length(); vIdx++) {

            if (EC::IncompleteProcessing == vResult) {
                vResult = EC::OK;
            }
        }
        return vResult;

    } // StringTool::split

    ErrorCode StringTool::split(string& pSourceRef, const string pSeparator, StringArray& pDestRef) {

        ErrorCode vResult = EC::IncompleteProcessing;

        pDestRef.clear();

        size_t vSourceLength = pSourceRef.length();

        if (0 == vSourceLength) { // trivial case
            vResult = EC::OK;
        }
        else {

            size_t vSepSize     = pSeparator.length();
            size_t vCurrentPos  = 0;
            size_t vPreviousPos = 0;
            size_t vMaxPos      = vSourceLength - vSepSize;

            string vSample;

            while (vCurrentPos != string::npos) {

                vCurrentPos = pSourceRef.find(pSeparator,vPreviousPos);

                if (string::npos == vCurrentPos) {
                    vSample = pSourceRef.substr(vPreviousPos);
                }
                else {
                    vSample = pSourceRef.substr(vPreviousPos,vCurrentPos - vPreviousPos);

                    if (vCurrentPos > vMaxPos) {
                        vCurrentPos = string::npos;
                    }
                    else {
                        vPreviousPos = vCurrentPos + vSepSize;
                    }
                }
                pDestRef.push(vSample);

            } // while (vCurrentPos != string::npos) {

            vResult = EC::OK;
        }
        return vResult;

    } // StringTool::split



    ErrorCode StringTool::toHex(void* pSource,size_t pSize,string& pDestination) {

        for (size_t vIdx=0; vIdx < pSize; vIdx++) {
            unsigned char vValue = ((char*)pSource)[vIdx];
            unsigned char vValueHex[3];
            unsigned char vHigh = HEXVALUES[vValue>>4];
            unsigned char vLow  = HEXVALUES[vValue&0x0F];
            vValueHex[0] = vHigh;
            vValueHex[1] = vLow;
            vValueHex[2] = '\0';
            pDestination.append((char*)vValueHex);
        }

        return EC::OK;

    } // StringTool::toHex

    ErrorCode StringTool::fromHex(string& pSource, void* pDestination, size_t pDestinationSize) {

        ErrorCode vResult = EC::NotCatalogedError;

        size_t vSize = pSource.size();

        if (vSize % 2) {

            vResult = EC::EvenSizeExpected;

        } else if ((vSize / 2) > pDestinationSize) {

            vResult = EC::BufferOverflow;

        } else {

            char* vStr = (char*) (pSource.c_str());
            char* vPtr = (char*) (pDestination);

            size_t vDataIdx = 0;

            for (size_t vPointer = 0; vPointer < vSize; vPointer += 2) {

                if (strchr(HEXVALUES, vStr[vPointer]) && strchr(HEXVALUES, vStr[vPointer + 1])) {
                    // All these conversions are included to work warnings about
                    // implicit conversion from char to int when applying bit operations.
                    // Also, as we use characters as REVHEX indexes, and the indexes must be of
                    // int type, a conversion must be performed.
                    //
                    char vHigh  = static_cast<char>(REVHEX[(int)vStr[vPointer]] << 4);
                    char vLow   = static_cast<char>(REVHEX[(int)vStr[vPointer + 1]]);
                    char vValue = static_cast<char>(vHigh + vLow);
                    vPtr[vDataIdx] = vValue;
                    vDataIdx++;
                } else {
                    vResult = EC::InvalidHexValue;
                    break;
                }
                vResult = EC::OK;
            }
        }

        return vResult;

    } // StringTool::fromHex


    ErrorCode StringTool::ltrim(string& pStringRef) {

        ErrorCode vResult = EC::IncompleteProcessing;

        size_t  vTotal   = pStringRef.size();

        // Don't work on empty strings, that will produce invalid access exceptions.
        //
        if (vTotal > 0) {

            const char* vPtr = pStringRef.c_str();

            bool   vEndLoop = false;

            // The vIndex must start with zero, because it is used as a counter.
            // When starting with 1, will discard the important case where no
            // spaces are in the beginning of the string.
            //
            size_t vIndex   = 0;

            while (!vEndLoop) {

                // When arrive to the end, the string was empty.
                //
                if (vIndex == vTotal) {
                    pStringRef.clear();
                    vEndLoop = true;
                    vResult = EC::OK;
                }
                else {
                    if (isspace(vPtr[vIndex])) {
                        vIndex++;
                    }
                    else {
                        pStringRef.erase(0,vIndex);
                        vEndLoop = true;
                        vResult = EC::OK;
                    }
                }
            }
        }

        return vResult;

    } // StringTool::ltrim

    ErrorCode StringTool::drop(string& pStringRef, const char* pDropHead) {

        ErrorCode vResult = EC::IncompleteProcessing;

        // Don't work on empty strings
        //
        if (pStringRef.size()>0) {
            size_t vPos = pStringRef.find(pDropHead);

            if (pStringRef.npos != vPos) {
                pStringRef.erase(vPos,pStringRef.npos);
            }
        }
        vResult = EC::OK; // not yet an exception to this behavior have been found

        return vResult;

    } // StringTool:drop

} // HSEP namespace