WriteConstraint.hpp

Go to the documentation of this file.

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

# include <cstdint>

namespace nodamushi{
namespace svd{
namespace normalized{

struct WriteConstraint
{
  struct range_t
  {
    bool valid;
    operator bool()const noexcept{return valid;}
    
    uint64_t maximum;
    uint64_t minimum;
    range_t():valid(false),maximum(~(uint64_t)0),minimum(0){}

    void init(uint64_t max,uint64_t min)noexcept
    {
      valid = true;
      maximum = max;
      minimum = min;
    }
    void clear()noexcept
    {
      valid = false;
      maximum = ~(uint64_t)0;
      minimum = 0;
    }
  };


  bool valid; 
  operator bool()const noexcept{return valid;}
  //---------------------------------------------------
  bool writeAsRead; 
  bool useEnumeratedValues;
  
  range_t range;

  template<typename SVD,typename VALUE,VALUE SVD::* MEMBER>
  WriteConstraint(derived_from_helper<SVD,VALUE,MEMBER>&& d):
      WriteConstraint(d.ptr){}

  template<typename VALUE>// value
  WriteConstraint(const VALUE* ptr):
      valid(ptr!=nullptr),
      writeAsRead(false),
      useEnumeratedValues(false),
      range()
  {
    if(valid){
      const auto& v = **ptr;
      if(v.writeAsRead) writeAsRead= *v.writeAsRead;
      if(v.useEnumeratedValues) useEnumeratedValues= *v.useEnumeratedValues;
      if(v.range){
        const auto& r= *v.range;
        uint64_t max=range.maximum,min=range.minimum;
        if(r.maximum) max = *r.maximum;
        if(r.minimum) min = *r.minimum;
        range.init(max,min);
      }
    }
  }
};

}}} // end namespace svd
#endif // __NODAMUSHI_SVD_NORMALIZED_WRITECONSTRAINT_HPP__