ObjectWriter::writeHexadecimalString() - Code Metrics - Bacon/BaconPdf - Measure and Improve Code Quality continuously with Scrutinizer

ObjectWriter::writeHexadecimalString() A
last analyzed 2015-12-08 00:08 UTC

↳ Parent: ObjectWriter

Complexity

Conditions	1
Paths	1

Size

Total Lines	5
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Importance

Changes	2
Bugs	0	Features	1

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

<?php
/**
 * BaconPdf
 *
 * @link      http://github.com/Bacon/BaconPdf For the canonical source repository
 * @copyright 2015 Ben Scholzen (DASPRiD)
 * @license   http://opensource.org/licenses/BSD-2-Clause Simplified BSD License
 */

namespace Bacon\Pdf\Writer;

use Bacon\Pdf\Exception\InvalidArgumentException;
use SplFileObject;

/**
 * Writer responsible for writing objects to a stream.
 *
 * While the PDF specification tells that there is a line limit of 255 characters, not even Adobe's own PDF library
 * respects this limit. We ignore it as well, as it imposes a huge impact on the performance of the writer.
 *
 * {@internal This is a very performance sensitive class, which is why some code may look duplicated. Before thinking
 * about refactoring these parts, take a good look and the supplied benchmarks and verify that your changes
 * do not affect the performance in a bad way. Keep in mind that the methods in this writer are called quite
 * often.}}
 */
class ObjectWriter
{
    /**
     * @var SplFileObject
     */
    private $fileObject;

    /**
     * @var bool
     */
    private $requiresWhitespace = false;

    /**
     * @var int
     */
    private $lastAllocatedObjectId = 0;

    /**
     * @var int[]
     */
    private $objectOffsets = [];

    /**
     * @param SplFileObject $fileObject
     */
    public function __construct(SplFileObject $fileObject)
    {
        $this->fileObject = $fileObject;
    }

    /**
     * Returns the current position in the file.
     *
     * @return int
     */
    public function getCurrentOffset()
    {
        return $this->fileObject->ftell();
    }

    /**
     * Writes a raw data line to the stream.
     *
     * A newline character is appended after the data. Keep in mind that you may still be after a token which requires
     * a following whitespace, depending on the context you are in.
     *
     * @param string $data
     */
    public function writeRawLine($data)
    {
        $this->fileObject->fwrite($data . "\n");
    }

    /**
     * Writes raw data to the stream.
     *
     * @param string $data
     */
    public function writeRaw($data)
    {
        $this->fileObject->fwrite($data);
    }

    /**
     * Returns all object offsets.
     *
     * @return int
     */
    public function getObjectOffsets()
    {
        return $this->objectOffsets;
    }

    /**
     * Allocates a new ID for an object.
     *
     * @return int
     */
    public function allocateObjectId()
    {
        return ++$this->lastAllocatedObjectId;
    }

    /**
     * Starts an object.
     *
     * If the object ID is omitted, a new one is allocated.
     *
     * @param  int|null $objectId
     * @return int
     */
    public function startObject($objectId = null)
    {
        if (null === $objectId) {
            $objectId = ++$this->lastAllocatedObjectId;
        }

        $this->objectOffsets[$objectId] = $this->fileObject->ftell();
        $this->fileObject->fwrite(sprintf("%d 0 obj\n", $objectId));

        return $objectId;
    }

    /**
     * Ends an object.
     */
    public function endObject()
    {
        $this->fileObject->fwrite("\nendobj\n");
    }

    /**
     * Starts a stream.
     */
    public function startStream()
    {
        $this->fileObject->fwrite("stream\n");
    }

    public function endStream()
    {
        $this->fileObject->fwrite("\nendstream\n");
    }

    /**
     * Writes an indirect reference
     *
     * @param int $objectId
     */
    public function writeIndirectReference($objectId)
    {
        if ($this->requiresWhitespace) {
            $this->fileObject->fwrite(sprintf(' %d 0 R', $objectId));
        } else {
            $this->fileObject->fwrite(sprintf('%d 0 R', $objectId));
        }

        $this->requiresWhitespace = true;
    }

    /**
     * Starts a dictionary.
     */
    public function startDictionary()
    {
        $this->fileObject->fwrite('<<');
        $this->requiresWhitespace = false;
    }

    /**
     * Ends a dictionary.
     */
    public function endDictionary()
    {
        $this->fileObject->fwrite('>>');
        $this->requiresWhitespace = false;
    }

    /**
     * Starts an array.
     */
    public function startArray()
    {
        $this->fileObject->fwrite('[');
        $this->requiresWhitespace = false;
    }

    /**
     * Ends an array.
     */
    public function endArray()
    {
        $this->fileObject->fwrite(']');
        $this->requiresWhitespace = false;
    }

    /**
     * Writes a null value.
     */
    public function writeNull()
    {
        if ($this->requiresWhitespace) {
            $this->fileObject->fwrite(' null');
        } else {
            $this->fileObject->fwrite('null');
        }

        $this->requiresWhitespace = true;
    }

    /**
     * Writes a boolean.
     *
     * @param bool $boolean
     */
    public function writeBoolean($boolean)
    {
        if ($this->requiresWhitespace) {
            $this->fileObject->fwrite($boolean ? ' true' : ' false');
        } else {
            $this->fileObject->fwrite($boolean ? 'true' : 'false');
        }

        $this->requiresWhitespace = true;
    }

    /**
     * Writes a number.
     *
     * @param  int|float $number
     * @throws InvalidArgumentException
     */
    public function writeNumber($number)
    {
        if ($this->requiresWhitespace) {
            $this->fileObject->fwrite(' ' . (rtrim(sprintf('%.6F', $number), '0.') ?: '0'));
        } else {
            $this->fileObject->fwrite(rtrim(sprintf('%.6F', $number), '0.') ?: '0');
        }

        $this->requiresWhitespace = true;
    }

    /**
     * Writes a name.
     *
     * @param string $name
     */
    public function writeName($name)
    {
        $this->fileObject->fwrite('/' . $name);
        $this->requiresWhitespace = true;
    }

    /**
     * Writes a literal string.
     *
     * The string itself is splitted into multiple lines after 248 characters. We chose that specific limit to avoid
     * splitting mutli-byte characters in half.
     *
     * @param string $string
     */
    public function writeLiteralString($string)
    {
        $this->fileObject->fwrite('(' . strtr($string, ['(' => '\\(', ')' => '\\)', '\\' => '\\\\']) . ')');
        $this->requiresWhitespace = false;
    }

    /**
     * Writes a hexadecimal string.
     *
     * @param string $string
     */
    public function writeHexadecimalString($string)
    {
        $this->fileObject->fwrite('<' . bin2hex($string) . '>');
        $this->requiresWhitespace = false;
    }
}


1			<?php
2			/**
3			* BaconPdf
4			*
5			* @link http://github.com/Bacon/BaconPdf For the canonical source repository
6			* @copyright 2015 Ben Scholzen (DASPRiD)
7			* @license http://opensource.org/licenses/BSD-2-Clause Simplified BSD License
8			*/
9
10			namespace Bacon\Pdf\Writer;
11
12			use Bacon\Pdf\Exception\InvalidArgumentException;
13			use SplFileObject;
14
15			/**
16			* Writer responsible for writing objects to a stream.
17			*
18			* While the PDF specification tells that there is a line limit of 255 characters, not even Adobe's own PDF library
19			* respects this limit. We ignore it as well, as it imposes a huge impact on the performance of the writer.
20			*
21			* {@internal This is a very performance sensitive class, which is why some code may look duplicated. Before thinking
22			* about refactoring these parts, take a good look and the supplied benchmarks and verify that your changes
23			* do not affect the performance in a bad way. Keep in mind that the methods in this writer are called quite
24			* often.}}
25			*/
26			class ObjectWriter
27			{
28			/**
29			* @var SplFileObject
30			*/
31			private $fileObject;
32
33			/**
34			* @var bool
35			*/
36			private $requiresWhitespace = false;
37
38			/**
39			* @var int
40			*/
41			private $lastAllocatedObjectId = 0;
42
43			/**
44			* @var int[]
45			*/
46			private $objectOffsets = [];
47
48			/**
49			* @param SplFileObject $fileObject
50			*/
51			public function __construct(SplFileObject $fileObject)
52			{
53			$this->fileObject = $fileObject;
54			}
55
56			/**
57			* Returns the current position in the file.
58			*
59			* @return int
60			*/
61			public function getCurrentOffset()
62			{
63			return $this->fileObject->ftell();
64			}
65
66			/**
67			* Writes a raw data line to the stream.
68			*
69			* A newline character is appended after the data. Keep in mind that you may still be after a token which requires
70			* a following whitespace, depending on the context you are in.
71			*
72			* @param string $data
73			*/
74			public function writeRawLine($data)
75			{
76			$this->fileObject->fwrite($data . "\n");
77			}
78
79			/**
80			* Writes raw data to the stream.
81			*
82			* @param string $data
83			*/
84			public function writeRaw($data)
85			{
86			$this->fileObject->fwrite($data);
87			}
88
89			/**
90			* Returns all object offsets.
91			*
92			* @return int
93			*/
94			public function getObjectOffsets()
95			{
96			return $this->objectOffsets;
97			}
98
99			/**
100			* Allocates a new ID for an object.
101			*
102			* @return int
103			*/
104			public function allocateObjectId()
105			{
106			return ++$this->lastAllocatedObjectId;
107			}
108
109			/**
110			* Starts an object.
111			*
112			* If the object ID is omitted, a new one is allocated.
113			*
114			* @param int\|null $objectId
115			* @return int
116			*/
117			public function startObject($objectId = null)
118			{
119			if (null === $objectId) {
120			$objectId = ++$this->lastAllocatedObjectId;
121			}
122
123			$this->objectOffsets[$objectId] = $this->fileObject->ftell();
124			$this->fileObject->fwrite(sprintf("%d 0 obj\n", $objectId));
125
126			return $objectId;
127			}
128
129			/**
130			* Ends an object.
131			*/
132			public function endObject()
133			{
134			$this->fileObject->fwrite("\nendobj\n");
135			}
136
137			/**
138			* Starts a stream.
139			*/
140			public function startStream()
141			{
142			$this->fileObject->fwrite("stream\n");
143			}
144
145			public function endStream()
146			{
147			$this->fileObject->fwrite("\nendstream\n");
148			}
149
150			/**
151			* Writes an indirect reference
152			*
153			* @param int $objectId
154			*/
155			public function writeIndirectReference($objectId)
156			{
157			if ($this->requiresWhitespace) {
158			$this->fileObject->fwrite(sprintf(' %d 0 R', $objectId));
159			} else {
160			$this->fileObject->fwrite(sprintf('%d 0 R', $objectId));
161			}
162
163			$this->requiresWhitespace = true;
164			}
165
166			/**
167			* Starts a dictionary.
168			*/
169			public function startDictionary()
170			{
171			$this->fileObject->fwrite('<<');
172			$this->requiresWhitespace = false;
173			}
174
175			/**
176			* Ends a dictionary.
177			*/
178			public function endDictionary()
179			{
180			$this->fileObject->fwrite('>>');
181			$this->requiresWhitespace = false;
182			}
183
184			/**
185			* Starts an array.
186			*/
187			public function startArray()
188			{
189			$this->fileObject->fwrite('[');
190			$this->requiresWhitespace = false;
191			}
192
193			/**
194			* Ends an array.
195			*/
196			public function endArray()
197			{
198			$this->fileObject->fwrite(']');
199			$this->requiresWhitespace = false;
200			}
201
202			/**
203			* Writes a null value.
204			*/
205			public function writeNull()
206			{
207			if ($this->requiresWhitespace) {
208			$this->fileObject->fwrite(' null');
209			} else {
210			$this->fileObject->fwrite('null');
211			}
212
213			$this->requiresWhitespace = true;
214			}
215
216			/**
217			* Writes a boolean.
218			*
219			* @param bool $boolean
220			*/
221			public function writeBoolean($boolean)
222			{
223			if ($this->requiresWhitespace) {
224			$this->fileObject->fwrite($boolean ? ' true' : ' false');
225			} else {
226			$this->fileObject->fwrite($boolean ? 'true' : 'false');
227			}
228
229			$this->requiresWhitespace = true;
230			}
231
232			/**
233			* Writes a number.
234			*
235			* @param int\|float $number
236			* @throws InvalidArgumentException
237			*/
238			public function writeNumber($number)
239			{
240			if ($this->requiresWhitespace) {
241			$this->fileObject->fwrite(' ' . (rtrim(sprintf('%.6F', $number), '0.') ?: '0'));
242			} else {
243			$this->fileObject->fwrite(rtrim(sprintf('%.6F', $number), '0.') ?: '0');
244			}
245
246			$this->requiresWhitespace = true;
247			}
248
249			/**
250			* Writes a name.
251			*
252			* @param string $name
253			*/
254			public function writeName($name)
255			{
256			$this->fileObject->fwrite('/' . $name);
257			$this->requiresWhitespace = true;
258			}
259
260			/**
261			* Writes a literal string.
262			*
263			* The string itself is splitted into multiple lines after 248 characters. We chose that specific limit to avoid
264			* splitting mutli-byte characters in half.
265			*
266			* @param string $string
267			*/
268			public function writeLiteralString($string)
269			{
270			$this->fileObject->fwrite('(' . strtr($string, ['(' => '\\(', ')' => '\\)', '\\' => '\\\\']) . ')');
271			$this->requiresWhitespace = false;
272			}
273
274			/**
275			* Writes a hexadecimal string.
276			*
277			* @param string $string
278			*/
279			public function writeHexadecimalString($string)
280			{
281			$this->fileObject->fwrite('<' . bin2hex($string) . '>');
282			$this->requiresWhitespace = false;
283			}
284			}
285

Bacon / BaconPdf

ObjectWriter::writeHexadecimalString() A last analyzed 2015-12-08 00:08 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

ObjectWriter::writeHexadecimalString() A
last analyzed 2015-12-08 00:08 UTC