VersionManager::getAggregateRootVersion() - Code Metrics - cubiche/event-sourcing - Measure and Improve Code Quality continuously with Scrutinizer

VersionManager::getAggregateRootVersion() A
last analyzed 2017-05-10 13:18 UTC

↳ Parent: VersionManager

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	4
rs	10
c	0
b	0
f	0
cc	1
eloc	2
nc	1
nop	1

<?php

/**
 * This file is part of the Cubiche package.
 *
 * Copyright (c) Cubiche
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Cubiche\Domain\EventSourcing\Versioning;

use Cubiche\Domain\EventSourcing\EventSourcedAggregateRootInterface;

/**
 * VersionManager class.
 *
 * @author Ivannis Suárez Jerez <[email protected]>
 */
class VersionManager
{
    /**
     * @var VersionManager
     */
    private static $instance = null;

    /**
     * @var VersionStoreInterface
     */
    protected $versionStore;

    /**
     * VersionManager constructor.
     *
     * @param VersionStoreInterface $versionStore
     */
    private function __construct(VersionStoreInterface $versionStore)
    {
        $this->versionStore = $versionStore;
    }

    /**
     * @return VersionManager
     */
    public static function create()
    {
        if (static::$instance === null) {
class YourClass
{
    private static $someVariable;

    public static function getSomeVariable()
    {
        return static::$someVariable;
    }
}
            static::$instance = new static(new InMemoryVersionStore());
class YourClass
{
    private static $someVariable;

    public static function getSomeVariable()
    {
        return static::$someVariable;
    }
}
        }

        return static::$instance;
class YourClass
{
    private static $someVariable;

    public static function getSomeVariable()
    {
        return static::$someVariable;
    }
}
    }

    /**
     * @param VersionStoreInterface $versionStore
     */
    public static function setVersionStore(VersionStoreInterface $versionStore)
    {
        static::create()->versionStore = $versionStore;
    }

    /**
     * @param EventSourcedAggregateRootInterface $aggregate
     *
     * @return int
     */
    public static function versionOf(EventSourcedAggregateRootInterface $aggregate)
    {
        return static::versionOfClass(get_class($aggregate));
    }

    /**
     * @param EventSourcedAggregateRootInterface $aggregate
     */
    public static function persistVersionOf(EventSourcedAggregateRootInterface $aggregate)
    {
        static::persistVersionOfClass(get_class($aggregate), $aggregate->version());
    }

    /**
     * @param string $className
     *
     * @return int
     */
    public static function versionOfClass($className)
    {
        return static::create()->getAggregateRootVersion($className);
    }

    /**
     * @param string $className
     * @param int    $version
     */
    public static function persistVersionOfClass($className, $version)
    {
        static::create()->setAggregateRootVersion($className, $version);
    }

    /**
     * @param string $aggregateClassName
     *
     * @return int
     */
    protected function getAggregateRootVersion($aggregateClassName)
    {
        return $this->versionStore->load($aggregateClassName);
    }

    /**
     * @param string $aggregateClassName
     * @param int    $version
     */
    protected function setAggregateRootVersion($aggregateClassName, $version)
    {
        $this->versionStore->persist($aggregateClassName, $version);
    }
}


1			<?php
2
3			/**
4			* This file is part of the Cubiche package.
5			*
6			* Copyright (c) Cubiche
7			*
8			* For the full copyright and license information, please view the LICENSE
9			* file that was distributed with this source code.
10			*/
11
12			namespace Cubiche\Domain\EventSourcing\Versioning;
13
14			use Cubiche\Domain\EventSourcing\EventSourcedAggregateRootInterface;
15
16			/**
17			* VersionManager class.
18			*
19			* @author Ivannis Suárez Jerez <[email protected]>
20			*/
21			class VersionManager
22			{
23			/**
24			* @var VersionManager
25			*/
26			private static $instance = null;
27
28			/**
29			* @var VersionStoreInterface
30			*/
31			protected $versionStore;
32
33			/**
34			* VersionManager constructor.
35			*
36			* @param VersionStoreInterface $versionStore
37			*/
38			private function __construct(VersionStoreInterface $versionStore)
39			{
40			$this->versionStore = $versionStore;
41			}
42
43			/**
44			* @return VersionManager
45			*/
46			public static function create()
47			{
48			if (static::$instance === null) {
			0 ignored issues – show Bug introduced 2016-10-18 09:55 UTC by Report Bug Copy Issue Report Since `$instance` is declared private, accessing it with `static` will lead to errors in possible sub-classes; consider using `self`, or increasing the visibility of `$instance` to at least protected. Let’s assume you have a class which uses late-static binding: class YourClass { private static $someVariable; public static function getSomeVariable() { return static::$someVariable; } } The code above will run fine in your PHP runtime. However, if you now create a sub-class and call the `getSomeVariable()` on that sub-class, you will receive a runtime error: class YourSubClass extends YourClass { } YourSubClass::getSomeVariable(); // Will cause an access error. In the case above, it makes sense to update `SomeClass` to use `self` instead: class SomeClass { private static $someVariable; public static function getSomeVariable() { return self::$someVariable; // self works fine with private. } } Loading history...
49			static::$instance = new static(new InMemoryVersionStore());
			0 ignored issues – show Bug introduced 2016-10-18 09:55 UTC by Report Bug Copy Issue Report Since `$instance` is declared private, accessing it with `static` will lead to errors in possible sub-classes; consider using `self`, or increasing the visibility of `$instance` to at least protected. Let’s assume you have a class which uses late-static binding: class YourClass { private static $someVariable; public static function getSomeVariable() { return static::$someVariable; } } The code above will run fine in your PHP runtime. However, if you now create a sub-class and call the `getSomeVariable()` on that sub-class, you will receive a runtime error: class YourSubClass extends YourClass { } YourSubClass::getSomeVariable(); // Will cause an access error. In the case above, it makes sense to update `SomeClass` to use `self` instead: class SomeClass { private static $someVariable; public static function getSomeVariable() { return self::$someVariable; // self works fine with private. } } Loading history...
50			}
51
52			return static::$instance;
			0 ignored issues – show Bug introduced 2016-10-18 09:55 UTC by Report Bug Copy Issue Report Since `$instance` is declared private, accessing it with `static` will lead to errors in possible sub-classes; consider using `self`, or increasing the visibility of `$instance` to at least protected. Let’s assume you have a class which uses late-static binding: class YourClass { private static $someVariable; public static function getSomeVariable() { return static::$someVariable; } } The code above will run fine in your PHP runtime. However, if you now create a sub-class and call the `getSomeVariable()` on that sub-class, you will receive a runtime error: class YourSubClass extends YourClass { } YourSubClass::getSomeVariable(); // Will cause an access error. In the case above, it makes sense to update `SomeClass` to use `self` instead: class SomeClass { private static $someVariable; public static function getSomeVariable() { return self::$someVariable; // self works fine with private. } } Loading history...
53			}
54
55			/**
56			* @param VersionStoreInterface $versionStore
57			*/
58			public static function setVersionStore(VersionStoreInterface $versionStore)
59			{
60			static::create()->versionStore = $versionStore;
61			}
62
63			/**
64			* @param EventSourcedAggregateRootInterface $aggregate
65			*
66			* @return int
67			*/
68			public static function versionOf(EventSourcedAggregateRootInterface $aggregate)
69			{
70			return static::versionOfClass(get_class($aggregate));
71			}
72
73			/**
74			* @param EventSourcedAggregateRootInterface $aggregate
75			*/
76			public static function persistVersionOf(EventSourcedAggregateRootInterface $aggregate)
77			{
78			static::persistVersionOfClass(get_class($aggregate), $aggregate->version());
79			}
80
81			/**
82			* @param string $className
83			*
84			* @return int
85			*/
86			public static function versionOfClass($className)
87			{
88			return static::create()->getAggregateRootVersion($className);
89			}
90
91			/**
92			* @param string $className
93			* @param int $version
94			*/
95			public static function persistVersionOfClass($className, $version)
96			{
97			static::create()->setAggregateRootVersion($className, $version);
98			}
99
100			/**
101			* @param string $aggregateClassName
102			*
103			* @return int
104			*/
105			protected function getAggregateRootVersion($aggregateClassName)
106			{
107			return $this->versionStore->load($aggregateClassName);
108			}
109
110			/**
111			* @param string $aggregateClassName
112			* @param int $version
113			*/
114			protected function setAggregateRootVersion($aggregateClassName, $version)
115			{
116			$this->versionStore->persist($aggregateClassName, $version);
117			}
118			}
119

cubiche / event-sourcing

VersionManager::getAggregateRootVersion() A last analyzed 2017-05-10 13:18 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

VersionManager::getAggregateRootVersion() A
last analyzed 2017-05-10 13:18 UTC