ondrej-bouda / ivory

src/Ivory/Value/BitString.php

Indentation +369 added lines, -369 removed lines

@@ -23,382 +23,382 @@
  */
 abstract class BitString implements IComparable, \ArrayAccess
 {
-	protected $bits;
-	protected $len;
-
-
-	/**
-	 * @param string $bits
-	 */
-	protected function __construct($bits)
-	{
-		if (!preg_match('~^[01]*$~', $bits)) {
-			throw new \InvalidArgumentException('bits');
-		}
-
-		$this->bits = $bits;
-		$this->len = strlen($bits);
-	}
-
-
-	/**
-	 * @return string textual representation of this bit string (index 0 is the leftmost bit): a string of 1's and 0's
-	 */
-	public function toString()
-	{
-		return $this->bits;
-	}
-
-	/**
-	 * @return int number of bits in the bit string
-	 */
-	public function getLength()
-	{
-		return $this->len;
-	}
-
-	/**
-	 * @return bool whether all the bits are zero
-	 */
-	public function isZero()
-	{
-		return !$this->isNonZero();
-	}
-
-	/**
-	 * @return bool whether some bit is one
-	 */
-	public function isNonZero()
-	{
-		for ($i = 0; $i < $this->len; $i++) {
-			if ($this->bits[$i] == '1') {
-				return true;
-			}
-		}
-
-		return false;
-	}
-
-	/**
-	 * @param BitString $other
-	 * @return bool whether this and the other bit string are of the same type, have the same bits and same length
-	 */
-	public function equals($other)
-	{
-		if ($other === null) {
-			return null;
-		}
-		return (get_class($this) == get_class($other) && $this->bits == $other->bits);
-	}
-
-	/**
-	 * @param BitString $other any bit string of any length
-	 * @return bool whether this and the other bit string have the same bits, i.e., are the same 1's and 0's strings
-	 */
-	public function bitEquals(BitString $other)
-	{
-		return ($this->bits === $other->bits); // ===: PHP would otherwise convert both strings to integers
-	}
-
-	/**
-	 * Finds out whether the operands intersect at a 1 bit.
-	 *
-	 * Works for any lengths of the bit strings. The shorter bit string is right-padded with 0's.
-	 *
-	 * @param BitString $other any bit string of any length
-	 * @return bool whether this and the other bit string share at least one set bit at the same offset
-	 */
-	public function intersects(BitString $other)
-	{
-		for ($i = min($this->len, $other->len) - 1; $i >= 0; $i--) {
-			if ($this->bits[$i] == '1' && $other->bits[$i] == '1') {
-				return true;
-			}
-		}
-
-		return false;
-	}
-
-	/**
-	 * Extracts a bit substring from this bit string.
-	 *
-	 * Note the semantics are according to the SQL standard, which PostgreSQL implements. That is, the arguments do NOT
-	 * work the same as for PHP {@link substr()} function.
-	 *
-	 * Examples:
-	 * - `substring(2)` on `'1101001'` yields `'101001'`
-	 * - `substring(2, 4)` on `'1101001'` yields `'1010'`
-	 * - `substring(2, 0)` on `'1101001'` yields `''`
-	 * - `substring(-2, 4)` on `'1101001'` yields `'1'`
-	 *
-	 * @param int $from position to start at;
-	 *                  one-based - e.g., <tt>$from = 2</tt> omits the first character;
-	 *                  if less than one, it yields the start of the string, but counting from the given (negative or
-	 *                    zero) position, effectively decreasing the <tt>$for</tt> argument, if given
-	 * @param int|null $for number of characters to take; must be non-negative;
-	 *                      <tt>null</tt> for the rest of the string
-	 * @return FixedBitString the substring of the bit string
-	 * @throws UndefinedOperationException when <tt>$for</tt> is negative
-	 */
-	public function substring($from, $for = null)
-	{
-		if ($for < 0) {
-			throw new UndefinedOperationException('negative number of bits to take');
-		}
-
-		$offset = max(0, $from - 1);
-		if ($offset >= $this->len) {
-			return FixedBitString::fromString('');
-		}
-
-		if ($for === null) {
-			$len = $this->len;
-		}
-		elseif ($from >= 0) {
-			$len = $for;
-		}
-		else {
-			$len = max(0, $for + $from - 1);
-		}
-
-		return FixedBitString::fromString(substr($this->bits, $offset, $len));
-	}
-
-	/**
-	 * Concatenates this bit string with another one.
-	 *
-	 * The result is a bit string with bits of this bit string followed by the bits from the `$concatenated` bit string.
-	 *
-	 * If both the operands are fixed-length of length `A` and `B`, the result is a fixed-length bit string of length
-	 * `A+B`. Otherwise, the result is a variable-length bit string.
-	 *
-	 * @param BitString $concatenated
-	 * @return VarBitString bit string made up by concatenating the <tt>$concatenated</tt> after this bit string
-	 */
-	public function concat(BitString $concatenated)
-	{
-		return VarBitString::fromString($this->bits . $concatenated->bits);
-	}
-
-	/**
-	 * Bitwise AND operation. Only legal for operands of equal bit lengths.
-	 *
-	 * @param BitString $other the other operand
-	 * @return FixedBitString new bit string: <tt>$this & $other</tt>
-	 * @throws UndefinedOperationException if the operands are of different bit lengths
-	 */
-	public function bitAnd(BitString $other)
-	{
-		if ($this->len != $other->len) {
-			throw new UndefinedOperationException('operands are of different bit lengths');
-		}
-
-		$res = str_repeat('0', $this->len);
-		for ($i = 0; $i < $this->len; $i++) {
-			if ($this->bits[$i] == '1' && $other->bits[$i] == '1') {
-				$res[$i] = '1';
-			}
-		}
-
-		return FixedBitString::fromString($res);
-	}
-
-	/**
-	 * Bitwise OR operation. Only legal for operands of equal bit lengths.
-	 *
-	 * @param BitString $other the other operand
-	 * @return FixedBitString new bit string: <tt>$this | $other</tt>
-	 * @throws UndefinedOperationException if the operands are of different bit lengths
-	 */
-	public function bitOr(BitString $other)
-	{
-		if ($this->len != $other->len) {
-			throw new UndefinedOperationException('operands are of different bit lengths');
-		}
-
-		$res = str_repeat('1', $this->len);
-		for ($i = 0; $i < $this->len; $i++) {
-			if ($this->bits[$i] == '0' && $other->bits[$i] == '0') {
-				$res[$i] = '0';
-			}
-		}
-
-		return FixedBitString::fromString($res);
-	}
-
-	/**
-	 * Bitwise exclusive OR operation. Only legal for operands of equal bit lengths.
-	 *
-	 * @param BitString $other the other operand
-	 * @return FixedBitString new bit string: <tt>$this ^ $other</tt>
-	 * @throws UndefinedOperationException if the operands are of different bit lengths
-	 */
-	public function bitXor(BitString $other)
-	{
-		if ($this->len != $other->len) {
-			throw new UndefinedOperationException('operands are of different bit lengths');
-		}
-
-		$res = str_repeat('0', $this->len);
-		for ($i = 0; $i < $this->len; $i++) {
-			if ($this->bits[$i] != $other->bits[$i]) {
-				$res[$i] = '1';
-			}
-		}
-
-		return FixedBitString::fromString($res);
-	}
-
-	/**
-	 * Bitwise negation, i.e., reverses all bits of the bit string.
-	 *
-	 * @return FixedBitString new bit string: <tt>~$this</tt>
-	 */
-	public function bitNot()
-	{
-		return FixedBitString::fromString(strtr($this->bits, '01', '10'));
-	}
-
-	/**
-	 * Shifts the bits to the left.
-	 *
-	 * The length of the bit string is preserved, thus, the `$shift` left trailing bits are discarded. The shifted bit
-	 * positions are filled with 0's.
-	 *
-	 * @param int $shift number of positions to shift the bits to the left;
-	 *                   might even be negative (results in shifting to the right by <tt>-$shift</tt>)
-	 * @return FixedBitString a bit string with bits shifted by <tt>$shift</tt> to the left
-	 */
-	public function bitShiftLeft($shift)
-	{
-		if ($shift < 0) {
-			return $this->bitShiftRight(-$shift);
-		}
-
-		$pad = min($this->len, $shift);
-		$prefix = ($pad == $this->len ? '' : substr($this->bits, $pad));
-		return FixedBitString::fromString($prefix . str_repeat('0', $pad));
-	}
-
-	/**
-	 * Shifts the bits to the right.
-	 *
-	 * The length of the bit string is preserved, thus, the `$shift` right trailing bits are discarded. The shifted bit
-	 * positions are filled with 0's.
-	 *
-	 * @param int $shift number of positions to shift the bits to the right;
-	 *                   might even be negative (results in shifting to the left by <tt>-$shift</tt>)
-	 * @return FixedBitString a bit string with bits shifted by <tt>$shift</tt> to the right
-	 */
-	public function bitShiftRight($shift)
-	{
-		if ($shift < 0) {
-			return $this->bitShiftLeft(-$shift);
-		}
-
-		$pad = min($this->len, $shift);
-		$postfix = substr($this->bits, 0, $this->len - $pad);
-		return FixedBitString::fromString(str_repeat('0', $pad) . $postfix);
-	}
-
-	/**
-	 * Rotates the bits to the left.
-	 *
-	 * @param int $rot the length of the rotation
-	 * @return FixedBitString a bit string with <tt>$rot</tt> (mod length) leftmost bits moved to the back of the bit
-	 *                          string
-	 */
-	public function bitRotateLeft($rot)
-	{
-		if ($rot < 0) {
-			return $this->bitRotateRight(-$rot);
-		}
-		if ($this->len == 0) {
-			return FixedBitString::fromString('');
-		}
-
-		$pos = $rot % $this->len;
-		return FixedBitString::fromString(substr($this->bits, $pos) . substr($this->bits, 0, $pos));
-	}
-
-	/**
-	 * Rotates the bits to the right.
-	 *
-	 * @param int $rot the length of the rotation
-	 * @return FixedBitString a bit string with <tt>$rot</tt> (mod length) rightmost bits moved to the front of the bit
-	 *                          string
-	 */
-	public function bitRotateRight($rot)
-	{
-		if ($rot < 0) {
-			return $this->bitRotateLeft(-$rot);
-		}
-		if ($this->len == 0) {
-			return FixedBitString::fromString('');
-		}
-
-		$pos = $this->len - ($rot % $this->len);
-		return FixedBitString::fromString(substr($this->bits, $pos) . substr($this->bits, 0, $pos));
-	}
-
-
-	public function __toString()
-	{
-		return $this->toString();
-	}
-
-
-	/**
-	 * @param int $offset the bit to know existence of; 0 for the leftmost bit, 1 for the next bit, -1 for the rightmost
+    protected $bits;
+    protected $len;
+
+
+    /**
+     * @param string $bits
+     */
+    protected function __construct($bits)
+    {
+        if (!preg_match('~^[01]*$~', $bits)) {
+            throw new \InvalidArgumentException('bits');
+        }
+
+        $this->bits = $bits;
+        $this->len = strlen($bits);
+    }
+
+
+    /**
+     * @return string textual representation of this bit string (index 0 is the leftmost bit): a string of 1's and 0's
+     */
+    public function toString()
+    {
+        return $this->bits;
+    }
+
+    /**
+     * @return int number of bits in the bit string
+     */
+    public function getLength()
+    {
+        return $this->len;
+    }
+
+    /**
+     * @return bool whether all the bits are zero
+     */
+    public function isZero()
+    {
+        return !$this->isNonZero();
+    }
+
+    /**
+     * @return bool whether some bit is one
+     */
+    public function isNonZero()
+    {
+        for ($i = 0; $i < $this->len; $i++) {
+            if ($this->bits[$i] == '1') {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * @param BitString $other
+     * @return bool whether this and the other bit string are of the same type, have the same bits and same length
+     */
+    public function equals($other)
+    {
+        if ($other === null) {
+            return null;
+        }
+        return (get_class($this) == get_class($other) && $this->bits == $other->bits);
+    }
+
+    /**
+     * @param BitString $other any bit string of any length
+     * @return bool whether this and the other bit string have the same bits, i.e., are the same 1's and 0's strings
+     */
+    public function bitEquals(BitString $other)
+    {
+        return ($this->bits === $other->bits); // ===: PHP would otherwise convert both strings to integers
+    }
+
+    /**
+     * Finds out whether the operands intersect at a 1 bit.
+     *
+     * Works for any lengths of the bit strings. The shorter bit string is right-padded with 0's.
+     *
+     * @param BitString $other any bit string of any length
+     * @return bool whether this and the other bit string share at least one set bit at the same offset
+     */
+    public function intersects(BitString $other)
+    {
+        for ($i = min($this->len, $other->len) - 1; $i >= 0; $i--) {
+            if ($this->bits[$i] == '1' && $other->bits[$i] == '1') {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Extracts a bit substring from this bit string.
+     *
+     * Note the semantics are according to the SQL standard, which PostgreSQL implements. That is, the arguments do NOT
+     * work the same as for PHP {@link substr()} function.
+     *
+     * Examples:
+     * - `substring(2)` on `'1101001'` yields `'101001'`
+     * - `substring(2, 4)` on `'1101001'` yields `'1010'`
+     * - `substring(2, 0)` on `'1101001'` yields `''`
+     * - `substring(-2, 4)` on `'1101001'` yields `'1'`
+     *
+     * @param int $from position to start at;
+     *                  one-based - e.g., <tt>$from = 2</tt> omits the first character;
+     *                  if less than one, it yields the start of the string, but counting from the given (negative or
+     *                    zero) position, effectively decreasing the <tt>$for</tt> argument, if given
+     * @param int|null $for number of characters to take; must be non-negative;
+     *                      <tt>null</tt> for the rest of the string
+     * @return FixedBitString the substring of the bit string
+     * @throws UndefinedOperationException when <tt>$for</tt> is negative
+     */
+    public function substring($from, $for = null)
+    {
+        if ($for < 0) {
+            throw new UndefinedOperationException('negative number of bits to take');
+        }
+
+        $offset = max(0, $from - 1);
+        if ($offset >= $this->len) {
+            return FixedBitString::fromString('');
+        }
+
+        if ($for === null) {
+            $len = $this->len;
+        }
+        elseif ($from >= 0) {
+            $len = $for;
+        }
+        else {
+            $len = max(0, $for + $from - 1);
+        }
+
+        return FixedBitString::fromString(substr($this->bits, $offset, $len));
+    }
+
+    /**
+     * Concatenates this bit string with another one.
+     *
+     * The result is a bit string with bits of this bit string followed by the bits from the `$concatenated` bit string.
+     *
+     * If both the operands are fixed-length of length `A` and `B`, the result is a fixed-length bit string of length
+     * `A+B`. Otherwise, the result is a variable-length bit string.
+     *
+     * @param BitString $concatenated
+     * @return VarBitString bit string made up by concatenating the <tt>$concatenated</tt> after this bit string
+     */
+    public function concat(BitString $concatenated)
+    {
+        return VarBitString::fromString($this->bits . $concatenated->bits);
+    }
+
+    /**
+     * Bitwise AND operation. Only legal for operands of equal bit lengths.
+     *
+     * @param BitString $other the other operand
+     * @return FixedBitString new bit string: <tt>$this & $other</tt>
+     * @throws UndefinedOperationException if the operands are of different bit lengths
+     */
+    public function bitAnd(BitString $other)
+    {
+        if ($this->len != $other->len) {
+            throw new UndefinedOperationException('operands are of different bit lengths');
+        }
+
+        $res = str_repeat('0', $this->len);
+        for ($i = 0; $i < $this->len; $i++) {
+            if ($this->bits[$i] == '1' && $other->bits[$i] == '1') {
+                $res[$i] = '1';
+            }
+        }
+
+        return FixedBitString::fromString($res);
+    }
+
+    /**
+     * Bitwise OR operation. Only legal for operands of equal bit lengths.
+     *
+     * @param BitString $other the other operand
+     * @return FixedBitString new bit string: <tt>$this | $other</tt>
+     * @throws UndefinedOperationException if the operands are of different bit lengths
+     */
+    public function bitOr(BitString $other)
+    {
+        if ($this->len != $other->len) {
+            throw new UndefinedOperationException('operands are of different bit lengths');
+        }
+
+        $res = str_repeat('1', $this->len);
+        for ($i = 0; $i < $this->len; $i++) {
+            if ($this->bits[$i] == '0' && $other->bits[$i] == '0') {
+                $res[$i] = '0';
+            }
+        }
+
+        return FixedBitString::fromString($res);
+    }
+
+    /**
+     * Bitwise exclusive OR operation. Only legal for operands of equal bit lengths.
+     *
+     * @param BitString $other the other operand
+     * @return FixedBitString new bit string: <tt>$this ^ $other</tt>
+     * @throws UndefinedOperationException if the operands are of different bit lengths
+     */
+    public function bitXor(BitString $other)
+    {
+        if ($this->len != $other->len) {
+            throw new UndefinedOperationException('operands are of different bit lengths');
+        }
+
+        $res = str_repeat('0', $this->len);
+        for ($i = 0; $i < $this->len; $i++) {
+            if ($this->bits[$i] != $other->bits[$i]) {
+                $res[$i] = '1';
+            }
+        }
+
+        return FixedBitString::fromString($res);
+    }
+
+    /**
+     * Bitwise negation, i.e., reverses all bits of the bit string.
+     *
+     * @return FixedBitString new bit string: <tt>~$this</tt>
+     */
+    public function bitNot()
+    {
+        return FixedBitString::fromString(strtr($this->bits, '01', '10'));
+    }
+
+    /**
+     * Shifts the bits to the left.
+     *
+     * The length of the bit string is preserved, thus, the `$shift` left trailing bits are discarded. The shifted bit
+     * positions are filled with 0's.
+     *
+     * @param int $shift number of positions to shift the bits to the left;
+     *                   might even be negative (results in shifting to the right by <tt>-$shift</tt>)
+     * @return FixedBitString a bit string with bits shifted by <tt>$shift</tt> to the left
+     */
+    public function bitShiftLeft($shift)
+    {
+        if ($shift < 0) {
+            return $this->bitShiftRight(-$shift);
+        }
+
+        $pad = min($this->len, $shift);
+        $prefix = ($pad == $this->len ? '' : substr($this->bits, $pad));
+        return FixedBitString::fromString($prefix . str_repeat('0', $pad));
+    }
+
+    /**
+     * Shifts the bits to the right.
+     *
+     * The length of the bit string is preserved, thus, the `$shift` right trailing bits are discarded. The shifted bit
+     * positions are filled with 0's.
+     *
+     * @param int $shift number of positions to shift the bits to the right;
+     *                   might even be negative (results in shifting to the left by <tt>-$shift</tt>)
+     * @return FixedBitString a bit string with bits shifted by <tt>$shift</tt> to the right
+     */
+    public function bitShiftRight($shift)
+    {
+        if ($shift < 0) {
+            return $this->bitShiftLeft(-$shift);
+        }
+
+        $pad = min($this->len, $shift);
+        $postfix = substr($this->bits, 0, $this->len - $pad);
+        return FixedBitString::fromString(str_repeat('0', $pad) . $postfix);
+    }
+
+    /**
+     * Rotates the bits to the left.
+     *
+     * @param int $rot the length of the rotation
+     * @return FixedBitString a bit string with <tt>$rot</tt> (mod length) leftmost bits moved to the back of the bit
+     *                          string
+     */
+    public function bitRotateLeft($rot)
+    {
+        if ($rot < 0) {
+            return $this->bitRotateRight(-$rot);
+        }
+        if ($this->len == 0) {
+            return FixedBitString::fromString('');
+        }
+
+        $pos = $rot % $this->len;
+        return FixedBitString::fromString(substr($this->bits, $pos) . substr($this->bits, 0, $pos));
+    }
+
+    /**
+     * Rotates the bits to the right.
+     *
+     * @param int $rot the length of the rotation
+     * @return FixedBitString a bit string with <tt>$rot</tt> (mod length) rightmost bits moved to the front of the bit
+     *                          string
+     */
+    public function bitRotateRight($rot)
+    {
+        if ($rot < 0) {
+            return $this->bitRotateLeft(-$rot);
+        }
+        if ($this->len == 0) {
+            return FixedBitString::fromString('');
+        }
+
+        $pos = $this->len - ($rot % $this->len);
+        return FixedBitString::fromString(substr($this->bits, $pos) . substr($this->bits, 0, $pos));
+    }
+
+
+    public function __toString()
+    {
+        return $this->toString();
+    }
+
+
+    /**
+     * @param int $offset the bit to know existence of; 0 for the leftmost bit, 1 for the next bit, -1 for the rightmost
      *                      bit, etc.
-	 * @return bool <tt>true</tt> if the bit string has <tt>$offset</tt>-th bit defined,
-	 *              <tt>false</tt> if the bit string is too short (i.e., shorter than <tt>$offset+1</tt> bits)
-	 */
-	public function offsetExists($offset)
-	{
-	    if ($offset < 0 && PHP_VERSION_ID < 70100) { // PHP < 7.1 did not support negative string offsets
+     * @return bool <tt>true</tt> if the bit string has <tt>$offset</tt>-th bit defined,
+     *              <tt>false</tt> if the bit string is too short (i.e., shorter than <tt>$offset+1</tt> bits)
+     */
+    public function offsetExists($offset)
+    {
+        if ($offset < 0 && PHP_VERSION_ID < 70100) { // PHP < 7.1 did not support negative string offsets
             $offset = $this->len + $offset;
         }
 
         return isset($this->bits[$offset]);
-	}
-
-	/**
-	 * @param int $offset the bit to get; 0 for the leftmost bit, 1 for the next bit, -1 for the rightmost bit, etc.
-	 * @return int|null 0 or 1 depending on whether the <tt>$offset</tt>-th bit is set, or
-	 *                  <tt>null</tt> if outside of the bit string
-	 */
-	public function offsetGet($offset)
-	{
+    }
+
+    /**
+     * @param int $offset the bit to get; 0 for the leftmost bit, 1 for the next bit, -1 for the rightmost bit, etc.
+     * @return int|null 0 or 1 depending on whether the <tt>$offset</tt>-th bit is set, or
+     *                  <tt>null</tt> if outside of the bit string
+     */
+    public function offsetGet($offset)
+    {
         if ($offset < 0 && PHP_VERSION_ID < 70100) { // PHP < 7.1 did not support negative string offsets
             $offset = $this->len + $offset;
         }
 
-		if (isset($this->bits[$offset])) {
-			return (int)$this->bits[$offset];
-		}
-		else {
-			return null;
-		}
-	}
-
-	/**
-	 * Setting a bit is not implemented - the bit string is immutable.
-	 *
-	 * @throws ImmutableException
-	 */
-	public function offsetSet($offset, $value)
-	{
-		throw new ImmutableException();
-	}
-
-	/**
-	 * Unsetting a bit is not implemented - the bit string is immutable.
-	 *
-	 * @throws ImmutableException
-	 */
-	public function offsetUnset($offset)
-	{
-		throw new ImmutableException();
-	}
+        if (isset($this->bits[$offset])) {
+            return (int)$this->bits[$offset];
+        }
+        else {
+            return null;
+        }
+    }
+
+    /**
+     * Setting a bit is not implemented - the bit string is immutable.
+     *
+     * @throws ImmutableException
+     */
+    public function offsetSet($offset, $value)
+    {
+        throw new ImmutableException();
+    }
+
+    /**
+     * Unsetting a bit is not implemented - the bit string is immutable.
+     *
+     * @throws ImmutableException
+     */
+    public function offsetUnset($offset)
+    {
+        throw new ImmutableException();
+    }
 }

Braces +3 added lines, -6 removed lines

@@ -153,11 +153,9 @@ 
 
 		if ($for === null) {
 			$len = $this->len;
-		}
-		elseif ($from >= 0) {
+		} elseif ($from >= 0) {
 			$len = $for;
-		}
-		else {
+		} else {
 			$len = max(0, $for + $from - 1);
 		}
 
@@ -376,8 +374,7 @@ 
 
 		if (isset($this->bits[$offset])) {
 			return (int)$this->bits[$offset];
-		}
-		else {
+		} else {
 			return null;
 		}
 	}

src/Ivory/Value/TimestampBase.php

Spacing +1 added lines, -1 removed lines

@@ -38,7 +38,7 @@
         $addYears = 0;
         $dateCreateInput = preg_replace_callback(
             '~\d{5,}(?=(?:-\d+-\d+|\d{4})(?:\s+|T)\d)~', // supports both dash-separated date/time parts and also the form without dash separators
-            function ($y) use (&$addYears) {
+            function($y) use (&$addYears) {
                 $res = $y[0] % 10000;
                 $addYears = $y[0] - $res;
                 return $res;

Braces +3 added lines, -6 removed lines

@@ -70,8 +70,7 @@ 
     {
         if ($float >= 10) {
             return (string)$float;
-        }
-        else {
+        } else {
             return '0' . (float)$float;
         }
     }
@@ -138,11 +137,9 @@ 
     {
         if ($this->inf) {
             return null;
-        }
-        elseif ($this->dt->format('u')) {
+        } elseif ($this->dt->format('u')) {
             return (float)$this->dt->format('s.u');
-        }
-        else {
+        } else {
             return (int)$this->dt->format('s');
         }
     }

src/Ivory/Value/PgLogSequenceNumber.php

Braces +1 added lines, -2 removed lines

@@ -33,8 +33,7 @@
         $scanned = sscanf($str, '%X/%X', $hi, $lo);
         if ($scanned == 2) {
             return new PgLogSequenceNumber($hi, $lo);
-        }
-        else {
+        } else {
             throw new \InvalidArgumentException('$str');
         }
     }

src/Ivory/Value/Polygon.php

Braces +2 added lines, -4 removed lines

@@ -28,11 +28,9 @@
         foreach ($points as $i => $point) {
             if ($point instanceof Point) {
                 $normalized[] = $point;
-            }
-            elseif (is_array($point)) {
+            } elseif (is_array($point)) {
                 $normalized[] = Point::fromCoords($point[0], $point[1]);
-            }
-            else {
+            } else {
                 throw new \InvalidArgumentException("points[$i]");
             }
         }

src/Ivory/Value/Box.php

Braces +2 added lines, -4 removed lines

@@ -25,15 +25,13 @@
     {
         if (is_array($corner)) {
             $corner = Point::fromCoords($corner);
-        }
-        elseif (!$corner instanceof Point) {
+        } elseif (!$corner instanceof Point) {
             throw new \InvalidArgumentException('corner');
         }
 
         if (is_array($oppositeCorner)) {
             $oppositeCorner = Point::fromCoords($oppositeCorner);
-        }
-        elseif (!$oppositeCorner instanceof Point) {
+        } elseif (!$oppositeCorner instanceof Point) {
             throw new \InvalidArgumentException('oppositeCorner');
         }
 

src/Ivory/Value/TimeTz.php

Braces +3 added lines, -6 removed lines

@@ -66,8 +66,7 @@ 
             if ($min > 0 || $sec > 0) {
                 throw new \OutOfRangeException('with hour 24, the minutes and seconds must be zero');
             }
-        }
-        elseif ($hour < 0 || $hour > 24) {
+        } elseif ($hour < 0 || $hour > 24) {
             throw new \OutOfRangeException('hours');
         }
 
@@ -81,11 +80,9 @@ 
 
         if (!isset($m['zone'])) {
             $offset = (new \DateTime())->getOffset();
-        }
-        elseif ($m['zone'] == 'Z') {
+        } elseif ($m['zone'] == 'Z') {
             $offset = 0;
-        }
-        else {
+        } else {
             $offset = $m['offh'] * 60 * 60;
             if (isset($m['offm'])) {
                 $offset += ($m['offh'] >= 0 ? 1 : -1) * $m['offm'] * 60;

src/Ivory/Value/TimeBase.php

Braces +5 added lines, -10 removed lines

@@ -34,11 +34,9 @@ 
 
         if ($s < 0) {
             throw new \OutOfRangeException('The resulting time underruns 00:00:00');
-        }
-        elseif ($s > 24 * 60 * 60) {
+        } elseif ($s > 24 * 60 * 60) {
             throw new \OutOfRangeException('The resulting time exceeds 24:00:00');
-        }
-        else {
+        } else {
             return $s;
         }
     }
@@ -57,8 +55,7 @@ 
             if ($minute > 0 || $second > 0) {
                 throw new \OutOfRangeException('with hour 24, the minutes and seconds must be zero');
             }
-        }
-        elseif ($hour < 0 || $hour > 24) {
+        } elseif ($hour < 0 || $hour > 24) {
             throw new \OutOfRangeException('hours');
         }
 
@@ -141,16 +138,14 @@ 
     {
         if ($date === null) {
             return $this->sec;
-        }
-        else {
+        } else {
             if (!$date instanceof Date) {
                 $date = Date::fromISOString($date);
             }
             $dayTs = $date->toUnixTimestamp();
             if ($dayTs !== null) {
                 return $dayTs + $this->sec;
-            }
-            else {
+            } else {
                 throw new \InvalidArgumentException('infinite date');
             }
         }

src/Ivory/Value/Circle.php

Braces +1 added lines, -2 removed lines

@@ -23,8 +23,7 @@
     {
         if (is_array($center)) {
             $center = Point::fromCoords($center);
-        }
-        elseif (!$center instanceof Point) {
+        } elseif (!$center instanceof Point) {
             throw new \InvalidArgumentException('center');
         }
 

src/Ivory/Value/TimestampTz.php

Braces +7 added lines, -14 removed lines

@@ -73,11 +73,9 @@ 
     {
         if ($dateTime instanceof \DateTimeImmutable) {
             return new TimestampTz(0, $dateTime);
-        }
-        elseif ($dateTime instanceof \DateTime) {
+        } elseif ($dateTime instanceof \DateTime) {
             return new TimestampTz(0, \DateTimeImmutable::createFromMutable($dateTime));
-        }
-        else {
+        } else {
             // there should not be any other implementation of \DateTimeInterface, but PHP is not that predictable
             return self::fromParts(
                 $dateTime->format('Y'),
@@ -138,8 +136,7 @@ 
                 $tz
             );
             return new TimestampTz(0, $dt);
-        }
-        else {
+        } else {
             $dt = self::isoStringToDateTime(
                 sprintf('%s%04d-01-01 00:00:00', ($z < 0 ? '-' : ''), abs($z)),
                 $tz
@@ -203,21 +200,18 @@ 
 
         if (filter_var($timezone, FILTER_VALIDATE_INT) !== false) {
             $tzSpec = ($timezone >= 0 ? '+' : '-') . gmdate('H:i', abs($timezone));
-        }
-        elseif (preg_match('~^([^:]+:\d+):\d+$~', $timezone, $m)) {
+        } elseif (preg_match('~^([^:]+:\d+):\d+$~', $timezone, $m)) {
             $tzSpec = $m[1];
             $msg = "PHP's DateTimeZone is unable to represent GMT offsets with precision to seconds. "
                 . "Cutting '$timezone' to '$tzSpec'";
             trigger_error($msg, E_USER_WARNING);
-        }
-        else {
+        } else {
             $tzSpec = $timezone;
         }
 
         try {
             return new \DateTimeZone($tzSpec);
-        }
-        catch (\Exception $e) {
+        } catch (\Exception $e) {
             throw new \InvalidArgumentException('$timezone', 0, $e);
         }
     }
@@ -247,8 +241,7 @@ 
     {
         if ($this->inf) {
             return null;
-        }
-        else {
+        } else {
             $y = (int)$this->dt->format('Y');
             $u = $this->dt->format('u');
             return [