source: nscp/include/arrayBuffer.cpp @ d66ccee

/**************************************************************************
*   Copyright (C) 2004-2007 by Michael Medin <michael@medin.name>         *
*                                                                         *
*   This code is part of NSClient++ - http://trac.nakednuns.org/nscp      *
*                                                                         *
*   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.,                                       *
*   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
***************************************************************************/
#include <arrayBuffer.h>


/**
 * Make a list out of a array of char arrays (arguments type)
 * @param argLen Length of argument array
 * @param *argument[] Argument array
 * @return Argument wrapped as a list
 */
array_buffer::arrayList array_buffer::arrayBuffer2list(const unsigned int argLen, wchar_t *argument[]) {
        arrayList ret;
        int i=0;
        for (unsigned int i=0;i<argLen;i++) {
                std::wstring s = argument[i];
                ret.push_back(s);
        }
        return ret;
}
/**
 * Make a list out of a array of char arrays (arguments type)
 * @param argLen Length of argument array
 * @param *argument[] Argument array
 * @return Argument wrapped as a list
 */
array_buffer::arrayVector array_buffer::arrayBuffer2vector(const unsigned int argLen, wchar_t *argument[]) {
        arrayVector ret;
        int i=0;
        for (unsigned int i=0;i<argLen;i++) {
                std::wstring s = argument[i];
                ret.push_back(s);
        }
        return ret;
}
/**
* Create an arrayBuffer from a list.
* This is the reverse of arrayBuffer2list.
* <b>Notice</b> it is up to the caller to free the memory allocated in the returned buffer.
*
* @param lst A list to convert.
* @param &argLen Write the length to this argument.
* @return A pointer that is managed by the caller.
*/
array_buffer::arrayBuffer array_buffer::list2arrayBuffer(const arrayList lst, unsigned int &argLen) {
        argLen = static_cast<unsigned int>(lst.size());
        arrayBuffer arrayBuffer = new arrayBufferItem[argLen];
        arrayList::const_iterator it = lst.begin();
        int i;
        for (i=0;it!=lst.end();++it,i++) {
                std::wstring::size_type alen = (*it).size();
                arrayBuffer[i] = new wchar_t[alen+2];
                wcsncpy(arrayBuffer[i], (*it).c_str(), alen+1);
        }
        if (i != argLen)
                throw ArrayBufferException("Invalid length!");
        return arrayBuffer;
}
/**
* Creates an empty arrayBuffer (only used to allow consistency)
* @param &argLen [OUT] The length (items) of the arrayBuffer
* @return The arrayBuffer
*/
array_buffer::arrayBuffer array_buffer::createEmptyArrayBuffer(unsigned int &argLen) {
        argLen = 0;
        arrayBuffer arrayBuffer = new arrayBufferItem[0];
        return arrayBuffer;
}
/**
* Creates an arrayBuffer with N-elements
* @param &argLen [IN OUT] The length (items) of the arrayBuffer
* @return The arrayBuffer
*/
array_buffer::arrayBuffer array_buffer::createArrayBuffer(unsigned int &argLen) {
        arrayBuffer arrayBuffer = new arrayBufferItem[argLen];
        for (unsigned int i=0;i<argLen;i++) {
                arrayBuffer[i] = NULL;
        }
        return arrayBuffer;
}
/**
* Joins an arrayBuffer back into a string
* @param **argument The ArrayBuffer
* @param argLen The length of the ArrayBuffer
* @param join The char to use as separators when joining
* @return The joined arrayBuffer
*/
std::wstring array_buffer::arrayBuffer2string(arrayBuffer argument, const unsigned int argLen, std::wstring join) {
        std::wstring ret;
        for (unsigned int i=0;i<argLen;i++) {
                if (argument[i] != NULL) {
                        ret += argument[i];
                        if (i != argLen-1)
                                ret += join;
                }
        }
        return ret;
}
/**
* Split a string into elements as a newly created arrayBuffer
* @param buffer The CharArray to split along
* @param splitChar The char to use as splitter
* @param &argLen [OUT] The length of the Array
* @return The arrayBuffer
*/
array_buffer::arrayBuffer array_buffer::split2arrayBuffer(const wchar_t* buffer, wchar_t splitChar, unsigned int &argLen) {
        if (!buffer)
                throw ArrayBufferException("Invalid buffer specified!");
        argLen = 0;
        const wchar_t *p = buffer;
        if (!p[0]) {
                return createEmptyArrayBuffer(argLen);
        }
        while (*p) {
                if (*p == splitChar)
                        argLen++;
                p++;
        }
        argLen++;
        wchar_t **arrayBuffer = new wchar_t*[argLen];
        p = buffer;
        for (unsigned int i=0;i<argLen;i++) {
                const wchar_t *q = wcschr(p, (i<argLen-1)?splitChar:0);
                unsigned int len = static_cast<int>(q-p);
                arrayBuffer[i] = new wchar_t[len+1];
                wcsncpy(arrayBuffer[i], p, len);
                arrayBuffer[i][len] = 0;
                p = ++q;
        }
        return arrayBuffer;
}


void array_buffer::set(arrayBuffer arrayBuffer, const unsigned int argLen, const unsigned int position, std::wstring argument) {
        if (position >= argLen)
                throw ArrayBufferException("position is outside the buffer");
        delete [] arrayBuffer[position];
        size_t len = argument.length();
        arrayBuffer[position] = new wchar_t[len+2];
        wcsncpy(arrayBuffer[position], argument.c_str(), len);
        arrayBuffer[position][len] = 0;
}

/**
 * Split a string into elements as a newly created arrayBuffer
 * @param inBuf The CharArray to split along
 * @param splitChar The char to use as splitter
 * @param &argLen [OUT] The length of the Array
 * @param escape [IN] Set to true to try to escape ":s ie. //token1 "token2 with space" token3//
 * @return The arrayBuffer
 */
array_buffer::arrayBuffer array_buffer::split2arrayBuffer(const std::wstring inBuf, wchar_t splitChar, unsigned int &argLen, bool escape) {
        if (inBuf.empty())
                return createEmptyArrayBuffer(argLen);

        std::wstring::size_type p1 = 0;
        std::wstring::size_type p2 = 0;
        std::list<std::wstring> token_list;
        while (p1 != std::wstring::npos && p2 != std::wstring::npos) {
                if (escape && inBuf[p1] == '\"') {
                        p2 = inBuf.find('\"', p1+1);
                        if (p2 != std::wstring::npos)
                                p2 = inBuf.find(splitChar, p2);
                } else {
                        p2 = inBuf.find(splitChar, p1);
                }
                if (p2 == std::wstring::npos)
                        p2 = inBuf.size();
                if (p1 == p2 && p1 != inBuf.size()) {
                        p1++;
                        continue;
                }
                // p1 = start of "this token"
                // p2 = end of "this token" (next split char)

                if (p2<=p1)
                        throw ArrayBufferException("Invalid position");
                std::wstring token = inBuf.substr(p1,p2-p1);
                if (escape && token[0] == '\"')
                        token = token.substr(1);
                if (escape && token[token.size()-1] == '\"')
                        token = token.substr(0, token.size()-1);


                token_list.push_back(token);
                if (p2 < inBuf.size())
                        p2++;
                if (p2 == inBuf.size())
                        p2 = std::wstring::npos;
                p1 = p2;
        }
        arrayBuffer arrayBuffer = new arrayBufferItem[token_list.size()];
        argLen=0;
        for (std::list<std::wstring>::const_iterator cit=token_list.begin();cit!=token_list.end();++cit) {
                size_t len = (*cit).size();
                wchar_t* token = new wchar_t[len+1];
                wcsncpy(token, (*cit).c_str(), len);
                arrayBuffer[argLen++] = token;
        }
        token_list.clear();
        return arrayBuffer;
}

/**
* Destroy an arrayBuffer.
* The buffer should have been created with list2arrayBuffer.
*
* @param **argument 
* @param argLen 
*/
void array_buffer::destroyArrayBuffer(arrayBuffer argument, const unsigned int argLen) {
        for (unsigned int i=0;i<argLen;i++) {
                delete [] argument[i];
        }
        delete [] argument;
}