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";
        
        
        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 $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();
}
 
?>