binary_extension.hpp

См. документацию.

#pragma once
 
#include "check.hpp"
 
namespace eosio {
   template <typename T>
   class binary_extension {
      public:
         using value_type = T;
 
         constexpr binary_extension() {}
         constexpr binary_extension( const T& ext )
         :_has_value(true)
         {
            ::new (&_data) T(ext);
         }
         constexpr binary_extension( T&& ext )
         :_has_value(true)
         {
            ::new (&_data) T(std::move(ext));
         }
         template <typename... Args>
         constexpr binary_extension( std::in_place_t, Args&&... args )
         :_has_value(true)
         {
            ::new (&_data) T(std::forward<Args>(args)...);
         }
 
         constexpr binary_extension( const binary_extension& other )
         :_has_value(other._has_value)
         {
            if( other._has_value ) ::new (&_data) T( *other );
         }
 
         constexpr binary_extension( binary_extension&& other )
         :_has_value(other._has_value)
         {
            if( other._has_value ) {
               ::new (&_data) T( *std::move(other) );
               other._has_value = false;
            }
         }
 
         ~binary_extension() { reset(); }
 
         constexpr binary_extension& operator = (const binary_extension& other) {
            if (has_value())
               reset();
 
            if (other.has_value()) {
               ::new (&_data) T(*other);
               _has_value = true;
            }
            return *this;
         }
 
         constexpr binary_extension& operator = (binary_extension&& other) {
            if (has_value())
               reset();
 
            if (other.has_value()) {
               ::new (&_data) T(*other);
               _has_value = true;
               other._has_value = false;
            }
            return *this;
         }
         constexpr explicit operator bool()const { return _has_value; }
         constexpr bool has_value()const { return _has_value; }
 
         constexpr T& value()& {
            if (!_has_value) {
               check(false, "cannot get value of empty binary_extension");
            }
            return _get();
         }
 
 
         constexpr const T& value()const & {
            if (!_has_value) {
               check(false, "cannot get value of empty binary_extension");
            }
            return _get();
         }
 
         template <typename U>
         constexpr auto value_or( U&& def ) -> std::enable_if_t<std::is_convertible<U, T>::value, T&>& {
            if (_has_value)
               return _get();
            return def;
         }
         constexpr T&& value_or()&& {
            if (!_has_value)
               return std::move(T());
            _has_value = false;
            return std::move(_get());
         }
         constexpr const T&& value_or()const&& {
            if (!_has_value)
               return std::move(T());
            _has_value = false;
            return std::move(_get());
         }
         constexpr T value_or()& {
            if (!_has_value)
               return T();
            return _get();
         }
         constexpr T value_or()const& {
            if (!_has_value)
               return T();
            return _get();
         }
 
         constexpr T* operator->() {
            return &_get();
         }
         constexpr const T* operator->()const {
            return &_get();
         }
 
         constexpr T& operator*()& {
            return _get();
         }
         constexpr const T& operator*()const& {
            return _get();
         }
         constexpr const T&& operator*()const&& {
            return std::move(_get());
         }
         constexpr T&& operator*()&& {
            return std::move(_get());
         }
 
         template<typename ...Args>
         T& emplace(Args&& ... args)& {
            if (_has_value) {
               reset();
            }
 
            ::new (&_data) T( std::forward<Args>(args)... );
            _has_value = true;
 
            return _get();
         }
 
         void reset() {
            if( _has_value ) {
               _get().~value_type();
               _has_value = false;
            }
         }
 
 
       private:
         bool _has_value = false;
         typename std::aligned_storage<sizeof(T), alignof(T)>::type _data;
 
         constexpr T& _get() {
            return *reinterpret_cast<T*>(&_data);
         }
 
         constexpr const T& _get()const {
            return *reinterpret_cast<const T*>(&_data);
         }
   };
 
 
   template<typename DataStream, typename T>
   inline DataStream& operator<<(DataStream& ds, const eosio::binary_extension<T>& be) {
     ds << be.value_or();
     return ds;
   }
 
   template<typename DataStream, typename T>
   inline DataStream& operator>>(DataStream& ds, eosio::binary_extension<T>& be) {
     if( ds.remaining() ) {
        T val;
        ds >> val;
        be.emplace(val);
     }
     return ds;
   }
 
 
} // namespace eosio