1 :
2 : /*
3 : * Copyright 2011 Google Inc.
4 : *
5 : * Use of this source code is governed by a BSD-style license that can be
6 : * found in the LICENSE file.
7 : */
8 :
9 :
10 :
11 : #ifndef SkData_DEFINED
12 : #define SkData_DEFINED
13 :
14 : #include "SkRefCnt.h"
15 :
16 : /**
17 : * SkData holds an immutable data buffer. Not only is the data immutable,
18 : * but the actual ptr that is returned (by data() or bytes()) is guaranteed
19 : * to always be the same for the life of this instance.
20 : */
21 : class SkData : public SkRefCnt {
22 : public:
23 : /**
24 : * Returns the number of bytes stored.
25 : */
26 0 : size_t size() const { return fSize; }
27 :
28 : /**
29 : * Returns the ptr to the data.
30 : */
31 0 : const void* data() const { return fPtr; }
32 :
33 : /**
34 : * Like data(), returns a read-only ptr into the data, but in this case
35 : * it is cast to uint8_t*, to make it easy to add an offset to it.
36 : */
37 0 : const uint8_t* bytes() const {
38 0 : return reinterpret_cast<const uint8_t*>(fPtr);
39 : }
40 :
41 : /**
42 : * Helper to copy a range of the data into a caller-provided buffer.
43 : * Returns the actual number of bytes copied, after clamping offset and
44 : * length to the size of the data. If buffer is NULL, it is ignored, and
45 : * only the computed number of bytes is returned.
46 : */
47 : size_t copyRange(size_t offset, size_t length, void* buffer) const;
48 :
49 : /**
50 : * Function that, if provided, will be called when the SkData goes out
51 : * of scope, allowing for custom allocation/freeing of the data.
52 : */
53 : typedef void (*ReleaseProc)(const void* ptr, size_t length, void* context);
54 :
55 : /**
56 : * Create a new dataref by copying the specified data
57 : */
58 : static SkData* NewWithCopy(const void* data, size_t length);
59 :
60 : /**
61 : * Create a new dataref, taking the data ptr as is, and using the
62 : * releaseproc to free it. The proc may be NULL.
63 : */
64 : static SkData* NewWithProc(const void* data, size_t length,
65 : ReleaseProc proc, void* context);
66 :
67 : /**
68 : * Create a new dataref, reference the data ptr as is, and calling
69 : * sk_free to delete it.
70 : */
71 : static SkData* NewFromMalloc(const void* data, size_t length);
72 :
73 : /**
74 : * Create a new dataref using a subset of the data in the specified
75 : * src dataref.
76 : */
77 : static SkData* NewSubset(const SkData* src, size_t offset, size_t length);
78 :
79 : /**
80 : * Returns a new empty dataref (or a reference to a shared empty dataref).
81 : * New or shared, the caller must see that unref() is eventually called.
82 : */
83 : static SkData* NewEmpty();
84 :
85 : private:
86 : ReleaseProc fReleaseProc;
87 : void* fReleaseProcContext;
88 :
89 : const void* fPtr;
90 : size_t fSize;
91 :
92 : SkData(const void* ptr, size_t size, ReleaseProc, void* context);
93 : ~SkData();
94 : };
95 :
96 : /**
97 : * Specialized version of SkAutoTUnref<SkData> for automatically unref-ing a
98 : * SkData. If the SkData is null, data(), bytes() and size() will return 0.
99 : */
100 : class SkAutoDataUnref : SkNoncopyable {
101 : public:
102 : SkAutoDataUnref(SkData* data) : fRef(data) {
103 : if (data) {
104 : fData = data->data();
105 : fSize = data->size();
106 : } else {
107 : fData = NULL;
108 : fSize = 0;
109 : }
110 : }
111 : ~SkAutoDataUnref() {
112 : SkSafeUnref(fRef);
113 : }
114 :
115 : const void* data() const { return fData; }
116 : const uint8_t* bytes() const {
117 : return reinterpret_cast<const uint8_t*> (fData);
118 : }
119 : size_t size() const { return fSize; }
120 : SkData* get() const { return fRef; }
121 :
122 : void release() {
123 : if (fRef) {
124 : fRef->unref();
125 : fRef = NULL;
126 : fData = NULL;
127 : fSize = 0;
128 : }
129 : }
130 :
131 : private:
132 : SkData* fRef;
133 : const void* fData;
134 : size_t fSize;
135 : };
136 :
137 : #endif
|