opentxs::OTString Class Reference

#include <OTString.hpp>

Inheritance diagram for opentxs::OTString:

Public Types
typedef std::list< std::string >	List
typedef std::map< std::string, std::string >	Map

Public Member Functions
EXPORT	OTString ()
EXPORT	OTString (const OTString &value)
EXPORT	OTString (const OTASCIIArmor &value)
	OTString (const OTSignature &value)
EXPORT	OTString (const OTContract &value)
EXPORT	OTString (const OTIdentifier &value)
	OTString (OTPseudonym &value)
EXPORT	OTString (const char *value)
	OTString (const char *value, size_t size)
EXPORT	OTString (const std::string &value)
virtual EXPORT	~OTString ()
virtual EXPORT void	Release ()
void	Initialize ()
EXPORT OTString &	operator= (OTString rhs)
void	swap (OTString &rhs)
bool	operator> (const OTString &rhs) const
bool	operator< (const OTString &rhs) const
bool	operator<= (const OTString &rhs) const
bool	operator>= (const OTString &rhs) const
EXPORT bool	operator== (const OTString &rhs) const
EXPORT int64_t	ToLong () const
EXPORT uint64_t	ToUlong () const
EXPORT bool	At (uint32_t index, char &c) const
EXPORT bool	Exists () const
EXPORT bool	DecodeIfArmored (bool escapedIsAllowed=true)
EXPORT uint32_t	GetLength () const
EXPORT bool	Compare (const char *compare) const
EXPORT bool	Compare (const OTString &compare) const
EXPORT bool	Contains (const char *compare) const
bool	Contains (const OTString &compare) const
EXPORT const char *	Get () const
EXPORT void	Set (const char *data, uint32_t enforcedMaxLength=0)
EXPORT void	Set (const OTString &data)
EXPORT bool	MemSet (const char *mem, uint32_t size)
EXPORT void	Concatenate (const char *arg,...)
void	Concatenate (const OTString &data)
void	Truncate (uint32_t index)
EXPORT void	Format (const char *fmt,...)
void	ConvertToLowerCase () const
void	ConvertToUpperCase () const
EXPORT bool	TokenizeIntoKeyValuePairs (Map &map) const
EXPORT void	OTfgets (std::istream &ofs)
bool	sgets (char *buffer, uint32_t size)
char	sgetc ()
void	sungetc ()
void	reset ()
void	WriteToFile (std::ostream &ofs) const
void	Release_String ()
EXPORT void	zeroMemory () const

Static Public Member Functions
static bool	vformat (const char *fmt, std::va_list *pvl, std::string &s)
static EXPORT std::string &	trim (std::string &str)
static EXPORT std::string	replace_chars (const std::string &str, const std::string &charsFrom, const char &charTo)
static EXPORT bool	safe_strcpy (char *dest, const char *src, size_t destSize, bool zeroSource=false)
static size_t	safe_strlen (const char *s, size_t max)
static EXPORT int64_t	StringToLong (const std::string &number)
static EXPORT uint64_t	StringToUlong (const std::string &number)

Protected Attributes
uint32_t	length_
uint32_t	position_
char *	data_

Friends
EXPORT friend std::ostream &	operator<< (std::ostream &os, const OTString &obj)

Detailed Description

Definition at line 158 of file OTString.hpp.

Member Typedef Documentation

typedef std::list<std::string> opentxs::OTString::List

Definition at line 161 of file OTString.hpp.

typedef std::map<std::string, std::string> opentxs::OTString::Map

Definition at line 162 of file OTString.hpp.

Constructor & Destructor Documentation

opentxs::OTString::OTString

(

)

Definition at line 786 of file OTString.cpp.

    : length_(0)
    , position_(0)
    , data_(nullptr)
{
    //    Initialize();
}

opentxs::OTString::OTString

(

const OTString &

value

)

Definition at line 857 of file OTString.cpp.

    : length_(0)
    , position_(0)
    , data_(nullptr)
{
    //    Initialize();
    LowLevelSetStr(strValue);
}

opentxs::OTString::OTString

(

const OTASCIIArmor &

value

)

Definition at line 819 of file OTString.cpp.

    : length_(0)
    , position_(0)
    , data_(nullptr)
{
    //    Initialize();

    if (strValue.Exists()) strValue.GetString(*this);
}

opentxs::OTString::OTString

(

const OTSignature &

value

)

Definition at line 837 of file OTString.cpp.

    : length_(0)
    , position_(0)
    , data_(nullptr)
{
    //    Initialize();

    if (strValue.Exists()) strValue.GetString(*this);
}

opentxs::OTString::OTString

(

const OTContract &

value

)

Definition at line 807 of file OTString.cpp.

    : length_(0)
    , position_(0)
    , data_(nullptr)
{
    //    Initialize();

    (const_cast<OTContract&>(theValue)).SaveContractRaw(*this);
}

opentxs::OTString::OTString

(

const OTIdentifier &

value

)

Definition at line 797 of file OTString.cpp.

    : length_(0)
    , position_(0)
    , data_(nullptr)
{
    //    Initialize();

    if (theValue.GetSize() > 0) theValue.GetString(*this);
}

opentxs::OTString::OTString

(

OTPseudonym &

value

)

Definition at line 847 of file OTString.cpp.

    : length_(0)
    , position_(0)
    , data_(nullptr)
{
    //    Initialize();

    theValue.SavePseudonym(*this);
}

opentxs::OTString::OTString

(

const char *

value

)

Definition at line 866 of file OTString.cpp.

    : length_(0)
    , position_(0)
    , data_(nullptr)
{
    //    Initialize();
    LowLevelSet(new_string, 0);
}

opentxs::OTString::OTString	(	const char *	value,
		size_t	size
	)

Definition at line 875 of file OTString.cpp.

    : length_(0)
    , position_(0)
    , data_(nullptr)
{
    //    Initialize();
    LowLevelSet(new_string, static_cast<uint32_t>(sizeLength));
}

opentxs::OTString::OTString

(

const std::string &

value

)

Definition at line 884 of file OTString.cpp.

    : length_(0)
    , position_(0)
    , data_(nullptr)
{
    //    Initialize();
    LowLevelSet(new_string.c_str(), static_cast<uint32_t>(new_string.length()));
}

opentxs::OTString::~OTString ( )

virtual

Definition at line 774 of file OTString.cpp.

{
    Release_String();
}

Member Function Documentation

bool opentxs::OTString::At	(	uint32_t	index,
		char &	c
	)		const

Definition at line 1025 of file OTString.cpp.

{
    if (lIndex < length_) {
        c = data_[lIndex];
        return true;
    }
    else
        return false;
}

bool opentxs::OTString::Compare

(

const char *

compare

)

const

Definition at line 1102 of file OTString.cpp.

{
    if (nullptr == data_ || nullptr == strCompare) {
        return false;
    }

    char* s1 = data_;
    char* s2 = (char*)strCompare;

    for (; *s1 && *s2; s1++, s2++)
        if (*s1 != *s2) return false;

    if (*s1 != *s2) return false;

    return true;
}

bool opentxs::OTString::Compare

(

const OTString &

compare

)

const

Definition at line 1119 of file OTString.cpp.

{
    if (nullptr == data_ || !strCompare.Exists()) {
        return false;
    }

    char* s1 = data_;
    const char* s2 = strCompare.Get();

    for (; *s1 && *s1 != ' '; s1++, s2++)
        if (*s1 != *s2) return false;

    return true;
}

void opentxs::OTString::Concatenate	(	const char *	arg,
			...
	)

Definition at line 1334 of file OTString.cpp.

{
    va_list vl;
    va_start(vl, fmt);

    std::string str_output;

    const bool bSuccess = OTString::vformat(fmt, &vl, str_output);

    va_end(vl);

    if (bSuccess) {
        const OTString strConcat(str_output);

        Concatenate(strConcat);
    }
}

void opentxs::OTString::Concatenate

(

const OTString &

data

)

Definition at line 1353 of file OTString.cpp.

{
    std::string str_output;

    if ((length_ > 0) && (nullptr != data_)) str_output += data_;

    if (strBuf.Exists() && (strBuf.GetLength() > 0)) str_output += strBuf.Get();

    Set(str_output.c_str());
}

bool opentxs::OTString::Contains

(

const char *

compare

)

const

Definition at line 1137 of file OTString.cpp.

{
    if (nullptr == data_ || nullptr == strCompare) {
        return false;
    }

    if (strstr(data_, strCompare)) return true;

    return false;
}

bool opentxs::OTString::Contains

(

const OTString &

compare

)

const

Definition at line 1148 of file OTString.cpp.

{
    if (nullptr == data_ || !strCompare.Exists()) {
        return false;
    }

    if (strstr(data_, strCompare.Get())) return true;

    return false;
}

void opentxs::OTString::ConvertToLowerCase

(

)

const

Definition at line 1171 of file OTString.cpp.

{
    if (data_ == nullptr) {
        return;
    }

    for (char* s1 = data_; *s1; s1++) {
        *s1 = static_cast<char>(tolower(*s1));
    }
}

void opentxs::OTString::ConvertToUpperCase

(

)

const

Definition at line 1182 of file OTString.cpp.

{
    if (data_ == nullptr) {
        return;
    }

    for (char* s1 = data_; *s1; s1++) {
        *s1 = static_cast<char>(toupper(*s1));
    }
}

bool opentxs::OTString::DecodeIfArmored

(

bool

escapedIsAllowed = true

)

Definition at line 1212 of file OTString.cpp.

{
    if (!Exists()) return false;

    bool bArmoredAndALSOescaped = false; // "- -----BEGIN OT ARMORED"
    bool bArmoredButNOTescaped = false;  // "-----BEGIN OT ARMORED"

    if (Contains(OT_BEGIN_ARMORED_escaped)) // check this one first...
    {
        bArmoredAndALSOescaped = true;

        if (!bEscapedIsAllowed) {
            otErr << __FUNCTION__ << ": Armored and escaped value passed in, "
                                     "but escaped are forbidden here. "
                                     "(Returning.)\n";
            return false;
        }
    }
    else if (Contains(OT_BEGIN_ARMORED)) {
        bArmoredButNOTescaped = true;
    }

    const bool bArmored = (bArmoredAndALSOescaped || bArmoredButNOTescaped);

    // Whether the string is armored or not, (-----BEGIN OT ARMORED)
    // either way, we'll end up with the decoded version in this variable:
    //
    std::string str_Trim;

    if (bArmored) // it's armored, we have to decode it first.
    {
        OTASCIIArmor ascTemp;
        if (false ==
            (ascTemp.LoadFromString(
                *this, bArmoredAndALSOescaped, // if it IS escaped or not, this
                                               // variable will be true or false
                                               // to show it.
                // The below szOverride sub-string determines where the content
                // starts, when loading.
                OT_BEGIN_ARMORED))) // Default is:       "-----BEGIN"
        // We're doing this: "-----BEGIN OT ARMORED" (Should worked for
        // escaped as well, here.)
        {
            otErr << __FUNCTION__ << ": Error loading string contents from "
                                     "ascii-armored encoding. "
                                     "Contents: \n" << Get() << "\n";
            return false;
        }
        else // success loading the actual contents out of the ascii-armored
               // version.
        {
            OTString strTemp(ascTemp); // <=== ascii-decoded here.
            std::string str_temp(strTemp.Get(), strTemp.GetLength());
            str_Trim = OTString::trim(
                str_temp); // This is the std::string for the trim process.
        }
    }
    else {
        std::string str_temp(Get(), GetLength());
        str_Trim = OTString::trim(str_temp); // This is the std::string for the
                                             // trim process. (Wasn't armored,
                                             // so here we use it as passed in.)
    }

    // At this point, str_Trim contains the actual contents, whether they
    // were originally ascii-armored OR NOT. (And they are also now trimmed,
    // either way.)

    Release();

    if (str_Trim.size() > 0) Set(str_Trim.c_str());

    return Exists();
}

bool opentxs::OTString::Exists

(

void

)

const

Definition at line 1035 of file OTString.cpp.

{
    return (nullptr != data_) ? true : false;
}

void opentxs::OTString::Format	(	const char *	fmt,
			...
	)

Definition at line 1319 of file OTString.cpp.

{
    va_list vl;
    va_start(vl, fmt);

    std::string str_output;

    const bool bSuccess = OTString::vformat(fmt, &vl, str_output);

    va_end(vl);

    if (bSuccess) Set(str_output.c_str());
}

const char * opentxs::OTString::Get

(

void

)

const

Definition at line 1045 of file OTString.cpp.

{
    return (nullptr != data_) ? const_cast<const char*>(data_) : "";
}

uint32_t opentxs::OTString::GetLength

(

void

)

const

Definition at line 1040 of file OTString.cpp.

{
    return length_;
}

void opentxs::OTString::Initialize

(

)

Definition at line 779 of file OTString.cpp.

{
    length_ = 0;
    position_ = 0;
    data_ = nullptr;
}

bool opentxs::OTString::MemSet	(	const char *	mem,
		uint32_t	size
	)

Definition at line 967 of file OTString.cpp.

{
    Release();
    // -------------------
    if ((nullptr == pMem) || (theSize < 1)) return true;

    char* str_new = new char[theSize + 1]; // then we allocate 11
    OT_ASSERT(nullptr != str_new);
    // -------------------
    OTPassword::zeroMemory(str_new, theSize + 1);

    //  void * OTPassword::safe_memcpy(void* dest,
    //                                 uint32_t dest_size,
    //                                 const
    //                                 void   * src,
    //                                 uint32_t src_length,
    //                                 bool     bZeroSource)

    OTPassword::safe_memcpy(static_cast<void*>(str_new), theSize + 1, pMem,
                            theSize);
    //    memcpy(static_cast<void*>(str_new), pMem, theSize); // then we copy 10
    // bytes

    // todo optimize: This is probably superfluous due to the zeroMemory above.
    // Then again, we might want to remove that, and then keep this.
    str_new[theSize] = '\0'; // add null-terminator. (I deliberately made this
                             // buffer 1 byte larger so I could put the 0 at the
                             // end.) Here the index[10] is the 11th byte, since
                             // we're counting from 0.

    // Calculate the length (in case there was a null terminator in the
    // middle...)
    // This way we're guaranteed to have the correct length.
    //
    uint32_t nLength = static_cast<uint32_t>(
        OTString::safe_strlen(str_new, static_cast<size_t>(theSize)));
    str_new[nLength] = '\0'; // This SHOULD be superfluous as well...

    length_ = nLength; // the length doesn't count the 0.
    data_ = str_new;

    return true;
}

bool opentxs::OTString::operator<

(

const OTString &

rhs

)

const

Definition at line 477 of file OTString.cpp.

{
    if (length_ == 0) {
        return (true);
    }
    if (s2.length_ == 0) {
        return (false);
    }
    if (strcmp(data_, s2.data_) >= 0) {
        return (false);
    }
    return (true);
}

bool opentxs::OTString::operator<=

(

const OTString &

rhs

)

const

Definition at line 491 of file OTString.cpp.

{
    if (length_ == 0) {
        return (true);
    }
    if (s2.length_ == 0) {
        return (false);
    }
    if (strcmp(data_, s2.data_) > 0) {
        return (false);
    }
    return (true);
}

OTString & opentxs::OTString::operator=

(

OTString

rhs

)

Definition at line 1011 of file OTString.cpp.

{
    if (this != &rhs) // Compare addresses.
        swap(rhs);    // Only swap if they are different objects.
    return *this;
}

bool opentxs::OTString::operator==

(

const OTString &

rhs

)

const

Definition at line 1077 of file OTString.cpp.

{
    // If they are not the same length, return false
    if (length_ != s2.length_) {
        return (false);
    }

    // At this point we know they are at least the same length.
    // Next--are they both 0? If they are both 0, return true
    if (length_ == 0 && s2.length_ == 0) {
        return (true);
    }

    // At this point we have 2 identical-length strings.
    // Now we call strcmp and convert it to true or false.
    if (strcmp(data_, s2.data_) ==
        0) { // TODO security: use a replacement for strcmp.
        return (true);
    }
    return (false);
}

bool opentxs::OTString::operator>

(

const OTString &

rhs

)

const

Definition at line 463 of file OTString.cpp.

{
    if (s2.length_ == 0) {
        return (true);
    }
    if (length_ == 0) {
        return (false);
    }
    if (strcmp(data_, s2.data_) <= 0) {
        return (false);
    }
    return (true);
}

bool opentxs::OTString::operator>=

(

const OTString &

rhs

)

const

Definition at line 505 of file OTString.cpp.

{
    if (s2.length_ == 0) {
        return (true);
    }
    if (length_ == 0) {
        return (false);
    }
    if (strcmp(data_, s2.data_) < 0) {
        return (false);
    }
    return (true);
}

void opentxs::OTString::OTfgets

(

std::istream &

ofs

)

Definition at line 1159 of file OTString.cpp.

{
    std::stringbuf sb;
    ifs.get(sb); // delimiter defaults to '\n'

    if (ifs.good()) {
        const std::string str_output = sb.str();

        Set(str_output.c_str());
    }
}

void opentxs::OTString::Release ( void  )

virtual

Definition at line 765 of file OTString.cpp.

{
    Release_String();

    // no need to use ot_super here, since OTString is a "base class."
}

void opentxs::OTString::Release_String

(

void

)

Definition at line 751 of file OTString.cpp.

{
    if (nullptr != data_) {
        // for security purposes.
        //
        OTPassword::zeroMemory(data_, length_);
        //        memset(data_, 0, length_);
        delete[] data_;
    }
    data_ = nullptr;
    position_ = 0;
    length_ = 0;
}

std::string opentxs::OTString::replace_chars ( const std::string &  str, const std::string &  charsFrom, const char &  charTo  )

static

Definition at line 420 of file OTString.cpp.

{
    std::string l_str(str);
    size_t found;

    found = str.find_first_of(charsFrom);
    while (found != std::string::npos) {
        l_str[found] = charTo;
        found = str.find_first_of(charsFrom, found + 1);
    }
    return l_str;
}

void opentxs::OTString::reset

(

void

)

Definition at line 1464 of file OTString.cpp.

{
    position_ = 0;
}

bool opentxs::OTString::safe_strcpy ( char *  dest, const char *  src, size_t  destSize, bool  zeroSource = false  )

static

Definition at line 353 of file OTString.cpp.

{
    // Make sure they don't overlap.
    //
    OT_ASSERT_MSG(false == ((src > dest) && (src < (dest + dest_size))),
                  "ASSERT: safe_strcpy: Unexpected memory overlap.\n");

    const size_t src_length = OTString::safe_strlen(src, MAX_STRING_LENGTH);

    OT_ASSERT_MSG(dest_size > src_length, "OTString::safe_strcpy: ASSERT: "
                                          "src_length must be less than "
                                          "dest_size.\n");

#ifdef _WIN32
    bool bSuccess = (0 == strcpy_s(dest, dest_size, src));
#else
    size_t src_cpy_length = strlcpy(dest, src, dest_size);
    bool bSuccess = (src_length == src_cpy_length);
#endif

    // Notice: we don't zero out the source unless we were successful (AND
    // unless we were asked to.)
    //
    if (bSuccess && bZeroSource)
        OTPassword::zeroMemory(const_cast<char*>(src),
                               static_cast<uint32_t>(src_length));

    return bSuccess;
}

size_t opentxs::OTString::safe_strlen ( const char *  s, size_t  max  )

static

Definition at line 388 of file OTString.cpp.

{
    OT_ASSERT_MSG(max <= MAX_STRING_LENGTH, "OT_String::safe_strlen: ASSERT: "
                                            "max length passed in is longer "
                                            "than allowed.\n");

    return strnlen(s, max);
}

void opentxs::OTString::Set	(	const char *	data,
		uint32_t	enforcedMaxLength = 0
	)

Definition at line 1055 of file OTString.cpp.

{
    if (new_string == data_) // Already the same string.
        return;

    Release();

    if (nullptr == new_string) return;

    LowLevelSet(new_string, nEnforcedMaxLength);
}

void opentxs::OTString::Set

(

const OTString &

data

)

Definition at line 1067 of file OTString.cpp.

{
    if (this == &strBuf) // Already the same string.
        return;

    Release();

    LowLevelSetStr(strBuf);
}

char opentxs::OTString::sgetc

(

void

)

Definition at line 1443 of file OTString.cpp.

{
    char answer;

    if (position_ >= length_) {
        return EOF;
    }
    answer = (char)(*(data_ + position_));

    ++position_;

    return answer;
}

bool opentxs::OTString::sgets	(	char *	buffer,
		uint32_t	size
	)

Definition at line 1380 of file OTString.cpp.

{
    if (nullptr == szBuffer) {
        return false;
    }

    if (position_ >= length_) return false;

    uint32_t lIndex = 0;
    char* pChar = (char*)(data_ + position_);

    // while *pChar isn't at the end of the source string,
    // and lIndex hasn't reached the end of the destination buffer,
    //
    while (0 != *pChar && (position_ < length_) &&
           lIndex < (nBufSize - 1)) // the -1 leaves room for a forced null
                                    // terminator.
    {
        // If the current character isn't a newline, then copy it...
        if ('\n' != *pChar) {
            szBuffer[lIndex] = *pChar;
            lIndex++;    // increment the buffer
            position_++; // increment the string's internal memory of where it
                         // stopped.
            pChar++;     // increment this for convenience (could calcuate from
                         // position)
        }
        // Until we reach a newline...
        else {
            // IT'S A NEWLINE!

            szBuffer[lIndex] =
                0; // destination buffer, this is the end of the line for him.
            position_++; // This still moves past the newline, so the next
                         // call will get the next
                         // string.
            // lIndex does NOT increment here because we reach the end of this
            // string.
            // neither does pChar. These local variables go away since we are
            // returning.

            if (0 == *(pChar + 1))
                return false;
            else
                return true; // there was more to read, but we stopped at the
                             // newline.
        }
    }

    // Need to add the nullptr terminator.
    szBuffer[lIndex] = 0;

    // We reached the end of the string.
    // EOF. So we return false to tell the caller not to bother calling again.
    if (0 == *pChar) {
        return false;
    }

    // Obviously if *pChar isn't at the end, then there was more to read,
    // but the buffer was full, so we return true.
    return true;
}

int64_t opentxs::OTString::StringToLong ( const std::string &  number )

static

Definition at line 677 of file OTString.cpp.

{
    if (strNumber.size() == 0) return 0;

    int64_t v = 0;
    size_t i = 0;

    char sign = (strNumber[0] == '-' || strNumber[0] == '+')
                    ? (++i, strNumber[0])
                    : '+';

    for (; i < strNumber.size(); ++i) {
        if (strNumber[i] < '0' || strNumber[i] > '9') break;
        v = ((v * 10) + (strNumber[i] - '0'));
    }
    return ((0 == v) ? 0 : ((sign == '-') ? -v : v));
}

uint64_t opentxs::OTString::StringToUlong ( const std::string &  number )

static

Definition at line 662 of file OTString.cpp.

{
    if (strNumber.size() == 0) return 0;

    uint64_t v = 0;
    size_t i = 0;

    for (; i < strNumber.size(); ++i) {
        if (strNumber[i] < '0' || strNumber[i] > '9') break;
        v = ((v * 10) + (strNumber[i] - '0'));
    }
    return ((0 == v) ? 0 : v);
}

void opentxs::OTString::sungetc

(

void

)

Definition at line 1457 of file OTString.cpp.

{
    if (position_ > 0) {
        --position_;
    }
}

void opentxs::OTString::swap

(

OTString &

rhs

)

Definition at line 1018 of file OTString.cpp.

{
    std::swap(length_, rhs.length_);
    std::swap(position_, rhs.position_);
    std::swap(data_, rhs.data_);
}

bool opentxs::OTString::TokenizeIntoKeyValuePairs

(

Map &

map

)

const

Definition at line 550 of file OTString.cpp.

{
#if !(defined(_WIN32) || defined(TARGET_OS_IPHONE) || defined(ANDROID))
    // fabcy-pansy parser that allows for multiple level of quotes nesting and
    // escaped quotes
    if (!Exists()) return true;

    wordexp_t exp_result;

    exp_result.we_wordc = 0;
    exp_result.we_wordv = nullptr;
    exp_result.we_offs = 0;

    if (wordexp(Get(), &exp_result, 0)) // non-zero == failure.
    {
        otErr << "OTString::TokenizeIntoKeyValuePairs: Error calling wordexp() "
                 "(to expand user-defined script args.)\nData: " << *this
              << "\n";
        //        wordfree(&exp_result);
        return false;
    }

    if ((exp_result.we_wordc > 0) && (nullptr != exp_result.we_wordv)) {
        // wordexp tokenizes by space (as well as expands, which is why I'm
        // using it.)
        // Therefore we need to iterate through the tokens, and create a single
        // string
        // with spaces between the tokens.
        //
        for (uint32_t i = 0;
             (i < (exp_result.we_wordc - 1)) &&
                 (exp_result.we_wordv[i] != nullptr) &&
                 (exp_result.we_wordv[i + 1] !=
                  nullptr); // odd man out. Only PAIRS of strings are processed!
             i += 2) {
            const std::string str_key = exp_result.we_wordv[i];
            const std::string str_val = exp_result.we_wordv[i + 1];

            otInfo << __FUNCTION__ << ":Parsed: " << str_key << " = " << str_val
                   << "\n";
            mapOutput.insert(
                std::pair<std::string, std::string>(str_key, str_val));
        }

        wordfree(&exp_result);
    }

    return true;
#else
    // simple parser that allows for one level of quotes nesting but no escaped
    // quotes
    if (!Exists()) return true;

    const char* txt = Get();
    std::string buf = txt;
    for (int32_t i = 0; txt[i] != 0;) {
        while (txt[i] == ' ') i++;
        int32_t k = i;
        int32_t k2 = i;
        if (txt[i] == '\'' || txt[i] == '"') {
            // quoted string
            char quote = txt[i++];
            k = i;
            while (txt[i] != quote && txt[i] != 0) i++;
            if (txt[i] != quote) {
                otErr << __FUNCTION__ << ": Unmatched quotes in: " << txt
                      << "\n";
                return false;
            }
            k2 = i;
            i++;
        }
        else {
            while (txt[i] != ' ' && txt[i] != 0) i++;
            k2 = i;
        }
        const std::string key = buf.substr(k, k2 - k);

        while (txt[i] == ' ') i++;
        int32_t v = i;
        int32_t v2 = i;
        if (txt[i] == '\'' || txt[i] == '"') {
            // quoted string
            char quote = txt[i++];
            v = i;
            while (txt[i] != quote && txt[i] != 0) i++;
            if (txt[i] != quote) {
                otErr << __FUNCTION__ << ": Unmatched quotes in: " << txt
                      << "\n";
                return false;
            }
            v2 = i;
            i++;
        }
        else {
            while (txt[i] != ' ' && txt[i] != 0) i++;
            v2 = i;
        }
        const std::string value = buf.substr(v, v2 - v);

        if (key.length() != 0 && value.length() != 0) {
            otInfo << __FUNCTION__ << ":Parsed: " << key << " = " << value
                   << "\n";
            mapOutput.insert(std::pair<std::string, std::string>(key, value));
        }
    }
    return true;
#endif
}

int64_t opentxs::OTString::ToLong

(

)

const

Definition at line 702 of file OTString.cpp.

{
    const std::string str_number(Get());

    return OTString::StringToLong(str_number);
}

uint64_t opentxs::OTString::ToUlong

(

)

const

Definition at line 695 of file OTString.cpp.

{
    const std::string str_number(Get());

    return OTString::StringToUlong(str_number);
}

std::string & opentxs::OTString::trim ( std::string &  str )

static

Definition at line 398 of file OTString.cpp.

{
    std::string whitespaces(" \t\f\v\n\r");

    size_t found = str.find_first_not_of(whitespaces);

    if (found != std::string::npos) {
        str.erase(0, found);
    }

    found = str.find_last_not_of(whitespaces);

    if (found != std::string::npos) {
        str.erase(found + 1);
    }

    //    otErr << "(DEBUGGING OTString.cpp) CONTRACT HAS BEEN TRIMMED!!!
    // RESULT: \n\n***BEGIN TRIM DATA:%s******END TRIM DATA\n\n",
    //                  str.c_str()); // todo temp remove
    return str;
}

void opentxs::OTString::Truncate

(

uint32_t

index

)

Definition at line 1193 of file OTString.cpp.

{
    OTString strTruncated;

    strTruncated.Set(Get(), lAt);

    Set(strTruncated);
}

bool opentxs::OTString::vformat ( const char *  fmt, std::va_list *  pvl, std::string &  s  )

static

Definition at line 191 of file OTString.cpp.

{
    OT_ASSERT(nullptr != fmt);
    OT_ASSERT(nullptr != pvl);

    int32_t size = 0;
    int32_t nsize = 0;
    char* buffer = nullptr;
    va_list args;

#ifdef _WIN32
    va_list args_2 = *pvl; // windows only.

    args = *pvl;
    size = _vscprintf(fmt, args) + 1;
#else
    va_copy(args, *pvl);
    size = 512;
#endif

    buffer = new char[size + 100];
    OT_ASSERT(nullptr != buffer);
    OTPassword::zeroMemory(buffer, size + 100);

#ifdef _WIN32
    nsize = vsnprintf_s(buffer, size, size, fmt, args_2);
#else
    nsize = vsnprintf(buffer, size, fmt, args);
    va_end(args);
#endif

    OT_ASSERT(nsize >= 0);

    // fail -- delete buffer and try again
    // If nsize was 1024 bytes, then that would mean that it printed 1024
    // characters,
    // even though the actual string must be 1025 in length (to have room for
    // the null
    // terminator.)
    // If size, the ACTUAL buffer, was 1024 (that is, if size <= nsize) then
    // size would
    // LACK the necessary space to store the 1025th byte containing the null
    // terminator.
    // Therefore we are forced to delete the buffer and make one that is
    // nsize+1, so that
    // it will be 1025 bytes and thus have the necessary space for the
    // terminator
    //
    if (size <= nsize) {
        size = nsize + 1;
        delete[] buffer;
        buffer = new char[size + 100];
        OT_ASSERT(nullptr != buffer);
        OTPassword::zeroMemory(buffer, size + 100);

#ifdef _WIN32
        nsize = vsnprintf_s(buffer, size, size, fmt, *pvl);
        va_end(args);
        va_end(args_2);
#else
        nsize = vsnprintf(buffer, size, fmt, *pvl);
#endif

        OT_ASSERT(nsize >= 0);
    }
    OT_ASSERT(size > nsize);

    str_Output = buffer;
    delete[] buffer;
    buffer = nullptr;
    return true;
}

void opentxs::OTString::WriteToFile

(

std::ostream &

ofs

)

const

Definition at line 1364 of file OTString.cpp.

{
    fwrite_string(ofs, data_);
}

void opentxs::OTString::zeroMemory

(

)

const

Definition at line 744 of file OTString.cpp.

{
    if (nullptr != data_) {
        OTPassword::zeroMemory(data_, length_);
    }
}

Friends And Related Function Documentation

EXPORT friend std::ostream& operator<< ( std::ostream &  os, const OTString &  obj  )

friend

Definition at line 150 of file OTString.cpp.

{
    os << obj.Get();
    return os;
}

Member Data Documentation

char* opentxs::OTString::data_

protected

Definition at line 277 of file OTString.hpp.

uint32_t opentxs::OTString::length_

protected

Definition at line 275 of file OTString.hpp.

uint32_t opentxs::OTString::position_

protected

Definition at line 276 of file OTString.hpp.

---

The documentation for this class was generated from the following files:

• /usr/local/src/opentxs/include/opentxs/core/OTString.hpp
• /usr/local/src/opentxs/src/core/OTString.cpp