/** ****************************************************************************************
* Invokes \b Find on the given domain and logs internal message when the domain was
* not known before.
*
* @param domainSystem The domain system. Either the standard or the internal one.
* @param domainPath The domain path.
* @return The resulting \ref cs::aworx::lox::core::Domain "Domain".
******************************************************************************************/
Domain findDomain( Domain domainSystem, AString domainPath )
{
AString substPath= domainSystem == domains ? tmpSubstitutionPath
: tmpSubstitutionPathInternalDomains;
int maxSubstitutions= 10;
for(;;)
{
// loop for creating domains, one by one
Domain dom= null;
for(;;)
{
bool wasCreated= false;
dom= domainSystem.Find( domainPath, DomainSensitivity, 1, ref wasCreated );
if ( wasCreated )
{
// get maximum domain path length (for nicer State output only...)
if ( maxDomainPathLength < dom.FullPath.Length() )
maxDomainPathLength= dom.FullPath.Length();
// log info on new domain
intMsg._()._('\'')._NC( dom.FullPath )._NC("' registered.");
logInternal( Verbosity.Info, "DMN", intMsg );
}
// read domain from Config
if ( !dom.ConfigurationRead )
{
dom.ConfigurationRead= true;
Variable variable= new Variable();
for ( int i= 0; i < dom.CountLoggers(); ++i )
{
Logger logger= dom.GetLogger(i);
if ( 0 != variable.Define( ALox.VERBOSITY, GetName(), logger.GetName() ).Load() )
getVerbosityFromConfig( logger, dom, variable );
}
getDomainPrefixFromConfig( dom );
}
// log inherited setting for each logger
if ( wasCreated )
{
if ( domainSystem.CountLoggers() == 0 )
logInternal( Verbosity.Verbose, "DMN", intMsg._()._NC("No loggers set, yet.") );
else
for ( int i= 0; i < domainSystem.CountLoggers(); i++ )
{
intMsg._()._(" \"")._( dom.GetLogger(i).GetName() )._NC("\":");
intMsg.InsertChars( ' ', maxLoggerNameLength + 6 - intMsg.Length() );
intMsg._NC( dom.FullPath )
._NC( " = " ); ALox.ToString( dom.GetVerbosity( i ), dom.GetPriority( i), intMsg );
logInternal( Verbosity.Verbose, "DMN", intMsg );
}
}
else
break;
}
// apply domain substitutions
if( domainSubstitutions.Count > 0 )
{
substPath.Clear();
while( maxSubstitutions-- > 0 )
{
// loop over rules
bool substituted= false;
foreach( DomainSubstitutionRule rule in domainSubstitutions )
{
switch( rule.type )
{
case DomainSubstitutionRule.Type.StartsWith:
if( substPath.IsEmpty() )
{
if ( dom.FullPath.StartsWith( rule.Search, DomainSensitivity ) )
{
substPath._( rule.Replacement )._( dom.FullPath, rule.Search.Length() );
substituted= true;
continue; //next rule
}
}
else
{
if ( substPath.StartsWith( rule.Search, DomainSensitivity ) )
{
substPath.ReplaceSubstring( rule.Replacement, 0, rule.Search.Length() );
substituted= true;
continue; //next rule
}
}
break;
case DomainSubstitutionRule.Type.EndsWith:
if( substPath.IsEmpty() )
{
if ( dom.FullPath.EndsWith( rule.Search, DomainSensitivity ) )
{
substPath._( dom.FullPath, 0, dom.FullPath.Length() - rule.Search.Length() )._( rule.Replacement );
substituted= true;
continue;
}
}
else
{
if ( substPath.EndsWith( rule.Search, DomainSensitivity ) )
{
substPath.DeleteEnd( rule.Search.Length() )._( rule.Replacement );
substituted= true;
continue;
}
}
break;
case DomainSubstitutionRule.Type.Substring:
if( substPath.IsEmpty() )
{
int idx= dom.FullPath.IndexOf( rule.Search, 0, DomainSensitivity );
if ( idx >= 0 )
{
substPath._( dom.FullPath, 0, idx )._( rule.Replacement)._( dom.FullPath, idx + rule.Search.Length() );
substituted= true;
continue; //next rule
}
}
else
{
int idx= substPath.IndexOf( rule.Search, 0, DomainSensitivity );
if ( idx >= 0 )
{
substPath.ReplaceSubstring( rule.Replacement, idx, rule.Search.Length() );
substituted= true;
continue; //next rule
}
}
break;
case DomainSubstitutionRule.Type.Exact:
{
if( substPath.IsEmpty() )
{
if ( dom.FullPath.Equals( rule.Search ) )
{
substPath._( rule.Replacement);
substituted= true;
continue; //next rule
}
}
else
{
if ( substPath.Equals( rule.Search) )
{
substPath._()._( rule.Replacement );
substituted= true;
continue; //next rule
}
}
}
break;
} // switch rule type
}//rules loop
// stop if non was found
if( !substituted )
break;
}
// too many substitutions?
if ( maxSubstitutions <= 0 && !oneTimeWarningCircularDS )
{
oneTimeWarningCircularDS= true;
intMsg._()._( "The Limit of 10 domain substitutions was reached. Circular substitution assumed!"
+ " (This error is only reported once!)" );
logInternal( Verbosity.Error, "DMN", intMsg );
}
// anything substituted?
if( substPath.Length() > 0 )
{
domainPath= substPath;
continue;
}
}
return dom;
}
}
// #############################################################################################
// Constructors
// #############################################################################################
/** ****************************************************************************************
* Constructs a new, empty Lox with the given \p name.
* The name is immutable and all \b %Lox objects registered with ALox must be unique.
* The name \c "Log" is reserved for the internal default singleton used for debug-logging.
* In addition, name \c "GLOBAL" is not allowed.
*
* If parameter \p register is \c true (the default), static method
* \ref cs::aworx::lox::ALox::Register "ALox.Register" is invoked and the object will be
* retrievable with static method
* \ref cs::aworx::lox::ALox::Get "ALox.Get". In some situations, such 'registration'
* may not be wanted.
* @param name The name of the Lox. Will be converted to upper case.
* @param doRegister If \c true, this object is registered with static class
* \ref cs::aworx::lox::ALox "ALox".
* Optional and defaults to \c true.
******************************************************************************************/
public Lox( String name, bool doRegister = true ) : base()
{
// set recursion warning of log buffer lock to 1. Warnings are logged if recursively
// acquired more than once
#if ALOX_DBG_LOG || ALOX_REL_LOG
logBufLock.RecursionWarningThreshold= 1;
scopeInfo= new ScopeInfo( name, threadDictionary );
scopeDomains= new ScopeStore<AString >( scopeInfo, false );
scopePrefixes= new ScopeStore<Object >( scopeInfo, false );
scopeLogData= new ScopeStore<Dictionary<AString, LogData>>( scopeInfo, true );
scopeLogOnce= new ScopeStore<Dictionary<AString, int[]> >( scopeInfo, true );
// create domain trees
domains = new Domain( null, new AString( "") );
internalDomains = new Domain( null, new AString( ALox.InternalDomains,
0, ALox.InternalDomains.Length - 1) );
// create internal sub-domains
bool wasCreated= false;
String[] internalDomainList= {"LGR", "DMN", "PFX", "THR", "LGD", "VAR" };
foreach ( String it in internalDomainList )
{
resDomainInternal._()._NC( it );
internalDomains.Find( resDomainInternal, Case.Sensitive, 1, ref wasCreated );
}
maxDomainPathLength= ALox.InternalDomains.Length + 3;
// register with ALox
if ( doRegister )
ALox.Register( this, ContainerOp.Insert );
// read domain substitution rules from configuration
Variable variable= new Variable( ALox.DOMAIN_SUBSTITUTION, GetName() );
if ( variable.Load() != 0 )
{
for( int ruleNo= 0; ruleNo< variable.Size(); ruleNo++ )
{
AString rule= variable.GetString( ruleNo );
int idx= rule.IndexOf( "->" );
if ( idx > 0 )
{
String domainPath= rule.ToString( 0, idx ).Trim();
String replacement= rule.ToString( idx + 2 ).Trim();
SetDomainSubstitutionRule( domainPath, replacement );
}
else
{
// using alib warning here as we can't do internal logging in the constructor
ALIB.WARNING( "Syntax error in variable \"" + variable.Fullname + "\"." );
}
}
}
#endif
}