<?php
/**
 * File containing the ezcDebug class.
 *
 * 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 Debug
 * @version //autogentag//
 * @license http://www.apache.org/licenses/LICENSE-2.0 Apache License, Version 2.0
 */

/**
 * Base iterator class to wrap stack traces.
 *
 * This class provides a basis for stack trace iterators that are stored for
 * each call to {@link ezcDebug::log()} if {@link ezcDebugOptions::$stackTrace}
 * is switched on or the specific parameter is set. The stack trace iterator
 * needs to ensure, that the created stack trace is converted to the format
 * understandable by the {@link ezcDebugFormatter} as defined in {@link
 * ezcDebugStacktraceIterator::unifyStackElement()}.
 * 
 * @package Debug
 * @version //autogen//
 */
abstract class ezcDebugStacktraceIterator implements Iterator, ArrayAccess, Countable
{

    /**
     * Raw stack trace as an array.
     * 
     * @var array
     */
    private $stackTrace;

    /**
     * Options. 
     * 
     * @var ezcDebugOptions
     */
    protected $options;

    /**
     * Creates a new stack trace iterator.
     *
     * Calls {@link ezcDebugStacktraceIterator::prepare()} internally to
     * prepare the stack trace before storing it.
     * 
     * @param mixed $stackTrace 
     * @param int $removeElements
     * @param ezcDebugOptions $options
     * @return void
     */
    public final function __construct( $stackTrace, $removeElements = 2, ezcDebugOptions $options )
    {
        $this->options    = $options;
        $this->stackTrace = $this->prepare( $stackTrace, $removeElements );
    }

    /**
     * Unifies a stack element for being returned to the formatter.
     *
     * This method ensures that an element of the stack trace conforms to the
     * format expected by a {@link ezcDebugOutputFormatter}. The format is
     * defined as follows:
     *
     * <code>
     * array(
     *      'file'      => '<fullpathtofile>',
     *      'line'      => <lineno>,
     *      'function'  => '<functionname>',
     *      'class'     => '<classname>',
     *      'params'    => array(
     *          <param_no> => '<paramvalueinfo>',
     *          <param_no> => '<paramvalueinfo>',
     *          <param_no> => '<paramvalueinfo>',
     *          ...
     *      )
     * )
     * </code>
     * 
     * @param mixed $stackElement 
     * @return array As described above.
     */
    protected abstract function unifyStackElement( $stackElement );

    /**
     * Prepares the stack trace for being stored in the iterator instance.
     *
     * This method is called by {@link
     * ezcDebugStacktraceIterator::__construct()} before the stack trace is
     * stored in the corresponding property. The given array can be manipulated
     * as needed to prepare the trace and the array to store internally must be
     * returned. The basic implementation removes $removeElements number of
     * elements from the start of the trace array and reduces the array to
     * {@link ezcDebugOptions::$stackTraceDepth} elements.
     *
     * @param array $stackTrace 
     * @param int $removeElements 
     */
    protected function prepare( $stackTrace, $removeElements )
    {
        return array_slice(
            $stackTrace,
            $removeElements,
            ( ( $elementCount = $this->options->stackTraceDepth ) === 0 ? null : $elementCount )
        );
    }

    /**
     * Returns the currently selected element of the iterator.
     *
     * This method is part of the Iterator interface.
     *
     * @return mixed
     */
    public final function current()
    {
        return $this->unifyStackElement(
            current( $this->stackTrace )
        );
    }

    /**
     * Returns the key of the currently selected element of the iterator.
     *
     * This method is part of the Iterator interface.
     *
     * @return mixed
     */
    public final function key()
    {
        return key( $this->stackTrace );
    }

    /**
     * Advances the iterator to the next element. 
     *
     * This method is part of the Iterator interface.
     * 
     * @return mixed
     */
    public final function next()
    {
        return next( $this->stackTrace );
    }

    /**
     * Resets the iterator to the first element.
     *
     * This method is part of the Iterator interface.
     * 
     * @return mixed
     */
    public final function rewind()
    {
        return reset( $this->stackTrace );
    }

    /**
     * Returns if the iterator is on a valid element or at the end.
     *
     * This method is part of the Iterator interface.
     * 
     * @return bool
     */
    public final function valid()
    {
        return ( current( $this->stackTrace ) !== false );
    }

    /**
     * Returns if the given offset exists.
     *
     * This method is part of the ArrayAccess interface.
     * 
     * @param mixed $offset 
     * @return bool
     */
    public final function offsetExists( $offset )
    {
        return array_key_exists( $offset, $this->stackTrace );
    }
    
    /**
     * Returns the value assigned to the given offset. 
     *
     * This method is part of the ArrayAccess interface.
     * 
     * @param mixed $offset 
     * @return mixed
     */
    public final function offsetGet( $offset )
    {
        if ( !$this->offsetExists( $offset ) )
        {
            throw new ezcBaseValueException(
                'offset',
                $offset,
                'valid offset'
            );
        }
        return $this->unifyStackElement( $this->stackTrace[$offset] );
    }

    /**
     * It is not allowed to use this method with this iterator.
     *
     * This method is part of the ArrayAccess interface.
     *
     * @throws ezcDebugException
     * @param mixed $offset 
     * @param mixed $value 
     * @return void
     */
    public final function offsetSet( $offset, $value )
    {
        throw new ezcDebugOperationNotPermittedException(
            'setting values via ArrayAccess'
        );
    }

    /**
     * It is not allowed to use this method with this iterator.
     *
     * This method is part of the ArrayAccess interface.
     *
     * @throws ezcDebugException
     * @param mixed $offset 
     * @return void
     */
    public final function offsetUnset( $offset )
    {
        throw new ezcDebugOperationNotPermittedException(
            'unsetting values via ArrayAccess'
        );
    }

    /**
     * Returns the number of elements in the iterator.
     *
     * This method is part of the Countable interface.
     * 
     * @return int
     */
    public final function count()
    {
        return count( $this->stackTrace );
    }
}

?>