private static void filterLogMessages(LinkedList <Ice.LogMessage> logMessages,
HashSet <Ice.LogMessageType> messageTypes,
HashSet <string> traceCategories, int messageMax)
{
Debug.Assert(logMessages.Count > 0 && messageMax != 0);
//
// Filter only if one of the 3 filters is set; messageMax < 0 means "give me all"
// that match the other filters, if any.
//
if (messageTypes.Count > 0 || traceCategories.Count > 0 || messageMax > 0)
{
int count = 0;
var p = logMessages.Last;
while (p != null)
{
bool keepIt = false;
Ice.LogMessage msg = p.Value;
if (messageTypes.Count == 0 || messageTypes.Contains(msg.type))
{
if (msg.type != Ice.LogMessageType.TraceMessage || traceCategories.Count == 0 ||
traceCategories.Contains(msg.traceCategory))
{
keepIt = true;
}
}
if (keepIt)
{
++count;
if (messageMax > 0 && count >= messageMax)
{
// Remove all older messages
p = p.Previous;
while (p != null)
{
var previous = p.Previous;
logMessages.Remove(p);
p = previous;
}
break; // while
}
else
{
p = p.Previous;
}
}
else
{
var previous = p.Previous;
logMessages.Remove(p);
p = previous;
}
}
}
// else, don't need any filtering
}
internal List <Ice.RemoteLoggerPrx> log(Ice.LogMessage logMessage)
{
lock (this)
{
List <Ice.RemoteLoggerPrx> remoteLoggers = null;
//
// Put message in _queue
//
if ((logMessage.type != Ice.LogMessageType.TraceMessage && _maxLogCount > 0) ||
(logMessage.type == Ice.LogMessageType.TraceMessage && _maxTraceCount > 0))
{
_queue.AddLast(logMessage);
if (logMessage.type != Ice.LogMessageType.TraceMessage)
{
Debug.Assert(_maxLogCount > 0);
if (_logCount == _maxLogCount)
{
//
// Need to remove the oldest log from the queue
//
Debug.Assert(_oldestLog != null);
var next = _oldestLog.Next;
_queue.Remove(_oldestLog);
_oldestLog = next;
while (_oldestLog != null && _oldestLog.Value.type == Ice.LogMessageType.TraceMessage)
{
_oldestLog = _oldestLog.Next;
}
Debug.Assert(_oldestLog != null); // remember: we just added a Log at the end
}
else
{
Debug.Assert(_logCount < _maxLogCount);
_logCount++;
if (_oldestLog == null)
{
_oldestLog = _queue.Last;
}
}
}
else
{
Debug.Assert(_maxTraceCount > 0);
if (_traceCount == _maxTraceCount)
{
//
// Need to remove the oldest trace from the queue
//
Debug.Assert(_oldestTrace != null);
var next = _oldestTrace.Next;
_queue.Remove(_oldestTrace);
_oldestTrace = next;
while (_oldestTrace != null && _oldestTrace.Value.type != Ice.LogMessageType.TraceMessage)
{
_oldestTrace = _oldestTrace.Next;
}
Debug.Assert(_oldestTrace != null); // remember: we just added a Log at the end
}
else
{
Debug.Assert(_traceCount < _maxTraceCount);
_traceCount++;
if (_oldestTrace == null)
{
_oldestTrace = _queue.Last;
}
}
}
}
//
// Queue updated, now find which remote loggers want this message
//
foreach (RemoteLoggerData p in _remoteLoggerMap.Values)
{
Filters filters = p.filters;
if (filters.messageTypes.Count == 0 || filters.messageTypes.Contains(logMessage.type))
{
if (logMessage.type != Ice.LogMessageType.TraceMessage || filters.traceCategories.Count == 0 ||
filters.traceCategories.Contains(logMessage.traceCategory))
{
if (remoteLoggers == null)
{
remoteLoggers = new List <Ice.RemoteLoggerPrx>();
}
remoteLoggers.Add(p.remoteLogger);
}
}
}
return(remoteLoggers);
}
}
