value.hpp

Go to the documentation of this file.

/*
 * These codes are licensed under CC0.
 * http://creativecommons.org/publicdomain/zero/1.0/
 */
#ifndef __NODAMUSHI_SVD_VALUE_HPP__
#define __NODAMUSHI_SVD_VALUE_HPP__

# include <utility>
# include <type_traits>
# include <functional>
# include <ostream>
# include <sstream>
# include <stdexcept>

# include "nodamushi/const_string.hpp"
# include "nodamushi/svd/value/value_setter.hpp"
# include "nodamushi/svd/vattr.hpp"
# include "nodamushi/svd/svd_reader.hpp"

namespace nodamushi{
namespace svd{

struct empty_value_access_error:public std::logic_error
{
  empty_value_access_error(std::string& message):logic_error(message){}
};


template<typename T,bool attribute,bool required,char... name>struct value
{
  using this_t = value<T,attribute,required,name...>;
  using value_type_t = ::nodamushi::svd::vattr_unwrap<T>;
  using type = typename value_type_t::type;

  static constexpr bool REQUIRED=required;
  static constexpr bool ATTRIBUTE=attribute;
  
  // constructors ------------------------------------------------
  value():_value(),_has_value(false){};
  value(const type& t):_value(t),_has_value(true){}
  value(value&&) = default;
    
  // constant properties -----------------------------------------
  constexpr bool is_required()const noexcept{return required;}
  constexpr bool is_attribute()const noexcept{return attribute;}
  NODAMUSHI_CONSTEXPR_STRING get_name()const noexcept;

  // contents ----------------------------------------------------
  //  setter
  template<typename SVD> auto operator =(SVD& src)
      ->typename std::enable_if<std::is_base_of<svd_reader,SVD>::value
                                ,bool>::type
  {
    if(::nodamushi::svd::value_try_set(_value,src)){
      _has_value = true;
      return true;
    }
    return false;
  }
  template<typename SVD> auto operator =(SVD&& src)
      ->typename std::enable_if<std::is_base_of<svd_reader,SVD>::value
                                ,bool>::type
  {
    if(::nodamushi::svd::value_try_set(_value,src)){
      _has_value = true;
      return true;
    }
    return false;
  }
  template<typename V> auto operator =(const V& value)
      ->typename std::enable_if<!std::is_base_of<svd_reader,V>::value
                                ,this_t&>::type
  {
    _value = value;  _has_value =true;
    return *this;
  }
  template<typename V> this_t& operator =(V&& value)
  {
    _value = std::move(value);  _has_value =true;
    return *this;
  }
  void clear()noexcept;
  value& operator=(value&&)=default;
  value& operator=(const value&)=default;
  

  
  // getter (empty_value_access_error will be occurer)
  const type& get()const;
  type& get();
  type& operator*(){return get();}
  const type& operator*()const {return get();}
  type* operator->(){return &get();}
  const type* operator->()const{return &get();}
  bool operator==(const type& t)const noexcept{return _has_value? _value ==t:false;}
  bool operator!=(const type& t)const noexcept{return _has_value? _value !=t:true;}
  bool operator==(type&& t)const noexcept{return _has_value? _value ==t:false;}
  bool operator!=(type&& t)const noexcept{return _has_value? _value !=t:true;}
  bool operator==(const value& t)const noexcept
  {return _has_value&&t._has_value? _value ==t._value:_has_value==t._has_value;}
  bool operator!=(const value&& t)const noexcept
  {return _has_value&&t._has_value? _value !=t._value:_has_value!=t._has_value;}

  type& get_for_init()noexcept{_has_value=true;return _value;}
  type& get(type& defaultValue)noexcept{return _has_value?_value:defaultValue;}
  type& get(type&& defaultValue)noexcept{return _has_value?_value:defaultValue;}
  const type& get(const type& defaultValue)const noexcept{return _has_value?_value:defaultValue;}



  bool empty()const noexcept{return !_has_value;}
  operator bool()const noexcept{return _has_value;}
  

  bool check_require()const noexcept{return !required || _has_value;}
  
 private:
  type _value;
  bool _has_value;
};

}}// end namespace nodamushi::svd

# ifndef __DOXYGEN__DOCUMENT__PREPROCESSOR__

#  define SVD_VALUE(type,name,...) \
  _SVD_VALUE_(type,name,false,__VA_ARGS__,_SVD_VALUE0_,_SVD_VALUE1_,0)

#  define SVD_ATTR(type,name,...) \
  _SVD_VALUE_(type,name,true,__VA_ARGS__,_SVD_VALUE0_,_SVD_VALUE1_,0)

#  define SVD_TYPE(type,attr,require,name) \
  value_t<type,attr,require,__SVD_VALUE_EXPAND_NAME__(name)>

# include "nodamushi/svd/value/imple.hpp"
# include "nodamushi/svd/value/void_value.hpp"
# include "nodamushi/svd/value/define.hpp"

# else
// for doxygen

#  define SVD_VALUE(type,name,...) \
  value<type,ELEMENT> name

#  define SVD_ATTR(type,name,...) \
  value<type,ATTR> name

#  define SVD_TYPE(type,attr,require,name) \
  value<type,ATTR>

# endif


#endif // __NODAMUSHI_SVD_VALUE_HPP__