rdf_model.hpp

#ifndef HAVE_RDF_MODEL_H
#define HAVE_RDF_MODEL_H 1

#include <string>
#include <iostream>

#include <boost/multiprecision/cpp_int.hpp>
#include <boost/multiprecision/cpp_dec_float.hpp> 

using boost::multiprecision::cpp_int;
using boost::multiprecision::cpp_dec_float_50;

/*
 * This module contains an implementation of the Sesame data model in C++ for use in C++ components
 * of the MICO platform
 */

namespace mico {
    namespace rdf {
        namespace model {

            enum ValueTypes { TYPE_URI, TYPE_BNODE, TYPE_PLAIN_LITERAL, TYPE_LANGUAGE_LITERAL, TYPE_TYPED_LITERAL };

            class Value {

                friend bool operator==(const Value& l, const Value& r);
                friend bool operator!=(const Value& l, const Value& r);
                friend std::ostream& operator<<(std::ostream&, Value&);
                friend std::ostream& operator<<(std::ostream&, Value*);

            protected:
                virtual bool equals(const Value& other) const = 0;

                virtual std::ostream& print(std::ostream& os) const = 0;

            public:

                virtual ~Value() {};

                virtual const std::string& stringValue() const = 0;

                virtual const ValueTypes getType() const = 0;
            };

            class Resource : public virtual Value {
            };

            class URI : public virtual Resource {

            private:
                std::string uri;

                // find split position according to algorithm in class description
                std::size_t split() const;

                bool equals(const Value& other) const;

                std::ostream& print(std::ostream& os) const { os << "URI("<<uri<<")"; return os; } ;

            public:

                URI(const std::string& uri) : uri(uri) {};
                URI(const char* uri)   : uri(uri) {};
                URI(const URI& uri)    : uri(uri.uri) {};

                std::string getLocalName() const { return uri.substr(split()); };

                std::string getNamespace() const { return uri.substr(0,split()); };


                inline const std::string& stringValue() const { return uri; } ;


                inline const ValueTypes getType() const { return TYPE_URI; };


                inline bool operator==(const std::string& s) const { return uri == s; };
                inline bool operator==(const char* s) const { return uri == s; };
                inline bool operator!=(const std::string& s) const { return uri != s; };
                inline bool operator!=(const char* s) const { return uri != s; };
            };


            class BNode : public virtual Resource {

            private:
                std::string id;

                bool equals(const Value& other) const;

                std::ostream& print(std::ostream& os) const { os << "BNode("<<id<<")"; return os; } ;
            public:
                BNode() : BNode(std::to_string(rand())) {};

                BNode(const std::string& id) : id(id) {};
                BNode(const char*   id) : id(id) {};
                BNode(const BNode&  id) : id(id.id) {};


                inline const std::string& getID() const { return id; };


                inline const std::string& stringValue() const { return id; };

                inline const ValueTypes getType() const { return TYPE_BNODE; };

                inline bool operator==(const std::string& s) const { return id == s; };
                inline bool operator==(const char* s) const { return id == s; };
                inline bool operator!=(const std::string& s) const { return id != s; };
                inline bool operator!=(const char* s) const { return id != s; };
            };

            class Literal : public virtual Value {
            protected:
                std::string label;

                virtual bool equals(const Value& other) const;

                virtual std::ostream& print(std::ostream& os) const { os << "Literal("<<label<<")"; return os; };
            public:

                Literal(const std::string& label) : label(label) {};
                Literal(const char*   label) : label(label) {};
                Literal(int8_t  i) : label(std::to_string((int)i)) {};
                Literal(int16_t i) : label(std::to_string((int)i)) {};
                Literal(int32_t i) : label(std::to_string((long int)i)) {};
                Literal(int64_t i) : label(std::to_string((long long)i)) {};
                Literal(double d) : label(std::to_string(d)) {};
                Literal(float  d) : label(std::to_string(d)) {};
                Literal(bool b) : label(b ? "true" : "false") {};

                virtual ~Literal() {};

                bool booleanValue() const;

                int8_t byteValue() const;


                cpp_dec_float_50 decimalValue() const;

                double doubleValue() const;

                float floatValue() const;

                cpp_int integerValue() const;

                int32_t intValue() const;

                int64_t longValue() const;

                int16_t shortValue() const;

                inline const std::string& getLabel() const { return label; };

                inline const std::string& stringValue() const { return label; };


                inline const ValueTypes getType() const { return TYPE_PLAIN_LITERAL; };



                inline bool operator==(const std::string& s) const { return label == s; };
                //inline bool operator==(const char* s) const { return label == s; };
                inline bool operator!=(const std::string& s) const { return label != s; };
                //inline bool operator!=(const char* s) const { return label != s; };


                inline operator bool() const { return booleanValue(); }
                inline operator int() const { return intValue(); }
                inline operator long int() const { return longValue(); }
                inline operator long long int() const { return longValue(); }
                inline operator float() const { return floatValue(); }
                inline operator double() const { return doubleValue(); }
                inline operator const char*() const { return label.c_str(); }

            };

            class LanguageLiteral : public virtual Literal {
            private:
                std::string lang;

                bool equals(const Value& other) const;

                std::ostream& print(std::ostream& os) const { os << "LanguageLiteral("<<label<<","<<lang<<")"; return os; } ;
            public:

                LanguageLiteral(const std::string& label, const std::string& language) : Literal(label), lang(language) {};
                LanguageLiteral(const char*   label, const char*   language) : Literal(label), lang(language) {};

                inline const std::string& getLanguage() const { return lang; };

                inline const ValueTypes getType() const { return TYPE_LANGUAGE_LITERAL; };

            };


            class DatatypeLiteral : public virtual Literal {
            private:
                URI datatype;

                bool equals(const Value& other) const;

                std::ostream& print(std::ostream& os) const { os << "DatatypeLiteral("<<label<<","<<datatype.stringValue()<<")"; return os; } ;

            public:
                DatatypeLiteral(const std::string& label, const URI& datatype) : Literal(label), datatype(datatype) {};
                DatatypeLiteral(const char*   label, const URI& datatype) : Literal(label), datatype(datatype) {};
                DatatypeLiteral(int8_t  i) : Literal(std::to_string((int)i)), datatype("http://www.w3.org/2001/XMLSchema#byte") {};
                DatatypeLiteral(int16_t i) : Literal(std::to_string((int)i)), datatype("http://www.w3.org/2001/XMLSchema#short") {};
                DatatypeLiteral(int32_t i) : Literal(std::to_string((long int)i)), datatype("http://www.w3.org/2001/XMLSchema#int") {};
                DatatypeLiteral(int64_t i) : Literal(std::to_string((long long)i)), datatype("http://www.w3.org/2001/XMLSchema#long") {};
                DatatypeLiteral(double d) : Literal(std::to_string(d)), datatype("http://www.w3.org/2001/XMLSchema#double") {};
                DatatypeLiteral(float  d) : Literal(std::to_string(d)), datatype("http://www.w3.org/2001/XMLSchema#float") {};
                DatatypeLiteral(bool b) : Literal(b ? "true" : "false"), datatype("http://www.w3.org/2001/XMLSchema#boolean") {};

                const URI& getDatatype() const { return datatype; };


                inline const ValueTypes getType() const { return TYPE_TYPED_LITERAL; };
            };


            class Statement {
            private:
                Resource& subject;
                URI&      predicate;
                Value&    object;

            public:
                // provide a copy constructor for every possible combination (for convenience)
                Statement(Resource& s, URI& p, Value& o) : subject(s), predicate(p), object(o) {};

                inline const Resource& getSubject() const { return subject; };

                inline const URI& getPredicate() const { return predicate; };


                inline const Value& getObject() const { return object; };

            };



            inline bool operator==(const std::string& l,const URI& r) {
                return r == l;
            }

            inline bool operator!=(const std::string& l,const URI& r) {
                return r != l;
            }

            inline bool operator==(const std::string& l,const BNode& r) {
                return r == l;
            }

            inline bool operator!=(const std::string& l,const BNode& r) {
                return r != l;
            }

            inline bool operator==(const std::string& l,const Literal& r) {
                return r == l;
            }

            inline bool operator!=(const std::string& l,const Literal& r) {
                return r != l;
            }


            // convenience: test double value of a literal
            /*
            inline bool operator==(const double d,const Literal& l) {
                return l.doubleValue() == d;
            }

            inline bool operator==(const Literal& l,const double d) {
                return l.doubleValue() == d;
            }

            inline bool operator!=(const double d,const Literal& l) {
                return l.doubleValue() != d;
            }

            inline bool operator!=(const Literal& l,const double d) {
                return l.doubleValue() != d;
            }
*/



            inline bool operator==(const Value& l,const Value& r) {
                return l.equals(r);
            }

            inline bool operator!=(const Value& l,const Value& r) {
                return !l.equals(r);
            }


            inline std::ostream& operator<<(std::ostream& os, Value& v) {
                return v.print(os);
            }

            inline std::ostream& operator<<(std::ostream& os, Value* v) {
                return v->print(os);
            }

        }
    }
}

#endif