<?php

/**

 * Licensed to the Apache Software Foundation (ASF) under one or more

 * contributor license agreements. See the NOTICE file distributed with

 * this work for additional information regarding copyright ownership.

 * The ASF licenses this file to You under the Apache License, Version 2.0

 * (the "License"); you may not use this file except in compliance with

 * the License. You may obtain a copy of the License at

 *

 *        http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 *

 * @package log4php

 */

/**

 * Abstract class that defines output logs strategies.

 *

 * @version $Revision: 1374777 $

 * @package log4php

 */

abstract class LoggerAppender extends LoggerConfigurable {

    /**

     * Set to true when the appender is closed. A closed appender will not

     * accept any logging requests.

     * @var boolean

     */

    protected $closed = false;

    /**

     * The first filter in the filter chain.

     * @var LoggerFilter

     */

    protected $filter;

    /**

     * The appender's layout. Can be null if the appender does not use

     * a layout.

     * @var LoggerLayout

     */

    protected $layout;

    /**

     * Appender name. Used by other components to identify this appender.

     * @var string

     */

    protected $name;

    /**

     * Appender threshold level. Events whose level is below the threshold

     * will not be logged.

     * @var LoggerLevel

     */

    protected $threshold;

    /**

     * Set to true if the appender requires a layout.

     *

     * True by default, appenders which do not use a layout should override

     * this property to false.

     *

     * @var boolean

     */

    protected $requiresLayout = true;

    /**

     * Default constructor.

     * @param string $name Appender name

     */

    public function __construct($name = '') {

        $this->name = $name;

        if ($this->requiresLayout) {

            $this->layout = $this->getDefaultLayout();

        }

    }

    public function __destruct() {

        $this->close();

    }

    /**

     * Returns the default layout for this appender. Can be overriden by

     * derived appenders.

     *

     * @return LoggerLayout

     */

    public function getDefaultLayout() {

        return new LoggerLayoutSimple();

    }

    /**

     * Adds a filter to the end of the filter chain.

     * @param LoggerFilter $filter add a new LoggerFilter

     */

    public function addFilter($filter) {

        if ($this->filter === null) {

            $this->filter = $filter;

        } else {

            $this->filter->addNext($filter);

        }

    }

    /**

     * Clears the filter chain by removing all the filters in it.

     */

    public function clearFilters() {

        $this->filter = null;

    }

    /**

     * Returns the first filter in the filter chain.

     * The return value may be <i>null</i> if no is filter is set.

     * @return LoggerFilter

     */

    public function getFilter() {

        return $this->filter;

    }

    /**

     * Returns the first filter in the filter chain.

     * The return value may be <i>null</i> if no is filter is set.

     * @return LoggerFilter

     */

    public function getFirstFilter() {

        return $this->filter;

    }

    /**

     * Performs threshold checks and invokes filters before delegating logging

     * to the subclass' specific <i>append()</i> method.

     * @see LoggerAppender::append()

     * @param LoggerLoggingEvent $event

     */

    public function doAppend(LoggerLoggingEvent $event) {

        if ($this->closed) {

            return;

        }

        if (!$this->isAsSevereAsThreshold($event->getLevel())) {

            return;

        }

        $filter = $this->getFirstFilter();

        while ($filter !== null) {

            switch ($filter->decide($event)) {

                case LoggerFilter::DENY:

                    return;

                case LoggerFilter::ACCEPT:

                    return $this->append($event);

                case LoggerFilter::NEUTRAL:

                    $filter = $filter->getNext();

            }

        }

        $this->append($event);

    }

    /**

     * Sets the appender layout.

     * @param LoggerLayout $layout

     */

    public function setLayout($layout) {

        if ($this->requiresLayout()) {

            $this->layout = $layout;

        }

    }

    /**

     * Returns the appender layout.

     * @return LoggerLayout

     */

    public function getLayout() {

        return $this->layout;

    }

    /**

     * Configurators call this method to determine if the appender

     * requires a layout.

     *

     * <p>If this method returns <i>true</i>, meaning that layout is required,

     * then the configurator will configure a layout using the configuration

     * information at its disposal.     If this method returns <i>false</i>,

     * meaning that a layout is not required, then layout configuration will be

     * skipped even if there is available layout configuration

     * information at the disposal of the configurator.</p>

     *

     * <p>In the rather exceptional case, where the appender

     * implementation admits a layout but can also work without it, then

     * the appender should return <i>true</i>.</p>

     *

     * @return boolean

     */

    public function requiresLayout() {

        return $this->requiresLayout;

    }

    /**

     * Retruns the appender name.

     * @return string

     */

    public function getName() {

        return $this->name;

    }

    /**

     * Sets the appender name.

     * @param string $name

     */

    public function setName($name) {

        $this->name = $name;

    }

    /**

     * Returns the appender's threshold level.

     * @return LoggerLevel

     */

    public function getThreshold() {

        return $this->threshold;

    }

    /**

     * Sets the appender threshold.

     *

     * @param LoggerLevel|string $threshold Either a {@link LoggerLevel}

     *   object or a string equivalent.

     * @see LoggerOptionConverter::toLevel()

     */

    public function setThreshold($threshold) {

        $this->setLevel('threshold', $threshold);

    }

    /**

     * Checks whether the message level is below the appender's threshold.

     *

     * If there is no threshold set, then the return value is always <i>true</i>.

     *

     * @param LoggerLevel $level

     * @return boolean Returns true if level is greater or equal than

     *   threshold, or if the threshold is not set. Otherwise returns false.

     */

    public function isAsSevereAsThreshold($level) {

        if ($this->threshold === null) {

            return true;

        }

        return $level->isGreaterOrEqual($this->getThreshold());

    }

    /**

     * Prepares the appender for logging.

     *

     * Derived appenders should override this method if option structure

     * requires it.

     */

    public function activateOptions() {

        $this->closed = false;

    }

    /**

     * Forwards the logging event to the destination.

     *

     * Derived appenders should implement this method to perform actual logging.

     *

     * @param LoggerLoggingEvent $event

     */

    abstract protected function append(LoggerLoggingEvent $event);

    /**

     * Releases any resources allocated by the appender.

     *

     * Derived appenders should override this method to perform proper closing

     * procedures.

     */

    public function close() {

        $this->closed = true;

    }

    /** Triggers a warning for this logger with the given message. */

    protected function warn($message) {

        $id = get_class($this) . (empty($this->name) ? '' : ":{$this->name}");

        trigger_error("log4php: [$id]: $message", E_USER_WARNING);

    }

}