From 8e88ae8e0b82dd0e1a70ee46817dd14637b771cb Mon Sep 17 00:00:00 2001 From: Hideaki Tai Date: Mon, 5 Apr 2021 10:43:01 +0900 Subject: [PATCH] update MsgPack to v0.3.5 --- README.md | 2 +- .../MsgPack/util/ArxContainer/ArxContainer.h | 866 ++++++++---------- .../ArxContainer/initializer_list.h | 32 +- .../MsgPack/util/ArxContainer/README.md | 3 - .../MsgPack/util/ArxContainer/library.json | 2 +- .../util/ArxContainer/library.properties | 2 +- util/MsgPack/README.md | 2 +- util/MsgPack/library.json | 2 +- util/MsgPack/library.properties | 2 +- 9 files changed, 430 insertions(+), 483 deletions(-) diff --git a/README.md b/README.md index 0027af1..634fdae 100644 --- a/README.md +++ b/README.md @@ -239,7 +239,7 @@ These macros have no effect for STL enabled boards. ## Embedded Libraries -- [MsgPack v0.3.4](https://github.com/hideakitai/MsgPack) +- [MsgPack v0.3.5](https://github.com/hideakitai/MsgPack) - [Packetizer v0.5.6](https://github.com/hideakitai/Packetizer) diff --git a/util/MsgPack/MsgPack/util/ArxContainer/ArxContainer.h b/util/MsgPack/MsgPack/util/ArxContainer/ArxContainer.h index 72b7830..42ad723 100644 --- a/util/MsgPack/MsgPack/util/ArxContainer/ArxContainer.h +++ b/util/MsgPack/MsgPack/util/ArxContainer/ArxContainer.h @@ -4,553 +4,501 @@ #define ARX_RINGBUFFER_H #if __cplusplus < 201103L - #error "C++11 must be enabled in the compiler for this library to work, please check your compiler flags" +#error "C++11 must be enabled in the compiler for this library to work, please check your compiler flags" #endif #include "ArxContainer/has_include.h" #include "ArxContainer/has_libstdcplusplus.h" #ifdef ARDUINO - #include +#include #endif #include "ArxContainer/replace_minmax_macros.h" #include "ArxContainer/initializer_list.h" -#if ARX_HAVE_LIBSTDCPLUSPLUS >= 201103L // Have libstdc++11 +#if ARX_HAVE_LIBSTDCPLUSPLUS >= 201103L // Have libstdc++11 #include #include #include -#else // Do not have libstdc++11 - +#else // Do not have libstdc++11 #ifndef ARX_VECTOR_DEFAULT_SIZE #define ARX_VECTOR_DEFAULT_SIZE 16 -#endif // ARX_VECTOR_DEFAULT_SIZE +#endif // ARX_VECTOR_DEFAULT_SIZE #ifndef ARX_DEQUE_DEFAULT_SIZE #define ARX_DEQUE_DEFAULT_SIZE 16 -#endif // ARX_DEQUE_DEFAULT_SIZE +#endif // ARX_DEQUE_DEFAULT_SIZE #ifndef ARX_MAP_DEFAULT_SIZE #define ARX_MAP_DEFAULT_SIZE 16 -#endif // ARX_MAP_DEFAULT_SIZE - +#endif // ARX_MAP_DEFAULT_SIZE namespace arx { - namespace container - { - namespace detail - { - template - T&& move(T& t){ return static_cast(t); } - } +namespace container { + namespace detail { + template + T&& move(T& t) { return static_cast(t); } + } // namespace detail +} // namespace container + +template +class RingBuffer { +protected: + T queue_[N + 1]; // add +1 size not to access invalid pointer for end() + int head_ {0}; + int tail_ {0}; + +public: + RingBuffer() + : queue_() + , head_ {0} + , tail_ {0} { } - template - class RingBuffer - { - protected: - - T queue_[N]; - int head_ {0}; - int tail_ {0}; - - public: - - RingBuffer() - : queue_() - , head_ {0} - , tail_{0} - { - } - - RingBuffer(std::initializer_list lst) - : queue_() - , head_(0) - , tail_(0) - { - for (auto it = lst.begin() ; it != lst.end() ; ++it) - { - queue_[tail_] = *it; - ++tail_; - } - } - - // copy - explicit RingBuffer(const RingBuffer& r) - : queue_() - , head_(r.head_) - , tail_(r.tail_) - { - for (size_t i = 0; i < r.size(); ++i) - queue_[i] = r.queue_[i]; - } - RingBuffer& operator= (const RingBuffer& r) - { - head_ = r.head_; - tail_ = r.tail_; - for (size_t i = 0; i < r.size(); ++i) - queue_[i] = r.queue_[i]; - return *this; - } - - // move - RingBuffer(RingBuffer&& r) - { - head_ = container::detail::move(r.head_); - tail_ = container::detail::move(r.tail_); - for (size_t i = 0; i < r.size(); ++i) - queue_[i] = container::detail::move(r.queue_[i]); - } - - RingBuffer& operator= (RingBuffer&& r) - { - head_ = container::detail::move(r.head_); - tail_ = container::detail::move(r.tail_); - for (size_t i = 0; i < r.size(); ++i) - queue_[i] = container::detail::move(r.queue_[i]); - return *this; + RingBuffer(std::initializer_list lst) + : queue_() + , head_(0) + , tail_(0) { + for (auto it = lst.begin(); it != lst.end(); ++it) { + queue_[tail_] = *it; + ++tail_; } + } - virtual ~RingBuffer() {} + // copy + explicit RingBuffer(const RingBuffer& r) + : queue_() + , head_(r.head_) + , tail_(r.tail_) { + for (size_t i = 0; i < r.size(); ++i) + queue_[i] = r.queue_[i]; + } + RingBuffer& operator=(const RingBuffer& r) { + head_ = r.head_; + tail_ = r.tail_; + for (size_t i = 0; i < r.size(); ++i) + queue_[i] = r.queue_[i]; + return *this; + } - using iterator = T*; - using const_iterator = const T*; + // move + RingBuffer(RingBuffer&& r) { + head_ = container::detail::move(r.head_); + tail_ = container::detail::move(r.tail_); + for (size_t i = 0; i < r.size(); ++i) + queue_[i] = container::detail::move(r.queue_[i]); + } - size_t capacity() const { return N; }; - size_t size() const { return tail_ - head_; } - inline const T* data() const { return &(get(head_)); } - T* data() { return &(get(head_)); } - bool empty() const { return tail_ == head_; } - void clear() { head_ = 0; tail_ = 0; } + RingBuffer& operator=(RingBuffer&& r) { + head_ = container::detail::move(r.head_); + tail_ = container::detail::move(r.tail_); + for (size_t i = 0; i < r.size(); ++i) + queue_[i] = container::detail::move(r.queue_[i]); + return *this; + } - void pop() { pop_front(); } - void pop_front() - { - if (size() == 0) return; - if (size() == 1) clear(); - else head_++; - } - void pop_back() - { - if (size() == 0) return; - if (size() == 1) clear(); - else tail_--; - } + virtual ~RingBuffer() {} - void push(const T& data) { push_back(data); } - void push(T&& data) { push_back(data); } - void push_back(const T& data) - { - get(tail_++) = data; - if (size() > N) ++head_; - }; - void push_back(T&& data) - { - get(tail_++) = data; - if (size() > N) ++head_; - }; - void push_front(const T& data) - { - get(head_--) = data; - if (size() > N) --tail_; - }; - void push_front(T&& data) - { - get(head_--) = data; - if (size() > N) --tail_; - }; - void emplace(const T& data) { push(data); } - void emplace(T&& data) { push(data); } - void emplace_back(const T& data) { push_back(data); } - void emplace_back(T&& data) { push_back(data); } - - const T& front() const { return get(head_); }; - T& front() { return get(head_); }; - - const T& back() const { return get(tail_ - 1); } - T& back() { return get(tail_ - 1); } - - const T& operator[] (size_t index) const { return get(head_ + (int)index); } - T& operator[] (size_t index) { return get(head_ + (int)index); } - - iterator begin() { return ptr(head_); } - iterator end() { return (queue_ + tail_ + 1); } - - const_iterator begin() const { return (const_iterator)ptr(head_); } - const_iterator end() const { return (const_iterator)(queue_ + tail_ + 1); } - - iterator erase(iterator p) - { - if (p == end()) return p; - for (T* pos = p + 1; pos != end(); ++pos) - *(pos - 1) = *pos; - --tail_; - return p; - } + using iterator = T*; + using const_iterator = const T*; - void resize(size_t sz) - { - size_t s = size(); - if (sz > size()) - { - for (size_t i = 0; i < sz - s; ++i) push(T()); - } - else if (sz < size()) - { - for (size_t i = 0; i < s - sz; ++i) pop(); - } - } + size_t capacity() const { return N; }; + size_t size() const { return tail_ - head_; } + inline const T* data() const { return &(get(head_)); } + T* data() { return &(get(head_)); } + bool empty() const { return tail_ == head_; } + void clear() { + head_ = 0; + tail_ = 0; + } - void assign(const_iterator first, const_iterator end) - { + void pop() { pop_front(); } + void pop_front() { + if (size() == 0) return; + if (size() == 1) clear(); - const char* p = first; - while (p != end) push(*p++); - } + else + head_++; + } + void pop_back() { + if (size() == 0) return; + if (size() == 1) + clear(); + else + tail_--; + } - void shrink_to_fit() - { - // dummy - } + void push(const T& data) { push_back(data); } + void push(T&& data) { push_back(data); } + void push_back(const T& data) { + get(tail_++) = data; + if (size() > N) ++head_; + }; + void push_back(T&& data) { + get(tail_++) = data; + if (size() > N) ++head_; + }; + void push_front(const T& data) { + get(head_--) = data; + if (size() > N) --tail_; + }; + void push_front(T&& data) { + get(head_--) = data; + if (size() > N) --tail_; + }; + void emplace(const T& data) { push(data); } + void emplace(T&& data) { push(data); } + void emplace_back(const T& data) { push_back(data); } + void emplace_back(T&& data) { push_back(data); } - void reserve(size_t n) - { - (void)n; - // dummy - } + const T& front() const { return get(head_); }; + T& front() { return get(head_); }; - void insert(const_iterator pos, const_iterator first, const_iterator last) - { - if (pos != end()) - { - size_t sz = 0; - { - iterator it = (iterator)first; - for (; it != last; ++it) ++sz; - } - iterator it = end() + sz - 1; - for (int i = sz; i > 0; --i, --it) - { - *it = *(it - sz); - } - it = (iterator)pos; - for (size_t i = 0; i < sz; ++i) - { - *it = *(first + i); - } - } - else - { - iterator it = (iterator)first; - for (; it != last; ++it) - { - push_back(*it); - } - } - } + const T& back() const { return get(tail_ - 1); } + T& back() { return get(tail_ - 1); } - private: + const T& operator[](size_t index) const { return get(head_ + (int)index); } + T& operator[](size_t index) { return get(head_ + (int)index); } - T& get(const int i) - { - if (i >= 0) return queue_[i % N]; - else return queue_[N - abs(i % N)]; - } + iterator begin() { return ptr(head_); } + iterator end() { return (iterator)(queue_ + tail_); } - const T& get(const int i) const - { - if (i >= 0) return queue_[i % N]; - else return queue_[N - abs(i % N)]; - } + const_iterator begin() const { return (const_iterator)ptr(head_); } + const_iterator end() const { return (const_iterator)(queue_ + tail_); } - T* ptr(const int i) - { - if (i >= 0) return (T*)(queue_ + i % N); - else return (T*)(queue_ + N - abs(i % N)); - } + iterator erase(iterator p) { + if (p == end()) return p; + for (T* pos = p; pos != end(); ++pos) + *pos = *(pos + 1); + --tail_; + return p; + } - const T* ptr(const int i) const - { - if (i >= 0) return (T*)(queue_ + i % N); - else return (T*)(queue_ + N - abs(i % N)); + void resize(size_t sz) { + size_t s = size(); + if (sz > size()) { + for (size_t i = 0; i < sz - s; ++i) push(T()); + } else if (sz < size()) { + for (size_t i = 0; i < s - sz; ++i) pop(); } - - }; - - template - bool operator== (const RingBuffer& x, const RingBuffer& y) - { - if (x.size() != y.size()) return false; - for (size_t i = 0; i < x.size(); ++i) - if (x[i] != y[i]) return false; - return true; } - template - bool operator!= (const RingBuffer& x, const RingBuffer& y) - { - return !(x == y); + void assign(const_iterator first, const_iterator end) { + clear(); + const char* p = first; + while (p != end) push(*p++); } + void shrink_to_fit() { + // dummy + } - template - struct vector : public RingBuffer - { - vector() : RingBuffer() { } - vector(std::initializer_list lst) : RingBuffer(lst) { } - - // copy - vector(const vector& r) : RingBuffer(r) { } - - vector& operator= (const vector& r) - { - RingBuffer::operator=(r); - return *this; - } - - // move - vector(vector&& r) : RingBuffer(r) { } - - vector& operator= (vector&& r) - { - RingBuffer::operator=(r); - return *this; - } - - virtual ~vector() {} - - private: - using RingBuffer::pop; - using RingBuffer::pop_front; - using RingBuffer::push; - using RingBuffer::push_front; - using RingBuffer::emplace; - }; - - - template - struct deque : public RingBuffer - { - deque() : RingBuffer() { } - deque(std::initializer_list lst) : RingBuffer(lst) { } - - // copy - deque(const deque& r) : RingBuffer(r) { } - - deque& operator= (const deque& r) - { - RingBuffer::operator=(r); - return *this; - } - - // move - deque(deque&& r) : RingBuffer(r) { } + void reserve(size_t n) { + (void)n; + // dummy + } - deque& operator= (deque&& r) - { - RingBuffer::operator=(r); - return *this; + void insert(const_iterator pos, const_iterator first, const_iterator last) { + if (pos != end()) { + size_t sz = 0; + { + iterator it = (iterator)first; + for (; it != last; ++it) ++sz; + } + iterator it = end() + sz - 1; + for (int i = sz; i > 0; --i, --it) { + *it = *(it - sz); + } + it = (iterator)pos; + for (size_t i = 0; i < sz; ++i) { + *it = *(first + i); + } + } else { + iterator it = (iterator)first; + for (; it != last; ++it) { + push_back(*it); + } } + } - virtual ~deque() {} - - private: - using RingBuffer::capacity; - using RingBuffer::pop; - using RingBuffer::push; - using RingBuffer::emplace; - using RingBuffer::assign; - using RingBuffer::begin; - using RingBuffer::end; - }; - - - template - struct pair - { - T1 first; - T2 second; - }; +private: + T& get(const int i) { + if (i >= 0) + return queue_[i % N]; + else + return queue_[N - abs(i % N)]; + } - template - pair make_pair(const T1& t1, const T2& t2) - { - return {t1, t2}; - }; + const T& get(const int i) const { + if (i >= 0) + return queue_[i % N]; + else + return queue_[N - abs(i % N)]; + } - template - bool operator== (const pair& x, const pair& y) - { - return (x.first == y.first) && (x.second == y.second); + T* ptr(const int i) { + if (i >= 0) + return (T*)(queue_ + i % N); + else + return (T*)(queue_ + N - abs(i % N)); } - template - bool operator!= (const pair& x, const pair& y) - { - return !(x == y); + const T* ptr(const int i) const { + if (i >= 0) + return (T*)(queue_ + i % N); + else + return (T*)(queue_ + N - abs(i % N)); + } +}; + +template +bool operator==(const RingBuffer& x, const RingBuffer& y) { + if (x.size() != y.size()) return false; + for (size_t i = 0; i < x.size(); ++i) + if (x[i] != y[i]) return false; + return true; +} + +template +bool operator!=(const RingBuffer& x, const RingBuffer& y) { + return !(x == y); +} + +template +struct vector : public RingBuffer { + vector() + : RingBuffer() {} + vector(std::initializer_list lst) + : RingBuffer(lst) {} + + // copy + vector(const vector& r) + : RingBuffer(r) {} + + vector& operator=(const vector& r) { + RingBuffer::operator=(r); + return *this; } + // move + vector(vector&& r) + : RingBuffer(r) {} - template - struct map : public RingBuffer, N> - { - using iterator = typename RingBuffer, N>::iterator; - using const_iterator = typename RingBuffer, N>::const_iterator; + vector& operator=(vector&& r) { + RingBuffer::operator=(r); + return *this; + } - map() : RingBuffer, N>() { } - map(std::initializer_list> lst) : RingBuffer, N>(lst) { } + virtual ~vector() {} + +private: + using RingBuffer::pop; + using RingBuffer::pop_front; + using RingBuffer::push; + using RingBuffer::push_front; + using RingBuffer::emplace; +}; + +template +struct deque : public RingBuffer { + deque() + : RingBuffer() {} + deque(std::initializer_list lst) + : RingBuffer(lst) {} + + // copy + deque(const deque& r) + : RingBuffer(r) {} + + deque& operator=(const deque& r) { + RingBuffer::operator=(r); + return *this; + } - // copy - map(const map& r) : RingBuffer, N>(r) { } + // move + deque(deque&& r) + : RingBuffer(r) {} - map& operator= (const map& r) - { - RingBuffer, N>::operator=(r); - return *this; - } + deque& operator=(deque&& r) { + RingBuffer::operator=(r); + return *this; + } - // move - map(map&& r) : RingBuffer(r) { } + virtual ~deque() {} + +private: + using RingBuffer::capacity; + using RingBuffer::pop; + using RingBuffer::push; + using RingBuffer::emplace; + using RingBuffer::assign; + using RingBuffer::begin; + using RingBuffer::end; +}; + +template +struct pair { + T1 first; + T2 second; +}; + +template +pair make_pair(const T1& t1, const T2& t2) { + return {t1, t2}; +}; + +template +bool operator==(const pair& x, const pair& y) { + return (x.first == y.first) && (x.second == y.second); +} + +template +bool operator!=(const pair& x, const pair& y) { + return !(x == y); +} + +template +struct map : public RingBuffer, N> { + using iterator = typename RingBuffer, N>::iterator; + using const_iterator = typename RingBuffer, N>::const_iterator; + + map() + : RingBuffer, N>() {} + map(std::initializer_list > lst) + : RingBuffer, N>(lst) {} + + // copy + map(const map& r) + : RingBuffer, N>(r) {} + + map& operator=(const map& r) { + RingBuffer, N>::operator=(r); + return *this; + } - map& operator= (map&& r) - { - RingBuffer, N>::operator=(r); - return *this; - } + // move + map(map&& r) + : RingBuffer(r) {} - virtual ~map() {} + map& operator=(map&& r) { + RingBuffer, N>::operator=(r); + return *this; + } - const_iterator find(const Key& key) const - { - for (size_t i = 0; i < this->size(); ++i) - { - const_iterator it = this->begin() + i; - if (key == it->first) - return it; - } - return this->end(); - } + virtual ~map() {} - iterator find(const Key& key) - { - for (size_t i = 0; i < this->size(); ++i) - { - iterator it = this->begin() + i; - if (key == it->first) - return it; - } - return this->end(); + const_iterator find(const Key& key) const { + for (size_t i = 0; i < this->size(); ++i) { + const_iterator it = this->begin() + i; + if (key == it->first) + return it; } + return this->end(); + } - pair insert(const Key& key, const T& t) - { - bool b {false}; - iterator it = find(key); - if (it == this->end()) - { - this->push(make_pair(key, t)); - b = true; - it = this->end() - 1; - } - return {it, b}; + iterator find(const Key& key) { + for (size_t i = 0; i < this->size(); ++i) { + iterator it = this->begin() + i; + if (key == it->first) + return it; } + return this->end(); + } - pair insert(const pair& p) - { - bool b {false}; - const_iterator it = find(p.first); - if (it == this->end()) - { - this->push(p); - b = true; - it = this->end() - 1; - } - return {(iterator)it, b}; + pair insert(const Key& key, const T& t) { + bool b {false}; + iterator it = find(key); + if (it == this->end()) { + this->push(make_pair(key, t)); + b = true; + it = this->end() - 1; } + return {it, b}; + } - pair emplace(const Key& key, const T& t) - { - return insert(key, t); + pair insert(const pair& p) { + bool b {false}; + const_iterator it = find(p.first); + if (it == this->end()) { + this->push(p); + b = true; + it = this->end() - 1; } + return {(iterator)it, b}; + } - pair emplace(const pair& p) - { - return insert(p); - } + pair emplace(const Key& key, const T& t) { + return insert(key, t); + } - const T& at(const Key& key) const - { - // iterator it = find(key); - // if (it != this->end()) return it->second; - // return T(); - return find(key)->second; - } + pair emplace(const pair& p) { + return insert(p); + } - T& at(const Key& key) - { - // iterator it = find(key); - // if (it != this->end()) return it->second; - // return T(); - return find(key)->second; - } + const T& at(const Key& key) const { + // iterator it = find(key); + // if (it != this->end()) return it->second; + // return T(); + return find(key)->second; + } - iterator erase(const iterator it) - { - iterator i = (iterator)find(it->first); - if (i != this->end()) - { - return this->erase(i); - } - return this->end(); - } + T& at(const Key& key) { + // iterator it = find(key); + // if (it != this->end()) return it->second; + // return T(); + return find(key)->second; + } - iterator erase(const size_t index) - { - if (index < this->size()) - { - iterator it = this->begin() + index; - return this->erase(it); - } - return this->end(); + iterator erase(const iterator it) { + iterator i = (iterator)find(it->first); + if (i != this->end()) { + return this->erase(i); } + return this->end(); + } - T& operator[] (const Key& key) - { - iterator it = find(key); - if (it != this->end()) return it->second; - - insert(::arx::make_pair(key, T())); - return this->back().second; + iterator erase(const size_t index) { + if (index < this->size()) { + iterator it = this->begin() + index; + return this->erase(it); } + return this->end(); + } - private: - - using RingBuffer, N>::capacity; - using RingBuffer, N>::data; - using RingBuffer, N>::pop; - using RingBuffer, N>::pop_front; - using RingBuffer, N>::pop_back; - using RingBuffer, N>::push; - using RingBuffer, N>::push_back; - using RingBuffer, N>::push_front; - using RingBuffer, N>::emplace_back; - using RingBuffer, N>::front; - using RingBuffer, N>::back; - using RingBuffer, N>::resize; - using RingBuffer, N>::assign; - using RingBuffer, N>::shrink_to_fit; - }; + T& operator[](const Key& key) { + iterator it = find(key); + if (it != this->end()) return it->second; -} // namespace arx + insert(::arx::make_pair(key, T())); + return this->back().second; + } -template +private: + using RingBuffer, N>::capacity; + using RingBuffer, N>::data; + using RingBuffer, N>::pop; + using RingBuffer, N>::pop_front; + using RingBuffer, N>::pop_back; + using RingBuffer, N>::push; + using RingBuffer, N>::push_back; + using RingBuffer, N>::push_front; + using RingBuffer, N>::emplace_back; + using RingBuffer, N>::front; + using RingBuffer, N>::back; + using RingBuffer, N>::resize; + using RingBuffer, N>::assign; + using RingBuffer, N>::shrink_to_fit; +}; + +} // namespace arx + +template using ArxRingBuffer = arx::RingBuffer; - -#endif // Do not have libstdc++11 -#endif // ARX_RINGBUFFER_H +#endif // Do not have libstdc++11 +#endif // ARX_RINGBUFFER_H diff --git a/util/MsgPack/MsgPack/util/ArxContainer/ArxContainer/initializer_list.h b/util/MsgPack/MsgPack/util/ArxContainer/ArxContainer/initializer_list.h index b1cd74f..374aa27 100644 --- a/util/MsgPack/MsgPack/util/ArxContainer/ArxContainer/initializer_list.h +++ b/util/MsgPack/MsgPack/util/ArxContainer/ArxContainer/initializer_list.h @@ -11,20 +11,22 @@ #include #else namespace std { - template - class initializer_list - { - private: - const T* array; - size_t len; - initializer_list(const T* a, size_t l) : array(a), len(l) {} - public: - initializer_list() : array(nullptr), len(0) {} - size_t size() const { return len; } - const T *begin() const { return array; } - const T *end() const { return array + len; } - }; -} // namespace std +template +class initializer_list { +private: + const T* array; + size_t len; + initializer_list(const T* a, size_t l) + : array(a), len(l) {} + +public: + initializer_list() + : array(nullptr), len(0) {} + size_t size() const { return len; } + const T* begin() const { return array; } + const T* end() const { return array + len; } +}; +} // namespace std #endif -#endif // ARX_TYPE_TRAITS_INITIALIZER_LIST_H +#endif // ARX_TYPE_TRAITS_INITIALIZER_LIST_H diff --git a/util/MsgPack/MsgPack/util/ArxContainer/README.md b/util/MsgPack/MsgPack/util/ArxContainer/README.md index 7a70a98..850c66c 100644 --- a/util/MsgPack/MsgPack/util/ArxContainer/README.md +++ b/util/MsgPack/MsgPack/util/ArxContainer/README.md @@ -158,16 +158,13 @@ PRs are welcome! - [Packetizer](https://github.com/hideakitai/Packetizer) - [MsgPack](https://github.com/hideakitai/MsgPack) -- [MsgPacketizer](https://github.com/hideakitai/MsgPacketizer) - [ArduinoOSC](https://github.com/hideakitai/ArduinoOSC) - [ArtNet](https://github.com/hideakitai/ArtNet) - [Tween](https://github.com/hideakitai/Tween) - [TimeProfiler](https://github.com/hideakitai/TimeProfiler) -- [SceneManager](https://github.com/hideakitai/SceneManager) - [TaskManager](https://github.com/hideakitai/TaskManager) - [ArxStringUtils](https://github.com/hideakitai/ArxStringUtils) - [Debouncer](https://github.com/hideakitai/Debouncer) -- [ES920](https://github.com/hideakitai/ES920) ## License diff --git a/util/MsgPack/MsgPack/util/ArxContainer/library.json b/util/MsgPack/MsgPack/util/ArxContainer/library.json index c095a99..24774c2 100644 --- a/util/MsgPack/MsgPack/util/ArxContainer/library.json +++ b/util/MsgPack/MsgPack/util/ArxContainer/library.json @@ -11,7 +11,7 @@ "url": "https://github.com/hideakitai", "maintainer": true }, - "version": "0.3.11", + "version": "0.3.12", "license": "MIT", "frameworks": "arduino", "platforms": "*" diff --git a/util/MsgPack/MsgPack/util/ArxContainer/library.properties b/util/MsgPack/MsgPack/util/ArxContainer/library.properties index ca75b4b..2858ebe 100644 --- a/util/MsgPack/MsgPack/util/ArxContainer/library.properties +++ b/util/MsgPack/MsgPack/util/ArxContainer/library.properties @@ -1,5 +1,5 @@ name=ArxContainer -version=0.3.11 +version=0.3.12 author=hideakitai maintainer=hideakitai sentence=C++ container-like classes (vector, map, etc.) for Arduino which cannot use STL diff --git a/util/MsgPack/README.md b/util/MsgPack/README.md index b03ebc9..d38552f 100644 --- a/util/MsgPack/README.md +++ b/util/MsgPack/README.md @@ -458,7 +458,7 @@ I reccomend to use low cost but much better performance chip like ESP series. ## Embedded Libraries - [ArxTypeTraits v0.2.1](https://github.com/hideakitai/ArxTypeTraits) -- [ArxContainer v0.3.11](https://github.com/hideakitai/ArxContainer) +- [ArxContainer v0.3.12](https://github.com/hideakitai/ArxContainer) - [DebugLog v0.4.0](https://github.com/hideakitai/DebugLog) - [TeensyDirtySTLErrorSolution v0.1.0](https://github.com/hideakitai/TeensyDirtySTLErrorSolution) diff --git a/util/MsgPack/library.json b/util/MsgPack/library.json index 6108d41..0236027 100644 --- a/util/MsgPack/library.json +++ b/util/MsgPack/library.json @@ -11,7 +11,7 @@ "url": "https://github.com/hideakitai", "maintainer": true }, - "version": "0.3.4", + "version": "0.3.5", "license": "MIT", "frameworks": "arduino", "platforms": "*" diff --git a/util/MsgPack/library.properties b/util/MsgPack/library.properties index 09a32b6..de11599 100644 --- a/util/MsgPack/library.properties +++ b/util/MsgPack/library.properties @@ -1,5 +1,5 @@ name=MsgPack -version=0.3.4 +version=0.3.5 author=hideakitai maintainer=hideakitai sentence=MessagePack implementation for Arduino (compatible with other C++ apps)