bool Load( Variable variable, bool searchOnly= false )
{
if ( args == null )
return false;
int optionLength= variable.Fullname.Length();
Substring actVar= new Substring();
for ( int i= 0; i < args.Length ; i++ )
{
// remove whitespaces (if somebody would work with quotation marks...)
// and request '-' and allow a second '-'
if ( !actVar.Set( args[i] ).Trim().Consume('-') )
continue;
actVar.Consume( '-' );
if ( variable.Fullname.CompareTo( args[i], Case.Ignore, actVar.Start, optionLength, 0, optionLength ) == 0)
{
//again, lets trim before searching the = sign (really almost unnecessary)
actVar.Start+= optionLength;
if ( actVar.IsEmpty() )
{
if ( !searchOnly )
variable.AddString();
return true;
}
if ( actVar.Consume( '=', Case.Sensitive, Whitespaces.Trim ) )
{
if ( !searchOnly )
{
actVar.Trim();
StringConverter.LoadFromString( variable, actVar );
}
return true;
}
}
}
return false;
}
public void Consume()
{
// null substring
{
Substring s= new Substring();
Substring r= new Substring("oldval");
UT_EQ( '\0', s.Consume ( ) );
UT_EQ( 0, s.Consume ( 0 , r) ); UT_TRUE(r.IsNull());
UT_EQ( 0, s.Consume ( 5 , r) ); UT_TRUE(r.IsNull());
UT_EQ( false, s.Consume ( 'a' ) );
UT_EQ( false, s.Consume ( "word" ) );
UT_EQ( '\0', s.ConsumeFromEnd( ) );
UT_EQ( 0, s.ConsumeFromEnd( 0 ) );
UT_EQ( 0, s.ConsumeFromEnd( 5 ) );
UT_EQ( false, s.ConsumeFromEnd( 'a' ) );
UT_EQ( false, s.ConsumeFromEnd( "word" ) );
}
// empty substring
{
Substring s= new Substring("aaaaaaaaaaaa");
Substring r= new Substring("oldval");
s.Start= 5;
s.End= 4;
UT_EQ( '\0', s.Consume ( ) );
UT_EQ( 0, s.Consume ( 0 ,r ) ); UT_TRUE( r.IsNotNull()); UT_TRUE(r.IsEmpty());
UT_EQ( 0, s.Consume ( 5 ,r ) ); UT_TRUE( r.IsNotNull()); UT_TRUE(r.IsEmpty());
UT_EQ( false, s.Consume ( 'a' ) );
UT_EQ( false, s.Consume ( "word" ) );
UT_EQ( '\0', s.ConsumeFromEnd( ) );
UT_EQ( 0, s.ConsumeFromEnd( 0 ) );
UT_EQ( 0, s.ConsumeFromEnd( 5 ) );
UT_EQ( false, s.ConsumeFromEnd( 'a' ) );
UT_EQ( false, s.ConsumeFromEnd( "word" ) );
}
// substring of length 1
{
Substring s= new Substring("aaaaaaaaaaaa");
Substring r= new Substring("oldval");
s.Start= s.End= 5; UT_EQ( 'a', s.Consume ( ) ); UT_EQ( 0, s.Length() );
s.Start= s.End= 5; UT_EQ( 1, s.Consume ( 0 ) ); UT_EQ( 1, s.Length() );
s.Start= s.End= 5; UT_EQ( 0, s.Consume ( 1 , r ) ); UT_EQ( 0, s.Length() ); UT_TRUE(r.Equals("a"));
s.Start= s.End= 5; UT_EQ( 0, s.Consume ( 5 , r ) ); UT_EQ( 0, s.Length() ); UT_TRUE(r.Equals("a"));
s.Start= s.End= 5; UT_EQ( true, s.Consume ( 'a' ) ); UT_EQ( 0, s.Length() );
s.Start= s.End= 5; UT_EQ( false, s.Consume ( 'b' ) ); UT_EQ( 1, s.Length() );
s.Start= s.End= 5; UT_EQ( false, s.Consume ( "word" ) ); UT_EQ( 1, s.Length() );
s.Start= s.End= 5; UT_EQ( 'a', s.ConsumeFromEnd( ) ); UT_EQ( 0, s.Length() );
s.Start= s.End= 5; UT_EQ( 1, s.ConsumeFromEnd( 0 ) ); UT_EQ( 1, s.Length() );
s.Start= s.End= 5; UT_EQ( 0, s.ConsumeFromEnd( 1 ) ); UT_EQ( 0, s.Length() );
s.Start= s.End= 5; UT_EQ( 0, s.ConsumeFromEnd( 5 ) ); UT_EQ( 0, s.Length() );
s.Start= s.End= 5; UT_EQ( true, s.ConsumeFromEnd( 'a' ) ); UT_EQ( 0, s.Length() );
s.Start= s.End= 5; UT_EQ( false, s.ConsumeFromEnd( 'b' ) ); UT_EQ( 1, s.Length() );
s.Start= s.End= 5; UT_EQ( false, s.ConsumeFromEnd( "word" ) ); UT_EQ( 1, s.Length() );
}
// substring of length 2
{
Substring s= new Substring("12ab3456");
Substring r= new Substring("oldval");
s.Start= 2; s.End= 3; UT_EQ( 'a', s.Consume ( ) ); UT_EQ( 1, s.Length() );
UT_EQ( 'b', s.Consume ( ) ); UT_EQ( 0, s.Length() );
s.Start= 2; s.End= 3; UT_EQ( 'b', s.ConsumeFromEnd( ) ); UT_EQ( 1, s.Length() );
UT_EQ( 'a', s.ConsumeFromEnd( ) ); UT_EQ( 0, s.Length() );
s.Start= 2; s.End= 3; UT_EQ( 2, s.Consume ( 0 , r ) ); UT_EQ( 2, s.Length() ); UT_TRUE(r.IsNotNull()); UT_TRUE(r.IsEmpty());
s.Start= 2; s.End= 3; UT_EQ( 1, s.Consume ( 1 , r ) ); UT_EQ( 1, s.Length() ); UT_TRUE(r.Equals("a"));
s.Start= 2; s.End= 3; UT_EQ( 0, s.Consume ( 2 , r ) ); UT_EQ( 0, s.Length() ); UT_TRUE(r.Equals("ab"));
s.Start= 2; s.End= 3; UT_EQ( 0, s.Consume ( 3 , r ) ); UT_EQ( 0, s.Length() ); UT_TRUE(r.Equals("ab"));
s.Start= 2; s.End= 3; UT_EQ( 2, s.ConsumeFromEnd( 0 , r ) ); UT_EQ( 2, s.Length() ); UT_TRUE(r.IsNotNull()); UT_TRUE(r.IsEmpty());
s.Start= 2; s.End= 3; UT_EQ( 1, s.ConsumeFromEnd( 1 , r ) ); UT_EQ( 1, s.Length() ); UT_TRUE(r.Equals("b"));
s.Start= 2; s.End= 3; UT_EQ( 0, s.ConsumeFromEnd( 2 , r ) ); UT_EQ( 0, s.Length() ); UT_TRUE(r.Equals("ab"));
s.Start= 2; s.End= 3; UT_EQ( 0, s.ConsumeFromEnd( 3 , r ) ); UT_EQ( 0, s.Length() ); UT_TRUE(r.Equals("ab"));
s.Start= 2; s.End= 3; UT_EQ( false, s.Consume ( 'b' ) ); UT_EQ( 2, s.Length() );
UT_EQ( true, s.Consume ( 'a' ) ); UT_EQ( 1, s.Length() );
UT_EQ( true, s.Consume ( 'b' ) ); UT_EQ( 0, s.Length() );
UT_EQ( false, s.Consume ( 'a' ) ); UT_EQ( 0, s.Length() );
UT_EQ( false, s.Consume ( 'b' ) ); UT_EQ( 0, s.Length() );
s.Start= 2; s.End= 3; UT_EQ( false, s.ConsumeFromEnd( 'a' ) ); UT_EQ( 2, s.Length() );
UT_EQ( true, s.ConsumeFromEnd( 'b' ) ); UT_EQ( 1, s.Length() );
UT_EQ( true, s.ConsumeFromEnd( 'a' ) ); UT_EQ( 0, s.Length() );
UT_EQ( false, s.ConsumeFromEnd( 'b' ) ); UT_EQ( 0, s.Length() );
UT_EQ( false, s.ConsumeFromEnd( 'a' ) ); UT_EQ( 0, s.Length() );
s.Start= 2; s.End= 3; UT_EQ( false, s.Consume ( "word" ) ); UT_EQ( 2, s.Length() );
s.Start= 2; s.End= 3; UT_EQ( false, s.Consume ( "AB" ) ); UT_EQ( 2, s.Length() );
s.Start= 2; s.End= 3; UT_EQ( true, s.Consume ( "ab" ) ); UT_EQ( 0, s.Length() );
s.Start= 2; s.End= 3; UT_EQ( false, s.ConsumeFromEnd( "word" ) ); UT_EQ( 2, s.Length() );
s.Start= 2; s.End= 3; UT_EQ( false, s.ConsumeFromEnd( "AB" ) ); UT_EQ( 2, s.Length() );
s.Start= 2; s.End= 3; UT_EQ( true, s.ConsumeFromEnd( "ab" ) ); UT_EQ( 0, s.Length() );
}
// 3 words
{
Substring s= new Substring("word1 word2 word3");
UT_EQ( 'w', s.Consume ( ) );
UT_EQ( 'o', s.Consume ( ) );
UT_EQ( 'r', s.Consume ( ) );
UT_EQ( 'd', s.Consume ( ) );
UT_EQ( '1', s.Consume ( ) );
UT_EQ( false , s.Consume ('w' ) );
UT_EQ( true , s.Consume ('w' , Case.Sensitive, Whitespaces.Trim ) );
UT_EQ( true , s.Consume ('o' , Case.Sensitive, Whitespaces.Trim ) );
UT_EQ( false , s.Consume ('o' , Case.Sensitive, Whitespaces.Trim ) );
UT_EQ( true , s.Consume ('r' , Case.Sensitive, Whitespaces.Trim ) );
UT_EQ( false , s.Consume ("D2" , Case.Sensitive, Whitespaces.Trim ) );
UT_EQ( false , s.Consume ("D2" ) );
UT_EQ( true , s.Consume ("d2" ) );
UT_EQ( 2 , s.Consume ( 4 ) );
UT_EQ( "d3" , s.ToString() );
s= new Substring("word1 word2 word3");
UT_EQ( '3', s.ConsumeFromEnd( ) );
UT_EQ( 'd', s.ConsumeFromEnd( ) );
UT_EQ( 'r', s.ConsumeFromEnd( ) );
UT_EQ( 'o', s.ConsumeFromEnd( ) );
UT_EQ( 'w', s.ConsumeFromEnd( ) );
UT_EQ( false , s.ConsumeFromEnd('2' ) );
UT_EQ( true , s.ConsumeFromEnd('2' , Case.Sensitive, Whitespaces.Trim ) );
UT_EQ( true , s.ConsumeFromEnd('d' , Case.Sensitive, Whitespaces.Trim ) );
UT_EQ( false , s.ConsumeFromEnd('d' , Case.Sensitive, Whitespaces.Trim ) );
UT_EQ( true , s.ConsumeFromEnd('r' , Case.Sensitive, Whitespaces.Trim ) );
UT_EQ( false , s.ConsumeFromEnd("WO" , Case.Sensitive, Whitespaces.Trim ) );
UT_EQ( false , s.ConsumeFromEnd("WO" ) );
UT_EQ( true , s.ConsumeFromEnd("wo" ) );
UT_EQ( 2 , s.ConsumeFromEnd( 4 ) );
UT_EQ( "wo" , s.ToString() );
}
// consume AString, Substring
{
Substring s= new Substring("word1 word2 word3 word4");
Substring sConsume= new Substring( "1234word12", 4, 4 );
AString aConsume= new AString ( "word" );
UT_EQ( true, s.Consume ( sConsume ) );
UT_EQ( false, s.Consume ( sConsume ) );
UT_EQ( '1', s.Consume ( ) );
UT_EQ( false, s.Consume ( sConsume ) );
UT_EQ( true, s.Consume ( sConsume, Case.Sensitive, Whitespaces.Trim ) );
UT_EQ( '2', s.Consume ( ) );
UT_EQ( ' ', s.Consume ( ) );
UT_EQ( true, s.Consume ( aConsume ) );
UT_EQ( false, s.Consume ( aConsume ) );
UT_EQ( '3', s.Consume ( ) );
UT_EQ( false, s.Consume ( aConsume ) );
UT_EQ( true, s.Consume ( aConsume, Case.Sensitive, Whitespaces.Trim ) );
s.Set("1word 2word 3word 4word");
UT_EQ( true, s.ConsumeFromEnd( sConsume ) );
UT_EQ( false, s.ConsumeFromEnd( sConsume ) );
UT_EQ( '4', s.ConsumeFromEnd( ) );
UT_EQ( false, s.ConsumeFromEnd( sConsume ) );
UT_EQ( true, s.ConsumeFromEnd( sConsume, Case.Sensitive, Whitespaces.Trim ) );
UT_EQ( '3', s.ConsumeFromEnd( ) );
UT_EQ( ' ', s.ConsumeFromEnd( ) );
UT_EQ( true, s.ConsumeFromEnd( aConsume ) );
UT_EQ( false, s.ConsumeFromEnd( aConsume ) );
UT_EQ( '2', s.ConsumeFromEnd( ) );
UT_EQ( false, s.ConsumeFromEnd( aConsume ) );
UT_EQ( true, s.ConsumeFromEnd( aConsume, Case.Sensitive, Whitespaces.Trim ) );
}
}
/** ****************************************************************************************
* 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 );
}
/** ****************************************************************************************
* Implements functionality for configuration variable \c LOXNAME_DUMP_STATE_ON_EXIT.
* Is called when a logger is removed.
******************************************************************************************/
protected void dumpStateOnLoggerRemoval()
{
if( !loggerAddedSinceLastDebugState )
return;
loggerAddedSinceLastDebugState= false;
Variable variable= new Variable( ALox.DUMP_STATE_ON_EXIT, GetName() );
variable.Load();
String domain= null;
Verbosity verbosity= Verbosity.Info;
Substring tok= new Substring();
int flags= 0;
for( int tokNo= 0; tokNo< variable.Size(); tokNo++ )
{
tok.Set( variable.GetString( tokNo ) );
if( tok.IsEmpty() )
continue;
// state flags
if( tok.Equals( "NONE" , Case.Ignore ) ) { flags= 0; break; }
else if( tok.Equals( "Basic" , Case.Ignore ) ) flags|= (int) Lox.StateInfo.Basic ;
else if( tok.Equals( "Version" , Case.Ignore ) ) flags|= (int) Lox.StateInfo.Version ;
else if( tok.Equals( "Loggers" , Case.Ignore ) ) flags|= (int) Lox.StateInfo.Loggers ;
else if( tok.Equals( "Domains" , Case.Ignore ) ) flags|= (int) Lox.StateInfo.Domains ;
else if( tok.Equals( "InternalDomains" , Case.Ignore ) ) flags|= (int) Lox.StateInfo.InternalDomains ;
else if( tok.Equals( "ScopeDomains" , Case.Ignore ) ) flags|= (int) Lox.StateInfo.ScopeDomains ;
else if( tok.Equals( "DSR" , Case.Ignore ) ) flags|= (int) Lox.StateInfo.DSR ;
else if( tok.Equals( "PrefixLogables" , Case.Ignore ) ) flags|= (int) Lox.StateInfo.PrefixLogables ;
else if( tok.Equals( "Once" , Case.Ignore ) ) flags|= (int) Lox.StateInfo.Once ;
else if( tok.Equals( "LogData" , Case.Ignore ) ) flags|= (int) Lox.StateInfo.LogData ;
else if( tok.Equals( "ThreadMappings" , Case.Ignore ) ) flags|= (int) Lox.StateInfo.ThreadMappings ;
else if( tok.Equals( "SPTR" , Case.Ignore ) ) flags|= (int) Lox.StateInfo.SPTR ;
else if( tok.Equals( "All" , Case.Ignore ) ) flags|= (int) Lox.StateInfo.All ;
// domain and verbosity
else if( tok.Consume( "domain", Case.Ignore, Whitespaces.Trim ) )
{
if( tok.Consume( '=', Case.Sensitive, Whitespaces.Trim ) )
domain= tok.Trim().ToString();
}
else if( tok.Consume( "verbosity", Case.Ignore, Whitespaces.Trim ) )
{
if( tok.Consume( '=', Case.Sensitive, Whitespaces.Trim ) )
verbosity= ALox.ReadVerbosity( tok.Trim() );
}
// unknown argument
else
{
logInternal( Verbosity.Error, "VAR", intMsg._()
._( "Unknown argument '" )._(tok)
._( "' in variable " )._(variable.Fullname)._( " = \"")._(variable.GetString())._('\"') );
}
}
if ( flags != 0 )
{
State( domain, verbosity, "Auto dump state on exit requested: ", (Lox.StateInfo) flags );
}
}
/** ****************************************************************************************
* Reads a prefix string from the ALib configuration system.
* This internal method is used when a new domain is created,
*
* @param dom The domain to set the verbosity for.
******************************************************************************************/
protected void getDomainPrefixFromConfig( Domain dom )
{
Variable variable= new Variable( ALox.PREFIXES, GetName() );
if( 0 == variable.Load() )
return;
Tokenizer prefixTok= new Tokenizer();
Tokenizer prefixTokInner= new Tokenizer();
Substring domainStr= new Substring();
AString domainStrBuf= new AString();
Substring prefixStr= new Substring();
for( int varNo= 0; varNo< variable.Size(); varNo++ )
{
prefixTok.Set( variable.GetString( varNo ), '=' );
domainStr.Set( prefixTok.Next() );
if ( domainStr.StartsWith( "INTERNAL_DOMAINS", DomainSensitivity ) )
{
domainStrBuf._()._( domainStr.Buf, domainStr.Start + 16, domainStr.Length() -16 );
while ( domainStrBuf.CharAtStart() == '/' )
domainStrBuf.DeleteStart( 1 );
domainStrBuf.InsertAt( ALox.InternalDomains, 0 );
domainStr.Set( domainStrBuf );
}
prefixTokInner.Set( prefixTok.Next(), ',' );
prefixStr.Set( prefixTokInner.Next() );
if ( prefixStr.IsEmpty() )
continue;
if ( prefixStr.Consume( '\"' ) )
prefixStr.ConsumeFromEnd( '\"' );
Inclusion otherPLs= Inclusion.Include;
prefixTokInner.Next();
if ( prefixTokInner.Actual.IsNotEmpty() )
otherPLs= ALIB.ReadInclusion( prefixTokInner.Actual );
int searchMode= 0;
if ( domainStr.Consume ( '*' ) ) searchMode+= 2;
if ( domainStr.ConsumeFromEnd( '*' ) ) searchMode+= 1;
if( ( searchMode == 0 && dom.FullPath.Equals ( domainStr, DomainSensitivity ) )
|| ( searchMode == 1 && dom.FullPath.StartsWith ( domainStr, DomainSensitivity ) )
|| ( searchMode == 2 && dom.FullPath.EndsWith ( domainStr, DomainSensitivity ) )
|| ( searchMode == 3 && dom.FullPath.IndexOf ( domainStr, 0, DomainSensitivity ) >=0 )
)
{
dom.PrefixLogables.Add( new Domain.PL( new AString( prefixStr ), otherPLs ) );
// log info on this
intMsg._()._NC( "String \"" )._NC( prefixStr )._NC ( "\" added as prefix logable for domain \'" )
._NC( dom.FullPath )
._NC( "\'. (Retrieved from variable" )
._NC( variable.Fullname )._( ".)" );
logInternal( Verbosity.Info, "PFX", intMsg );
}
}
}
