class.ilADT.php

Go to the documentation of this file.

<?php
/* Copyright (c) 1998-2009 ILIAS open source, Extended GPL, see docs/LICENSE */
 
abstract class ilADT
{
    protected $definition; // [ilADTDefinition]
    protected $validation_errors = []; // [array]
    
    
    // :TODO: error codes for ALL types - see self::translateErrorMessage()
    
    const ADT_VALIDATION_ERROR_NULL_NOT_ALLOWED = "adt1";
    
    // text-based
    const ADT_VALIDATION_ERROR_MAX_LENGTH = "adt2";
    
    // multi
    const ADT_VALIDATION_ERROR_MAX_SIZE = "adt3";
    
    // number-based
    const ADT_VALIDATION_ERROR_MIN = "adt4";
    const ADT_VALIDATION_ERROR_MAX = "adt5";
    
    // date-based
    const ADT_VALIDATION_DATE = "adt6";
    
    // invalid target node for internal link
    const ADT_VALIDATION_ERROR_INVALID_NODE = 'adt7';
    
    public function __construct(ilADTDefinition $a_def)
    {
        $this->setDefinition($a_def);
        $this->reset();
    }
    
    public function getType()
    {
        return $this->getDefinition()->getType();
    }
            
    protected function reset()
    {
    }
    
    
    //
    // definition
    //
    
    abstract protected function isValidDefinition(ilADTDefinition $a_def);
    
    protected function setDefinition(ilADTDefinition $a_def)
    {
        if ($this->isValidDefinition($a_def)) {
            $this->definition = clone $a_def;
        } else {
            throw new ilException("ilADT invalid definition");
        }
    }
    
    protected function getDefinition()
    {
        return $this->definition;
    }
    
    public function getCopyOfDefinition()
    {
        return (clone $this->definition);
    }
            
    
    //
    // comparison
    //
        
    abstract public function equals(ilADT $a_adt);
    
    abstract public function isLarger(ilADT $a_adt);
    
    public function isLargerOrEqual(ilADT $a_adt)
    {
        return ($this->equals($a_adt) ||
            $this->isLarger($a_adt));
    }
    
    abstract public function isSmaller(ilADT $a_adt);
    
    public function isSmallerOrEqual(ilADT $a_adt)
    {
        return ($this->equals($a_adt) ||
            $this->isSmaller($a_adt));
    }
    
    public function isInbetween(ilADT $a_adt_from, ilADT $a_adt_to)
    {
        return ($this->isLarger($a_adt_from) &&
            $this->isSmaller($a_adt_to));
    }
    
    public function isInbetweenOrEqual(ilADT $a_adt_from, ilADT $a_adt_to)
    {
        return ($this->equals($a_adt_from) ||
            $this->equals($a_adt_to) ||
            $this->isInbetween($a_adt_from, $a_adt_to));
    }
    
    
    //
    // null
    //
    
    abstract public function isNull();
    
    
    //
    // validation
    //
    
    public function isValid()
    {
        $this->validation_errors = array();
        
        if (!$this->getDefinition()->isNullAllowed() && $this->isNull()) {
            $this->addValidationError(self::ADT_VALIDATION_ERROR_NULL_NOT_ALLOWED);
            return false;
        }
        return true;
    }
    
    protected function addValidationError($a_error_code)
    {
        $this->validation_errors[] = (string) $a_error_code;
    }
    
    public function getValidationErrors()
    {
        if (is_array($this->validation_errors) &&
            sizeof($this->validation_errors)) {
            return array_unique($this->validation_errors);
        }
        return array();
    }
    
    public function translateErrorCode($a_code)
    {
        global $DIC;
 
        $lng = $DIC['lng'];
        
        // $lng->txt("msg_wrong_format");
        
        switch ($a_code) {
            case self::ADT_VALIDATION_ERROR_NULL_NOT_ALLOWED:
                return $lng->txt("msg_input_is_required");
                
            case self::ADT_VALIDATION_ERROR_MAX_LENGTH:
                return $lng->txt("adt_error_max_length");
                
            case self::ADT_VALIDATION_ERROR_MAX_SIZE:
                return $lng->txt("adt_error_max_size");
            
            case self::ADT_VALIDATION_ERROR_MIN:
                return $lng->txt("form_msg_value_too_low");
                
            case self::ADT_VALIDATION_ERROR_MAX:
                return $lng->txt("form_msg_value_too_high");
                
            // :TODO: currently not used - see ilDateTimeInputGUI
            case self::ADT_VALIDATION_DATE:
                return $lng->txt("exc_date_not_valid");
                
            default:
                throw new Exception("ADT unknown error code");
        }
    }
    
    abstract public function getCheckSum();
    
    abstract public function exportStdClass();
    
    abstract public function importStdClass($a_std);
}