project info updated

Author: s3b4stian

CHANGELOG.md

@@ -6,6 +6,26 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/) 
 and this project adheres to [Semantic Versioning](http://semver.org/).
 
+## [v3.0.0](https://github.com/linna/typed-array/compare/v2.0.1...v3.0.0) - 2020-XX-XX
+
+### Added
+- php 8.0 support
+- `ArrayArrayObject` class
+- `BoolArrayObject` class
+- `CallableArrayObject` class
+- `ClassArrayObject` class
+- `FloatArrayObject` class
+- `IntArrayObject` class
+- `ObjectArrayObject` class
+- `StringArrayObject` class
+
+### Changed
+- namespace from `Linna` to `Linna\TypedArrayObject`
+- type chek is performed als on method `ArrayObject->append()`
+
+### removed
+- `Linna\TypedArray` class
+
 ## [v2.0.1](https://github.com/linna/typed-array/compare/v2.0.0...v2.0.1) - 2020-03-23
 
 ### Added

README.md

@@ -23,58 +23,86 @@
 This package provide typed arrays for php as extension of native [ArrayObject](http://php.net/manual/en/class.arrayobject.php).  
 
 ## Requirements
-This package require php 7.1
+This package require php 8.0
 
 ## Installation
 With composer:
 ```
 composer require linna/typed-array
 ```
 
+## Classes
+
+| Name                  | Native Type Handled | Description                                          |
+|-----------------------|---------------------|------------------------------------------------------|
+| `ArrayArrayObject`    | array               |                                                      |
+| `BoolArrayObject`     | bool                |                                                      |
+| `CallableArrayObject` | callable            |                                                      |
+| `ClassArrayObject`    | any existing class  | passed as first argument in constructor as `::class` |
+| `FloatArrayObject`    | float               |                                                      |
+| `IntArrayObject`      | int                 |                                                      |
+| `ObjectArrayObject`   | object              |                                                      |
+| `StringArrayObject`   | string              |                                                      |
+
+
 ## Usage
 ```php
-use Linna\TypedArray;
+use Linna\TypedArrayObject\IntArrayObject;
+use Linna\TypedArrayObject\ClassArrayObject;
 
 //correct, only int passed to constructor.
-$intArray = new TypedArray('int', [1, 2, 3, 4]);
+$intArray = new IntArrayObject([1, 2, 3, 4]);
 
 //correct, int assigned
 $intArray[] = 5;
-
-//throw InvalidArgumentException, string assigned.
+//throw InvalidArgumentException, string assigned, int expected.
 $intArray[] = 'a';
 
+//correct, int used
+$intArray->append(5);
+//throw InvalidArgumentException, string used, int expected.
+$intArray->append('a');
+
 //throw InvalidArgumentException, mixed array passed to constructor.
-$otherIntArray = new TypedArray('int', [1, 'a', 3, 4]);
+$otherIntArray = new IntArrayObject([1, 'a', 3, 4]);
 
 //correct, only Foo class instances passed to constructor.
-$fooArray = new TypedArray(Foo::class, [
+$fooArray = new ClassArrayObject(Foo::class, [
     new Foo(),
     new Foo()
 ]);
 
 //correct, Foo() instance assigned.
 $fooArray[] = new Foo();
-
 //throw InvalidArgumentException, Bar() instance assigned.
 $fooArray[] = new Bar();
 
+//correct, Foo() instance used.
+$fooArray->append(new Foo());
+//throw InvalidArgumentException, Bar() instance used, Foo() instance expected.
+$fooArray->append(new Bar());
+
 //throw InvalidArgumentException, mixed array of instances passed to constructor.
-$otherFooArray = new TypedArray(Foo::class, [
+$otherFooArray = new ClassArrayObject(Foo::class, [
     new Foo(),
     new Bar()
 ]);
 ```
 
 > **Note:** Allowed types are: *array*, *bool*, *callable*, *float*, *int*, *object*, *string* and all existing classes.
 
+## Performance consideration for v3.0
+Compared to previous versions of the library, this version is a bit faster because every types has it own class.
+
+![Array Speed Test](array-speed-test-v3.png)
+
 ## Performance consideration for v2.0
 Compared to first version of the library, this version is a bit slower because after merging `TypedObjectArray` with `TypedArray`,
 there are more code that be executed when new instance is created and on assign operations.
 
 ![Array Speed Test](array-speed-test-v2.png)
 
-## Performance consideration
+## Performance consideration for v1.0
 Compared to the parent class [ArrayObject](http://php.net/manual/en/class.arrayobject.php) typed arrays are slower on writing
 approximately from 6x to 8x. The slowness is due to not native `__construct()` and not native `offsetSet()`.  
 Other operations do not have a speed difference with the native ArrayObject.

array-speed-test-v3.png

@@ -33,9 +33,14 @@ class ArrayArrayObject extends ArrayObject
      */
     public function __construct(array $input = [], int $flags = 0, string $iterator_class = "ArrayIterator")
     {
-        //to avoid foreach, compare sizes of array
-        //before and after apply a filter :)
-        if (\count($input) > \count(\array_filter($input, 'is_array'))) {
+        //get input array len
+        $count = \count($input);
+        //check for invalid values inside provided array
+        //for is simple than previosu solution
+        for ($i = 0; $i < $count; $i++) {
+            if (\is_array($input[$i])) {
+                continue;
+            }
             throw new InvalidArgumentException(self::EXC_MESSAGE);
         }
 

src/Linna/TypedArrayObject/ArrayArrayObject.php

@@ -33,9 +33,14 @@ class BoolArrayObject extends ArrayObject
      */
     public function __construct(array $input = [], int $flags = 0, string $iterator_class = "ArrayIterator")
     {
-        //to avoid foreach, compare sizes of array
-        //before and after apply a filter :)
-        if (\count($input) > \count(\array_filter($input, 'is_bool'))) {
+        //get input array len
+        $count = \count($input);
+        //check for invalid values inside provided array
+        //for is simple than previosu solution
+        for ($i = 0; $i < $count; $i++) {
+            if (\is_bool($input[$i])) {
+                continue;
+            }
             throw new InvalidArgumentException(self::EXC_MESSAGE);
         }
 

src/Linna/TypedArrayObject/BoolArrayObject.php

@@ -33,9 +33,14 @@ class CallableArrayObject extends ArrayObject
      */
     public function __construct(array $input = [], int $flags = 0, string $iterator_class = "ArrayIterator")
     {
-        //to avoid foreach, compare sizes of array
-        //before and after apply a filter :)
-        if (\count($input) > \count(\array_filter($input, 'is_callable'))) {
+        //get input array len
+        $count = \count($input);
+        //check for invalid values inside provided array
+        //for is simple than previosu solution
+        for ($i = 0; $i < $count; $i++) {
+            if (\is_callable($input[$i])) {
+                continue;
+            }
             throw new InvalidArgumentException(self::EXC_MESSAGE);
         }
 

src/Linna/TypedArrayObject/CallableArrayObject.php

@@ -42,11 +42,13 @@ public function __construct(string $class, array $input = [], int $flags = 0, st
             throw new InvalidArgumentException("Type <{$this->type}> provided isn't a class.");
         }
 
-        //to avoid foreach, compare sizes of array
-        //before and after apply a filter :)
-        if (\count($input) > \count(\array_filter($input, function ($e) use ($class) {
-            return $e instanceof $class;
-        }))) {
+        //get input array len
+        $count = \count($input);
+        //check for invalid values inside provided array
+        for ($i = 0; $i < $count; $i++) {
+            if ($input[$i] instanceof $class) {
+                continue;
+            }
             throw new InvalidArgumentException("Elements passed must be of the type <{$this->type}>.");
         }
 

src/Linna/TypedArrayObject/ClassArrayObject.php

@@ -33,9 +33,14 @@ class FloatArrayObject extends ArrayObject
      */
     public function __construct(array $input = [], int $flags = 0, string $iterator_class = "ArrayIterator")
     {
-        //to avoid foreach, compare sizes of array
-        //before and after apply a filter :)
-        if (\count($input) > \count(\array_filter($input, 'is_float'))) {
+        //get input array len
+        $count = \count($input);
+        //check for invalid values inside provided array
+        //for is simple than previosu solution
+        for ($i = 0; $i < $count; $i++) {
+            if (\is_float($input[$i])) {
+                continue;
+            }
             throw new InvalidArgumentException(self::EXC_MESSAGE);
         }
 

src/Linna/TypedArrayObject/FloatArrayObject.php

@@ -33,9 +33,14 @@ class IntArrayObject extends ArrayObject
      */
     public function __construct(array $input = [], int $flags = 0, string $iterator_class = "ArrayIterator")
     {
-        //to avoid foreach, compare sizes of array
-        //before and after apply a filter :)
-        if (\count($input) > \count(\array_filter($input, 'is_int'))) {
+        //get input array len
+        $count = \count($input);
+        //check for invalid values inside provided array
+        //for is simple than previosu solution
+        for ($i = 0; $i < $count; $i++) {
+            if (\is_int($input[$i])) {
+                continue;
+            }
             throw new InvalidArgumentException(self::EXC_MESSAGE);
         }
 

src/Linna/TypedArrayObject/IntArrayObject.php

@@ -33,9 +33,14 @@ class ObjectArrayObject extends ArrayObject
      */
     public function __construct(array $input = [], int $flags = 0, string $iterator_class = "ArrayIterator")
     {
-        //to avoid foreach, compare sizes of array
-        //before and after apply a filter :)
-        if (\count($input) > \count(\array_filter($input, 'is_object'))) {
+        //get input array len
+        $count = \count($input);
+        //check for invalid values inside provided array
+        //for is simple than previosu solution
+        for ($i = 0; $i < $count; $i++) {
+            if (\is_object($input[$i])) {
+                continue;
+            }
             throw new InvalidArgumentException(self::EXC_MESSAGE);
         }