/// <summary>
/// Parse a level name string into a Level.
/// <para>
/// The argument string may consist of either a level name
/// or an integer value.
/// </para>
/// <para>
/// For example:
/// <ul>
/// <li> "SEVERE"
/// <li> "1000"
/// </ul>
///
/// </para>
/// </summary>
/// <param name="name"> string to be parsed </param>
/// <exception cref="NullPointerException"> if the name is null </exception>
/// <exception cref="IllegalArgumentException"> if the value is not valid.
/// Valid values are integers between <CODE>Integer.MIN_VALUE</CODE>
/// and <CODE>Integer.MAX_VALUE</CODE>, and all known level names.
/// Known names are the levels defined by this class (e.g., <CODE>FINE</CODE>,
/// <CODE>FINER</CODE>, <CODE>FINEST</CODE>), or created by this class with
/// appropriate package access, or new levels defined or created
/// by subclasses.
/// </exception>
/// <returns> The parsed value. Passing an integer that corresponds to a known name
/// (e.g., 700) will return the associated name (e.g., <CODE>CONFIG</CODE>).
/// Passing an integer that does not (e.g., 1) will return a new level name
/// initialized to that value. </returns>
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public static synchronized Level parse(String name) throws IllegalArgumentException
public static Level Parse(String name)
{
lock (typeof(Level))
{
// Check that name is not null.
name.Length();
KnownLevel level;
// Look for a known Level with the given non-localized name.
level = KnownLevel.FindByName(name);
if (level != null)
{
return(level.LevelObject);
}
// Now, check if the given name is an integer. If so,
// first look for a Level with the given value and then
// if necessary create one.
try
{
int x = Convert.ToInt32(name);
level = KnownLevel.FindByValue(x);
if (level == null)
{
// add new Level
Level levelObject = new Level(name, x);
level = KnownLevel.FindByValue(x);
}
return(level.LevelObject);
}
catch (NumberFormatException)
{
// Not an integer.
// Drop through.
}
// Finally, look for a known level with the given localized name,
// in the current default locale.
// This is relatively expensive, but not excessively so.
level = KnownLevel.FindByLocalizedLevelName(name);
if (level != null)
{
return(level.LevelObject);
}
// OK, we've tried everything and failed
throw new IllegalArgumentException("Bad level \"" + name + "\"");
}
}
// Serialization magic to prevent "doppelgangers".
// This is a performance optimization.
private Object ReadResolve()
{
KnownLevel o = KnownLevel.Matches(this);
if (o != null)
{
return(o.LevelObject);
}
// Woops. Whoever sent us this object knows
// about a new log level. Add it to our list.
Level level = new Level(this.Name_Renamed, this.Value, this.ResourceBundleName_Renamed);
return(level);
}
// private constructor to specify whether this instance should be added
// to the KnownLevel list from which Level.parse method does its look up
private Level(String name, int value, String resourceBundleName, bool visible)
{
if (name == null)
{
throw new NullPointerException();
}
this.Name_Renamed = name;
this.Value = value;
this.ResourceBundleName_Renamed = resourceBundleName;
this.LocalizedLevelName_Renamed = resourceBundleName == null ? name : null;
this.CachedLocale = null;
if (visible)
{
KnownLevel.Add(this);
}
}
// Returns a mirrored Level object that matches the given name as
// specified in the Level.parse method. Returns null if not found.
//
// It returns the same Level object as the one returned by Level.parse
// method if the given name is a non-localized name or integer.
//
// If the name is a localized name, findLevel and parse method may
// return a different level value if there is a custom Level subclass
// that overrides Level.getLocalizedName() to return a different string
// than what's returned by the default implementation.
//
internal static Level FindLevel(String name)
{
if (name == null)
{
throw new NullPointerException();
}
KnownLevel level;
// Look for a known Level with the given non-localized name.
level = KnownLevel.FindByName(name);
if (level != null)
{
return(level.MirroredLevel);
}
// Now, check if the given name is an integer. If so,
// first look for a Level with the given value and then
// if necessary create one.
try
{
int x = Convert.ToInt32(name);
level = KnownLevel.FindByValue(x);
if (level == null)
{
// add new Level
Level levelObject = new Level(name, x);
level = KnownLevel.FindByValue(x);
}
return(level.MirroredLevel);
}
catch (NumberFormatException)
{
// Not an integer.
// Drop through.
}
level = KnownLevel.FindByLocalizedLevelName(name);
if (level != null)
{
return(level.MirroredLevel);
}
return(null);
}
internal static void Add(Level l)
{
lock (typeof(KnownLevel))
{
// the mirroredLevel object is always added to the list
// before the custom Level instance
KnownLevel o = new KnownLevel(l);
IList <KnownLevel> list = NameToLevels[l.Name_Renamed];
if (list == null)
{
list = new List <>();
NameToLevels[l.Name_Renamed] = list;
}
list.Add(o);
list = IntToLevels[l.Value];
if (list == null)
{
list = new List <>();
IntToLevels[l.Value] = list;
}
list.Add(o);
}
}
