Field.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_FIELD_HPP__
#define __NODAMUSHI_SVD_NORMALIZED_FIELD_HPP__

# include "nodamushi/svd/normalized/node_container.hpp"
# include "nodamushi/svd/normalized/nullable.hpp"
# include "nodamushi/svd/normalized/bit_range.hpp"
# include "nodamushi/svd/normalized/derived_from_helper.hpp"
# include "nodamushi/svd/normalized/dim_info.hpp"

# include "nodamushi/svd/Access.hpp"
# include "nodamushi/svd/ReadAction.hpp"
# include "nodamushi/svd/ModifiedWriteValues.hpp"

namespace nodamushi{
namespace svd{
namespace normalized{

template<typename STRREF>struct Field
{
  using this_t = Field<STRREF>;
  using Peripheral= ::nodamushi::svd::normalized::Peripheral<STRREF>;
  using Register= ::nodamushi::svd::normalized::Register<STRREF>;
  using Enumeration = ::nodamushi::svd::normalized::Enumeration<STRREF>;

  using p_ptr = parent_ptr<Register>;
  

private:
  p_ptr parent;
public:
  path<STRREF>                  derivedFrom;
  std::string                   name;
  dim_info                      dim;
  bit_range                     bit;
  STRREF                        description;
  nullable<Access>              access;
  nullable<ModifiedWriteValues> modifiedWriteValues;
  nullable<ReadAction>          readAction;
  list<Enumeration>     enumeratedValues;
  //-------------------------------------------
  unsigned int lsb()const{return bit.lsb();}
  unsigned int msb()const{return bit.msb();}
  
  node_ptr<Register const> get_parent()const noexcept{return parent.lock();}
  node_ptr<Register> get_parent()noexcept{return parent.lock();}

  node_ptr<Peripheral const> get_peripheral()const noexcept{return find_parent_peripheral(*this);}
  node_ptr<Peripheral> get_peripheral()noexcept{return find_parent_peripheral(*this);}

  Access get_access()const{
    return access.get<this_t,get_default_fieldaccess<this_t>>(this);
  }
  ModifiedWriteValues get_modifiedWriteValues()const{
    return modifiedWriteValues.get<this_t,get_default_access<this_t>>(this);
  }
  ReadAction get_readAction()const{
    return readAction.get<this_t,get_default_readAction<this_t>>(this);
  }
  uint64_t get_resetValue(){
    if(auto p = get_parent()){
      return bit.get(p->get_resetValue() & p->get_resetMask());
    }
    return 0;
  }
  //-------------------------------------------
  template<typename STR>
  node_ptr<Enumeration> find(const ::nodamushi::svd::path<STR>& p,size_t pindex=0)
  {
    const size_t ps = p.size();
    if(ps == pindex+1){
      string_ref n = p[pindex];
      auto i = enumeratedValues.ptr_begin(),e = enumeratedValues.ptr_end();
      while(i!=e){
        auto c = *i;
        if(c->name == n)
          return c;
        ++i;
      }
    }
    return {};
  }

  //-----------------------------------------------------------------
  template<typename T>
  Field(const T& n): // don't change name
      parent(),
      derivedFrom(),
      name(n.name),
      dim(n.dim),
      bit(n),
      __NORMALIZED_DERIVED_FROM(description),
      __NORMALIZED_DERIVED_FROM(access),
      __NORMALIZED_DERIVED_FROM(modifiedWriteValues),
      __NORMALIZED_DERIVED_FROM(readAction)
  {
    if(n.svd.derivedFrom)
      derivedFrom = *n.svd.derivedFrom;
    for(const auto& c:n.enumeratedValues)
      enumeratedValues.emplace_back(c);
  }
  
  void update_parent(p_ptr& new_parent,node_ptr<this_t>& me)
  {
    parent = new_parent;
  }
  constexpr void* get_parent2()const noexcept{return nullptr;}
  
};
//---------- Visitor --------------------
__NX_NORM_HANDLE_VISIT(Field)
{
  namespace nv = ::nodamushi::visitor;
  using r = nv::result;
  r ret;
  ret =  CONTROLLER::apply(t.enumeratedValues,v);
  if(ret == r::BREAK)return ret;
  return r::CONTINUE;
}};
//--------------------------------------------


}}} // end namespace svd

#endif // __NODAMUSHI_SVD_NORMALIZED_FIELD_HPP__