Logback: the reliable, generic, fast and flexible logging framework.
Copyright (C) 1999-2015, QOS.ch. All rights reserved.
This program and the accompanying materials are dual-licensed under
either the terms of the Eclipse Public License v1.0 as published by
the Eclipse Foundation
  or (per the licensee's choosing)
under the terms of the GNU Lesser General Public License version 2.1
as published by the Free Software Foundation.
/**
 * Logback: the reliable, generic, fast and flexible logging framework.
 * Copyright (C) 1999-2015, QOS.ch. All rights reserved.
 *
 * This program and the accompanying materials are dual-licensed under
 * either the terms of the Eclipse Public License v1.0 as published by
 * the Eclipse Foundation
 *
 *   or (per the licensee's choosing)
 *
 * under the terms of the GNU Lesser General Public License version 2.1
 * as published by the Free Software Foundation.
 */
package ch.qos.logback.core;

import java.util.ArrayList;
import java.util.List;

import ch.qos.logback.core.helpers.CyclicBuffer;
import ch.qos.logback.core.spi.LogbackLock;
import ch.qos.logback.core.status.OnConsoleStatusListener;
import ch.qos.logback.core.status.Status;
import ch.qos.logback.core.status.StatusListener;
import ch.qos.logback.core.status.StatusManager;

public class BasicStatusManager implements StatusManager {

    public static final int MAX_HEADER_COUNT = 150;
    public static final int TAIL_SIZE = 150;

    int count = 0;

    // protected access was requested in http://jira.qos.ch/browse/LBCORE-36
    final protected List<Status> statusList = new ArrayList<Status>();
    final protected CyclicBuffer<Status> tailBuffer = new CyclicBuffer<Status>(TAIL_SIZE);
    final protected LogbackLock statusListLock = new LogbackLock();

    int level = Status.INFO;

    // protected access was requested in http://jira.qos.ch/browse/LBCORE-36
    final protected List<StatusListener> statusListenerList = new ArrayList<StatusListener>();
    final protected LogbackLock statusListenerListLock = new LogbackLock();

    // Note on synchronization
    // This class contains two separate locks statusListLock and
    // statusListenerListLock guarding respectively the statusList+tailBuffer and
    // statusListenerList fields. The locks are used internally
    // without cycles. They are exposed to derived classes which should be careful
    // not to create deadlock cycles.

    
Add a new status object.
Params:
newStatus – 
               the status message to add/**
     * Add a new status object.
     * 
     * @param newStatus
     *                the status message to add
     */
    public void add(Status newStatus) {
        // LBCORE-72: fire event before the count check
        fireStatusAddEvent(newStatus);

        count++;
        if (newStatus.getLevel() > level) {
            level = newStatus.getLevel();
        }

        synchronized (statusListLock) {
            if (statusList.size() < MAX_HEADER_COUNT) {
                statusList.add(newStatus);
            } else {
                tailBuffer.add(newStatus);
            }
        }

    }

    public List<Status> getCopyOfStatusList() {
        synchronized (statusListLock) {
            List<Status> tList = new ArrayList<Status>(statusList);
            tList.addAll(tailBuffer.asList());
            return tList;
        }
    }

    private void fireStatusAddEvent(Status status) {
        synchronized (statusListenerListLock) {
            for (StatusListener sl : statusListenerList) {
                sl.addStatusEvent(status);
            }
        }
    }

    public void clear() {
        synchronized (statusListLock) {
            count = 0;
            statusList.clear();
            tailBuffer.clear();
        }
    }

    public int getLevel() {
        return level;
    }

    public int getCount() {
        return count;
    }

    
This implementation does not allow duplicate installations of OnConsoleStatusListener
Params:
listener – /**
     * This implementation does not allow duplicate installations of OnConsoleStatusListener
     * @param listener
     */
    public boolean add(StatusListener listener) {
        synchronized (statusListenerListLock) {
            if (listener instanceof OnConsoleStatusListener) {
                boolean alreadyPresent = checkForPresence(statusListenerList, listener.getClass());
                if (alreadyPresent)
                    return false;
            }
            statusListenerList.add(listener);
        }
        return true;
    }

    private boolean checkForPresence(List<StatusListener> statusListenerList, Class<?> aClass) {
        for (StatusListener e : statusListenerList) {
            if (e.getClass() == aClass)
                return true;
        }
        return false;
    }

    public void remove(StatusListener listener) {
        synchronized (statusListenerListLock) {
            statusListenerList.remove(listener);
        }
    }

    public List<StatusListener> getCopyOfStatusListenerList() {
        synchronized (statusListenerListLock) {
            return new ArrayList<StatusListener>(statusListenerList);
        }
    }

}