PersistenceService.hpp

#ifndef HAVE_PERSISTENCE_SERVICE_H
#define HAVE_PERSISTENCE_SERVICE_H 1

#include <string>
#include <iterator>
#include <memory>

#include <boost/iterator/iterator_facade.hpp>


#include "Metadata.hpp"
//#include "ContentItem.hpp"
#include "anno4cpp.h"
#include "Uri.hpp"

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



namespace mico {
    namespace persistence {

        using namespace mico::rdf::query;

        class item_iterator;

        namespace model {
          class Item;
        }


        class PersistenceMetadata : public Metadata {
            friend class PersistenceService;

        protected:
            PersistenceMetadata(std::string baseUrl) : Metadata(baseUrl)  {};

        };


        class PersistenceService {

        private:

            std::string marmottaServerUrl;
            std::string contentDirectory;
            PersistenceMetadata metadata;
            std::string m_jniErrorMessage;

            static JNIEnv* m_sEnv;

            jnipp::GlobalRef<ComGithubAnno4jAnno4j> m_anno4j;


            void initService();

            void setContext(jnipp::Ref<OrgOpenrdfRepositoryObjectObjectConnection> con, jnipp::Ref<OrgOpenrdfModelURI> context);


        public:
            static JavaVM* m_sJvm;


            static JavaVM* getJVM() { return m_sJvm; }

            PersistenceService(std::string serverAddress);


            PersistenceService(std::string serverAddress, int marmottaPort, std::string user, std::string password);


            PersistenceService(std::string marmottaServerUrl, std::string contentDirectory);


            PersistenceMetadata& getMetadata() { return metadata; };

            std::shared_ptr<model::Item> createItem();

            std::shared_ptr<model::Item> getItem(const mico::persistence::model::URI& id);

            void deleteItem(const mico::persistence::model::URI& id);


            std::vector<std::shared_ptr<model::Item> > getItems();

//            /**
//            * Return an iterator over all currently available content items.
//            *
//            * @return iterable
//            */
//            item_iterator begin();


//            /**
//            * Return the end iterator for checking when iteration has completed.
//            */
//            item_iterator end();


            jnipp::LocalRef<jnipp::com::github::anno4j::Anno4j> getAnno4j();

            std::string getStoragePrefix();

            std::string getContentDirectory();

            std::string unmaskContentLocation(const std::string &maskedURL );

            void checkJavaExceptionThrow();

            void checkJavaExceptionThrow(std::vector<std::string> exceptionNames);

            bool checkJavaExceptionNoThrow(std::string& msg);

            bool checkJavaExceptionNoThrow(std::vector<std::string> exceptionNames, std::string& msg);
        };


#ifndef DOXYGEN_SHOULD_SKIP_THIS

//        class item_iterator  : public boost::iterator_facade<item_iterator, Item*, boost::forward_traversal_tag, Item*> {
//        private:
//            int pos;
//            const std::string& baseUrl;
//            const std::string& contentDirectory;
//            const mico::rdf::query::TupleResult* result;

//        public:
//            item_iterator(const std::string& baseUrl, const std::string& contentDirectory)
//                    : pos(-1), baseUrl(baseUrl), contentDirectory(contentDirectory), result(NULL) {};

//            item_iterator(const std::string& baseUrl, const std::string& contentDirectory, const mico::rdf::query::TupleResult* r)
//                    : pos(0), baseUrl(baseUrl), contentDirectory(contentDirectory), result(r) {};

//            ~item_iterator() { if(result) { delete result; } };


//        private:

//            friend class boost::iterator_core_access;

//            void increment();
//            bool equal(item_iterator const& other) const;
//            Item* dereference() const;

//        };
#endif
    }
}

#endif