/*
* Constructs a {@code LogRecord} object using the supplied the logging
* level and message. The millis property is set to the current time. The
* sequence property is set to a new unique value, allocated in increasing
* order within the virtual machine. The thread ID is set to a unique value
* for the current thread. All other properties are set to {@code null}.
*
* @param level
* the logging level, may not be {@code null}.
* @param msg
* the raw message.
* @throws NullPointerException
* if {@code level} is {@code null}.
*/
public LogRecord(Level level, String msg)
{
if (null == level)
{
// logging.4=The 'level' parameter is null.
throw new java.lang.NullPointerException("The 'level' parameter is null."); //$NON-NLS-1$
}
this.level = level;
this.message = msg;
this.millis = java.lang.SystemJ.currentTimeMillis();
lock (typeof(LogRecord).getClass()) {
this.sequenceNumber = currentSequenceNumber++;
java.lang.Integer id = currentThreadId.get();
if (null == id)
{
this.threadID = initThreadId;
currentThreadId.set(java.lang.Integer.valueOf(initThreadId++));
}
else
{
this.threadID = id.intValue();
}
}
this.sourceClassName = null;
this.sourceMethodName = null;
this.loggerName = null;
this.parameters = null;
this.resourceBundle = null;
this.resourceBundleName = null;
this.thrown = null;
}
// init properties
private void init(String p, java.lang.Boolean a, java.lang.Integer l, java.lang.Integer c)
{ //throws IOException {
// check access
manager = LogManager.getLogManager();
manager.checkAccess();
initProperties(p, a, l, c);
initOutputFiles();
}
/**
* Returns the number of occurrence of the given element in this bag
* by looking up its count in the underlying map.
*
* @param object the object to search for
* @return the number of occurrences of the object, zero if not found
*/
public virtual int getCount(Object obj)
{
int result = 0;
java.lang.Integer count = MapUtils.getInteger(_map, obj);
if (count != null)
{
result = count.intValue();
}
return(result);
}
/**
* Adds a new item, which compares as equal to the given existing item.
*
* @param existingObj an item already in the Comparator's set of
* known objects
* @param newObj an item to be added to the Comparator's set of
* known objects
* @return true if newObj has been added for the first time, false if
* it was already known to the Comparator.
* @throws IllegalArgumentException if existingObject is not in the
* Comparator's set of known objects.
* @throws UnsupportedOperationException if a comparison has already been made
*/
public bool addAsEqual(Object existingObj, Object newObj)
{
checkLocked();
java.lang.Integer position = (java.lang.Integer)map.get(existingObj);
if (position == null)
{
throw new java.lang.IllegalArgumentException(existingObj + " not known to " + this);
}
Object result = map.put(newObj, position);
return(result == null);
}
/**
* Increment the active count for the given key. Also
* increments the total active count.
*
* @param key pool key
*/
private void incrementActiveCount(K key)
{
_totActive++;
java.lang.Integer old = _activeCount.get(key);
if (null == old)
{
_activeCount.put(key, new java.lang.Integer(1));
}
else
{
_activeCount.put(key, new java.lang.Integer(old.intValue() + 1));
}
}
/**
* Decrements the active count for the given key.
* Also decrements the total active count.
*
* @param key pool key
*/
private void decrementActiveCount(K key)
{
_totActive--;
java.lang.Integer active = _activeCount.get(key);
if (null == active)
{
// do nothing, either null or zero is OK
}
else if (active.intValue() <= 1)
{
_activeCount.remove(key);
}
else
{
_activeCount.put(key, new java.lang.Integer(active.intValue() - 1));
}
}
// Comparator methods
//-----------------------------------------------------------------------
/**
* Compares two objects according to the order of this Comparator.
* <p>
* It is important to note that this class will throw an IllegalArgumentException
* in the case of an unrecognised object. This is not specified in the
* Comparator interface, but is the most appropriate exception.
*
* @param obj1 the first object to compare
* @param obj2 the second object to compare
* @return negative if obj1 is less, positive if greater, zero if equal
* @throws IllegalArgumentException if obj1 or obj2 are not known
* to this Comparator and an alternative behavior has not been set
* via {@link #setUnknownObjectBehavior(int)}.
*/
public int compare(Object obj1, Object obj2)
{
isLockedJ = true;
java.lang.Integer position1 = (java.lang.Integer)map.get(obj1);
java.lang.Integer position2 = (java.lang.Integer)map.get(obj2);
if (position1 == null || position2 == null)
{
switch (unknownObjectBehavior)
{
case UNKNOWN_BEFORE:
if (position1 == null)
{
return((position2 == null) ? 0 : -1);
}
else
{
return(1);
}
case UNKNOWN_AFTER:
if (position1 == null)
{
return((position2 == null) ? 0 : 1);
}
else
{
return(-1);
}
case UNKNOWN_THROW_EXCEPTION:
Object unknownObj = (position1 == null) ? obj1 : obj2;
throw new java.lang.IllegalArgumentException("Attempting to compare unknown object " + unknownObj);
default:
throw new java.lang.UnsupportedOperationException("Unknown unknownObjectBehavior: " + unknownObjectBehavior);
}
}
else
{
return(position1.compareTo(position2));
}
}
private void initProperties(String p, java.lang.Boolean a, java.lang.Integer l, java.lang.Integer c)
{
base.initProperties("ALL", null, "java.util.logging.XMLFormatter",
null);
String className = this.getClass().getName();
pattern = (null == p) ? getStringProperty(className + ".pattern",
DEFAULT_PATTERN) : p;
if (null == pattern || "".equals(pattern))
{
// logging.19=Pattern cannot be empty
throw new java.lang.NullPointerException("Pattern cannot be empty");
}
append = (null == a) ? getBooleanProperty(className + ".append",
DEFAULT_APPEND) : a.booleanValue();
count = (null == c) ? getIntProperty(className + ".count",
DEFAULT_COUNT) : c.intValue();
limit = (null == l) ? getIntProperty(className + ".limit",
DEFAULT_LIMIT) : l.intValue();
count = count < 1 ? DEFAULT_COUNT : count;
limit = limit < 0 ? DEFAULT_LIMIT : limit;
files = new java.io.File[count];
}
