Config - Code Metrics - Inspection of "Merge remote-tracking branch 'origin/refactoring'" - krowinski/php-mysql-replication - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( fb2510...e090ea )

by kacper

created 2017-07-14 09:03 UTC

Config B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	375
Duplicated Lines	10.93 %

Coupling/Cohesion

Components	4
Dependencies	1

Test Coverage

Coverage

70.25%

Importance

Changes

Metric	Value
wmc	53
lcom	4
cbo	1
dl	41
loc	375
ccs	85
cts	121
cp	0.7025
rs	7.4757
c	0
b	0
f	0

22 Methods

Rating	Name	Duplication	Size	Complexity
B	__construct()	0	37	1
C	validate()	41	71	27
A	getCustom()	0	4	1
A	getUser()	0	4	1
A	getHost()	0	4	1
A	getPort()	0	4	1
A	getPassword()	0	4	1
A	getCharset()	0	4	1
A	getGtid()	0	4	1
A	getMariaDbGtid()	0	4	1
A	getSlaveId()	0	4	1
A	getBinLogFileName()	0	4	1
A	getBinLogPosition()	0	4	1
A	getEventsOnly()	0	4	1
A	getEventsIgnore()	0	4	1
A	getTablesOnly()	0	4	1
A	getDatabasesOnly()	0	4	1
A	getTableCacheSize()	0	4	1
A	checkDataBasesOnly()	0	4	2
A	checkTablesOnly()	0	4	2
A	checkEvent()	0	12	4
A	getHeartbeatPeriod()	0	4	1

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like Config often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use Config, and based on these observations, apply Extract Interface, too.

<?php

namespace MySQLReplication\Config;

/**
 * Class Config
 * @package MySQLReplication\Config
 */
class Config
{
    /**
     * @var string
     */
    private static $user;
    /**
     * @var string
     */
    private static $host;
    /**
     * @var int
     */
    private static $port;
    /**
     * @var string
     */
    private static $password;
    /**
     * @var string
     */
    private static $charset;
    /**
     * @var string
     */
    private static $gtid;
    /**
     * @var int
     */
    private static $slaveId;
    /**
     * @var string
     */
    private static $binLogFileName;
    /**
     * @var int
     */
    private static $binLogPosition;
    /**
     * @var array
     */
    private static $eventsOnly;
    /**
     * @var array
     */
    private static $eventsIgnore;
    /**
     * @var array
     */
    private static $tablesOnly;
    /**
     * @var array
     */
    private static $databasesOnly;
    /**
     * @var string
     */
    private static $mariaDbGtid;
    /**
     * @var int
     */
    private static $tableCacheSize;
    /**
     * @var array
     */
    private static $custom;
    /**
     * @var int
     */
    private static $heartbeatPeriod;

    /**
     * Config constructor.
     * @param string $user
     * @param string $host
     * @param int $port
     * @param string $password
     * @param string $charset
     * @param string $gtid
     * @param string $mariaGtid
     * @param int $slaveId
     * @param string $binLogFileName
     * @param $binLogPosition
     * @param array $eventsOnly
     * @param array $eventsIgnore
     * @param array $tablesOnly
     * @param array $databasesOnly
     * @param int $tableCacheSize
     * @param array $custom
     * @param int $heartbeatPeriod
     */
    public function __construct(
        $user,
        $host,
        $port,
        $password,
        $charset,
        $gtid,
        $mariaGtid,
        $slaveId,
        $binLogFileName,
        $binLogPosition,
        array $eventsOnly,
        array $eventsIgnore,
        array $tablesOnly,
        array $databasesOnly,
        $tableCacheSize,
        array $custom,
        $heartbeatPeriod
    ) {
        self::$user = $user;
        self::$host = $host;
        self::$port = $port;
        self::$password = $password;
        self::$charset = $charset;
        self::$gtid = $gtid;
        self::$slaveId = $slaveId;
        self::$binLogFileName = $binLogFileName;
        self::$binLogPosition = $binLogPosition;
        self::$eventsOnly = $eventsOnly;
        self::$eventsIgnore = $eventsIgnore;
        self::$tablesOnly = $tablesOnly;
        self::$databasesOnly = $databasesOnly;
        self::$mariaDbGtid = $mariaGtid;
        self::$tableCacheSize = $tableCacheSize;
        self::$custom = $custom;
        self::$heartbeatPeriod = $heartbeatPeriod;
    }

    /**
     * @throws ConfigException
     */
    public static function validate()
    {
        if (!empty(self::$user) && !is_string(self::$user)) {

            throw new ConfigException(ConfigException::USER_ERROR_MESSAGE, ConfigException::USER_ERROR_CODE);
        }
        if (!empty(self::$host)) {
            $ip = gethostbyname(self::$host);
            if (!filter_var($ip, FILTER_VALIDATE_IP)) {
                throw new ConfigException(ConfigException::IP_ERROR_MESSAGE, ConfigException::IP_ERROR_CODE);
            }
        }
        if (!empty(self::$port) && !filter_var(

                self::$port, FILTER_VALIDATE_INT, ['options' => ['min_range' => 0]]
            )
        ) {
            throw new ConfigException(ConfigException::PORT_ERROR_MESSAGE, ConfigException::PORT_ERROR_CODE);
        }
        if (!empty(self::$password) && !is_string(self::$password) && !is_numeric(self::$password)) {
            throw new ConfigException(ConfigException::PASSWORD_ERROR_MESSAGE, ConfigException::PASSWORD_ERROR_CODE);
        }
        if (!empty(self::$charset) && !is_string(self::$charset)) {

            throw new ConfigException(ConfigException::CHARSET_ERROR_MESSAGE, ConfigException::CHARSET_ERROR_CODE);
        }
        if (!empty(self::$gtid) && !is_string(self::$gtid)) {
            foreach (explode(',', self::$gtid) as $gtid) {
                if (!(bool)preg_match(
                    '/^([0-9a-fA-F]{8}(?:-[0-9a-fA-F]{4}){3}-[0-9a-fA-F]{12})((?::[0-9-]+)+)$/', $gtid, $matches
                )
                ) {
                    throw new ConfigException(ConfigException::GTID_ERROR_MESSAGE, ConfigException::GTID_ERROR_CODE);
                }
            }
        }
        if (!empty(self::$slaveId) && !filter_var(

                self::$slaveId, FILTER_VALIDATE_INT, ['options' => ['min_range' => 0]]
            )
        ) {
            throw new ConfigException(ConfigException::SLAVE_ID_ERROR_MESSAGE, ConfigException::SLAVE_ID_ERROR_CODE);
        }
        if (!empty(self::$binLogFileName) && !is_string(self::$binLogFileName)) {

            throw new ConfigException(
                ConfigException::BIN_LOG_FILE_NAME_ERROR_MESSAGE, ConfigException::BIN_LOG_FILE_NAME_ERROR_CODE
            );
        }
        if (!empty(self::$binLogPosition) && !filter_var(

                self::$binLogPosition, FILTER_VALIDATE_INT, ['options' => ['min_range' => 0]]
            )
        ) {
            throw new ConfigException(
                ConfigException::BIN_LOG_FILE_POSITION_ERROR_MESSAGE, ConfigException::BIN_LOG_FILE_POSITION_ERROR_CODE
            );
        }
        if (!empty(self::$mariaDbGtid) && !is_string(self::$mariaDbGtid)) {

            throw new ConfigException(
                ConfigException::MARIADBGTID_ERROR_MESSAGE, ConfigException::MARIADBGTID_ERROR_CODE
            );
        }
        if (!filter_var(self::$tableCacheSize, FILTER_VALIDATE_INT, ['options' => ['min_range' => 0]])) {

            throw new ConfigException(
                ConfigException::TABLE_CACHE_SIZE_ERROR_MESSAGE, ConfigException::TABLE_CACHE_SIZE_ERROR_CODE
            );
        }
        if (0 !== self::$heartbeatPeriod && !filter_var(
                self::$heartbeatPeriod, FILTER_VALIDATE_INT, ['options' => ['min_range' => 1, 'max_range' => 4294967]]
            )
        ) {
            throw new ConfigException(
                ConfigException::HEARTBEAT_PERIOD_ERROR_MESSAGE, ConfigException::HEARTBEAT_PERIOD_ERROR_CODE
            );
        }
    }

    /**
     * @return array
     */
    public static function getCustom()
    {
        return self::$custom;
    }

    /**
     * @return string
     */
    public static function getUser()
    {
        return self::$user;
    }

    /**
     * @return string
     */
    public static function getHost()
    {
        return self::$host;
    }

    /**
     * @return int
     */
    public static function getPort()
    {
        return self::$port;
    }

    /**
     * @return string
     */
    public static function getPassword()
    {
        return self::$password;
    }

    /**
     * @return string
     */
    public static function getCharset()
    {
        return self::$charset;
    }

    /**
     * @return string
     */
    public static function getGtid()
    {
        return self::$gtid;
    }

    /**
     * @return string
     */
    public static function getMariaDbGtid()
    {
        return self::$mariaDbGtid;
    }

    /**
     * @return int
     */
    public static function getSlaveId()
    {
        return self::$slaveId;
    }

    /**
     * @return string
     */
    public static function getBinLogFileName()
    {
        return self::$binLogFileName;
    }

    /**
     * @return int
     */
    public static function getBinLogPosition()
    {
        return self::$binLogPosition;
    }

    /**
     * @return array
     */
    public static function getEventsOnly()
    {
        return self::$eventsOnly;
    }

    /**
     * @return array
     */
    public static function getEventsIgnore()
    {
        return self::$eventsIgnore;
    }

    /**
     * @return array
     */
    public static function getTablesOnly()
    {
        return self::$tablesOnly;
    }

    /**
     * @return array
     */
    public static function getDatabasesOnly()
    {
        return self::$databasesOnly;
    }

    /**
     * @return int
     */
    public static function getTableCacheSize()
    {
        return self::$tableCacheSize;
    }

    /**
     * @param string $database
     * @return bool
     */
    public static function checkDataBasesOnly($database)
    {
        return [] !== Config::getDatabasesOnly() && !in_array($database, Config::getDatabasesOnly(), true);
    }

    /**
     * @param string $table
     * @return bool
     */
    public static function checkTablesOnly($table)
    {
        return [] !== Config::getTablesOnly() && !in_array($table, Config::getTablesOnly(), true);
    }

    /**
     * @param int $type
     * @return bool
     */
    public static function checkEvent($type)
    {
        if ([] !== Config::getEventsOnly() && !in_array($type, Config::getEventsOnly(), true)) {
            return false;
        }

        if (in_array($type, Config::getEventsIgnore(), true)) {
            return false;
        }

        return true;
    }

    /**
     * @return int
     */
    public static function getHeartbeatPeriod()
    {
        return self::$heartbeatPeriod;
    }
}

1			<?php
2
3			namespace MySQLReplication\Config;
4
5			/**
6			* Class Config
7			* @package MySQLReplication\Config
8			*/
9			class Config
10			{
11			/**
12			* @var string
13			*/
14			private static $user;
15			/**
16			* @var string
17			*/
18			private static $host;
19			/**
20			* @var int
21			*/
22			private static $port;
23			/**
24			* @var string
25			*/
26			private static $password;
27			/**
28			* @var string
29			*/
30			private static $charset;
31			/**
32			* @var string
33			*/
34			private static $gtid;
35			/**
36			* @var int
37			*/
38			private static $slaveId;
39			/**
40			* @var string
41			*/
42			private static $binLogFileName;
43			/**
44			* @var int
45			*/
46			private static $binLogPosition;
47			/**
48			* @var array
49			*/
50			private static $eventsOnly;
51			/**
52			* @var array
53			*/
54			private static $eventsIgnore;
55			/**
56			* @var array
57			*/
58			private static $tablesOnly;
59			/**
60			* @var array
61			*/
62			private static $databasesOnly;
63			/**
64			* @var string
65			*/
66			private static $mariaDbGtid;
67			/**
68			* @var int
69			*/
70			private static $tableCacheSize;
71			/**
72			* @var array
73			*/
74			private static $custom;
75			/**
76			* @var int
77			*/
78			private static $heartbeatPeriod;
79
80			/**
81			* Config constructor.
82			* @param string $user
83			* @param string $host
84			* @param int $port
85			* @param string $password
86			* @param string $charset
87			* @param string $gtid
88			* @param string $mariaGtid
89			* @param int $slaveId
90			* @param string $binLogFileName
91			* @param $binLogPosition
92			* @param array $eventsOnly
93			* @param array $eventsIgnore
94			* @param array $tablesOnly
95			* @param array $databasesOnly
96			* @param int $tableCacheSize
97			* @param array $custom
98			* @param int $heartbeatPeriod
99			*/
100	54		public function __construct(
101			$user,
102			$host,
103			$port,
104			$password,
105			$charset,
106			$gtid,
107			$mariaGtid,
108			$slaveId,
109			$binLogFileName,
110			$binLogPosition,
111			array $eventsOnly,
112			array $eventsIgnore,
113			array $tablesOnly,
114			array $databasesOnly,
115			$tableCacheSize,
116			array $custom,
117			$heartbeatPeriod
118			) {
119	54		self::$user = $user;
120	54		self::$host = $host;
121	54		self::$port = $port;
122	54		self::$password = $password;
123	54		self::$charset = $charset;
124	54		self::$gtid = $gtid;
125	54		self::$slaveId = $slaveId;
126	54		self::$binLogFileName = $binLogFileName;
127	54		self::$binLogPosition = $binLogPosition;
128	54		self::$eventsOnly = $eventsOnly;
129	54		self::$eventsIgnore = $eventsIgnore;
130	54		self::$tablesOnly = $tablesOnly;
131	54		self::$databasesOnly = $databasesOnly;
132	54		self::$mariaDbGtid = $mariaGtid;
133	54		self::$tableCacheSize = $tableCacheSize;
134	54		self::$custom = $custom;
135	54		self::$heartbeatPeriod = $heartbeatPeriod;
136	54		}
137
138			/**
139			* @throws ConfigException
140			*/
141	54		public static function validate()
142			{
143	54	View Code Duplication	if (!empty(self::$user) && !is_string(self::$user)) {
			0 ignored issues – show Duplication introduced 2017-07-13 13:45 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
144			throw new ConfigException(ConfigException::USER_ERROR_MESSAGE, ConfigException::USER_ERROR_CODE);
145			}
146	54		if (!empty(self::$host)) {
147	54		$ip = gethostbyname(self::$host);
148	54		if (!filter_var($ip, FILTER_VALIDATE_IP)) {
149			throw new ConfigException(ConfigException::IP_ERROR_MESSAGE, ConfigException::IP_ERROR_CODE);
150			}
151	54		}
152	54	View Code Duplication	if (!empty(self::$port) && !filter_var(
			0 ignored issues – show Duplication introduced 2017-07-13 13:45 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
153	54		self::$port, FILTER_VALIDATE_INT, ['options' => ['min_range' => 0]]
154	54		)
155	54		) {
156			throw new ConfigException(ConfigException::PORT_ERROR_MESSAGE, ConfigException::PORT_ERROR_CODE);
157			}
158	54		if (!empty(self::$password) && !is_string(self::$password) && !is_numeric(self::$password)) {
159			throw new ConfigException(ConfigException::PASSWORD_ERROR_MESSAGE, ConfigException::PASSWORD_ERROR_CODE);
160			}
161	54	View Code Duplication	if (!empty(self::$charset) && !is_string(self::$charset)) {
			0 ignored issues – show Duplication introduced 2017-07-13 13:45 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
162			throw new ConfigException(ConfigException::CHARSET_ERROR_MESSAGE, ConfigException::CHARSET_ERROR_CODE);
163			}
164	54		if (!empty(self::$gtid) && !is_string(self::$gtid)) {
165			foreach (explode(',', self::$gtid) as $gtid) {
166			if (!(bool)preg_match(
167			'/^([0-9a-fA-F]{8}(?:-[0-9a-fA-F]{4}){3}-[0-9a-fA-F]{12})((?::[0-9-]+)+)$/', $gtid, $matches
168			)
169			) {
170			throw new ConfigException(ConfigException::GTID_ERROR_MESSAGE, ConfigException::GTID_ERROR_CODE);
171			}
172			}
173			}
174	54	View Code Duplication	if (!empty(self::$slaveId) && !filter_var(
			0 ignored issues – show Duplication introduced 2017-07-13 13:45 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
175	54		self::$slaveId, FILTER_VALIDATE_INT, ['options' => ['min_range' => 0]]
176	54		)
177	54		) {
178			throw new ConfigException(ConfigException::SLAVE_ID_ERROR_MESSAGE, ConfigException::SLAVE_ID_ERROR_CODE);
179			}
180	54	View Code Duplication	if (!empty(self::$binLogFileName) && !is_string(self::$binLogFileName)) {
			0 ignored issues – show Duplication introduced 2017-07-13 13:45 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
181			throw new ConfigException(
182			ConfigException::BIN_LOG_FILE_NAME_ERROR_MESSAGE, ConfigException::BIN_LOG_FILE_NAME_ERROR_CODE
183			);
184			}
185	54	View Code Duplication	if (!empty(self::$binLogPosition) && !filter_var(
			0 ignored issues – show Duplication introduced 2017-07-13 13:45 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
186			self::$binLogPosition, FILTER_VALIDATE_INT, ['options' => ['min_range' => 0]]
187			)
188	54		) {
189			throw new ConfigException(
190			ConfigException::BIN_LOG_FILE_POSITION_ERROR_MESSAGE, ConfigException::BIN_LOG_FILE_POSITION_ERROR_CODE
191			);
192			}
193	54	View Code Duplication	if (!empty(self::$mariaDbGtid) && !is_string(self::$mariaDbGtid)) {
			0 ignored issues – show Duplication introduced 2017-07-13 13:45 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
194			throw new ConfigException(
195			ConfigException::MARIADBGTID_ERROR_MESSAGE, ConfigException::MARIADBGTID_ERROR_CODE
196			);
197			}
198	54	View Code Duplication	if (!filter_var(self::$tableCacheSize, FILTER_VALIDATE_INT, ['options' => ['min_range' => 0]])) {
			0 ignored issues – show Duplication introduced 2017-07-13 13:45 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
199			throw new ConfigException(
200			ConfigException::TABLE_CACHE_SIZE_ERROR_MESSAGE, ConfigException::TABLE_CACHE_SIZE_ERROR_CODE
201			);
202			}
203	54		if (0 !== self::$heartbeatPeriod && !filter_var(
204			self::$heartbeatPeriod, FILTER_VALIDATE_INT, ['options' => ['min_range' => 1, 'max_range' => 4294967]]
205			)
206	54		) {
207			throw new ConfigException(
208			ConfigException::HEARTBEAT_PERIOD_ERROR_MESSAGE, ConfigException::HEARTBEAT_PERIOD_ERROR_CODE
209			);
210			}
211	54		}
212
213			/**
214			* @return array
215			*/
216			public static function getCustom()
217			{
218			return self::$custom;
219			}
220
221			/**
222			* @return string
223			*/
224	54		public static function getUser()
225			{
226	54		return self::$user;
227			}
228
229			/**
230			* @return string
231			*/
232	54		public static function getHost()
233			{
234	54		return self::$host;
235			}
236
237			/**
238			* @return int
239			*/
240	54		public static function getPort()
241			{
242	54		return self::$port;
243			}
244
245			/**
246			* @return string
247			*/
248	54		public static function getPassword()
249			{
250	54		return self::$password;
251			}
252
253			/**
254			* @return string
255			*/
256	54		public static function getCharset()
257			{
258	54		return self::$charset;
259			}
260
261			/**
262			* @return string
263			*/
264	54		public static function getGtid()
265			{
266	54		return self::$gtid;
267			}
268
269			/**
270			* @return string
271			*/
272	54		public static function getMariaDbGtid()
273			{
274	54		return self::$mariaDbGtid;
275			}
276
277			/**
278			* @return int
279			*/
280	54		public static function getSlaveId()
281			{
282	54		return self::$slaveId;
283			}
284
285			/**
286			* @return string
287			*/
288	54		public static function getBinLogFileName()
289			{
290	54		return self::$binLogFileName;
291			}
292
293			/**
294			* @return int
295			*/
296	54		public static function getBinLogPosition()
297			{
298	54		return self::$binLogPosition;
299			}
300
301			/**
302			* @return array
303			*/
304	54		public static function getEventsOnly()
305			{
306	54		return self::$eventsOnly;
307			}
308
309			/**
310			* @return array
311			*/
312	54		public static function getEventsIgnore()
313			{
314	54		return self::$eventsIgnore;
315			}
316
317			/**
318			* @return array
319			*/
320	52		public static function getTablesOnly()
321			{
322	52		return self::$tablesOnly;
323			}
324
325			/**
326			* @return array
327			*/
328	52		public static function getDatabasesOnly()
329			{
330	52		return self::$databasesOnly;
331			}
332
333			/**
334			* @return int
335			*/
336	52		public static function getTableCacheSize()
337			{
338	52		return self::$tableCacheSize;
339			}
340
341			/**
342			* @param string $database
343			* @return bool
344			*/
345	52		public static function checkDataBasesOnly($database)
346			{
347	52		return [] !== Config::getDatabasesOnly() && !in_array($database, Config::getDatabasesOnly(), true);
348			}
349
350			/**
351			* @param string $table
352			* @return bool
353			*/
354	52		public static function checkTablesOnly($table)
355			{
356	52		return [] !== Config::getTablesOnly() && !in_array($table, Config::getTablesOnly(), true);
357			}
358
359			/**
360			* @param int $type
361			* @return bool
362			*/
363	54		public static function checkEvent($type)
364			{
365	54		if ([] !== Config::getEventsOnly() && !in_array($type, Config::getEventsOnly(), true)) {
366	3		return false;
367			}
368
369	54		if (in_array($type, Config::getEventsIgnore(), true)) {
370			return false;
371			}
372
373	54		return true;
374			}
375
376			/**
377			* @return int
378			*/
379	54		public static function getHeartbeatPeriod()
380			{
381	54		return self::$heartbeatPeriod;
382			}
383			}

krowinski / php-mysql-replication