no message

zhaojs

2023-07-31 0de015249a3abe05031eb4f5d988e8eb7ef83c87

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
<?php
 
namespace PhpZip\Model\Data;
 
use PhpZip\Model\ZipData;
use PhpZip\Model\ZipEntry;
use PhpZip\ZipFile;
 
/**
 * The class contains a streaming resource with new content added to the ZIP archive.
 */
class ZipNewData implements ZipData
{
    /**
     * A static variable allows closing the stream in the destructor
     * only if it is its sole holder.
     *
     * @var array<int, int> array of resource ids and the number of class clones
     */
    private static $guardClonedStream = [];
 
    /** @var ZipEntry */
    private $zipEntry;
 
    /** @var resource */
    private $stream;
 
    /**
     * ZipStringData constructor.
     *
     * @param ZipEntry        $zipEntry
     * @param string|resource $data
     */
    public function __construct(ZipEntry $zipEntry, $data)
    {
        $this->zipEntry = $zipEntry;
 
        if (\is_string($data)) {
            $zipEntry->setUncompressedSize(\strlen($data));
 
            if (!($handle = fopen('php://temp', 'w+b'))) {
                // @codeCoverageIgnoreStart
                throw new \RuntimeException('A temporary resource cannot be opened for writing.');
                // @codeCoverageIgnoreEnd
            }
            fwrite($handle, $data);
            rewind($handle);
            $this->stream = $handle;
        } elseif (\is_resource($data)) {
            $this->stream = $data;
        }
 
        $resourceId = (int) $this->stream;
        self::$guardClonedStream[$resourceId] =
            isset(self::$guardClonedStream[$resourceId]) ?
                self::$guardClonedStream[$resourceId] + 1 :
                0;
    }
 
    /**
     * @return resource returns stream data
     */
    public function getDataAsStream()
    {
        if (!\is_resource($this->stream)) {
            throw new \LogicException(sprintf('Resource has been closed (entry=%s).', $this->zipEntry->getName()));
        }
 
        return $this->stream;
    }
 
    /**
     * @return string returns data as string
     */
    public function getDataAsString()
    {
        $stream = $this->getDataAsStream();
        $pos = ftell($stream);
 
        try {
            rewind($stream);
 
            return stream_get_contents($stream);
        } finally {
            fseek($stream, $pos);
        }
    }
 
    /**
     * @param resource $outStream
     */
    public function copyDataToStream($outStream)
    {
        $stream = $this->getDataAsStream();
        rewind($stream);
        stream_copy_to_stream($stream, $outStream);
    }
 
    /**
     * @see https://php.net/manual/en/language.oop5.cloning.php
     */
    public function __clone()
    {
        $resourceId = (int) $this->stream;
        self::$guardClonedStream[$resourceId] =
            isset(self::$guardClonedStream[$resourceId]) ?
                self::$guardClonedStream[$resourceId] + 1 :
                1;
    }
 
    /**
     * The stream will be closed when closing the zip archive.
     *
     * The method implements protection against closing the stream of the cloned object.
     *
     * @see ZipFile::close()
     */
    public function __destruct()
    {
        $resourceId = (int) $this->stream;
 
        if (isset(self::$guardClonedStream[$resourceId]) && self::$guardClonedStream[$resourceId] > 0) {
            self::$guardClonedStream[$resourceId]--;
 
            return;
        }
 
        if (\is_resource($this->stream)) {
            fclose($this->stream);
        }
    }
}