MarkLogic.h

/* -*- mode: c++; indent-tabs-mode: nil; c-basic-offset: 2 -*-
 *
 *  Copyright (c) 2019 MarkLogic Corporation
 *
 */
#ifndef _MARKLOGIC_MARKLOGIC_H_
#define _MARKLOGIC_MARKLOGIC_H_

#include <stddef.h>

#ifdef _MSC_VER
typedef __int32 int32_t;
typedef unsigned __int32 uint32_t;
typedef __int64 int64_t;
typedef unsigned __int64 uint64_t;
#ifndef MLDLL
#define MLDLL __declspec(dllimport)
#endif
#else // !_MSC_VER
#include <stdint.h>
#define MLDLL
#endif

#define MARKLOGIC_API_VERSION 3

namespace marklogic
{

class CodePointStringImpl;
class Map;
class MapImpl;
class SequenceImpl;
class StringImpl;
class LangStringImpl;

class MLDLL RangeIndex
{
public:
  enum Type {
    INT,                   
    UNSIGNED_INT,          
    LONG,                  
    UNSIGNED_LONG,         
    FLOAT,                 
    DOUBLE,                
    DECIMAL,               
    DATE_TIME,             
    TIME,                  
    DATE,                  
    G_YEAR_MONTH,          
    G_YEAR,                
    G_MONTH,               
    G_DAY,                 
    YEAR_MONTH_DURATION,   
    DAY_TIME_DURATION,     
    STRING,                
    ANY_URI,               
    POINT                  
  };

  enum Order {
    ASCENDING,
    DESCENDING
  };
};

template<class T, typename PT>
class MLDLL CTypeWrapperBase
{
protected:
  PT val;

public:
  CTypeWrapperBase(): val(0) {}
  CTypeWrapperBase(PT v): val(v) {}

  operator PT&() { return val; }
  operator const PT&() const { return val; }

  bool operator<(T o) const { return val < o.val; }
  bool operator<=(T o) const { return val <= o.val; }
  bool operator>(T o) const { return val > o.val; }
  bool operator>=(T o) const { return val >= o.val; }
  bool operator==(T o) const { return val == o.val; }
  bool operator!=(T o) const { return val != o.val; }

  T operator-(T o) const { return val - o.val; }
  T operator+(T o) const { return val + o.val; }
  T operator*(T o) const { return val * o.val; }
  T operator/(T o) const { return val / o.val; }

  T operator--(int) { return val--; }
  T operator++(int) { return val++; }
  T& operator--() { --val; return (T&)*this; }
  T& operator++() { ++val; return (T&)*this; }
  T& operator-=(T o) { val -= o.val; return (T&)*this; }
  T& operator+=(T o) { val += o.val; return (T&)*this; }
  T& operator*=(T o) { val *= o.val; return (T&)*this; }
  T& operator/=(T o) { val /= o.val; return (T&)*this; }
};

template<class T, typename PT>
class MLDLL CTypeWrapperF : public CTypeWrapperBase<T,PT>
{
protected:
  typedef CTypeWrapperF<T,PT> Base;

public:
  CTypeWrapperF() {}
  CTypeWrapperF(PT v): CTypeWrapperBase<T,PT>(v) {}

  T operator-() const { return -this->val; }
  T operator+() const { return +this->val; }
};

template<class T, typename PT>
class MLDLL CTypeWrapperU : public CTypeWrapperBase<T,PT>
{
protected:
  typedef CTypeWrapperU<T,PT> Base;

public:
  CTypeWrapperU() {}
  CTypeWrapperU(PT v): CTypeWrapperBase<T,PT>(v) {}

  T operator%(T o) const { return this->val % o.val; }
  T& operator%=(T o) { this->val %= o.val; return (T&)*this; }
};

template<class T, typename PT>
class MLDLL CTypeWrapper : public CTypeWrapperU<T,PT>
{
protected:
  typedef CTypeWrapper<T,PT> Base;

public:
  CTypeWrapper() {}
  CTypeWrapper(PT v): CTypeWrapperU<T,PT>(v) {}

  T operator-() const { return -this->val; }
  T operator+() const { return +this->val; }
};


#ifdef _MSC_VER
typedef double DecimalType;
#else
typedef long double DecimalType;
#endif

class MLDLL Decimal : public CTypeWrapperF<Decimal,DecimalType>
{
public:
  Decimal(): Base() {}
  Decimal(DecimalType v): Base(v) {}
};

class MLDLL DateTime : public CTypeWrapper<DateTime,int64_t>
{
public:
  DateTime(): Base() {}
  DateTime(int64_t v): Base(v) {}
};

class MLDLL Date : public CTypeWrapper<Date,int64_t>
{
public:
  Date(): Base() {}
  Date(int64_t v): Base(v) {}
};

class MLDLL Time : public CTypeWrapper<Time,int64_t>
{
public:
  Time(): Base() {}
  Time(int64_t v): Base(v) {}
};

class MLDLL GYearMonth : public CTypeWrapper<GYearMonth,int>
{
public:
  GYearMonth(): Base() {}
  GYearMonth(int v): Base(v) {}
};

class MLDLL GYear : public CTypeWrapper<GYear,int>
{
public:
  GYear(): Base() {}
  GYear(int v): Base(v) {}
};

class MLDLL GMonth : public CTypeWrapperU<GMonth,unsigned>
{
public:
  GMonth(): Base() {}
  GMonth(unsigned v): Base(v) {}
};

class MLDLL GDay : public CTypeWrapperU<GDay,unsigned>
{
public:
  GDay(): Base() {}
  GDay(unsigned v): Base(v) {}
};

class MLDLL YearMonthDuration : public CTypeWrapper<YearMonthDuration,int>
{
public:
  YearMonthDuration(): Base() {}
  YearMonthDuration(int v): Base(v) {}
};

class MLDLL DayTimeDuration : public CTypeWrapper<DayTimeDuration,int64_t>
{
public:
  DayTimeDuration(): Base() {}
  DayTimeDuration(int64_t v): Base(v) {}
};

class MLDLL String
{
public:
  String(StringImpl* =0);
  String(const char* _str, const char* _collation = 0);
  String(const String& o);
  String& operator=(const String& o);
  ~String();

  operator bool() const { return str!=0; }

  operator const char*() const;
  const char* get() const;
  size_t length() const;
  const char* collation() const;

  bool operator<(const String& o) const;
  bool operator<=(const String& o) const;
  bool operator>(const String& o) const;
  bool operator>=(const String& o) const;
  bool operator==(const String& o) const;
  bool operator!=(const String& o) const;

protected:
  StringImpl* str;
};

class MLDLL LangString
{
public:
  LangString(LangStringImpl* =0);
  LangString(const char* _str, const char* _language = 0);
  LangString(const LangString& o);
  LangString& operator=(const LangString& o);
  ~LangString();

  operator bool () const { return str!=0; }

  operator const char*() const;
  const char* get() const;
  size_t length() const;
  const char* language() const;

  bool operator<(const LangString& o) const;
  bool operator<=(const LangString& o) const;
  bool operator>(const LangString& o) const;
  bool operator>=(const LangString& o) const;
  bool operator==(const LangString& o) const;
  bool operator!=(const LangString& o) const;

protected:
  LangStringImpl* str;
};

class MLDLL Point
{
protected:
  double lat;
  double lng;
  const void* coord;

public:
  Point();
  Point(double _lat, double _lng, const char* _coordinateSystem = "wgs84");

  double latitude() const;
  double longitude() const;
  const char* coordinateSystem() const;

  bool operator<(const Point& o) const;
  bool operator<=(const Point& o) const;
  bool operator>(const Point& o) const;
  bool operator>=(const Point& o) const;
  bool operator==(const Point& o) const;
  bool operator!=(const Point& o) const;
};

class MLDLL TupleIterator
{
public:
  virtual void next() =0;
  virtual bool done() const =0;

  // Information about this tuple iterator
  virtual bool descending() const =0;
  virtual size_t width() const =0;
  virtual RangeIndex::Type type(size_t i) const =0;
  virtual const char* collation(size_t i) const =0;
  virtual const char* coordinateSystem(size_t i) const =0;

  // Information about the current tuple
  virtual uint64_t frequency() const =0;
  virtual bool null(size_t i) const =0;

  virtual void value(size_t i, int&) const =0;
  virtual void value(size_t i, unsigned&) const =0;
  virtual void value(size_t i, int64_t&) const =0;
  virtual void value(size_t i, uint64_t&) const =0;
  virtual void value(size_t i, float&) const =0;
  virtual void value(size_t i, double&) const =0;
  virtual void value(size_t i, Decimal&) const =0;
  virtual void value(size_t i, DateTime&) const =0;
  virtual void value(size_t i, Date&) const =0;
  virtual void value(size_t i, Time&) const =0;
  virtual void value(size_t i, GYearMonth&) const =0;
  virtual void value(size_t i, GYear&) const =0;
  virtual void value(size_t i, GMonth&) const =0;
  virtual void value(size_t i, GDay&) const =0;
  virtual void value(size_t i, YearMonthDuration&) const =0;
  virtual void value(size_t i, DayTimeDuration&) const =0;
  virtual void value(size_t i, String&) const =0;
  virtual void value(size_t i, Point&) const =0;
  virtual void value(size_t i, LangString&) const =0;
protected:
  TupleIterator();
  virtual ~TupleIterator();
private:
  TupleIterator(const TupleIterator&);
  TupleIterator &operator=(const TupleIterator&);
};

class MLDLL OutputSequence
{
public:
  virtual void writeValue(int) =0;
  virtual void writeValue(unsigned) =0;
  virtual void writeValue(int64_t) =0;
  virtual void writeValue(uint64_t) =0;
  virtual void writeValue(float) =0;
  virtual void writeValue(double) =0;
  virtual void writeValue(Decimal) =0;
  virtual void writeValue(DateTime) =0;
  virtual void writeValue(Date) =0;
  virtual void writeValue(Time) =0;
  virtual void writeValue(GYearMonth) =0;
  virtual void writeValue(GYear) =0;
  virtual void writeValue(GMonth) =0;
  virtual void writeValue(GDay) =0;
  virtual void writeValue(YearMonthDuration) =0;
  virtual void writeValue(DayTimeDuration) =0;
  virtual void writeValue(const String&) =0;
  virtual void writeValue(Point) =0;
  virtual void writeValue(bool) =0;
  virtual void writeValue(const LangString&) =0;
  virtual void startMap() =0;
  virtual void writeMapKey(const char*) =0;
  virtual void endMap() =0;
protected:
  OutputSequence();
  virtual ~OutputSequence();
private:
  OutputSequence(const OutputSequence&);
  OutputSequence &operator=(const OutputSequence&);
};

class MLDLL Encoder
{
public:
  virtual void encode(const void*, size_t) =0;

  virtual void encode(int) =0;
  virtual void encode(unsigned) =0;
  virtual void encode(int64_t) =0;
  virtual void encode(uint64_t) =0;
  virtual void encode(float) =0;
  virtual void encode(double) =0;
  virtual void encode(Decimal) =0;
  virtual void encode(DateTime) =0;
  virtual void encode(Date) =0;
  virtual void encode(Time) =0;
  virtual void encode(GYearMonth) =0;
  virtual void encode(GYear) =0;
  virtual void encode(GMonth) =0;
  virtual void encode(GDay) =0;
  virtual void encode(YearMonthDuration) =0;
  virtual void encode(DayTimeDuration) =0;
  virtual void encode(const String&) =0;
  virtual void encode(Point) =0;
  virtual void encode(bool) =0;
  virtual void encode(const LangString&) =0;

protected:
  Encoder();
  virtual ~Encoder();
private:
  Encoder(const Encoder&);
  Encoder &operator=(const Encoder&);
};

class MLDLL Decoder
{
public:
  virtual void decode(const void*&, size_t&) =0;
  virtual void decode(void*, size_t) =0;

  virtual void decode(int&) =0;
  virtual void decode(unsigned&) =0;
  virtual void decode(int64_t&) =0;
  virtual void decode(uint64_t&) =0;
  virtual void decode(float&) =0;
  virtual void decode(double&) =0;
  virtual void decode(Decimal&) =0;
  virtual void decode(DateTime&) =0;
  virtual void decode(Date&) =0;
  virtual void decode(Time&) =0;
  virtual void decode(GYearMonth&) =0;
  virtual void decode(GYear&) =0;
  virtual void decode(GMonth&) =0;
  virtual void decode(GDay&) =0;
  virtual void decode(YearMonthDuration&) =0;
  virtual void decode(DayTimeDuration&) =0;
  virtual void decode(String&) =0;
  virtual void decode(Point&) =0;
  virtual void decode(bool&) =0;
  virtual void decode(LangString&) =0;

protected:
  Decoder();
  virtual ~Decoder();
private:
  Decoder(const Decoder&);
  Decoder &operator=(const Decoder&);
};

class MLDLL Reporter
{
public:
  enum LogLevel {
    Finest,
    Finer,
    Fine,
    Debug,
    Config,
    Info,
    Notice,
    Warning,
    Error,
    Critical,
    Alert,
    Emergency,
    Disabled
  };

  virtual LogLevel logLevel() const =0;
  virtual void log(LogLevel level, const char* message) =0;
  virtual void error(const char* message) =0;

protected:
  Reporter();
  virtual ~Reporter();
private:
  Reporter(const Reporter&);
  Reporter &operator=(const Reporter&);
};

class MLDLL Item
{
public:
  enum Type {
    // Atomic types
    INT,                        
    UNSIGNED_INT,               
    LONG,                       
    UNSIGNED_LONG,              
    FLOAT,                      
    DOUBLE,                     
    DECIMAL,                    
    DATE_TIME,                  
    TIME,                       
    DATE,                       
    G_YEAR_MONTH,               
    G_YEAR,                     
    G_MONTH,                    
    G_DAY,                      
    YEAR_MONTH_DURATION,        
    DAY_TIME_DURATION,          
    STRING,                     
    ANY_URI,                    
    BOOLEAN,                    

    // QNAME,
    // NOTATION,
    // DURATION,
    // G_MONTH_DAY,
    // BASE_64_BINARY,
    // HEX_BINARY,
    // UNTYPED_ATOMIC,

    // MarkLogic types
    POINT,                      
    MAP,                        

    // RDF types
    LANG_STRING,                

    // BOX,
    // CIRCLE,
    // POLYGON,
    // LINESTRING,
    // COMPLEX_POLYGON,
    // ARRAY,

    // // Nodes
    // DOCUMENT,
    // ELEMENT,
    // ATTRIBUTE,
    // TEXT,
    // PROCESSING_INSTRUCTION,
    // COMMENT,
    // NAMESPACE,
    // BINARY,

    // FUNCTION,

    OTHER                       
  };
};

class MLDLL Sequence
{
public:
  Sequence(SequenceImpl* =0);
  Sequence(const Sequence&);
  Sequence& operator=(const Sequence&);
  ~Sequence();

  operator bool() const { return seq!=0; }

  void next();
  bool done() const;

  Item::Type type() const;
  uint64_t frequency() const;

  void value(int&) const;
  void value(unsigned&) const;
  void value(int64_t&) const;
  void value(uint64_t&) const;
  void value(float&) const;
  void value(double&) const;
  void value(Decimal&) const;
  void value(DateTime&) const;
  void value(Date&) const;
  void value(Time&) const;
  void value(GYearMonth&) const;
  void value(GYear&) const;
  void value(GMonth&) const;
  void value(GDay&) const;
  void value(YearMonthDuration&) const;
  void value(DayTimeDuration&) const;
  void value(String&) const;
  void value(bool&) const;

  void value(Point&) const;
  void value(Map&) const;
  void value(LangString&) const;
private:
  SequenceImpl* seq;
};

class MLDLL Map
{
public:
  Map(MapImpl* =0);
  Map(const Map&);
  Map& operator=(const Map&);
  ~Map();

  operator bool() const { return map!=0; }

  Sequence get(const char* key) const;

private:
  MapImpl* map;
};

class MLDLL AggregateUDF
{
public:
  // Management methods
  virtual AggregateUDF* clone() const =0;
  virtual void close() =0;

  virtual void start(Sequence& arg, Reporter& r) =0;
  virtual void finish(OutputSequence& os, Reporter& r) =0;

  // Map/reduce methods
  virtual void map(TupleIterator& values, Reporter& r) =0;
  virtual void reduce(const AggregateUDF* o, Reporter& r) =0;

  // Serialize/deserialize
  virtual void encode(Encoder& e, Reporter& r) =0;
  virtual void decode(Decoder& d, Reporter& r) =0;

  virtual RangeIndex::Order getOrder() const;

protected:
  // Detect DLLs compiled against a different API version
  AggregateUDF(unsigned version = MARKLOGIC_API_VERSION);
  virtual ~AggregateUDF();
};

typedef AggregateUDF*(*AggregateFunction)();

class MLDLL Token
{
public:
  typedef unsigned char TokenType;

  static const TokenType SPACE   = 's';
  static const TokenType PUNCT   = 'p';
  static const TokenType WORD    = 'w';
  static const TokenType SPECIAL = 'x';

  typedef unsigned char PartOfSpeech;
  static const PartOfSpeech UNSPECIFIED_POS   = '\0';
  static const PartOfSpeech NOUN_POS          = 'n';
  static const PartOfSpeech VERB_POS          = 'v';
  static const PartOfSpeech ADJECTIVE_POS     = 'a';
  static const PartOfSpeech ADVERB_POS        = 'r';
  static const PartOfSpeech PRONOUN_POS       = 'p';
  static const PartOfSpeech CONJUNCTION_POS   = 'c';
  static const PartOfSpeech DETERMINER_POS    = 'd';
  static const PartOfSpeech MISC_POS          = '?';

public:
  unsigned begin;
  unsigned end;
  TokenType type;
  PartOfSpeech pos;

public:
  Token(unsigned _begin, unsigned _end, TokenType _type, PartOfSpeech _pos): 
    begin(_begin), end(_end), type(_type), pos(_pos) {}
  Token(unsigned _begin, unsigned _end, TokenType _type): 
    begin(_begin), end(_end), type(_type), pos(UNSPECIFIED_POS) {}
  Token(): begin(0), end(0), type(SPACE), pos(UNSPECIFIED_POS) {}
  Token(const Token& t): 
    begin(t.begin), end(t.end), type(t.type), pos(t.pos) {}
  ~Token() {}
};

typedef unsigned CodePoint;

class MLDLL CodePointString
{
public:
  CodePointString(const CodePoint* ptr, unsigned siz);
  CodePointString(const char* utf8);
  CodePointString(const CodePointString& other);
  CodePointString& operator=(const CodePointString& other);
  ~CodePointString();

  operator bool() const { return cpstr!=0; };

  const CodePoint* data() const;
  unsigned length() const;
  
  void appendUTF8(const char* utf8);
  void append(const CodePoint* ptr, unsigned siz);
  void push_back(CodePoint cp);
  void clear();
  void reserve(size_t sz);

protected:
  CodePointStringImpl* cpstr;
};

class MLDLL LexerUDF
{
public:
  // Management methods
  virtual void close() =0;
  virtual bool isStale() const =0;
  virtual void initialize(const char* lang,
                          int argc, const char** argv,
                          Reporter& r) =0;

  // Operations
  virtual void reset(const CodePoint* cp, unsigned sz, Reporter& r) =0;
  virtual void finish(Reporter& r) =0;
  virtual bool next(Reporter& r) =0;
  virtual const Token* token() const =0;

protected:
  // Detect DLLs compiled against a different API version
  LexerUDF(unsigned version = MARKLOGIC_API_VERSION);
  virtual ~LexerUDF();
};

typedef LexerUDF*(*LexerFunction)();

class MLDLL StemmerUDF
{
public:
  // Management methods
  virtual void close() =0;
  virtual bool isStale() const =0;
  virtual void initialize(const char* lang, 
                          int argc, const char** argv,
                          Reporter& r) =0;

  // Operations
  virtual void reset(const CodePoint* cp, const unsigned sz, Token::PartOfSpeech pos, Reporter& r) =0;

  virtual void start(Reporter& r) =0;

  virtual bool next(Reporter& r) =0;

  virtual const CodePointString* stem() =0;

  virtual bool delegate() const =0;

protected:
  // Detect DLLs compiled against a different API version
  StemmerUDF(unsigned version = MARKLOGIC_API_VERSION);
  virtual ~StemmerUDF();
};

typedef StemmerUDF*(*StemmerFunction)();

class MLDLL Registry
{
public:
  void version(unsigned pluginVersion = makeVersion(__DATE__,__TIME__),
    unsigned marklogicVersion = MARKLOGIC_API_VERSION);

  template<class T> void registerAggregate(const char* name);
  virtual void registerAggregate(const char* name, AggregateFunction f) =0;

  template<class T> void registerLexer(const char* name);
  virtual void registerLexer(const char* name, LexerFunction f) =0;

  template<class T> void registerStemmer(const char* name);
  virtual void registerStemmer(const char* name, StemmerFunction f) =0;

protected:
  Registry();
  virtual ~Registry();
private:
  Registry(const Registry&);
  Registry &operator=(const Registry&);
  static unsigned makeVersion(const char*,const char*);
protected:
  unsigned pluginVersion;
};

template<class T>
inline AggregateUDF*
constructAggregate()
{
  return new T();
}

template<class T>
inline LexerUDF*
constructLexer()
{
  return new T();
}

template<class T>
inline StemmerUDF*
constructStemmer()
{
  return new T();
}

template<class T>
inline void Registry::
registerAggregate(const char* name)
{
  registerAggregate(name,  marklogic::constructAggregate<T>);
}

template<class T>
inline void Registry::
registerLexer(const char* name)
{
  registerLexer(name,  marklogic::constructLexer<T>);
}

template<class T>
inline void Registry::
registerStemmer(const char* name)
{
  registerStemmer(name,  marklogic::constructStemmer<T>);
}

}

#endif