// ############################################################################################# // Internals // ############################################################################################# /** **************************************************************************************** * Internal, recursive helper of #Find. * * @param domainPath Path to search. * @param sensitivity Denotes if domain name search is treated case sensitive or not. * @param maxCreate The maximum number of sub domains that are created if not * found at the end of the path. * @param[out] wasCreated Output parameter that is set \c true if domain was not found * and hence created. * @return The domain found or created. ******************************************************************************************/ protected Domain findRecursive( Substring domainPath, Case sensitivity, int maxCreate, ref bool wasCreated ) { //--- get act sub-name and rest of path domainPath.Consume( Separator ); int endSubName= domainPath.IndexOf( Separator ); ALIB.ASSERT_ERROR( endSubName != 0, "Internal Error" ); // find end of actual domain name and save rest Substring restOfDomainPath= tSubstring2; restOfDomainPath.SetNull(); if ( endSubName > 0 ) domainPath.Split( endSubName, restOfDomainPath, 1 ); // search sub-domain Domain subDomain= null; // "." if( domainPath.Equals( "." ) ) subDomain= this; // ".." else if( domainPath.Equals( ".." ) ) subDomain= Parent != null ? Parent : this; // search in sub-domain else { int i; bool fixedOnce= false; for(;;) { for( i= 0; i< SubDomains.Count; i++ ) { int comparison= SubDomains[i].Name.CompareTo( domainPath, sensitivity ); if( comparison >= 0 ) { if ( comparison == 0 ) subDomain= SubDomains[i]; break; } } // domain found? if ( subDomain != null ) break; // try and fix name if( !fixedOnce ) { fixedOnce= true; bool illegalCharacterFound= false; for( int cp= 0; cp< domainPath.Length() ; ++cp ) { char c= domainPath.CharAt(cp); if ( c < '-' || c > 'z' || c == '<' || c == '>' || c == '[' || c == ']' || c == '=' || c == '?' || c == ';' || c == ':' || c == '\\'|| c == '\''|| c == '.' || c == ',' ) { illegalCharacterFound= true; domainPath.Buf[domainPath.Start + cp]= '#'; } } if ( illegalCharacterFound ) continue; } // create if ( maxCreate == 0 ) return null; wasCreated= true; SubDomains.Insert( i, subDomain= new Domain( this, new AString( domainPath ) ) ); maxCreate--; if ( maxCreate == 0 ) return subDomain; break; } } // recursion? if ( restOfDomainPath.IsNotEmpty() ) { domainPath.Set( restOfDomainPath ); return subDomain.findRecursive( domainPath, sensitivity, maxCreate, ref wasCreated ); } // that's it return subDomain; }
/** **************************************************************************************** * Helper method used when reading file. * @param subs A sub-string. * @return true if provided substring starts with comment character. ******************************************************************************************/ protected bool startsWithCommentSymbol( Substring subs ) { int i= commentChars.IndexOf( subs.CharAtStart() ); return ( i >= 0 && i < 2) || ( i == 2 && subs.CharAt(1) == '/' ); }
/** **************************************************************************************** * Interprets given \p src as a value of enum type * \ref cs::aworx::lib::enums::Inclusion "enums.Inclusion". * If the case insensitive comparison of the first non-whitespace characters of the string * with values "i", "y", "t", "1" * matches, \b %Inclusion.Include is returned. * Otherwise, including the case that \p src is 'nulled', \b %Inclusion.Exclude is returned. * * @param src The string to 'parse'. * * @returns The \b %Inclusion value read. ******************************************************************************************/ public static Inclusion ReadInclusion( Substring src ) { int idx= src.IndexOfAny( CString.DefaultWhitespaces, Inclusion.Exclude ); if ( idx >= 0 ) { int c= Char.ToLower( src.CharAt(idx) ); foreach ( char v in trueValuesInclusion ) if ( c == v ) return Inclusion.Include; } return Inclusion.Exclude; }
/** **************************************************************************************** * Interprets given \p src as a value of enum type * \ref aworx.lib::enums::Case "enums.Case". * If the case insensitive comparison of the first non-whitespace characters of the string * with values "s", "y", "t", "1" * matches, \b %Case.Sensitive is returned. * Otherwise, including the case that \p src is 'nulled', \b %Case.Ignore is returned. * * @param src The string to 'parse'. * * @returns The \b %Case value read. ******************************************************************************************/ public static Case ReadCase( Substring src ) { int idx= src.IndexOfAny( CString.DefaultWhitespaces, Inclusion.Exclude ); if ( idx >= 0 ) { int c= Char.ToLower( src.CharAt(idx) ); foreach ( char v in trueValuesCase ) if ( c == v ) return Case.Sensitive; } return Case.Ignore; }
/** **************************************************************************************** * Interprets given \p src as a boolean value. * \ref cs::aworx::lib::enums::Inclusion "enums.Inclusion". * If the case insensitive comparison of the first non-whitespace characters of the string with * with values "t", "1", "y", "on", "ok" * matches, \c true is returned. * Otherwise, including the case that \p src is 'nulled', \c false is returned. * * @param src The string to 'parse'. * * @returns The \b %Case value read. ******************************************************************************************/ public static bool ReadBoolean( Substring src ) { int idx= src.IndexOfAny( CString.DefaultWhitespaces, Inclusion.Exclude ); if ( idx >= 0 ) { char c= Char.ToLower( src.CharAt(idx) ); foreach ( char v in trueValuesBoolean ) if ( c == v ) return true; char c2= Char.ToLower( src.CharAt( idx + 1 ) ); if ( c == 'o' && ( c2 == 'n' || c2 == 'k' ) ) return true; } return false; }
/** **************************************************************************************** * Interprets given \p src as a verbosity. * A case insensitive comparison of only the first (!) character of the start of the string * is performed (against 'v', 'i', 'w' and 'e'). * If no match is found, \e %Verbosity::Off is returned. * @param src The string to 'parse'. * @returns The verbosity read. ******************************************************************************************/ public static Verbosity ReadVerbosity( Substring src ) { int idx= src.IndexOfAny( CString.DefaultWhitespaces, Inclusion.Exclude ); if ( idx >= 0 ) { char c= Char.ToLower( src.CharAt(idx) ); if ( c == 'v' ) return Verbosity.Verbose; if ( c == 'i' ) return Verbosity.Info; if ( c == 'w' ) return Verbosity.Warning; if ( c == 'e' ) return Verbosity.Error; } return Verbosity.Off; }
public void FrontEnd() { // empty substring { Substring subs= new Substring(); UT_EQ( '\0', subs.CharAtStart( ) ); UT_EQ( '\0', subs.CharAt( 0 ) ); UT_EQ( '\0', subs.CharAt( 1 ) ); UT_EQ( '\0', subs.CharAt(-1 ) ); UT_EQ( '\0', subs.CharAt( 2 ) ); UT_EQ( '\0', subs.CharAt(-2 ) ); UT_EQ( '\0', subs.CharAtEnd ( ) ); UT_EQ( '\0', subs.CharAtEnd ( 0 ) ); UT_EQ( '\0', subs.CharAtEnd ( 1 ) ); UT_EQ( '\0', subs.CharAtEnd (-1 ) ); UT_EQ( '\0', subs.CharAtEnd ( 2 ) ); UT_EQ( '\0', subs.CharAtEnd (-2 ) ); } // empty substring { Substring subs= new Substring("aaaaaaaaaaaa"); subs.Start= 5; subs.End= 4; UT_EQ( '\0', subs.CharAtStart( ) ); UT_EQ( '\0', subs.CharAt( 0 ) ); UT_EQ( '\0', subs.CharAt( 1 ) ); UT_EQ( '\0', subs.CharAt(-1 ) ); UT_EQ( '\0', subs.CharAt( 2 ) ); UT_EQ( '\0', subs.CharAt(-2 ) ); UT_EQ( '\0', subs.CharAtEnd ( ) ); UT_EQ( '\0', subs.CharAtEnd ( 0 ) ); UT_EQ( '\0', subs.CharAtEnd ( 1 ) ); UT_EQ( '\0', subs.CharAtEnd (-1 ) ); UT_EQ( '\0', subs.CharAtEnd ( 2 ) ); UT_EQ( '\0', subs.CharAtEnd (-2 ) ); } // substring of length 1 { Substring subs= new Substring("aaaaaaaaaaaa"); subs.Start= subs.End= 5; UT_EQ('a', subs.CharAtStart( ) ); UT_EQ('a', subs.CharAt( 0 ) ); UT_EQ('\0', subs.CharAt( 1 ) ); UT_EQ('\0', subs.CharAt(-1 ) ); UT_EQ('\0', subs.CharAt( 2 ) ); UT_EQ('\0', subs.CharAt(-2 ) ); UT_EQ('a', subs.CharAtEnd ( ) ); UT_EQ('a', subs.CharAtEnd ( 0 ) ); UT_EQ('\0', subs.CharAtEnd ( 1 ) ); UT_EQ('\0', subs.CharAtEnd (-1 ) ); UT_EQ('\0', subs.CharAtEnd ( 2 ) ); UT_EQ('\0', subs.CharAtEnd (-2 ) ); } // substring of length 2 { Substring subs= new Substring("aaaaabbbbbb"); subs.End= subs.IndexOf('b'); subs.Start= subs.End - 1; UT_EQ('a', subs.CharAtStart( ) ); UT_EQ('a', subs.CharAt( 0 ) ); UT_EQ('b', subs.CharAt( 1 ) ); UT_EQ('\0', subs.CharAt(-1 ) ); UT_EQ('\0', subs.CharAt( 2 ) ); UT_EQ('\0', subs.CharAt(-2 ) ); UT_EQ('b', subs.CharAtEnd ( ) ); UT_EQ('b', subs.CharAtEnd ( 0 ) ); UT_EQ('a', subs.CharAtEnd ( 1 ) ); UT_EQ('\0', subs.CharAtEnd (-1 ) ); UT_EQ('\0', subs.CharAtEnd ( 2 ) ); UT_EQ('\0', subs.CharAtEnd (-2 ) ); } }