com.sun.jmx.examples.scandir.config.ResultLogConfig Java Examples

void setConfig(ResultLogConfig logConfigBean) throws IOException {
    if (logConfigBean == null)
        throw new IllegalArgumentException("logConfigBean is null");
    synchronized (this) {
        config = logConfigBean;
        setMemoryLogCapacity(config.getMemoryMaxRecords());
    }
    final String filename = config.getLogFileName();
    final String logname  = getLogFileName(false);
    if ((filename != null && !filename.equals(logname))
    || (filename == null && logname != null)) {
        newLogFile(config.getLogFileName(),
                config.getLogFileMaxRecords());
    } else {
        setLogFileCapacity(config.getLogFileMaxRecords());
    }
}
 

void setConfig(ResultLogConfig logConfigBean) throws IOException {
    if (logConfigBean == null)
        throw new IllegalArgumentException("logConfigBean is null");
    synchronized (this) {
        config = logConfigBean;
        setMemoryLogCapacity(config.getMemoryMaxRecords());
    }
    final String filename = config.getLogFileName();
    final String logname  = getLogFileName(false);
    if ((filename != null && !filename.equals(logname))
    || (filename == null && logname != null)) {
        newLogFile(config.getLogFileName(),
                config.getLogFileMaxRecords());
    } else {
        setLogFileCapacity(config.getLogFileMaxRecords());
    }
}
 

void setConfig(ResultLogConfig logConfigBean) throws IOException {
    if (logConfigBean == null)
        throw new IllegalArgumentException("logConfigBean is null");
    synchronized (this) {
        config = logConfigBean;
        setMemoryLogCapacity(config.getMemoryMaxRecords());
    }
    final String filename = config.getLogFileName();
    final String logname  = getLogFileName(false);
    if ((filename != null && !filename.equals(logname))
    || (filename == null && logname != null)) {
        newLogFile(config.getLogFileName(),
                config.getLogFileMaxRecords());
    } else {
        setLogFileCapacity(config.getLogFileMaxRecords());
    }
}
 

void setConfig(ResultLogConfig logConfigBean) throws IOException {
    if (logConfigBean == null)
        throw new IllegalArgumentException("logConfigBean is null");
    synchronized (this) {
        config = logConfigBean;
        setMemoryLogCapacity(config.getMemoryMaxRecords());
    }
    final String filename = config.getLogFileName();
    final String logname  = getLogFileName(false);
    if ((filename != null && !filename.equals(logname))
    || (filename == null && logname != null)) {
        newLogFile(config.getLogFileName(),
                config.getLogFileMaxRecords());
    } else {
        setLogFileCapacity(config.getLogFileMaxRecords());
    }
}
 

void setConfig(ResultLogConfig logConfigBean) throws IOException {
    if (logConfigBean == null)
        throw new IllegalArgumentException("logConfigBean is null");
    synchronized (this) {
        config = logConfigBean;
        setMemoryLogCapacity(config.getMemoryMaxRecords());
    }
    final String filename = config.getLogFileName();
    final String logname  = getLogFileName(false);
    if ((filename != null && !filename.equals(logname))
    || (filename == null && logname != null)) {
        newLogFile(config.getLogFileName(),
                config.getLogFileMaxRecords());
    } else {
        setLogFileCapacity(config.getLogFileMaxRecords());
    }
}
 

void setConfig(ResultLogConfig logConfigBean) throws IOException {
    if (logConfigBean == null)
        throw new IllegalArgumentException("logConfigBean is null");
    synchronized (this) {
        config = logConfigBean;
        setMemoryLogCapacity(config.getMemoryMaxRecords());
    }
    final String filename = config.getLogFileName();
    final String logname  = getLogFileName(false);
    if ((filename != null && !filename.equals(logname))
    || (filename == null && logname != null)) {
        newLogFile(config.getLogFileName(),
                config.getLogFileMaxRecords());
    } else {
        setLogFileCapacity(config.getLogFileMaxRecords());
    }
}
 

void setConfig(ResultLogConfig logConfigBean) throws IOException {
    if (logConfigBean == null)
        throw new IllegalArgumentException("logConfigBean is null");
    synchronized (this) {
        config = logConfigBean;
        setMemoryLogCapacity(config.getMemoryMaxRecords());
    }
    final String filename = config.getLogFileName();
    final String logname  = getLogFileName(false);
    if ((filename != null && !filename.equals(logname))
    || (filename == null && logname != null)) {
        newLogFile(config.getLogFileName(),
                config.getLogFileMaxRecords());
    } else {
        setLogFileCapacity(config.getLogFileMaxRecords());
    }
}
 

void setConfig(ResultLogConfig logConfigBean) throws IOException {
    if (logConfigBean == null)
        throw new IllegalArgumentException("logConfigBean is null");
    synchronized (this) {
        config = logConfigBean;
        setMemoryLogCapacity(config.getMemoryMaxRecords());
    }
    final String filename = config.getLogFileName();
    final String logname  = getLogFileName(false);
    if ((filename != null && !filename.equals(logname))
    || (filename == null && logname != null)) {
        newLogFile(config.getLogFileName(),
                config.getLogFileMaxRecords());
    } else {
        setLogFileCapacity(config.getLogFileMaxRecords());
    }
}
 

void setConfig(ResultLogConfig logConfigBean) throws IOException {
    if (logConfigBean == null)
        throw new IllegalArgumentException("logConfigBean is null");
    synchronized (this) {
        config = logConfigBean;
        setMemoryLogCapacity(config.getMemoryMaxRecords());
    }
    final String filename = config.getLogFileName();
    final String logname  = getLogFileName(false);
    if ((filename != null && !filename.equals(logname))
    || (filename == null && logname != null)) {
        newLogFile(config.getLogFileName(),
                config.getLogFileMaxRecords());
    } else {
        setLogFileCapacity(config.getLogFileMaxRecords());
    }
}
 

void setConfig(ResultLogConfig logConfigBean) throws IOException {
    if (logConfigBean == null)
        throw new IllegalArgumentException("logConfigBean is null");
    synchronized (this) {
        config = logConfigBean;
        setMemoryLogCapacity(config.getMemoryMaxRecords());
    }
    final String filename = config.getLogFileName();
    final String logname  = getLogFileName(false);
    if ((filename != null && !filename.equals(logname))
    || (filename == null && logname != null)) {
        newLogFile(config.getLogFileName(),
                config.getLogFileMaxRecords());
    } else {
        setLogFileCapacity(config.getLogFileMaxRecords());
    }
}
 

void setConfig(ResultLogConfig logConfigBean) throws IOException {
    if (logConfigBean == null)
        throw new IllegalArgumentException("logConfigBean is null");
    synchronized (this) {
        config = logConfigBean;
        setMemoryLogCapacity(config.getMemoryMaxRecords());
    }
    final String filename = config.getLogFileName();
    final String logname  = getLogFileName(false);
    if ((filename != null && !filename.equals(logname))
    || (filename == null && logname != null)) {
        newLogFile(config.getLogFileName(),
                config.getLogFileMaxRecords());
    } else {
        setLogFileCapacity(config.getLogFileMaxRecords());
    }
}
 

void setConfig(ResultLogConfig logConfigBean) throws IOException {
    if (logConfigBean == null)
        throw new IllegalArgumentException("logConfigBean is null");
    synchronized (this) {
        config = logConfigBean;
        setMemoryLogCapacity(config.getMemoryMaxRecords());
    }
    final String filename = config.getLogFileName();
    final String logname  = getLogFileName(false);
    if ((filename != null && !filename.equals(logname))
    || (filename == null && logname != null)) {
        newLogFile(config.getLogFileName(),
                config.getLogFileMaxRecords());
    } else {
        setLogFileCapacity(config.getLogFileMaxRecords());
    }
}
 

/**
 * Create a new ResultLogManagerMXBean. This constructor is package
 * protected: only the {@link ScanManager} can create a
 * <code>ResultLogManager</code>.
 **/
ResultLogManager() {
    // Instantiate the memory log - override the add() method so that
    // it removes the head of the list when the maximum capacity is
    // reached. Note that add() is the only method we will be calling,
    // otherwise we would have to override all the other flavors
    // of adding methods. Note also that this implies that the memoryLog
    // will *always* remain encapsulated in this object and is *never*
    // handed over (otherwise we wouldn't be able to ensure that
    // add() is the only method ever called to add a record).
    //
    memoryLog =
            Collections.synchronizedList(new LinkedList<ResultRecord>() {
        public synchronized boolean add(ResultRecord e) {
            final int max = getMemoryLogCapacity();
            while (max > 0 && size() >= max) {
                memCapacityReached = true;
                removeFirst();
            }
            return super.add(e);
        }
    });

    // default memory capacity
    memCapacity = 2048;

    // default file capacity: 0 means infinite ;-)
    fileCapacity = 0;

    // by default logging to file is disabled.
    logFile = null;

    // Until the ScanManager apply a new configuration, we're going to
    // work with a default ResultLogConfig object.
    config = new ResultLogConfig();
    config.setMemoryMaxRecords(memCapacity);
    config.setLogFileName(getLogFileName(false));
    config.setLogFileMaxRecords(fileCapacity);
}
 

/**
 * Create a new ResultLogManagerMXBean. This constructor is package
 * protected: only the {@link ScanManager} can create a
 * <code>ResultLogManager</code>.
 **/
ResultLogManager() {
    // Instantiate the memory log - override the add() method so that
    // it removes the head of the list when the maximum capacity is
    // reached. Note that add() is the only method we will be calling,
    // otherwise we would have to override all the other flavors
    // of adding methods. Note also that this implies that the memoryLog
    // will *always* remain encapsulated in this object and is *never*
    // handed over (otherwise we wouldn't be able to ensure that
    // add() is the only method ever called to add a record).
    //
    memoryLog =
            Collections.synchronizedList(new LinkedList<ResultRecord>() {
        public synchronized boolean add(ResultRecord e) {
            final int max = getMemoryLogCapacity();
            while (max > 0 && size() >= max) {
                memCapacityReached = true;
                removeFirst();
            }
            return super.add(e);
        }
    });

    // default memory capacity
    memCapacity = 2048;

    // default file capacity: 0 means infinite ;-)
    fileCapacity = 0;

    // by default logging to file is disabled.
    logFile = null;

    // Until the ScanManager apply a new configuration, we're going to
    // work with a default ResultLogConfig object.
    config = new ResultLogConfig();
    config.setMemoryMaxRecords(memCapacity);
    config.setLogFileName(getLogFileName(false));
    config.setLogFileMaxRecords(fileCapacity);
}
 

/**
 * Create a new ResultLogManagerMXBean. This constructor is package
 * protected: only the {@link ScanManager} can create a
 * <code>ResultLogManager</code>.
 **/
ResultLogManager() {
    // Instantiate the memory log - override the add() method so that
    // it removes the head of the list when the maximum capacity is
    // reached. Note that add() is the only method we will be calling,
    // otherwise we would have to override all the other flavors
    // of adding methods. Note also that this implies that the memoryLog
    // will *always* remain encapsulated in this object and is *never*
    // handed over (otherwise we wouldn't be able to ensure that
    // add() is the only method ever called to add a record).
    //
    memoryLog =
            Collections.synchronizedList(new LinkedList<ResultRecord>() {
        public synchronized boolean add(ResultRecord e) {
            final int max = getMemoryLogCapacity();
            while (max > 0 && size() >= max) {
                memCapacityReached = true;
                removeFirst();
            }
            return super.add(e);
        }
    });

    // default memory capacity
    memCapacity = 2048;

    // default file capacity: 0 means infinite ;-)
    fileCapacity = 0;

    // by default logging to file is disabled.
    logFile = null;

    // Until the ScanManager apply a new configuration, we're going to
    // work with a default ResultLogConfig object.
    config = new ResultLogConfig();
    config.setMemoryMaxRecords(memCapacity);
    config.setLogFileName(getLogFileName(false));
    config.setLogFileMaxRecords(fileCapacity);
}
 

/**
 * Create a new ResultLogManagerMXBean. This constructor is package
 * protected: only the {@link ScanManager} can create a
 * <code>ResultLogManager</code>.
 **/
ResultLogManager() {
    // Instantiate the memory log - override the add() method so that
    // it removes the head of the list when the maximum capacity is
    // reached. Note that add() is the only method we will be calling,
    // otherwise we would have to override all the other flavors
    // of adding methods. Note also that this implies that the memoryLog
    // will *always* remain encapsulated in this object and is *never*
    // handed over (otherwise we wouldn't be able to ensure that
    // add() is the only method ever called to add a record).
    //
    memoryLog =
            Collections.synchronizedList(new LinkedList<ResultRecord>() {
        public synchronized boolean add(ResultRecord e) {
            final int max = getMemoryLogCapacity();
            while (max > 0 && size() >= max) {
                memCapacityReached = true;
                removeFirst();
            }
            return super.add(e);
        }
    });

    // default memory capacity
    memCapacity = 2048;

    // default file capacity: 0 means infinite ;-)
    fileCapacity = 0;

    // by default logging to file is disabled.
    logFile = null;

    // Until the ScanManager apply a new configuration, we're going to
    // work with a default ResultLogConfig object.
    config = new ResultLogConfig();
    config.setMemoryMaxRecords(memCapacity);
    config.setLogFileName(getLogFileName(false));
    config.setLogFileMaxRecords(fileCapacity);
}
 

/**
 * Create a new ResultLogManagerMXBean. This constructor is package
 * protected: only the {@link ScanManager} can create a
 * <code>ResultLogManager</code>.
 **/
ResultLogManager() {
    // Instantiate the memory log - override the add() method so that
    // it removes the head of the list when the maximum capacity is
    // reached. Note that add() is the only method we will be calling,
    // otherwise we would have to override all the other flavors
    // of adding methods. Note also that this implies that the memoryLog
    // will *always* remain encapsulated in this object and is *never*
    // handed over (otherwise we wouldn't be able to ensure that
    // add() is the only method ever called to add a record).
    //
    memoryLog =
            Collections.synchronizedList(new LinkedList<ResultRecord>() {
        public synchronized boolean add(ResultRecord e) {
            final int max = getMemoryLogCapacity();
            while (max > 0 && size() >= max) {
                memCapacityReached = true;
                removeFirst();
            }
            return super.add(e);
        }
    });

    // default memory capacity
    memCapacity = 2048;

    // default file capacity: 0 means infinite ;-)
    fileCapacity = 0;

    // by default logging to file is disabled.
    logFile = null;

    // Until the ScanManager apply a new configuration, we're going to
    // work with a default ResultLogConfig object.
    config = new ResultLogConfig();
    config.setMemoryMaxRecords(memCapacity);
    config.setLogFileName(getLogFileName(false));
    config.setLogFileMaxRecords(fileCapacity);
}
 

/**
 * Create a new ResultLogManagerMXBean. This constructor is package
 * protected: only the {@link ScanManager} can create a
 * <code>ResultLogManager</code>.
 **/
ResultLogManager() {
    // Instantiate the memory log - override the add() method so that
    // it removes the head of the list when the maximum capacity is
    // reached. Note that add() is the only method we will be calling,
    // otherwise we would have to override all the other flavors
    // of adding methods. Note also that this implies that the memoryLog
    // will *always* remain encapsulated in this object and is *never*
    // handed over (otherwise we wouldn't be able to ensure that
    // add() is the only method ever called to add a record).
    //
    memoryLog =
            Collections.synchronizedList(new LinkedList<ResultRecord>() {
        public synchronized boolean add(ResultRecord e) {
            final int max = getMemoryLogCapacity();
            while (max > 0 && size() >= max) {
                memCapacityReached = true;
                removeFirst();
            }
            return super.add(e);
        }
    });

    // default memory capacity
    memCapacity = 2048;

    // default file capacity: 0 means infinite ;-)
    fileCapacity = 0;

    // by default logging to file is disabled.
    logFile = null;

    // Until the ScanManager apply a new configuration, we're going to
    // work with a default ResultLogConfig object.
    config = new ResultLogConfig();
    config.setMemoryMaxRecords(memCapacity);
    config.setLogFileName(getLogFileName(false));
    config.setLogFileMaxRecords(fileCapacity);
}
 

/**
 * Create a new ResultLogManagerMXBean. This constructor is package
 * protected: only the {@link ScanManager} can create a
 * <code>ResultLogManager</code>.
 **/
ResultLogManager() {
    // Instantiate the memory log - override the add() method so that
    // it removes the head of the list when the maximum capacity is
    // reached. Note that add() is the only method we will be calling,
    // otherwise we would have to override all the other flavors
    // of adding methods. Note also that this implies that the memoryLog
    // will *always* remain encapsulated in this object and is *never*
    // handed over (otherwise we wouldn't be able to ensure that
    // add() is the only method ever called to add a record).
    //
    memoryLog =
            Collections.synchronizedList(new LinkedList<ResultRecord>() {
        public synchronized boolean add(ResultRecord e) {
            final int max = getMemoryLogCapacity();
            while (max > 0 && size() >= max) {
                memCapacityReached = true;
                removeFirst();
            }
            return super.add(e);
        }
    });

    // default memory capacity
    memCapacity = 2048;

    // default file capacity: 0 means infinite ;-)
    fileCapacity = 0;

    // by default logging to file is disabled.
    logFile = null;

    // Until the ScanManager apply a new configuration, we're going to
    // work with a default ResultLogConfig object.
    config = new ResultLogConfig();
    config.setMemoryMaxRecords(memCapacity);
    config.setLogFileName(getLogFileName(false));
    config.setLogFileMaxRecords(fileCapacity);
}
 

/**
 * Create a new ResultLogManagerMXBean. This constructor is package
 * protected: only the {@link ScanManager} can create a
 * <code>ResultLogManager</code>.
 **/
ResultLogManager() {
    // Instantiate the memory log - override the add() method so that
    // it removes the head of the list when the maximum capacity is
    // reached. Note that add() is the only method we will be calling,
    // otherwise we would have to override all the other flavors
    // of adding methods. Note also that this implies that the memoryLog
    // will *always* remain encapsulated in this object and is *never*
    // handed over (otherwise we wouldn't be able to ensure that
    // add() is the only method ever called to add a record).
    //
    memoryLog =
            Collections.synchronizedList(new LinkedList<ResultRecord>() {
        public synchronized boolean add(ResultRecord e) {
            final int max = getMemoryLogCapacity();
            while (max > 0 && size() >= max) {
                memCapacityReached = true;
                removeFirst();
            }
            return super.add(e);
        }
    });

    // default memory capacity
    memCapacity = 2048;

    // default file capacity: 0 means infinite ;-)
    fileCapacity = 0;

    // by default logging to file is disabled.
    logFile = null;

    // Until the ScanManager apply a new configuration, we're going to
    // work with a default ResultLogConfig object.
    config = new ResultLogConfig();
    config.setMemoryMaxRecords(memCapacity);
    config.setLogFileName(getLogFileName(false));
    config.setLogFileMaxRecords(fileCapacity);
}
 

/**
 * Create a new ResultLogManagerMXBean. This constructor is package
 * protected: only the {@link ScanManager} can create a
 * <code>ResultLogManager</code>.
 **/
ResultLogManager() {
    // Instantiate the memory log - override the add() method so that
    // it removes the head of the list when the maximum capacity is
    // reached. Note that add() is the only method we will be calling,
    // otherwise we would have to override all the other flavors
    // of adding methods. Note also that this implies that the memoryLog
    // will *always* remain encapsulated in this object and is *never*
    // handed over (otherwise we wouldn't be able to ensure that
    // add() is the only method ever called to add a record).
    //
    memoryLog =
            Collections.synchronizedList(new LinkedList<ResultRecord>() {
        public synchronized boolean add(ResultRecord e) {
            final int max = getMemoryLogCapacity();
            while (max > 0 && size() >= max) {
                memCapacityReached = true;
                removeFirst();
            }
            return super.add(e);
        }
    });

    // default memory capacity
    memCapacity = 2048;

    // default file capacity: 0 means infinite ;-)
    fileCapacity = 0;

    // by default logging to file is disabled.
    logFile = null;

    // Until the ScanManager apply a new configuration, we're going to
    // work with a default ResultLogConfig object.
    config = new ResultLogConfig();
    config.setMemoryMaxRecords(memCapacity);
    config.setLogFileName(getLogFileName(false));
    config.setLogFileMaxRecords(fileCapacity);
}
 

/**
 * Create a new ResultLogManagerMXBean. This constructor is package
 * protected: only the {@link ScanManager} can create a
 * <code>ResultLogManager</code>.
 **/
ResultLogManager() {
    // Instantiate the memory log - override the add() method so that
    // it removes the head of the list when the maximum capacity is
    // reached. Note that add() is the only method we will be calling,
    // otherwise we would have to override all the other flavors
    // of adding methods. Note also that this implies that the memoryLog
    // will *always* remain encapsulated in this object and is *never*
    // handed over (otherwise we wouldn't be able to ensure that
    // add() is the only method ever called to add a record).
    //
    memoryLog =
            Collections.synchronizedList(new LinkedList<ResultRecord>() {
        public synchronized boolean add(ResultRecord e) {
            final int max = getMemoryLogCapacity();
            while (max > 0 && size() >= max) {
                memCapacityReached = true;
                removeFirst();
            }
            return super.add(e);
        }
    });

    // default memory capacity
    memCapacity = 2048;

    // default file capacity: 0 means infinite ;-)
    fileCapacity = 0;

    // by default logging to file is disabled.
    logFile = null;

    // Until the ScanManager apply a new configuration, we're going to
    // work with a default ResultLogConfig object.
    config = new ResultLogConfig();
    config.setMemoryMaxRecords(memCapacity);
    config.setLogFileName(getLogFileName(false));
    config.setLogFileMaxRecords(fileCapacity);
}
 

/**
 * Create a new ResultLogManagerMXBean. This constructor is package
 * protected: only the {@link ScanManager} can create a
 * <code>ResultLogManager</code>.
 **/
ResultLogManager() {
    // Instantiate the memory log - override the add() method so that
    // it removes the head of the list when the maximum capacity is
    // reached. Note that add() is the only method we will be calling,
    // otherwise we would have to override all the other flavors
    // of adding methods. Note also that this implies that the memoryLog
    // will *always* remain encapsulated in this object and is *never*
    // handed over (otherwise we wouldn't be able to ensure that
    // add() is the only method ever called to add a record).
    //
    memoryLog =
            Collections.synchronizedList(new LinkedList<ResultRecord>() {
        public synchronized boolean add(ResultRecord e) {
            final int max = getMemoryLogCapacity();
            while (max > 0 && size() >= max) {
                memCapacityReached = true;
                removeFirst();
            }
            return super.add(e);
        }
    });

    // default memory capacity
    memCapacity = 2048;

    // default file capacity: 0 means infinite ;-)
    fileCapacity = 0;

    // by default logging to file is disabled.
    logFile = null;

    // Until the ScanManager apply a new configuration, we're going to
    // work with a default ResultLogConfig object.
    config = new ResultLogConfig();
    config.setMemoryMaxRecords(memCapacity);
    config.setLogFileName(getLogFileName(false));
    config.setLogFileMaxRecords(fileCapacity);
}
 

/**
 * Create a new ResultLogManagerMXBean. This constructor is package
 * protected: only the {@link ScanManager} can create a
 * <code>ResultLogManager</code>.
 **/
ResultLogManager() {
    // Instantiate the memory log - override the add() method so that
    // it removes the head of the list when the maximum capacity is
    // reached. Note that add() is the only method we will be calling,
    // otherwise we would have to override all the other flavors
    // of adding methods. Note also that this implies that the memoryLog
    // will *always* remain encapsulated in this object and is *never*
    // handed over (otherwise we wouldn't be able to ensure that
    // add() is the only method ever called to add a record).
    //
    memoryLog =
            Collections.synchronizedList(new LinkedList<ResultRecord>() {
        public synchronized boolean add(ResultRecord e) {
            final int max = getMemoryLogCapacity();
            while (max > 0 && size() >= max) {
                memCapacityReached = true;
                removeFirst();
            }
            return super.add(e);
        }
    });

    // default memory capacity
    memCapacity = 2048;

    // default file capacity: 0 means infinite ;-)
    fileCapacity = 0;

    // by default logging to file is disabled.
    logFile = null;

    // Until the ScanManager apply a new configuration, we're going to
    // work with a default ResultLogConfig object.
    config = new ResultLogConfig();
    config.setMemoryMaxRecords(memCapacity);
    config.setLogFileName(getLogFileName(false));
    config.setLogFileMaxRecords(fileCapacity);
}
 

ResultLogConfig getConfig() {
    return config;
}
 

ResultLogConfig getConfig() {
    return config;
}
 

ResultLogConfig getConfig() {
    return config;
}
 

ResultLogConfig getConfig() {
    return config;
}
 

ResultLogConfig getConfig() {
    return config;
}
 

ResultLogConfig getConfig() {
    return config;
}