map_triple.hpp

Go to the documentation of this file.

#ifndef MAP_TRIPLE_HPP_
#define MAP_TRIPLE_HPP_
#include "boost/fusion/include/at.hpp"
#include "boost/fusion/include/for_each.hpp"
#include "boost/fusion/include/front.hpp"
#include "boost/fusion/include/mpl.hpp"
#include "boost/mpl/assert.hpp"
#include "boost/mpl/at.hpp"
#include "boost/mpl/fold.hpp"
#include "boost/mpl/if.hpp"
#include "boost/mpl/push_back.hpp"
#include "boost/mpl/vector.hpp"
#include "boost/mpl/vector_c.hpp"

#include "owlcpp/rdf/detail/map_triple_config.hpp"
#include "owlcpp/rdf/detail/triple_index.hpp"

namespace owlcpp{

template<bool Index_subj, bool Index_pred, bool Index_obj, bool Index_doc>
class Map_triple {

   typedef typename
            map_triple_detail::Store_config<Index_subj,Index_pred,Index_obj,Index_doc>
   config;

   typedef typename config::store store;
   typedef typename boost::mpl::front<store>::type main_store;
   BOOST_MPL_ASSERT((boost::is_same<typename main_store::tag, map_triple_detail::Main_store_tag>));

   class Insert {
   public:
      Insert(Triple const& t) : t_(t) {}
      template<class Ind> void operator()(Ind& i) const {i.add(t_);}
   private:
      Triple const& t_;
   };

   struct Clear {
      template<class Ind> void operator()(Ind& i) const {i.clear();}
   };

   class Erase {
   public:
      Erase(Triple const& t) : t_(t) {}
      template<class Ind> void operator()(Ind& i) const {i.erase(t_);}
   private:
      const Triple t_;
   };

public:
   typedef typename main_store::const_iterator const_iterator;
   typedef typename main_store::const_iterator iterator;

   template<class Subj, class Pred, class Obj, class Doc> struct result {
      typedef typename
               map_triple_detail::Search_config<config,Subj,Pred,Obj,Doc>::range
               type;
   };

   template<bool Subj, bool Pred, bool Obj, bool Doc>
   class result_b {
      typedef typename map_triple_detail::Deduce_args<Subj,Pred,Obj,Doc>::type
               q_args;

   public:
      typedef typename result<
               typename boost::mpl::at_c<q_args,0>::type,
               typename boost::mpl::at_c<q_args,1>::type,
               typename boost::mpl::at_c<q_args,2>::type,
               typename boost::mpl::at_c<q_args,3>::type
      >::type type;
   };


   std::size_t size() const {return boost::fusion::front(store_).get_range().size();}
   bool empty() const {return boost::fusion::front(store_).get_range().empty();}
   const_iterator begin() const {return boost::fusion::front(store_).get_range().begin();}
   const_iterator end() const {return boost::fusion::front(store_).get_range().end();}

   void clear() {
      Clear c;
      boost::fusion::for_each(store_, c);
   }

   void erase(Triple const& t) {
      Erase e(t);
      boost::fusion::for_each(store_, e);
   }

   void insert(
            const Node_id subj,
            const Node_id pred,
            const Node_id obj,
            const Doc_id doc
   ) {
      const Triple t = Triple::make(subj, pred, obj, doc);
      Insert ins(t);
      boost::fusion::for_each(store_, ins);
   }


   template<class Subj, class Pred, class Obj, class Doc>
   typename result<Subj,Pred,Obj,Doc>::type
   find(const Subj subj, const Pred pred, const Obj obj, const Doc doc) const {
   /*
   - find search index
   - form predicate
   - get index iterator range
   - make filter iterator range
    */
      typedef map_triple_detail::Search_config<config,Subj,Pred,Obj,Doc> search_config;
      typedef typename search_config::index_num index_num;
      typedef typename boost::mpl::at<store, index_num>::type index_t;
      index_t const& index = boost::fusion::at<index_num>(store_);
      typedef typename index_t::const_range range1_t;
      const range1_t r1 = map_triple_detail::Search_range1<index_t>::get(index,subj,pred,obj,doc);
      return search_config::search::get(r1, subj, pred, obj, doc);
   }

private:
   store store_;

};

}//namespace owlcpp
#endif /* MAP_TRIPLE_HPP_ */