H:/Workspace/php-axiom/www/php-axiom/libraries/axiom/axTableRowGroupHelper.class.php

Go to the documentation of this file.

<?php
class axTableRowGroupHelper extends axBaseHelper {
    
    protected $_type;
    
    protected $_filter = array();
    
    protected $_callbacks = array();
    
    protected $_before_content;
    
    protected $_before_callback;
    
    protected $_after_content;
    
    protected $_after_callback;
    
    public function __construct ($type) {
        switch (strtolower($type)) {
            case 'head':
            case 'thead':
                $this->_type = "head";
                parent::__construct('thead');
                break;
                
            case 'foot':
            case 'tfoot':
                $this->_type = "foot";
                parent::__construct('tfoot');
                break;
                
            case 'body':
            case 'tbody':
            default:
                $this->_type = "body";
                parent::__construct('tbody');
        }
    }
    
    public function getType () {
        return $this->_type;
    }
    
    public function getFilter () {
        return $this->_filter;
    }
    
    public function setFilter (array $filter) {
        $this->_filter = $filter;
        return $this;
    }
    
    public function getColumnCallback ($key) {
        return isset($this->_callbacks[$key]) ? $this->_callbacks[$key] : null;
    }
    
    public function setColumnCallback ($key, $callback) {
        if (is_string($callback) && !is_callable($callback))
            $callback = callback($callback);
        
        if (!is_callable($callback))
            throw new InvalidArgumentException("Invalid callback provided");
            
        $this->_callbacks[$key] = $callback;
        return $this;
    }
    
    public function setColumnCallbacks (array $callbacks) {
        try {
            foreach ($callbacks as $key => $callback)
                $this->setColumnCallback($key, $callback);
        }
        catch (Exception $e) {
            $this->_callbacks = array();
            throw new RuntimeException("Cannot set callbacks");
        }
        return $this;
    }
    
    public function before ($content, $replace_callback = null) {
        if ($replace_callback) {
            if (is_string($replace_callback) && !is_callable($replace_callback))
                $replace_callback = callback($replace_callback);
            
            if (!is_callable($replace_callback))
                throw new InvalidArgumentException("Provided callback is invalid");
        }
        
        $this->_before_content = (array)$content;
        $this->_before_callback = $replace_callback;
        return $this;
    }
    
    public function after ($content, $replace_callback = null) {
        if ($replace_callback) {
            if (is_string($replace_callback) && !is_callable($replace_callback))
                $replace_callback = callback($replace_callback);
            
            if (!is_callable($replace_callback))
                throw new InvalidArgumentException("Provided callback is invalid");
        }
            
        $this->_after_content = (array)$content;
        $this->_after_callback = $replace_callback;
        return $this;
    }
    
    public function addRows ($rows, $cell_type = "auto") {
        if (!is_array($rows) && !$rows instanceof Traversable)
            throw new InvalidArgumentException("First parameter is expected to be array or Traversable, " . gettype($rows) . " given", 3003);
        
        if ($cell_type == "auto")
            $cell_type = ($this->_type == "thead" || $this->_type == "head") ? "head" : "data";
            
        foreach ($rows as $row) {
            $this->addRow($row, $cell_type);
        }
        return $this;
    }
    
    public function addRow ($values, $cell_type = "auto") {
        if (is_scalar($values))
            $values = array($values);
        elseif ($values instanceof axModel)
            $values = $values->getData();
        elseif (!is_array($values) && !$values instanceof Traversable) {
            throw new InvalidArgumentException(
                "First parameter is expected to be scalar, array or axModel, ".get_class($values)." given", 3002
            );
        }
            
        if ($cell_type == "auto")
            $cell_type = ($this->_type == "thead" || $this->_type == "head")  ? "head" : "data";
            
        if (!empty($this->_filter))
            $values = array_intersect_key($values, array_flip($this->_filter));
        
        foreach (array_intersect_key($values, $this->_callbacks) as $key => $value) {
            $values[$key] = $this->_callbacks[$key]($value);
        }
        
        if (!empty($this->_before_content)) {
            if (!empty($this->_before_callback)) {
                $alpha = $this->_before_callback;
                $before = (array)$alpha($this->_before_content, $values);
            }
            else
                $before = $this->_before_content;
                
            $values = array_merge($before, array_values($values));
        }
        
        if (!empty($this->_after_content)) {
            if (!empty($this->_after_callback)) {
                $alpha = $this->_after_callback;
                $after = (array)$alpha($this->_after_content, $values);
            }
            else
                $after = $this->_after_content;
                
            $values = array_merge(array_values($values), $after);
        }
        
        $this->appendChild(axTableRowHelper::export($values, $cell_type));
        return $this;
    }
    
    public function __toString () {
        $attr = array();
        foreach ($this->_attributes as $name => $value) {
            $attr[] = "$name=\"$value\"";
        }
        $node = "<{$this->_node_name} " . implode(' ', $attr) . ">";

        if (count($this->_children))
            $node .= implode($this->_children);

        return $node . "</{$this->_node_name}>";
    }
    
    public static function export ($type) {
        return new self ($type);
    }
}