hdt 3.1.0 → 3.2.0

package/.eslintrc

@@ -137,7 +137,7 @@
     key-spacing: 0,
     lines-around-comment: 2,
     linebreak-style: 2,
-    max-nested-callbacks: [2, 2],
+    max-nested-callbacks: [2, 3],
     new-cap: 2,
     new-parens: 2,
     newline-after-var: 0,

package/.github/workflows/ci.yml

@@ -10,11 +10,21 @@ jobs:
   test:
     runs-on: ${{ matrix.os }}
     strategy:
+      fail-fast: false
       matrix:
-        os: [ubuntu-latest]
+        os:
+          - ubuntu-20.04
+          - ubuntu-22.04
+          - ubuntu-24.04
+          - ubuntu-latest
+          - macos-13
+          - macos-14
+          - macos-15
+          - macos-latest
         node-version:
           - 18.x
           - 20.x
+          - 22.x
     steps:
       - name: Use Node.js ${{ matrix.node-version }}
         uses: actions/setup-node@v3
@@ -33,7 +43,7 @@ jobs:
             **/node_modules
             .rdf-test-suite-cache
             .rdf-test-suite-ldf-cache
-          key: ${{ runner.os }}-test-modules-${{ hashFiles('**/package-lock.json') }}
+          key: ${{ runner.os }}-${{ runner.node-version }}-test-modules-${{ hashFiles('**/package-lock.json') }}
       - name: Install dependencies
         run: npm install
       - name: Run tests

package/.idea/codeStyles/Project.xml

@@ -0,0 +1,38 @@
+<component name="ProjectCodeStyleConfiguration">
+  <code_scheme name="Project" version="173">
+    <JSCodeStyleSettings version="0">
+      <option name="FORCE_SEMICOLON_STYLE" value="true" />
+      <option name="USE_DOUBLE_QUOTES" value="false" />
+      <option name="FORCE_QUOTE_STYlE" value="true" />
+      <option name="ENFORCE_TRAILING_COMMA" value="WhenMultiline" />
+      <option name="SPACES_WITHIN_OBJECT_LITERAL_BRACES" value="true" />
+      <option name="SPACES_WITHIN_IMPORTS" value="true" />
+    </JSCodeStyleSettings>
+    <TypeScriptCodeStyleSettings version="0">
+      <option name="USE_DOUBLE_QUOTES" value="false" />
+      <option name="SPACES_WITHIN_IMPORTS" value="true" />
+    </TypeScriptCodeStyleSettings>
+    <codeStyleSettings language="JavaScript">
+      <option name="BLOCK_COMMENT_ADD_SPACE" value="true" />
+      <option name="ELSE_ON_NEW_LINE" value="true" />
+      <option name="INDENT_CASE_FROM_SWITCH" value="false" />
+      <option name="ALIGN_MULTILINE_PARAMETERS" value="false" />
+      <option name="ALIGN_MULTILINE_FOR" value="false" />
+      <option name="IF_BRACE_FORCE" value="1" />
+      <option name="DOWHILE_BRACE_FORCE" value="1" />
+      <option name="WHILE_BRACE_FORCE" value="1" />
+      <option name="FOR_BRACE_FORCE" value="1" />
+      <indentOptions>
+        <option name="INDENT_SIZE" value="2" />
+        <option name="CONTINUATION_INDENT_SIZE" value="2" />
+      </indentOptions>
+    </codeStyleSettings>
+    <codeStyleSettings language="TypeScript">
+      <indentOptions>
+        <option name="INDENT_SIZE" value="2" />
+        <option name="CONTINUATION_INDENT_SIZE" value="2" />
+        <option name="TAB_SIZE" value="2" />
+      </indentOptions>
+    </codeStyleSettings>
+  </code_scheme>
+</component>

package/.idea/codeStyles/codeStyleConfig.xml

@@ -0,0 +1,5 @@
+<component name="ProjectCodeStyleConfiguration">
+  <state>
+    <option name="USE_PER_PROJECT_SETTINGS" value="true" />
+  </state>
+</component>

package/.idea/hdt.iml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="WEB_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$">
+      <excludeFolder url="file://$MODULE_DIR$/.tmp" />
+      <excludeFolder url="file://$MODULE_DIR$/temp" />
+      <excludeFolder url="file://$MODULE_DIR$/tmp" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

package/.idea/inspectionProfiles/Project_Default.xml

@@ -0,0 +1,7 @@
+<component name="InspectionProjectProfileManager">
+  <profile version="1.0">
+    <option name="myName" value="Project Default" />
+    <inspection_tool class="Eslint" enabled="true" level="WARNING" enabled_by_default="true" />
+    <inspection_tool class="JSHint" enabled="true" level="ERROR" enabled_by_default="true" />
+  </profile>
+</component>

package/.idea/jsLinters/jshint.xml

@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="JSHintConfiguration" version="2.13.6" use-config-file="true" use-custom-config-file="true" custom-config-file-path="$PROJECT_DIR$/.jshintrc">
+    <option bitwise="true" />
+    <option browser="true" />
+    <option curly="true" />
+    <option eqeqeq="true" />
+    <option forin="true" />
+    <option maxerr="50" />
+    <option noarg="true" />
+    <option noempty="true" />
+    <option nonew="true" />
+    <option strict="true" />
+    <option undef="true" />
+  </component>
+</project>

package/.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/hdt.iml" filepath="$PROJECT_DIR$/.idea/hdt.iml" />
+    </modules>
+  </component>
+</project>

package/.idea/vcs.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="" vcs="Git" />
+    <mapping directory="$PROJECT_DIR$/deps" vcs="Git" />
+  </component>
+</project>

package/README.md

@@ -1,6 +1,6 @@
 # HDT for Node.js
 [![npm version](https://badge.fury.io/js/hdt.svg)](https://www.npmjs.com/package/hdt)
-[![Build Status](https://travis-ci.org/RubenVerborgh/HDT-Node.svg?branch=master)](https://travis-ci.org/RubenVerborgh/HDT-Node)
+[![Build status](https://github.com/LinkedDataFragments/HDT-Node/workflows/CI/badge.svg)](https://github.com/LinkedDataFragments/HDT-Node/actions?query=workflow%3ACI)
 [![Dependency Status](https://david-dm.org/RubenVerborgh/HDT-Node.svg)](https://david-dm.org/RubenVerborgh/HDT-Node)
 [![devDependency Status](https://david-dm.org/RubenVerborgh/HDT-Node/dev-status.svg)](https://david-dm.org/RubenVerborgh/HDT-Node#info=devDependencies)
 
@@ -80,6 +80,37 @@ hdt.fromFile('./test/test.hdt')
   });
 ```
 
+### Searching for bindings matching a pattern
+Search for [bindings](https://rdf.js.org/query-spec/#bindings-interface) with `searchBindings`,
+which takes [bindingsFactory](https://rdf.js.org/query-spec/#bindingsfactory-interface), subject, predicate, object, and options arguments.
+Subject, predicate, and object can be IRIs, literals, or variables,
+[represented as RDF/JS terms](https://rdf.js.org/data-model-spec/#term-interface).
+If any of these parameters is a variable, it is considered a wildcard.
+Optionally, an offset and limit can be passed in an options object,
+selecting only the specified subset.
+
+The promise returns an object with an array of bindings, the total number of expected bindings for the pattern,
+and whether the total count is an estimate or exact.
+
+If variables are reused across terms, this library will make sure to only return bindings when matches for those variables are equal.
+
+```JavaScript
+const DF = new (require('rdf-data-factory').DataFactory)();
+const BF = new (require('@comunica/utils-bindings-factory').BindingsFactory)(DF);
+
+var doc;
+hdt.fromFile('./test/test.hdt')
+  .then(function(hdtDocument) {
+    doc = hdtDocument;
+    return doc.searchBindings(DF.namedNode('http://example.org/s1'), DF.variable('p'), DF.variable('o'), { offset: 0, limit: 10 })
+  })
+  .then(function(result) {
+    console.log('Approximately ' + result.totalCount + ' bindings match the pattern.');
+    result.bindings.forEach(function (binding) { console.log(binding.toString()); });
+    return doc.close();
+  });
+```
+
 ### Search terms starting with a prefix
 Find terms (literals and IRIs) that start with a given prefix.
 

package/binding.gyp

@@ -38,6 +38,7 @@
       ],
       "defines": [
         "HAVE_CDS",
+        "_LIBCPP_ENABLE_CXX17_REMOVED_UNARY_BINARY_FUNCTION",
       ],
       "cflags!":    [ "-fno-rtti", "-fno-exceptions" ],
       "cflags_cc!": [ "-fno-rtti", "-fno-exceptions" ],

package/deps/libhdt/src/util/StopWatch.cpp

@@ -163,7 +163,7 @@ std::ostream &operator<<(std::ostream &stream, StopWatch &sw) {
 }
 
 std::string StopWatch::toHuman(unsigned long long time) {
-    uint64_t tot_secs = time/1000000;
+    unsigned long long tot_secs = time/1000000;
 
 	unsigned int hours = tot_secs/3600;
 	unsigned int mins = (tot_secs/60) % 60;

package/lib/HdtDocument.cc

@@ -55,6 +55,7 @@ const Nan::Persistent<Function>& HdtDocument::GetConstructor() {
     constructorTemplate->InstanceTemplate()->SetInternalFieldCount(1);
     // Create prototype
     Nan::SetPrototypeMethod(constructorTemplate, "_searchTriples", SearchTriples);
+    Nan::SetPrototypeMethod(constructorTemplate, "_searchBindings", SearchBindings);
     Nan::SetPrototypeMethod(constructorTemplate, "_searchLiterals", SearchLiterals);
     Nan::SetPrototypeMethod(constructorTemplate, "_searchTerms",  SearchTerms);
     Nan::SetPrototypeMethod(constructorTemplate, "_fetchDistinctTerms", FetchDistinctTerms);
@@ -234,6 +235,141 @@ NAN_METHOD(HdtDocument::SearchTriples) {
     new Nan::Callback(info[5].As<Function>()), info.This()));
 }
 
+/******** HdtDocument#_searchBindings ********/
+
+class SearchBindingsWorker : public Nan::AsyncWorker {
+  HdtDocument* document;
+  // JavaScript function arguments
+  string subject, predicate, object;
+  uint32_t offset, limit;
+  // Callback return values
+  vector<TripleID> triples;
+  map<unsigned int, string> subjects, predicates, objects;
+  uint32_t totalCount;
+  bool hasExactCount;
+  bool varS, varP, varO;
+
+public:
+  SearchBindingsWorker(HdtDocument* document, char* subject, char* predicate, char* object,
+                       uint32_t offset, uint32_t limit, Nan::Callback* callback, Local<Object> self)
+    : Nan::AsyncWorker(callback),
+      document(document), subject(subject), predicate(predicate), object(object),
+      offset(offset), limit(limit), totalCount(0) {
+    SaveToPersistent(SELF, self);
+  };
+
+  void Execute() {
+    IteratorTripleID* it = NULL;
+    try {
+      // Determine which terms are variables
+      varS = isVariable(subject);
+      varP = isVariable(predicate);
+      varO = isVariable(object);
+
+      // Prepare the triple pattern
+      Dictionary* dict = document->GetHDT()->getDictionary();
+      TripleString triple(varS ? "" : subject, varP ? "" : predicate, varO ? "" : toHdtLiteral(object));
+      TripleID tripleId;
+      dict->tripleStringtoTripleID(triple, tripleId);
+      // If any of the components does not exist, there are no matches
+      if ((!varS && subject[0]   && !tripleId.getSubject())   ||
+          (!varP && predicate[0] && !tripleId.getPredicate()) ||
+          (!varO && object[0]    && !tripleId.getObject())) {
+        hasExactCount = true;
+        return;
+      }
+
+      // Estimate the total number of triples
+      it = document->GetHDT()->getTriples()->search(tripleId);
+      totalCount = it->estimatedNumResults();
+      hasExactCount = it->numResultEstimation() == EXACT;
+
+      // Go to the right offset
+      if (it->canGoTo())
+        try { it->skip(offset), offset = 0; }
+        catch (const runtime_error error) { /* invalid offset */ }
+      else
+        while (offset && it->hasNext()) it->next(), offset--;
+
+      // Add matching triples to the result vector
+      if (!offset) {
+        while (it->hasNext() && triples.size() < limit) {
+          TripleID& triple = *it->next();
+          triples.push_back(triple);
+          if (varS && !subjects.count(triple.getSubject())) {
+            subjects[triple.getSubject()] = dict->idToString(triple.getSubject(), SUBJECT);
+          }
+          if (varP && !predicates.count(triple.getPredicate())) {
+            predicates[triple.getPredicate()] = dict->idToString(triple.getPredicate(), PREDICATE);
+          }
+          if (varO && !objects.count(triple.getObject())) {
+            string object(dict->idToString(triple.getObject(), OBJECT));
+            objects[triple.getObject()] = fromHdtLiteral(object);
+          }
+        }
+      }
+    }
+    catch (const runtime_error error) { SetErrorMessage(error.what()); }
+    if (it)
+      delete it;
+  }
+
+  void HandleOKCallback() {
+    Nan::HandleScope scope;
+    // Convert the triple components into strings
+    map<unsigned int, string>::const_iterator it;
+    map<unsigned int, Local<String> > subjectStrings, predicateStrings, objectStrings;
+    for (it = subjects.begin(); it != subjects.end(); it++)
+      subjectStrings[it->first] = Nan::New(it->second.c_str()).ToLocalChecked();
+    for (it = predicates.begin(); it != predicates.end(); it++)
+      predicateStrings[it->first] = Nan::New(it->second.c_str()).ToLocalChecked();
+    for (it = objects.begin(); it != objects.end(); it++)
+      objectStrings[it->first] = Nan::New(it->second.c_str()).ToLocalChecked();
+
+    // Convert the triples into a double JavaScript array
+    uint32_t count = 0;
+    Local<Array> bindingsArray = Nan::New<Array>(triples.size());
+    uint32_t variables = (varS ? 1 : 0) + (varP ? 1 : 0) + (varO ? 1 : 0);
+    for (vector<TripleID>::const_iterator it = triples.begin(); it != triples.end(); it++) {
+      uint32_t countInner = 0;
+      Local<Object> bindingsArrayInner = Nan::New<Array>(variables);
+      if (varS) {
+        Nan::Set(bindingsArrayInner, countInner++, subjectStrings[it->getSubject()]);
+      }
+      if (varP) {
+        Nan::Set(bindingsArrayInner, countInner++, predicateStrings[it->getPredicate()]);
+      }
+      if (varO) {
+        Nan::Set(bindingsArrayInner, countInner++, objectStrings[it->getObject()]);
+      }
+      Nan::Set(bindingsArray, count++, bindingsArrayInner);
+    }
+
+    // Send the JavaScript array through the callback
+    const unsigned argc = 4;
+    Local<Value> argv[argc] = { Nan::Null(), bindingsArray,
+                                Nan::New<Integer>((uint32_t)totalCount),
+                                Nan::New<Boolean>((bool)hasExactCount) };
+    callback->Call(Nan::To<v8::Object>(GetFromPersistent(SELF)).ToLocalChecked(), argc, argv, async_resource);
+  }
+
+  void HandleErrorCallback() {
+    Nan::HandleScope scope;
+    Local<Value> argv[] = { Exception::Error(Nan::New(ErrorMessage()).ToLocalChecked()) };
+    callback->Call(Nan::To<v8::Object>(GetFromPersistent(SELF)).ToLocalChecked(), 1, argv, async_resource);
+  }
+};
+
+// Searches for a triple pattern in the document and return bindings.
+// JavaScript signature: HdtDocument#_searchBindings(subject, predicate, object, offset, limit, callback)
+NAN_METHOD(HdtDocument::SearchBindings) {
+  assert(info.Length() == 6);
+  Nan::AsyncQueueWorker(new SearchBindingsWorker(Unwrap<HdtDocument>(info.This()),
+    *Nan::Utf8String(info[0]), *Nan::Utf8String(info[1]), *Nan::Utf8String(info[2]),
+    Nan::To<uint32_t>(info[3]).FromJust(), Nan::To<uint32_t>(info[4]).FromJust(),
+    new Nan::Callback(info[5].As<Function>()), info.This()));
+}
+
 
 
 /******** HdtDocument#_searchLiterals ********/
@@ -612,6 +748,10 @@ NAN_PROPERTY_GETTER(HdtDocument::Closed) {
 //   "literal"^^<http://example.org/datatype>
 // The functions below convert when needed.
 
+// Check if a term is a variable
+bool isVariable(string& term) {
+  return term[0] == '?';
+}
 
 // Converts a JavaScript literal to an HDT literal
 string& toHdtLiteral(string& literal) {

package/lib/HdtDocument.h

@@ -32,6 +32,8 @@ class HdtDocument : public node::ObjectWrap {
 
   // HdtDocument#_searchTriples(subject, predicate, object, offset, limit, callback, self)
   static NAN_METHOD(SearchTriples);
+  // HdtDocument#_searchBindings(subject, predicate, object, offset, limit, callback, self)
+  static NAN_METHOD(SearchBindings);
   // HdtDocument#_searchLiterals(substring, offset, limit, callback, self)
   static NAN_METHOD(SearchLiterals);
   // HdtDocument#_searchTerms(prefix, limit, position, callback)
@@ -50,6 +52,8 @@ class HdtDocument : public node::ObjectWrap {
   static NAN_PROPERTY_GETTER(Closed);
 };
 
+// Check if a term is a variable
+bool isVariable(string& term);
 // Converts a JavaScript literal to an HDT literal
 std::string& toHdtLiteral(std::string& literal);
 // Converts an HDT literal to a JavaScript literal

package/lib/hdt.js

@@ -13,6 +13,10 @@ function isValidHdtTerm(term) {
   return term && term.termType && (term.termType === 'Literal' || term.termType === 'BlankNode' || term.termType === 'NamedNode');
 }
 
+function isValidHdtTermForSearchBindings(term) {
+  return isValidHdtTerm(term) || (term && term.termType === 'Variable');
+}
+
 // Searches the document for triples with the given subject, predicate, and object.
 HdtDocumentPrototype.searchTriples = function (subject, predicate, object, options) {
   if (this.closed) return closedError;
@@ -29,6 +33,80 @@ HdtDocumentPrototype.searchTriples = function (subject, predicate, object, optio
   });
 };
 
+// Searches the document for triples with the given subject, predicate, and object, and return them as bindings
+HdtDocumentPrototype.searchBindings = function (bindingsFactory, subject, predicate, object, options) {
+  if (this.closed) return closedError;
+  if (!isValidHdtTermForSearchBindings(subject) || !isValidHdtTermForSearchBindings(predicate) || !isValidHdtTermForSearchBindings(object)) throw new Error('Passed invalid subject term');
+  options = options || {};
+  return new Promise((resolve, reject) => {
+    // Collect variable terms
+    const variables = [];
+    if (subject.termType === 'Variable')   variables.push(subject);
+    if (predicate.termType === 'Variable') variables.push(predicate);
+    if (object.termType === 'Variable')    variables.push(object);
+
+    // Check if we need to do post-filtering for overlapping variables
+    let shouldFilterIndexes = false;
+    const filterIndexes = variables.map((variable, i) => {
+      const equalVariables = [];
+      for (let j = i + 1; j < variables.length; j++) {
+        if (variable.equals(variables[j])) {
+          equalVariables.push(j);
+          shouldFilterIndexes = true;
+        }
+      }
+      return equalVariables;
+    });
+
+    // If we have offset and limit with overlapping variables, they must be handled in JS-land.
+    const offset = parseOffset(options);
+    const limit = parseLimit(options);
+
+    this._searchBindings(termToString(subject), termToString(predicate), termToString(object),
+      shouldFilterIndexes ? 0 : offset, shouldFilterIndexes ? MAX : limit,
+      (err, bindingsRaw, totalCount, hasExactCount) => {
+        if (err)
+          return reject(err);
+
+        // If we had overlapping variables, potentially filter bindings
+        if (shouldFilterIndexes) {
+          // Filter bindings
+          bindingsRaw = bindingsRaw.filter(binding => {
+            for (let i = 0; i < binding.length; i++) {
+              const bindingEntry = binding[i];
+              const filterI = filterIndexes[i];
+              if (filterI) {
+                for (const j of filterI) {
+                  if (j !== undefined && bindingEntry !== binding[j]) {
+                    totalCount--;
+                    return false;
+                  }
+                }
+              }
+            }
+            return true;
+          });
+
+          // Apply offsets and limits in JS-land
+          if (offset > 0 || limit < MAX) {
+            hasExactCount = true;
+            totalCount = bindingsRaw.length;
+            bindingsRaw = bindingsRaw.slice(offset, offset + limit);
+          }
+        }
+
+        // Create bindings objects
+        const bindings = bindingsRaw.map(b => bindingsFactory.bindings(b.map((value, i) => [variables[i], stringToTerm(value)])));
+
+        return resolve({
+          bindings,
+          totalCount,
+          hasExactCount,
+        });
+      });
+  });
+};
+
 // Gives an approximate number of matches of triples with the given subject, predicate, and object.
 HdtDocumentPrototype.countTriples = function (subject, predicate, object) {
   return this.search(subject, predicate, object, { offset: 0, limit: 0 });
@@ -152,6 +230,7 @@ module.exports = {
         // Document the features of the HDT file
         document.features = Object.freeze({
           searchTriples:  true, // supported by default
+          searchBindings: true, // supported by default
           countTriples:   true, // supported by default
           searchLiterals: !!(document._features & 1),
           readHeader:     true, // supported by default

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hdt",
-  "version": "3.1.0",
+  "version": "3.2.0",
   "description": "Native bindings to access HDT compressed triple files.",
   "author": "Ruben Verborgh <ruben.verborgh@gmail.com>",
   "keywords": [
@@ -28,7 +28,8 @@
   "scripts": {
     "test": "rm test/*.hdt.index.* 2> /dev/null; mocha",
     "lint": "eslint --fix lib/*.js test/*.js bin/*",
-    "validate": "npm ls"
+    "validate": "npm ls",
+    "preinstall": "if [ -e replace-in-file.json ]; then replace-in-file --configFile=replace-in-file.json; fi && node-gyp rebuild"
   },
   "dependencies": {
     "minimist": "^1.1.0",
@@ -40,7 +41,9 @@
     "eslint": "^5.3.0",
     "mocha": "^6.2.2",
     "precommit-hook": "^3.0.0",
-    "should": "^13.1.0"
+    "replace-in-file": "^8.3.0",
+    "should": "^13.1.0",
+    "@comunica/utils-bindings-factory": "^4.0.2"
   },
   "pre-commit": [
     "lint",

package/perf/run.js

@@ -0,0 +1,43 @@
+const hdt = require('../lib/hdt');
+const DF = require('n3').DataFactory;
+const BF = new (require('@comunica/utils-bindings-factory').BindingsFactory)(DF);
+
+const REPLICATION = 100000;
+hdt.fromFile('../test/test.hdt').then(runForDocument);
+
+async function runForDocument(document) {
+  console.time('warmup');
+  await iterate(document, 10000, searchTriples);
+  await iterate(document, 10000, searchBindings);
+  console.timeEnd('warmup');
+
+  console.time('searchTriples');
+  await iterate(document, REPLICATION, searchTriples);
+  console.timeEnd('searchTriples');
+
+  console.time('searchBindings');
+  await iterate(document, REPLICATION, searchBindings);
+  console.timeEnd('searchBindings');
+}
+
+async function iterate(document, replication, fun) {
+  for (let i = 0; i < replication; i++) {
+    await fun(document);
+  }
+}
+
+async function searchTriples(document) {
+  const { triples } = await document.searchTriples(DF.namedNode('http://example.org/s2'), null, null);
+  assert(triples.length == 10);
+}
+
+async function searchBindings(document) {
+  const { bindings } = await document.searchBindings(BF, DF.namedNode('http://example.org/s2'), DF.variable('p'), DF.variable('o'));
+  assert(bindings.length == 10);
+}
+
+function assert(condition, message) {
+  if (!condition) {
+    throw message || "Assertion failed";
+  }
+}

package/replace-in-file.json

@@ -0,0 +1,5 @@
+{
+  "files": "deps/libhdt/src/util/StopWatch.cpp",
+  "from": "uint64_t",
+  "to": "unsigned long long"
+}

package/deps/hdt-it/LICENSE

@@ -1,280 +0,0 @@
-                   GNU GENERAL PUBLIC LICENSE
-                       Version 2, June 1991
-
- Copyright (C) 1989, 1991 Free Software Foundation, Inc.
-                       59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-                            Preamble
-
-  The licenses for most software are designed to take away your
-freedom to share and change it.  By contrast, the GNU General Public
-License is intended to guarantee your freedom to share and change free
-software--to make sure the software is free for all its users.  This
-General Public License applies to most of the Free Software
-Foundation's software and to any other program whose authors commit to
-using it.  (Some other Free Software Foundation software is covered by
-the GNU Library General Public License instead.)  You can apply it to
-your programs, too.
-
-  When we speak of free software, we are referring to freedom, not
-price.  Our General Public Licenses are designed to make sure that you
-have the freedom to distribute copies of free software (and charge for
-this service if you wish), that you receive source code or can get it
-if you want it, that you can change the software or use pieces of it
-in new free programs; and that you know you can do these things.
-
-  To protect your rights, we need to make restrictions that forbid
-anyone to deny you these rights or to ask you to surrender the rights.
-These restrictions translate to certain responsibilities for you if you
-distribute copies of the software, or if you modify it.
-
-  For example, if you distribute copies of such a program, whether
-gratis or for a fee, you must give the recipients all the rights that
-you have.  You must make sure that they, too, receive or can get the
-source code.  And you must show them these terms so they know their
-rights.
-
-  We protect your rights with two steps: (1) copyright the software, and
-(2) offer you this license which gives you legal permission to copy,
-distribute and/or modify the software.
-
-  Also, for each author's protection and ours, we want to make certain
-that everyone understands that there is no warranty for this free
-software.  If the software is modified by someone else and passed on, we
-want its recipients to know that what they have is not the original, so
-that any problems introduced by others will not reflect on the original
-authors' reputations.
-
-  Finally, any free program is threatened constantly by software
-patents.  We wish to avoid the danger that redistributors of a free
-program will individually obtain patent licenses, in effect making the
-program proprietary.  To prevent this, we have made it clear that any
-patent must be licensed for everyone's free use or not licensed at all.
-
-  The precise terms and conditions for copying, distribution and
-modification follow.
-
-                    GNU GENERAL PUBLIC LICENSE
-   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
-
-  0. This License applies to any program or other work which contains
-a notice placed by the copyright holder saying it may be distributed
-under the terms of this General Public License.  The "Program", below,
-refers to any such program or work, and a "work based on the Program"
-means either the Program or any derivative work under copyright law:
-that is to say, a work containing the Program or a portion of it,
-either verbatim or with modifications and/or translated into another
-language.  (Hereinafter, translation is included without limitation in
-the term "modification".)  Each licensee is addressed as "you".
-
-Activities other than copying, distribution and modification are not
-covered by this License; they are outside its scope.  The act of
-running the Program is not restricted, and the output from the Program
-is covered only if its contents constitute a work based on the
-Program (independent of having been made by running the Program).
-Whether that is true depends on what the Program does.
-
-  1. You may copy and distribute verbatim copies of the Program's
-source code as you receive it, in any medium, provided that you
-conspicuously and appropriately publish on each copy an appropriate
-copyright notice and disclaimer of warranty; keep intact all the
-notices that refer to this License and to the absence of any warranty;
-and give any other recipients of the Program a copy of this License
-along with the Program.
-
-You may charge a fee for the physical act of transferring a copy, and
-you may at your option offer warranty protection in exchange for a fee.
-
-  2. You may modify your copy or copies of the Program or any portion
-of it, thus forming a work based on the Program, and copy and
-distribute such modifications or work under the terms of Section 1
-above, provided that you also meet all of these conditions:
-
-    a) You must cause the modified files to carry prominent notices
-    stating that you changed the files and the date of any change.
-
-    b) You must cause any work that you distribute or publish, that in
-    whole or in part contains or is derived from the Program or any
-    part thereof, to be licensed as a whole at no charge to all third
-    parties under the terms of this License.
-
-    c) If the modified program normally reads commands interactively
-    when run, you must cause it, when started running for such
-    interactive use in the most ordinary way, to print or display an
-    announcement including an appropriate copyright notice and a
-    notice that there is no warranty (or else, saying that you provide
-    a warranty) and that users may redistribute the program under
-    these conditions, and telling the user how to view a copy of this
-    License.  (Exception: if the Program itself is interactive but
-    does not normally print such an announcement, your work based on
-    the Program is not required to print an announcement.)
-
-These requirements apply to the modified work as a whole.  If
-identifiable sections of that work are not derived from the Program,
-and can be reasonably considered independent and separate works in
-themselves, then this License, and its terms, do not apply to those
-sections when you distribute them as separate works.  But when you
-distribute the same sections as part of a whole which is a work based
-on the Program, the distribution of the whole must be on the terms of
-this License, whose permissions for other licensees extend to the
-entire whole, and thus to each and every part regardless of who wrote it.
-
-Thus, it is not the intent of this section to claim rights or contest
-your rights to work written entirely by you; rather, the intent is to
-exercise the right to control the distribution of derivative or
-collective works based on the Program.
-
-In addition, mere aggregation of another work not based on the Program
-with the Program (or with a work based on the Program) on a volume of
-a storage or distribution medium does not bring the other work under
-the scope of this License.
-
-  3. You may copy and distribute the Program (or a work based on it,
-under Section 2) in object code or executable form under the terms of
-Sections 1 and 2 above provided that you also do one of the following:
-
-    a) Accompany it with the complete corresponding machine-readable
-    source code, which must be distributed under the terms of Sections
-    1 and 2 above on a medium customarily used for software interchange; or,
-
-    b) Accompany it with a written offer, valid for at least three
-    years, to give any third party, for a charge no more than your
-    cost of physically performing source distribution, a complete
-    machine-readable copy of the corresponding source code, to be
-    distributed under the terms of Sections 1 and 2 above on a medium
-    customarily used for software interchange; or,
-
-    c) Accompany it with the information you received as to the offer
-    to distribute corresponding source code.  (This alternative is
-    allowed only for noncommercial distribution and only if you
-    received the program in object code or executable form with such
-    an offer, in accord with Subsection b above.)
-
-The source code for a work means the preferred form of the work for
-making modifications to it.  For an executable work, complete source
-code means all the source code for all modules it contains, plus any
-associated interface definition files, plus the scripts used to
-control compilation and installation of the executable.  However, as a
-special exception, the source code distributed need not include
-anything that is normally distributed (in either source or binary
-form) with the major components (compiler, kernel, and so on) of the
-operating system on which the executable runs, unless that component
-itself accompanies the executable.
-
-If distribution of executable or object code is made by offering
-access to copy from a designated place, then offering equivalent
-access to copy the source code from the same place counts as
-distribution of the source code, even though third parties are not
-compelled to copy the source along with the object code.
-
-  4. You may not copy, modify, sublicense, or distribute the Program
-except as expressly provided under this License.  Any attempt
-otherwise to copy, modify, sublicense or distribute the Program is
-void, and will automatically terminate your rights under this License.
-However, parties who have received copies, or rights, from you under
-this License will not have their licenses terminated so long as such
-parties remain in full compliance.
-
-  5. You are not required to accept this License, since you have not
-signed it.  However, nothing else grants you permission to modify or
-distribute the Program or its derivative works.  These actions are
-prohibited by law if you do not accept this License.  Therefore, by
-modifying or distributing the Program (or any work based on the
-Program), you indicate your acceptance of this License to do so, and
-all its terms and conditions for copying, distributing or modifying
-the Program or works based on it.
-
-  6. Each time you redistribute the Program (or any work based on the
-Program), the recipient automatically receives a license from the
-original licensor to copy, distribute or modify the Program subject to
-these terms and conditions.  You may not impose any further
-restrictions on the recipients' exercise of the rights granted herein.
-You are not responsible for enforcing compliance by third parties to
-this License.
-
-  7. If, as a consequence of a court judgment or allegation of patent
-infringement or for any other reason (not limited to patent issues),
-conditions are imposed on you (whether by court order, agreement or
-otherwise) that contradict the conditions of this License, they do not
-excuse you from the conditions of this License.  If you cannot
-distribute so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you
-may not distribute the Program at all.  For example, if a patent
-license would not permit royalty-free redistribution of the Program by
-all those who receive copies directly or indirectly through you, then
-the only way you could satisfy both it and this License would be to
-refrain entirely from distribution of the Program.
-
-If any portion of this section is held invalid or unenforceable under
-any particular circumstance, the balance of the section is intended to
-apply and the section as a whole is intended to apply in other
-circumstances.
-
-It is not the purpose of this section to induce you to infringe any
-patents or other property right claims or to contest validity of any
-such claims; this section has the sole purpose of protecting the
-integrity of the free software distribution system, which is
-implemented by public license practices.  Many people have made
-generous contributions to the wide range of software distributed
-through that system in reliance on consistent application of that
-system; it is up to the author/donor to decide if he or she is willing
-to distribute software through any other system and a licensee cannot
-impose that choice.
-
-This section is intended to make thoroughly clear what is believed to
-be a consequence of the rest of this License.
-
-  8. If the distribution and/or use of the Program is restricted in
-certain countries either by patents or by copyrighted interfaces, the
-original copyright holder who places the Program under this License
-may add an explicit geographical distribution limitation excluding
-those countries, so that distribution is permitted only in or among
-countries not thus excluded.  In such case, this License incorporates
-the limitation as if written in the body of this License.
-
-  9. The Free Software Foundation may publish revised and/or new versions
-of the General Public License from time to time.  Such new versions will
-be similar in spirit to the present version, but may differ in detail to
-address new problems or concerns.
-
-Each version is given a distinguishing version number.  If the Program
-specifies a version number of this License which applies to it and "any
-later version", you have the option of following the terms and conditions
-either of that version or of any later version published by the Free
-Software Foundation.  If the Program does not specify a version number of
-this License, you may choose any version ever published by the Free Software
-Foundation.
-
-  10. If you wish to incorporate parts of the Program into other free
-programs whose distribution conditions are different, write to the author
-to ask for permission.  For software which is copyrighted by the Free
-Software Foundation, write to the Free Software Foundation; we sometimes
-make exceptions for this.  Our decision will be guided by the two goals
-of preserving the free status of all derivatives of our free software and
-of promoting the sharing and reuse of software generally.
-
-                            NO WARRANTY
-
-  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
-FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
-OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
-PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
-OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
-TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
-PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
-REPAIR OR CORRECTION.
-
-  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
-WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
-REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
-INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
-OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
-TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
-YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
-PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
-POSSIBILITY OF SUCH DAMAGES.
-
-                     END OF TERMS AND CONDITIONS

package/deps/hdt-it/README.md

@@ -1,73 +0,0 @@
-# HDT-it! GUI tool for the HDT triple format
-
-Overview
-=================
-
-HDT-it is a tool that can generate
-and consume RDF files in HDT format. It demonstrates the capabilities
-of HDT by allowing to search basic triple patterns against HDT files, and
-also visualizes the 3D adjacency matrix of the underlying RDF graph to
-provide an overview of the dataset distribution.
-
-Download executable
-=================
-
-An executable version of the tool is available for multiple platforms in http://www.rdfhdt.org/downloads/ 
-
-Compiling
-=================
-
-Dependencies: 
-
-- HDT-Lib 
-- QT4 (http://doc.qt.io/qt-4.8/)
-	
-Compilation:
-	
-1.Compile the main hdt-lib library. To compile the library run `make` under the directory `hdt-lib`, this will generate the library and tools.
-2. Execute Qmake in libcds-v1.0.12:
-
-    $ cd libcds-v1.0.12/qmake
-    $ qmake 
-    $ make
-    
-3.Execute Qmake in hdt-lib
-
-    $ cd hdt-lib/qmake
-    $ qmake 
-    $ make
-    
-4.Execute Qmake in hdt-it
-
-    $ cd hdt-it
-    $ qmake 
-    $ make
-
-The application should be available in a new hdt-it subfolder (e.g. hdt-it/unix or hdt-it/win32)
- 
-Licensing
-=================
-Copyright (C) 2012, Mario Arias, Javier D. Fernandez, Miguel A. Martinez-Prieto
-All rights reserved.
-
-This library is free software; you can redistribute it and/or
-modify it under the terms of the GNU Lesser General Public
-License as published by the Free Software Foundation; either
-version 2.1 of the License, or (at your option) any later version.
-
-This library is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-Lesser General Public License for more details.
-
-You should have received a copy of the GNU Lesser General Public
-License along with this library; if not, write to the Free Software
-Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
-
-Visit our Web Page: www.rdfhdt.org
-
-Contacting the authors:
- - Mario Arias:               mario.arias@deri.org
- - Javier D. Fernandez:       jfergar@infor.uva.es
- - Miguel A. Martinez-Prieto: migumar2@infor.uva.es
- 

package/deps/libcds/README

@@ -1,12 +0,0 @@
-libcds implements low-level succinct data structures such as bitmaps,
-sequences, permutations, etc. The main goal is to provide a set of
-structures that form the building block of most compressed/succinct
-solutions. In the near future we are planning to add compression
-algorithms and support for succinct trees.
-
-You can find more information at http://libcds.recoded.cl/
-
-Right now we are just fixing bugs and testing some new things in here,
-but most of the effort is being put into libcds2, this rewrite aims at
-solving many problems with 64bits systems. This is necessary in order
-to index bigger inputs.