Source for file PelEntryNumber.php

Documentation is available at PelEntryNumber.php

  1. <?php
  2.  
  3. /*  PEL: PHP Exif Library.  A library with support for reading and
  4.  *  writing all Exif headers in JPEG and TIFF images using PHP.
  5.  *
  6.  *  Copyright (C) 2004, 2005, 2006  Martin Geisler.
  7.  *
  8.  *  This program is free software; you can redistribute it and/or modify
  9.  *  it under the terms of the GNU General Public License as published by
  10.  *  the Free Software Foundation; either version 2 of the License, or
  11.  *  (at your option) any later version.
  12.  *
  13.  *  This program is distributed in the hope that it will be useful,
  14.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16.  *  GNU General Public License for more details.
  17.  *
  18.  *  You should have received a copy of the GNU General Public License
  19.  *  along with this program in the file COPYING; if not, write to the
  20.  *  Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
  21.  *  Boston, MA 02110-1301 USA
  22.  */
  23.  
  24. /* $Id$ */
  25.  
  26.  
  27. /**
  28.  * Abstract class for numbers.
  29.  *
  30.  * @author Martin Geisler <mgeisler@users.sourceforge.net>
  31.  * @version $Revision$
  32.  * @date $Date$
  33.  * @license http://www.gnu.org/licenses/gpl.html GNU General Public
  34.  *  License (GPL)
  35.  * @package PEL
  36.  */
  37.  
  38. /**#@+ Required class definitions. */
  39. require_once('PelException.php');
  40. require_once('PelEntry.php');
  41. /**#@-*/
  42.  
  43.  
  44. /**
  45.  * Exception cast when numbers overflow.
  46.  *
  47.  * @author Martin Geisler <mgeisler@users.sourceforge.net>
  48.  * @package PEL
  49.  * @subpackage Exception
  50.  */
  51. class PelOverflowException extends PelException {
  52.   
  53.   /**
  54.    * Construct a new overflow exception.
  55.    *
  56.    * @param int the value that is out of range.
  57.    *
  58.    * @param int the minimum allowed value.
  59.    *
  60.    * @param int the maximum allowed value.
  61.    */
  62.   function __construct($v, $min, $max) {
  63.     parent::__construct('Value %.0f out of range [%.0f, %.0f]',
  64.                         $v, $min, $max);
  65.   }
  66. }
  67.  
  68.  
  69. /**
  70.  * Class for holding numbers.
  71.  *
  72.  * This class can hold numbers, with range checks.
  73.  *
  74.  * @author Martin Geisler <mgeisler@users.sourceforge.net>
  75.  * @package PEL
  76.  */
  77. abstract class PelEntryNumber extends PelEntry {
  78.  
  79.   /**
  80.    * The value held by this entry.
  81.    *
  82.    * @var array 
  83.    */
  84.   protected $value = array();
  85.  
  86.   /**
  87.    * The minimum allowed value.
  88.    *
  89.    * Any attempt to change the value below this variable will result
  90.    * in a {@link PelOverflowException} being thrown.
  91.    *
  92.    * @var int 
  93.    */
  94.   protected $min;
  95.  
  96.   /**
  97.    * The maximum allowed value.
  98.    *
  99.    * Any attempt to change the value over this variable will result in
  100.    * a {@link PelOverflowException} being thrown.
  101.    *
  102.    * @var int 
  103.    */
  104.   protected $max;
  105.   
  106.   /**
  107.    * The dimension of the number held.
  108.    *
  109.    * Normal numbers have a dimension of one, pairs have a dimension of
  110.    * two, etc.
  111.    *
  112.    * @var int 
  113.    */
  114.   protected $dimension = 1;
  115.  
  116.  
  117.   /**
  118.    * Change the value.
  119.    *
  120.    * This method can change both the number of components and the
  121.    * value of the components.  Range checks will be made on the new
  122.    * value, and a {@link PelOverflowException} will be thrown if the
  123.    * value is found to be outside the legal range.
  124.    *
  125.    * The method accept several number arguments.  The {@link getValue}
  126.    * method will always return an array except for when a single
  127.    * number is given here.
  128.    *
  129.    * @param int|array$value... the new value(s).  This can be zero or
  130.    *  more numbers, that is, either integers or arrays.  The input will
  131.    *  be checked to ensure that the numbers are within the valid range.
  132.    *  If not, then a {@link PelOverflowException} will be thrown.
  133.    *
  134.    * @see getValue
  135.    */
  136.   function setValue(/* $value... */) {
  137.     $value = func_get_args();
  138.     $this->setValueArray($value);
  139.   }
  140.  
  141.  
  142.   /**
  143.    * Change the value.
  144.    *
  145.    * This method can change both the number of components and the
  146.    * value of the components.  Range checks will be made on the new
  147.    * value, and a {@link PelOverflowException} will be thrown if the
  148.    * value is found to be outside the legal range.
  149.    *
  150.    * @param array the new values.  The array must contain the new
  151.    *  numbers.
  152.    *
  153.    * @see getValue
  154.    */
  155.   function setValueArray($value) {
  156.     foreach ($value as $v)
  157.       $this->validateNumber($v);
  158.     
  159.     $this->components = count($value);
  160.     $this->value      = $value;
  161.   }
  162.  
  163.  
  164.   /**
  165.    * Return the numeric value held.
  166.    *
  167.    * @return int|arraythis will either be a single number if there is
  168.    *  only one component, or an array of numbers otherwise.
  169.    */
  170.   function getValue() {
  171.     if ($this->components == 1)
  172.       return $this->value[0];
  173.     else
  174.       return $this->value;
  175.   }
  176.  
  177.  
  178.   /**
  179.    * Validate a number.
  180.    *
  181.    * This method will check that the number given is within the range
  182.    * given my {@link getMin()} and {@link getMax()}, inclusive.  If
  183.    * not, then a {@link PelOverflowException} is thrown.
  184.    *
  185.    * @param int|arraythe number in question.
  186.    *
  187.    * @return void nothing, but will throw a {@link }
  188.    *  PelOverflowException} if the number is found to be outside the
  189.    *  legal range and {@link Pel::$strict} is true.
  190.    */
  191.   function validateNumber($n) {
  192.     if ($this->dimension == 1) {
  193.       if ($n < $this->min || $n > $this->max)
  194.         Pel::maybeThrow(new PelOverflowException($n,
  195.                                                  $this->min,
  196.                                                  $this->max));
  197.     } else {
  198.       for ($i = 0; $i < $this->dimension; $i++)
  199.         if ($n[$i] < $this->min || $n[$i] > $this->max)
  200.           Pel::maybeThrow(new PelOverflowException($n[$i],
  201.                                                    $this->min,
  202.                                                    $this->max));
  203.     }
  204.   }
  205.  
  206.  
  207.   /**
  208.    * Add a number.
  209.    *
  210.    * This appends a number to the numbers already held by this entry,
  211.    * thereby increasing the number of components by one.
  212.    *
  213.    * @param int|arraythe number to be added.
  214.    */
  215.   function addNumber($n) {
  216.     $this->validateNumber($n);
  217.     $this->value[] = $n;
  218.     $this->components++;
  219.   }
  220.  
  221.  
  222.   /**
  223.    * Convert a number into bytes.
  224.    *
  225.    * The concrete subclasses will have to implement this method so
  226.    * that the numbers represented can be turned into bytes.
  227.    *
  228.    * The method will be called once for each number held by the entry.
  229.    *
  230.    * @param int the number that should be converted.
  231.    *
  232.    * @param PelByteOrder one of {@link PelConvert::LITTLE_ENDIAN} and
  233.    *  {@link PelConvert::BIG_ENDIAN}, specifying the target byte order.
  234.    *
  235.    * @return string bytes representing the number given.
  236.    */
  237.   abstract function numberToBytes($number, $order);
  238.  
  239.   
  240.   /**
  241.    * Turn this entry into bytes.
  242.    *
  243.    * @param PelByteOrder the desired byte order, which must be either
  244.    *  {@link PelConvert::LITTLE_ENDIAN} or {@link }
  245.    *  PelConvert::BIG_ENDIAN}.
  246.    *
  247.    * @return string bytes representing this entry.
  248.    */
  249.   function getBytes($o) {
  250.     $bytes = '';
  251.     for ($i = 0; $i < $this->components; $i++) {
  252.       if ($this->dimension == 1) {
  253.         $bytes .= $this->numberToBytes($this->value[$i], $o);
  254.       } else {
  255.         for ($j = 0; $j < $this->dimension; $j++) {
  256.           $bytes .= $this->numberToBytes($this->value[$i][$j], $o);
  257.         }
  258.       }
  259.     }
  260.     return $bytes;
  261.   }
  262.  
  263.  
  264.   /**
  265.    * Format a number.
  266.    *
  267.    * This method is called by {@link getText} to format numbers.
  268.    * Subclasses should override this method if they need more
  269.    * sophisticated behavior than the default, which is to just return
  270.    * the number as is.
  271.    *
  272.    * @param int the number which will be formatted.
  273.    *
  274.    * @param boolean it could be that there is both a verbose and a
  275.    *  brief formatting available, and this argument controls that.
  276.    *
  277.    * @return string the number formatted as a string suitable for
  278.    *  display.
  279.    */
  280.   function formatNumber($number, $brief = false) {
  281.     return $number;
  282.   }
  283.  
  284.  
  285.   /**
  286.    * Get the numeric value of this entry as text.
  287.    *
  288.    * @param boolean use brief output?  The numbers will be separated
  289.    *  by a single space if brief output is requested, otherwise a space
  290.    *  and a comma will be used.
  291.    *
  292.    * @return string the numbers(s) held by this entry.
  293.    */
  294.   function getText($brief = false) {
  295.     if ($this->components == 0)
  296.       return '';
  297.  
  298.     $str = $this->formatNumber($this->value[0]);
  299.     for ($i = 1; $i < $this->components; $i++) {
  300.       $str .= ($brief ? ' ' : ', ');
  301.       $str .= $this->formatNumber($this->value[$i]);
  302.     }
  303.  
  304.     return $str;
  305.   }
  306.  
  307. }
  308.  
  309. ?>

Documentation generated on Thu, 05 May 2011 07:19:04 +0200 by phpDocumentor 1.4.3