Line data Source code
1 : /*
2 : *
3 : * Copyright (c) 2021 Project CHIP Authors
4 : *
5 : * Licensed under the Apache License, Version 2.0 (the "License");
6 : * you may not use this file except in compliance with the License.
7 : * You may obtain a copy of the License at
8 : *
9 : * http://www.apache.org/licenses/LICENSE-2.0
10 : *
11 : * Unless required by applicable law or agreed to in writing, software
12 : * distributed under the License is distributed on an "AS IS" BASIS,
13 : * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 : * See the License for the specific language governing permissions and
15 : * limitations under the License.
16 : */
17 :
18 : /**
19 : * @file
20 : * General faults could be detected by the Node.
21 : */
22 :
23 : #pragma once
24 :
25 : #include <lib/core/CHIPError.h>
26 : #include <lib/support/CodeUtils.h>
27 :
28 : namespace chip {
29 : namespace DeviceLayer {
30 :
31 : static constexpr size_t kMaxHardwareFaults = 11;
32 : static constexpr size_t kMaxRadioFaults = 7;
33 : static constexpr size_t kMaxNetworkFaults = 4;
34 :
35 : template <size_t N>
36 : class GeneralFaults
37 : {
38 : public:
39 : /* The iterator */
40 : class Iterator
41 : {
42 : public:
43 : Iterator(const GeneralFaults<N> * GeneralFaults, int index);
44 : uint8_t operator*() const;
45 : Iterator & operator++();
46 : bool operator!=(const Iterator & other) const;
47 :
48 : private:
49 : const GeneralFaults<N> * mGeneralFaultsPtr;
50 : int mIndex = -1;
51 : };
52 :
53 0 : GeneralFaults() = default;
54 0 : ~GeneralFaults() { mSize = 0; }
55 :
56 : CHIP_ERROR add(const uint8_t value);
57 :
58 : const uint8_t * data() const { return mData; }
59 : size_t size() const;
60 : uint8_t operator[](int index) const;
61 :
62 : Iterator begin() const;
63 : Iterator end() const;
64 :
65 : private:
66 : uint8_t mData[N];
67 : int mSize = 0;
68 : };
69 :
70 : /*
71 : * GeneralFaults methods
72 : **/
73 : template <size_t N>
74 0 : inline CHIP_ERROR GeneralFaults<N>::add(const uint8_t value)
75 : {
76 0 : if (mSize == N)
77 : {
78 0 : return CHIP_ERROR_NO_MEMORY;
79 : }
80 :
81 : // add the new element
82 0 : mData[mSize] = value;
83 0 : ++mSize;
84 0 : return CHIP_NO_ERROR;
85 : }
86 :
87 : template <size_t N>
88 : inline size_t GeneralFaults<N>::size() const
89 : {
90 : return static_cast<size_t>(mSize);
91 : }
92 :
93 : template <size_t N>
94 : inline uint8_t GeneralFaults<N>::operator[](int index) const
95 : {
96 : VerifyOrDie(index < mSize);
97 : return mData[index];
98 : }
99 :
100 : template <size_t N>
101 : inline typename GeneralFaults<N>::Iterator GeneralFaults<N>::begin() const
102 : {
103 : return GeneralFaults<N>::Iterator{ this, 0 };
104 : }
105 :
106 : template <size_t N>
107 : inline typename GeneralFaults<N>::Iterator GeneralFaults<N>::end() const
108 : {
109 : return GeneralFaults<N>::Iterator{ this, mSize };
110 : }
111 :
112 : /*
113 : * Iterator methods
114 : **/
115 : template <size_t N>
116 : inline GeneralFaults<N>::Iterator::Iterator(const GeneralFaults<N> * pGeneralFaults, int index) :
117 : mGeneralFaultsPtr(pGeneralFaults), mIndex(index)
118 : {}
119 :
120 : template <size_t N>
121 : inline uint8_t GeneralFaults<N>::Iterator::operator*() const
122 : {
123 : return mGeneralFaultsPtr->operator[](mIndex);
124 : }
125 :
126 : template <size_t N>
127 : inline typename GeneralFaults<N>::Iterator & GeneralFaults<N>::Iterator::operator++()
128 : {
129 : ++mIndex;
130 : return *this;
131 : }
132 :
133 : template <size_t N>
134 : inline bool GeneralFaults<N>::Iterator::operator!=(const GeneralFaults<N>::Iterator & other) const
135 : {
136 : return mIndex != other.mIndex;
137 : }
138 :
139 : } // namespace DeviceLayer
140 : } // namespace chip
|
