neo4j_interface.h

/*
MIT License Block

Copyright (c) 2016 Alex Barry

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
*/

#ifndef AOSSL_NEO4J_INCLUDE_NEO4J_INTERFACE_H_
#define AOSSL_NEO4J_INCLUDE_NEO4J_INTERFACE_H_

#include <neo4j-client.h>
#include <string>
#include <unordered_map>
#include <exception>

#include "aossl/core/include/slot_pool.h"

// Neo4j Exception

// A child class of std::exception
// which holds error information
struct Neo4jException: public std::exception {
  // An error message passed on initialization
  std::string int_msg;
  const char * int_msg_cstr;
  neo4j_result_stream_t *results = NULL;

  // Create a Neo4j Exception, and store the given error message
  inline Neo4jException(std::string msg) {
    int_msg = "Error in Neo4j Request: " + msg;
    int_msg_cstr = int_msg.c_str();
  }

  inline Neo4jException(std::string msg, neo4j_result_stream_t *r) {
    int_msg = "Error in Neo4j Request: " + msg;
    int_msg_cstr = int_msg.c_str();
    results = r;
  }

  Neo4jException() {}
  ~Neo4jException() throw() {if (results) {neo4j_close_results(results);}}
  // Show the error message in readable format
  const char * what() const throw() {
    return int_msg_cstr;
  }
};

// Query Results


class DbListInterface {
 public:
  virtual ~DbListInterface() {}

  virtual bool get_bool_element(unsigned int ind) = 0;

  virtual int get_int_element(unsigned int ind) = 0;

  virtual double get_float_element(unsigned int ind) = 0;

  virtual std::string get_string_element(unsigned int ind, \
    int char_buffer_size) = 0;

  virtual std::string get_string_element(unsigned int ind) = 0;

  virtual std::string to_string() = 0;

  virtual unsigned int size() = 0;
};


class DbMapInterface {
 public:
  virtual ~DbMapInterface() {}

  virtual unsigned int size() = 0;

  virtual bool element_exists(std::string key) = 0;

  virtual std::string get_string_element(std::string key, \
    int char_buffer_size) = 0;

  virtual std::string get_string_element(std::string key) = 0;

  virtual bool get_bool_element(std::string key) = 0;

  virtual int get_int_element(std::string key) = 0;

  virtual double get_float_element(std::string key) = 0;

  virtual DbListInterface* get_list_element(std::string key) = 0;

  virtual std::string to_string() = 0;
};


class DbObjectInterface {
 public:
  virtual ~DbObjectInterface() {}


  virtual bool is_node() = 0;


  virtual bool is_edge() = 0;


  virtual bool is_path() = 0;

  virtual std::string to_string() = 0;


  virtual DbMapInterface* properties() = 0;


  virtual DbListInterface* labels() = 0;


  virtual std::string type() = 0;


  virtual bool forward() = 0;


  virtual unsigned int size() = 0;


  virtual DbObjectInterface* get_path_element(int path_index) = 0;
};


// Represents a single query Result, returned by the iterator
// Consists of a set of nodes and edges
class ResultTreeInterface {
 public:
  virtual ~ResultTreeInterface() {}

  virtual DbObjectInterface* get(int index) = 0;

  virtual bool exists() = 0;
};


class ResultsIteratorInterface {
 public:
  virtual ~ResultsIteratorInterface() {}

  virtual void clear() = 0;


  virtual bool empty() = 0;

  virtual unsigned int length() = 0;

  virtual ResultTreeInterface* next() = 0;
};

// Neo4j Admin


class Neo4jQueryParameterInterface {
 public:
  virtual ~Neo4jQueryParameterInterface() {}

  virtual int get_type() = 0;

  virtual bool get_boolean_value() = 0;

  virtual bool get_boolean_value(int index) = 0;

  virtual std::string get_string_value() = 0;

  virtual std::string get_string_value(int index) = 0;

  virtual const char * get_cstring_value() = 0;

  virtual int get_integer_value() = 0;

  virtual int get_integer_value(int index) = 0;

  virtual double get_double_value() = 0;

  virtual double get_double_value(int index) = 0;

  virtual bool is_array() = 0;

  virtual unsigned int size() = 0;

  virtual void add_value(float new_val) = 0;

  virtual void add_value(int new_val) = 0;

  virtual void add_value(bool new_val) = 0;

  virtual void add_value(std::string new_val) = 0;

  virtual void add_value(const char * new_val) = 0;

  // Internal Use only - Used by Neo4j Admin when executing query.
  virtual neo4j_value_t get_neo4j_list() = 0;
};


class Neo4jInterface {
 public:
  virtual ~Neo4jInterface() {}

  virtual ResultsIteratorInterface* execute(const char * query) = 0;

  virtual ResultsIteratorInterface* execute(std::string query) = 0;

  virtual ResultsIteratorInterface* execute(const char * query, \
    std::unordered_map<std::string, Neo4jQueryParameterInterface*>\
    query_params) = 0;

  virtual ResultsIteratorInterface* execute(std::string query, \
    std::unordered_map<std::string, Neo4jQueryParameterInterface*> \
    query_params) = 0;
};

#endif  // AOSSL_NEO4J_INCLUDE_NEO4J_INTERFACE_H_