CUStrings.h

//
//  CUStrings.h
//  Cornell University Game Library (CUGL)
//
//  Android does not support a lot of the built-in string methods.  Therefore,
//  we need alternate definitions that are platform agnostic.  Note that these
//  functions have names that are very similar to those in the std namespace,
//  but all live in the cocos2d namespace.
//
//  Note that this module does not refer to the integral types as short, int,
//  long, etc.  Those types are NOT cross-platform.  For example, a long is
//  8 bytes on Unix/OS X, but 4 bytes on some Win32 platforms.
//
//  CUGL zlib License:
//      This software is provided 'as-is', without any express or implied
//      warranty.  In no event will the authors be held liable for any damages
//      arising from the use of this software.
//
//      Permission is granted to anyone to use this software for any purpose,
//      including commercial applications, and to alter it and redistribute it
//      freely, subject to the following restrictions:
//
//      1. The origin of this software must not be misrepresented; you must not
//      claim that you wrote the original software. If you use this software
//      in a product, an acknowledgment in the product documentation would be
//      appreciated but is not required.
//
//      2. Altered source versions must be plainly marked as such, and must not
//      be misrepresented as being the original software.
//
//      3. This notice may not be removed or altered from any source distribution.
//
//  Author: Walker White
//  Version: 2/10/16
//
#ifndef __CU_STRINGS_H_
#define __CU_STRINGS_H_
#include <SDL/SDL.h>
#include <vector>
#include <string>
#include <locale>
#include <algorithm>

namespace cugl {
    
#pragma mark NUMBER TO STRING FUNCTIONS

    std::string to_string(Uint8 value);
    
    std::string to_string(Sint16 value);
    
    std::string to_string(Uint16 value);
    
    std::string to_string(Sint32 value);
    
    std::string to_string(Uint32 value );
    
    std::string to_string(Sint64 value );
    
    std::string to_string(Uint64 value );
    
    std::string to_string(float value, int precision=-1);
    
    std::string to_string(double value, int precision=-1);

    
#pragma mark -
#pragma mark ARRAY TO STRING FUNCTIONS

    std::string to_string(Uint8* array, size_t length, size_t offset=0);
    
    std::string to_string(Sint16* array, size_t length, size_t offset=0);
    
    std::string to_string(Uint16* array, size_t length, size_t offset=0);
    
    std::string to_string(Sint32* array, size_t length, size_t offset=0);
    
    std::string to_string(Uint32* array, size_t length, size_t offset=0);
    
    std::string to_string(Sint64* array, size_t length, size_t offset=0);
    
    std::string to_string(Uint64* array, size_t length, size_t offset=0);
    
    std::string to_string(float* array, size_t length, size_t offset=0, int precision=-1);
    
    std::string to_string(double* array, size_t length, size_t offset=0, int precision=-1);
    
    
#pragma mark -
#pragma mark STRING TO NUMBER FUNCTIONS

    Uint8 stou8(const std::string& str, std::size_t* pos = 0, int base = 10);
    
    Sint16 stos16(const std::string& str, std::size_t* pos = 0, int base = 10);
    
    Uint16 stou16(const std::string& str, std::size_t* pos = 0, int base = 10);
    
    Sint32 stos32(const std::string& str, std::size_t* pos = 0, int base = 10);
    
    Uint32 stou32(const std::string& str, std::size_t* pos = 0, int base = 10);
    
    Sint64 stos64(const std::string& str, std::size_t* pos = 0, int base = 10);
    
    Uint64 stou64(const std::string& str, std::size_t* pos = 0, int base = 10);
    
    float stof(const std::string& str, std::size_t* pos = 0);
    
    double stod(const std::string& str, std::size_t* pos = 0);

    
#pragma mark -
#pragma mark UTILITY FUNCTIONS

    std::string to_lower(const std::string& str);

    std::string to_upper(const std::string& str);

    std::string trim(const std::string& str);
    
    std::vector<std::string> split(const std::string& str, const std::string& sep);

    std::vector<std::string> split(const std::string& str, const char* sep);
    
    bool isalpha(const std::string& str);

    bool isalphanum(const std::string& str);
    
    bool isnumeric(const std::string& str);

    bool isnumber(const std::string& str);

}

#endif /* __CU_STRINGS_H_ */