1/*
2 * Copyright (c) 2021-2023 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#ifndef STREAM_BUFFER_H
17#define STREAM_BUFFER_H
18
19#include <cstdint>
20#include <string>
21#include <vector>
22
23#include "proto.h"
24#include "nocopyable.h"
25#include "securec.h"
26#include "devicestatus_define.h"
27
28#undef LOG_TAG
29#define LOG_TAG "StreamBuffer"
30
31namespace OHOS {
32namespace Msdp {
33class StreamBuffer {
34public:
35    StreamBuffer() = default;
36    DISALLOW_MOVE(StreamBuffer);
37    explicit StreamBuffer(const StreamBuffer &buf);
38    virtual StreamBuffer &operator=(const StreamBuffer &buffer);
39    virtual ~StreamBuffer() = default;
40
41    size_t Size() const;
42    int32_t ResidualSize() const;
43    int32_t GetAvailableBufSize() const;
44    void Reset();
45    void Clean();
46    bool SeekReadPos(int32_t n);
47    bool Read(std::string &buf);
48    bool Write(const std::string &buf);
49    bool Read(StreamBuffer &buf);
50    bool Write(const StreamBuffer &buf);
51    bool Read(char *buf, size_t size);
52    bool empty() const;
53    bool ChkRWError() const;
54    virtual bool Write(const char *buf, size_t size);
55    const std::string &GetErrorStatusRemark() const;
56    const char *Data() const;
57    const char *ReadBuf() const;
58    template<typename T>
59    bool Read(T &data);
60    template<typename T>
61    bool Write(const T &data);
62    template<typename T>
63    StreamBuffer &operator >> (T &data);
64    template<typename T>
65    StreamBuffer &operator << (const T &data);
66
67protected:
68    bool Clone(const StreamBuffer &buf);
69
70protected:
71    enum class ErrorStatus {
72        ERROR_STATUS_OK,
73        ERROR_STATUS_READ,
74        ERROR_STATUS_WRITE
75    };
76    ErrorStatus rwErrorStatus_ { ErrorStatus::ERROR_STATUS_OK };
77    int32_t rCount_ { 0 };
78    int32_t wCount_ { 0 };
79    int32_t rPos_ { 0 };
80    int32_t wPos_ { 0 };
81    char szBuff_[MAX_STREAM_BUF_SIZE + 1] {};
82};
83
84template<typename T>
85bool StreamBuffer::Read(T &data)
86{
87    if (!Read(reinterpret_cast<char *>(&data), sizeof(data))) {
88        FI_HILOGE("[%{public}s], size:%{public}zu, count:%{public}d, errCode:%{public}d",
89            GetErrorStatusRemark().c_str(), sizeof(data), rCount_ + 1, STREAM_BUF_READ_FAIL);
90        return false;
91    }
92    return true;
93}
94
95template<typename T>
96bool StreamBuffer::Write(const T &data)
97{
98    if (!Write(reinterpret_cast<const char *>(&data), sizeof(data))) {
99        FI_HILOGE("[%{public}s], size:%{public}zu, count:%{public}d, errCode:%{public}d",
100            GetErrorStatusRemark().c_str(), sizeof(data), wCount_ + 1, STREAM_BUF_WRITE_FAIL);
101        return false;
102    }
103    return true;
104}
105
106template<typename T>
107StreamBuffer &StreamBuffer::operator>>(T &data)
108{
109    if (!Read(data)) {
110        FI_HILOGW("Read data failed");
111    }
112    return *this;
113}
114
115template<typename T>
116StreamBuffer &StreamBuffer::operator<<(const T &data)
117{
118    if (!Write(data)) {
119        FI_HILOGW("Write data failed");
120    }
121    return *this;
122}
123} // namespace Msdp
124} // namespace OHOS
125#endif // STREAM_BUFFER_H