ContentItem.hpp

#ifndef HAVE_CONTENTITEM_H
#define HAVE_CONTENTITEM_H 1

#include <iterator>
#include <string>

#include <boost/uuid/uuid.hpp>
#include <boost/uuid/uuid_io.hpp>
#include <boost/iterator/iterator_facade.hpp>

#include "Content.hpp"
#include "Metadata.hpp"

#include "rdf_model.hpp"
#include "rdf_query.hpp"

namespace mico {
    namespace persistence {


        class ContentItemMetadata : public Metadata {

            friend class ContentItem;

        protected:
            ContentItemMetadata(std::string baseUrl, std::string context) : Metadata(baseUrl, context)  {};

        };


        class ExecutionMetadata : public Metadata {

            friend class ContentItem;

        protected:
            ExecutionMetadata(std::string baseUrl, std::string context) : Metadata(baseUrl, context)  {};

        };


        class ResultMetadata : public Metadata {

            friend class ContentItem;

        protected:
            ResultMetadata(std::string baseUrl, std::string context) : Metadata(baseUrl, context)  {};

        };


        class content_part_iterator;

        // suffixes for named graph URIs of a content item
        const std::string SUFFIX_METADATA  = "-metadata";
        const std::string SUFFIX_EXECUTION = "-execution";
        const std::string SUFFIX_RESULT    = "-result";

        class ContentItem {

            friend bool operator==(const ContentItem& ci1, const ContentItem& ci2);

        protected:
            const std::string& baseUrl;
            const std::string& contentDirectory;
            boost::uuids::uuid id;

            ContentItemMetadata metadata;
            ExecutionMetadata   execution;
            ResultMetadata      result;

        public:
            ContentItem(const std::string& baseUrl, const std::string& contentDirectory, const boost::uuids::uuid& id);

            ContentItem(const std::string& baseUrl, const std::string& contentDirectory, const mico::rdf::model::URI& uri);

            inline  std::string getBaseUrl() const { return baseUrl; }


            inline const mico::rdf::model::URI getURI() const { return mico::rdf::model::URI(baseUrl + "/" + boost::uuids::to_string(id)); }

            ContentItemMetadata& getMetadata() { return metadata; }

            ExecutionMetadata& getExecution() { return execution; }

            ResultMetadata& getResult() { return result; }


            Content* createContentPart();

            Content* createContentPart(const mico::rdf::model::URI& id);

            Content* getContentPart(const mico::rdf::model::URI& id);


            void deleteContentPart(const mico::rdf::model::URI& id);


            Content* operator[](const mico::rdf::model::URI& id);


            content_part_iterator begin();


            content_part_iterator end();



        };

#ifndef DOXYGEN_SHOULD_SKIP_THIS

        class content_part_iterator  : public boost::iterator_facade<content_part_iterator, Content*, boost::forward_traversal_tag, Content*> {
        private:
            int pos;
            ContentItem& item;
            const std::string& baseUrl;
            const std::string& contentDirectory;
            const mico::rdf::query::TupleResult* result;

        public:
            content_part_iterator(ContentItem& item, const std::string& baseUrl, const std::string& contentDirectory)
                    : pos(-1), item(item), baseUrl(baseUrl), contentDirectory(contentDirectory), result(NULL) {}

            content_part_iterator(ContentItem& item, const std::string& baseUrl, const std::string& contentDirectory, const mico::rdf::query::TupleResult* r)
                    :  pos(0), item(item), baseUrl(baseUrl), contentDirectory(contentDirectory), result(r) {}

            ~content_part_iterator() { if(result) { delete result; } }


        private:

            friend class boost::iterator_core_access;

            void increment();
            bool equal(content_part_iterator const& other) const;
            Content* dereference() const;

        };
#endif

        inline bool operator==(const ContentItem& ci1, const ContentItem& ci2) {
            return ci1.baseUrl == ci2.baseUrl && ci1.id == ci2.id;
        }
    }
}
#endif