Cluster.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_CLUSTER_HPP__
#define __NODAMUSHI_SVD_NORMALIZED_CLUSTER_HPP__

# include "nodamushi/svd/normalized/node_container.hpp"

namespace nodamushi{
namespace svd{
namespace normalized{

/*
 * @brief Normalized cluster class.
 * if STRREF is string_view or something like it, 
 *  the reference source of string is the value of  nodamushi::svd::Cluster instance member.
 * 
 * @see http://www.keil.com/pack/doc/CMSIS/SVD/html/elem_registers.html#elem_cluster
 * @see nodamushi::svd::Cluster
 */
template<typename STRREF>struct Cluster
{
  using this_t = Cluster<STRREF>;
  using p_ptr  = parent_ptr<Peripheral<STRREF>>;
  using p2_ptr = parent_ptr<Cluster<STRREF>>;
  using Register=::nodamushi::svd::normalized::Register<STRREF>;
  using Field  = ::nodamushi::svd::normalized::Field<STRREF>;
  using Peripheral= ::nodamushi::svd::normalized::Peripheral<STRREF>;


private:
  p_ptr  parent;
  p2_ptr parent2;
public:
  path<STRREF>           derivedFrom;
  std::string            name;
  dim_info               dim;
  STRREF                 description;
  STRREF                 alternateCluster;
  STRREF                 headerStructName;
  uint64_t               addressOffset;
  
  nullable<uint32_t>     size;
  nullable<Access>       access;
  nullable<Protection>   protection;
  nullable<uint64_t>     resetValue;
  nullable<uint64_t>     resetMask;

  list<Cluster>          clusters;
  list<Register>         registers;
  //-----------------------------------------------------------
  node_ptr<Peripheral> get_parent() noexcept{return parent.lock();}
  node_ptr<Cluster>    get_parent2() noexcept{return parent2.lock();}
  node_ptr<Peripheral const> get_parent()const noexcept{return parent.lock();}

  node_ptr<Cluster const>    get_parent2()const noexcept{return parent2.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);}
  
  uint64_t get_address()const{ return calc_address(*this);}
  uint64_t get_address_offset()const{ return calc_offset(*this);}
  uint32_t get_size()const{
    return size.get<this_t,get_default_size<this_t>>(this);
  }
  uint64_t get_resetValue()const{
    return resetValue.get<this_t,get_default_resetValue<this_t>>(this);
  }
  uint64_t get_resetMask()const{
    return resetMask.get<this_t,get_default_resetMask<this_t>>(this);
  }
  Access get_access()const{
    return access.get<this_t,get_default_access<this_t>>(this);
  }
  Protection get_protection()const{
    return protection.get<this_t,get_default_protection<this_t>>(this);
  }  
  //-------------------------------------------
  template<typename STR>
  node_ptr<void> find(::nodamushi::svd::path<STR>& p,size_t pindex=0)
  {
    const size_t ps = p.size();
    if(ps > pindex){
      string_ref n = p[pindex];
      if(auto c = __find_helper(clusters,n)){
        if(ps == pindex +1)return c;
        else               return c->find(p,pindex+1);
      }
      if(auto c = __find_helper(registers,n)){
        if(ps == pindex +1)return c;
        else               return c->find(p,pindex+1);
      }
    }
    return {};
  }
  template<typename STR>
  node_ptr<Cluster> find_cluster(::nodamushi::svd::path<STR>& p,size_t pindex=0)
  {
    const size_t ps = p.size();
    if(ps > pindex){
      string_ref n = p[pindex];
      if(auto c = __find_helper(clusters,n)){
        if(ps == pindex +1)return c;
        else               return c->find_cluster(p,pindex+1);
      }
    }
    return {};
  }
  template<typename STR>
  node_ptr<Register> find_register(::nodamushi::svd::path<STR>& p,size_t pindex=0)
  {
    const size_t ps = p.size();
    if(ps > pindex){
      string_ref n = p[pindex];
      if(ps > pindex + 1){
        if(auto c = __find_helper(clusters,n))
          return c->find_register(p,pindex+1);
      }else if(ps == pindex + 1){
        return __find_helper(registers,n);
      }
    }
    return {};
  }
  template<typename STR>
  node_ptr<Field> find_field(::nodamushi::svd::path<STR>& p,size_t pindex=0)
  {
    const size_t ps = p.size();
    if(ps > pindex+1){
      string_ref n = p[pindex];
      if(ps > pindex + 2){
        if(auto c = __find_helper(clusters,n))
          return c->find_field(p,pindex+1);
      }else if(ps == pindex + 2){
        if(auto c = __find_helper(registers,n))
          return c->find_field(p,pindex+1);
      }
    }
    return {};
  }
  ::nodamushi::svd::path<> get_path()const
  {
    ::nodamushi::svd::path<> p;
    path_helper(*this,p);
    return p;
  }

  //-------------------------------------------
  template<typename T>
  Cluster(const T& n):// 'n' don't change name 
      parent(),
      parent2(),
      derivedFrom(),
      name(n.name),
      dim(n.dim),
      __NORMALIZED_DERIVED_FROM(description),
      __NORMALIZED_DERIVED_FROM(alternateCluster),
      __NORMALIZED_DERIVED_FROM(headerStructName),
      __NORMALIZED_DERIVED_FROM(addressOffset),
      __NORMALIZED_DERIVED_FROM(size),
      __NORMALIZED_DERIVED_FROM(access),
      __NORMALIZED_DERIVED_FROM(protection),
      __NORMALIZED_DERIVED_FROM(resetValue),
      __NORMALIZED_DERIVED_FROM(resetMask),
      clusters(n.clusters.size()),
      registers(n.registers.size())
  {
    if(n.svd.derivedFrom)
      derivedFrom = *n.svd.derivedFrom;
    // add dim offset
    if(n.dim && n.dim.index!=0){
      __NORMALIZED_DERIVED_FROM_HELPER(dimIncrement);
      size_t inc = 1;
      if(dimIncrement)
        inc = *dimIncrement;
      addressOffset += inc * n.dim.index;
    }

    for(const auto& c:n.clusters)
      clusters.emplace_back(c);
    for(const auto& c:n.registers)
      registers.emplace_back(c);
    // sort by address
    clusters.sort([](const Cluster& a,const Cluster& b)->bool
                  {return a.addressOffset < b.addressOffset;});
    registers.sort([](const Register& a,const Register& b)->bool
                   {return a.addressOffset < b.addressOffset;});

  }
  void update_parent(p_ptr& new_parent,node_ptr<this_t>& me)
  {
    parent = new_parent;
    parent2= {};
    update_parent_of_children(clusters,me);
    update_parent_of_children(registers,me);
  }

  void update_parent(p2_ptr& new_parent,node_ptr<this_t>& me)
  {
    parent2= new_parent;
    parent = {};
    update_parent_of_children(clusters,me);
    update_parent_of_children(registers,me);
  }

};

//---------- Visitor --------------------
__NX_NORM_HANDLE_VISIT(Cluster)
{
  namespace nv = ::nodamushi::visitor;
  using r = nv::result;
  r ret;
  // visit register / cluster
  ret = CONTROLLER::apply(t.clusters,v);
  if(ret == r::BREAK)return r::BREAK;
  if(ret == r::SKIP)return r::CONTINUE;

  ret =  CONTROLLER::apply(t.registers,v);
  if(ret == r::BREAK)return r::BREAK;
  return r::CONTINUE;
}};
//--------------------------------------------

}}} // end namespace
#endif // __NODAMUSHI_SVD_NORMALIZED_CLUSTER_HPP__