rdf_query.hpp

#ifndef HAVE_RDF_QUERY_H
#define HAVE_RDF_QUERY_H 1

#include <iostream>
#include <map>
#include <vector>
#include <string>



namespace mico {
    namespace rdf {
        namespace model {
            class Value;
        }

        namespace query {

            typedef std::map<std::string,mico::rdf::model::Value*> BindingSet;


            class QueryResult {
            public:

                virtual void loadFrom(std::istream& is) = 0;


                virtual void loadFrom(const char* ptr, size_t len) = 0;

            };

            class BooleanResult : public QueryResult {

                static void startElement(void *data, const char *el, const char **attr);
                static void endElement(void *data, const char *el);
                static void characterData(void *data, const char *chars, int len);

            private:
                bool value;

            public:
                BooleanResult() : value(false) {};
                BooleanResult(bool value) : value(value) {};

                void loadFrom(std::istream& is);


                void loadFrom(const char* ptr, size_t len);


                // can be used as boolean value in boolean expressions...
                inline operator bool() const { return value; };

            };



            class TupleResult : public QueryResult {

            private:
                friend std::istream& operator>>(std::istream& is, TupleResult& r);
                friend std::ostream& operator<<(std::ostream& is, TupleResult& r);

                std::vector<std::string> bindingNames;
                std::vector<BindingSet>  data;

                static void startElement(void *data, const char *el, const char **attr);
                static void endElement(void *data, const char *el);
                static void characterData(void *data, const char *chars, int len);

            public:

                virtual ~TupleResult() {};


                const std::vector<std::string>& getBindingNames() const { return bindingNames; };


                void loadFrom(std::istream& is);


                void loadFrom(const char* ptr, size_t len);


                // delegate methods
                inline std::vector<BindingSet>::iterator begin() { return data.begin(); }
                inline std::vector<BindingSet>::iterator end() { return data.end(); }
                inline size_t size() const { return data.size(); }
                inline BindingSet& at(size_t i) { return data.at(i); }
                inline const BindingSet& at(size_t i) const { return data.at(i); }

                inline BindingSet& operator[](size_t i) { return data[i]; };
                inline const BindingSet& operator[](size_t i) const { return data[i]; };
            };




            std::istream& operator>>(std::istream& is, TupleResult& r);
            std::istream& operator>>(std::istream& is, BooleanResult& r);


            std::ostream& operator<<(std::ostream& is, TupleResult& r);
            std::ostream& operator<<(std::ostream& is, BooleanResult& r);


        }
    }
}


#endif