CommonMiddleware::serializeIt() - Code Metrics - Inspection of "调整：中间件创建方式" - dxkite/suda - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( a325c0...46b506 )

by 世昌

created 2019-04-18 05:55 UTC

CommonMiddleware::serializeIt() A

↳ Parent: CommonMiddleware

Complexity

Conditions	1
Paths	1

Size

Total Lines	5
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	3
nc	1
nop	1
dl	0
loc	5
rs	10
c	0
b	0
f	0

<?php
namespace suda\orm\middleware;

use suda\framework\runnable\Runnable;
use suda\orm\middleware\NullMiddleware;

/**
 * 通用中间件
 */
class CommonMiddleware extends NullMiddleware
{

    /**
     * 注册中间件处理
     *
     * @var Runnable[]
     */
    protected $processor;

    /**
     * 设置某参数序列化
     *
     * @param string $name
     * @return CommonMiddleware
     */
    public function serializeIt(string $name): CommonMiddleware
    {
        $this->registerInput($name, [$this, 'inputSerialize']);
        $this->registerOutput($name, [$this, 'outputUnserialize']);
        return $this;
    }

    /**
     * 注册输入处理
     *
     * @param string $name
     * @param \suda\framework\runnable\Runnable|\Closure|array|string $runnable
     * @return CommonMiddleware
     */
    public function registerInput(string $name, $runnable): CommonMiddleware
    {
        $this->processor['input:'.$name] = $runnable;
        return $this;
    }

    /**
     * 输出数据处理
     *
     * @param string $name
     * @param \suda\framework\runnable\Runnable|\Closure|array|string $runnable
     * @return \suda\orm\middleware\NullMiddleware
     */
    public function registerOutput(string $name, $runnable): CommonMiddleware
    {
        $this->processor['output:'.$name] = $runnable;
        return $this;
    }

    /**
     * 输入名处理
     *
     * @param \suda\framework\runnable\Runnable|\Closure|array|string $runnable
     * @return \suda\orm\middleware\NullMiddleware
     */
    public function registerInputName($runnable): CommonMiddleware
    {
        $this->processor['input-name'] = $runnable;
        return $this;
    }
 
    /**
     * 输出名处理
     *
     * @param \suda\framework\runnable\Runnable|\Closure|array|string $runnable
     * @return \suda\orm\middleware\NullMiddleware
     */
    public function registerOutputName($runnable): CommonMiddleware
    {
        $this->processor['output-name'] = $runnable;
        return $this;
    }

    /**
     * 输出字段处理
     *
     * @param \suda\framework\runnable\Runnable|\Closure|array|string $runnable
     * @return \suda\orm\middleware\NullMiddleware
     */
    public function registerRow($runnable): CommonMiddleware
    {
        $this->processor['output-row'] = $runnable;
        return $this;
    }


    /**
     * 处理输入数据
     *
     * @param string $name
     * @param mixed $data
     * @return mixed
     */
    public function input(string $name, $data)
    {
        $key = 'input:'.$name;
        if (array_key_exists($key, $this->processor)) {
            return (new Runnable($this->processor[$key]))($data);
        }
        return $data;
    }

    /**
     * 处理输出数据
     *
     * @param string $name
     * @param mixed $data
     * @return mixed
     */
    public function output(string $name, $data)
    {
        $key = 'output:'.$name;
        if (array_key_exists($key, $this->processor)) {
            return (new Runnable($this->processor[$key]))($data);
        }
        return $data;
    }

    /**
     * 对输出列进行处理
     *
     * @param mixed $row
     * @return mixed
     */
    public function outputRow($row)
    {
        $key = 'output-row';
        if (array_key_exists($key, $this->processor)) {
            return (new Runnable($this->processor[$key]))($row);
        }
        return $row;
    }

    /**
     * 输入参数名
     *
     * @param string $name
     * @return string
     */
    public function inputName(string $name):string
    {
        $key = 'input-name';
        if (array_key_exists($key, $this->processor)) {
            return (new Runnable($this->processor[$key]))($name);
        }
        return $name;
    }

    /**
     * 输出参数名
     *
     * @param string $name
     * @return string
     */
    public function outputName(string $name):string
    {
        $key = 'output-name';
        if (array_key_exists($key, $this->processor)) {
            return (new Runnable($this->processor[$key]))($name);
        }
        return $name;
    }

    /**
     * 序列化
     *
     * @param mixed $data
     * @return string
     */
    private function inputSerialize($data)
    {
        return $data === null? $data : \serialize($data);
    }

    /**
     * 序列化
     *
     * @param mixed $data
     * @return mixed
     */
    private function outputUnserialize($data)
    {
        return \unserialize($data) ?: null;
    }
}


1			<?php
2			namespace suda\orm\middleware;
3
4			use suda\framework\runnable\Runnable;
5			use suda\orm\middleware\NullMiddleware;
6
7			/**
8			* 通用中间件
9			*/
10			class CommonMiddleware extends NullMiddleware
11			{
12
13			/**
14			* 注册中间件处理
15			*
16			* @var Runnable[]
17			*/
18			protected $processor;
19
20			/**
21			* 设置某参数序列化
22			*
23			* @param string $name
24			* @return CommonMiddleware
25			*/
26			public function serializeIt(string $name): CommonMiddleware
27			{
28			$this->registerInput($name, [$this, 'inputSerialize']);
29			$this->registerOutput($name, [$this, 'outputUnserialize']);
30			return $this;
31			}
32
33			/**
34			* 注册输入处理
35			*
36			* @param string $name
37			* @param \suda\framework\runnable\Runnable\|\Closure\|array\|string $runnable
38			* @return CommonMiddleware
39			*/
40			public function registerInput(string $name, $runnable): CommonMiddleware
41			{
42			$this->processor['input:'.$name] = $runnable;
43			return $this;
44			}
45
46			/**
47			* 输出数据处理
48			*
49			* @param string $name
50			* @param \suda\framework\runnable\Runnable\|\Closure\|array\|string $runnable
51			* @return \suda\orm\middleware\NullMiddleware
52			*/
53			public function registerOutput(string $name, $runnable): CommonMiddleware
54			{
55			$this->processor['output:'.$name] = $runnable;
56			return $this;
57			}
58
59			/**
60			* 输入名处理
61			*
62			* @param \suda\framework\runnable\Runnable\|\Closure\|array\|string $runnable
63			* @return \suda\orm\middleware\NullMiddleware
64			*/
65			public function registerInputName($runnable): CommonMiddleware
66			{
67			$this->processor['input-name'] = $runnable;
68			return $this;
69			}
70
71			/**
72			* 输出名处理
73			*
74			* @param \suda\framework\runnable\Runnable\|\Closure\|array\|string $runnable
75			* @return \suda\orm\middleware\NullMiddleware
76			*/
77			public function registerOutputName($runnable): CommonMiddleware
78			{
79			$this->processor['output-name'] = $runnable;
80			return $this;
81			}
82
83			/**
84			* 输出字段处理
85			*
86			* @param \suda\framework\runnable\Runnable\|\Closure\|array\|string $runnable
87			* @return \suda\orm\middleware\NullMiddleware
88			*/
89			public function registerRow($runnable): CommonMiddleware
90			{
91			$this->processor['output-row'] = $runnable;
92			return $this;
93			}
94
95
96			/**
97			* 处理输入数据
98			*
99			* @param string $name
100			* @param mixed $data
101			* @return mixed
102			*/
103			public function input(string $name, $data)
104			{
105			$key = 'input:'.$name;
106			if (array_key_exists($key, $this->processor)) {
107			return (new Runnable($this->processor[$key]))($data);
108			}
109			return $data;
110			}
111
112			/**
113			* 处理输出数据
114			*
115			* @param string $name
116			* @param mixed $data
117			* @return mixed
118			*/
119			public function output(string $name, $data)
120			{
121			$key = 'output:'.$name;
122			if (array_key_exists($key, $this->processor)) {
123			return (new Runnable($this->processor[$key]))($data);
124			}
125			return $data;
126			}
127
128			/**
129			* 对输出列进行处理
130			*
131			* @param mixed $row
132			* @return mixed
133			*/
134			public function outputRow($row)
135			{
136			$key = 'output-row';
137			if (array_key_exists($key, $this->processor)) {
138			return (new Runnable($this->processor[$key]))($row);
139			}
140			return $row;
141			}
142
143			/**
144			* 输入参数名
145			*
146			* @param string $name
147			* @return string
148			*/
149			public function inputName(string $name):string
150			{
151			$key = 'input-name';
152			if (array_key_exists($key, $this->processor)) {
153			return (new Runnable($this->processor[$key]))($name);
154			}
155			return $name;
156			}
157
158			/**
159			* 输出参数名
160			*
161			* @param string $name
162			* @return string
163			*/
164			public function outputName(string $name):string
165			{
166			$key = 'output-name';
167			if (array_key_exists($key, $this->processor)) {
168			return (new Runnable($this->processor[$key]))($name);
169			}
170			return $name;
171			}
172
173			/**
174			* 序列化
175			*
176			* @param mixed $data
177			* @return string
178			*/
179			private function inputSerialize($data)
180			{
181			return $data === null? $data : \serialize($data);
182			}
183
184			/**
185			* 序列化
186			*
187			* @param mixed $data
188			* @return mixed
189			*/
190			private function outputUnserialize($data)
191			{
192			return \unserialize($data) ?: null;
193			}
194			}
195

dxkite / suda

Push — master ( a325c0...46b506 )

CommonMiddleware::serializeIt() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like