Leviathan::StringIterator Class Reference

Iterator class for getting parts of a string. More...

#include <StringIterator.h>

Public Member Functions
DLLEXPORT	StringIterator (std::unique_ptr< StringDataIterator > &&iterator)
	Creates a iterator from the iterating object. More...
DLLEXPORT	StringIterator (const std::wstring &text)
	Helper constructor for common string type. More...
DLLEXPORT	StringIterator (const std::string &text)
	Helper constructor for common string type. More...
DLLEXPORT	StringIterator (const std::wstring *text)
	Helper constructor for common string type. More...
DLLEXPORT	StringIterator (const std::string *text)
	Helper constructor for common string type. More...
DLLEXPORT	StringIterator ()
	Creates an empty iterator. More...
virtual DLLEXPORT	~StringIterator ()
DLLEXPORT void	ReInit (std::unique_ptr< StringDataIterator > &&iterator)
	Changes the current iterator to the new iterator and goes to the beginning. More...
DLLEXPORT void	ReInit (const std::wstring &text)
	Helper function for ReInit for common string type. More...
DLLEXPORT void	ReInit (const std::string &text)
	Helper function for ReInit for common string type. More...
DLLEXPORT void	ReInit (const std::wstring *text)
	Helper function for ReInit for common string type. More...
DLLEXPORT void	ReInit (const std::string *text)
	Helper function for ReInit for common string type. More...
template<class RStrType >
std::unique_ptr< RStrType >	GetStringInQuotes (QUOTETYPE quotes, int specialflags=0)
	Gets the next string in quotes. More...
template<class RStrType >
std::unique_ptr< RStrType >	GetNextNumber (DECIMALSEPARATORTYPE decimal, int specialflags=0)
	Gets the next number. More...
template<class RStrType >
std::unique_ptr< RStrType >	GetNextCharacterSequence (int stopcaseflags, int specialflags=0)
	Gets the next sequence of characters according to stopcaseflags. More...
template<class RStrType >
std::unique_ptr< RStrType >	GetUntilEqualityAssignment (EQUALITYCHARACTER stopcase, int specialflags=0)
	Gets the string that is before the equality assignment. More...
template<class RStrType >
std::unique_ptr< RStrType >	GetUntilEnd ()
	Gets all characters until the end. More...
template<class RStrType >
std::unique_ptr< RStrType >	GetUntilLineEnd ()
	Gets all characters until a line end. More...
template<class RStrType >
std::unique_ptr< RStrType >	GetUntilNextCharacterOrNothing (int charactertolookfor, int specialflags=0)
	Gets characters until a character or nothing if the specified character is not found. More...
template<class RStrType >
std::unique_ptr< RStrType >	GetUntilNextCharacterOrAll (int charactertolookfor, int specialflags=0)
	Gets characters until a character or all remaining characters. More...
template<class RStrType >
std::unique_ptr< RStrType >	GetUntilCharacterSequence (const RStrType &findstr, int specialflags=0)
	Gets all characters until a sequence is matched. More...
template<class RStrType >
std::unique_ptr< RStrType >	GetStringInBracketsRecursive (int specialflags=0)
	Gets characters inside brackets. More...
void	SkipWhiteSpace (int specialflags=0)
	Skips until characters that are not whitespace are found. More...
void	SkipCharacters (int chartoskip, int additionalflag=0, int specialflags=0)
	Skips until chartoskip doesn't match the current character. More...
size_t	GetPosition ()
	Returns the current reading position. More...
size_t	GetCurrentLine ()
	Returns the current line the processing is happening. More...
int	GetCharacter (size_t forward=0)
	Gets the character in the position current + forward. More...
bool	IsAtNewLine ()
	Returns true if current character is a new line. More...
DLLEXPORT int	GetPreviousCharacter ()
	Gets the previous character. More...
size_t	GetLastValidCharIndex () const
	Returns the last valid index on the iterator. More...
bool	MoveToNext ()
	Skips the current character and moves to the next. More...
DLLEXPORT void	SkipLineEnd ()
	Skips characters until the line number changes. More...
bool	IsOutOfBounds ()
	Returns true when the read position is valid. More...
bool	IsInsideString ()
bool	IsInsideComment ()
template<class STRSType >
std::unique_ptr< STRSType >	GetSubstringFromIndexes (size_t firstcharacter, size_t lastcharacter) const
	Returns substring from the wanted indexes. More...
IteratorFindUntilData	GetPositionsUntilACharacter (int character, int specialflags=0)
	Gets the position of the current character and the specified character. More...

Protected Member Functions
ITERATORCALLBACK_RETURNTYPE	FindFirstQuotedString (IteratorPositionData *data, QUOTETYPE quotes, int specialflags)
ITERATORCALLBACK_RETURNTYPE	FindNextNormalCharacterString (IteratorPositionData *data, int stopflags, int specialflags)
ITERATORCALLBACK_RETURNTYPE	FindNextNumber (IteratorNumberFindData *data, DECIMALSEPARATORTYPE decimal, int specialflags)
ITERATORCALLBACK_RETURNTYPE	FindUntilEquality (IteratorAssignmentData *data, EQUALITYCHARACTER equality, int specialflags)
ITERATORCALLBACK_RETURNTYPE	SkipSomething (IteratorCharacterData &data, const int additionalskip, const int specialflags)
ITERATORCALLBACK_RETURNTYPE	FindUntilSpecificCharacter (IteratorFindUntilData *data, int character, int specialflags)
ITERATORCALLBACK_RETURNTYPE	FindUntilNewLine (IteratorFindUntilData *data)
ITERATORCALLBACK_RETURNTYPE	FindInMatchingParentheses (IteratorNestingLevelData *data, int left, int right, int specialflags)
template<class AcceptStr >
ITERATORCALLBACK_RETURNTYPE	FindUntilSequence (IteratorUntilSequenceData< AcceptStr > *data, int specialflags)

Detailed Description

Iterator class for getting parts of a string.

Definition at line 135 of file StringIterator.h.

Constructor & Destructor Documentation

StringIterator() [1/6]

DLLEXPORT Leviathan::StringIterator::StringIterator

(

std::unique_ptr< StringDataIterator > &&

iterator

)

Creates a iterator from the iterating object.

Definition at line 10 of file StringIterator.cpp.

                                                  :
    HandlesDelete(true),
    DataIterator(iterator.release())
{}

StringIterator() [2/6]

DLLEXPORT Leviathan::StringIterator::StringIterator

(

const std::wstring &

text

)

Helper constructor for common string type.

Definition at line 20 of file StringIterator.cpp.

                                                                     :
    HandlesDelete(true), DataIterator(new StringClassDataIterator<wstring>(text))
{}

StringIterator() [3/6]

DLLEXPORT Leviathan::StringIterator::StringIterator

(

const std::string &

text

)

Helper constructor for common string type.

Definition at line 16 of file StringIterator.cpp.

                                                                    :
    HandlesDelete(true), DataIterator(new StringClassDataIterator<string>(text))
{}

StringIterator() [4/6]

DLLEXPORT Leviathan::StringIterator::StringIterator

(

const std::wstring *

text

)

Helper constructor for common string type.

Parameters

text	Pointer to a string that won't be deleted by this

Definition at line 24 of file StringIterator.cpp.

                                                                     :
    HandlesDelete(true), DataIterator(new StringClassPointerIterator<wstring>(text))
{}

StringIterator() [5/6]

DLLEXPORT Leviathan::StringIterator::StringIterator

(

const std::string *

text

)

Helper constructor for common string type.

Parameters

text	Pointer to a string that won't be deleted by this

Definition at line 28 of file StringIterator.cpp.

                                                                    :
    HandlesDelete(true), DataIterator(new StringClassPointerIterator<string>(text))
{}

StringIterator() [6/6]

DLLEXPORT StringIterator::StringIterator

(

)

Creates an empty iterator.

Use ReInit to fill with data

Definition at line 8 of file StringIterator.cpp.

{}

~StringIterator()

DLLEXPORT Leviathan::StringIterator::~StringIterator ( )

virtual

Definition at line 32 of file StringIterator.cpp.

{
    if(HandlesDelete) {

        SAFE_DELETE(DataIterator);
    }
}

Member Function Documentation

FindFirstQuotedString()

ITERATORCALLBACK_RETURNTYPE Leviathan::StringIterator::FindFirstQuotedString ( IteratorPositionData *  data, QUOTETYPE  quotes, int  specialflags  )

inlineprotected

Definition at line 1049 of file StringIterator.h.

    {
        bool TakeChar = true;
        bool End = false;

        if(specialflags & SPECIAL_ITERATOR_ONNEWLINE_STOP && IsAtNewLine()) {
            ITR_FUNCDEBUG("Stopping to new line");

            if(data->Positions.Start) {
                // Set the last character to two before this
                // (skip the current and " and end there)
                int previouscheck = GetPreviousCharacter();

                // Check do we need to go back 2 characters or just one //
                if((quotes == QUOTETYPE_BOTH &&
                       (previouscheck == '"' || previouscheck == '\'')) ||
                    (quotes == QUOTETYPE_DOUBLEQUOTES && previouscheck == '"') ||
                    (quotes == QUOTETYPE_SINGLEQUOTES && previouscheck == '\'')) {
                    ITR_FUNCDEBUG("Going back over an extra quote character");
                    data->Positions.End = GetPosition() - 2;
                } else {
                    data->Positions.End = GetPosition() - 1;
                }

                ITR_FUNCDEBUG("Ending to new line, end is now: " +
                              Convert::ToString(data->Positions.End));
            }

            SkipLineEnd();
            return ITERATORCALLBACK_RETURNTYPE_STOP;
        }

        int currentcharacter = GetCharacter();

        switch(quotes) {
        case QUOTETYPE_BOTH: {
            if(CurrentFlags & ITERATORFLAG_SET_INSIDE_STRING) {
                // check if we are on the quotes, because we don't want those //
                if(currentcharacter == '"' || currentcharacter == '\'') {
                    // if we aren't ignoring special disallow //
                    if(!(CurrentFlags & ITERATORFLAG_SET_IGNORE_SPECIAL)) {
                        TakeChar = false;
                        ITR_FUNCDEBUG("Found quote character");
                    }
                }

            } else {
                End = true;
                ITR_FUNCDEBUG("Outside quotes");
            }
        } break;
        case QUOTETYPE_SINGLEQUOTES: {
            if(CurrentFlags & ITERATORFLAG_SET_INSIDE_STRING_SINGLE) {
                // check if we are on the quotes, because we don't want those //
                if(currentcharacter == '\'') {
                    // if we aren't ignoring special disallow //
                    if(!(CurrentFlags & ITERATORFLAG_SET_IGNORE_SPECIAL)) {
                        TakeChar = false;
                        ITR_FUNCDEBUG("Found quote character");
                    }
                }

            } else {
                End = true;
                ITR_FUNCDEBUG("Outside quotes");
            }
        } break;
        case QUOTETYPE_DOUBLEQUOTES: {
            if(CurrentFlags & ITERATORFLAG_SET_INSIDE_STRING_DOUBLE) {
                // check if we are on the quotes, because we don't want those //
                if(currentcharacter == '"') {
                    // if we aren't ignoring special disallow //
                    if(!(CurrentFlags & ITERATORFLAG_SET_IGNORE_SPECIAL)) {
                        TakeChar = false;
                        ITR_FUNCDEBUG("Found quote character");
                    }
                }

            } else {
                End = true;
                ITR_FUNCDEBUG("Outside quotes");
            }
        } break;
        }

        // If we have found a character this is on the ending quote //
        if(!TakeChar && data->Positions.Start) {

            // Set the last character to the one before this (skip the " and end there) //
            data->Positions.End = GetPosition() - 1;
            ITR_FUNCDEBUG(
                "On ending quote, end is now: " + Convert::ToString(data->Positions.End));
        }

        if(End) {
            // if we have found at least a character we can end this here //
            if(data->Positions.Start) {
                // Set the last character to two before this
                // (skip the current and " and end there)
                data->Positions.End = GetPosition() - 2;
                ITR_FUNCDEBUG("Ending outside quotes, end is now: " +
                              Convert::ToString(data->Positions));
                return ITERATORCALLBACK_RETURNTYPE_STOP;
            }
        } else if(TakeChar) {
            // check is this first quoted character //
            if(!data->Positions.Start) {
                // first position! //
                data->Positions.Start = GetPosition();
                ITR_FUNCDEBUG(
                    "First character found: " + Convert::ToString(data->Positions.Start));
            }
        }

        return ITERATORCALLBACK_RETURNTYPE_CONTINUE;
    }

FindInMatchingParentheses()

ITERATORCALLBACK_RETURNTYPE Leviathan::StringIterator::FindInMatchingParentheses ( IteratorNestingLevelData *  data, int  left, int  right, int  specialflags  )

inlineprotected

Definition at line 1585 of file StringIterator.h.

    {
        // Ignore if ignoring special characters //
        if(!(CurrentFlags & ITERATORFLAG_SET_IGNORE_SPECIAL) &&
            !(CurrentFlags & ITERATORFLAG_SET_INSIDE_STRING)) {
            if(specialflags & SPECIAL_ITERATOR_ONNEWLINE_STOP && IsAtNewLine()) {

                // Invalid, always //
                return ITERATORCALLBACK_RETURNTYPE_STOP;
            }

            int currentcharacter = GetCharacter();

            // Nesting level starts //
            if(currentcharacter == left) {

                ++data->NestingLevel;

                if(data->NestingLevel > 1) {

                    // There where multiple lefts in a row, like "[[[...]]]"
                    goto isinsidevalidleftrightpair;
                }

                return ITERATORCALLBACK_RETURNTYPE_CONTINUE;
            }

            // One nesting level is ending //
            if(currentcharacter == right) {

                --data->NestingLevel;

                if(data->NestingLevel == 0) {

                    data->Positions.End = GetPosition() - 1;
                    return ITERATORCALLBACK_RETURNTYPE_STOP;
                }
            }
        }

    isinsidevalidleftrightpair:

        if(!data->Positions.Start && data->NestingLevel > 0) {

            data->Positions.Start = GetPosition();
        }

        return ITERATORCALLBACK_RETURNTYPE_CONTINUE;
    }

FindNextNormalCharacterString()

ITERATORCALLBACK_RETURNTYPE Leviathan::StringIterator::FindNextNormalCharacterString ( IteratorPositionData *  data, int  stopflags, int  specialflags  )

inlineprotected

Definition at line 1167 of file StringIterator.h.

    {
        bool IsValid = true;

        if(specialflags & SPECIAL_ITERATOR_ONNEWLINE_STOP && IsAtNewLine()) {
            ITR_FUNCDEBUG("Stopping to new line");

            if(data->Positions.Start) {
                // ended //
                data->Positions.End = GetPosition() - 1;
                ITR_FUNCDEBUG("Ending to new line, end is now: " +
                              Convert::ToString(data->Positions.End));
            }

            SkipLineEnd();
            return ITERATORCALLBACK_RETURNTYPE_STOP;
        }

        int currentcharacter = GetCharacter();

        // If set this is invalid inside comments //
        if((specialflags & SPECIAL_ITERATOR_HANDLECOMMENTS_ASSTRING) &&
            (CurrentFlags & ITERATORFLAG_SET_INSIDE_COMMENT)) {
            IsValid = false;
            goto invalidcodelabelunnormalcharacter;
        }

        if((stopflags & UNNORMALCHARACTER_TYPE_LOWCODES ||
               stopflags & UNNORMALCHARACTER_TYPE_WHITESPACE) &&
            !(CurrentFlags & ITERATORFLAG_SET_INSIDE_STRING)) {
            if(currentcharacter <= ' ') {
                IsValid = false;
                goto invalidcodelabelunnormalcharacter;
            }
        }

        if(stopflags & UNNORMALCHARACTER_TYPE_NON_ASCII) {

            if(CurrentFlags & ITERATORFLAG_SET_INSIDE_STRING ||
                !((currentcharacter >= '0' && currentcharacter <= '9') ||
                    (currentcharacter >= 'A' && currentcharacter <= 'Z') ||
                    (currentcharacter >= 'a' && currentcharacter <= 'z'))) {
                IsValid = false;
                goto invalidcodelabelunnormalcharacter;
            }
        }

        if(stopflags & UNNORMALCHARACTER_TYPE_CONTROLCHARACTERS &&
            !(CurrentFlags & ITERATORFLAG_SET_INSIDE_STRING) &&
            !(CurrentFlags & ITERATORFLAG_SET_IGNORE_SPECIAL)) {
            if(((currentcharacter <= '/' && currentcharacter >= '!') ||
                   (currentcharacter <= '@' && currentcharacter >= ':') ||
                   (currentcharacter <= '`' && currentcharacter >= '[') ||
                   (currentcharacter <= '~' && currentcharacter >= '{')) &&
                !(currentcharacter == '_' || currentcharacter == '-')) {
                IsValid = false;
                goto invalidcodelabelunnormalcharacter;
            }
        }

        if(IsValid) {
            // check is this first character //
            if(!data->Positions.Start) {
                // first position! //
                data->Positions.Start = GetPosition();
                ITR_FUNCDEBUG("Started: " + Convert::ToString(data->Positions.Start));
            }

        } else {

        invalidcodelabelunnormalcharacter:


            // check for end //
            if(data->Positions.Start) {
                // ended //
                data->Positions.End = GetPosition() - 1;
                ITR_FUNCDEBUG("End now: " + Convert::ToString(data->Positions.End));
                return ITERATORCALLBACK_RETURNTYPE_STOP;
            }
        }

        return ITERATORCALLBACK_RETURNTYPE_CONTINUE;
    }

FindNextNumber()

ITERATORCALLBACK_RETURNTYPE Leviathan::StringIterator::FindNextNumber ( IteratorNumberFindData *  data, DECIMALSEPARATORTYPE  decimal, int  specialflags  )

inlineprotected

Definition at line 1253 of file StringIterator.h.

    {
        // Check is the current element a part of a number //

        bool IsValid = false;

        if(specialflags & SPECIAL_ITERATOR_ONNEWLINE_STOP && IsAtNewLine()) {
            ITR_FUNCDEBUG("Stopping to new line");

            if(data->Positions.Start) {
                // ended //
                data->Positions.End = GetPosition() - 1;
                ITR_FUNCDEBUG("Ending to new line, end is now: " +
                              Convert::ToString(data->Positions.End));
            }

            SkipLineEnd();
            return ITERATORCALLBACK_RETURNTYPE_STOP;
        }

        // Comments might be skipped //
        if(!(specialflags & SPECIAL_ITERATOR_HANDLECOMMENTS_ASSTRING) ||
            !(CurrentFlags & ITERATORFLAG_SET_INSIDE_COMMENT)) {
            int currentcharacter = GetCharacter();

            if((currentcharacter >= 48) && (currentcharacter <= 57)) {
                // Is a plain old digit //
                IsValid = true;

            } else {
                // Check is it a decimal separator (1 allowed)
                // or a negativity sign in front
                if(currentcharacter == '+' || currentcharacter == '-') {

                    if((data->DigitsFound < 1) && (!data->NegativeFound)) {
                        IsValid = true;
                    }
                    data->NegativeFound = true;
                } else if(((currentcharacter == '.') &&
                              ((decimal == DECIMALSEPARATORTYPE_DOT) ||
                                  (decimal == DECIMALSEPARATORTYPE_BOTH))) ||
                          ((currentcharacter == ',') &&
                              ((decimal == DECIMALSEPARATORTYPE_COMMA) ||
                                  (decimal == DECIMALSEPARATORTYPE_BOTH)))) {
                    if((!data->DecimalFound) && (data->DigitsFound > 0)) {
                        IsValid = true;
                        data->DecimalFound = true;
                    }
                }
            }
        } else {
            ITR_FUNCDEBUG("Ignoring inside a comment");
        }

        if(IsValid) {
            // check is this first digit //
            data->DigitsFound++;
            if(!data->Positions.Start) {
                // first position! //

                data->Positions.Start = GetPosition();
                ITR_FUNCDEBUG("Data started: " + Convert::ToString(data->Positions.Start));
            }

        } else {
            // check for end //
            if(data->Positions.Start) {
                // ended //
                data->Positions.End = GetPosition() - 1;
                ITR_FUNCDEBUG("End now: " + Convert::ToString(data->Positions.End));
                return ITERATORCALLBACK_RETURNTYPE_STOP;
            }
        }
        return ITERATORCALLBACK_RETURNTYPE_CONTINUE;
    }

FindUntilEquality()

ITERATORCALLBACK_RETURNTYPE Leviathan::StringIterator::FindUntilEquality ( IteratorAssignmentData *  data, EQUALITYCHARACTER  equality, int  specialflags  )

inlineprotected

Definition at line 1330 of file StringIterator.h.

    {
        // check is current element a valid element //
        bool IsValid = true;
        bool IsStop = false;

        if(specialflags & SPECIAL_ITERATOR_ONNEWLINE_STOP && IsAtNewLine()) {
            ITR_FUNCDEBUG("Stopping to new line");

            SkipLineEnd();
            return ITERATORCALLBACK_RETURNTYPE_STOP;
        }

        // Comments cannot be part of this //
        if((specialflags & SPECIAL_ITERATOR_HANDLECOMMENTS_ASSTRING) &&
            (CurrentFlags & ITERATORFLAG_SET_INSIDE_COMMENT)) {
            // Not valid inside a comment //
            ITR_FUNCDEBUG("Comment skipped");
            IsValid = false;

        } else {

            int charvalue = GetCharacter();

            // Skip if this is a space //
            if(charvalue < 33) {
                // Not allowed in a name //
                ITR_FUNCDEBUG("Whitespace skipped");
                IsValid = false;
            }

            if(equality == EQUALITYCHARACTER_TYPE_ALL) {
                // check for all possible value separators //
                if(charvalue == '=' || charvalue == ':') {

                    if(!(CurrentFlags & ITERATORFLAG_SET_IGNORE_SPECIAL)) {
                        // If ignored don't stop //
                        ITR_FUNCDEBUG("Found = or :");
                        IsStop = true;
                    }
                }
            } else if(equality == EQUALITYCHARACTER_TYPE_EQUALITY) {
                // Check for an equality sign //
                if(charvalue == '=') {
                    if(!(CurrentFlags & ITERATORFLAG_SET_IGNORE_SPECIAL)) {
                        ITR_FUNCDEBUG("Found =");
                        IsStop = true;
                    }
                }
            } else if(equality == EQUALITYCHARACTER_TYPE_DOUBLEDOTSTYLE) {
                // Check does it match the characters //
                if(charvalue == ':') {
                    if(!(CurrentFlags & ITERATORFLAG_SET_IGNORE_SPECIAL)) {
                        ITR_FUNCDEBUG("Found :");
                        IsStop = true;
                    }
                }
            }
        }

        if(!IsStop) {
            // end if end already found //
            if(data->SeparatorFound) {
                ITR_FUNCDEBUG("Found stop");
                return ITERATORCALLBACK_RETURNTYPE_STOP;
            }
        } else {
            data->SeparatorFound = true;
            IsValid = false;
        }

        if(IsValid) {
            // Check is this the first character //
            if(!data->Positions.Start) {
                // first position! //
                data->Positions.Start = GetPosition();
                ITR_FUNCDEBUG("Data started: " + Convert::ToString(data->Positions.Start));

            } else {
                // Set end to this valid character //
                data->Positions.End = GetPosition();
                ITR_FUNCDEBUG("End now: " + Convert::ToString(data->Positions.End));
            }
        }


        return ITERATORCALLBACK_RETURNTYPE_CONTINUE;
    }

FindUntilNewLine()

ITERATORCALLBACK_RETURNTYPE Leviathan::StringIterator::FindUntilNewLine ( IteratorFindUntilData *  data )

inlineprotected

Definition at line 1546 of file StringIterator.h.

    {
        // Continue if the current character is a new line character //

        // All line separator characters should be here //
        if(IsAtNewLine()) {

            if(!data->FoundEnd) {
                // Ignore the first new line //
                data->FoundEnd = true;
                ITR_FUNCDEBUG("Ignoring first newline character");
                goto positionisvalidlabelstringiteratorfindnewline;
            }

            // This is a new line character //
            ITR_FUNCDEBUG("Found newline character");

            // End before this character //
            data->Positions.End = GetPosition() - 1;
            ITR_FUNCDEBUG("Ending here: " + Convert::ToString(data->Positions));

            SkipLineEnd();
            return ITERATORCALLBACK_RETURNTYPE_STOP;
        }

    positionisvalidlabelstringiteratorfindnewline:

        // Set position //
        if(!data->Positions.Start) {

            // End before this character //
            data->Positions.Start = GetPosition();
            data->FoundEnd = true;
            ITR_FUNCDEBUG("Data started: " + Convert::ToString(data->Positions));
        }

        return ITERATORCALLBACK_RETURNTYPE_CONTINUE;
    }

FindUntilSequence()

template<class AcceptStr >

ITERATORCALLBACK_RETURNTYPE Leviathan::StringIterator::FindUntilSequence ( IteratorUntilSequenceData< AcceptStr > *  data, int  specialflags  )

inlineprotected

Definition at line 1639 of file StringIterator.h.

    {
        // First check if this is a line end //
        int curcharacter = GetCharacter();

        if(specialflags & SPECIAL_ITERATOR_ONNEWLINE_STOP && IsAtNewLine()) {

            // Set the end to one before this, if found any //
            if(data->Positions.Start) {

                data->Positions.End = GetPosition() - 1;
            }

            SkipLineEnd();
            return ITERATORCALLBACK_RETURNTYPE_STOP;
        }

        // We may not be inside strings nor comments for checking //
        if(!(CurrentFlags & ITERATORFLAG_SET_INSIDE_STRING) &&
            (!(CurrentFlags & ITERATORFLAG_SET_INSIDE_COMMENT) ||
                !(specialflags & SPECIAL_ITERATOR_HANDLECOMMENTS_ASSTRING))) {
            // Check do we match the current position //
            if(curcharacter == data->StringToMatch[data->CurMatchedIndex]) {

                // Found a matching character //

                // Move to next match position and don't yet verify if this is a valid
                // character
                ++data->CurMatchedIndex;

                if(data->CurMatchedIndex >= data->StringToMatch.size()) {

                    // End found //
                    return ITERATORCALLBACK_RETURNTYPE_STOP;
                }

                return ITERATORCALLBACK_RETURNTYPE_CONTINUE;
            }
        }

        // Go back to beginning of matching //
        data->CurMatchedIndex = 0;

        // All is fine //
        if(!data->Positions.Start) {

            data->Positions.Start = GetPosition();
            data->Positions.End = data->Positions.Start;
        } else {

            // This might be poisonous to performance, but this gets the job done //
            data->Positions.End = GetPosition();
        }

        return ITERATORCALLBACK_RETURNTYPE_CONTINUE;
    }

FindUntilSpecificCharacter()

ITERATORCALLBACK_RETURNTYPE Leviathan::StringIterator::FindUntilSpecificCharacter ( IteratorFindUntilData *  data, int  character, int  specialflags  )

inlineprotected

Definition at line 1458 of file StringIterator.h.

    {
        // Can this character be added //
        bool ValidChar = true;

        if(specialflags & SPECIAL_ITERATOR_ONNEWLINE_STOP && IsAtNewLine()) {
            ITR_FUNCDEBUG("Stopping to new line");

            if(data->Positions.Start) {
                // This should be fine to get here //
                data->Positions.End = GetPosition() - 1;
                ITR_FUNCDEBUG("Ending to new line, end is now: " +
                              Convert::ToString(data->Positions.End));
            }

            // Make sure to not return until end of the whole string //
            data->NewLineBreak = true;

            SkipLineEnd();
            return ITERATORCALLBACK_RETURNTYPE_STOP;
        }

        int tmpchara = GetCharacter();

        // We can just continue if we are inside a string //
        if(!(CurrentFlags & ITERATORFLAG_SET_INSIDE_STRING) &&
            !((specialflags & SPECIAL_ITERATOR_HANDLECOMMENTS_ASSTRING) &&
                (CurrentFlags & ITERATORFLAG_SET_INSIDE_COMMENT))) {
            // Check did we encounter stop character //
#ifdef ALLOW_DEBUG
            if(DebugMode) {

                std::string value = "Trying to match: ";
                utf8::append(tmpchara, std::back_inserter(value));
                value += "==" + Convert::ToString(tmpchara);

                Logger::Get()->Write("Iterator: procfunc: " + value);
            }
#endif // ALLOW_DEBUG

            if(tmpchara == character) {
                // Skip if ignoring special characters //
                if(!(CurrentFlags & ITERATORFLAG_SET_IGNORE_SPECIAL)) {
                    // Not valid character //
                    ValidChar = false;
                    ITR_FUNCDEBUG("Found match");
                    // We must have started to encounter the stop character //
                    if(data->Positions.Start) {
                        // We encountered the stop character //
                        data->FoundEnd = true;
                        ITR_FUNCDEBUG("Encountered end");
                    }
                }
            }
        } else {
#ifdef ALLOW_DEBUG
            if((CurrentFlags & ITERATORFLAG_SET_INSIDE_STRING)) {
                ITR_FUNCDEBUG("Ignoring inside string");
            }
            if((specialflags & SPECIAL_ITERATOR_HANDLECOMMENTS_ASSTRING) &&
                (CurrentFlags & ITERATORFLAG_SET_INSIDE_COMMENT)) {
                ITR_FUNCDEBUG("Ignoring inside comment");
            }
#endif // _DEBUG
        }

        if(ValidChar) {
            // valid character set start if not already set //
            if(!data->Positions.Start) {
                data->Positions.Start = GetPosition();
                data->Positions.End = data->Positions.Start;
                ITR_FUNCDEBUG("Data started: " + Convert::ToString(data->Positions.Start));
            }
            return ITERATORCALLBACK_RETURNTYPE_CONTINUE;
        }
        // let's stop if we have found something //
        if(data->Positions.Start) {
            // This should be fine to get here //
            data->Positions.End = GetPosition() - 1;
            ITR_FUNCDEBUG("Ending here: " + Convert::ToString(data->Positions.End));
            return ITERATORCALLBACK_RETURNTYPE_STOP;
        }

        // haven't found anything, we'll need to find something //
        return ITERATORCALLBACK_RETURNTYPE_CONTINUE;
    }

GetCharacter()

int Leviathan::StringIterator::GetCharacter ( size_t  forward = 0 )

inline

Gets the character in the position current + forward.

Definition at line 501 of file StringIterator.h.

    {

        // Special case for current character //
        if(!forward) {

            if(!CurrentStored) {

                if(!DataIterator->GetNextCharCode(CurrentCharacter, 0)) {

                    // Invalid position //
                    return -1;
                }

                CurrentStored = true;

                ITR_COREDEBUG(
                    "Current char: (" + Convert::CodePointToUtf8(CurrentCharacter) + ")");
            }

            return CurrentCharacter;
        }

        // Get the character from our iterator and store it to a temporary value
        // and then return it
        int tmpval = -1;
        DataIterator->GetNextCharCode(tmpval, forward);

        ITR_COREDEBUG("Peek forward char: (" + Convert::CodePointToUtf8(tmpval) + ")");

        return tmpval;
    }

GetCurrentLine()

size_t Leviathan::StringIterator::GetCurrentLine ( )

inline

Returns the current line the processing is happening.

Definition at line 494 of file StringIterator.h.

    {

        return DataIterator->GetCurrentLineNumber();
    }

GetLastValidCharIndex()

size_t Leviathan::StringIterator::GetLastValidCharIndex ( ) const

inline

Returns the last valid index on the iterator.

Definition at line 549 of file StringIterator.h.

    {

        return DataIterator->GetLastValidIteratorPosition();
    }

GetNextCharacterSequence()

template<class RStrType >

std::unique_ptr<RStrType> Leviathan::StringIterator::GetNextCharacterSequence ( int  stopcaseflags, int  specialflags = 0  )

inline

Gets the next sequence of characters according to stopcaseflags.

Parameters

stopcaseflags

Specifies until what type of characters this string is read. Should be created by using UNNORMALCHARACTER as bit flags inside the argument int

Returns

The string found or NULL

Definition at line 238 of file StringIterator.h.

    {
        // Setup the result object //
        IteratorPositionData data;

        // Iterate with our getting function //
        StartIterating(specialflags, &StringIterator::FindNextNormalCharacterString, &data,
            stopcaseflags, specialflags);

        // check for nothing found //
        if(!data.Positions.Start && !data.Positions.Start) {

            return NULL;
        }

        // Make sure end is fine //
        if(!data.Positions.End)
            data.Positions.End = GetLastValidCharIndex();


        // Return the wanted part //
        return GetSubstringFromIndexes<RStrType>(data.Positions.Start, data.Positions.End);
    }

GetNextNumber()

template<class RStrType >

std::unique_ptr<RStrType> Leviathan::StringIterator::GetNextNumber ( DECIMALSEPARATORTYPE  decimal, int  specialflags = 0  )

inline

Gets the next number.

This function will skip until it finds a number and returns the number string according to the decimal parameter. If the type is DECIMALSEPARATORTYPE_NONE decimal numbers are only read until the dot

Returns

The string found or NULL

Definition at line 207 of file StringIterator.h.

    {
        // Setup the result object //
        IteratorNumberFindData data;

        // iterate over the string getting the proper part //
        // Iterate with our getting function //
        StartIterating(
            specialflags, &StringIterator::FindNextNumber, &data, decimal, specialflags);

        // Check for nothing found //
        if(!data.Positions.Start) {
            return nullptr;
        }

        // create substring of the wanted part //


        // Make sure end is fine //
        if(!data.Positions.End)
            data.Positions.End = GetLastValidCharIndex();

        // Return the wanted part //
        return GetSubstringFromIndexes<RStrType>(data.Positions.Start, data.Positions.End);
    }

GetPosition()

size_t Leviathan::StringIterator::GetPosition ( )

inline

Returns the current reading position.

Note

This might be somewhat expensive operation based on the underlying StringDataIterator class (mostly expensive for UTF8 strings)

Definition at line 487 of file StringIterator.h.

    {

        return DataIterator->CurrentIteratorPosition();
    }

GetPositionsUntilACharacter()

IteratorFindUntilData Leviathan::StringIterator::GetPositionsUntilACharacter ( int  character, int  specialflags = 0  )

inline

Gets the position of the current character and the specified character.

Definition at line 626 of file StringIterator.h.

    {
        // Setup the result object //
        IteratorFindUntilData data;

        // Iterate with our getting function //
        StartIterating(specialflags, &StringIterator::FindUntilSpecificCharacter, &data,
            character, specialflags);

#ifdef ITERATOR_ALLOW_DEBUG
        if(DebugMode) {
            Logger::Get()->Write("Iterator: find GetPositionsUntilACharacter, positions: " +
                                 Convert::ToString(data.Positions) +
                                 ", found: " + Convert::ToString(data.FoundEnd));
        }
#endif // _DEBUG

        return data;
    }

GetPreviousCharacter()

DLLEXPORT int Leviathan::StringIterator::GetPreviousCharacter

(

)

Gets the previous character.

Definition at line 82 of file StringIterator.cpp.

{
    int tmpval = -1;
    if(!DataIterator->GetPreviousCharacter(tmpval)) {
        // Darn //
        ITR_COREDEBUG("Failed to get previous character");
        return 0;
    }

    ITR_COREDEBUG("Peek back char: (" + Convert::CodePointToUtf8(tmpval) + ")");
    return tmpval;
}

GetStringInBracketsRecursive()

template<class RStrType >

std::unique_ptr<RStrType> Leviathan::StringIterator::GetStringInBracketsRecursive ( int  specialflags = 0 )

inline

Gets characters inside brackets.

This function will skip until it finds a a left bracket '[' and then returns the content inside keeping track of the number of '[' and ']' characters encountered and returns once the top level brackets close

Note

Empty brackets "[]" are considered invalid and return NULL

Returns

The string found or NULL

Definition at line 429 of file StringIterator.h.

    {

        // Setup the result object //
        IteratorNestingLevelData data;

        // Iterate with our getting function //
        StartIterating(specialflags, &StringIterator::FindInMatchingParentheses, &data, '[',
            ']', specialflags);

        // Create the substring from the result //
        std::unique_ptr<RStrType> resultstr;

        // NULL if nothing found //
        if(!data.Positions.Start || !data.Positions.End)
            return nullptr;

        // Return the wanted part //
        return GetSubstringFromIndexes<RStrType>(data.Positions.Start, data.Positions.End);
    }

GetStringInQuotes()

template<class RStrType >

std::unique_ptr<RStrType> Leviathan::StringIterator::GetStringInQuotes ( QUOTETYPE  quotes, int  specialflags = 0  )

inline

Gets the next string in quotes.

This function will skip until it finds a quote (either " or ' specified by quotes) and then returns the content inside

Returns

The string found or NULL

Definition at line 180 of file StringIterator.h.

    {
        // Setup the result object //
        IteratorPositionData data;

        // Iterate with our getting function //
        StartIterating(
            specialflags, &StringIterator::FindFirstQuotedString, &data, quotes, specialflags);

        // Create the substring from the result //
        std::unique_ptr<RStrType> resultstr;

        // NULL if nothing found //
        if(!data.Positions.Start || !data.Positions.End)
            return nullptr;

        // Return the wanted part //
        return GetSubstringFromIndexes<RStrType>(data.Positions.Start, data.Positions.End);
    }

GetSubstringFromIndexes()

template<class STRSType >

std::unique_ptr<STRSType> Leviathan::StringIterator::GetSubstringFromIndexes ( size_t  firstcharacter, size_t  lastcharacter  ) const

inline

Returns substring from the wanted indexes.

Definition at line 605 of file StringIterator.h.

    {
        // Don't want to do anything if no string //
        if(!DataIterator)
            return nullptr;

        // Return a substring from our data source //
        std::unique_ptr<STRSType> returnval(new STRSType());

        if(DataIterator->ReturnSubString(firstcharacter, lastcharacter, *returnval)) {

            return returnval;
        }

        // It failed for some reason //
        return nullptr;
    }

GetUntilCharacterSequence()

template<class RStrType >

std::unique_ptr<RStrType> Leviathan::StringIterator::GetUntilCharacterSequence ( const RStrType &  findstr, int  specialflags = 0  )

inline

Gets all characters until a sequence is matched.

Returns

The string found or NULL

Bug:

Finding until an UTF-8 sequence doesn't work, the findstr parameter should be a StringDataIterator for it to work

Definition at line 394 of file StringIterator.h.

    {
        // Setup the result object //
        IteratorUntilSequenceData<RStrType> data(findstr);

        // Iterate with our getting function //
        StartIterating(
            specialflags, &StringIterator::FindUntilSequence<RStrType>, &data, specialflags);

        // Check for validity //
        if(!data.Positions.Start) {
            // Nothing found //
            return nullptr;
        }

        // This only happens when the string ends with a partial match //
        // Example: look for "this", string is like this: my super nice th
        if(!data.Positions.End) {
            // Set to end of string //
            data.Positions.End = GetLastValidCharIndex();
        }

        // Return the wanted part //
        return GetSubstringFromIndexes<RStrType>(data.Positions.Start, data.Positions.End);
    }

GetUntilEnd()

template<class RStrType >

std::unique_ptr<RStrType> Leviathan::StringIterator::GetUntilEnd ( )

inline

Gets all characters until the end.

Note

This does not advance the iterator so this object can still be used after this

Returns

The string found or NULL if the read position is invalid

Definition at line 297 of file StringIterator.h.

    {

        // Just return from here to the last character //
        return GetSubstringFromIndexes<RStrType>(GetPosition(), GetLastValidCharIndex());
    }

GetUntilEqualityAssignment()

template<class RStrType >

std::unique_ptr<RStrType> Leviathan::StringIterator::GetUntilEqualityAssignment ( EQUALITYCHARACTER  stopcase, int  specialflags = 0  )

inline

Gets the string that is before the equality assignment.

This function will read until either : or = is encountered specified by stopcase

Returns

The string found or NULL

Definition at line 267 of file StringIterator.h.

    {
        // Setup the result object //
        IteratorAssignmentData data;

        // Iterate with our getting function //
        StartIterating(
            specialflags, &StringIterator::FindUntilEquality, &data, stopcase, specialflags);

        // Check for validity //
        if(!data.Positions.Start || data.SeparatorFound == false) {
            // nothing found //
            return nullptr;
        }

        if(!data.Positions.End) {
            // Set to start, this only happens if there is just one character //
            data.Positions.End = data.Positions.Start;
        }

        // Return the wanted part //
        return GetSubstringFromIndexes<RStrType>(data.Positions.Start, data.Positions.End);
    }

GetUntilLineEnd()

template<class RStrType >

std::unique_ptr<RStrType> Leviathan::StringIterator::GetUntilLineEnd ( )

inline

Gets all characters until a line end.

This function will read until a new line character and end after it

Returns

The string found or NULL

Definition at line 309 of file StringIterator.h.

    {

        // Setup the result object //
        IteratorFindUntilData data;

        // Iterate with our getting function //
        StartIterating(0, &StringIterator::FindUntilNewLine, &data);

        // Check for validity //
        if(!data.Positions.Start) {
            // Nothing found //
            return nullptr;
        }

        if(!data.Positions.End) {
            // Set to end of string //
            data.Positions.End = GetLastValidCharIndex();
        }

        // Return the wanted part //
        return GetSubstringFromIndexes<RStrType>(data.Positions.Start, data.Positions.End);
    }

GetUntilNextCharacterOrAll()

template<class RStrType >

std::unique_ptr<RStrType> Leviathan::StringIterator::GetUntilNextCharacterOrAll ( int  charactertolookfor, int  specialflags = 0  )

inline

Gets characters until a character or all remaining characters.

This function will read until charactertolookfor and return the string without charactertolookfor, or if not found until the end

Parameters

charactertolookfor

The code point to look for

Returns

The string found or NULL if there are no valid characters left

See also

GetUntilNextCharacterOrAll GetUntilEnd

Definition at line 368 of file StringIterator.h.

    {
        auto data = GetPositionsUntilACharacter(charactertolookfor, specialflags);

        if(!data.Positions.Start || !data.Positions.End) {
            // return empty string //
            return nullptr;
        }

        // Return all if not found //
        if(!data.FoundEnd &&
            (!data.NewLineBreak || !(specialflags & SPECIAL_ITERATOR_ONNEWLINE_STOP))) {
            return GetSubstringFromIndexes<RStrType>(
                data.Positions.Start, GetLastValidCharIndex());
        }

        // Return the wanted part //
        return GetSubstringFromIndexes<RStrType>(data.Positions.Start, data.Positions.End);
    }

GetUntilNextCharacterOrNothing()

template<class RStrType >

std::unique_ptr<RStrType> Leviathan::StringIterator::GetUntilNextCharacterOrNothing ( int  charactertolookfor, int  specialflags = 0  )

inline

Gets characters until a character or nothing if the specified character is not found.

This function will read until charactertolookfor and return the string without charactertolookfor, or if not found nothing

Parameters

charactertolookfor

The code point to look for

Returns

The string found or NULL

See also

GetUntilNextCharacterOrAll

Definition at line 344 of file StringIterator.h.

    {

        auto data = GetPositionsUntilACharacter(charactertolookfor, specialflags);

        // Check was the end found //
        if(!data.FoundEnd || !data.Positions.Start) {
            // not found the ending character //
            return nullptr;
        }

        // Return the wanted part //
        return GetSubstringFromIndexes<RStrType>(data.Positions.Start, data.Positions.End);
    }

IsAtNewLine()

bool Leviathan::StringIterator::IsAtNewLine ( )

inline

Returns true if current character is a new line.

Definition at line 535 of file StringIterator.h.

    {

        // Ignore new lines if '\' is put before them
        if(CurrentFlags & ITERATORFLAG_SET_IGNORE_SPECIAL)
            return false;

        return StringOperations::IsLineTerminator(GetCharacter());
    }

IsInsideComment()

bool Leviathan::StringIterator::IsInsideComment ( )

inline

Definition at line 597 of file StringIterator.h.

    {

        return CurrentFlags & ITERATORFLAG_SET_INSIDE_CCOMMENT;
    }

IsInsideString()

bool Leviathan::StringIterator::IsInsideString ( )

inline

Definition at line 591 of file StringIterator.h.

    {

        return CurrentFlags & ITERATORFLAG_SET_INSIDE_STRING;
    }

IsOutOfBounds()

bool Leviathan::StringIterator::IsOutOfBounds ( )

inline

Returns true when the read position is valid.

Definition at line 584 of file StringIterator.h.

    {

        return !DataIterator->IsPositionValid();
    }

MoveToNext()

bool Leviathan::StringIterator::MoveToNext ( )

inline

Skips the current character and moves to the next.

Returns

True when there is a valid character or false if the end has already been reached

Definition at line 558 of file StringIterator.h.

    {

        DataIterator->MoveToNextCharacter();
        bool valid = DataIterator->IsPositionValid();
        // It's important to reset this //
        CurrentStored = false;

        // We need to handle the flags on this position if we aren't on the first character //
        if(valid && DataIterator->CurrentIteratorPosition() != 0) {

            ITR_COREDEBUG("Move to next");

            CheckActiveFlags();

            // check current character //
            HandleSpecialCharacters();
        }

        return valid;
    }

ReInit() [1/5]

DLLEXPORT void StringIterator::ReInit

(

std::unique_ptr< StringDataIterator > &&

iterator

)

Changes the current iterator to the new iterator and goes to the beginning.

Definition at line 40 of file StringIterator.cpp.

{
    // Remove the last iterator //
    if(HandlesDelete) {

        SAFE_DELETE(DataIterator);
    }

    ITR_COREDEBUG("ReInit")

    HandlesDelete = true;
    DataIterator = iterator.release();

    // Reset everything //
    CurrentCharacter = -1;
    CurrentStored = false;


    // Clear the flags //
    CurrentFlags = 0;
}

ReInit() [2/5]

DLLEXPORT void Leviathan::StringIterator::ReInit

(

const std::wstring &

text

)

Helper function for ReInit for common string type.

Definition at line 62 of file StringIterator.cpp.

{
    ReInit(std::make_unique<StringClassDataIterator<wstring>>(text));
}

ReInit() [3/5]

DLLEXPORT void Leviathan::StringIterator::ReInit

(

const std::string &

text

)

Helper function for ReInit for common string type.

Definition at line 67 of file StringIterator.cpp.

{
    ReInit(std::make_unique<StringClassDataIterator<string>>(text));
}

ReInit() [4/5]

DLLEXPORT void Leviathan::StringIterator::ReInit

(

const std::wstring *

text

)

Helper function for ReInit for common string type.

Parameters

text	Pointer to a string that won't be deleted by this

Definition at line 72 of file StringIterator.cpp.

{
    ReInit(std::make_unique<StringClassPointerIterator<wstring>>(text));
}

ReInit() [5/5]

DLLEXPORT void Leviathan::StringIterator::ReInit

(

const std::string *

text

)

Helper function for ReInit for common string type.

Parameters

text	Pointer to a string that won't be deleted by this

Definition at line 77 of file StringIterator.cpp.

{
    ReInit(std::make_unique<StringClassPointerIterator<string>>(text));
}

SkipCharacters()

void Leviathan::StringIterator::SkipCharacters ( int  chartoskip, int  additionalflag = 0, int  specialflags = 0  )

inline

Skips until chartoskip doesn't match the current character.

Parameters

chartoskip	The code point to skip
additionalflag	Flag composing of UNNORMALCHARACTER_TYPE which defines additional things to skip

See also

SkipWhiteSpace

Definition at line 463 of file StringIterator.h.

    {
        IteratorCharacterData stufftoskip(chartoskip);

        // Iterate over the string skipping until hit something that doesn't need to be
        // skipped
        StartIterating(specialflags, &StringIterator::SkipSomething, stufftoskip,
            additionalflag, specialflags);
    }

SkipLineEnd()

DLLEXPORT void Leviathan::StringIterator::SkipLineEnd

(

)

Skips characters until the line number changes.

Definition at line 95 of file StringIterator.cpp.

{
    ITR_COREDEBUG("Skip line end");

    const auto current = GetCharacter(0);
    const auto next = GetCharacter(1);

    // Move past the current new line //
    MoveToNext();

    // Skip multi part new lines //
    if(StringOperations::IsLineTerminator(current, next))
        MoveToNext();
}

SkipSomething()

ITERATORCALLBACK_RETURNTYPE Leviathan::StringIterator::SkipSomething ( IteratorCharacterData &  data, const int  additionalskip, const int  specialflags  )

inlineprotected

Definition at line 1420 of file StringIterator.h.

    {
        if(specialflags & SPECIAL_ITERATOR_ONNEWLINE_STOP && IsAtNewLine()) {
            ITR_FUNCDEBUG("Stopping to new line");

            SkipLineEnd();
            return ITERATORCALLBACK_RETURNTYPE_STOP;
        }

        // We can probably always skip inside a comment //
        if((specialflags & SPECIAL_ITERATOR_HANDLECOMMENTS_ASSTRING) &&
            (CurrentFlags & ITERATORFLAG_SET_INSIDE_COMMENT)) {
            return ITERATORCALLBACK_RETURNTYPE_CONTINUE;
        }

        // We can just return if we are inside a string //
        if(CurrentFlags & ITERATORFLAG_SET_INSIDE_STRING) {
            return ITERATORCALLBACK_RETURNTYPE_STOP;
        }

        // Check does the character match what is being skipped //
        int curchara = GetCharacter();

        if(additionalskip & UNNORMALCHARACTER_TYPE_LOWCODES) {
            if(curchara <= 32)
                return ITERATORCALLBACK_RETURNTYPE_CONTINUE;
        }

        if(curchara == data.CharacterToUse) {
            // We want to skip it //
            return ITERATORCALLBACK_RETURNTYPE_CONTINUE;
        }

        // didn't match to be skipped characters //
        return ITERATORCALLBACK_RETURNTYPE_STOP;
    }

SkipWhiteSpace()

void Leviathan::StringIterator::SkipWhiteSpace ( int  specialflags = 0 )

inline

Skips until characters that are not whitespace are found.

See also

SkipCharacters

Definition at line 452 of file StringIterator.h.

    {

        SkipCharacters(32, UNNORMALCHARACTER_TYPE_LOWCODES, specialflags);
    }

---

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

• StringIterator.h
• StringIterator.cpp