app_base.h

Go to the documentation of this file.

 
#ifndef GRAPHSCOPE_APP_BASE_H_
#define GRAPHSCOPE_APP_BASE_H_
 
#include "flex/utils/app_utils.h"
 
#include <dlfcn.h>
#include <string.h>
 
#include <iostream>
#include <limits>
#include <string>
#include <vector>
 
#include <glog/logging.h>
 
namespace gs {
 
class GraphDBSession;
class GraphDB;
class AppBase {
 public:
 enum class AppType : uint8_t {
 kCppProcedure = 0,
 kCypherProcedure = 1,
 kCypherAdhoc = 2,
 kBuiltIn = 3,
 };
 
 enum class AppMode : uint8_t {
 kRead = 0,
 kWrite = 1,
 };
 
 virtual AppType type() const = 0;
 virtual AppMode mode() const = 0;
 virtual bool run(GraphDBSession& db, Decoder& input, Encoder& output) = 0;
 virtual ~AppBase() {}
};
 
class ReadAppBase : public AppBase {
 public:
 AppMode mode() const override;
 
 AppType type() const override;
 
 bool run(GraphDBSession& db, Decoder& input, Encoder& output) override;
 
 virtual bool Query(const GraphDBSession& db, Decoder& input,
 Encoder& output) = 0;
};
 
class WriteAppBase : public AppBase {
 public:
 AppMode mode() const override;
 
 AppType type() const override;
 
 bool run(GraphDBSession& db, Decoder& input, Encoder& output) override;
 
 virtual bool Query(GraphDBSession& db, Decoder& input, Encoder& output) = 0;
};
 
class AppWrapper {
 public:
 AppWrapper() : app_(NULL), func_deletor_(NULL) {}
 AppWrapper(AppBase* app, void (*func_deletor)(void*))
 : app_(app), func_deletor_(func_deletor) {}
 AppWrapper(AppWrapper&& rhs) {
 app_ = rhs.app_;
 func_deletor_ = rhs.func_deletor_;
 rhs.app_ = NULL;
 rhs.func_deletor_ = NULL;
 }
 ~AppWrapper() {
 if (app_ != NULL && func_deletor_ != NULL) {
 func_deletor_(app_);
 } else if (app_ != NULL) {
 delete app_;
 }
 }
 
 AppWrapper& operator=(AppWrapper&& rhs) {
 app_ = rhs.app_;
 func_deletor_ = rhs.func_deletor_;
 rhs.app_ = NULL;
 rhs.func_deletor_ = NULL;
 return *this;
 }
 
 AppBase* app() { return app_; }
 const AppBase* app() const { return app_; }
 
 private:
 AppBase* app_;
 void (*func_deletor_)(void*);
};
 
class GraphDBSession;
 
class AppFactoryBase {
 public:
 AppFactoryBase() {}
 virtual ~AppFactoryBase() {}
 
 virtual AppWrapper CreateApp(const GraphDB& db) = 0;
};
 
class SharedLibraryAppFactory : public AppFactoryBase {
 public:
 SharedLibraryAppFactory(const std::string& path);
 
 ~SharedLibraryAppFactory();
 
 AppWrapper CreateApp(const GraphDB& db) override;
 
 private:
 std::string app_path_;
 void* app_handle_;
 
 void* (*func_creator_)(const GraphDB&);
 void (*func_deletor_)(void*);
};
 
struct AppMetric {
 AppMetric()
 : total_(0),
 min_val_(std::numeric_limits<int64_t>::max()),
 max_val_(0),
 count_(0) {}
 ~AppMetric() {}
 
 void add_record(int64_t val) {
 total_ += val;
 min_val_ = std::min(min_val_, val);
 max_val_ = std::max(max_val_, val);
 ++count_;
 }
 
 bool empty() const { return (count_ == 0); }
 
 AppMetric& operator+=(const AppMetric& rhs) {
 total_ += rhs.total_;
 min_val_ = std::min(min_val_, rhs.min_val_);
 max_val_ = std::max(max_val_, rhs.max_val_);
 count_ += rhs.count_;
 
 return *this;
 }
 
 void output(const std::string& name) const {
 LOG(INFO) << "Query - " << name << ":";
 LOG(INFO) << "\tcount: " << count_;
 LOG(INFO) << "\tmin: " << min_val_;
 LOG(INFO) << "\tmax: " << max_val_;
 LOG(INFO) << "\tavg: "
 << static_cast<double>(total_) / static_cast<double>(count_);
 }
 
 int64_t total_;
 int64_t min_val_;
 int64_t max_val_;
 int64_t count_;
};
 
} // namespace gs
 
namespace std {
std::istream& operator>>(std::istream& in, gs::AppBase::AppType& type);
std::ostream& operator<<(std::ostream& out, const gs::AppBase::AppType& type);
 
std::istream& operator>>(std::istream& in, gs::AppBase::AppMode& mode);
std::ostream& operator<<(std::ostream& out, const gs::AppBase::AppMode& mode);
 
} // namespace std
 
#endif // GRAPHSCOPE_APP_BASE_H_