api/api/triple__store_8hpp_source.html

 #ifndef TRIPLE_STORE_HPP_

 #define TRIPLE_STORE_HPP_

 #include "owlcpp/rdf/detail/map_traits.hpp"

 #include "owlcpp/rdf/map_ns.hpp"

 #include "owlcpp/rdf/map_node.hpp"

 #include "owlcpp/rdf/map_doc.hpp"

 #include "owlcpp/rdf/map_doc_crtpb.hpp"

 #include "owlcpp/rdf/map_std.hpp"

 #include "owlcpp/rdf/map_std_ns_crtpb.hpp"

 #include "owlcpp/rdf/map_std_node_crtpb.hpp"

 #include "owlcpp/rdf/nodes_std.hpp"

 #include "owlcpp/rdf/map_node_literal_crtpb.hpp"

 #include "owlcpp/rdf/map_node_blank_crtpb.hpp"

 #include "owlcpp/rdf/map_triple.hpp"

 #include "owlcpp/rdf/map_triple_crtpb.hpp"

 #include "owlcpp/rdf/crtpb_ns_node_iri.hpp"


 namespace owlcpp{


 class Triple_store :

 public Map_std_ns_crtpb<Triple_store>,

 public Map_std_node_crtpb<Triple_store>,

 public Crtpb_ns_node_iri<Triple_store>,

 public Map_doc_crtpb<Triple_store>,

 public Map_node_literal_crtpb<Triple_store>,

 public Map_node_blank_crtpb<Triple_store>,

 public Map_triple_crtpb<Triple_store>

 {

    friend class Map_std_ns_crtpb<Triple_store>;

    friend class Map_std_node_crtpb<Triple_store>;

    friend class Map_node_literal_crtpb<Triple_store>;

    friend class Map_node_blank_crtpb<Triple_store>;

    friend class Map_doc_crtpb<Triple_store>;

    friend class Map_triple_crtpb<Triple_store>;


    typedef detail::Map_traits<Triple_store> traits;


 public:

    typedef traits::map_std_type map_std_type;

    typedef traits::map_ns_type map_ns_type;

    typedef traits::map_node_type map_node_type;

    typedef traits::map_doc_type map_doc_type;

    typedef traits::map_triple_type map_triple_type;


    struct Err : public Rdf_err {};


    Triple_store()

    : map_std_(map_std_type::get(Nodes_owl()))

    {}


    template<class Nodes_std> explicit Triple_store(Nodes_std const& nodes_std)

    : map_std_(map_std_type::get(nodes_std))

    {}


    map_std_type const& map_std() const {return map_std_;}

    map_ns_type const& map_ns() const {return map_ns_;}

    map_node_type const& map_node() const {return map_node_;}

    map_doc_type const& map_doc() const {return map_doc_;}

    map_triple_type const& map_triple() const {return map_triple_;}


    //disambiguate overloaded methods

    using Map_std_ns_crtpb<Triple_store>::operator[];

    using Map_std_node_crtpb<Triple_store>::operator[];

    using Map_doc_crtpb<Triple_store>::operator[];

    using Map_std_ns_crtpb<Triple_store>::at;

    using Map_std_node_crtpb<Triple_store>::at;

    using Map_doc_crtpb<Triple_store>::at;


    using Map_std_node_crtpb<Triple_store>::insert_node_iri;

    using Crtpb_ns_node_iri<Triple_store>::insert_node_iri;


    using Map_std_node_crtpb<Triple_store>::find_node_iri;

    using Crtpb_ns_node_iri<Triple_store>::find_node_iri;


    using Map_std_ns_crtpb<Triple_store>::find;

    using Map_std_node_crtpb<Triple_store>::find;

    using Map_doc_crtpb<Triple_store>::find;


    using Map_std_ns_crtpb<Triple_store>::insert;

    using Map_triple_crtpb<Triple_store>::insert;


 private:

    map_std_type const& map_std_;

    map_ns_type map_ns_;

    map_node_type map_node_;

    map_doc_type map_doc_;

    map_triple_type map_triple_;


 };


 }//namespace owlcpp

 #endif /* TRIPLE_STORE_HPP_ */

owlcpp::Map_std_node_crtpb< Triple_store >::insert_node_iri
Node_id insert_node_iri(const Ns_id nsid, std::string const &name)
Insert IRI node.
Definition: map_std_node_crtpb.hpp:80

owlcpp::Nodes_owl
Definition: nodes_std.hpp:21

crtpb_ns_node_iri.hpp

map_std.hpp

owlcpp::Triple_store::Err
Definition: triple_store.hpp:57

owlcpp::Crtpb_ns_node_iri< Triple_store >::insert_node_iri
Node_id insert_node_iri(std::string const &iri)
if not already present, store IRI reference node
Definition: crtpb_ns_node_iri.hpp:24

map_triple_crtpb.hpp

owlcpp::Map_node_blank_crtpb
Definition: map_node_blank_crtpb.hpp:19

map_std_node_crtpb.hpp

owlcpp::Rdf_err
Definition: exception.hpp:13

owlcpp::Map_node_literal_crtpb
Definition: map_node_literal_crtpb.hpp:19

owlcpp::Map_triple_crtpb< Triple_store >::insert
void insert(Triple const &t)
Insert a new triple void insert( const Node_id subj, const Node_id pred, const Node_id obj...
Definition: map_triple_crtpb.hpp:86

nodes_std.hpp

owlcpp::Map_triple_crtpb
Definition: map_triple_crtpb.hpp:19

owlcpp::Crtpb_ns_node_iri
Definition: crtpb_ns_node_iri.hpp:16

owlcpp::Map_std_node_crtpb
Definition: map_std_node_crtpb.hpp:20

map_doc_crtpb.hpp

owlcpp::Map_std_node_crtpb< Triple_store >::find
node_type const * find(const Node_id id) const
Definition: map_std_node_crtpb.hpp:59

map_node_blank_crtpb.hpp

owlcpp::Triple_store
Store namespace IRIs, RDF nodes, document infos, and RDF triples.
Definition: triple_store.hpp:32

map_node.hpp

map_std_ns_crtpb.hpp

map_triple.hpp

map_node_literal_crtpb.hpp

map_doc.hpp

owlcpp::Map_std_node_crtpb< Triple_store >::at
node_type const & at(const Node_id id) const
Definition: map_std_node_crtpb.hpp:51

owlcpp::Map_doc_crtpb
Definition: map_doc_crtpb.hpp:20

map_ns.hpp

owlcpp::Map_std_ns_crtpb
Definition: map_std_ns_crtpb.hpp:20