#include <KKStr.h>

Classes
class	LessCaseInsensitiveOperator

Public Types
typedef const KKStr *	KKStrConstPtr

typedef KKStr *	KKStrPtr

Public Member Functions
	KKStr ()

	KKStr (const char *str)

	KKStr (const KKStr &str)
	Copy Constructor. More...

	KKStr (KKStr &&str)

	KKStr (kkint32 size)
	Creates a KKStr object that pre-allocates space for 'size' characters. More...

	KKStr (double d, kkint32 precision)
	summary>Constructs a KKStr instance form a stl::string instance. More...

	KKStr (const std::string &s)

	KKStr (const char *src, kkuint32 startPos, kkuint32 endPos)
	Constructs a KKStr instance from a sub-string of 'src'. More...

	~KKStr ()

void	Append (const char *buff)

void	Append (const char *buff, kkuint32 buffLen)

void	Append (char ch)

void	Append (const KKStr &str)

void	Append (const std::string &str)

void	AppendInt32 (kkint32 i)

void	AppendUInt32 (kkuint32 i)

const char *	c_str ()

bool	CharInStr (char ch)

void	ChopFirstChar ()

void	ChopLastChar ()

kkint32	Compare (const KKStr &s2) const

kkint32	Compare (const std::string &s2) const
	Compares with STL string. More...

kkint32	CompareIgnoreCase (const KKStr &s2) const
	Compares with another KKStr, ignoring case. More...

kkint32	CompareIgnoreCase (const std::string &s2) const

kkint32	CompareIgnoreCase (const char *s2) const
	summary>Compares to Strings and returns -1, 0, or 1, indicating if less than, equal, or greater. More...

kkint32	CompareTo (const KKStr &s2) const

bool	Contains (const KKStr &value)

bool	Contains (const char *value)

kkint32	CountInstancesOf (char ch) const

const char *	data ()

KKStr	DecodeQuotedStr () const
	Trees this KKSr instance as a QuotedStr; decodes escape sequences such as '\', '', ' ', '', and '\0' into original characters. More...

bool	Empty () const

bool	EndsWith (const KKStr &value)

bool	EndsWith (const char *value)

bool	EndsWith (const KKStr &value, bool ignoreCase)

bool	EndsWith (const char *value, bool ignoreCase)

char	EnterStr ()

bool	EqualIgnoreCase (const KKStr &s2) const

bool	EqualIgnoreCase (const KKStrConstPtr s2) const

bool	EqualIgnoreCase (const char *s2) const

char	ExtractChar ()
	Removes the first character from the string and returns it to the caller. More...

char	ExtractLastChar ()
	Removes the last character from the string and returns it to the caller. More...

KKStr	ExtractQuotedStr (const char *delChars, bool decodeEscapeCharacters)

KKStr	ExtractToken (const char *delStr="\n\t\r ")

KKStr	ExtractToken2 (const char *delStr="\n\t\r ")
	Extract first Token from the string. More...

bool	ExtractTokenBool (const char *delStr)
	Extract the next token from the string assuming that it is a logical True/False value. More...

double	ExtractTokenDouble (const char *delStr)

kkint32	ExtractTokenInt (const char *delStr)

kkuint32	ExtractTokenUint (const char *delStr)

kkuint64	ExtractTokenUint64 (const char *delStr)

kkint32	Find (const KKStr &str, kkint32 pos=0) const
	Will return the position where the 1st instance of 'str' after 'pos' occurs or -1 if not found. More...

kkint32	Find (const char *s, kkint32 pos, kkint32 n) const

kkint32	Find (const char *s, kkint32 pos=0) const

kkint32	Find (char c, kkint32 pos=0) const

char	FirstChar () const

void	FreeUpUnUsedSpace ()

KKStr	GetNextToken2 (const char *delStr="\n\t\r ") const
	Retrieves the first token in the string without removing any characters. More...

kkint32	InstancesOfChar (char ch) const

char	LastChar () const

void	LeftPad (kkint32 width, uchar ch= ' ')
	pads the string with enough 'ch' characters on the left side until the string is as long as 'width' characters. More...

kkuint32	Len () const
	Returns the number of characters in the string. More...

kkint32	LocateCharacter (char ch) const
	Returns index of 1st occurrence of 'ch' otherwise -1. More...

kkint32	LocateLastOccurrence (char ch) const
	Returns index of last occurrence of 'ch' otherwise -1. More...

kkint32	LocateLastOccurrence (const KKStr &s) const
	Returns index of last occurrence of 's' otherwise -1. More...

kkint32	LocateNthOccurrence (char ch, kkint32 x) const

kkint32	LocateStr (const KKStr &searchStr) const
	Returns index of 1st occurrence of 'searchStr' otherwise -1. More...

void	LopOff (kkint32 lastCharPos)
	Trims off all characters after the 'lastCharPos' index; to make an empty string you would have to specify -1. More...

void	Lower ()
	Make all characters in the String into lower case. More...

KKStr	MaxLen (kkuint32 maxLen) const

kkuint32	MaxLenSupported () const

kkint32	MemoryConsumedEstimated () const

bool	operator!= (const KKStr &right) const

bool	operator!= (KKStrConstPtr right) const

bool	operator!= (const char *rtStr) const

bool	operator!= (const std::string right) const

KKStr	operator+ (const char *right) const

KKStr	operator+ (const KKStr &right) const

KKStr	operator+ (kkint16 right) const

KKStr	operator+ (kkuint16 right) const

KKStr	operator+ (kkint32 right) const

KKStr	operator+ (kkuint32 right) const

KKStr	operator+ (kkint64 right) const

KKStr	operator+ (kkuint64 right) const

KKStr	operator+ (float right) const

KKStr	operator+ (double right) const

KKStr &	operator+= (const char *right)

KKStr &	operator+= (const KKStr &right)

KKStr &	operator+= (kkint16 right)

KKStr &	operator+= (kkuint16 right)

KKStr &	operator+= (kkint32 right)

KKStr &	operator+= (kkuint32 right)

KKStr &	operator+= (kkint64 right)

KKStr &	operator+= (kkuint64 right)

KKStr &	operator+= (float right)

KKStr &	operator+= (double right)

bool	operator< (const KKStr &right) const

KKStr &	operator<< (const char *right)

KKStr &	operator<< (const KKStr &right)

KKStr &	operator<< (KKStr &&right)

KKStr &	operator<< (char right)

KKStr &	operator<< (kkint16 right)

KKStr &	operator<< (kkuint16 right)

KKStr &	operator<< (kkint32 right)

KKStr &	operator<< (kkuint32 right)

KKStr &	operator<< (kkint64 right)

KKStr &	operator<< (kkuint64 right)

KKStr &	operator<< (float right)

KKStr &	operator<< (double right)

KKStr &	operator<< (std::ostream &(*mf)(std::ostream &))

bool	operator<= (const KKStr &right) const

KKStr &	operator= (const KKStr &src)

KKStr &	operator= (KKStr &&src)

KKStr &	operator= (const char *src)

KKStr &	operator= (kkint32 right)

KKStr &	operator= (const std::vector< KKStr > &right)

bool	operator== (const KKStr &right) const

bool	operator== (KKStrConstPtr right) const

bool	operator== (const char *rtStr) const

bool	operator== (const std::string right) const

bool	operator> (const KKStr &right) const

bool	operator>= (const KKStr &right) const

char	operator[] (kkint16 i) const

char	operator[] (kkuint16 i) const

char	operator[] (kkint32 i) const

char	operator[] (kkuint32 i) const

VectorKKStr	Parse (const char *delStr="\n\r\t, ") const
	Will break up the contents of the string into tokens where one of the characters in 'delStr' separates each token. More...

KKStr	QuotedStr () const
	Returns a quoted version of string where special characters Line-Feed, Carriage Return, and Tab, are encoded as escape sequences. More...

void	ReadXML (XmlStream &s, XmlTagConstPtr tag, VolConstBool &cancelFlag, RunLog &log)

void	RightPad (kkint32 width, char ch= ' ')
	Pads string on the right side with specified character so that the string will be of specified length. More...

VectorKKStr	Split (const char *delStr="\n\r\t, ") const
	Breaks up the contents of the string into tokens where the characters in 'delStr' acts as separates each token. More...

VectorKKStr	Split (char del) const
	Splits the string up into tokens using 'del' as the separator returning them in a vector. More...

bool	StartsWith (const KKStr &value) const

bool	StartsWith (const char *value) const

bool	StartsWith (const KKStr &value, bool ignoreCase) const

bool	StartsWith (const char *value, bool ignoreCase) const

const char *	Str () const
	Returns a pointer to a ascii string. More...

bool	StrInStr (const KKStr &searchField) const
	Searches for the occurrence of 'searchField' and where in the string. If found will return 'true' otherwise 'false'. More...

void	StrReplace (char *dest, const char src)
	Replaces the contents of dest with src. More...

wchar_t *	StrWide () const

KKStr	SubStrPart (kkint32 firstChar) const
	returns a SubString consisting of all characters starting at index 'firstChar' until the end of the string. More...

KKStr	SubStrPart (kkint32 firstChar, kkint32 lastChar) const
	returns a SubString consisting of all characters starting at index 'firstChar' and ending at 'lastIndex' More...

KKStr	Tail (kkint32 tailLen) const
	Returns a string consisting of the 'tailLen' characters from the end of the string. More...

bool	ToBool () const
	Returns the bool equivalent of the string, ex 'Yes' = true, 'No' = false, 'True' = true, etc. More...

double	ToDouble () const

float	ToFloat () const

kkint32	ToInt () const

kkint16	ToInt16 () const

kkint32	ToInt32 () const

kkint64	ToInt64 () const

KKStrPtr	ToKKStrPtr () const

double	ToLatitude () const
	Processes string as if a standard latitude; ex: "15:32.2S" = -15.53833. More...

long	ToLong () const

double	ToLongitude () const
	Processes string as if a standard longitude; ex: "95:32.2E" = 95.53833. More...

KKStr	ToLower () const

float	ToPercentage () const

KKStr	ToQuotedStr () const

kkuint32	ToUint () const

kkuint32	ToUint32 () const

kkuint64	ToUint64 () const

ulong	ToUlong () const

KKStr	ToUpper () const

VectorInt32 *	ToVectorInt32 () const

wchar_t *	ToWchar_t () const

KKStr	ToXmlStr () const

KKStr &	Trim (const char *whiteSpaceChars="\n\r\t ")

void	TrimLeft (const char *whiteSpaceChars="\n\r\t ")

KKStr &	TrimRight (const char *whiteSpaceChars="\n\r\t ")

void	TrimRightChar ()

void	Upper ()
	Converts all characters in string to their Upper case equivalents via 'toupper'. More...

bool	ValidInt (kkint32 &value)

bool	ValidMoney (float &value) const

bool	ValidNum (double &value) const

KKStr	Wide (kkint32 width, char dir= 'R') const
	Pads the string with spaces so that it is exactly 'width' characters long. Can pad either left, right, or center as specified by 'dir'. If KKStr Already greater than 'width' will truncate new string. /summary> param name='width'> Width of KKStr; will pad KKStr with spaces until it is width long. param name='dir'>Direction to pad from 'L' - Pad on the left side, 'R' - Pad on the right side, and 'C' - Pad on left and Right so that text is centered. More...

void	WriteXML (const KKStr &varName, std::ostream &o) const

Static Public Member Functions
static kkint32	CompareStrings (const KKStr &s1, const KKStr &s2)
	Compares to Strings and returns -1, 0, or 1, indicating if less than, equal, or greater. More...

static KKStr	Concat (const char **values)

static KKStr	Concat (const VectorKKStr &values)

static KKStr	Concat (const std::vector< std::string > &values)
	Concatenates the list of 'std::string' strings. More...

static const KKStr &	EmptyStr ()
	Static method that returns an Empty String. More...

static void	MemCpy (void dest, void src, kkuint32 size)

static void	MemSet (void *dest, kkuint8 byte, kkuint32 size)

static KKStr	Spaces (kkint32 c)
	Returns a string of spaces 'c' characters long. More...

static const char *	Str (const char *s)

static void	StrCapitalize (char *str)

static const char *	StrChr (const char *str, int ch)

static kkint32	StrCompareIgnoreCase (const char s1, const char s2)

static void	StrDelete (char **str)

static bool	StrEqual (const char s1, const char s2)

static bool	StrEqualN (const char s1, const char s2, kkuint32 len)

static bool	StrEqualNoCase (const char s1, const char s2)

static bool	StrEqualNoCaseN (const char s1, const char s2, kkuint32 len)

static bool	StrInStr (const char target, const char searchStr)

Detailed Description

Definition at line 80 of file KKStr.h.

Member Typedef Documentation

typedef const KKStr* KKB::KKStr::KKStrConstPtr

Definition at line 84 of file KKStr.h.

typedef KKStr* KKB::KKStr::KKStrPtr

Definition at line 83 of file KKStr.h.

Constructor & Destructor Documentation

KKStr::KKStr ( )

Definition at line 527 of file KKStr.cpp.

Referenced by KKB::Application::Application(), KKMLL::Attribute::Attribute(), KKB::BmpImage::BmpImage(), KKMLL::ClassificationBiasMatrix::ClassificationBiasMatrix(), KKMLL::Classifier2::Classifier2(), KKB::Configuration::Configuration(), ExtractToken2(), KKMLL::FeatureVector::FeatureVector(), KKMLL::FeatureVectorList::FeatureVectorList(), KKB::KKException::KKException(), KKMLL::Model::Model(), KKMLL::ModelParam::ModelParam(), KKMLL::ModelParamDual::ModelParamDual(), KKMLL::NormalizationParms::NormalizationParms(), KKMLL::Orderings::Orderings(), KKB::Raster::Raster(), KKLSC::ScannerFile::ScannerFile(), KKLSC::ScannerFileEntry::ScannerFileEntry(), KKMLL::SVMModel::SVMModel(), KKMLL::SVMparam::SVMparam(), KKMLL::TrainingClass::TrainingClass(), KKMLL::TrainingClassList::TrainingClassList(), KKMLL::TrainingConfiguration2::TrainingConfiguration2(), KKMLL::TrainingProcess2::TrainingProcess2(), KKB::XmlStream::XmlStream(), and KKB::XmlTag::XmlTag().

              : 
    val (NULL)
 {
   AllocateStrSpace (10);
   val[0] = 0;
   len = 0;
 }

KKStr::~KKStr ( )

Definition at line 833 of file KKStr.cpp.

 {
   if  (val)
   {
     delete [] val;
     val = NULL;
   }
 }

KKStr::KKStr ( const char * str )

Definition at line 537 of file KKStr.cpp.

References KKB::STRCOPY().

Referenced by KKMLL::TrainingConfiguration2::Factory::Factory(), KKB::KKException::KKException(), KKMLL::FeatureFileIO::LoadInSubDirectoryTree(), KKB::operator+(), KKB::osGetCurrentDirectory(), KKB::osGetFileNamePartOfFile(), KKB::osGetPathPartOfFile(), KKB::KKStrList::ParseDelimitedString(), KKMLL::ConfusionMatrix2::PrintConfusionMatrix(), KKMLL::ConfusionMatrix2::PrintConfusionMatrixHTML(), KKMLL::ConfusionMatrix2::PrintConfusionMatrixLatexTable(), KKMLL::ConfusionMatrix2::PrintConfusionMatrixNarrow(), KKMLL::ConfusionMatrix2::PrintConfusionMatrixTabDelimited(), KKB::StrFormatDouble(), KKB::StrFormatInt64(), KKB::StrFromDouble(), KKB::StrFromFloat(), KKB::StrFromInt16(), KKB::StrFromInt32(), KKB::StrFromInt64(), KKB::StrFromUint16(), KKB::StrFromUint32(), KKB::StrFromUint64(), KKMLL::TrainingConfiguration2::TrainingConfiguration2(), KKMLL::TrainingProcess2::TrainingProcess2(), and Wide().

                              :
         val (NULL)
 {
   if  (!str)
   {
     AllocateStrSpace (1);
     val[0] = 0;
     len = 0;
     return;
   }
   
   kkuint32  newLen = (kkuint32)strlen (str);
   AllocateStrSpace (newLen + 1);
 
   STRCOPY (val, (kkuint16)allocatedSize, str);
 
   len = (kkuint16)newLen;
 }

KKStr::KKStr ( const KKStr & str )

Copy Constructor.

Definition at line 561 of file KKStr.cpp.

References Concat(), KKB::KKException::KKException(), operator+(), KKB::operator+(), and KKB::StrFromUint16().

Referenced by KKMLL::Attribute::AddANominalValue(), KKB::Application::Application(), KKMLL::Attribute::Attribute(), KKB::BmpImage::BmpImage(), KKB::Chart::Chart(), KKMLL::ClassificationBiasMatrix::ClassificationBiasMatrix(), KKMLL::SizeDistribution::ClassTotals::ClassTotals(), KKB::CmdLineExpander::CmdLineExpander(), KKB::Configuration::Configuration(), KKB::Configuration::ConfSection::ConfSection(), KKMLL::BinaryClassParms::CreateFromTabDelStr(), KKMLL::TrainingConfiguration2::Factory::Factory(), KKMLL::FactoryFVProducer::FactoryFVProducer(), KKMLL::FeatureFileIO::FeatureFileIO(), KKMLL::FeatureVector::FeatureVector(), KKMLL::FeatureVectorList::FeatureVectorList(), KKMLL::FeatureVectorProducer::FeatureVectorProducer(), KKB::PointList::FromDelStr(), KKMLL::FeatureFileIOC45::GetFileDesc(), KKB::HTMLReport::HTMLReport(), KKB::ImageDirTree::ImageDirTree(), KKB::KKException::KKException(), KKJobManagment::KKJobManager::KKJobManager(), KKB::KKObserver::KKObserver(), KKB::KKThread::KKThread(), KKMLL::FeatureFileIODstWeb::LoadFile(), KKB::KKStrListIndexed::LookUp(), KKMLL::AttributeList::LookUpByName(), KKMLL::Model::Model(), KKMLL::ModelParam::ModelParam(), KKMLL::ModelParamDual::ModelParamDual(), KKB::MsgQueue::MsgQueue(), KKMLL::Orderings::Orderings(), KKB::osAddSlash(), KKB::osCopyFileBetweenDirectories(), KKB::osLookForFile(), KKB::osMakeFullFileName(), KKB::osMoveFileBetweenDirectories(), KKB::osReadRestOfLine2(), KKB::osRemoveExtension(), KKB::osSubstituteInEnvironmentVariables(), Parse(), KKMLL::ModelParam::ParseCmdLine(), KKMLL::ModelParamOldSVM::ParseCmdLine(), KKMLL::SVMparam::ParseCmdLineParameter(), KKMLL::ClassAssignments::ParseToString(), KKMLL::SizeDistribution::ClassTotals::PrintFormatedLine(), KKMLL::ProbNamePair::ProbNamePair(), KKB::Raster::Raster(), KKB::RasterBuffer::RasterBuffer(), KKB::KKStrListIndexed::ReadXML(), KKMLL::GrayScaleImagesFVList::RecalcFeatureValuesFromImagesInDirTree(), KKLSC::ScannerFile::ScannerFile(), KKLSC::ScannerFileEntry::ScannerFileEntry(), KKB::Chart::Series::Series(), KKB::Configuration::Setting::Setting(), KKB::Configuration::SettingValueToStr(), Split(), KKJobManagment::KKJobManager::StatusFileProcessLine(), KKLSC::Variables::SubstituteInEnvironmentVariables(), KKMLL::SVMparam::SVMparam(), KKB::TokenBufferStr::TokenBufferStr(), KKB::TokenBufferStream::TokenBufferStream(), ToKKStrPtr(), ToLatitude(), ToLongitude(), ToLower(), KKMLL::MLClass::ToString(), ToUpper(), KKMLL::TrainingClass::TrainingClass(), KKMLL::TrainingClassList::TrainingClassList(), KKMLL::TrainingConfiguration2::TrainingConfiguration2(), KKB::Chart::XLabel::XLabel(), KKB::XmlAttribute::XmlAttribute(), KKB::XmlFactory::XmlFactory(), KKB::XmlFactoryManager::XmlFactoryManager(), KKB::XmlStream::XmlStream(), and KKB::XmlTag::XmlTag().

                               : 
         val (NULL)
 {
   if  (!str.val)
   {
     AllocateStrSpace (1);
     len = 0;
     return;
   }
 
   if  (str.val[str.len] != 0)
   {
     std::cerr << std::endl 
          << "KKStr::KKStr    ***ERROR***    Missing terminating NULL" << std::endl
          << std::endl;
   }
 
   kkuint16  neededSpace = str.len + 1;
   if  (neededSpace > str.allocatedSize)
   {
     KKStr  errMsg = "KKStr::KKStr (const KKStr&  str)   AllocatedSize["  + ::StrFromUint16(str.allocatedSize) + "]  on Source KKStr is to Short";
     std::cerr << endl << errMsg << "  ***ERROR***" << std::endl << std::endl;
     throw new KKException (errMsg);
   }
 
   AllocateStrSpace (str.allocatedSize);
   if  (!val)  {
     std::cerr << std::endl << "KKStr::KKStr  ***ERROR***   Allocation Failed." << std::endl << std::endl; 
     throw KKException("KKStr::KKStr  ***ERROR***  Allocation Failed.");
   }
 
   std::memcpy (val, str.val, str.len);
   len = str.len;
 }

KKStr::KKStr ( KKStr && str )

Move Constructor

Definition at line 599 of file KKStr.cpp.

                           :
     allocatedSize (str.allocatedSize),
     len           (str.len),
     val           (str.val)
 {
   str.allocatedSize = 0;
   str.len           = 0;
   str.val           = NULL;
 }

KKStr::KKStr ( kkint32 size )

Creates a KKStr object that pre-allocates space for 'size' characters.

Creates a KKStr object that has 'size' characters preallocated; and set to empty string.

summary> Initializes the string with a displayable version of d with precision decimal points.

Definition at line 655 of file KKStr.cpp.

Referenced by KKMLL::FileDesc::AddANominalValue(), KKB::XmlTag::AddAtribute(), KKMLL::FeatureVector::AddFeatureData(), KKB::KKThread::AddMsg(), KKB::BitString::BitString(), Concat(), KKMLL::FeatureEncoder::CreateEncodedFileDesc(), DecodeQuotedStr(), KKB::Matrix::DeterminantSlow(), KKMLL::FeatureEncoder::EncodeAExample(), ExtractQuotedStr(), KKMLL::FeatureFileIO::FileFormatsReadAndWriteOptionsStr(), KKMLL::FeatureFileIO::FileFormatsReadOptionsStr(), KKMLL::FeatureFileIO::FileFormatsWrittenOptionsStr(), KKMLL::CrossValidationVoting::FoldAccuracysToStr(), KKMLL::CrossValidation::FoldAccuracysToStr(), KKMLL::CrossValidationVoting::FoldStr(), FreeUpUnUsedSpace(), KKMLL::FeatureFileIODstWeb::GetFileDesc(), KKMLL::FeatureFileIOC45::GetFileDesc(), KKB::KKStrParser::GetNextToken(), KKB::KKStrParser::GetRestOfLine(), KKB::KKStrParser::GetRestOfStr(), KKLSC::ScannerFile::GuessFormatOfFile(), KKB::BitString::HexStr(), KKB::Raster::Histogram(), KKB::Matrix::Inverse(), LeftPad(), KKB::BitString::ListOfSetBits16(), KKMLL::FeatureFileIOUCI::LoadFile(), KKB::Matrix::Matrix(), KKB::DateType::MM_DD_YY(), KKB::DateType::MMM_DD_YYYY(), KKB::Matrix::operator*(), KKB::Matrix::operator+(), operator+(), KKB::operator+(), KKB::Matrix::operator+=(), KKB::Matrix::operator-(), KKB::operator<<(), KKB::RunLog::operator<<(), operator<<(), KKB::Matrix::operator[](), KKMLL::FeatureNumList::operator[](), KKB::osReadNextLine(), KKB::osReadNextQuotedStr(), KKB::osReadRestOfLine(), KKB::KKStrParser::PeekNextToken(), KKMLL::ConfusionMatrix2::PrintAccuracyByProbByClassHTML(), KKMLL::BinaryClassParmsList::PushOnBack(), KKMLL::FeatureVectorList::PushOnBack(), KKMLL::BinaryClassParmsList::PushOnFront(), KKMLL::FeatureVectorList::PushOnFront(), QuotedStr(), KKLSC::ScannerFile::ReadHeader(), KKMLL::ModelKnn::ReadXML(), KKMLL::ModelUsfCasCor::ReadXML(), KKMLL::ModelSvmBase::ReadXML(), KKMLL::ModelDual::ReadXML(), KKMLL::ModelOldSVM::ReadXML(), KKMLL::Model::ReadXMLModelToken(), KKMLL::ModelDual::ReconcilePredictions(), KKB::XmlFactoryManager::RegisterFactory(), KKMLL::FeatureVector::ResetNumOfFeatures(), KKB::SaveImagePGM(), KKB::SaveImagePNG(), KKB::SaveImagePPM(), StripOutInvalidLatexCaracters(), KKB::KKStrParser::SubStrPart(), SubStrPart(), KKMLL::ModelParamOldSVM::SvmParamToString(), KKMLL::SVMparam::SvmParamToString(), KKMLL::ModelParamSvmBase::ToCmdLineStr(), KKMLL::ModelParamUsfCasCor::ToCmdLineStr(), KKMLL::ModelParamDual::ToCmdLineStr(), SVM233::svm_parameter::ToCmdLineStr(), KKMLL::ModelParam::ToCmdLineStr(), SVM289_BFS::svm_parameter::ToCmdLineStr(), SVM289_MFS::svm_parameter::ToCmdLineStr(), KKMLL::ModelParamOldSVM::ToCmdLineStr(), KKMLL::MLClassIndexList::ToCommaDelString(), KKJobManagment::KKJob::ToStatusStr(), KKJobManagment::KKJobManager::ToStatusStr(), KKMLL::FeatureNumList::ToString(), KKMLL::SVMparam::ToString(), KKLSC::ScannerFileEntry::ToTabDelStr(), KKLSC::StartStopPoint::ToTabDelStr(), SVM233::svm_parameter::ToTabDelStr(), SVM289_BFS::svm_parameter::ToTabDelStr(), SVM289_MFS::svm_parameter::ToTabDelStr(), ToXmlStr(), KKLSC::ScannerFile::WriteHeader(), KKLSC::ScannerFile::WriteInstrumentDataWord(), SVM289_MFS::Svm_Model::WriteXML(), KKMLL::SVMModel::WriteXML(), KKB::DateType::YY_MM_DD(), KKB::DateType::YYYY_MM_DD(), KKB::DateType::YYYY_MMM_DD(), and KKB::DateType::YYYYMMDD().

                           :
         val (NULL)
 {
   if  (size <= 0)
     size = 1;
 
   else if  ((kkuint32)size >= KKStrIntMax)
   {
     cerr  << std::endl 
           << "KKStr::KKStr    ***WARNNING***   Trying to allocate Size[" << size << "]  which is >= KKStrIntMax[" << KKStrIntMax << "]." << std::endl
           << std::endl;
     size = KKStrIntMax - 1;
   }
 
   AllocateStrSpace (size);
   val[0] = 0;
   len = 0;
 }

KKStr::KKStr	(	double	d,
		kkint32	precision
	)

summary>Constructs a KKStr instance form a stl::string instance.

Creates a String that is populated with 'd' as displayable characters and precision of 'precision'.

Definition at line 617 of file KKStr.cpp.

References KKB::SPRINTF(), and KKB::STRCOPY().

               :
     val (NULL)
 {
   char  buff[60];
 
   if  ((precision < 0)  ||  (precision > 10))
   {
     SPRINTF (buff, sizeof (buff), "%f", d);
   }
   else
   {
     SPRINTF (buff, sizeof (buff), "%.*f", precision, d);
   }
 
   kkuint16  newLen = (kkuint16)strlen (buff); 
   AllocateStrSpace (newLen + 1);
 
   STRCOPY (val, allocatedSize, buff);
 
   len = newLen;
 }

KKStr::KKStr ( const std::string & s )

summary> Constructs an instance from a substring of the ascii-z string src .

param name='src'> Source string to build new instance from.

param name = 'startPos'> Index of first character that we want to include in new instance.

param name='endPos'> Index of last character that we want to include in new instance.

Definition at line 677 of file KKStr.cpp.

                                 :
         allocatedSize (0),
         len (0),
         val (NULL)
 {
   AllocateStrSpace ((kkint32)(s.size () + 1));
 
   len = (kkuint16)s.size ();
   for  (kkint32 x = 0;  x < len;  ++x)
     val[x] = s[x];
   val[len] = 0;
 }

KKStr::KKStr	(	const char *	src,
		kkuint32	startPos,
		kkuint32	endPos
	)

Constructs a KKStr instance from a sub-string of 'src'.

Definition at line 693 of file KKStr.cpp.

References KKB::KKException::KKException().

Referenced by KKB::KKStrParser::GetNextToken(), KKB::KKStrParser::PeekNextToken(), and KKLSC::ScannerFile::ReportTextMsg().

               :
         allocatedSize (0),
         len (0),
         val (NULL)
 {
   if  (startPos > endPos)
   {
     AllocateStrSpace (1);
     return;
   }
 
   kkuint32  subStrLen = 1 + endPos - startPos;
   if  (subStrLen > (KKStrIntMax - 1))
   {
     cerr << "KKStr::KKStr   ***ERROR***  requested SubStr[" << startPos << ", " << endPos << "]  len[" << subStrLen << "] is greater than KKStrIntMax[" << (KKStrIntMax - 1) << "]" << std::endl;
     endPos = (startPos + KKStrIntMax - 2);
     subStrLen = 1 + endPos - startPos;
   }
 
   AllocateStrSpace (1 + subStrLen);             // Need one extra byte for NULL terminating character.
   if  (!val)
     throw KKException ("KKStr::KKStr   Allocation Failed");
 
   memcpy (val, src + startPos, subStrLen);
   len = (kkuint16)subStrLen;
   val[subStrLen] = 0;
 }

Member Function Documentation

void KKStr::Append ( const char * buff )

Definition at line 1783 of file KKStr.cpp.

References KKB::KKException::KKException(), KKB::operator+(), and KKB::StrFromUint32().

Referenced by AppendInt32(), AppendUInt32(), Concat(), operator+(), operator<<(), QuotedStr(), and ToXmlStr().

 {
   #ifdef  KKDEBUG
   ValidateLen ();
   #endif
 
   if  (!buff)  
     return;
 
   kkuint32  buffLen = (kkuint32)strlen (buff);
   kkuint32  newLen = len + buffLen;
   kkuint32  neededSpace = newLen + 1;
 
   if  (neededSpace > allocatedSize)
   {
     if  (neededSpace >= KKStrIntMax)
     {
       cerr << std::endl 
            << "KKStr::Append   ***ERROR***   Size of buffer can not fit into String." << std::endl
            << "                buffLen[" << buffLen         << "]" << std::endl
            << "                neededSpace[" << neededSpace << "]" << std::endl
            << std::endl;
       throw KKException ("KKStr::Append  Length will exceed what KKStr can managed;  neededSpace: " + StrFromUint32 (neededSpace));
     }
     GrowAllocatedStrSpace (neededSpace);
   }
 
   kkuint32  x = 0;
   for  (x = 0;  x < buffLen;  x++)
   {
     val[len] = buff[x];
     len++;
   }
   val[len] = 0;
 }  /* Append */

void KKStr::Append	(	const char *	buff,
		kkuint32	buffLen
	)

Definition at line 1821 of file KKStr.cpp.

References KKB::KKException::KKException(), KKB::operator+(), and KKB::StrFromUint32().

Referenced by Append(), and SubStrPart().

 {
   #ifdef  KKDEBUG
   ValidateLen ();
   #endif
 
   if  (buffLen == 0)  
     return;
 
   kkuint32  newLen = len + buffLen;
   kkuint32  neededSpace = newLen + 1;
 
   if  (neededSpace > allocatedSize)
   {
     if  (neededSpace >= KKStrIntMax)
     {
       cerr << std::endl 
            << "KKStr::Append   ***ERROR***   Size of buffer can not fit into String." << std::endl
            << "                buffLen[" << buffLen         << "]" << std::endl
            << "                neededSpace[" << neededSpace << "]" << std::endl
            << std::endl;
       throw KKException("KKStr::Append  Length will exceed what KKStr can managed;  neededSpace: " + StrFromUint32(neededSpace));
     }
     GrowAllocatedStrSpace (neededSpace);
   }
 
   kkuint32  x = 0;
   for  (x = 0;  x < buffLen;  x++)
   {
     val[len] = buff[x];
     len++;
   }
 
   val[len] = 0;
 }  /* Append*/

void KKStr::Append ( char ch )

Definition at line 1863 of file KKStr.cpp.

References KKB::KKException::KKException(), KKB::operator+(), and KKB::StrFromUint32().

Referenced by AppendInt32(), AppendUInt32(), DecodeQuotedStr(), ExtractQuotedStr(), KKB::KKStrParser::GetNextToken(), KKB::KKStrParser::GetRestOfLine(), KKB::KKStrParser::GetRestOfStr(), KKB::BitString::HexStr(), KKB::operator+(), operator<<(), KKB::osReadNextLine(), KKB::osReadRestOfLine(), KKB::KKStrParser::PeekNextToken(), QuotedStr(), KKLSC::ScannerFile::ReadHeaderOneLine(), KKMLL::ModelDual::ReconcilePredictions(), StripOutInvalidLatexCaracters(), KKB::KKStrParser::SubStrPart(), and ToXmlStr().

 {
   kkuint32  neededSpace = len + 2;
   if  (neededSpace > allocatedSize)
   {
     if  (neededSpace >= KKStrIntMax)
     {
       cerr << std::endl 
            << "KKStr::Append   ***ERROR***   Size of buffer can not fit into String." << std::endl
            << "                neededSpace[" << neededSpace << "]" << std::endl
            << std::endl;
       throw KKException("KKStr::Append (char ch)  Length will exceed what KKStr can managed;  neededSpace: " + StrFromUint32(neededSpace));
     }
     GrowAllocatedStrSpace (neededSpace);
   }
   val[len] = ch;
   len++;
   val[len] = 0;
 }  /* Append */

void KKStr::Append ( const KKStr & str )

Definition at line 1887 of file KKStr.cpp.

References Append().

Referenced by operator+(), KKB::operator+(), KKMLL::operator<<(), and ReadXML().

 {
   Append (str.val, str.len);
 }

void KKStr::Append ( const std::string & str )

Definition at line 1894 of file KKStr.cpp.

 {
   Append (str.c_str ());
 }

void KKStr::AppendInt32 ( kkint32 i )

Definition at line 1901 of file KKStr.cpp.

References Append().

Referenced by KKB::RunLog::operator<<(), and operator<<().

 {
   if  (i == 0)
   {
     Append ('0');
     return;
   }
 
   char  buff[64];
   kkint16  bi = sizeof (buff) - 1;
   buff[bi] = 0;
 
   bool  negative = false;
   if  (i < 0)
   {
     negative = true;
     i = 0 - i;
   }
 
   while  (i > 0)
   {
     --bi;
     kkint16  digit = i % 10;
     i = i / 10;
     buff[bi] = '0' + (char)digit;
   }
 
   if  (negative)
   {
     --bi;
     buff[bi] = '-';
   }
 
   Append (buff + bi);
   return;
 }  /* AppendInt32 */

void KKStr::AppendUInt32 ( kkuint32 i )

Definition at line 1940 of file KKStr.cpp.

References Append().

Referenced by KKB::RunLog::operator<<(), and operator<<().

 {
   if  (i == 0)
   {
     Append ('0');
     return;
   }
 
   char  buff[64];
   kkint16  bi = sizeof (buff) - 1;
   buff[bi] = 0;
 
   while  (i > 0)
   {
     --bi;
     kkint16  digit = i % 10;
     i = i / 10;
     buff[bi] = '0' + (char)digit;
   }
 
   Append (buff + bi);
   return;
 }  /* AppendUInt32 */

const char* KKB::KKStr::c_str ( )

inline

Definition at line 585 of file KKStr.h.

References Str().

585 {return Str ();}

KKB::KKStr::Str

const char * Str() const

Returns a pointer to a ascii string.

Definition: KKStr.h:422

bool KKStr::CharInStr ( char ch )

Determines if 'ch' occurs anywhere in the string.

Definition at line 2712 of file KKStr.cpp.

 {
   if  (!val)
     return false;
 
   for  (kkint32 x = 0;  x < len;  x++)
   {
     if  (val[x] == ch)
       return true;
   }
   return false;
 }

void KKStr::ChopFirstChar ( )

Removes the first character from the string.

Definition at line 1649 of file KKStr.cpp.

Referenced by KKB::PointList::FromDelStr(), ToLatitude(), and ToLongitude().

 {
   #ifdef  KKDEBUG
   ValidateLen ();
   #endif
 
   if  (!val)  return;
 
   if  (len > 0)
   {
     for  (int x = 0;  x < len;  ++x)
       val[x] = val[x + 1];
     len--;
     val[len] = 0;
   }
 }  /* ChopLastChar */

void KKStr::ChopLastChar ( )

Removes the last character from the string.

Definition at line 1668 of file KKStr.cpp.

Referenced by KKMLL::FeatureFileIODstWeb::AttrDescLine::AttrDescLine(), KKMLL::FeatureFileIOC45::GetFileDesc(), KKMLL::FeatureFileIODstWeb::LoadFile(), KKB::osGetDirNameFromPath(), KKB::osGetParentDirectoryOfDirPath(), KKB::osGetParentDirPath(), KKB::osGetRootNameOfDirectory(), ToLatitude(), and ToLongitude().

 {
   #ifdef  KKDEBUG
   ValidateLen ();
   #endif
 
   if  (!val)  return;
 
   if  (len > 0)
   {
     len--;
     val[len] = 0;
   }
 }  /* ChopLastChar */

kkint32 KKStr::Compare ( const KKStr & s2 ) const

'-1' = less than 's2', '0' = Same as 's2', and '1' = Greater than 's2'.

Definition at line 844 of file KKStr.cpp.

Referenced by CompareTo(), operator!=(), operator<(), operator<=(), operator==(), operator>(), and operator>=().

 {
   kkint32  zed = Min (len, s2.len);
 
   const char*  s1Ptr = val;
   const char*  s2Ptr = s2.val;
 
   for  (kkint32 x = 0;  x < zed;  x++)
   {
     if  ((*s1Ptr) < (*s2Ptr))
       return -1;
 
     else if  ((*s1Ptr) > (*s2Ptr))
       return 1;
 
     s1Ptr++;
     s2Ptr++;
   }
 
   if  (len == s2.len)
     return 0;
 
   else if  (len < s2.len)
     return -1;
 
   else 
     return 1;
 
 }  /* Compare */

kkint32 KKStr::Compare ( const std::string & s2 ) const

Compares with STL string.

'-1' = less than 's2', '0' = Same as 's2', and '1' = Greater than 's2'.

Parameters

[in] s2 STL String std::string that we will compare with.

Returns: -1=less, 0=equal, 1=greater, -1, 0, or 1, indicating if less than, equal, or greater.

Definition at line 881 of file KKStr.cpp.

 {
   kkuint16  s2Len = (kkuint16)s2.size ();
   kkint32  zed = Min (len, s2Len);
 
   const char*  s1Ptr = val;
   const char*  s2Ptr = s2.c_str ();
 
   for  (kkint32 x = 0;  x < zed;  x++)
   {
     if  ((*s1Ptr) < (*s2Ptr))
       return -1;
 
     else if  ((*s1Ptr) > (*s2Ptr))
       return 1;
 
     s1Ptr++;
     s2Ptr++;
   }
 
   if  (len == s2Len)
     return 0;
 
   else if  (len < s2Len)
     return -1;
 
   else 
     return 1;
 
 }  /* Compare */

kkint32 KKStr::CompareIgnoreCase ( const KKStr & s2 ) const

Compares with another KKStr, ignoring case.

summary>Compares with STL string ignoring case.

Parameters

s2	STL String std::string that we will compare with.

returns> -1=less, 0=equal, 1=greater, -1, 0, or 1, indicating if less than, equal, or greater.

Parameters

[in] s2 Other String to compare with.

Returns: -1=less, 0=equal, 1=greater, -1, 0, or 1, indicating if less than, equal, or greater.

Definition at line 919 of file KKStr.cpp.

Referenced by EqualIgnoreCase().

 {
   kkint32  zed = Min (len, s2.len);
 
   const char*  s1Ptr = val;
   const char*  s2Ptr = s2.val;
 
   for  (kkint32 x = 0;  x < zed;  x++)
   {
     if  (toupper (*s1Ptr) < toupper (*s2Ptr))
       return -1;
 
     else if  (toupper (*s1Ptr) > toupper (*s2Ptr))
       return 1;
 
     s1Ptr++;
     s2Ptr++;
   }
 
   if  (len == s2.len)
     return 0;
 
   else if  (len < s2.len)
     return -1;
 
   else 
     return 1;
 }  /* CompareIgnoreCase */

kkint32 KKStr::CompareIgnoreCase ( const std::string & s2 ) const

summary>Compares with ascii-z string ignoring case.

param name='s2'> Ascii-z string to compare with.

returns> -1=less, 0=equal, 1=greater, -1, 0, or 1, indicating if less than, equal, or greater.

Definition at line 998 of file KKStr.cpp.

 {
   kkuint16  s2Len = (kkuint16)s2.size ();
   kkint32  zed = Min (len, s2Len);
 
   const char*  s1Ptr = val;
   const char*  s2Ptr = s2.c_str ();
 
   for  (kkint32 x = 0;  x < zed;  x++)
   {
     if  (toupper (*s1Ptr) < toupper (*s2Ptr))
       return -1;
 
     else if  (toupper (*s1Ptr) > toupper (*s2Ptr))
       return 1;
 
     s1Ptr++;
     s2Ptr++;
   }
 
   if  (len == s2Len)
     return 0;
 
   else if  (len < s2Len)
     return -1;
 
   else 
     return 1;
 
 }  /* CompareIgnoreCase */

kkint32 KKStr::CompareIgnoreCase ( const char * s2 ) const

summary>Compares to Strings and returns -1, 0, or 1, indicating if less than, equal, or greater.

Compares with ascii-z string ignoring case.

Parameters

[in] s2 Ascii-z string to compare with.

Returns: -1=less, 0=equal, 1=greater, -1, 0, or 1, indicating if less than, equal, or greater.

Definition at line 955 of file KKStr.cpp.

Referenced by KKJobManagment::KKJob::JobStatusFromStr(), KKB::DateType::MonthFromStr(), KKJobManagment::KKJob::PrerequisitesFromStr(), and KKJobManagment::KKJobManager::StatusFileProcessLine().

 {
   if  (s2 == NULL)
   {
     if  (len == 0)
       return  0;
     else
       return  1;
   }
 
   kkuint32  s2Len = 0;
   if  (s2 != NULL)
     s2Len = (kkuint32)strlen (s2);
   kkuint32  zed = Min ((kkuint32)len, s2Len);
 
   const char*  s1Ptr = val;
   const char*  s2Ptr = s2;
 
   for  (kkuint16 x = 0;  x < zed;  x++)
   {
     if  (toupper (*s1Ptr) < toupper (*s2Ptr))
       return -1;
 
     else if  (toupper (*s1Ptr) > toupper (*s2Ptr))
       return 1;
 
     s1Ptr++;
     s2Ptr++;
   }
 
   if  (len == s2Len)
     return 0;
 
   else if  (len < s2Len)
     return -1;
 
   else 
     return 1;
 }  /* CompareIgnoreCase */

kkint32 KKStr::CompareStrings	(	const KKStr &	s1,
		const KKStr &	s2
	)

static

Compares to Strings and returns -1, 0, or 1, indicating if less than, equal, or greater.

summary> Concatenates the list of char* strings, stopping at first NULL. Each of these NULL terminated strings are concatenated onto the result string; terminates when 'values[x] == NULL'. /summary>

Definition at line 4714 of file KKStr.cpp.

Referenced by KKB::KKStrList::StringComparison::operator()().

 {
   if  (s1.val == NULL)
   {
     if  (s2.val == NULL)
       return 0;
     else
       return -1;
   }
 
   else if  (s2.val == NULL)
   {
     return  1;
   }
 
   else
   {
     return  strcmp (s1.val, s2.val);
   }
 }  /* CompareStrings */

kkint32 KKB::KKStr::CompareTo ( const KKStr & s2 ) const

inline

summary>Compares with another KKStr, ignoring case.

param name='s2'> Other String to compare with.

returns> -1=less, 0=equal, 1=greater, -1, 0, or 1, indicating if less than, equal, or greater.

Definition at line 184 of file KKStr.h.

References Compare().

KKStr KKStr::Concat ( const char ** values )

static

summary> Concatenates the list of char* strings, stops at first NULL Each of these NULL terminated strings are concatenated onto the result string; terminates when 'values[x] == NULL'. /summary>

Definition at line 1031 of file KKStr.cpp.

References Append(), Concat(), and KKStr().

 {
   if  (values == NULL)
     return "";
 
   kkuint32  len = 0;
   kkint32  x = 0;
   while  (values[x] != NULL)
   {
     len += (kkuint32)strlen (values[x]);
     x++;
   }
 
   KKStr  result (len);
   x = 0;
   while  (values[x] != NULL)
   {
     result.Append (values[x]);
     x++;
   }
 
   return  result;
 }  /* Concat */

KKStr KKStr::Concat ( const VectorKKStr & values )

static

Definition at line 1057 of file KKStr.cpp.

References Concat(), and KKStr().

 {
   kkuint32 x   = 0;
   kkint32 len  = 0;
 
   for  (x = 0;  x < values.size ();  x++)
     len += (kkint32)values.size ();
 
   KKStr  result (len);
   x = 0;
   for  (x = 0;  x < values.size ();  x++)
   {
     result.Append (values[x]);
     x++;
   }
 
   return  result;
 }  /* Concat */

KKStr KKStr::Concat ( const std::vector< std::string > & values )

static

Concatenates the list of 'std::string' strings.

Iterates through values concatenating each one onto a result string.

Iterates through values Concatenating each one onto a result string.

Definition at line 1082 of file KKStr.cpp.

References Concat(), and KKStr().

 {
   kkuint32 x   = 0;
   kkint32 len  = 0;
 
   for  (x = 0;  x < values.size ();  x++)
     len += (kkint32)values.size ();
 
   KKStr  result (len);
   x = 0;
   for  (x = 0;  x < values.size ();  x++)
   {
     result.Append (values[x]);
     x++;
   }
 
   return  result;
 }  /* Concat */

bool KKStr::Contains ( const KKStr & value )

Definition at line 1103 of file KKStr.cpp.

References Empty(), and StrInStr().

 {
   if  (value.Empty ())
     return true;
   else
     return StrInStr (value);
 }

bool KKStr::Contains ( const char * value )

Definition at line 1112 of file KKStr.cpp.

References Find().

 {
   if  ((value == NULL)  ||  (*value == 0))
     return true;
   else
     return (Find (value, 0) >= 0);
 }

kkint32 KKStr::CountInstancesOf ( char ch ) const

Definition at line 1122 of file KKStr.cpp.

Referenced by KKB::DateTime::DateTime().

 {
   if  (!val)
     return 0;
   kkint32  count = 0;
   for  (kkint32 x = 0;  x < len;  ++x)
   {
     if  (val[x] == ch)
       ++count;
   }
   return  count;
 }

const char* KKB::KKStr::data ( )

inline

Definition at line 587 of file KKStr.h.

References Str().

587 {return Str ();}

KKB::KKStr::Str

const char * Str() const

Returns a pointer to a ascii string.

Definition: KKStr.h:422

KKStr KKStr::DecodeQuotedStr ( ) const

Trees this KKSr instance as a QuotedStr; decodes escape sequences such as '\', '', '
', '', and '\0' into original characters.

Definition at line 3243 of file KKStr.cpp.

References Append(), Concat(), EmptyStr(), and KKStr().

 {
   if  ((!val)  ||  (len == 0))
     return  EmptyStr ();
 
   KKStr  result (len + 4);
   kkint32  idx = 0;
    
   kkint32  lastCharPos = len - 1;
 
   if  ((val[idx] == '"')  &&  (val[len - 1] == '"'))
   {
     ++idx;
     --lastCharPos;
   }
 
   while  (idx <= lastCharPos)
   {
     if  (val[idx] == '\\')
     {
       ++idx;
       if  (idx <= lastCharPos)
       {
         result.Append (val[idx]);
         ++idx;
       }
     }
     else
     {
       result.Append (val[idx]);
       ++idx;
     }
   }
 
   return  result;
 }  /* DecodeQuotedStr */

bool KKB::KKStr::Empty ( ) const

inline

Definition at line 241 of file KKStr.h.

241 {return (len <= 0);}

const KKStr & KKStr::EmptyStr ( )

static

Static method that returns an Empty String.

Returns: a empty String.

Definition at line 3453 of file KKStr.cpp.

References Concat().

Referenced by KKB::XmlAttributeList::AttributeValueKKStr(), DecodeQuotedStr(), KKMLL::TrainingConfiguration2::DirectoryPathForClass(), ExtractQuotedStr(), KKMLL::FeatureVectorProducer::FeatureName(), KKB::KKStrParser::GetNextToken(), KKMLL::Attribute::GetNominalValue(), KKB::KKStrParser::GetRestOfLine(), KKB::KKStrParser::GetRestOfStr(), KKLSC::ScannerFile::GetValue(), KKMLL::FeatureVector::MLClassName(), KKMLL::ClassStatistic::Name(), KKB::XmlElement::NameTagStr(), KKB::osGetParentDirectoryOfDirPath(), KKB::osGetParentDirPath(), KKMLL::MLClass::ParentName(), KKB::KKStrParser::PeekNextToken(), KKMLL::FeatureVector::PredictedClassName(), KKMLL::ModelParamDual::ProbFusionMethodToStr(), KKB::ReadImagePpmField(), KKB::XmlToken::SectionName(), KKB::XmlElement::SectionName(), KKB::Configuration::SettingValueToStr(), KKB::KKStrParser::SubStrPart(), KKB::KKThread::ThreadStatusToStr(), ToXmlStr(), KKB::XmlToken::VarName(), and KKB::XmlElement::VarName().

 {
   static  KKStr  emptyStr = "";
   return  emptyStr;
 }

bool KKStr::EndsWith ( const KKStr & value )

Definition at line 1190 of file KKStr.cpp.

References EndsWith().

 {
   return  EndsWith (value, false);
 }

bool KKStr::EndsWith ( const char * value )

Definition at line 1197 of file KKStr.cpp.

References EndsWith().

 {
   return  EndsWith (value, false);
 }

bool KKStr::EndsWith	(	const KKStr &	value,
		bool	ignoreCase
	)

Definition at line 1204 of file KKStr.cpp.

References Len(), StrEqual(), and StrEqualNoCase().

Referenced by EndsWith().

 {
   if  (value.len == 0)
     return true;
 
   kkint32  startPos = 1 + len - value.Len ();
   if  (startPos < 0)
     return false;
 
   if  (ignoreCase)
     return  StrEqualNoCase (val + startPos, value.val);
   else
     return  StrEqual  (val + startPos, value.val);
 }

bool KKStr::EndsWith	(	const char *	value,
		bool	ignoreCase
	)

Definition at line 1223 of file KKStr.cpp.

References StrEqual(), and StrEqualNoCase().

Referenced by EndsWith().

 {
   if  (value == NULL)
     return true;
 
   kkint32  valueLen = (kkint32)strlen (value);
 
   kkint32  startPos = 1 + len - valueLen;
   if  (startPos < 0)
     return false;
 
   if  (ignoreCase)
     return  StrEqualNoCase (val + startPos, value);
   else
     return  StrEqual (val + startPos, value);
 }

char KKStr::EnterStr ( )

Definition at line 2394 of file KKStr.cpp.

References KKB::STRCOPY().

 {
   kkint32 bp = 0;
   char  buff[256];
   uchar  ch;
   
   ch = (uchar)getchar ();
   if  (ch == 10)
     ch = EnterChar;
 
   while  ((ch != EnterChar) && (ch != EscapeChar))
     {
       if  (ch == 8)
         {
           // Back Space 
           if  (bp > 0)  {
              bp--;
              buff[bp] = 0;
              putchar (ch);
             }
         }
       
       else if  (ch == 0)
         {
           // We have a control character.
           ch = (uchar)getchar ();
         }
 
       else
         {
           // putchar (ch);
           buff[bp] = ch;
           bp++;
         }
 
       ch = (uchar)getchar ();
       if  (ch == 10)
         ch = EnterChar;
     }
 
   buff[bp] = 0;
 
   kkuint16  newLen = (kkuint16)strlen (buff);
 
   kkuint16  neededSpace = newLen + 1;
 
   if  (neededSpace > allocatedSize)
   {
     delete  [] val;
     val = NULL;
     AllocateStrSpace (neededSpace);
   }
 
   STRCOPY (val, allocatedSize, buff);
   len = newLen;
 
   return  ch;
 }  /* EnterStr */

bool KKStr::EqualIgnoreCase ( const KKStr & s2 ) const

Definition at line 1250 of file KKStr.cpp.

References CompareIgnoreCase().

Referenced by KKMLL::TrainingClassList::LocateByDirectory(), KKMLL::TrainingConfiguration2List::LookUp(), KKMLL::Classifier2List::LookUpByName(), KKB::Configuration::SettingList::LookUpLineNum(), KKLSC::ScannerFile::ScannerFileFormatFromStr(), and KKLSC::StartStopPoint::StartStopTypeFromStr().

 {
   return  (CompareIgnoreCase (s2) == 0);
 }  /* EqualIgnoreCase */

bool KKStr::EqualIgnoreCase ( const KKStrConstPtr s2 ) const

Definition at line 1244 of file KKStr.cpp.

References EqualIgnoreCase(), and Str().

Referenced by KKB::Configuration::SettingList::LookUp(), and KKB::Configuration::ConfSectionList::LookUp().

 {
   return  EqualIgnoreCase  (s2->Str ());
 }

bool KKStr::EqualIgnoreCase ( const char * s2 ) const

Definition at line 1257 of file KKStr.cpp.

References StrCompareIgnoreCase().

Referenced by KKMLL::AttributeTypeFromStr(), EqualIgnoreCase(), KKMLL::FeatureNumList::ExtractFeatureNumsFromStr(), KKLSC::ScannerFile::ExtractHeaderField(), KKLSC::ScannerFile::GuessFormatOfFile(), SVM289_BFS::Kernel_Type_FromStr(), SVM289_MFS::Kernel_Type_FromStr(), KKMLL::FeatureFileIOC45::LoadFile(), KKLSC::ScannerFile::LoadIndexFile(), KKMLL::ModelParam::ModelParamTypeFromStr(), KKMLL::Model::ModelTypeFromStr(), KKB::MorphOp::OperationTypeFromStr(), KKMLL::ModelParam::ParseCmdLine(), KKLSC::ScannerFileEntry::ParseTabDelStr(), SVM289_BFS::svm_parameter::ParseTabDelStr(), SVM289_MFS::svm_parameter::ParseTabDelStr(), KKMLL::FeatureNumList::ParseToString(), KKMLL::ModelParamDual::ProbFusionMethodFromStr(), SVM289_BFS::svm_parameter::ProcessSvmParameter(), SVM289_MFS::svm_parameter::ProcessSvmParameter(), KKMLL::ModelParamKnn::ReadXML(), KKMLL::AttributeTypeVector::ReadXML(), KKMLL::ModelParamSvmBase::ReadXML(), KKMLL::ModelParamUsfCasCor::ReadXML(), KKMLL::ModelParamDual::ReadXML(), KKMLL::TrainingClass::ReadXML(), KKMLL::NormalizationParms::ReadXML(), KKMLL::FeatureEncoder::ReadXML(), KKMLL::ModelParamOldSVM::ReadXML(), SVM233::SvmModel233::ReadXML(), SVM289_MFS::Svm_Model::ReadXML(), KKMLL::FileDesc::ReadXML(), KKMLL::SVMparam::ReadXML(), KKMLL::ModelOldSVM::ReadXML(), KKMLL::SVMModel::ReadXML(), KKMLL::TrainingProcess2::ReadXML(), KKMLL::TrainingConfiguration2::ReadXMLBaseToken(), KKMLL::ModelParam::ReadXMLModelParamToken(), KKMLL::Model::ReadXMLModelToken(), KKB::SaveImageGrayscaleInverted4Bit(), KKB::SaveImageGrayscaleInverted8Bit(), KKJobManagment::KKJobManager::StatusFileProcessLine(), KKLSC::Variables::SubstituteInEnvironmentVariables(), SVM289_BFS::SVM_Type_FromStr(), SVM289_MFS::SVM_Type_FromStr(), and KKMLL::XmlElementMLClass::XmlElementMLClass().

 {
   return  (StrCompareIgnoreCase (val, s2) == 0);
 }  /* EqualIgnoreCase */

char KKStr::ExtractChar ( )

Removes the first character from the string and returns it to the caller.

If the String is already empty it will return 0.

Definition at line 3197 of file KKStr.cpp.

 {
   #ifdef  KKDEBUG
   ValidateLen ();
   #endif
 
   if  (!val)
     return 0;
 
   if  (len <= 0)
     return 0;
 
   char  returnChar = val[0];
    
   kkuint16  newLen = len - 1;
 
   for  (kkuint16  x = 0;  x < newLen; x++)
   {
     val[x] = val[x + 1];
   }
 
   len = newLen;
   val[len] = 0;
 
   return  returnChar;
 }  /* ExtractChar */

char KKStr::ExtractLastChar ( )

Removes the last character from the string and returns it to the caller.

If the String is already empty it will return 0.summary> Extracts the next string token; if the string starts with a quote(") will extract until the terminating quote. Special control characters that are encoded with back-slashes such as carriage-return, line-feed, tab, quotes, etc will be decoded. It is the inverse of the QuotedStr or ToQuotedStr methods. /summary> param nqame='delChars'> List of acceptable delimiter characters.

param name='decodeEscapeCharacters'> Indicates if escape sequences should be decoded back to their original code.

returns>Token String

Definition at line 3226 of file KKStr.cpp.

 {
   #ifdef  KKDEBUG
   ValidateLen ();
   #endif
 
   if  ((!val)  ||  (len < 1))
     return 0;
 
   --len;
 
   return val[len];
 }  /* ExtractLastChar */

KKStr KKStr::ExtractQuotedStr	(	const char *	delChars,
		bool	decodeEscapeCharacters
	)

summary> Extract first Token from the string.

remarks> Removes first Token from string and returns it skipping over any leading delimiters. Tokens will be terminated by end of string or the first occurrence of a delimiter character. If no more tokens left will return a Empty KKStr. Note if you do not want to skip over leading delimiter characters the use 'ExtractToken2'. /remarks> param name='delStr'> List of delimiting characters.

returns> Extracted Token.

seealso cref='ExtractToken2'/>

Definition at line 3282 of file KKStr.cpp.

References Append(), Concat(), EmptyStr(), and KKStr().

Referenced by KKB::CmdLineExpander::CmdLineExpander(), and KKMLL::BinaryClassParms::CreateFromTabDelStr().

 {
   if  ((!val)  ||  (len == 0))
     return  EmptyStr ();
 
   KKStr  result (len);
   kkint32  idx = 0;
    
   bool  lookForTerminatingQuote = false;
 
   if  (val[idx] == '"')
   {
     lookForTerminatingQuote = true;
     idx++;
   }
 
 
   if  (idx >= len)
   {
     delete  [] val;
     val = NULL;
     AllocateStrSpace (1);
     return  result;
   }
 
   // Search for matching terminating Quote
   while  (idx < len)
   {
     if  (lookForTerminatingQuote)
     {
       if  (val[idx] == '"')
       {
         idx++;
         if  (idx < len)
         {
           if  (strchr (delChars, val[idx]))
             idx++;
         }
 
         break;
       }
     }
 
     else 
     {
       if  (strchr (delChars, val[idx]))
       {
         idx++;
         break;
       }
     }
 
     if  ((val[idx] == '\\')  &&  (decodeEscapeCharacters))
     {
       idx++;
       if  (idx < len)
       {
         switch  (val[idx])
         {
          case  '"': result.Append ('"');      break;
          case  't': result.Append ('\t');     break;
          case  'n': result.Append ('\n');     break;
          case  'r': result.Append ('\r');     break;
          case '\\': result.Append ('\\');     break;
          case  '0': result.Append (char (0)); break;
          case    0:                           break;
          default:   result.Append (val[idx]); break;
         }
         idx++;
       }
     }
     else
     {
       result.Append (val[idx]);
       idx++;
     }
   }
 
   if  (idx < len)
   {
     len = (kkuint16)(len - idx);
     memmove (val, &(val[idx]), len);
     val[len] = 0;
   }
   else
   {
     val[0] = 0;
     len = 0;
   }
 
   return  result;
 }  /* ExtractQuotedStr */

KKStr KKStr::ExtractToken ( const char * delStr = "\n\t\r " )

Definition at line 2969 of file KKStr.cpp.

References Concat(), and operator=().

Referenced by KKMLL::FeatureFileIODstWeb::AttrDescLine::AttrDescLine(), KKB::DateType::DateType(), KKMLL::FeatureNumList::ExtractFeatureNumsFromStr(), KKMLL::MLClassList::ExtractThreeTitleLines(), GetClassNameByHierarchyLevel(), KKMLL::FeatureFileIOUCI::GetFileDesc(), KKMLL::FeatureFileIOSparse::GetFileDesc(), KKMLL::FeatureFileIODstWeb::LoadFile(), KKMLL::FeatureFileIOUCI::LoadFile(), KKB::osCreateDirectoryPath(), KKMLL::ModelParam::ParseCmdLine(), KKMLL::ModelParamOldSVM::ParseCmdLine(), KKMLL::ClassAssignments::ParseToString(), SVM233::svm_parameter::svm_parameter(), and KKB::TimeType::TimeType().

 {
   if  (!val)
      return  "";
   
 
   #ifdef  KKDEBUG
   ValidateLen ();
   #endif
 
   KKStr  token;
   
   char*  tokenStart = val;
   
   // Skip leading Delimiters
   while  ((*tokenStart  != 0)  &&  (strchr (delStr, *tokenStart)))
      tokenStart++;
 
   if  (*tokenStart == 0)
   {
     delete  [] val;
     val = NULL;
     AllocateStrSpace (1);
     return  token;
   }
 
   char*  tokenNext = tokenStart;
 
   while  ((*tokenNext != 0)  &&  (!strchr (delStr, *tokenNext)))
      tokenNext++;
   
   if  (*tokenNext)
   {
     *tokenNext = 0;
     token = tokenStart;
 
     *tokenNext = ' ';
     tokenNext++;
 
     len = (kkuint16)strlen (tokenNext);
     memmove (val, tokenNext, len);
     val[len] = 0;
   }
   
   else
   {
     token = tokenStart;
     memset (val, 0, allocatedSize);
     len = 0;
   }   
 
   return  token;
 } /* ExtractToken */

KKStr KKStr::ExtractToken2 ( const char * delStr = "\n\t\r " )

Extract first Token from the string.

Removes first Token from string and returns it. Unlike 'ExtractToken' it will not skip over leading delimiters. If the first character is a delimiter it will return a empty string. Tokens will be terminated by end of string or the first occurrence of a delimiter character. If no more tokens left will return a Empty KKStr.

Parameters

[in] delStr List of delimiting characters.

Returns: Extracted Token.

See also: ExtractToken; ExtractTokenInt; ExtractTokenDouble; ExtractTokenUint; ExtractTokenBool

Definition at line 3026 of file KKStr.cpp.

References Concat(), KKStr(), and operator=().

Referenced by KKMLL::ClassProbList::CreateFromXMLStream(), ExtractTokenBool(), ExtractTokenDouble(), ExtractTokenInt(), ExtractTokenUint(), ExtractTokenUint64(), KKLSC::ScannerFile::GuessFormatOfFile(), KKLSC::ScannerFile::LoadIndexFile(), Parse(), KKLSC::ScannerFileEntry::ParseTabDelStr(), KKLSC::StartStopPoint::ParseTabDelStr(), SVM233::svm_parameter::ParseTabDelStr(), SVM289_BFS::svm_parameter::ParseTabDelStr(), SVM289_MFS::svm_parameter::ParseTabDelStr(), KKLSC::ScannerFile::ReadHeader(), KKMLL::ModelDual::ReconcilePredictions(), KKLSC::ScannerFile::ReportTextMsg(), Split(), KKJobManagment::KKJobManager::StatusFileProcessLine(), and KKJobManagment::KKJobManager::StatusFileProcessLineJobStatusChange().

 {
   #ifdef  KKDEBUG
   ValidateLen ();
   #endif
 
 
   if  (!val)
      return  KKStr ();
   
   KKStr  token;
   
   char*  tokenStart = val;
   
   // Skip Leading Blanks
   while  ((*tokenStart  != 0)  &&  (*tokenStart == ' '))
      tokenStart++;
 
   if  (*tokenStart == 0)
   {
     delete  [] val;
     val = NULL;
     AllocateStrSpace (1);
     return  token;
   }
 
   char*  tokenNext = tokenStart;
 
   while  ((*tokenNext != 0)  &&  (!strchr (delStr, *tokenNext)))
      tokenNext++;
   
   // Remove trailing spaces
   char*  tokenEnd = tokenNext;
   tokenEnd--;
   while  ((tokenEnd != tokenStart)  &&  ((*tokenEnd == ' ')  ||  (*tokenEnd == '\n')  ||  (*tokenEnd == '\r')))
     *tokenEnd = 0;
 
   if  (*tokenNext)
   {
     *tokenNext = 0;
     token = tokenStart;
 
     *tokenNext = ' ';
     tokenNext++;
 
     len = (kkuint16)strlen (tokenNext);
     memmove (val, tokenNext, len);
     val[len] = 0;
   }
   
   else
   {
     token = tokenStart;
     memset (val, 0, allocatedSize);
     len = 0;
   }   
 
   return  token;
 } /* ExtractToken2 */

bool KKStr::ExtractTokenBool ( const char * delStr )

Extract the next token from the string assuming that it is a logical True/False value.

This function calls 'ExtractToken2' and then returns true if the string that it extracted is equal to "Y", "Yes", "True", "T", or "1" otherwise false.

Parameters

[in] delStr List of delimiter characters.

Returns: 'true' or 'false'.

Definition at line 3165 of file KKStr.cpp.

References Concat(), ExtractToken2(), operator==(), and Upper().

Referenced by KKMLL::ModelParam::ParseCmdLine().

 {
   KKStr  workStr = ExtractToken2 (delStr);
   workStr.Upper ();
 
   return  ((workStr == "YES")  ||
            (workStr == "Y")    ||
            (workStr == "TRUE") ||
            (workStr == "T")    ||
            (workStr == "1")
           );
 }  /* ExtractTokenBool */

double KKStr::ExtractTokenDouble ( const char * delStr )

Definition at line 3180 of file KKStr.cpp.

References Concat(), ExtractToken2(), and Len().

Referenced by KKMLL::ClassProbList::CreateFromXMLStream(), KKLSC::ScannerFileEntry::ParseTabDelStr(), SVM233::svm_parameter::ParseTabDelStr(), SVM289_BFS::svm_parameter::ParseTabDelStr(), SVM289_MFS::svm_parameter::ParseTabDelStr(), and KKJobManagment::KKJobManager::StatusFileProcessLine().

 {
   #ifdef  KKDEBUG
   ValidateLen ();
   #endif
 
   KKStr  workStr = ExtractToken2 (delStr);
 
   if  (workStr.Len () == 0)
     return 0.0;
 
   return  atof (workStr.Str ());
 }

kkint32 KKStr::ExtractTokenInt ( const char * delStr )

Definition at line 3129 of file KKStr.cpp.

References Concat(), and ExtractToken2().

Referenced by KKMLL::FeatureNumList::ExtractFeatureNumsFromStr(), KKB::PointList::FromDelStr(), KKLSC::ScannerFile::LoadIndexFile(), KKLSC::StartStopPoint::ParseTabDelStr(), SVM233::svm_parameter::ParseTabDelStr(), SVM289_BFS::svm_parameter::ParseTabDelStr(), SVM289_MFS::svm_parameter::ParseTabDelStr(), KKMLL::ClassAssignments::ParseToString(), KKB::ReadImagePGM(), KKLSC::ScannerFile::ReportTextMsg(), KKJobManagment::KKJobManager::StatusFileProcessLine(), and KKJobManagment::KKJobManager::StatusFileProcessLineJobStatusChange().

 {
   #ifdef  KKDEBUG
   ValidateLen ();
   #endif
 
   KKStr  workStr = ExtractToken2 (delStr);
   return  atoi (workStr.Str ());
 }

kkuint32 KKStr::ExtractTokenUint ( const char * delStr )

Definition at line 3141 of file KKStr.cpp.

References Concat(), and ExtractToken2().

Referenced by KKLSC::ScannerFile::LoadIndexFile(), KKLSC::ScannerFileEntry::ParseTabDelStr(), and KKLSC::ScannerFile::ReportTextMsg().

 {
   #ifdef  KKDEBUG
   ValidateLen ();
   #endif
 
   KKStr  workStr = ExtractToken2 (delStr);
   return  (kkuint32)atol (workStr.Str ());
 }

KKB::kkuint64 KKStr::ExtractTokenUint64 ( const char * delStr )

Definition at line 3153 of file KKStr.cpp.

References Concat(), ExtractToken2(), and ToUint64().

Referenced by KKLSC::ScannerFile::LoadIndexFile().

 {
   #ifdef  KKDEBUG
   ValidateLen ();
   #endif
 
   KKStr  workStr = ExtractToken2 (delStr);
   return  workStr.ToUint64 ();
 }

kkint32 KKStr::Find	(	const KKStr &	str,
		kkint32	pos = `0`
	)		const

Will return the position where the 1st instance of 'str' after 'pos' occurs or -1 if not found.

Todo:: Want to implement all the methods that the std::string class implements this way people who are familiar with the std::string class will find using this class easier.

param name='str'> String that you are searching for.

param name='pos'> The starting position to start the search from.

returns> The index where 'str' first occurs at or after 'pos' otherwise -1 if not found.

Definition at line 3931 of file KKStr.cpp.

References Len(), SearchStr(), and Str().

 {
   return  SearchStr (val, len, pos, str.Str (), str.Len ());
 }

kkint32 KKStr::Find	(	const char *	s,
		kkint32	pos,
		kkint32	n
	)		const

Definition at line 3938 of file KKStr.cpp.

References SearchStr().

 {
   return  SearchStr (val, len, pos, s, n);
 }

kkint32 KKStr::Find	(	const char *	s,
		kkint32	pos = `0`
	)		const

Definition at line 3945 of file KKStr.cpp.

Referenced by Contains().

 {
   return  SearchStr (val, len, pos, s, (kkint32)strlen (s));
 }

kkint32 KKStr::Find	(	char	c,
		kkint32	pos = `0`
	)		const

Definition at line 3952 of file KKStr.cpp.

Referenced by KKB::PointList::FromDelStr().

 {
   for  (kkint32 x = pos;  x < len;  x++)
   {
     if  (val[x] == c)
       return  x;
   }
   return -1;
 }

char KKStr::FirstChar ( ) const

Returns the first character in the string; if the string is empty returns 0.

Definition at line 1970 of file KKStr.cpp.

Referenced by KKMLL::FeatureFileIODstWeb::AttrDescLine::AttrDescLine(), KKMLL::TrainingClass::ExpandedDirectory(), KKB::PointList::FromDelStr(), KKMLL::FeatureFileIODstWeb::GetFileDesc(), KKB::XmlStream::GetNextContent(), KKB::XmlStream::GetNextToken(), KKMLL::FeatureFileIODstWeb::LoadFile(), KKB::osCreateDirectoryPath(), KKMLL::ModelParam::ParseCmdLine(), ToLatitude(), and ToLongitude().

 {
   if  (val == NULL)
     return 0;
 
   return  val[0];
 }

void KKStr::FreeUpUnUsedSpace ( )

Alloocated space s significanly larger than length of string will reallocate to free up unused space.

Definition at line 1980 of file KKStr.cpp.

References Concat(), KKB::KKException::KKException(), and KKStr().

 {
   kkuint32 unUsedSpace = allocatedSize - (len + 1);
   kkuint32 acceptableWaist = allocatedSize / 5;
   if  (unUsedSpace > acceptableWaist)
   {
     kkuint32 neededSpace = len + 1;
     char* newVal = new char[neededSpace];
     if (newVal == NULL)
     {
       KKStr  errMsg(128);
       errMsg << "KKStr::FreeUpUnUsedSpace   ***ERROR***   Allocation of NeededSpace[" << neededSpace << "] characters failed.";
       cerr << endl << errMsg << endl << endl;
       throw KKException(errMsg);
     }
 
     memcpy(newVal, val, len);
     newVal[len] = 0;
     delete[]  val;
     val = newVal;
     allocatedSize = (kkuint16)neededSpace;
   }
 }

KKStr KKStr::GetNextToken2 ( const char * delStr = "\n\t\r " ) const

Retrieves the first token in the string without removing any characters.

Similar to 'ExtractToken2' except it does not remove characters from the string.

Returns: The first token in the string.

Definition at line 3089 of file KKStr.cpp.

References SubStrPart().

 {
   #ifdef  KKDEBUG
   ValidateLen ();
   #endif
 
   if  (!val)
     return "";
   
   kkint32  startCharPos = 0;
 
   while  (startCharPos < len)
   {
     if  (val[startCharPos] != ' ')
       break;
     startCharPos++;
   }
 
   if  (startCharPos >= len)
     return  "";
 
   kkint32  lastCharPos = startCharPos;
 
   while  (lastCharPos < len)
   {
     if  (strchr (delStr, val[lastCharPos]) != NULL)
     {
       // We just found the first delimiter
       lastCharPos--;
       return  SubStrPart (startCharPos, lastCharPos);
     }
     lastCharPos++;
   }
 
   return  SubStrPart (startCharPos);
 }  /* GetNextToken2 */

kkint32 KKStr::InstancesOfChar ( char ch ) const

Returns the number of instances of 'ch' in the string.

Definition at line 2041 of file KKStr.cpp.

Referenced by KKMLL::MLClass::NumHierarchialLevels().

 {
   #ifdef  KKDEBUG
   ValidateLen ();
   #endif
 
   if  (val == NULL)
     return  0;
 
   kkint32  count = 0;
 
   for  (kkuint16 x = 0; x < len;  x++)
   {
     if  (val[x] == ch)
       count++;
   }
 
   return  count;
 }  /* InstancesOfChar */

char KKStr::LastChar ( ) const

Returns the last character in the string but if the string is empty returns 0.

Definition at line 2007 of file KKStr.cpp.

Referenced by KKMLL::FeatureFileIODstWeb::AttrDescLine::AttrDescLine(), KKMLL::FeatureFileIOC45::GetFileDesc(), KKMLL::FeatureFileIODstWeb::LoadFile(), KKB::osAddLastSlash(), KKB::osAddSlash(), KKB::osCreateDirectoryPath(), KKB::osGetDirNameFromPath(), KKB::osGetFileNamePartOfFile(), KKB::osGetListOfDirectories(), KKB::osGetParentDirectoryOfDirPath(), KKB::osGetParentDirPath(), KKB::osGetRootNameOfDirectory(), KKB::osMoveFileBetweenDirectories(), KKB::osParseFileSpec(), and ToPercentage().

 {
   if  (!val)
     return 0;
 
   if  (val[0] == 0)
     return 0;
   else
     return val[len - 1];
 }  /* LastChar */

void KKStr::LeftPad	(	kkint32	width,
		uchar	ch = `' '`
	)

pads the string with enough 'ch' characters on the left side until the string is as long as 'width' characters.

if 'width' is less than the current length of the string then the string will have characters removed the beginning until its 'len' equals 'width'.

Todo:: Need to properly debug through 'KKStr::LeftPad;

Definition at line 2303 of file KKStr.cpp.

References Concat(), KKB::KKException::KKException(), and KKStr().

Referenced by KKMLL::MLClassList::ExtractThreeTitleLines(), KKMLL::ConfusionMatrix2::PrintConfusionMatrixNarrow(), KKMLL::SizeDistribution::ClassTotals::PrintFormatedLine(), and Wide().

 {
   #ifdef  KKDEBUG
   ValidateLen ();
   #endif
 
   if  (width < 0)
   {
     cerr << std::endl;
     cerr << "KKStr::LeftPad (kkint32  width,  char ch)    **** ERROR ****" << std::endl;
     cerr << "                width[" << width << "]  invalid." << std::endl;
     cerr << std::endl;
     width = 0;
   }
 
   kkuint32  neededSpace = (kkuint32)width + 1;
   if (neededSpace >= KKStrIntMax)
   {
     KKStr  errMsg(128);
     errMsg << "KKStr::LeftPad   ***ERROR***   Size of buffer can not fit into String; neededSpace[" << neededSpace << "].";
     cerr << std::endl << errMsg << endl << endl;
     throw KKException(errMsg);
   }
 
   if  (!val)
   {
     len = 0;
     allocatedSize = 0;
   }
 
   if  (neededSpace > allocatedSize)
   {
     GrowAllocatedStrSpace(neededSpace);
   }
 
   if (val == NULL)
   {
     KKStr  errMsg(128);
     errMsg << "KKStr::LeftPad   ***ERROR***   val == NULL; couuld not allocate neededSpace[" << neededSpace << "].";
     cerr << std::endl << errMsg << endl << endl;
     throw KKException(errMsg);
   }
 
 
   if  (len >= (kkuint16)width)
   {
     // 2010-04-20
     // This code has never been debugged.  So the first time we run it
     // we want to make sure that it is doing what I say it is doing.
     /** @todo  Need to properly debug through 'KKStr::LeftPad; */
     kkuint16  toIdx    = 0;
     kkuint16  fromIdx  = len - (kkuint16)width;
     while  (fromIdx < len)
     {
       val[toIdx] = val[fromIdx];
       val[fromIdx] = 0;
       ++toIdx;
       ++fromIdx;
     }
     len = (kkuint16)width;
     val[len] = 0;
   }
   else
   {
     kkint32  fromIdx = len - 1;
     kkint32  toIdx   = width - 1;
     while  (fromIdx >= 0)
     {
       val[toIdx] = val[fromIdx];
       --fromIdx;
       --toIdx;
     }
 
     while  (toIdx >= 0)
     {
       val[toIdx] = ch;
       --toIdx;
     }
 
     len = (kkuint16)width;
     val[len] = 0;
   }
   return;
 }  /* LeftPad */

kkuint32 KKB::KKStr::Len ( ) const

inline

Returns the number of characters in the string.

Definition at line 366 of file KKStr.h.

Referenced by KKB::KKThread::AddMsg(), KKB::TokenBufferStr::EndOfFile(), EndsWith(), ExtractAttribute(), ExtractTokenDouble(), Find(), KKB::PointList::FromDelStr(), KKB::BitString::FromHexStr(), KKMLL::MLClass::GetClassNameFromDirName(), KKMLL::FeatureFileIOC45::GetFileDesc(), KKB::TokenBufferStr::GetNextChar(), KKB::KKStrParser::KKStrParser(), LocateLastOccurrence(), KKB::operator+(), osFileNameMatchesSearchFields(), KKB::osGetDriveLetter(), osLocateEnvStrStart(), KKB::osReadNextLine(), KKB::osReadRestOfLine(), KKB::osSplitDirectoryPathIntoParts(), KKB::osSubstituteInEnvironmentVariables(), KKB::osValidFileNameErrors(), KKMLL::ModelParam::ParseCmdLine(), KKMLL::ModelParamOldSVM::ParseCmdLine(), KKB::TokenBufferStr::PeekNextChar(), QuotedStr(), KKMLL::ModelDual::ReconcilePredictions(), StripOutAnyComments(), StripOutInvalidLatexCaracters(), SVM233::svm_parameter::svm_parameter(), KKB::TimeType::TimeType(), ToPercentage(), ToXmlStr(), Wide(), KKLSC::ScannerFile::WriteInstrumentDataWord(), and KKB::XmlContent::WriteXml().

kkint32 KKStr::LocateCharacter ( char ch ) const

Returns index of 1st occurrence of 'ch' otherwise -1.

Definition at line 2021 of file KKStr.cpp.

Referenced by KKMLL::FeatureNumList::ExtractFeatureNumsFromStr(), KKMLL::MLClassList::ExtractTwoTitleLines(), KKMLL::FeatureFileIODstWeb::GetFileDesc(), KKB::osGetFileNamePartOfFile(), KKB::osGetListOfDirectories(), KKB::osLocateFirstSlashChar(), KKB::osParseFileSpec(), KKB::osSubstituteInEnvironmentVariables(), KKLSC::Variables::SubstituteInEnvironmentVariables(), ToLatitude(), ToLongitude(), and ToVectorInt32().

 {
   if  (!val)
     return  -1;
 
   kkint32  idx    = 0;
 
   while  (idx < len)
   {
     if  (val[idx] == ch)
       return  idx;
     idx++;
   }
 
   return  -1;
 }  /* LocateCharacter */

kkint32 KKStr::LocateLastOccurrence ( char ch ) const

Returns index of last occurrence of 'ch' otherwise -1.

Returns the position of the last occurrence of the character 'ch'.

A return of -1 indicates that there is no occurrence of 'ch' in the string.

Definition at line 2118 of file KKStr.cpp.

Referenced by KKMLL::DuplicateImage::ExampleWithSmallestScanLine(), KKMLL::MLClass::GetClassNameFromDirName(), KKMLL::FeatureFileIOC45::LoadFeatureFile(), KKB::osGetParentDirectoryOfDirPath(), KKB::osGetParentDirPath(), KKB::osGetPathPartOfFile(), KKB::osGetRootName(), KKB::osGetRootNameOfDirectory(), KKB::osGetRootNameWithExtension(), KKB::osLocateLastSlashChar(), KKB::osParseFileName(), KKB::osParseFileSpec(), and KKB::osRemoveExtension().

 {
   #ifdef  KKDEBUG
   ValidateLen ();
   #endif
 
   if  (!val)
     return -1;
 
   bool   found  = false;
   kkint32  idx    = len - 1;
 
   while  ((idx >= 0)  &&  (!found))
   {
     if  (val[idx] == ch)
       found = true;
     else
       idx--;
   }
 
   if  (found)
     return  idx;
   else
     return  -1;
 }  /* LocateLastOccurrence */

kkint32 KKStr::LocateLastOccurrence ( const KKStr & s ) const

Returns index of last occurrence of 's' otherwise -1.

Returns the position of the last occurrence of the string 's'.

A return of -1 indicates that there is no occurrence of 's' in the string.

Definition at line 2151 of file KKStr.cpp.

References Len().

 {
   kkint32  sLen = s.Len ();
 
   if  ((!val)  ||  (!s.val)  ||  (sLen <= 0)  ||  (sLen > len))
     return -1;
 
   bool  found  = false;
   kkint32 idx    = len - sLen;
 
   char*  sVal = s.val;
 
   while  ((idx >= 0)  &&  (!found))
   {
     if  (strncmp (val + idx, sVal, sLen) == 0)
       found = true;
     else
       idx--;
   }
 
   if  (found)
     return  idx;
   else
     return  -1;
 }  /* LocateLastOccurrence */

kkint32 KKStr::LocateNthOccurrence	(	char	ch,
		kkint32	x
	)		const

Definition at line 2179 of file KKStr.cpp.

 {
   if  (!val)
     return -1;
 
   kkint32 numInstances = 0;
   kkint32  x = 0;
   while  ((x < len)  &&  (numInstances < n))
   {
     if  (val[x] == ch)
       ++numInstances;
     ++x;
   }
 
   if  (numInstances < n)
     return -1;
   else
     return (x - 1);
 }

kkint32 KKStr::LocateStr ( const KKStr & searchStr ) const

Returns index of 1st occurrence of 'searchStr' otherwise -1.

returns the position of the 1st occurrence of the string 'searchStr'.

A return of -1 indicates that there is no occurrence of 'searchStr' in the string.

Definition at line 2091 of file KKStr.cpp.

References MemCompare().

 {
   if  ((!val)  ||  (!(searchStr.val)))
     return  -1;
 
   kkint32  idx = 0;
 
   kkint32  lastIdx = len - searchStr.len;
 
   while  (idx <= lastIdx)
   {
     if  (MemCompare (val, searchStr.val, idx, 0, searchStr.len) == 0)
       return idx;
     idx++;
   }
 
   return -1;
 }; // LocateStr

void KKStr::LopOff ( kkint32 lastCharPos )

Trims off all characters after the 'lastCharPos' index; to make an empty string you would have to specify -1.

Remove characters from the end of the string.

Removes characters from end of string starting at position 'lastCharPos'. If 'lastCharPos' is greater than length of string will do nothing. If 'lastCharPos' is less than or equal to '0' will delete all characters from string.

Parameters

[in] lastCharPos Will remove all characters starting at 'lastCharPos' from end of string.

Definition at line 2866 of file KKStr.cpp.

 {
   #ifdef  KKDEBUG
   ValidateLen ();
   #endif
 
   if  (lastCharPos >= len)
     return;
 
   if  (lastCharPos < -1)
     lastCharPos = -1;
 
   kkuint16  newLen = (kkuint16)(lastCharPos + 1);
   while  (len > newLen)
   {
     len--;
     val[len] = 0;
   }
 }  /* LoppOff */

void KKStr::Lower ( )

Make all characters in the String into lower case.

Converts all characters in string to their Lower case equivalents via 'tolower'.

See also: ToLower

Definition at line 2482 of file KKStr.cpp.

Referenced by ToLower().

 {
   #ifdef  KKDEBUG
   ValidateLen ();
   #endif
 
   if  (!val)
     return;
 
   kkuint32  x;
 
   for  (x = 0; x < len; x++)
     val[x] = (uchar)tolower (val[x]);
 }  /* Lower */

KKStr KKStr::MaxLen ( kkuint32 maxLen ) const

Returns a string that will not be longer that 'maxLen'; any chracters beyond that length will be chopped off.

Definition at line 2499 of file KKStr.cpp.

References SubStrPart().

 {
   maxLen = Max ((kkuint32)0, maxLen);
   if  (len < maxLen)
     return *this;
   else
     return SubStrPart (0, maxLen - 1);
 }

kkuint32 KKStr::MaxLenSupported ( ) const

Returns the maximum String Length that this string can support.

Definition at line 2510 of file KKStr.cpp.

Referenced by KKB::osReadRestOfLine(), and RightPad().

 {
   return KKStrIntMax - 1;
 }

void KKStr::MemCpy	(	void *	dest,
		void *	src,
		kkuint32	size
	)

static

Definition at line 4338 of file KKStr.cpp.

 {
 
   if  (dest == NULL)
   {
     cerr << endl << "KKStr::MemCpy   ***ERROR***    (dest == NULL)" << endl << endl;
   }
 
   else if  (src == NULL)
   {
     cerr << endl << "KKStr::MemCpy   ***ERROR***    (src == NULL)" << endl << endl;
   }
 
   else
   {
     memcpy (dest, src, size);
   }
 }

kkint32 KKStr::MemoryConsumedEstimated ( ) const

Definition at line 766 of file KKStr.cpp.

 {
   return sizeof (char*) + 2 * sizeof (kkuint16) + allocatedSize;
 }

void KKStr::MemSet	(	void *	dest,
		kkuint8	byte,
		kkuint32	size
	)

static

Definition at line 4362 of file KKStr.cpp.

 {
   if  (dest == NULL)
   {
     cerr << "KKStr::MemSet  ***ERROR***    (dest == NULL)" << endl;
     return;
   }
 
   memset (dest, byte, size);
 }

bool KKStr::operator!= ( const KKStr & right ) const

Definition at line 1558 of file KKStr.cpp.

References Compare().

Referenced by KKMLL::FeatureVectorList::ExtractDuplicatesByRootImageFileName(), KKB::Tokenizer::GetNextTokens(), KKB::XmlTokenizer::GetNextTokens(), KKMLL::FileDesc::MergeSymbolicFields(), KKMLL::Attribute::operator==(), and KKMLL::FileDesc::SameExceptForSymbolicData().

 {
   return  (Compare (right) != 0);
 }

bool KKStr::operator!= ( KKStrConstPtr right ) const

Definition at line 1577 of file KKStr.cpp.

References Compare().

 {
   if  (!right)
     return true;
 
   return  (Compare (*right) != 0);
 }

bool KKStr::operator!= ( const char * rtStr ) const

Definition at line 1596 of file KKStr.cpp.

References StrEqual().

Referenced by KKMLL::FeatureFileIODstWeb::GetFileDesc(), KKMLL::FeatureFileIOUCI::GetFileDesc(), and KKMLL::FeatureFileIOUCI::LoadFile().

 {
   return  (!StrEqual (val, rtStr));
 }

bool KKStr::operator!= ( const std::string right ) const

Definition at line 1611 of file KKStr.cpp.

 {
   return  (Compare (right) != 0);
 }

KKStr KKStr::operator+ ( const char * right ) const

Definition at line 3986 of file KKStr.cpp.

References Append(), Concat(), and KKStr().

 {
   kkint32  resultStrLen = len + (kkint32)strlen (right);
   KKStr  result (resultStrLen + 1);
   result.Append (*this);
   result.Append (right);
   return  result;
 }

KKStr KKStr::operator+ ( const KKStr & right ) const

Definition at line 3998 of file KKStr.cpp.

References Append(), Concat(), and KKStr().

Referenced by KKB::BmpImage::BlueRow(), KKB::Application::BuildDate(), KKMLL::FeatureEncoder2::CreateEncodedFileDesc(), KKMLL::FeatureEncoder::CreateEncodedFileDesc(), KKMLL::TrainingConfiguration2::CreateFromDirectoryStructure(), KKB::DateTime::DateTime(), KKMLL::ModelDual::Description(), KKMLL::Model::Description(), KKMLL::TrainingClass::ExpandedDirectory(), KKMLL::FeatureFileIO::FeatureDataReSink(), KKMLL::FeatureEncoder::FeatureEncoder(), KKMLL::TrainingConfiguration2::GetEffectiveConfigFileName(), KKB::TimeType::HH_MM_SS(), KKB::DateTime::HH_MM_SS(), KKB::TimeType::HHMMSS(), KKB::BmpImage::ImageRow(), KKMLL::FeatureFileIOColumn::LoadFile(), KKMLL::FeatureFileIOUCI::LoadFile(), KKMLL::FeatureFileIOC45::LoadFile(), KKMLL::FeatureFileIO::LoadInSubDirectoryTree(), KKMLL::TrainingConfiguration2::LoadOtherClasssExamples(), KKB::operator+(), KKB::operator<<(), KKB::osCreateUniqueFileName(), KKB::osGetDirNameFromPath(), KKB::osGetListOfFilesInDirectoryTree(), KKB::osLookForFile(), KKB::osSubstituteInEnvironmentVariables(), KKB::BmpImage::RedRow(), KKB::Raster::SegmentImage(), KKLSC::Variables::SubstituteInEnvironmentVariables(), KKMLL::ModelParamKnn::ToCmdLineStr(), KKMLL::ModelParamSvmBase::ToCmdLineStr(), KKB::PixelValue::ToStr(), KKB::DateTime::YYYY_MM_DD_HH_MM_SS(), and KKB::DateTime::YYYYMMDDHHMMSS().

 {
   kkint32  resultStrLen = len + right.len;
 
   KKStr  result (resultStrLen + 1);
   result.Append (*this);
   result.Append (right);
   return  result;
 }

KKStr KKStr::operator+ ( kkint16 right ) const

Definition at line 4010 of file KKStr.cpp.

References Append(), Concat(), KKStr(), and KKB::SPRINTF().

 {
   char  buff[60];
   SPRINTF (buff, sizeof (buff), "%-ld", right);
   kkint32  resultStrLen = len + (kkint32)strlen (buff);
   KKStr  result (resultStrLen + 1);
   result.Append (*this);
   result.Append (buff);
   return  result;
 }

KKStr KKStr::operator+ ( kkuint16 right ) const

Definition at line 4022 of file KKStr.cpp.

References Append(), Concat(), KKStr(), and KKB::SPRINTF().

 {
   char  buff[30];
   SPRINTF (buff, sizeof (buff), "%u", right);
 
   kkint32  resultStrLen = len + (kkint32)strlen (buff);
   KKStr  result (resultStrLen + 1);
   result.Append (*this);
   result.Append (buff);
   return  result;
 }

KKStr KKStr::operator+ ( kkint32 right ) const

Definition at line 4036 of file KKStr.cpp.

References Append(), Concat(), KKStr(), and KKB::SPRINTF().

Referenced by KKB::GoalKeeperSimple::EndBlock(), and KKB::GoalKeeper::EndBlock().

 {
   char  buff[60];
   SPRINTF (buff, sizeof (buff), "%-ld", right);
 
   kkint32  resultStrLen = len + (kkint32)strlen (buff);
   KKStr  result (resultStrLen + 1);
   result.Append (*this);
   result.Append (buff);
   return  result;
 }

KKStr KKStr::operator+ ( kkuint32 right ) const

Definition at line 4050 of file KKStr.cpp.

References Append(), Concat(), KKStr(), and KKB::SPRINTF().

 {
   char  buff[30];
   SPRINTF (buff, sizeof (buff), "%u", right);
 
   kkint32  resultStrLen = len + (kkint32)strlen (buff);
   KKStr  result (resultStrLen + 1);
   result.Append (*this);
   result.Append (buff);
   return  result;
 }

KKStr KKStr::operator+ ( kkint64 right ) const

Definition at line 4064 of file KKStr.cpp.

References Append(), Concat(), KKStr(), and KKB::SPRINTF().

 {
   char  buff[70];
   SPRINTF (buff, sizeof (buff), "%-lld", right);
 
   kkint32  resultStrLen = len + (kkint32)strlen (buff);
   KKStr  result (resultStrLen + 1);
   result.Append (*this);
   result.Append (buff);
   return  result;
 }

KKStr KKStr::operator+ ( kkuint64 right ) const

Definition at line 4078 of file KKStr.cpp.

References Append(), Concat(), KKStr(), and KKB::SPRINTF().

 {
   char  buff[70];
   SPRINTF (buff, sizeof (buff), "%-llu", right);
 
   kkint32  resultStrLen = len + (kkint32)strlen (buff);
   KKStr  result (resultStrLen + 1);
   result.Append (*this);
   result.Append (buff);
   return  result;
 }

KKStr KKStr::operator+ ( float right ) const

Definition at line 4092 of file KKStr.cpp.

References Append(), Concat(), KKStr(), and KKB::SPRINTF().

 {
   char  buff[60];
 
   SPRINTF (buff, sizeof (buff), "%.9g", right);
 
   kkint32  resultStrLen = len + (kkint32)strlen (buff);
   KKStr  result (resultStrLen + 1);
   result.Append (*this);
   result.Append (buff);
   return  result;
 }

KKStr KKStr::operator+ ( double right ) const

Definition at line 4107 of file KKStr.cpp.

References Append(), Concat(), KKStr(), and KKB::SPRINTF().

 {
   char  buff[60];
   SPRINTF (buff, sizeof (buff), "%.17g", right);
 
   kkint32 resultStrLen = len + (kkint32)strlen (buff);
   KKStr  result (resultStrLen + 1);
   result.Append (*this);
   result.Append (buff);
   return  result;
 }

KKStr& KKB::KKStr::operator+= ( const char * right )

inline

Definition at line 681 of file KKStr.h.

681 {return *this << right;}

KKStr& KKB::KKStr::operator+= ( const KKStr & right )

inline

Definition at line 682 of file KKStr.h.

Referenced by KKMLL::ModelDual::ReconcilePredictions().

682 {return *this << right;}

KKStr& KKB::KKStr::operator+= ( kkint16 right )

inline

Definition at line 683 of file KKStr.h.

683 {return *this << right;}

KKStr& KKB::KKStr::operator+= ( kkuint16 right )

inline

Definition at line 684 of file KKStr.h.

684 {return *this << right;}

KKStr& KKB::KKStr::operator+= ( kkint32 right )

inline

Definition at line 685 of file KKStr.h.

685 {return *this << right;}

KKStr& KKB::KKStr::operator+= ( kkuint32 right )

inline

Definition at line 686 of file KKStr.h.

686 {return *this << right;}

KKStr& KKB::KKStr::operator+= ( kkint64 right )

inline

Definition at line 687 of file KKStr.h.

687 {return *this << right;}

KKStr& KKB::KKStr::operator+= ( kkuint64 right )

inline

Definition at line 688 of file KKStr.h.

688 {return *this << right;}

KKStr& KKB::KKStr::operator+= ( float right )

inline

Definition at line 689 of file KKStr.h.

689 {return *this << right;}

KKStr& KKB::KKStr::operator+= ( double right )

inline

Definition at line 690 of file KKStr.h.

690 {return *this << right;}

bool KKStr::operator< ( const KKStr & right ) const

Definition at line 1635 of file KKStr.cpp.

References Compare().

Referenced by KKB::KKStrList::BinarySearch(), KKMLL::FeatureVectorList::BinarySearchByName(), KKMLL::FeatureVectorList::LookUpByRootName(), KKMLL::FeatureFileIODstWeb::AttrDescLineComparator::operator()(), KKMLL::ClassStatisticList::ClassStatisticSortComparrison::operator()(), KKMLL::ClassStatisticList::ClassStatSortByCount::operator()(), KKMLL::MLClassList::MLClassNameComparison::operator()(), KKMLL::FeatureVectorList::ImageFileNameComparison::operator()(), KKMLL::FeatureVectorList::RootNameComparrison::operator()(), KKMLL::FeatureVectorList::ClassNameComparrison::operator()(), and KKMLL::FeatureVectorList::ClassNameComparrisonReversed::operator()().

 {
   return  (Compare (right) < 0);
 }

KKStr & KKStr::operator<< ( const char * right )

Definition at line 4129 of file KKStr.cpp.

References Append(), and KKB::KKException::KKException().

 {
   if  (!right)
   {
     const char*  msg = "KKStr&  operator<<(const char*  right)    **** ERROR ****  right==NULL";
     cerr << std::endl << msg <<  std::endl << std::endl;
     throw KKException (msg);
   }
 
   Append (right);
   return  *this;
 }

KKStr & KKStr::operator<< ( const KKStr & right )

Definition at line 4144 of file KKStr.cpp.

References Append(), and Str().

 {
   Append (right.Str ());
   return  *this;
 }

KKStr & KKStr::operator<< ( KKStr && right )

Definition at line 4151 of file KKStr.cpp.

References Append(), and Str().

 {
   if  (len < 1)
   {
     val           = right.val;
     len           = right.len;
     allocatedSize = right.allocatedSize;
 
     right.val           = NULL;
     right.len           = 0;
     right.allocatedSize = 0;
   }
   else
   {
     Append (right.Str ());
   }
   
   return  *this;
 }

KKStr & KKStr::operator<< ( char right )

Definition at line 4121 of file KKStr.cpp.

References Append().

 {
   Append (right);
   return  *this;
 }

KKStr & KKStr::operator<< ( kkint16 right )

Definition at line 4174 of file KKStr.cpp.

References AppendInt32().

 {
   AppendInt32 (right);
   return  *this;
 }

KKStr & KKStr::operator<< ( kkuint16 right )

Definition at line 4182 of file KKStr.cpp.

References AppendUInt32().

 {
   AppendUInt32 (right);
   return  *this;
 }

KKStr & KKStr::operator<< ( kkint32 right )

Definition at line 4190 of file KKStr.cpp.

References AppendInt32().

 {
   AppendInt32 (right);
   return  *this;
 }

KKStr & KKStr::operator<< ( kkuint32 right )

Definition at line 4198 of file KKStr.cpp.

References AppendUInt32().

 {
   AppendUInt32 (right);
   return  *this;
 }

KKStr & KKStr::operator<< ( kkint64 right )

Definition at line 4206 of file KKStr.cpp.

References Append(), Concat(), KKStr(), operator=(), Str(), and KKB::StrFormatInt64().

 {
   KKStr  s (30);
   s = StrFormatInt64 (right, "0");
   Append (s.Str ());
   return  *this;
 }

KKStr & KKStr::operator<< ( kkuint64 right )

Definition at line 4216 of file KKStr.cpp.

References Append(), Concat(), KKStr(), operator=(), Str(), and KKB::StrFormatInt64().

 {
   KKStr  s (30);
   s = StrFormatInt64 (right, "0");
   Append (s.Str ());
   return  *this;
 }

KKStr & KKStr::operator<< ( float right )

Definition at line 4226 of file KKStr.cpp.

References Append(), and KKB::SPRINTF().

 {  
   char  buff[60];
   SPRINTF (buff, sizeof (buff), "%.9g", right);
   if  (strchr (buff, '.') != NULL)
   {
     // Remove trailing Zeros
     kkint32  buffLen = (kkint32)strlen (buff);
     while  ((buffLen > 1)  &&  (buff[buffLen - 1] == '0')  &&  (buff[buffLen - 2] == '0'))
     {
       buffLen--;
       buff[buffLen] = 0;
     }
   }
   Append (buff);
   return *this;
 }

KKStr & KKStr::operator<< ( double right )

Definition at line 4246 of file KKStr.cpp.

References Append(), and KKB::SPRINTF().

 {  
   char  buff[70];
   SPRINTF (buff, sizeof (buff), "%.17g", right);
   if  (strchr (buff, '.') != NULL)
   {
     // Remove trailing Zeros
     kkint32  buffLen = (kkint32)strlen (buff);
     while  ((buffLen > 1)  &&  (buff[buffLen - 1] == '0')  &&  (buff[buffLen - 2] == '0'))
     {
       buffLen--;
       buff[buffLen] = 0;
     }
   }
   Append (buff);
   return *this;
 }

KKStr & KKStr::operator<< ( std::ostream &(*)(std::ostream &) mf )

Definition at line 5244 of file KKStr.cpp.

 {
   ostringstream  o;
   mf (o);
   Append (o.str ().c_str ());
   return  *this;
 }

bool KKStr::operator<= ( const KKStr & right ) const

Definition at line 1642 of file KKStr.cpp.

References Compare().

 {
   return  (Compare (right) <= 0);
 }

KKStr & KKStr::operator= ( const KKStr & src )

Definition at line 1390 of file KKStr.cpp.

References KKB::KKException::KKException().

Referenced by KKMLL::ConfusionMatrix2::AccuracyStr(), KKLSC::ScannerFileEntry::Assign(), KKB::RunLog::AttachFile(), KKB::RunLog::AttachFileAppend(), KKMLL::TrainingProcess2::BuildTrainingProcess(), KKMLL::Classifier2::Classifier2(), KKMLL::FileDesc::ClassNameAttribute(), KKLSC::ScannerFileEntry::Description(), KKMLL::MLClass::Description(), KKMLL::FeatureVector::ExampleFileName(), KKB::KKThread::ExceptionText(), KKMLL::FeatureVectorList::ExtractDuplicatesByRootImageFileName(), KKMLL::MLClassList::ExtractThreeTitleLines(), KKMLL::FeatureFileIO::FeatureDataReSink(), KKMLL::TrainingClass::FeatureFileName(), KKMLL::FileDesc::FileName(), KKMLL::ModelParam::FileName(), KKMLL::FeatureVectorList::FileName(), KKB::Raster::FileName(), KKMLL::ConfusionMatrix2::FMeasure(), KKB::PointList::FromDelStr(), KKLSC::ScannerFileEntry::FullName(), KKMLL::FeatureFileIODstWeb::GetFileDesc(), KKMLL::FeatureFileIOC45::GetFileDesc(), KKB::Configuration::Load(), KKMLL::TrainingConfiguration2::Load(), KKMLL::FeatureFileIOC45::LoadFeatureFile(), KKMLL::FeatureFileIOC45::LoadFile(), KKMLL::TrainingConfiguration2::LoadOtherClasssExamples(), KKMLL::Model::Name(), KKLSC::ScannerFile::Open(), KKMLL::Attribute::operator=(), KKMLL::Orderings::Orderings(), KKB::osGetRootName(), KKB::osGetRootNameOfDirectory(), KKB::osGetRootNameWithExtension(), KKB::osParseFileName(), KKB::osParseFileSpec(), KKMLL::Attribute::ReadXML(), KKMLL::TrainingClassList::RootDir(), KKMLL::TrainingConfiguration2::RootDir(), KKMLL::Model::RootFileName(), KKLSC::ScannerFileEntry::RootName(), KKB::RunLog::RunLog(), KKB::BmpImage::Save(), KKMLL::Orderings::Save(), KKB::BmpImage::SaveGrayscaleInverted4Bit(), KKB::BmpImage::SaveGrayscaleInverted8Bit(), KKLSC::Variables::SetHomeDir(), KKMLL::KKMLVariables::SetMachineLearninigHomeDir(), KKMLL::TrainingClass::SubClassifierName(), SVM233::svm_parameter::svm_parameter(), KKB::Raster::TakeOwnershipOfAnotherRastersData(), KKB::Raster::Title(), ToLatitude(), ToLongitude(), KKB::RunLog::WriteLine(), and KKMLL::NormalizationParms::WriteToFile().

 {
   #ifdef  KKDEBUG
   ValidateLen ();
   src.ValidateLen ();
   #endif
 
   if  (&src == this)
   {
     // We are assigning our selves to our selves;  there is nothing to do.
     return *this;
   }
 
   kkuint16  spaceNeeded = src.len + 1;
   if  ((spaceNeeded > allocatedSize)  ||  (!val))
   {
     delete  val;
     val = NULL;
     allocatedSize = 0;
     AllocateStrSpace (spaceNeeded);
     if  (!val)
       throw KKException ("KKStr::operator=");
   }
   else
   {
     memset (val, 0, allocatedSize);
   }
 
   if  (src.val)
     memcpy (val, src.val, src.len);
 
   len = src.len;
   val[len] = 0;
 
   return *this;
 }

KKStr & KKStr::operator= ( KKStr && src )

Definition at line 1369 of file KKStr.cpp.

Referenced by KKMLL::FeatureFileIODstWeb::AttrDescLine::AttrDescLine(), KKMLL::ClassificationBiasMatrix::ClassificationBiasMatrix(), KKMLL::TrainingConfiguration2::CreateFromDirectoryStructure(), KKMLL::ClassProbList::CreateFromXMLStream(), KKMLL::TrainingClass::ExpandedDirectory(), ExtractAttribute(), KKMLL::FeatureVectorList::ExtractDuplicatesByRootImageFileName(), KKMLL::FeatureNumList::ExtractFeatureNumsFromStr(), KKMLL::MLClassList::ExtractThreeTitleLines(), KKMLL::FeatureFileIO::FeatureDataReSink(), KKB::PointList::FromDelStr(), GetClassNameByHierarchyLevel(), KKMLL::MLClass::GetClassNameFromDirName(), KKMLL::TrainingConfiguration2::GetEffectiveConfigFileName(), KKMLL::FeatureFileIOC45::GetFileDesc(), KKMLL::FeatureFileIOUCI::GetFileDesc(), KKMLL::TrainingConfiguration2::Load(), KKMLL::FeatureFileIOC45::LoadFeatureFile(), KKMLL::FeatureFileIODstWeb::LoadFile(), KKMLL::FeatureFileIOC45::LoadFile(), KKLSC::ScannerFile::LoadIndexFile(), KKMLL::FeatureFileIO::LoadInSubDirectoryTree(), KKMLL::TrainingConfiguration2::LoadOtherClasssExamples(), KKLSC::ScannerFile::Open(), KKB::operator<<(), KKB::RunLog::operator<<(), operator<<(), KKMLL::Orderings::Orderings(), KKB::osCreateDirectoryPath(), KKB::osCreateUniqueFileName(), KKB::osGetRootName(), KKB::osGetRootNameOfDirectory(), KKB::osGetRootNameWithExtension(), KKB::osParseFileName(), KKB::osParseFileSpec(), KKB::osSubstituteInEnvironmentVariables(), KKMLL::ModelParam::ParseCmdLine(), KKMLL::ModelParamOldSVM::ParseCmdLine(), KKLSC::ScannerFileEntry::ParseTabDelStr(), KKMLL::ConfusionMatrix2::PrintAccuracyByProbByClassHTML(), KKMLL::ModelDual::ProbabilitiesByClassDual(), KKMLL::Model::ProbabilitiesByClassDual(), KKB::ReadImagePGM(), KKB::ReadImagePPM(), KKMLL::AttributeTypeVector::ReadXML(), KKMLL::Attribute::ReadXML(), KKMLL::ModelParamOldSVM::ReadXML(), KKMLL::ModelParam::ReadXMLModelParamToken(), KKMLL::Model::ReadXMLModelToken(), KKMLL::TrainingConfiguration2::RootDir(), KKLSC::ScannerFile::SaveIndexFile(), KKMLL::TrainingProcess2::SaveTrainingProcess(), KKJobManagment::KKJobManager::StatusFileProcessLine(), StripOutAnyComments(), KKLSC::Variables::SubstituteInEnvironmentVariables(), SVM233::svm_parameter::svm_parameter(), KKB::TimeType::TimeType(), KKMLL::ModelParamSvmBase::ToCmdLineStr(), KKMLL::ModelParamDual::ToCmdLineStr(), KKMLL::ModelParamOldSVM::ToCmdLineStr(), ToLatitude(), ToLongitude(), KKMLL::SVMparam::ToString(), ToVectorInt32(), Wide(), and KKB::XmlTag::XmlTag().

 {
   #ifdef  KKDEBUG
   ValidateLen ();
   src.ValidateLen ();
   #endif
 
   delete  val;
   val           = src.val;
   allocatedSize = src.allocatedSize;
   len           = src.len;
   src.val           = NULL;
   src.allocatedSize = 0;
   src.len           = 0;
 
   return *this;
 }

KKStr & KKStr::operator= ( const char * src )

Definition at line 1442 of file KKStr.cpp.

References KKB::STRCOPY().

 {
   #ifdef  KKDEBUG
   ValidateLen ();
   #endif
 
   if  (!src)
   {
     delete  val;
     val = NULL;
     allocatedSize = 0;
     AllocateStrSpace (10);
     len = 0;
     return *this;
   }
 
   kkuint16  newLen = (kkuint16)strlen (src);
   kkuint16  spaceNeeded = newLen + 1;
 
   if  (spaceNeeded > allocatedSize)
   {
     delete  val;
     val = NULL;
     allocatedSize = 0;
     AllocateStrSpace (spaceNeeded);
   }
 
   STRCOPY (val, allocatedSize, src);
   len = newLen;
  
   return *this;
 }

KKStr & KKStr::operator= ( kkint32 right )

Definition at line 1478 of file KKStr.cpp.

References KKB::SPRINTF(), and KKB::STRCOPY().

Referenced by KKMLL::SizeDistribution::ClassTotals::PrintFormatedLine().

 {
   #ifdef  KKDEBUG
   ValidateLen ();
   #endif
 
   char  buff[60];
   SPRINTF (buff, sizeof (buff), "%d", right);
 
   kkuint16  newLen = (kkuint16)strlen (buff);
 
   kkuint16  spaceNeeded = newLen + 1;
 
   if  (spaceNeeded > allocatedSize)
   {
     delete  val;
     val = NULL;
     allocatedSize = 0;
     AllocateStrSpace (spaceNeeded);
   }
 
   memset (val, 0, allocatedSize);
 
   STRCOPY (val, allocatedSize, buff);
   len = newLen;
 
   return *this;
 }

KKStr & KKStr::operator= ( const std::vector< KKStr > & right )

Definition at line 1509 of file KKStr.cpp.

References Concat(), and KKB::KKException::KKException().

 {
   kkint32  spaceNeeded = 2;  /* Start with 2 bytes for overhead. */
   kkuint32  x = 0;
   for  (x = 0;  x < right.size ();  x++)
     spaceNeeded += right[x].Len ();
 
   if  (spaceNeeded > allocatedSize)
   {
     delete  val;
     val = NULL;
     allocatedSize = 0;
     AllocateStrSpace (spaceNeeded);
   }
 
   if  (!val)
   {
     KKStr  errMsg = "KKStr::operator= (const std::vector<KKStr>& right)   ***ERROR***   Space for string not allocatd!";
     cerr << endl << errMsg << endl <<endl;
     throw KKException (errMsg);
   }
 
   char*  ptr = val;
   kkint32  allocatedSpaceNotUsed = allocatedSize - 1;
   for  (x = 0;  x < right.size ();  x++)
   {
     kkint32  rightLen = right[x].Len ();
 #ifdef  USE_SECURE_FUNCS
     strncpy_s (ptr, allocatedSpaceNotUsed, right[x].Str (), rightLen);
 #else
     strncpy   (ptr, right[x].Str (), rightLen);
 #endif
     ptr = ptr + rightLen;
     allocatedSpaceNotUsed -= rightLen;
     *ptr = 0;
   }
   return  *this;
 }

bool KKStr::operator== ( const KKStr & right ) const

Definition at line 1550 of file KKStr.cpp.

References Compare().

Referenced by KKMLL::FeatureVectorList::ExtractDuplicatesByRootImageFileName(), KKMLL::FeatureFileIODstWeb::GetFileDesc(), KKMLL::FeatureFileIODstWeb::LoadFile(), KKMLL::FeatureVectorList::LookUpByRootName(), and KKMLL::ModelDual::ReconcilePredictions().

 {
   return  (Compare (right) == 0);
 }

bool KKStr::operator== ( KKStrConstPtr right ) const

Definition at line 1566 of file KKStr.cpp.

References Compare().

 {
   if  (!right)
     return false;
 
   return  (Compare (*right) == 0);
 }

bool KKStr::operator== ( const char * rtStr ) const

Definition at line 1588 of file KKStr.cpp.

References StrEqual().

Referenced by KKMLL::BinaryClassParms::CreateFromTabDelStr(), KKMLL::ModelParam::EncodingMethodFromStr(), KKMLL::EncodingMethodFromStr(), KKMLL::DuplicateImage::ExampleWithSmallestScanLine(), KKMLL::FeatureNumList::ExtractFeatureNumsFromStr(), ExtractTokenBool(), KKMLL::FeatureFileIOSparse::GetFileDesc(), KKMLL::KernalTypeFromStr(), SVM289_BFS::Kernel_Type_FromStr(), SVM289_MFS::Kernel_Type_FromStr(), KKMLL::FeatureFileIOC45::LoadFeatureFile(), KKMLL::FeatureFileIOC45::LoadFile(), KKB::Configuration::LoadFile(), KKMLL::FeatureFileIO::LoadInSubDirectoryTree(), KKMLL::MachineTypeFromStr(), osFileNameMatchesSearchFields(), KKB::osGetListOfFilesInDirectoryTree(), KKMLL::ModelParam::ParseCmdLine(), KKMLL::SVMparam::ParseCmdLineParameter(), SVM233::svm_parameter::ParseTabDelStr(), SVM289_BFS::svm_parameter::ParseTabDelStr(), SVM289_MFS::svm_parameter::ParseTabDelStr(), SVM233::svm_parameter::ProcessSvmParameter(), KKB::ReadImage(), KKB::SaveImage(), KKMLL::SelectionMethodFromStr(), KKJobManagment::KKJobManager::StatusFileProcessLine(), KKB::SupportedImageFileFormat(), SVM233::svm_parameter::svm_parameter(), SVM289_BFS::SVM_Type_FromStr(), and SVM289_MFS::SVM_Type_FromStr().

 {
   return  StrEqual (val, rtStr);
 }

bool KKStr::operator== ( const std::string right ) const

Definition at line 1603 of file KKStr.cpp.

 {
   return  (Compare (right) == 0);
 }

bool KKStr::operator> ( const KKStr & right ) const

Definition at line 1619 of file KKStr.cpp.

References Compare().

Referenced by KKB::KKStrList::BinarySearch(), KKMLL::FeatureVectorList::BinarySearchByName(), KKMLL::FeatureVectorList::LookUpByRootName(), KKMLL::FeatureVectorList::ImageFileNameComparisonReversed::operator()(), KKMLL::FeatureVectorList::RootNameComparrisonReversed::operator()(), KKMLL::FeatureVectorList::ClassNameComparrison::operator()(), and KKMLL::FeatureVectorList::ClassNameComparrisonReversed::operator()().

 {
   return  (Compare (right) > 0);
 }

bool KKStr::operator>= ( const KKStr & right ) const

Definition at line 1627 of file KKStr.cpp.

References Compare().

 {
   return  (Compare (right) >= 0);
 }

char KKStr::operator[] ( kkint16 i ) const

Returns back the character at position 'i', if i > length of KKStr then returns back 0.

Definition at line 3379 of file KKStr.cpp.

Referenced by KKB::osGetDriveLetter(), KKB::osSubstituteInEnvironmentVariables(), and KKB::ReadImagePGM().

 {
   #ifdef  KKDEBUG
   ValidateLen ();
   #endif
 
   if  (!val)
     return 0;
 
   if  ((i < 0)  ||  ((kkuint16)i >= len))
     return 0;
   else
     return val[i];
 }

char KKStr::operator[] ( kkuint16 i ) const

Returns back the character at position 'i', if i > length of KKStr then returns back 0.

Definition at line 3396 of file KKStr.cpp.

Referenced by KKB::osSplitDirectoryPathIntoParts().

 {
   #ifdef  KKDEBUG
   ValidateLen ();
   #endif
 
   if  (!val)
     return 0;
 
   if  (i >= len)
     return 0;
   else
     return val[i];
 }

char KKStr::operator[] ( kkint32 i ) const

Returns back the character at position 'i', if i > length of KKStr then returns back 0.

Definition at line 3413 of file KKStr.cpp.

Referenced by KKMLL::TrainingClass::ExpandedDirectory(), ExtractAttribute(), KKB::BitString::FromHexStr(), KKB::KKStrParser::GetNextTokenChar(), KKMLL::ModelParamOldSVM::ParseCmdLine(), StripOutAnyComments(), KKLSC::Variables::SubstituteInEnvironmentVariables(), and SVM233::svm_parameter::svm_parameter().

 {
   #ifdef  KKDEBUG
   ValidateLen ();
   #endif
 
   if  (!val)
     return 0;
 
   if  ((i < 0)  ||  ((kkuint16)i >= len))
     return 0;
   else
     return val[i];
 }

char KKStr::operator[] ( kkuint32 i ) const

Returns back the character at position 'i', if i > length of KKStr then returns back 0.

Definition at line 3430 of file KKStr.cpp.

Referenced by KKMLL::MLClass::GetClassNameFromDirName(), KKMLL::FeatureFileIOC45::GetFileDesc(), KKB::TokenBufferStr::GetNextChar(), KKB::osSplitDirectoryPathIntoParts(), KKB::osValidFileNameErrors(), KKB::TokenBufferStr::PeekNextChar(), and StripOutInvalidLatexCaracters().

 {
   #ifdef  KKDEBUG
   ValidateLen ();
   #endif
 
   if  (!val)
     return 0;
 
   if  (i >= len)
     return 0;
   else
     return val[i];
 }

VectorKKStr KKStr::Parse ( const char * delStr = "\n\r\t, " ) const

Will break up the contents of the string into tokens where one of the characters in 'delStr' separates each token.

Definition at line 3461 of file KKStr.cpp.

References Concat(), Empty(), ExtractToken2(), KKStr(), TrimLeft(), and TrimRight().

 {
   KKStr  wrkStr (*this);
   wrkStr.TrimLeft (" ");
   wrkStr.TrimRight (" ");
 
   VectorKKStr  result;
 
   while  (!wrkStr.Empty ())
   {
     KKStr  field = wrkStr.ExtractToken2 (delStr);
     result.push_back (field);
   }
 
   return  result;
 }  /* Parse */

KKStr KKStr::QuotedStr ( ) const

Returns a quoted version of string where special characters Line-Feed, Carriage Return, and Tab, are encoded as escape sequences.

string where 'Line Feed(\n'), Carriage Returns('\r'), Tabs('\t'), and Quotes(") are coded as escape sequences "\n", "\r", "t", or "\". It is then enclosed in quotes(").

Returns: Quoted String.

Definition at line 2890 of file KKStr.cpp.

References Append(), Concat(), KKStr(), and Len().

Referenced by ToQuotedStr(), KKB::XmlTag::ToString(), KKB::KKStrList::WriteXML(), and KKB::KKStrListIndexed::WriteXML().

 {
   if  ((!val)  ||  (len < 1))
   {
     return "\"\"";
   }
   
   
   KKStr  result (Len () + 5);
 
   result.Append ('"');
 
   kkint32  idx = 0;
 
   while  (idx < len)
   {
     switch  (val[idx])
     {
       case  '\"': result.Append ("\\\"");  break;
       case  '\t': result.Append ("\\t");   break;
       case  '\n': result.Append ("\\n");   break;
       case  '\r': result.Append ("\\r");   break;
       case  '\\': result.Append ("\\\\");  break;
       case     0: result.Append ("\\0");   break;
          
       default:     result.Append (val[idx]);   break;
     }
 
     idx++;
   }
 
   result.Append ('"');
 
   return  result;
 }  /* QuotedStr */

void KKStr::ReadXML	(	XmlStream &	s,
		XmlTagConstPtr	tag,
		VolConstBool &	cancelFlag,
		RunLog &	log
	)

Definition at line 4438 of file KKStr.cpp.

References Append(), KKB::XmlTag::AttributeValueInt32(), KKB::XmlContent::Content(), KKB::XmlStream::GetNextToken(), KKB::XmlToken::tokContent, KKB::XmlToken::TokenType(), and TrimRight().

 {
   kkuint16  expectedLen = tag->AttributeValueInt32 ("Len");
   delete val;
   val = NULL;
   allocatedSize = 0;
   if  (expectedLen > 0)
     AllocateStrSpace (expectedLen);
 
   delete  val;
   val = NULL;
   allocatedSize = 0;
   AllocateStrSpace (expectedLen);
 
   XmlTokenPtr  t = s.GetNextToken (cancelFlag, log);
   while  (t  &&  (!cancelFlag))
   {
     if  (t->TokenType () == XmlToken::TokenTypes::tokContent)
     {
       XmlContentPtr c = dynamic_cast<XmlContentPtr> (t);
       Append (*(c->Content ()));
     }
     delete  t;
     if  (cancelFlag)
       t = NULL;
     else
       t = s.GetNextToken (cancelFlag, log);
   }
   delete  t;
   t = NULL;
 
   TrimRight (" \r\n");
 }  /* ReadXML */

void KKStr::RightPad	(	kkint32	width,
		char	ch = `' '`
	)

Pads string on the right side with specified character so that the string will be of specified length.

Parameters

[in]	width	Width that string will need to be; if less than current length then the string will be truncated to 'len'.
[in]	ch	Character to pad with; if not specified will default to space (' ').

Definition at line 2239 of file KKStr.cpp.

References Concat(), KKB::KKException::KKException(), MaxLenSupported(), operator+(), KKB::operator+(), and KKB::StrFromInt32().

Referenced by KKMLL::MLClassList::ExtractThreeTitleLines(), KKMLL::SizeDistribution::ClassTotals::PrintFormatedLine(), Spaces(), and Wide().

 {
   #ifdef  KKDEBUG
   ValidateLen ();
   #endif
 
   if  (width < 0)
   {
     KKStr errMsg = "KKStr::RightPad (kkint32  width,  char ch)    ***ERROR***   width[" + StrFromInt32 (width) + "]  invalid.";
     cerr << endl << errMsg << endl << endl;
     throw KKException(errMsg);
   }
 
   if  ((kkuint32)width > MaxLenSupported ())  {
     KKStr errMsg = "KKStr::RightPad (kkint32  width,  char ch)    ***ERROR***   width[" + StrFromInt32 (width) + "]  greater-than KKStr suppotrts.";
     cerr << endl << errMsg << endl << endl;
     throw KKException(errMsg);
   }
 
   if  (!val)
   {
     AllocateStrSpace (width + 1);
     len = 0;
   }
 
   if  (len > (kkuint16)width)
   {
     len = (kkuint16)width;
     for  (kkint32 x = len;  x < allocatedSize;  x++)
       val[x] = 0;
   }
 
   else
   {
     kkuint32  neededSpace = width + 1;
 
     if  (neededSpace > allocatedSize)
     {
       if  (neededSpace >= KKStrIntMax)
       {
         cerr << std::endl 
              << "KKStr::RightPad   ***ERROR***   Size of buffer can not fit into String." << std::endl
              << "                  neededSpace[" << neededSpace << "]" << std::endl
              << std::endl;
         return;
       }
       GrowAllocatedStrSpace (neededSpace); 
     }
    
     while (len < (kkuint16)width)
     {
       val[len] = ch;
       len++;
     }
 
     val[len] = 0;
   }
 }  /* RightPad */

KKStr KKStr::Spaces ( kkint32 c )

static

Returns a string of spaces 'c' characters long.

Parameters

[in] c Number of space characters to fill the string with.

Definition at line 4329 of file KKStr.cpp.

References Concat(), and RightPad().

Referenced by Wide().

 {
   KKStr s;
   s.RightPad (c);
   return  s;
 }

VectorKKStr KKStr::Split ( const char * delStr = "\n\r\t, " ) const

Breaks up the contents of the string into tokens where the characters in 'delStr' acts as separates each token.

Parameters

[in] delStr List of characters that where any one of them can be a delimiter.

Definition at line 3480 of file KKStr.cpp.

References Concat(), Empty(), ExtractToken2(), KKStr(), TrimLeft(), and TrimRight().

Referenced by KKMLL::FeatureFileIOC45::GetFileDesc().

 {
   KKStr  wrkStr (*this);
   wrkStr.TrimLeft (" ");
   wrkStr.TrimRight (" ");
 
   VectorKKStr  result;
 
   while  (!wrkStr.Empty ())
   {
     KKStr  field = wrkStr.ExtractToken2 (delStr);
     result.push_back (field);
   }
 
   return  result;
 }  /* Split */

VectorKKStr KKStr::Split ( char del ) const

Splits the string up into tokens using 'del' as the separator returning them in a vector.

Definition at line 3500 of file KKStr.cpp.

References Concat(), Empty(), ExtractToken2(), KKStr(), TrimLeft(), and TrimRight().

Referenced by KKMLL::MLClassList::BuildListFromDelimtedStr(), DelimitedStrToArray(), KKMLL::MLClassList::ExtractHTMLTableHeader(), KKMLL::MLClass::MLClassForGivenHierarchialLevel(), KKJobManagment::KKJob::PrerequisitesFromStr(), and KKJobManagment::KKJob::ProcessStatusStr().

 {
   char  delStr[2];
   delStr[0] = del;
   delStr[1] = 0;
 
   KKStr  wrkStr (*this);
   wrkStr.TrimLeft (" ");
   wrkStr.TrimRight (" ");
 
   VectorKKStr  result;
 
   while  (!wrkStr.Empty ())
   {
     KKStr  field = wrkStr.ExtractToken2 (delStr);
     result.push_back (field);
   }
 
   return  result;
 }  /* Parse */

bool KKStr::StartsWith ( const KKStr & value ) const

Definition at line 1137 of file KKStr.cpp.

References StartsWith().

Referenced by KKMLL::ModelDual::ReconcileProbAndVotes().

 {
   return  StartsWith (value, false);
 }

bool KKStr::StartsWith ( const char * value ) const

Definition at line 1144 of file KKStr.cpp.

References StartsWith().

Referenced by KKMLL::ClassProbList::CreateFromXMLStream().

 {
   return  StartsWith (value, false);
 }

bool KKStr::StartsWith	(	const KKStr &	value,
		bool	ignoreCase
	)		const

Definition at line 1150 of file KKStr.cpp.

References StrEqualN(), and StrEqualNoCaseN().

Referenced by StartsWith().

 {
   if  (value.len == 0)
     return true;
 
   if  (value.len > len)
     return  false;
 
   if  (ignoreCase)
     return  StrEqualNoCaseN (val, value.val, value.len);
   else
     return  StrEqualN       (val, value.val, value.len);
 }

bool KKStr::StartsWith	(	const char *	value,
		bool	ignoreCase
	)		const

Definition at line 1169 of file KKStr.cpp.

References StrEqualN(), and StrEqualNoCaseN().

Referenced by KKLSC::ScannerFile::ReportTextMsg(), and StartsWith().

 {
   if  (value == NULL)
     return true;
 
   kkint32  valueLen = (kkint32)strlen (value);
 
   if  (ignoreCase)
     return  StrEqualNoCaseN (val, value, valueLen);
   else
     return  StrEqualN       (val, value, valueLen);
 }

const char* KKB::KKStr::Str ( ) const

inline

Returns a pointer to a ascii string.

Definition at line 422 of file KKStr.h.

Referenced by KKB::BmpImage::BmpImage(), c_str(), data(), EqualIgnoreCase(), Find(), KKLSC::ScannerFile::GuessFormatOfFile(), KKB::KKStrParser::KKStrParser(), KKMLL::FeatureNumList::Load(), KKMLL::MLClassList::Load(), KKB::Configuration::LoadFile(), KKLSC::ScannerFile::LoadIndexFile(), KKLSC::ScannerFile::Open(), KKB::KKStr::LessCaseInsensitiveOperator::operator()(), KKB::operator<<(), KKB::RunLog::operator<<(), operator<<(), KKMLL::FeatureVectorList::OrderUsingNamesFromAFile(), KKB::osDeleteFile(), KKB::osFileExists(), osFileNameMatchesSearchFields(), osLocateEnvStrStart(), KKB::osLookForFile(), KKB::ReadImagePGM(), KKB::ReadImagePPM(), KKB::BmpImage::Save(), KKB::BmpImage::SaveGrayscaleInverted4Bit(), KKB::BmpImage::SaveGrayscaleInverted8Bit(), KKB::SaveImagePGM(), KKB::SaveImagePNG(), KKB::SaveImagePPM(), KKB::KKException::what(), Wide(), KKLSC::ScannerFile::WriteInstrumentDataWord(), and KKB::XmlContent::WriteXml().

const char * KKStr::Str ( const char * s )

static

Definition at line 286 of file KKStr.cpp.

 {
   if  (!s)
     return "";
   else
     return  s;
 }

void KKStr::StrCapitalize ( char * str )

static

Definition at line 4375 of file KKStr.cpp.

Referenced by StrInStr().

 {
   if  (!str)
      return;
   
   char* ch = str;
   while  (*ch)
   {
     *ch = (char)toupper (*ch);
     ch++;
   }
 }

const char * KKStr::StrChr	(	const char *	str,
		int	ch
	)

static

Definition at line 308 of file KKStr.cpp.

 {
   return strchr (str, ch);
 }

kkint32 KKStr::StrCompareIgnoreCase	(	const char *	s1,
		const char *	s2
	)

static

Definition at line 318 of file KKStr.cpp.

Referenced by EqualIgnoreCase().

 {
   if  (s1 == NULL)
   {
     if  (s2 == NULL)
       return 0;
     else
       return -1;
   }
   else if  (s2 == NULL)
     return 1;
 
 
   while  ((*s1)  &&  (*s2)  &&  (toupper (*s1) == toupper (*s2)))
   {
     s1++;
     s2++;
   }
 
   if  (*s1 == 0)
   {
     if  (*s2 == 0)
     {
       return 0;
     }
     else
     {
       // s1 < s2
       return -1;
     }
   }
   else
   {
     if  (*s2 == 0)
     {
       return 1;
     }
     else
     {
       if  (*s1 < *s2)
         return -1;
       else
         return 1;
     }
   }
 
 
   //return  _stricmp (s1, s2);
 }  /* StrCompareIgnoreCase */

void KKStr::StrDelete ( char ** str )

static

Definition at line 296 of file KKStr.cpp.

 {
   if  (*str)
   {
      delete [] *str;
      *str = NULL;      
   }  
 }

bool KKStr::StrEqual	(	const char *	s1,
		const char *	s2
	)

static

Definition at line 373 of file KKStr.cpp.

Referenced by EndsWith(), operator!=(), and operator==().

 {
   if  ((!s1) &&  (!s2))
      return  true;
 
   if  ((!s1)  ||  (!s2))
      return  false;
 
   return  (strcmp (s1, s2) == 0);
 }

bool KKStr::StrEqualN	(	const char *	s1,
		const char *	s2,
		kkuint32	len
	)

static

Definition at line 388 of file KKStr.cpp.

Referenced by StartsWith().

 {
   if  ((!s1)  &&  (!s2))
      return  true;
 
   if  ((!s1)  ||  (!s2))
      return  false;
 
   for (kkuint32  x = 0;  x < len;  ++x)
     if  (s1[x] != s2[x])
       return false;
 
   return  true;
 }

bool KKStr::StrEqualNoCase	(	const char *	s1,
		const char *	s2
	)

static

Definition at line 408 of file KKStr.cpp.

Referenced by EndsWith(), and KKB::osLookForFile().

 {
   if  ((!s1) &&  (!s2))
      return  true;
 
   if  ((!s1)  ||  (!s2))
      return  false;
 
   size_t l1 = strlen (s1);
   size_t l2 = strlen (s2);
 
   if  (l1 != l2)
     return  false;
 
 
   for  (size_t i = 0;  i < l1;  i++)
   {
     if  (toupper (s1[i]) != toupper (s2[i]))
       return false;
   }
 
   return true;
 }  /* StrEqualNoCase */

bool KKStr::StrEqualNoCaseN	(	const char *	s1,
		const char *	s2,
		kkuint32	len
	)

static

Definition at line 436 of file KKStr.cpp.

Referenced by StartsWith().

 {
   if  ((!s1)  &&  (!s2))
      return  true;
 
   if  ((!s1)  ||  (!s2))
      return  false;
 
   for (kkuint32  x = 0;  x < len;  ++x)
     if  (toupper (s1[x]) != toupper (s2[x]))
       return false;
 
   return  true;
 }

bool KKStr::StrInStr	(	const char *	target,
		const char *	searchStr
	)

static

Definition at line 4391 of file KKStr.cpp.

References StrCapitalize().

Referenced by StrInStr().

 {
   if  ((target == NULL)  ||  (searchStr == NULL))
     return false;
 
 # ifdef  USE_SECURE_FUNCS
     char*  t = _strdup (target);
     char*  s = _strdup (searchStr);
 # else
     char*  t = strdup (target);
     char*  s = strdup (searchStr);
 #endif
 
 
   StrCapitalize (t);
   StrCapitalize (s);
   
   bool  f = (strstr (t, s) != NULL);
 
   free(t);
   free(s);
   return f;
 }

bool KKStr::StrInStr ( const KKStr & searchField ) const

Searches for the occurrence of 'searchField' and where in the string. If found will return 'true' otherwise 'false'.

Definition at line 2731 of file KKStr.cpp.

References StrInStr().

Referenced by Contains().

 {
   return  StrInStr (val, searchField.val);
 }

void KKStr::StrReplace	(	char **	dest,
		const char *	src
	)

Replaces the contents of *dest with *src.

First deletes current *dest then allocates new a new string to **dest so no memory is lost.

Definition at line 456 of file KKStr.cpp.

References Concat(), operator+(), KKB::operator+(), KKB::STRCOPY(), and KKB::StrFormatInt().

 {
   if  (*dest)
      delete [] *dest;
 
   kkint32  spaceNeeded;
   
   if  (src)
   {
     spaceNeeded = (kkint32)strlen (src) + 1;
     *dest = new char[spaceNeeded];
     
     if  (*dest == NULL)
     {
       KKStr errMsg = "KKStr::StrReplace  ***ERROR***   Failed to allocate SpaceNeeded[" + StrFormatInt (spaceNeeded, "#####0") + "].";
       cerr << errMsg << std::endl  << std::endl;
       throw  errMsg;
     }
 
     STRCOPY (*dest, spaceNeeded, src);
   }
   else
   {
     *dest = new char[1];
 
     if  (*dest == NULL)
     {
       KKStr  errMsg = "StrReplace   ***ERROR***   Failed to allocate Empty KKStr.";
       cerr << std::endl << errMsg << std::endl;
       throw  errMsg;
     }
 
     (*dest)[0] = 0;
   }
 } /* StrReplace */

wchar_t * KKStr::StrWide ( ) const

Returns a Wide Character version of the string. The caller will be responsible for deleting this string.

Definition at line 1264 of file KKStr.cpp.

 {
   wchar_t*  w = NULL;
 
   if  (!val)
   {
     w = new wchar_t[1];
     w[0] = 0;
     return w;
   }
 
   kkint32  x;
   w = new wchar_t[len + 1];
   for  (x = 0; x < len;  x++)
     w[x] = (wchar_t) val[x];
   return w;
 }  /* StrWide */

KKStr KKStr::SubStrPart ( kkint32 firstChar ) const

returns a SubString consisting of all characters starting at index 'firstChar' until the end of the string.

If the index 'firstChar' is past the end of the string a empty string will be returned.

Parameters

[in] firstChar First character in string to include in the sub-string.

Returns: Sub-string.

Definition at line 2780 of file KKStr.cpp.

References Append(), Concat(), and KKStr().

Referenced by KKMLL::FeatureFileIODstWeb::AttrDescLine::AttrDescLine(), KKMLL::DuplicateImage::ExampleWithSmallestScanLine(), ExtractAttribute(), KKMLL::MLClassList::ExtractTwoTitleLines(), KKB::PointList::FromDelStr(), KKMLL::FeatureFileIODstWeb::GetFileDesc(), KKMLL::FeatureFileIOC45::GetFileDesc(), GetNextToken2(), KKMLL::FeatureFileIOC45::LoadFeatureFile(), KKMLL::FeatureFileIODstWeb::LoadFile(), KKB::osCreateDirectoryPath(), KKB::osGetFileNamePartOfFile(), KKB::osGetRootName(), KKB::osGetRootNameOfDirectory(), KKB::osGetRootNameWithExtension(), KKB::osParseFileName(), KKB::osParseFileSpec(), KKB::osSubstituteInEnvironmentVariables(), SVM233::svm_parameter::ProcessSvmParameter(), KKLSC::Variables::SubstituteInEnvironmentVariables(), Tail(), ToLatitude(), ToLongitude(), and ToVectorInt32().

 {
   #ifdef  KKDEBUG
   ValidateLen ();
   #endif
 
   if  ((kkuint16)firstChar >= len)
     return "";
 
   if  (firstChar < 0)
     firstChar = 0;
 
   kkuint16  subStrLen = len - (kkuint16)firstChar;
   KKStr  subStr (subStrLen + 1);
   subStr.Append (((char*)&(val[firstChar])), subStrLen);
 
   return  subStr;
 }  /* SubStrPart */

KKStr KKStr::SubStrPart	(	kkint32	firstChar,
		kkint32	lastChar
	)		const

returns a SubString consisting of all characters starting at index 'firstChar' and ending at 'lastIndex'

If the index 'firstChar' is past the end of the string a empty string will be returned. If 'lastIndex is past the end of the string then will only include characters until the end of the string.
The length of the substring will be (lastChar - firstChar) + 1.

Parameters

[in]	firstChar	First character in string to include in the sub-string.
[in]	lastChar	Last character in include in the string.

Returns: Sub-string.

Definition at line 2802 of file KKStr.cpp.

References Concat(), and KKStr().

Referenced by KKMLL::DuplicateImage::ExampleWithSmallestScanLine(), ExtractAttribute(), KKMLL::MLClassList::ExtractTwoTitleLines(), KKB::PointList::FromDelStr(), KKMLL::MLClass::GetClassNameFromDirName(), KKMLL::FeatureFileIODstWeb::GetFileDesc(), KKMLL::FeatureFileIOC45::GetFileDesc(), KKMLL::FeatureFileIOUCI::GetFileDesc(), KKMLL::FeatureFileIOSparse::GetFileDesc(), KKMLL::FeatureFileIOC45::LoadFeatureFile(), KKMLL::FeatureFileIOUCI::LoadFile(), MaxLen(), KKB::osGetParentDirectoryOfDirPath(), KKB::osGetParentDirPath(), KKB::osGetPathPartOfFile(), KKB::osGetRootName(), KKB::osParseFileName(), KKB::osParseFileSpec(), KKB::osRemoveExtension(), KKB::osSubstituteInEnvironmentVariables(), KKJobManagment::KKJobManager::StatusFileProcessLine(), StripOutAnyComments(), KKLSC::Variables::SubstituteInEnvironmentVariables(), KKB::TimeType::TimeType(), ToLatitude(), ToLongitude(), ToPercentage(), and ToVectorInt32().

 {
   #ifdef  KKDEBUG
   ValidateLen ();
   #endif
 
   if  (((kkuint16)firstChar >= len)  ||  (lastChar < firstChar))
     return  "";
 
   if  (firstChar < 0)
     firstChar = 0;
 
   if  (lastChar >= len)
     lastChar = len - 1;
 
 
   kkuint16  subStrLen = ((kkuint16)lastChar - (kkuint16)firstChar) + 1;
   KKStr  subStr (subStrLen + 2);
 
   kkuint16  x = (kkuint16)firstChar;
   kkuint16  y = 0;
 
   for  (x = (kkuint16)firstChar; x <= (kkuint16)lastChar;  x++, y++)
   {
     subStr.val[y] = val[x];
   }
   
   subStr.val[y] = 0;
   subStr.len = subStrLen;
   return  subStr;
 }  /* SubStrPart */

KKStr KKStr::Tail ( kkint32 tailLen ) const

Returns a string consisting of the 'tailLen' characters from the end of the string.

Return back the last 'tailLen' characters.

*ex:
    if  test = "Hello World.";
        test.Tail (2) will return "d.".

Definition at line 2847 of file KKStr.cpp.

References SubStrPart().

 {
   if  (tailLen <= 0)
     return "";
 
   kkuint16  firstChar = Max ((kkuint16)(len - (kkuint16)tailLen), (kkuint16)0);
   return  SubStrPart (firstChar);
 }  /* Tail */

bool KKStr::ToBool ( ) const

Returns the bool equivalent of the string, ex 'Yes' = true, 'No' = false, 'True' = true, etc.

Definition at line 3523 of file KKStr.cpp.

References KKB::STRICMP().

Referenced by KKLSC::ScannerFile::ExtractHeaderField(), KKB::KKStrParser::GetNextTokenBool(), SVM289_BFS::svm_parameter::ProcessSvmParameter(), SVM289_MFS::svm_parameter::ProcessSvmParameter(), KKB::KKStrListIndexed::ReadXML(), KKB::XmlElementBool::XmlElementBool(), and KKMLL::XmlElementMLClass::XmlElementMLClass().

 {
   if  (len < 1)
     return false;
 
   if  ((STRICMP (val, "y")    == 0)  ||
        (STRICMP (val, "yes")  == 0)  ||
        (STRICMP (val, "t")    == 0)  ||
        (STRICMP (val, "true") == 0)  ||
        (STRICMP (val, "1")    == 0)
       )
     return true;
   else
     return false;
 }

double KKStr::ToDouble ( ) const

Definition at line 3541 of file KKStr.cpp.

Referenced by KKB::KKStrParser::GetNextTokenDouble(), KKMLL::SVMparam::ParseCmdLineParameter(), SVM233::svm_parameter::ParseTabDelStr(), SVM289_BFS::svm_parameter::ParseTabDelStr(), SVM289_MFS::svm_parameter::ParseTabDelStr(), SVM289_BFS::svm_parameter::ProcessSvmParameter(), SVM289_MFS::svm_parameter::ProcessSvmParameter(), ToLatitude(), and ToLongitude().

 {
   if  (!val)
     return 0.0;
 
   double  d = atof (val);
   return d;
 }  /* ToDouble */

float KKStr::ToFloat ( ) const

Definition at line 3553 of file KKStr.cpp.

Referenced by KKLSC::ScannerFile::ExtractHeaderField(), KKB::KKStrParser::GetNextTokenFloat(), KKLSC::ScannerHeaderFields::GetValueFloat(), KKMLL::FeatureFileIOC45::LoadFile(), SVM233::svm_parameter::ParseTabDelStr(), SVM289_BFS::svm_parameter::ParseTabDelStr(), SVM289_MFS::svm_parameter::ParseTabDelStr(), ToPercentage(), and KKMLL::XmlElementMLClass::XmlElementMLClass().

 {
   if  (!val)
     return 0.0f;
 
   float  f = (float)atof (val);
   return f;
 }   /* ToFloat */

kkint32 KKStr::ToInt ( ) const

Definition at line 3565 of file KKStr.cpp.

Referenced by KKLSC::ScannerFile::ExtractHeaderField(), KKB::KKStrParser::GetNextTokenInt(), KKMLL::ModelParam::ParseCmdLine(), SVM233::svm_parameter::ParseTabDelStr(), SVM289_BFS::svm_parameter::ParseTabDelStr(), SVM289_MFS::svm_parameter::ParseTabDelStr(), KKB::ReadImagePGM(), and KKJobManagment::KKJobManager::StatusFileProcessLine().

 {
   if  (!val)
     return 0;
 
   kkint32  i = atoi (val);
   return i;
 }  /* ToInt*/

kkint16 KKStr::ToInt16 ( ) const

Definition at line 3576 of file KKStr.cpp.

Referenced by KKMLL::MLClassIndexList::ParseClassIndexList().

 {
   if  (!val)
     return 0;
 
   kkint16  i = (kkint16)atoi (val);
   return i;
 }  /* ToInt32*/

kkint32 KKStr::ToInt32 ( ) const

Definition at line 3587 of file KKStr.cpp.

Referenced by KKB::XmlAttributeList::AttributeValueInt32(), KKLSC::ScannerFile::ExtractHeaderField(), KKLSC::ScannerHeaderFields::GetValueInt32(), KKB::osGetNumberOfProcessors(), SVM233::svm_parameter::ProcessSvmParameter(), KKB::ReadImagePPM(), and ToVectorInt32().

 {
   if  (!val)
     return 0;
 
   kkint32  i = atoi (val);
   return i;
 }  /* ToInt32*/

KKB::kkint64 KKStr::ToInt64 ( ) const

Definition at line 3598 of file KKStr.cpp.

 {
   if  (!val)  return 0;
 
   #if  defined(__GNUC__)
     return atoll (val);
   #else
     return  (kkint64)_atoi64 (val);
   #endif
 }

KKStrPtr KKStr::ToKKStrPtr ( ) const

Instatiates a new instance of KKStr with Allocated optimized for current string length.

Definition at line 2541 of file KKStr.cpp.

References Concat(), and KKStr().

 {
   return new KKStr (*this);
 }

double KKStr::ToLatitude ( ) const

Processes string as if a standard latitude; ex: "15:32.2S" = -15.53833.

Definition at line 3725 of file KKStr.cpp.

References ChopFirstChar(), ChopLastChar(), Concat(), FirstChar(), KKStr(), LocateCharacter(), operator=(), SubStrPart(), ToDouble(), Trim(), TrimLeft(), and TrimRight().

 {
   KKStr latitudeStr (*this);
   latitudeStr.Trim ();
 
   bool  north = true;
   char  lastChar = (char)toupper (latitudeStr.LastChar ());
   if  (lastChar == 'N')
   {
     north = true;
     latitudeStr.ChopLastChar ();
   }
   else if  (lastChar == 'S')
   {
     north = false;
     latitudeStr.ChopLastChar ();
   }
   latitudeStr.TrimRight ();
 
   if  (latitudeStr.FirstChar () == '-')
   {
     latitudeStr.ChopFirstChar ();
     north = !north;
     latitudeStr.TrimLeft ();
   }
 
   double  degrees = 0.0;
   double  minutes = 0.0;
   double  seconds = 0.0;
 
   KKStr  degreesStr = "";
   KKStr  minutesStr = "";
   KKStr  secondsStr  = "";
 
   kkint32  x = latitudeStr.LocateCharacter (':');
   if  (x >= 0)
   {
     degreesStr = latitudeStr.SubStrPart (0, x - 1);
     degreesStr.TrimRight ();
     minutesStr = latitudeStr.SubStrPart (x + 1);
     minutesStr.Trim ();
   }
   else
   {
     x = latitudeStr.LocateCharacter (' ');
     if  (x >= 0)
     {
       degreesStr = latitudeStr.SubStrPart (0, x - 1);
       degreesStr.TrimRight ();
       minutesStr = latitudeStr.SubStrPart (x + 1);
       minutesStr.Trim ();
     }
     else
     {
       degreesStr = latitudeStr;
       minutesStr = "";
     }
   }
 
   x = minutesStr.LocateCharacter (':');
   if  (x >= 0)
   {
     secondsStr = minutesStr.SubStrPart (x + 1);
     minutesStr = minutesStr.SubStrPart (0, x - 1);
     secondsStr.Trim ();
   }
   else
   {
     x = minutesStr.LocateCharacter (' ');
     if  (x >= 0)
     {
       secondsStr = minutesStr.SubStrPart (x + 1);
       minutesStr = minutesStr.SubStrPart (0, x - 1);
       secondsStr.Trim ();
     }
   }
  
   degrees = degreesStr.ToDouble ();
   minutes = minutesStr.ToDouble ();
   seconds = secondsStr.ToDouble ();
 
   double  latitude = degrees + (minutes / 60.0) + (seconds / 3600.0);
   while  (latitude > 90.0)
     latitude = latitude - 180.0;
 
   if  (!north)
     latitude = 0.0 - latitude;
 
   return  latitude;
 }  /* ToLatitude */

long KKStr::ToLong ( ) const

Definition at line 3611 of file KKStr.cpp.

Referenced by KKB::KKStrParser::GetNextTokenLong().

 {
   if  (!val)
     return 0;
 
   long  l = atol (val);
   return l;
 }  /* ToLong */

double KKStr::ToLongitude ( ) const

Processes string as if a standard longitude; ex: "95:32.2E" = 95.53833.

Definition at line 3819 of file KKStr.cpp.

References ChopFirstChar(), ChopLastChar(), Concat(), FirstChar(), KKStr(), LocateCharacter(), operator=(), SubStrPart(), ToDouble(), Trim(), and TrimRight().

 {
   KKStr longitudeStr (*this);
   bool  east = true;
   char  lastChar = (char)toupper (longitudeStr.LastChar ());
   if  (lastChar == 'E')
   {
     east = true;
     longitudeStr.ChopLastChar ();
   }
   else if  (lastChar == 'W')
   {
     east = false;
     longitudeStr.ChopLastChar ();
   }
 
   if  (longitudeStr.FirstChar () == '-')
   {
     longitudeStr.ChopFirstChar ();
     east = !east;
   }
 
   double  degrees = 0.0;
   double  minutes = 0.0;
   double  seconds = 0.0;
 
   KKStr  degreesStr = "";
   KKStr  minutesStr = "";
   KKStr  secondsStr  = "";
 
   kkint32  x = longitudeStr.LocateCharacter (':');
   if  (x >= 0)
   {
     degreesStr = longitudeStr.SubStrPart (0, x - 1);
     degreesStr.TrimRight ();
     minutesStr = longitudeStr.SubStrPart (x + 1);
     minutesStr.Trim ();
   }
   else
   {
     x = longitudeStr.LocateCharacter (' ');
     if  (x >= 0)
     {
       degreesStr = longitudeStr.SubStrPart (0, x - 1);
       degreesStr.TrimRight ();
       minutesStr = longitudeStr.SubStrPart (x + 1);
       minutesStr.Trim ();
     }
     else
     {
       degreesStr = longitudeStr;
       minutesStr = "";
     }
   }
 
   x = minutesStr.LocateCharacter (':');
   if  (x >= 0)
   {
     secondsStr = minutesStr.SubStrPart (x + 1);
     minutesStr = minutesStr.SubStrPart (0, x - 1);
     secondsStr.Trim ();
   }
   else
   {
     x = minutesStr.LocateCharacter (' ');
     if  (x >= 0)
     {
       secondsStr = minutesStr.SubStrPart (x + 1);
       minutesStr = minutesStr.SubStrPart (0, x - 1);
       secondsStr.Trim ();
     }
   }
  
   degrees = degreesStr.ToDouble ();
   minutes = minutesStr.ToDouble ();
   seconds = secondsStr.ToDouble ();
 
   double  longitude = degrees + (minutes / 60.0) + (seconds / 3600.0);
   while  (longitude > 180.0)
     longitude = longitude - 360.0;
   if  (!east)
     longitude = 0.0 - longitude;
 
   return  longitude;
 }  /* ToLongitude */

KKStr KKStr::ToLower ( ) const

Definition at line 2529 of file KKStr.cpp.

References Concat(), KKStr(), and Lower().

Referenced by KKMLL::FeatureFileIO::FeatureFileIO(), and KKB::ReadImage().

 {
   if  (!val)
     return "";
 
   KKStr  lowerStr (*this);
   lowerStr.Lower ();
   return  lowerStr;
 }  /* ToLower */

float KKStr::ToPercentage ( ) const

Definition at line 3623 of file KKStr.cpp.

References Concat(), LastChar(), Len(), SubStrPart(), and ToFloat().

 {
   if  (LastChar () == '%')
   {
     KKStr  workStr = this->SubStrPart (0, Len () - 2);
     return  workStr.ToFloat ();
   }
 
   return  100.0f * ToFloat ();
 }

KKStr KKB::KKStr::ToQuotedStr ( ) const

inline

Definition at line 540 of file KKStr.h.

References QuotedStr().

540 {return QuotedStr ();}

KKB::KKStr::QuotedStr

KKStr QuotedStr() const

Returns a quoted version of string where special characters Line-Feed, Carriage Return, and Tab, are encoded as escape sequences.

Definition: KKStr.cpp:2890

kkuint32 KKStr::ToUint ( ) const

Definition at line 3636 of file KKStr.cpp.

Referenced by KKB::KKStrParser::GetNextTokenUint().

 {
   if  (!val)  return 0;
   return  (kkuint32)atol (val);
 }

KKB::kkuint32 KKStr::ToUint32 ( ) const

Definition at line 3652 of file KKStr.cpp.

 {
   if  (!val)  return 0;
   return  (kkuint32)atol (val);
 }

KKB::kkuint64 KKStr::ToUint64 ( ) const

Definition at line 3660 of file KKStr.cpp.

Referenced by ExtractTokenUint64().

 {
   if  (!val)  return 0;
   #if  defined(__GNUC__)
     return  (kkuint64)atoll (val);
   #else
     return  (kkuint64)_atoi64 (val);
   #endif
 }

KKB::ulong KKStr::ToUlong ( ) const

Definition at line 3644 of file KKStr.cpp.

 {
   if  (!val)  return 0;
   return  (ulong)atol (val);
 }

KKStr KKStr::ToUpper ( ) const

Definition at line 2517 of file KKStr.cpp.

References Concat(), KKStr(), and Upper().

Referenced by KKMLL::MLClass::CreateNewMLClass(), KKMLL::ModelParam::EncodingMethodFromStr(), KKMLL::EncodingMethodFromStr(), KKMLL::MachineTypeFromStr(), KKMLL::Attribute::ReadXML(), and KKMLL::SelectionMethodFromStr().

 {
   if  (!val)
     return "";
 
   KKStr  upperStr (*this);
   upperStr.Upper ();
   return  upperStr;
 }  /* ToUpper */

VectorInt32 * KKStr::ToVectorInt32 ( ) const

Definition at line 3671 of file KKStr.cpp.

References Concat(), Empty(), KKB::KKStrParser::GetNextToken(), KKB::KKStrParser::KKStrParser(), LocateCharacter(), operator=(), SubStrPart(), and ToInt32().

 {
   VectorInt32*  results = new VectorInt32 ();
 
   KKStrParser parser (val);
 
   KKStr  field = parser.GetNextToken (",\t \n\r");
   while  (!field.Empty ())
   {
     kkint32 dashPos = field.LocateCharacter ('-');
     if  (dashPos < 0)
     {
       // This is not a range
       results->push_back (field.ToInt32 ());
     }
     else
     {
       // We are looking at a range
       kkint32  startNum = field.SubStrPart (0, dashPos - 1).ToInt32 ();
       kkint32  endNum   = field.SubStrPart (dashPos + 1).ToInt32 ();
       for  (kkint32 z = startNum;   z <= endNum;  ++z)
         results->push_back (z);
     }
     field = parser.GetNextToken (",\t \n\r");
   }
   return  results;
 }  /* ToVectorint32 */

wchar_t * KKStr::ToWchar_t ( ) const

Definition at line 3703 of file KKStr.cpp.

Referenced by KKB::ReadImageUsingGDI().

 {
   wchar_t* wa = NULL;
   if  (val == NULL)
   {
     wa = new wchar_t[1];
     mbstowcs (wa, "", 1);
     return  wa;
   }
   else
   {
     size_t  wideLen = len + 1;
     wa = new wchar_t[wideLen];
     mbstowcs (wa, val, wideLen);
   }
   return wa;
 }

KKStr KKStr::ToXmlStr ( ) const

Definition at line 2929 of file KKStr.cpp.

References Append(), Concat(), EmptyStr(), KKStr(), and Len().

 {
   if  ((!val)  ||  (len < 1))
   {
     return KKStr::EmptyStr ();
   }
   
   KKStr  result (Len () + 5);
   
   kkint32  idx = 0;
   while  (idx < len)
   {
     switch  (val[idx])
     {
       case  '<' : result.Append ("&lt;");    break;
       case  '>' : result.Append ("&gt;");    break;
       case  '&' : result.Append ("&amp;");   break;
       case  '\"': result.Append ("&quot;");  break;
       case  '\'': result.Append ("&apos;");  break;
       case  '\t': result.Append ("&tab;");   break;
       case  '\n': result.Append ("&nl;");    break;
       case  '\r': result.Append ("&cr;");    break;
       case  '\\': result.Append ("&bs;");    break;
       case     0: result.Append ("&null;");  break;
          
       default:   result.Append (val[idx]);   break;
     }
 
     idx++;
   }
 
   return  result;
 }  /* ToXmlStr */

KKStr & KKStr::Trim ( const char * whiteSpaceChars = "\n\r\t " )

Definition at line 1686 of file KKStr.cpp.

References TrimLeft(), and TrimRight().

Referenced by KKB::osReadRestOfLine(), ToLatitude(), and ToLongitude().

 {
   TrimRight (whiteSpaceChars);
   TrimLeft(whiteSpaceChars);
   return  *this;  
 }  /* Trim */

void KKStr::TrimLeft ( const char * whiteSpaceChars = "\n\r\t " )

Definition at line 1745 of file KKStr.cpp.

Referenced by KKMLL::FeatureFileIODstWeb::AttrDescLine::AttrDescLine(), KKB::CmdLineExpander::CmdLineExpander(), KKMLL::FeatureNumList::ExtractFeatureNumsFromStr(), KKMLL::MLClassList::ExtractThreeTitleLines(), KKB::PointList::FromDelStr(), KKMLL::FeatureFileIODstWeb::GetFileDesc(), KKMLL::FeatureFileIOUCI::GetFileDesc(), KKMLL::FeatureFileIOUCI::LoadFile(), KKB::operator>>(), Parse(), KKMLL::ModelParam::ParseCmdLine(), KKMLL::ModelParamOldSVM::ParseCmdLine(), Split(), KKJobManagment::KKJobManager::StatusFileProcessLine(), KKJobManagment::KKJobManager::StatusFileProcessLineJobStatusChange(), SVM233::svm_parameter::svm_parameter(), ToLatitude(), Trim(), and Wide().

 {
   #ifdef  KKDEBUG
   ValidateLen ();
   #endif
 
 
   if  (!val)
   {
     AllocateStrSpace (1);
     len = 0;
     return;
   }
 
   kkuint16  x = 0;
 
   while  ((strchr (whiteSpaceChars, val[x]))  &&  (val[x] != 0))
     x++;
 
   if  (x == 0)
     return;
 
   kkuint16  y = 0;
 
   while  (x < len)
   {
     val[y] = val[x];
     x++;
     y++;
   }
 
   len = y;
   val[len] = 0;
 }  /* TrimLeft */

KKStr & KKStr::TrimRight ( const char * whiteSpaceChars = "\n\r\t " )

Definition at line 1695 of file KKStr.cpp.

Referenced by KKMLL::FeatureFileIODstWeb::AttrDescLine::AttrDescLine(), KKB::CmdLineExpander::CmdLineExpander(), KKMLL::MLClassList::ExtractThreeTitleLines(), KKMLL::FeatureFileIODstWeb::GetFileDesc(), KKMLL::FeatureFileIOUCI::GetFileDesc(), KKB::KKStrParser::GetRestOfLine(), KKB::KKStrParser::GetRestOfStr(), KKMLL::MLClassList::Load(), KKMLL::FeatureFileIOUCI::LoadFile(), KKB::operator>>(), KKB::osReadRestOfLine(), Parse(), KKB::KKStrList::ParseDelimitedString(), ReadXML(), Split(), KKJobManagment::KKJobManager::StatusFileProcessLine(), KKJobManagment::KKJobManager::StatusFileProcessLineJobStatusChange(), ToLatitude(), ToLongitude(), Trim(), and Wide().

 {
   #ifdef  KKDEBUG
   ValidateLen ();
   #endif
 
   if  (!val)
   {
     AllocateStrSpace (1);
     len = 0;
     return *this;
   }
 
   kkint32  x = len - 1;
   while  ((len > 0)  && (strchr (whiteSpaceChars, val[x])))
   {
     val[x] = 0;
     x--;
     len--;
   }
 
   return *this;
 }  /* TrimRight */

void KKStr::TrimRightChar ( )

Definition at line 1723 of file KKStr.cpp.

 {
   #ifdef  KKDEBUG
   ValidateLen ();
   #endif
 
   if  (!val)
   {
     AllocateStrSpace (1);
     len  = 0;
     return;
   }
 
   if  (len > 0)
   {
     len--;
     val[len] = 0;
   }
 }  /* TrimRightChar */

void KKStr::Upper ( )

Converts all characters in string to their Upper case equivalents via 'toupper'.

See also: ToUpper

Definition at line 2461 of file KKStr.cpp.

Referenced by KKMLL::Attribute::Attribute(), KKMLL::SizeDistribution::ClassTotals::ClassTotals(), KKMLL::BinaryClassParms::CreateFromTabDelStr(), KKMLL::DuplicateImage::ExampleWithSmallestScanLine(), KKMLL::FeatureNumList::ExtractFeatureNumsFromStr(), ExtractTokenBool(), KKMLL::FeatureFileIODstWeb::GetFileDesc(), KKMLL::KernalTypeFromStr(), SVM289_BFS::Kernel_Type_FromStr(), SVM289_MFS::Kernel_Type_FromStr(), KKMLL::FeatureFileIOC45::LoadFeatureFile(), KKMLL::FeatureFileIODstWeb::LoadFile(), KKMLL::AttributeList::LookUpByName(), KKB::osLookForFile(), KKMLL::ModelParam::ParseCmdLine(), KKMLL::ModelParamOldSVM::ParseCmdLine(), KKMLL::SVMparam::ParseCmdLineParameter(), SVM233::svm_parameter::ProcessSvmParameter(), KKB::SaveImage(), KKB::SupportedImageFileFormat(), SVM289_BFS::SVM_Type_FromStr(), SVM289_MFS::SVM_Type_FromStr(), and ToUpper().

 {
   #ifdef  KKDEBUG
   ValidateLen ();
   #endif
 
   if  (!val)
     return;
 
   kkuint32  x;
 
   for  (x = 0; x < len; x++)
     val[x] = (uchar)toupper (val[x]);
 }  /* Upper */

bool KKStr::ValidInt ( kkint32 & value )

returns true if KKStr is formated as a valid integer otherwise false.

Parameters

[out] value of string as interpreted as a integer.

Definition at line 2548 of file KKStr.cpp.

 {
 
   kkint32  sign = 1;
 
   value = 0;
 
   if  (!val)
      return false;
   else
     {
        char*  ch = val;
 
        // Skip over white space
 
        while  ((strchr (" \n\t", *ch))  &&  (*ch))
          ch++;
 
        if  (!(*ch))
           return  false;
 
        if  (*ch == '-')
          {
            ch++;
            sign = -1;
          }
 
        kkint32  digit;
                
        digit = (*ch - '0');
 
        while  ((digit >= 0)  &&  (digit <= 9))
          {
             value = value * 10 + digit;
             ch++;
             digit = (*ch - '0');
          }
 
        value = value * sign;
 
        return  (*ch == 0);
     }
 }

bool KKStr::ValidMoney ( float & value ) const

Definition at line 2594 of file KKStr.cpp.

 {
   kkint32  digit = 0;
   kkint32  sign  = 1;
   value = 0;
   if  (!val)
     return false;
 
   char*  ch = val;
 
   // Skip over white space
   while  ((strchr (" \n\t", *ch))  &&  (*ch))
     ch++;
   if  (!(*ch))
     return  false;
 
   bool  decimalFound  = false;
   kkint32 decimalDigits = 0;
 
   if  (*ch == '-')
   {
     ch++;
     sign = -1;
   }
 
   digit = (*ch - '0');
   while  (((digit >= 0)  &&  (digit <= 9))  ||  (*ch == '.'))
   {
    if  (*ch == '.')
    {
      if  (decimalFound)
        return false;
      decimalFound = true;
    }
    else
    {
      if  (decimalFound)
        decimalDigits++;
      value = value * 10 + digit;
    }
    ch++;
    digit = (*ch - '0');
   }
 
   if  (decimalDigits > 2)
     return false;
 
   while  (decimalDigits > 0)
   {
     value = value / 10;
     decimalDigits--;
   }
 
   value = value * sign;
   return  (*ch == 0);
 }  //  ValidMoney

bool KKStr::ValidNum ( double & value ) const

Returns true if String is a valid number, ex 1.0 or -3.123, etc

Definition at line 2653 of file KKStr.cpp.

 {
   kkint32  digit = 0;
   kkint32  sign  = 1;
   value = 0.0;
   value = 0;
   if  (!val)
     return false;
 
   char*  ch = val;
 
   // Skip over white space
   while  ((strchr (" \n\t", *ch))  &&  (*ch))
     ch++;
   if  (!(*ch))
     return  false;
 
   bool  decimalFound  = false;
   kkint32 decimalDigits = 0;
 
   if  (*ch == '-')
   {
     ch++;
     sign = -1;
   }
 
   digit = (*ch - '0');
 
   while  (((digit >= 0)  &&  (digit <= 9))  ||  (*ch == '.'))
   {
    if  (*ch == '.')
    {
      if  (decimalFound)
        return false;
      decimalFound = true;
    }
    else
    {
      if  (decimalFound)
        decimalDigits++;
      value = value * 10 + digit;
    }
    ch++;
    digit = (*ch - '0');
   }
 
   while  (decimalDigits > 0)
   {
     value = value / 10;
     decimalDigits--;
   }
 
   value = value * sign;
   return  (*ch == 0);
 }  /* ValidNum */

KKStr KKStr::Wide	(	kkint32	width,
		char	dir = `'R'`
	)		const

Pads the string with spaces so that it is exactly 'width' characters long. Can pad either left, right, or center as specified by 'dir'. If KKStr Already greater than 'width' will truncate new string. /summary> param name='width'> Width of KKStr; will pad KKStr with spaces until it is width long. param name='dir'>Direction to pad from 'L' - Pad on the left side, 'R' - Pad on the right side, and 'C' - Pad on left and Right so that text is centered.

Definition at line 2203 of file KKStr.cpp.

References Concat(), KKStr(), LeftPad(), Len(), KKB::operator+(), operator=(), RightPad(), Spaces(), Str(), TrimLeft(), and TrimRight().

 {
   #ifdef  KKDEBUG
   ValidateLen ();
   #endif
 
 
   KKStr  str (val);
   if  ((dir == 'L')  ||  (dir == 'l'))
      str.LeftPad  (width, ' ');
 
   else if  ((dir == 'C')  ||  (dir == 'c'))
   {
     str.TrimRight ();
     str.TrimLeft ();
 
     kkint32  x = (width - str.Len ()) / 2;
 
     if  (x > 0)
     {
       str = Spaces (x).Str () + str;
       str.RightPad (width, ' ');
     }
   }
 
   else
     str.RightPad (width, ' ');
 
   return str;
 }  /* Wide */

void KKStr::WriteXML	(	const KKStr &	varName,
		std::ostream &	o
	)		const

Definition at line 4420 of file KKStr.cpp.

References KKB::XmlTag::AddAtribute(), Empty(), KKB::XmlTag::tagEnd, KKB::XmlTag::tagStart, KKB::XmlTag::WriteXML(), KKB::XmlContent::WriteXml(), and KKB::XmlTag::XmlTag().

Referenced by KKMLL::Model::WriteModelXMLFields(), KKMLL::ModelParamSvmBase::WriteXML(), KKMLL::ModelParamDual::WriteXML(), KKMLL::FeatureEncoder::WriteXML(), KKMLL::ModelParamOldSVM::WriteXML(), KKMLL::TrainingClassList::WriteXML(), SVM233::SvmModel233::WriteXML(), SVM289_MFS::Svm_Model::WriteXML(), KKMLL::ModelOldSVM::WriteXML(), KKMLL::SVMModel::WriteXML(), KKMLL::TrainingProcess2::WriteXML(), and KKMLL::ModelParam::WriteXMLFields().

 {
   XmlTag startTag ("KKStr", XmlTag::TagTypes::tagStart);
   if  (!varName.Empty ())
     startTag.AddAtribute ("VarName", varName);
   startTag.AddAtribute ("Len", len);
   startTag.WriteXML (o);
   XmlContent::WriteXml (val, o);
   XmlTag  endTag ("KKStr", XmlTag::TagTypes::tagEnd);
   endTag.WriteXML (o);
   o << endl;
 }  /* WriteXML */

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

C:/Users/Kurt/GitHub/KSquareLibraries/KKBase/KKStr.h
C:/Users/Kurt/GitHub/KSquareLibraries/KKBase/KKStr.cpp

Classes

Public Types

Public Member Functions

Static Public Member Functions

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation