/** **************************************************************************************** * 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 }