ot::Spinel::MultiFrameBuffer

class MultiFrameBuffer : public FrameWritePointer { public:     MultiFrameBuffer(void)         : FrameWritePointer()     {         Clear();     }     void Clear(void)     {         mWriteFrameStart = mBuffer;         mWritePointer    = mBuffer + kHeaderSize;         mRemainingLength = kSize - kHeaderSize;         IgnoreError(SetSkipLength(0));     }     bool HasFrame(void) const { return (mWritePointer != GetFrame()); }     otError SetLength(uint16_t aLength)     {         otError error = OT_ERROR_NO_BUFS;         if (GetFrame() + aLength <= GetArrayEnd(mBuffer))         {             mWritePointer    = GetFrame() + aLength;             mRemainingLength = static_cast<uint16_t>(mBuffer + kSize - mWritePointer);             error            = OT_ERROR_NONE;         }         return error;     }     uint16_t GetLength(void) const { return static_cast<uint16_t>(mWritePointer - GetFrame()); }     otError SetSkipLength(uint16_t aSkipLength)     {         otError error = OT_ERROR_NO_BUFS;         if (mWriteFrameStart + kHeaderSize + aSkipLength <= GetArrayEnd(mBuffer))         {             Lib::Utils::LittleEndian::WriteUint16(aSkipLength, mWriteFrameStart + kHeaderSkipLengthOffset);             mWritePointer    = GetFrame();             mRemainingLength = static_cast<uint16_t>(mBuffer + kSize - mWritePointer);             error            = OT_ERROR_NONE;         }         return error;     }     uint16_t GetSkipLength(void) const     {         return Lib::Utils::LittleEndian::ReadUint16(mWriteFrameStart + kHeaderSkipLengthOffset);     }     uint8_t *GetFrame(void) const { return mWriteFrameStart + kHeaderSize + GetSkipLength(); }     uint16_t GetFrameMaxLength(void) const { return static_cast<uint16_t>(mBuffer + kSize - GetFrame()); }     otError SaveFrame(void)     {         otError error = OT_ERROR_NONE;         if (!CanWrite(kHeaderSize))         {             error = OT_ERROR_NO_BUFS;         }         else         {             Lib::Utils::LittleEndian::WriteUint16(GetSkipLength() + GetLength(),                                                   mWriteFrameStart + kHeaderTotalLengthOffset);             mWriteFrameStart = mWritePointer;             IgnoreError(SetSkipLength(0));         }         return error;     }     void DiscardFrame(void)     {         IgnoreError(SetSkipLength(0));         mWritePointer    = GetFrame();         mRemainingLength = static_cast<uint16_t>(mBuffer + kSize - mWritePointer);     }     bool HasSavedFrame(void) const { return (mWriteFrameStart != mBuffer); }     otError GetNextSavedFrame(uint8_t *&aFrame, uint16_t &aLength)     {         otError error = OT_ERROR_NONE;         assert(aFrame == nullptr || (mBuffer <= aFrame && aFrame < GetArrayEnd(mBuffer)));         aFrame = (aFrame == nullptr) ? mBuffer : aFrame + aLength;         if (HasSavedFrame() && (aFrame != mWriteFrameStart))         {             uint16_t totalLength = Lib::Utils::LittleEndian::ReadUint16(aFrame + kHeaderTotalLengthOffset);             uint16_t skipLength  = Lib::Utils::LittleEndian::ReadUint16(aFrame + kHeaderSkipLengthOffset);             aLength = totalLength - skipLength;             aFrame += kHeaderSize + skipLength;         }         else         {             aLength = 0;             aFrame  = nullptr;             error   = OT_ERROR_NOT_FOUND;         }         return error;     }     void ClearSavedFrames(void)     {         uint16_t len = static_cast<uint16_t>(mWriteFrameStart - mBuffer);         if (len > 0)         {             memmove(mBuffer, mWriteFrameStart, static_cast<uint16_t>(mWritePointer - mWriteFrameStart));             mWritePointer -= len;             mWriteFrameStart -= len;             mRemainingLength += len;         }     } private:     enum     {         kHeaderTotalLengthOffset = 0,         kHeaderSkipLengthOffset  = sizeof(uint16_t),         kHeaderSize              = sizeof(uint16_t) + sizeof(uint16_t),     };     template <typename Type, uint16_t kArrayLength> Type *GetArrayEnd(Type (&aArray)[kArrayLength])     {         return &aArray[kArrayLength];     }     template <typename Type, uint16_t kArrayLength> const Type *GetArrayEnd(const Type (&aArray)[kArrayLength])     {         return &aArray[kArrayLength];     }     static void IgnoreError(otError aError) { (void)(aError); }     uint8_t  mBuffer[kSize];     uint8_t *mWriteFrameStart;  };