1 /*
2 * Copyright (C) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "parcel.h"
17
18 namespace OHOS {
Parcelable()19 Parcelable::Parcelable() : Parcelable(false)
20 {}
21
Parcelable(bool asRemote)22 Parcelable::Parcelable(bool asRemote)
23 {}
24
Parcel(Allocator * allocator)25 Parcel::Parcel(Allocator *allocator)
26 {}
27
~Parcel()28 Parcel::~Parcel()
29 {}
30
GetWritableBytes() const31 size_t Parcel::GetWritableBytes() const
32 {
33 return 0;
34 }
35
GetReadableBytes() const36 size_t Parcel::GetReadableBytes() const
37 {
38 return 0;
39 }
40
GetDataCapacity() const41 size_t Parcel::GetDataCapacity() const
42 {
43 return 0;
44 }
45
SetMaxCapacity(size_t maxCapacity)46 bool Parcel::SetMaxCapacity(size_t maxCapacity)
47 {
48 (void) maxCapacity;
49 return false;
50 }
51
SetAllocator(Allocator * allocator)52 bool Parcel::SetAllocator(Allocator *allocator)
53 {
54 (void) allocator;
55 return true;
56 }
57
CheckOffsets()58 bool Parcel::CheckOffsets()
59 {
60 return false;
61 }
62
SetDataCapacity(size_t newCapacity)63 bool Parcel::SetDataCapacity(size_t newCapacity)
64 {
65 (void) newCapacity;
66 return false;
67 }
68
SetDataSize(size_t dataSize)69 bool Parcel::SetDataSize(size_t dataSize)
70 {
71 (void) dataSize;
72 return true;
73 }
74
WriteDataBytes(const void * data,size_t size)75 bool Parcel::WriteDataBytes(const void *data, size_t size)
76 {
77 (void) data;
78 (void) size;
79 return true;
80 }
81
WritePadBytes(size_t padSize)82 void Parcel::WritePadBytes(size_t padSize)
83 {
84 (void) padSize;
85 }
86
WriteUnpadBuffer(const void * data,size_t size)87 bool Parcel::WriteUnpadBuffer(const void *data, size_t size)
88 {
89 (void) data;
90 (void) size;
91 return false;
92 }
93
94 template <typename T>
Write(T value)95 bool Parcel::Write(T value)
96 {
97 return false;
98 }
99
WriteInt32(int32_t value)100 bool Parcel::WriteInt32(int32_t value)
101 {
102 return Write<int32_t>(value);
103 }
104
WriteUint32(uint32_t value)105 bool Parcel::WriteUint32(uint32_t value)
106 {
107 return Write<uint32_t>(value);
108 }
109
WriteRemoteObject(const Parcelable * object)110 bool Parcel::WriteRemoteObject(const Parcelable *object)
111 {
112 (void) object;
113 return false;
114 }
115
WriteParcelable(const Parcelable * object)116 bool Parcel::WriteParcelable(const Parcelable *object)
117 {
118 (void) object;
119 return false;
120 }
121
122
123 template <typename T>
Read(T & value)124 bool Parcel::Read(T &value)
125 {
126 return false;
127 }
128
129 template <typename T>
Read()130 T Parcel::Read()
131 {
132 T lvalue {};
133 return Read<T>(lvalue) ? lvalue : 0;
134 }
135
ParseFrom(uintptr_t data,size_t size)136 bool Parcel::ParseFrom(uintptr_t data, size_t size)
137 {
138 (void) data;
139 (void) size;
140 return false;
141 }
142
ReadBuffer(size_t length)143 const uint8_t *Parcel::ReadBuffer(size_t length)
144 {
145 (void) length;
146 return nullptr;
147 }
148
ReadUnpadBuffer(size_t length)149 const uint8_t *Parcel::ReadUnpadBuffer(size_t length)
150 {
151 (void) length;
152 return nullptr;
153 }
154
GetReadPosition()155 size_t Parcel::GetReadPosition()
156 {
157 return 0;
158 }
159
ReadInt32()160 int32_t Parcel::ReadInt32()
161 {
162 return Read<int32_t>();
163 }
164
ReadUint32()165 uint32_t Parcel::ReadUint32()
166 {
167 return Read<uint32_t>();
168 }
169 } // namespace OHOS
170