map_std_node_crtpb.hpp

Go to the documentation of this file.

#ifndef MAP_STD_NODE_CRTPB_HPP_
#define MAP_STD_NODE_CRTPB_HPP_
#include "boost/assert.hpp"
#include "boost/concept/assert.hpp"

#include "owlcpp/detail/map_traits.hpp"
#include "owlcpp/terms/detail/max_standard_id.hpp"

namespace owlcpp{

template<class Super> class Map_std_node_crtpb {
   typedef detail::Map_traits<Super> traits;
   typedef typename traits::map_std_type map_std_type;
   typedef typename traits::map_node_type map_node_type;

   map_std_type const& _map_std() const {
      return static_cast<Super const&>(*this).map_std_;
   }

   map_node_type const& _map_node() const {
      return static_cast<Super const&>(*this).map_node_;
   }

   map_node_type& _map_node() {
      return static_cast<Super&>(*this).map_node_;
   }

public:
   typedef typename traits::node_type node_type;

   bool is_standard(const Node_id nid) const {return _map_std().is_standard(nid);}

   node_type const& operator[](const Node_id id) const {
      return _map_std().is_standard(id) ? _map_std()[id] : _map_node()[id];
   }

   node_type const& at(const Node_id id) const {
      return _map_std().is_standard(id) ? _map_std().at(id) : _map_node().at(id);
   }

   node_type const* find(const Node_id id) const {
      return _map_std().is_standard(id) ?
               _map_std().find(id) :
               _map_node().find(id)
               ;
   }


   Node_id insert_node_iri(const Ns_id nsid, std::string const& name) {
      BOOST_ASSERT(
               static_cast<Super const&>(*this).find(nsid) &&
               "invalid namespace ID"
      );
      typedef typename Super::Err Err;
      if( is_blank(nsid) ) {
         BOOST_THROW_EXCEPTION(
                  Err()
                  << typename Err::msg_t("blank namespace for IRI node")
                  << typename Err::str1_t(name)
         );
      }
      if( Node_id const*const nid = _map_std().find(nsid, name) ) return *nid;

      if( _map_std().is_standard(nsid) ) {
         BOOST_THROW_EXCEPTION(
                  Err()
                  << typename Err::msg_t("unknown term in standard namespace")
                  << typename Err::str1_t( name )
                  << typename Err::str2_t( _map_std().at(nsid).str() )
         );
      }
      return _map_node().insert_iri(nsid, name);
   }

   Node_id const* find_node_iri(const Ns_id nsid, std::string const& name) const {
      BOOST_ASSERT(
               static_cast<Super const&>(*this).find(nsid) &&
               "invalid namespace ID"
      );
      if( Node_id const*const nid = _map_std().find(nsid, name) ) return nid;
      return _map_node().find_iri(nsid, name);
   }

};

}//namespace owlcpp
#endif /* MAP_STD_NODE_CRTPB_HPP_ */