// #############################################################################################
// 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;
}
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 ) );
}
}
public void IndexOf()
{
Substring subs;
// indexOf()
{
subs= new Substring("ABCD");
UT_EQ( -1, subs.IndexOf('X') );
UT_EQ( 0, subs.IndexOf('A') );
UT_EQ( 1, subs.IndexOf('B') );
UT_EQ( 2, subs.IndexOf('C') );
UT_EQ( 3, subs.IndexOf('D') );
}
// search characters
subs.Set( "abc@" + "abcd abcd" + "abc@de", 4, 9 );
{
UT_EQ( -1 , subs.IndexOf( '@', -5 ) );
UT_EQ( -1 , subs.IndexOf( '@' ) );
UT_EQ( -1 , subs.IndexOf( '@', 5 ) );
UT_EQ( -1 , subs.IndexOf( '@', 150 ) );
UT_EQ( 0 , subs.IndexOf( 'a' ) );
UT_EQ( 1 , subs.IndexOf( 'b' ) );
UT_EQ( 2 , subs.IndexOf( 'c' ) );
UT_EQ( 0 , subs.IndexOf( 'a', 0 ) );
UT_EQ( 1 , subs.IndexOf( 'b', 0 ) );
UT_EQ( 2 , subs.IndexOf( 'c', 0 ) );
UT_EQ( 5 , subs.IndexOf( 'a', 1 ) );
UT_EQ( 1 , subs.IndexOf( 'b', 1 ) );
UT_EQ( 2 , subs.IndexOf( 'c', 1 ) );
UT_EQ( 5 , subs.IndexOf( 'a', 2 ) );
UT_EQ( 6 , subs.IndexOf( 'b', 2 ) );
UT_EQ( 2 , subs.IndexOf( 'c', 2 ) );
UT_EQ( 5 , subs.IndexOf( 'a', 3 ) );
UT_EQ( 6 , subs.IndexOf( 'b', 3 ) );
UT_EQ( 7 , subs.IndexOf( 'c', 3 ) );
UT_EQ( 8 , subs.IndexOf( 'd', 7 ) );
UT_EQ( 8 , subs.IndexOf( 'd', 8 ) );
UT_EQ( -1 , subs.IndexOf( 'd', 9 ) );
}
// search null, empty string
subs.Set( "abc@" + "abcd abcd" + "abc@de", 4, 9 );
{
UT_EQ( 0 , subs.IndexOf( (AString) null ) );
UT_EQ( 5 , subs.IndexOf( (AString) null, 5 ) );
UT_EQ( -1 , subs.IndexOf( (AString) null, 50 ) );
UT_EQ( 0 , subs.IndexOf( (AString) null, - 5 ) );
UT_EQ( 0 , subs.IndexOf( (String) null ) );
UT_EQ( 5 , subs.IndexOf( (String) null, 5 ) );
UT_EQ( -1 , subs.IndexOf( (String) null, 50 ) );
UT_EQ( 0 , subs.IndexOf( (String) null, - 5 ) );
UT_EQ( 0 , subs.IndexOf( "", - 5 ) );
UT_EQ( 0 , subs.IndexOf( "", 0 ) );
UT_EQ( 4 , subs.IndexOf( "", 4 ) );
UT_EQ( -1 , subs.IndexOf( "", 100 ) );
}
// search
subs.Set( "abc@" + "abcd abcd" + "abc@de", 4, 9 );
{
UT_EQ( 0 , subs.IndexOf( "abcd" ) );
UT_EQ( 1 , subs.IndexOf( "b" ) );
UT_EQ( 4 , subs.IndexOf( " abcd" ) );
UT_EQ( 5 , subs.IndexOf( "abcd", 1 ) );
UT_EQ( 0 , subs.IndexOf( "abcd",- 1 ) );
UT_EQ( -1, subs.IndexOf( "xyz", -10 ) );
}
// ignore case
String t= "Hello A-Worx util";
subs.Set( "abc@" + t + "abc@de", 4, t.Length );
{
UT_EQ( 6 , subs.IndexOf( "a-worx", 0 ,Case.Ignore ) );
UT_EQ( 6 , subs.IndexOf( "a-worx", 1 ,Case.Ignore ) );
UT_EQ( 6 , subs.IndexOf( "a-worx", -10 ,Case.Ignore ) );
UT_EQ( 6 , subs.IndexOf( "a-worx", 6 ,Case.Ignore ) );
UT_EQ( -1, subs.IndexOf( "a-worx", 7 ,Case.Ignore ) );
UT_EQ( -1, subs.IndexOf( "a-worx", 100 ,Case.Ignore ) );
UT_EQ( 0, subs.IndexOf( "hel", 0 ,Case.Ignore ) );
UT_EQ( -1, subs.IndexOf( "hel", 1 ,Case.Ignore ) );
UT_EQ( 13, subs.IndexOf( "util", 1 ,Case.Ignore ) );
UT_EQ( 13, subs.IndexOf( "UTIL", 5 ,Case.Ignore ) );
UT_EQ( 13, subs.IndexOf( "UTIL", 13 ,Case.Ignore ) );
UT_EQ( -1, subs.IndexOf( "UTIL", 14 ,Case.Ignore ) );
}
// ------------------ search one of several characters ------------------
subs.Set( "abc@" + "abcd abcde" + "abc@de", 4, 10 );
{
// search one of
int l= subs.Length();
UT_EQ( 4, subs.IndexOfAny ( CString.DefaultWhitespaces,Inclusion.Include ) );
UT_EQ( -1, subs.IndexOfAny ( "x" .ToCharArray() ,Inclusion.Include ) );
UT_EQ( -1, subs.IndexOfAny ( "xy" .ToCharArray() ,Inclusion.Include ) );
UT_EQ( -1, subs.IndexOfAny ( "xyz" .ToCharArray() ,Inclusion.Include ) );
UT_EQ( 3, subs.IndexOfAny ( "xyd" .ToCharArray() ,Inclusion.Include ) );
UT_EQ( 3, subs.IndexOfAny ( "d" .ToCharArray() ,Inclusion.Include ) );
UT_EQ( 3, subs.IndexOfAny ( "xyd" .ToCharArray() ,Inclusion.Include, -2 ) );
UT_EQ( 8, subs.IndexOfAny ( "xyd" .ToCharArray() ,Inclusion.Include, 4 ) );
UT_EQ( -1, subs.IndexOfAny ( "xyd" .ToCharArray() ,Inclusion.Include, 20 ) );
UT_EQ( -1, subs.LastIndexOfAny( "" .ToCharArray() ,Inclusion.Include ) );
UT_EQ( -1, subs.LastIndexOfAny( "x" .ToCharArray() ,Inclusion.Include ) );
UT_EQ( -1, subs.LastIndexOfAny( "xy" .ToCharArray() ,Inclusion.Include ) );
UT_EQ( -1, subs.LastIndexOfAny( "xyz" .ToCharArray() ,Inclusion.Include ) );
UT_EQ( 8, subs.LastIndexOfAny( "xyd" .ToCharArray() ,Inclusion.Include ) );
UT_EQ( -1, subs.LastIndexOfAny( "xyd" .ToCharArray() ,Inclusion.Include, -2 ) );
UT_EQ( -1, subs.LastIndexOfAny( "xyd" .ToCharArray() ,Inclusion.Include, 2 ) );
UT_EQ( 3, subs.LastIndexOfAny( "xyd" .ToCharArray() ,Inclusion.Include, 4 ) );
UT_EQ( 0, subs.LastIndexOfAny( "a" .ToCharArray() ,Inclusion.Include, 4 ) );
UT_EQ( 1, subs.LastIndexOfAny( "b" .ToCharArray() ,Inclusion.Include, 4 ) );
UT_EQ( 1, subs.LastIndexOfAny( "ba" .ToCharArray() ,Inclusion.Include, 4 ) );
UT_EQ( 0, subs.LastIndexOfAny( "xa" .ToCharArray() ,Inclusion.Include, 4 ) );
UT_EQ( 8, subs.LastIndexOfAny( "xyd" .ToCharArray() ,Inclusion.Include, 20 ) );
UT_EQ( 8, subs.LastIndexOfAny( "d" .ToCharArray() ,Inclusion.Include, 20 ) );
UT_EQ( 9, subs.LastIndexOfAny( "e" .ToCharArray() ,Inclusion.Include, 20 ) );
// search NOT one of
UT_EQ( 0, subs.IndexOfAny ( "" .ToCharArray() ,Inclusion.Exclude ) );
UT_EQ( 0, subs.IndexOfAny ( "x" .ToCharArray() ,Inclusion.Exclude ) );
UT_EQ( 0, subs.IndexOfAny ( "xy" .ToCharArray() ,Inclusion.Exclude ) );
UT_EQ( 0, subs.IndexOfAny ( "xyz" .ToCharArray() ,Inclusion.Exclude ) );
UT_EQ( 1, subs.IndexOfAny ( "a" .ToCharArray() ,Inclusion.Exclude ) );
UT_EQ( 2, subs.IndexOfAny ( "ba" .ToCharArray() ,Inclusion.Exclude ) );
UT_EQ( 3, subs.IndexOfAny ( "abc" .ToCharArray() ,Inclusion.Exclude ) );
UT_EQ( 3, subs.IndexOfAny ( "acb" .ToCharArray() ,Inclusion.Exclude ) );
UT_EQ( 3, subs.IndexOfAny ( "cba" .ToCharArray() ,Inclusion.Exclude ) );
UT_EQ( 3, subs.IndexOfAny ( "xcba" .ToCharArray() ,Inclusion.Exclude ) );
UT_EQ( l-1, subs.LastIndexOfAny( "" .ToCharArray() ,Inclusion.Exclude ) );
UT_EQ( l-1, subs.LastIndexOfAny( "x" .ToCharArray() ,Inclusion.Exclude ) );
UT_EQ( l-1, subs.LastIndexOfAny( "xy" .ToCharArray() ,Inclusion.Exclude ) );
UT_EQ( l-2, subs.LastIndexOfAny( "e" .ToCharArray() ,Inclusion.Exclude ) );
UT_EQ( l-3, subs.LastIndexOfAny( "de" .ToCharArray() ,Inclusion.Exclude ) );
UT_EQ( l-4, subs.LastIndexOfAny( "cde" .ToCharArray() ,Inclusion.Exclude ) );
UT_EQ( l-4, subs.LastIndexOfAny( "ced" .ToCharArray() ,Inclusion.Exclude ) );
UT_EQ( l-4, subs.LastIndexOfAny( "ecd" .ToCharArray() ,Inclusion.Exclude ) );
UT_EQ( 5, subs.LastIndexOfAny( "ecd" .ToCharArray() ,Inclusion.Exclude, 5 ) );
UT_EQ( 4, subs.LastIndexOfAny( "ecd" .ToCharArray() ,Inclusion.Exclude, 4 ) );
UT_EQ( 1, subs.LastIndexOfAny( "acd" .ToCharArray() ,Inclusion.Exclude, 3 ) );
UT_EQ( -1, subs.LastIndexOfAny( "abc" .ToCharArray() ,Inclusion.Exclude, 2 ) );
UT_EQ( 3, subs.LastIndexOfAny( "xay" .ToCharArray() ,Inclusion.Exclude, 3 ) );
UT_EQ( 2, subs.LastIndexOfAny( "d" .ToCharArray() ,Inclusion.Exclude, 3 ) );
UT_EQ( -1, subs.LastIndexOfAny( "a" .ToCharArray() ,Inclusion.Exclude, 0 ) );
}
}
/** ****************************************************************************************
* Implements functionality for configuration variable \c LOXNAME_LOGGERNAME_VERBOSITY.
* Is called when a logger is removed.
* @param logger The logger to write the verbosity for.
******************************************************************************************/
protected void writeVerbositiesOnLoggerRemoval( Logger logger )
{
// When writing back we will use this priority as the maximum to write. This way, if this was
// an automatic default value, we will not write back into the user's variable store.
// As always, only if the app fetches new variables on termination, this is entry is copied.
Variable variable= new Variable( ALox.VERBOSITY, GetName(), logger.GetName() );
variable.Load();
// first token is "writeback" ?
if ( variable.Size() == 0 )
return;
Substring firstArg= new Substring( variable.GetString() );
if ( !firstArg.Consume( "writeback", Case.Ignore, Whitespaces.Trim ) )
return;
// optionally read a destination variable name
Substring destVarCategory = new Substring();
Substring destVarName = new Substring();
if( firstArg.Trim().IsNotEmpty() )
{
// separate category from variable name
int catSeparatorIdx= firstArg.IndexOf( '_' );
if (catSeparatorIdx >= 0 )
{
destVarCategory.Set( firstArg, 0 , catSeparatorIdx );
destVarName .Set( firstArg, catSeparatorIdx + 1);
}
else
destVarName.Set( firstArg );
if ( destVarName.IsEmpty() )
{
logInternal( Verbosity.Error, "VAR", intMsg._()
._( "Argument 'writeback' in variable " )
._( variable.Fullname)
._( "\n Error: Wrong destination variable name format\"" )
._( firstArg )._( "\"" ) );
return;
}
}
// either write directly into LOX_LOGGER_VERBOSITY variable...
Variable destVar= null;
if( destVarName.IsEmpty() )
{
variable.ClearValues( 1 );
destVar= variable;
}
// ...or into a new given variable
else
{
destVar= new Variable( destVarCategory, destVarName, ALox.VERBOSITY.Delim );
destVar.FormatHints= variable.FormatHints;
destVar.FormatAttrAlignment= variable.FormatAttrAlignment;
destVar.Comments._("Created at runtime through config option 'writeback' in variable \"")._( variable.Fullname )._("\".");
}
// collect verbosities
{
int loggerNoMainDom= domains .GetLoggerNo( logger );
int loggerNoIntDom= internalDomains.GetLoggerNo( logger );
if ( loggerNoMainDom >= 0 ) verbositySettingToVariable( domains , loggerNoMainDom, destVar );
if ( loggerNoIntDom >= 0 ) verbositySettingToVariable( internalDomains, loggerNoIntDom , destVar );
}
// now store using the same plug-in as original variable has
destVar.Priority= variable.Priority;
destVar.Store();
// internal logging
intMsg._()._( "Argument 'writeback' in variable " )._( variable.Fullname )
._( ":\n Verbosities for logger \"" ) ._( logger.GetName() )
._( "\" written " );
if( destVarName.IsEmpty() )
intMsg._( "(to source variable)." );
else
intMsg._( "to variable \"" ) ._( destVar.Fullname ) ._("\".") ;
logInternal( Verbosity.Info, "VAR", intMsg._( destVarName )._( "\"." ) );
// verbose logging of the value written
intMsg._()._(" Value:");
for( int i= 0; i< destVar.Size() ; i++ )
intMsg._( "\n " )._( destVar.GetString(i) );
logInternal( Verbosity.Verbose, "VAR", intMsg );
}
