Sincronizacion de objetos comunes a Bandas y HE.

diff --git a/lib/MECON/Tiempo/Banda.php b/lib/MECON/Tiempo/Banda.php
index 6908e4f7cda13bfc48612f70c7a9d02586d763e8..fefffaf6afccef31fdc71809ed1cc6d1544e5708 100644 (file)
--- a/lib/MECON/Tiempo/Banda.php
+++ b/lib/MECON/Tiempo/Banda.php
@@ -38,73 +38,203 @@ require_once 'MECON/Tiempo/Intervalo.php';
 class MECON_Tiempo_Banda {
 
     var $intervalos;
+    var $db;
 
-    function MECON_Tiempo_Banda() {
+    /**
+     * Constructor.
+     * @param $db Conexión opcional a una base de datos.
+     */
+    function MECON_Tiempo_Banda($db = null)
+    {
+        $this->db = $db;
         $this->intervalos = array();
     }
 
-    function Cargar($db, $agente, $fecha) {
-        // FIXME - lo que es base de datos debe VOLAR!!!!!!!
+    /**
+     * Funcion que se encarga de cargar los intervalos de tiempo de un agente.
+     * Devuelve true en caso de detectar una inconsistecia de reloj o false en caso contrario
+     * 
+     * @param $agente Documento del agente
+     * @param $accesos Array o Date Variable que puede ser un array con todos los accesos
+     *        de un agente o un objeto Date que indica la fecha de la banda a procesar
+     * @param $db Conexión opcional a una base de datos.
+     */
+    function cargar($agente, $accesos, $db = null)
+    {
+        if ($db) {
+            $this->db = $db;
+        }
 
-        $funcion = $db->getOne(
-                       "SELECT E.funcion
-                       FROM novedades.estado as E, novedades.web003 as S
-                       WHERE
-                       E.nrodoc = $agente AND
-                       S.nrodoc = $agente AND
-                       S.codep  = E.dependencia"
-                   );
+        $funcion = $this->db->getOne(
+                "SELECT E.funcion
+                FROM novedades.estado as E, novedades.web003 as S
+                WHERE
+                E.nrodoc = $agente AND
+                S.nrodoc = $agente AND
+                S.codep  = E.dependencia"
+                );
 
-        $fecha = $fecha->format("%Y%m%d");
-        $query = "SELECT A.tipo_acceso, A.hora
-                 FROM agentes G, accesos A
-                 WHERE G.cred = A.cred
-                 AND G.docu = $agente
-                 AND A.fecha = $fecha
-                 AND A.inconsistencia = 0
-                 ORDER BY A.hora";
-        $result = $db->query($query);
-        if(DB::isError($result))
-            trigger_error($result->getMessage(), E_USER_ERROR);
+        if (is_a($accesos,'date')) {
+            $fecha =& $accesos;
+            $fecha = $fecha->format("%Y%m%d");
+            $query = "SELECT TA.tipo_acceso, A.hora 
+                FROM Acceso A, Agente_Credencial AC, Tipo_Acceso TA
+                WHERE AC.credencial = A.credencial
+                AND A.fecha = '$fecha'
+                AND AC.agente = $agente
+                AND TA.puerta = A.puerta
+                AND AC.desde <= '$fecha'
+                AND (  AC.hasta >= '$fecha'
+                        OR   AC.hasta IS NULL)
+                ORDER BY A.hora";
+            $result = $this->db->query($query);
+            if(DB::isError($result))
+                trigger_error($result->getMessage(), E_USER_ERROR);
 
-        if($funcion != 'SE') {//Version tough
-            $int = null;
-            while( $r = $result->fetchRow() ) {
-                if($r[0] == 'E')
-                    $int = new MECON_Tiempo_Intervalo(new MECON_Tiempo_Hora( $r[1] ), new MECON_Tiempo_Hora( $r[1] ));
-                if($r[0] == 'S' && $int != null) {
-                    $int->setFin( new MECON_Tiempo_Hora( $r[1] ) );
-                    $this->agregarIntervalo( $int );
-                    $int = null;
+            $inconsistencia = false;
+            if($funcion != 'SE')
+            {//Version tough
+                $int = null;
+                while( $r = $result->fetchRow() )
+                {
+                    if($r[0] == 'E')
+                    {
+                        if($int != null)
+                            $inconsistencia = true;
+                        $int = new Mecon_Tiempo_Intervalo(new Mecon_Tiempo_Hora( $r[1] ),
+                                new Mecon_Tiempo_Hora( $r[1] ));
+                    }
+                    if($r[0] == 'S')
+                    {
+                        if($int != null)
+                        {
+                            $int->setFin( new Mecon_Tiempo_Hora( $r[1] ) );
+                            $this->agregarIntervalo( $int );
+                            $int = null;
+                        }
+                        else
+                            $inconsistencia = true;
+                    }
                 }
+                if($int != null)
+                    $inconsistencia = true;
             }
-        } else {
-            if($result->numRows() > 0) {//Version Light o Serenos
-                $int = new MECON_Tiempo_Intervalo(new MECON_Tiempo_Hora('00:00'), new MECON_Tiempo_Hora('00:00'));
-                while( $r = $result->fetchRow() ) {
-                    if($r[0] == 'E')
-                        $int = new MECON_Tiempo_Intervalo(new MECON_Tiempo_Hora( $r[1] ), new MECON_Tiempo_Hora( $r[1] ));
-                    if($r[0] == 'S' && $int != null) {
-                        $int->setFin( new MECON_Tiempo_Hora( $r[1] ) );
+            else
+            {
+                if($result->numRows() > 0)
+                {//Version Light o Serenos
+                    $int = new Mecon_Tiempo_Intervalo(new Mecon_Tiempo_Hora('00:00'),
+                            new Mecon_Tiempo_Hora('00:00'));
+                    while( $r = $result->fetchRow() )
+                    {
+                        if($r[0] == 'E')
+                        {
+                            // if($int != null)
+                            //$inconsistencia = true;
+                            $int = new Mecon_Tiempo_Intervalo(new Mecon_Tiempo_Hora( $r[1] ),
+                                    new Mecon_Tiempo_Hora( $r[1] ));
+                        }
+                        if($r[0] == 'S')
+                        {
+                            if($int != null)
+                            {
+                                $int->setFin( new Mecon_Tiempo_Hora( $r[1] ) );
+                                $this->agregarIntervalo( $int );
+                                $int = null;
+                            }
+                            //else
+                            //  $inconsistencia = true;
+                        }
+                    }
+                    if($int != null)
+                    {
+                        $int->setFin( new Hora('24:00') );
                         $this->agregarIntervalo( $int );
                         $int = null;
                     }
                 }
-                if($int != null) {
-                    $int->setFin( new MECON_Tiempo_Hora('24:00') );
+            }
+        }
+        else
+        {
+            $inconsistencia = false;
+            if($funcion != 'SE')
+            {//Version tough
+                $int = null;
+                if(!is_null($accesos))
+                {
+                    foreach( $accesos as $r )
+                    {
+                        if($r[0] == 'E')
+                        {
+                            if($int != null)
+                                $inconsistencia = true;
+                            $int = new Mecon_Tiempo_Intervalo(new Mecon_Tiempo_Hora( $r[1] ),
+                                    new Mecon_Tiempo_Hora( $r[1] ));
+                        }
+                        if($r[0] == 'S')
+                        {
+                            if($int != null)
+                            {
+                                $int->setFin( new Mecon_Tiempo_Hora( $r[1] ) );
+                                $this->agregarIntervalo( $int );
+                                $int = null;
+                            }
+                            else
+                                $inconsistencia = true;
+                        }
+                    }
+                }
+                if($int != null)
+                    $inconsistencia = true;
+            }
+            else
+            {
+                //Version Light o Serenos
+                $int = new Mecon_Tiempo_Intervalo(new Mecon_Tiempo_Hora('00:00'),
+                        new Mecon_Tiempo_Hora('00:00'));
+
+                if(!is_null($accesos))
+                {
+                    foreach( $accesos as $r )
+                    {
+                        if($r[0] == 'E')
+                        {
+                            // if($int != null)
+                            //$inconsistencia = true;
+                            $int = new Mecon_Tiempo_Intervalo(new Mecon_Tiempo_Hora( $r[1] ),
+                                    new Mecon_Tiempo_Hora( $r[1] ));
+                        }
+                        if($r[0] == 'S')
+                        {
+                            if($int != null)
+                            {
+                                $int->setFin( new Mecon_Tiempo_Hora( $r[1] ) );
+                                $this->agregarIntervalo( $int );
+                                $int = null;
+                            }
+                            //else
+                            //  $inconsistencia = true;
+                        }
+                    }
+                }
+                if($int != null)
+                {
+                    $int->setFin( new Hora('24:00') );
                     $this->agregarIntervalo( $int );
                     $int = null;
                 }
             }
-        }
+        } 
+        return $inconsistencia;
     }
 
-    /*
-    *
-    * Completa las salidas del medio del dia.
-    *
-    */
-    function CompletarSalidas() {
+    /**
+     * Completa las salidas del medio del dia.
+     *
+     */
+    function CompletarSalidas()
+    {
         if(count($this->intervalos) > 0) {
             $p = reset($this->intervalos);
             $u = end($this->intervalos);
@@ -115,14 +245,13 @@ class MECON_Tiempo_Banda {
 
 
     /**
-    * Agrega un intervalo a la banda
-    * Chequeando superposiciones y en orden
-    *
-    * @param Intervalo $intervalo Intervalo a agregar.
-    */
-    function agregarIntervalo($intervalo) {
-        if(! is_a($intervalo, "mecon_tiempo_intervalo"))
-            return false;
+     * Agrega un intervalo a la banda
+     * Chequeando superposiciones y en orden
+     *
+     * @param Intervalo $intervalo Intervalo a agregar.
+     */
+    function agregarIntervalo($intervalo)
+    {
         if ($intervalo->invertido()) {
             $intervalo->_chequear();
             $this->agregarIntervalo(new MECON_Tiempo_Intervalo(new MECON_Tiempo_Hora('00:00'), new MECON_Tiempo_Hora ('24:00')));
@@ -134,9 +263,9 @@ class MECON_Tiempo_Banda {
         // recorre el vector de intervalos
         foreach( $this->intervalos as $i ) {
             // si se superpone con alguno, fusionar con ese
-            if($i->seSuperpone($intervalo))
+            if($i->seSuperpone($intervalo)) {
                 $intervalo->fusionar($i);
-            else {
+            } else {
                 if($i->inicio->greater($intervalo->inicio) && ! $insertado) {
                     array_push($n_intervalos, $intervalo);
                     $insertado = true;
@@ -151,22 +280,19 @@ class MECON_Tiempo_Banda {
     }
 
     /**
-    * Saca 
-    *
-    *
-    */
-    function sacarBanda($banda) {
+     * Saca.
+     */
+    function sacarBanda($banda)
+    {
         foreach($banda->intervalos as $i)
-        $this->sacarIntervalo($i);
+            $this->sacarIntervalo($i);
     }
 
     /**
-    * Saca un intervalo de una banda horaria.
-    *
-    */
-    function sacarIntervalo($intervalo) {
-        if(! is_a($intervalo, "mecon_tiempo_intervalo"))
-            return false;
+     * Saca un intervalo de una banda horaria.
+     */
+    function sacarIntervalo($intervalo)
+    {
         // Si el intervalo está vacío, no hace nada.
         $dur = $intervalo->getDuracion();
         if ($dur->isEmpty()) {
@@ -194,9 +320,11 @@ class MECON_Tiempo_Banda {
 
     }
 
-    function sacarTiempo($t) {
-        if(! is_a($t, "date_span"))
-            return false;
+    /**
+     * Saca.
+     */
+    function sacarTiempo($t)
+    {
         $n_int = array();
         while(count($this->intervalos) > 0) {
             $int = array_shift($this->intervalos);
@@ -206,8 +334,7 @@ class MECON_Tiempo_Banda {
 #con cortar alcanza
                     $ini = new MECON_Tiempo_Hora();
                     $ini->copy($int->inicio);
-                    $ini->add
-                    ($t);
+                    $ini->add($t);
                     /*TODO guardar este tiempo como rechazado*/
                     $int->cortar($ini);
                     $t->setFromSeconds(0);
@@ -222,51 +349,45 @@ class MECON_Tiempo_Banda {
         $this->intervalos = $n_int;
     }
 
-    /*
-    * Chequea si el intervalo pedido esta cubierto por la banda, si faltan
-    *  horas en la banta se retorna el tiempo que falta
-    *
-    * @return Date_Span el periodo faltante
-    *
-    */
-    function chequearIntervalo($intervalo) {
-        if(! is_a($intervalo, "mecon_tiempo_intervalo"))
-            return false;
+    /**
+     * Chequea si el intervalo pedido esta cubierto por la banda, si faltan
+     *  horas en la banta se retorna el tiempo que falta
+     *
+     * @return Date_Span el periodo faltante
+     */
+    function chequearIntervalo($intervalo)
+    {
         $t = new MECON_Tiempo_Hora();
         foreach ($this->intervalos as $i)
-        $t->add
-        ($i->superponer($intervalo));
+            $t->add($i->superponer($intervalo));
         $d = $intervalo->getDuracion();
         $d->subtract($t);
         return $d;
     }
 
-    /*
-    * Chequea si la banda(parametro) esta cubierto por la banda(this),
-    *  si faltan horas en la banda(this) para llegar a banda(parametro)
-    *  se retorna el tiempo que falta
-    *
-    * @return Date_Span el periodo faltante
-    *
-    */
-    function chequearBanda($banda) {
-        if(! is_a($banda, "mecon_tiempo_banda"))
-            return false;
+    /**
+     * Chequea si la banda(parametro) esta cubierto por la banda(this),
+     * si faltan horas en la banda(this) para llegar a banda(parametro)
+     * se retorna el tiempo que falta
+     *
+     * @return Date_Span el periodo faltante
+     */
+    function chequearBanda($banda)
+    {
         $f = new MECON_Tiempo_Hora();
         foreach ($banda->intervalos as $i)
-        $f->add
-        ($this->chequearIntervalo($i));
+            $f->add($this->chequearIntervalo($i));
         return $f;
     }
 
 
-    /*
-    * Devuelve una representacion del objeto como un string.
-    *
-    * @return string Representacion del objeto.
-    *
-    */
-    function toString() {
+    /**
+     * Devuelve una representacion del objeto como un string.
+     *
+     * @return string Representacion del objeto.
+     */
+    function toString()
+    {
         $s = '';
         $t = count($this->intervalos);
         for ($n = 0; $n < ($t - 1); $n++) {
@@ -279,7 +400,8 @@ class MECON_Tiempo_Banda {
         return $s;
     }
 
-    function getIntervalos() {
+    function getIntervalos()
+    {
         return $this->intervalos;
     }
 
@@ -294,9 +416,8 @@ class MECON_Tiempo_Banda {
      *
      * @return object Banda Bnada anterior al punto de corte.
      */
-    function cortar($c) {
-        if(!is_a($c, 'mecon_tiempo_hora') and !is_a($c, 'mecon_tiempo_intervalo'))
-            return false;
+    function cortar($c)
+    {
         $b = $this->__clone();
         $b->intervalos = array();
         $intervalos = array();
@@ -320,11 +441,11 @@ class MECON_Tiempo_Banda {
      *
      * @return object Date_Span Tiempo total.
      */
-    function total() {
+    function total()
+    {
         $t = new Date_Span;
         foreach ($this->intervalos as $i) {
-            $t->add
-            ($i->getDuracion());
+            $t->add($i->getDuracion());
         }
         return $t;
     }
@@ -334,25 +455,48 @@ class MECON_Tiempo_Banda {
      *
      * @return object Date_Span Tiempo total.
      */
-    function getDuracion() {
+    function getDuracion()
+    {
         return $this->total();
     }
 
+    /**
+     * Chequea si el período pasado como argumento se superpone con la banda.
+     * @param $periodo Puede ser un MECON_Tiempo_Intervalo o MECON_Tiempo_Banda.
+     * @return true si se superpone, false si no.
+     */
+    function seSuperpone($periodo)
+    {
+        $intervalos = array($periodo);
+        if (is_a($periodo, 'mecon_tiempo_banda')) {
+            $intervalos = $periodo->intervalos;
+        }
+        foreach ($intervalos as $i) {
+            if ($i->seSuperpone($this->intervalos)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
     /**
      * Resetea la banda.
      */
-    function flush() {
+    function flush()
+    {
         $this->intervalos = array();
     }
 
-    function copy($b) {
+    function copy($b)
+    {
         $this->flush();
         foreach ($b->intervalos as $i) {
             $this->intervalos[] = $i->__clone();
         }
     }
 
-    function __clone() {
+    function __clone()
+    {
         $class = get_class($this);
         $b = new $class;
         $b->copy($this);

diff --git a/lib/MECON/Tiempo/Hora.php b/lib/MECON/Tiempo/Hora.php
index 347f08e9bae464d439f3fbe225a83b7c5bcb613c..4da62ff9e1946957f26de376c0dd8d319a12d7c3 100644 (file)
--- a/lib/MECON/Tiempo/Hora.php
+++ b/lib/MECON/Tiempo/Hora.php
@@ -36,64 +36,54 @@ require_once 'Date/Span.php';
  */
 class MECON_Tiempo_Hora extends Date_Span {
 
-    function set
-        ($str) {
+    function set($str)
+    {
         $str = strval($str);
         if (preg_match('/^\d+$/', $str)) {
             if ($str < 24) {
                 $str = sprintf('0:%02d:00:00', $str );
-            }
-            elseif ($str == 24 or $str == 2400) {
+            } elseif ($str == 24 or $str == 2400) {
                 $str = '1:00:00:00';
-            }
-            elseif ($str < 2400) {
+            } elseif ($str < 2400) {
                 switch (strlen($str)) {
-                case 2:
+                    case 2:
                         $str = sprintf('0:%02d:%02d:00', $str{0}, $str{1});
-                    break;
-                case 3:
-                    $str = sprintf('0:%02d:%02d:00', $str{0}, $str{1} . $str{2});
-                    break;
-                case 4:
-                    $str = sprintf('0:%02d:%02d:00', $str{0} . $str{1}, $str{2} . $str{3});
-                    break;
+                        break;
+                    case 3:
+                        $str = sprintf('0:%02d:%02d:00', $str{0}, $str{1} . $str{2});
+                        break;
+                    case 4:
+                        $str = sprintf('0:%02d:%02d:00', $str{0} . $str{1}, $str{2} . $str{3});
+                        break;
                 }
-            }
-            else {
+            } else {
                 return false;
             }
-        }
-        elseif (preg_match('/^(\d{0,2})\D(\d{1,2})$/', $str, $m)) {
+        } elseif (preg_match('/^(\d{0,2})\D(\d{1,2})$/', $str, $m)) {
             if ($m[1] < 24 and $m[2] < 60) {
                 $str = sprintf('0:%02d:%02d:00', $m[1], $m[2]);
-            }
-            elseif ($m[1] == 24 and $m[2] == 0) {
+            } elseif ($m[1] == 24 and $m[2] == 0) {
                 $str = '1:00:00:00';
-            }
-            else {
+            } else {
                 return false;
             }
-        }
-        elseif (preg_match('/^(\d{0,2})\D(\d{1,2})\D(\d{1,2})$/', $str, $m)) {
+        } elseif (preg_match('/^(\d{0,2})\D(\d{1,2})\D(\d{1,2})$/', $str, $m)) {
             if ($m[1] < 24 and $m[2] < 60 and $m[3] < 60) {
                 $str = sprintf('0:%02d:%02d:%02d', $m[1], $m[2], $m[3]);
-            }
-            elseif ($m[1] == 24 and $m[2] == 0 and $m[3] == 0) {
+            } elseif ($m[1] == 24 and $m[2] == 0 and $m[3] == 0) {
                 $str = '1:00:00:00';
-            }
-            else {
+            } else {
                 return false;
             }
-        }
-        else {
+        } else {
             return false;
         }
         $this->setFromString($str, "%D:%H:%M:%S");
         return true;
     }
 
-    function get
-        () {
+    function get()
+    {
         return $this->format("%E:%M");
     }
 

diff --git a/lib/MECON/Tiempo/Intervalo.php b/lib/MECON/Tiempo/Intervalo.php
index 01a005de29e5854bcddc94c78cc371d355768c09..3fff5b402d6c19eca00e79d21102ceb419f45eb4 100644 (file)
--- a/lib/MECON/Tiempo/Intervalo.php
+++ b/lib/MECON/Tiempo/Intervalo.php
@@ -59,15 +59,14 @@ class MECON_Tiempo_Intervalo {
      *                       fin es anterior a la de inicio.
      *                       
      */
-    function MECON_Tiempo_Intervalo( $inicio = null, $fin = null, $chequear = true ) {
-        if (is_null($inicio))
+    function MECON_Tiempo_Intervalo($inicio = null, $fin = null, $chequear = true)
+    {
+        if (!$inicio) {
             $inicio = new MECON_Tiempo_Hora;
-        if (is_null($fin))
+        }
+        if (!$fin) {
             $fin = new MECON_Tiempo_Hora;
-        if(!is_a($inicio, 'mecon_tiempo_hora'))
-            return false;
-        if(!is_a($fin,    'mecon_tiempo_hora'))
-            return false;
+        }
         $this->inicio = $inicio;
         $this->fin    = $fin;
         if ($chequear) {
@@ -75,7 +74,8 @@ class MECON_Tiempo_Intervalo {
         }
     }
 
-    function _chequear() {
+    function _chequear()
+    {
         $a = $this->fin;
         if($a->lower($this->inicio)) {
             $tmp = $this->fin;
@@ -84,13 +84,12 @@ class MECON_Tiempo_Intervalo {
         }
     }
 
-    function invertido() {
+    function invertido()
+    {
         return $this->fin->lower($this->inicio);
     }
 
-    function setInicio( $inicio ) {
-        if(! is_a($inicio, 'mecon_tiempo_hora'))
-            return false;
+    function setInicio($inicio) {
         $this->inicio = $inicio;
         $this->_chequear();
     }
@@ -102,14 +101,14 @@ class MECON_Tiempo_Intervalo {
      * @param var $fin
      *
      */
-    function setFin( $fin ) {
-        if(! is_a($fin,'mecon_tiempo_hora'))
-            return false;
+    function setFin($fin)
+    {
         $this->fin = $fin;
         $this->_chequear();
     }
 
-    function getDuracion() {
+    function getDuracion()
+    {
         $c = new MECON_Tiempo_Hora;
         $c->copy($this->fin);
         $c->subtract($this->inicio);
@@ -118,43 +117,50 @@ class MECON_Tiempo_Intervalo {
 
     // XXX - Amplié el método para comparar con varios intervalos a la vez,
     // si el argumento no es un array, anda de todas maneras.
-    function seSuperpone( $intervalos ) {
-        if (!is_array($intervalos))
+    function seSuperpone($intervalos)
+    {
+        if (!is_array($intervalos)) {
             $intervalos = array($intervalos);
+        }
         foreach ($intervalos as $i) {
-            if (is_a($i, 'mecon_tiempo_intervalo')) {
-                if ($i->fin->greaterEqual($this->inicio) &&
-                        $this->fin->greaterEqual($i->inicio))
-                    return true;
-                if ($this->fin->greaterEqual($i->inicio) &&
-                        $i->fin->greaterEqual($this->inicio))
-                    return true;
+            if ($i->fin->greater($this->inicio) &&
+                    $this->fin->greater($i->inicio))
+            {
+                return true;
+            }
+            if ($this->fin->greater($i->inicio) &&
+                    $i->fin->greater($this->inicio))
+            {
+                return true;
             }
         }
         return false;
     }
 
-    function fusionar( $f ) {
-        if(! is_a($f, 'mecon_tiempo_intervalo'))
-            return false;
-        if(! $this->seSuperpone( $f ))
+    function fusionar($f)
+    {
+        if (!$this->seSuperpone($f)) {
             return false;
-        if($f->fin->greater($this->fin))
+        }
+        if ($f->fin->greater($this->fin)) {
             $this->fin = $f->fin;
-        if($f->inicio->lower($this->inicio))
+        }
+        if ($f->inicio->lower($this->inicio)) {
             $this->inicio = $f->inicio;
+        }
         return true;
     }
 
-    function superponer( $i ) {
-        if(! is_a($i, 'mecon_tiempo_intervalo'))
-            return false;
+    function superponer($i)
+    {
         $inicio = $this->inicio;
         $fin = $this->fin;
-        if($this->inicio->lower($i->inicio))
+        if ($this->inicio->lower($i->inicio)) {
             $inicio = $i->inicio;
-        if($this->fin->greater( $i->fin   ))
+        }
+        if ($this->fin->greater($i->fin)) {
             $fin = $i->fin;
+        }
         $fin->subtract($inicio);
         return $fin;
     }
@@ -168,14 +174,13 @@ class MECON_Tiempo_Intervalo {
      *
      * @return object Intervalo Intervalo anterior al punto de corte.
      */
-    function cortar($c) {
+    function cortar($c)
+    {
         if(is_a($c, 'mecon_tiempo_hora')) {
             return $this->cortarHora($c);
-        }
-        elseif (is_a($c, 'mecon_tiempo_intervalo')) {
+        } elseif (is_a($c, 'mecon_tiempo_intervalo')) {
             return $this->cortarIntervalo($c);
-        }
-        else {
+        } else {
             return false;
         }
     }
@@ -188,9 +193,8 @@ class MECON_Tiempo_Intervalo {
      *
      * @return object Intervalo Intervalo anterior a la hora de corte.
      */
-    function cortarHora($h) {
-        if (!is_a($h, 'mecon_tiempo_hora'))
-            return false;
+    function cortarHora($h)
+    {
         $class = get_class($this);
         $r = new $class;
         $r->copy($this);
@@ -215,9 +219,8 @@ class MECON_Tiempo_Intervalo {
      *
      * @return object Intervalo Intervalo anterior al intervalo de corte.
      */
-    function cortarIntervalo($i) {
-        if (!is_a($i, 'mecon_tiempo_intervalo'))
-            return false;
+    function cortarIntervalo($i)
+    {
         $ant = $this->cortarHora($i->inicio);
         $this->cortarHora($i->fin);
         return $ant;
@@ -227,21 +230,18 @@ class MECON_Tiempo_Intervalo {
         return 'inicio: ' . $this->inicio->format() . ' | fin: ' . $this->fin->format();
     }
 
-    function copy($int = null) {
-        if (!(is_a($int, 'mecon_tiempo_intervalo')))
-            return false;
-        $this->inicio = new MECON_Tiempo_Hora($int->inicio->get
-                                 ());
-        $this->fin = new MECON_Tiempo_Hora($int->fin->get
-                              ());
+    function copy($i)
+    {
+        $this->inicio = $i->inicio->__clone();
+        $this->fin    = $i->fin->__clone();
         return true;
     }
 
-    function __clone() {
+    function __clone()
+    {
         $class = get_class($this);
         $i = new $class;
-        $i->inicio = $this->inicio->__clone();
-        $i->fin    = $this->fin->__clone();
+        $i->copy($this);
         return $i;
     }