Merge pull request #136 from kiwix/2.0.0

2.0.0

.clang-format

@@ -0,0 +1,12 @@
+BasedOnStyle:  Google
+BinPackArguments: false
+BinPackParameters: false
+BreakBeforeBinaryOperators: All
+BreakBeforeBraces: Linux
+DerivePointerAlignment: false
+SpacesInContainerLiterals: false
+Standard: Cpp11
+
+AllowShortFunctionsOnASingleLine: Inline
+AllowShortIfStatementsOnASingleLine: false
+AllowShortLoopsOnASingleLine: false

.travis.yml

@@ -1,13 +1,43 @@
 language: cpp
 dist: trusty
-sudo: required
+sudo: false
 cache: ccache
+before_install:
+- if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then eval "${MATRIX_EVAL}"; fi
+- PATH=$PATH:$HOME/bin
+- ${CXX} --version
 install: travis/install_deps.sh
 script: travis/compile.sh
 env:
- - PLATFORM="native_static"
- - PLATFORM="native_dyn"
- - PLATFORM="win32_static"
- - PLATFORM="win32_dyn"
- - PLATFORM="android_arm"
- - PLATFORM="android_arm64"
+  global:
+    - MATRIX_EVAL="CC=gcc-5 && CXX=g++-5"
+  matrix:
+    - PLATFORM="native_static"
+    - PLATFORM="native_dyn"
+    - PLATFORM="win32_static"
+    - PLATFORM="win32_dyn"
+    - PLATFORM="android_arm"
+    - PLATFORM="android_arm64"
+addons:
+  apt:
+    sources:
+      - ubuntu-toolchain-r-test
+    packages:
+      - g++-5
+      - cmake
+      - python3-pip
+      - libbz2-dev
+      - ccache
+      - zlib1g-dev
+      - uuid-dev
+      - libctpp2-dev
+      - ctpp2-utils
+      - libmicrohttpd-dev
+      - g++-mingw-w64-i686
+      - gcc-mingw-w64-i686
+      - gcc-mingw-w64-base
+      - mingw-w64-tools
+matrix:
+  include:
+    - env: PLATFORM="native_dyn"
+      os: osx

AUTHORS

@@ -0,0 +1,17 @@
+Automactic <christopherliqd@gmail.com>
+Ayoub DARDORY <ayoubuto@gmail.com>
+Cristian Patrasciuc <cristip@google.com>
+Dattaz <taz@dattaz.fr>
+Elad Keyshawn <elad.keyshawn@gmail.com>
+Emmanuel Engelhart <kelson@kiwix.org>
+Isaac <mhutti1@gmail.com>
+jleow00 <leow.yonghan.jerome@gmail.com>
+Julian Harty <julianharty@gmail.com>
+Kiran Mathew Koshy <kiranmathewkoshy@gmail.com>
+Kunal Mehta <legoktm@member.fsf.org>
+Matthieu Gautier <mgautier@kymeria.fr>
+Rashiq Ahmad <rashiq.z@gmail.com>
+Renaud Gaudin <reg@kiwix.org>
+Shivam <ssarodia@gmail.com>
+Steve Wills <steve@mouf.net>
+Synhershko <synhershko@users.sourceforge.net>

ChangeLog

@@ -1,3 +1,62 @@
+kiwix-lib 2.0.0
+===============
+
+ * Introduce a new API to retrive content from a reader.
+   * Introduce the `Entry` class.
+   * Reader's methods return an `Entry`.
+   * Content and other information can be retrieved from the `Entry`.
+   * Older Reader's methods are depreciated.
+ * Add an `OPDSDumper` class to dump a whole `Library` as an OPDS feed.
+ * Add a tool function to get the content of a file.
+ * Add a tool function to create a tempory directory.
+ * Add a `Downloader` class to download a file.
+ * Allow the manager to populate a `Library` from an OPDS feed.
+ * Try to locate libctpp2 in default system libdir and then fallback in 'lib'
+   directory.
+ * Build kiwix-lib setting RPATH.
+ * Build kiwix-lib without warning (werror=true)
+ * Build kiwix-lib on macos.
+
+kiwix-lib 1.1.1
+===============
+
+ * Correct the name of kiwix-lib (from `kiwixlib`) in meson.build to generate
+   dist archive with the correct name.
+ * Libzim version need to be at least 3.2.0
+
+kiwix-lib 1.1.0
+===============
+
+ * Allow for more than 70 search result per page in html results rendering
+   (kiwix/kiwix-tools#92)
+ * Add a small api to do geo queries.
+ * Add multi-search support in the JNI (#67)
+ * Add an API to get only one part of an article.
+ * Add an API to get direct location of an article content in the zim file.
+ * Improve urlencoding
+ * Fix pagination in html results rendering.
+ * Compile using gcc-5 on Travis.
+ * Allow JNI to access search snippets.
+ * JNI throw an exception instead of returning an invalid object if something
+   goes wrong.
+ * Add doctext documentation. (#116)
+ * Various bug fixes.
+
+kiwix-lib 1.0.0
+===============
+
+ * Correctly regenerate template resource using cttp2c at compilation time.
+ * Suggestion use xapian database when available
+ * Support multi-zim search in kiwix-lib (a search can now search on several
+   embedded database in zims in the same time)
+ * Fix some wording
+ * Fix license issues
+ * Add out argument to jni getContent* method to get the title of article in
+   the same time we get the content
+ * Rename `compile_resources.py` script to `kiwix-compile-resources`
+ * Use static lib when building for android or in "static mode"
+ * Make the ResourceNotFound exception public
+
 kiwix-lib 0.2.0
 ===============
 

README.md

@@ -37,6 +37,7 @@ libraries need to be available:
 (package libctpp2-dev on Ubuntu)
 * Xapian ......................................... https://xapian.org/
 (package libxapian-dev on Ubuntu)
+* libaria2 .................................. https://aria2.github.io/
 
 These dependencies may or may not be packaged by your operating
 system. They may also be packaged but only in an older version. The
@@ -68,7 +69,7 @@ Then install Meson itself:
 ```
 virtualenv -p python3 ./ # Create virtualenv
 source bin/activate      # Activate the virtualenv
-pip install meson        # Install Meson
+pip3 install meson        # Install Meson
 hash -r                  # Refresh bash paths
 ```
 

format_code.sh

@@ -0,0 +1,36 @@
+#!/usr/bin/bash
+
+files=(
+"include/library.h"
+"include/common/stringTools.h"
+"include/common/pathTools.h"
+"include/common/otherTools.h"
+"include/common/regexTools.h"
+"include/common/networkTools.h"
+"include/manager.h"
+"include/reader.h"
+"include/kiwix.h"
+"include/xapianSearcher.h"
+"include/searcher.h"
+"src/library.cpp"
+"src/android/kiwix.cpp"
+"src/android/org/kiwix/kiwixlib/JNIKiwixBool.java"
+"src/android/org/kiwix/kiwixlib/JNIKiwix.java"
+"src/android/org/kiwix/kiwixlib/JNIKiwixString.java"
+"src/android/org/kiwix/kiwixlib/JNIKiwixInt.java"
+"src/searcher.cpp"
+"src/common/pathTools.cpp"
+"src/common/regexTools.cpp"
+"src/common/otherTools.cpp"
+"src/common/networkTools.cpp"
+"src/common/stringTools.cpp"
+"src/xapianSearcher.cpp"
+"src/manager.cpp"
+"src/reader.cpp"
+)
+
+for i in "${files[@]}"
+do
+  echo $i
+  clang-format -i -style=file $i
+done

include/common.h

@@ -0,0 +1,24 @@
+
+#ifndef _KIWIX_COMMON_H_
+#define _KIWIX_COMMON_H_
+
+#include <zim/zim.h>
+
+#ifdef __GNUC__
+#define DEPRECATED __attribute__((deprecated))
+#elif defined(_MSC_VER)
+#define DEPRECATED __declspec(deprecated)
+#else
+#praga message("WARNING: You need to implement DEPRECATED for this compiler")
+#define DEPRECATED
+#endif
+
+
+namespace kiwix {
+
+typedef zim::size_type size_type;
+typedef zim::offset_type offset_type;
+
+}
+
+#endif //_KIWIX_COMMON_H_

include/common/networkTools.h

@@ -24,25 +24,26 @@
 #include <winsock2.h>
 #include <ws2tcpip.h>
 #else
+#include <net/if.h>
+#include <netdb.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <unistd.h>
 #include <sys/ioctl.h>
 #include <sys/socket.h>
 #include <sys/types.h>
-#include <net/if.h>
-#include <netdb.h>
+#include <unistd.h>
 #endif
 
 #include <iostream>
-#include <vector>
-#include <string>
 #include <map>
+#include <string>
+#include <vector>
 
-namespace kiwix {
-  std::map<std::string, std::string> getNetworkInterfaces();
-  std::string getBestPublicIp();
+namespace kiwix
+{
+std::map<std::string, std::string> getNetworkInterfaces();
+std::string getBestPublicIp();
 }
 
 #endif

include/common/otherTools.h

@@ -26,8 +26,9 @@
 #include <unistd.h>
 #endif
 
-namespace kiwix {
-  void sleep(unsigned int milliseconds);
+namespace kiwix
+{
+void sleep(unsigned int milliseconds);
 }
 
 #endif

include/common/pathTools.h

@@ -20,18 +20,18 @@
 #ifndef KIWIX_PATHTOOLS_H
 #define KIWIX_PATHTOOLS_H
 
+#include <fcntl.h>
+#include <limits.h>
+#include <stdio.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <fstream>
+#include <ios>
+#include <iostream>
+#include <sstream>
 #include <string>
 #include <vector>
-#include <sstream>
-#include <iostream>
-#include <fstream>
-#include <string.h>
-#include <stdio.h>
-#include <sys/types.h>
-#include <fcntl.h>
-#include <sys/stat.h>
-#include <ios>
-#include <limits.h>
 
 #ifdef _WIN32
 #include <direct.h>
@@ -41,20 +41,23 @@
 
 using namespace std;
 
-bool isRelativePath(const string &path);
+bool isRelativePath(const string& path);
 string computeAbsolutePath(const string path, const string relativePath);
 string computeRelativePath(const string path, const string absolutePath);
-string removeLastPathElement(const string path, const bool removePreSeparator = false, 
-			     const bool removePostSeparator = false);
-string appendToDirectory(const string &directoryPath, const string &filename);
+string removeLastPathElement(const string path,
+                             const bool removePreSeparator = false,
+                             const bool removePostSeparator = false);
+string appendToDirectory(const string& directoryPath, const string& filename);
 
-unsigned int getFileSize(const string &path);
-string getFileSizeAsString(const string &path);
-bool fileExists(const string &path);
-bool makeDirectory(const string &path);
-bool copyFile(const string &sourcePath, const string &destPath);
-string getLastPathElement(const string &path);
+unsigned int getFileSize(const string& path);
+string getFileSizeAsString(const string& path);
+string getFileContent(const string& path);
+bool fileExists(const string& path);
+bool makeDirectory(const string& path);
+string makeTmpDirectory();
+bool copyFile(const string& sourcePath, const string& destPath);
+string getLastPathElement(const string& path);
 string getExecutablePath();
 string getCurrentDirectory();
-bool writeTextFile(const string &path, const string &content);
+bool writeTextFile(const string& path, const string& content);
 #endif

include/common/regexTools.h

@@ -22,11 +22,15 @@
 
 #include <unicode/regex.h>
 #include <unicode/ucnv.h>
-#include <string>
 #include <map>
+#include <string>
 
-bool matchRegex(const std::string &content, const std::string &regex);
-std::string replaceRegex(const std::string &content, const std::string &replacement, const std::string &regex);
-std::string appendToFirstOccurence(const std::string &content, const std::string regex, const std::string &replacement);
+bool matchRegex(const std::string& content, const std::string& regex);
+std::string replaceRegex(const std::string& content,
+                         const std::string& replacement,
+                         const std::string& regex);
+std::string appendToFirstOccurence(const std::string& content,
+                                   const std::string regex,
+                                   const std::string& replacement);
 
 #endif

include/common/stringTools.h

@@ -22,44 +22,48 @@
 
 #include <unicode/unistr.h>
 
-#include <iostream>
-#include <vector>
-#include <string>
 #include <fstream>
+#include <iomanip>
+#include <iostream>
 #include <sstream>
+#include <string>
+#include <vector>
 
 #include "pathTools.h"
 
-namespace kiwix {
-
+namespace kiwix
+{
 #ifndef __ANDROID__
 
-  std::string beautifyInteger(const unsigned int number);
-  std::string beautifyFileSize(const unsigned int number);
-  std::string urlEncode(const std::string &c);
-  void printStringInHexadecimal(const char *s);
-  void printStringInHexadecimal(UnicodeString s);
-  void stringReplacement(std::string& str, const std::string& oldStr, const std::string& newStr);
-  std::string encodeDiples(const std::string& str);
+std::string beautifyInteger(const unsigned int number);
+std::string beautifyFileSize(const unsigned int number);
+void printStringInHexadecimal(const char* s);
+void printStringInHexadecimal(UnicodeString s);
+void stringReplacement(std::string& str,
+                       const std::string& oldStr,
+                       const std::string& newStr);
+std::string encodeDiples(const std::string& str);
 
 #endif
 
-  std::string removeAccents(const std::string &text);
-  void loadICUExternalTables();
-  std::string urlDecode(const std::string &c);
+std::string removeAccents(const std::string& text);
+void loadICUExternalTables();
 
-  std::vector<std::string> split(const std::string&, const std::string&);
-  std::vector<std::string> split(const char*, const char*);
-  std::vector<std::string> split(const std::string&, const char*);
-  std::vector<std::string> split(const char*, const std::string&);
+std::string urlEncode(const std::string& value, bool encodeReserved = false);
+std::string urlDecode(const std::string& value, bool component = false);
 
-  std::string ucAll(const std::string &word);
-  std::string lcAll(const std::string &word);
-  std::string ucFirst(const std::string &word);
-  std::string lcFirst(const std::string &word);
-  std::string toTitle(const std::string &word);
+std::vector<std::string> split(const std::string&, const std::string&);
+std::vector<std::string> split(const char*, const char*);
+std::vector<std::string> split(const std::string&, const char*);
+std::vector<std::string> split(const char*, const std::string&);
 
-  std::string normalize(const std::string &word);
+std::string ucAll(const std::string& word);
+std::string lcAll(const std::string& word);
+std::string ucFirst(const std::string& word);
+std::string lcFirst(const std::string& word);
+std::string toTitle(const std::string& word);
+
+std::string normalize(const std::string& word);
 }
 
 #endif

include/downloader.h

@@ -0,0 +1,70 @@
+/*
+ * Copyright 2018 Matthieu Gautier <mgautier@kymeria.fr>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU  General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * any later version.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ */
+
+#ifndef KIWIX_DOWNLOADER_H
+#define KIWIX_DOWNLOADER_H
+
+#include <string>
+#include <aria2/aria2.h>
+#include <pthread.h>
+
+namespace kiwix
+{
+
+
+struct DownloadedFile {
+  DownloadedFile()
+   : success(false) {}
+  bool success;
+  std::string path;
+};
+
+/**
+ * A tool to download things.
+ *
+ */
+class Downloader
+{
+ public:
+  Downloader();
+  ~Downloader();
+
+  /**
+   * Download a content.
+   *
+   * @param url the url to download
+   * @return the content downloaded.
+   */
+  DownloadedFile download(const std::string& url);
+
+ private:
+  static pthread_mutex_t globalLock;
+
+  aria2::Session* session;
+  DownloadedFile* fileHandle;
+  std::string tmpDir;
+
+  static int downloadEventCallback(aria2::Session* session,
+                                   aria2::DownloadEvent event,
+                                   aria2::A2Gid gid,
+                                   void* userData);
+};
+}
+
+#endif

include/entry.h

@@ -0,0 +1,191 @@
+/*
+ * Copyright 2018 Matthieu Gautier <mgautier@kymeria.fr>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU  General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * any later version.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ */
+
+#ifndef KIWIX_ENTRY_H
+#define KIWIX_ENTRY_H
+
+#include <stdio.h>
+#include <zim/article.h>
+#include <exception>
+#include <string>
+#include "common.h"
+
+using namespace std;
+
+namespace kiwix
+{
+
+
+class NoEntry : public std::exception {};
+
+/**
+ * A entry represent an.. entry in a zim file.
+ */
+class Entry
+{
+  public:
+    /**
+     * Default constructor.
+     *
+     * Construct an invalid entry.
+     */
+    Entry() = default;
+
+    /**
+     * Construct an entry making reference to an zim article.
+     *
+     * @param article a zim::Article object
+     */
+    Entry(zim::Article article);
+    virtual ~Entry() = default;
+
+    /**
+     * Get the path of the entry.
+     *
+     * The path is the "key" of an entry.
+     *
+     * @return the path of the entry.
+     */
+    std::string getPath() const;
+    
+    /**
+     * Get the title of the entry.
+     *
+     * @return the title of the entry.
+     */
+    std::string getTitle() const;
+        
+    /**
+     * Get the content of the entry.
+     *
+     * The string is a copy of the content.
+     * If you don't want to do a copy, use get_blob.
+     *
+     * @return the content of the entry.
+     */
+    std::string getContent() const;
+        
+    /**
+     * Get the blob of the entry.
+     *
+     * A blob make reference to the content without copying it.
+     *
+     * @param offset The starting offset of the blob.
+     * @return the blob of the entry.
+     */
+    zim::Blob   getBlob(offset_type offset = 0) const;
+        
+    /**
+     * Get the blob of the entry.
+     *
+     * A blob make reference to the content without copying it.
+     *
+     * @param offset The starting offset of the blob.
+     * @param size The size of the blob.
+     * @return the blob of the entry.
+     */
+    zim::Blob   getBlob(offset_type offset, size_type size) const;
+        
+    /**
+     * Get the info for direct access to the content of the entry.
+     *
+     * Some entry (ie binary ones) have their content plain stored
+     * in the zim file. Knowing the offset where the content is stored
+     * an user can directly read the content in the zim file bypassing the
+     * kiwix-lib/libzim.
+     *
+     * @return A pair specifying where to read the content.
+     *         The string is the real file to read (may be different that .zim
+     *         file if zim is cut).
+     *         The offset is the offset to read in the file.
+     *         Return <"",0> if is not possible to read directly.
+     */
+    std::pair<std::string, offset_type> getDirectAccessInfo() const;
+        
+    /**
+     * Get the size of the entry.
+     *
+     * @return the size of the entry.
+     */
+    size_type   getSize() const;
+
+    /**
+     * Get the mime_type of the entry.
+     *
+     * @return the mime_type of the entry.
+     */
+    std::string getMimetype() const;
+    
+    
+    /**
+     * Get if the entry is a redirect entry.
+     *
+     * @return True if the entry is a redirect.
+     */
+    bool isRedirect() const;
+
+    /**
+     * Get if the entry is a link target entry.
+     *
+     * @return True if the entry is a link target.
+     */
+    bool isLinkTarget() const;
+
+    /**
+     * Get if the entry is a deleted entry.
+     *
+     * @return True if the entry is a deleted entry.
+     */
+    bool isDeleted() const;
+
+    /**
+     * Get the entry pointed by this entry.
+     *
+     * @return the entry pointed.
+     * @throw NoEntry if the entry is not a redirected entry.
+     */
+    Entry getRedirectEntry() const;
+
+    /**
+     * Get the final entry pointed by this entry.
+     *
+     * Follow the redirection until a "not redirecting" entry is found.
+     * If the entry is not a redirected entry, return the entry itself.
+     *
+     * @return the final entry.
+     */
+    Entry getFinalEntry() const;
+
+    /**
+     * Convert the entry to a boolean value.
+     *
+     * @return True if the entry is valid.
+     */
+    explicit operator bool() const { return good(); }
+
+  private:
+    zim::Article article;
+    mutable zim::Article final_article;
+
+    bool good() const { return article.good(); }
+};
+
+}
+
+#endif // KIWIX_ENTRY_H

include/kiwix.h

@@ -22,5 +22,4 @@
 
 #include "library.h"
 
-
 #endif

include/library.h

@@ -22,86 +22,109 @@
 
 #include <stdio.h>
 #include <stdlib.h>
-#include <string>
 #include <string.h>
-#include <vector>
 #include <stack>
+#include <string>
+#include <vector>
 
-#include "common/stringTools.h"
 #include "common/regexTools.h"
+#include "common/stringTools.h"
 
 #define KIWIX_LIBRARY_VERSION "20110515"
 
 using namespace std;
 
-namespace kiwix {
+namespace kiwix
+{
+enum supportedIndexType { UNKNOWN, XAPIAN };
 
-  enum supportedIndexType { UNKNOWN, XAPIAN };
 
-  class Book {
+/**
+ * A class to store information about a book (a zim file)
+ */
+class Book
+{
+ public:
+  Book();
+  ~Book();
 
-  public:
-    Book();
-    ~Book();
+  static bool sortByLastOpen(const Book& a, const Book& b);
+  static bool sortByTitle(const Book& a, const Book& b);
+  static bool sortBySize(const Book& a, const Book& b);
+  static bool sortByDate(const Book& a, const Book& b);
+  static bool sortByCreator(const Book& a, const Book& b);
+  static bool sortByPublisher(const Book& a, const Book& b);
+  static bool sortByLanguage(const Book& a, const Book& b);
+  string getHumanReadableIdFromPath();
 
-    static bool sortByLastOpen(const Book &a, const Book &b);
-    static bool sortByTitle(const Book &a, const Book &b);
-    static bool sortBySize(const Book &a, const Book &b);
-    static bool sortByDate(const Book &a, const Book &b);
-    static bool sortByCreator(const Book &a, const Book &b);
-    static bool sortByPublisher(const Book &a, const Book &b);
-    static bool sortByLanguage(const Book &a, const Book &b);
-    string getHumanReadableIdFromPath();
+  string id;
+  string path;
+  string pathAbsolute;
+  string last;
+  string indexPath;
+  string indexPathAbsolute;
+  supportedIndexType indexType;
+  string title;
+  string description;
+  string language;
+  string creator;
+  string publisher;
+  string date;
+  string url;
+  string name;
+  string tags;
+  string origId;
+  string articleCount;
+  string mediaCount;
+  bool readOnly;
+  string size;
+  string favicon;
+  string faviconMimeType;
+};
 
-    string id;
-    string path;
-    string pathAbsolute;
-    string last;
-    string indexPath;
-    string indexPathAbsolute;
-    supportedIndexType indexType;
-    string title;
-    string description;
-    string language;
-    string creator;
-    string publisher;
-    string date;
-    string url;
-    string name;
-    string tags;
-    string origId;
-    string articleCount;
-    string mediaCount;
-    bool readOnly;
-    string size;
-    string favicon;
-    string faviconMimeType;
-  };
+/**
+ * A Library store several books.
+ */
+class Library
+{
+ public:
+  Library();
+  ~Library();
 
-  class Library {
+  string version;
+  /**
+   * Add a book to the library.
+   *
+   * If a book already exist in the library with the same id, update
+   * the existing book instead of adding a new one.
+   *
+   * @param book The book to add.
+   * @return True if the book has been added.
+   *         False if a book has been updated.
+   */
+  bool addBook(const Book& book);
 
-  public:
-    Library();
-    ~Library();
-
-    string version;
-    bool addBook(const Book &book);
-    bool removeBookByIndex(const unsigned int bookIndex);
-    vector <kiwix::Book> books;
-
-    /*
-     * 'current' is the variable storing the current content/book id
-     * in the library. This is used to be able to load per default a
-     * content. As Kiwix may work with many library XML files, you may
-     * have "current" defined many time with different values. The
-     * last XML file read has the priority, Although we do not have an
-     * library object for each file, we want to be able to fallback to
-     * an 'old' current book if the one which should be load
-     * failed. That is the reason why we need a stack here
-     */
-    stack<string> current;
-  };
+  /**
+   * Remove a book from the library.
+   *
+   * @param bookIndex the index of the book to remove.
+   * @return True
+   */
+  bool removeBookByIndex(const unsigned int bookIndex);
+  vector<kiwix::Book> books;
 
+  /*
+   * 'current' is the variable storing the current content/book id
+   * in the library. This is used to be able to load per default a
+   * content. As Kiwix may work with many library XML files, you may
+   * have "current" defined many time with different values. The
+   * last XML file read has the priority, Although we do not have an
+   * library object for each file, we want to be able to fallback to
+   * an 'old' current book if the one which should be load
+   * failed. That is the reason why we need a stack here
+   */
+  stack<string> current;
+};
 }
 
 #endif

include/manager.h

@@ -20,73 +20,306 @@
 #ifndef KIWIX_MANAGER_H
 #define KIWIX_MANAGER_H
 
-#include <string>
-#include <sstream>
 #include <time.h>
+#include <sstream>
+#include <string>
 
 #include <pugixml.hpp>
 
 #include "common/base64.h"
-#include "common/regexTools.h"
 #include "common/pathTools.h"
+#include "common/regexTools.h"
 #include "library.h"
 #include "reader.h"
 
 using namespace std;
 
-namespace kiwix {
+namespace kiwix
+{
+enum supportedListMode { LASTOPEN, REMOTE, LOCAL };
+enum supportedListSortBy { TITLE, SIZE, DATE, CREATOR, PUBLISHER };
 
-  enum supportedListMode { LASTOPEN, REMOTE, LOCAL };
-  enum supportedListSortBy { TITLE, SIZE, DATE, CREATOR, PUBLISHER };
+/**
+ * A tool to manage a `Library`.
+ *
+ * A `Manager` handle a internal `Library`.
+ * This `Library` can be retrived with `cloneLibrary` method.
+ */
+class Manager
+{
+ public:
+  Manager();
+  ~Manager();
 
-  class Manager {
+  /**
+   * Read a `library.xml` and add book in the file to the library.
+   *
+   * @param path The path to the `library.xml`.
+   * @param readOnly Set if the libray path could be overwritten latter with
+   *                 updated content.
+   * @return True if file has been properly parsed.
+   */
+  bool readFile(const string path, const bool readOnly = true);
 
-  public:
-    Manager();
-    ~Manager();
+  /**
+   * Read a `library.xml` and add book in the file to the library.
+   *
+   * @param nativePath The path of the `library.xml`
+   * @param UTF8Path The utf8 version (?) of the path. Also the path where the
+   *                 library will be writen i readOnly is False.
+   * @param readOnly Set if the libray path could be overwritten latter with
+   *                 updated content.
+   * @return True if file has been properly parsed.
+   */
+  bool readFile(const string nativePath,
+                const string UTF8Path,
+                const bool readOnly = true);
 
-    bool readFile(const string path, const bool readOnly = true);
-    bool readFile(const string nativePath, const string UTF8Path, const bool readOnly = true);
-    bool readXml(const string xml, const bool readOnly = true, const string libraryPath = "");
-    bool writeFile(const string path);
-    bool removeBookByIndex(const unsigned int bookIndex);
-    bool removeBookById(const string id);
-    bool setCurrentBookId(const string id);
-    string getCurrentBookId();
-    bool setBookIndex(const string id, const string path, const supportedIndexType type);
-    bool setBookIndex(const string id, const string path);
-    bool setBookPath(const string id, const string path);
-    string addBookFromPathAndGetId(const string pathToOpen, const string pathToSave = "", const string url = "",
-				   const bool checkMetaData = false);
-    bool addBookFromPath(const string pathToOpen, const string pathToSave = "", const string url = "",
-			 const bool checkMetaData = false);
-    Library cloneLibrary();
-    bool getBookById(const string id, Book &book);
-    bool getCurrentBook(Book &book);
-    unsigned int getBookCount(const bool localBooks, const bool remoteBooks);
-    bool updateBookLastOpenDateById(const string id);
-    void removeBookPaths();
-    bool listBooks(const supportedListMode mode, const supportedListSortBy sortBy, const unsigned int maxSize,
-		   const string language, const string creator, const string publisher, const string search);
-    vector<string> getBooksLanguages();
-    vector<string> getBooksCreators();
-    vector<string> getBooksPublishers();
-    vector<string> getBooksIds();
+  /**
+   * Load a library content store in the string.
+   *
+   * @param xml The content corresponding of the library xml
+   * @param readOnly Set if the libray path could be overwritten latter with
+   *                 updated content.
+   * @param libraryPath The library path (used to resolve relative path)
+   * @return True if the content has been properly parsed.
+   */
+  bool readXml(const string& xml,
+               const bool readOnly = true,
+               const string libraryPath = "");
 
-    string writableLibraryPath;
+  /**
+   * Load a library content stored in a OPDS stream.
+   *
+   * @param content The content of the OPDS stream.
+   * @param readOnly Set if the library path could be overwritten later with
+   *                 updated content.
+   * @param libraryPath The library path (used to resolve relative path)
+   * @return True if the content has been properly parsed.
+   */
+  bool readOpds(const string& content, const std::string& urlHost);
 
-    vector<std::string> bookIdList;
+  /**
+   * Write the library to a file.
+   *
+   * @param path the path of the file to write.
+   * @return True.
+   */
+  bool writeFile(const string path);
 
-  protected:
-    kiwix::Library library;
 
-    bool readBookFromPath(const string path, Book *book = NULL);
-    bool parseXmlDom(const pugi::xml_document &doc, const bool readOnly, const string libraryPath);
+  /**
+   * Remove a book from the library.
+   *
+   * @param bookIndex the index of the book to remove
+   * @return True
+   */
+  bool removeBookByIndex(const unsigned int bookIndex);
 
-  private:
-    void checkAndCleanBookPaths(Book &book, const string &libraryPath);
-  };
+  /**
+   * Remove a book from the library.
+   *
+   * @param id the id of the book to remove.
+   * @return True if the book were in the library.
+   */
+  bool removeBookById(const string id);
 
+  /**
+   * Set the current book.
+   *
+   * @param id The id to add to the stack of current books.
+   *           If id is empty, remove the current book from the stack.
+   * @return True
+   */
+  bool setCurrentBookId(const string id);
+
+  /**
+   * Get the current book id.
+   *
+   * @return The id of the current book (or empty string if no current book).
+   */
+  string getCurrentBookId() const;
+
+  /**
+   * Set the path of the external fulltext index associated to a book.
+   *
+   * @param id The id of the book to set.
+   * @param path The path of the external fullext index.
+   * @param supportedIndexType The type of the fulltext index.
+   * @return True if the book is in the library.
+   */
+  bool setBookIndex(const string id,
+                    const string path,
+                    const supportedIndexType type = XAPIAN);
+
+  /**
+   * Set the path of the zim file associated to a book.
+   *
+   * @param id The id of the book to set.
+   * @param path The path of the zim file.
+   * @return True if the book is in the library.
+   */
+  bool setBookPath(const string id, const string path);
+
+  /**
+   * Add a book to the library.
+   *
+   * @param pathToOpen The path to the zim file to add.
+   * @param pathToSave The path to store in the library in place of pathToOpen.
+   * @param url        The url of the book to store in the library.
+   * @param checMetaData Tell if we check metadata before adding book to the
+   *                     library.
+   * @return The id of the book if the book has been added to the library.
+   *         Else, an empty string.
+   */
+  string addBookFromPathAndGetId(const string pathToOpen,
+                                 const string pathToSave = "",
+                                 const string url = "",
+                                 const bool checkMetaData = false);
+
+  /**
+   * Add a book to the library.
+   *
+   * @param pathToOpen The path to the zim file to add.
+   * @param pathToSave The path to store in the library in place of pathToOpen.
+   * @param url        The url of the book to store in the library.
+   * @param checMetaData Tell if we check metadata before adding book to the
+   *                     library.
+   * @return True if the book has been added to the library.
+   */
+
+  bool addBookFromPath(const string pathToOpen,
+                       const string pathToSave = "",
+                       const string url = "",
+                       const bool checkMetaData = false);
+
+  /**
+   * Clone and return the internal library.
+   *
+   * @return A clone of the library.
+   */
+  Library cloneLibrary();
+
+  /**
+   * Get the book corresponding to an id.
+   *
+   * @param[in] id The id of the book
+   * @param[out] book The book corresponding to the id.
+   * @return True if the book has been found.
+   */
+  bool getBookById(const string id, Book& book);
+
+  /**
+   * Get the current book.
+   *
+   * @param[out] The current book.
+   * @return True if there is a current book.
+   */
+  bool getCurrentBook(Book& book);
+
+  /**
+   * Get the number of book in the library.
+   *
+   * @param localBooks If we must count local books (books with a path).
+   * @param remoteBooks If we must count remote books (books with an url)
+   * @return The number of books.
+   */
+  unsigned int getBookCount(const bool localBooks, const bool remoteBooks);
+
+  /**
+   * Update the "last open date" of a book
+   *
+   * @param id the id of the book.
+   * @return True if the book is in the library.
+   */
+  bool updateBookLastOpenDateById(const string id);
+
+  /**
+   * Remove (set to empty) paths of all books in the library.
+   */
+  void removeBookPaths();
+
+  /**
+   * List books in the library.
+   *
+   * The books list will be available in public vector member `bookIdList`.
+   *
+   * @param mode The mode of listing :
+   *             - LASTOPEN sort by last opened book.
+   *             - LOCAL list only local file.
+   *             - REMOTE list only remote file.
+   * @param sortBy Attribute to sort by the book list.
+   * @param maxSize Do not list book bigger than maxSize MiB.
+   *                Set to 0 to cancel this filter.
+   * @param language List only books in this language.
+   * @param creator List only books of this creator.
+   * @param publisher List only books of this publisher.
+   * @param search List only books with search in the title, description or
+   *               language.
+   * @return True
+   */
+  bool listBooks(const supportedListMode mode,
+                 const supportedListSortBy sortBy,
+                 const unsigned int maxSize,
+                 const string language,
+                 const string creator,
+                 const string publisher,
+                 const string search);
+
+  /**
+   * Filter the library and generate a new one with the keep elements.
+   *
+   * @param search List only books with search in the title or description.
+   * @return A `Library`.
+   */
+  Library filter(const string& search);
+
+
+  /**
+   * Get all langagues of the books in the library.
+   *
+   * @return A list of languages.
+   */
+  vector<string> getBooksLanguages();
+
+  /**
+   * Get all book creators of the books in the library.
+   *
+   * @return A list of book creators.
+   */
+  vector<string> getBooksCreators();
+
+  /**
+   * Get all book publishers of the books in the library.
+   *
+   * @return A list of book publishers.
+   */
+  vector<string> getBooksPublishers();
+
+  /**
+   * Get all book ids of the books in the library.
+   *
+   * @return A list of book ids.
+   */
+  vector<string> getBooksIds();
+
+  string writableLibraryPath;
+
+  vector<std::string> bookIdList;
+
+ protected:
+  kiwix::Library library;
+
+  bool readBookFromPath(const string path, Book* book = NULL);
+  bool parseXmlDom(const pugi::xml_document& doc,
+                   const bool readOnly,
+                   const string libraryPath);
+  bool parseOpdsDom(const pugi::xml_document& doc,
+                    const std::string& urlHost);
+
+ private:
+  void checkAndCleanBookPaths(Book& book, const string& libraryPath);
+};
 }
 
 #endif

include/meson.build

@@ -1,7 +1,11 @@
 headers = [
+  'common.h',
   'library.h',
   'manager.h',
+  'opds_dumper.h',
+  'downloader.h',
   'reader.h',
+  'entry.h',
   'searcher.h'
 ]
 
@@ -18,7 +22,6 @@ install_headers(
   'common/pathTools.h',
   'common/regexTools.h',
   'common/stringTools.h',
-  'common/tree.h',
   subdir:'kiwix/common'
 )
 

include/opds_dumper.h

@@ -0,0 +1,107 @@
+/*
+ * Copyright 2017 Matthieu Gautier <mgautier@kymeria.fr>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU  General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * any later version.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ */
+
+#ifndef KIWIX_OPDS_DUMPER_H
+#define KIWIX_OPDS_DUMPER_H
+
+#include <time.h>
+#include <sstream>
+#include <string>
+
+#include <pugixml.hpp>
+
+#include "common/base64.h"
+#include "common/pathTools.h"
+#include "common/regexTools.h"
+#include "library.h"
+#include "reader.h"
+
+using namespace std;
+
+namespace kiwix
+{
+
+/**
+ * A tool to dump a `Library` into a opds stream.
+ *
+ */
+class OPDSDumper
+{
+ public:
+  OPDSDumper() = default;
+  OPDSDumper(Library library);
+  ~OPDSDumper();
+
+  /**
+   * Dump the OPDS feed.
+   *
+   * @param id The id of the library.
+   * @return The OPDS feed.
+   */
+  std::string dumpOPDSFeed();
+
+  /**
+   * Set the id of the opds stream.
+   *
+   * @param id the id to use.
+   */
+  void setId(const std::string& id) { this->id = id;}
+
+  /**
+   * Set the title oft the opds stream.
+   *
+   * @param title the title to use.
+   */
+  void setTitle(const std::string& title) { this->title = title; }
+
+  /**
+   * Set the root location used when generating url.
+   *
+   * @param rootLocation the root location to use.
+   */
+  void setRootLocation(const std::string& rootLocation) { this->rootLocation = rootLocation; }
+
+  /**
+   * Set the search url.
+   *
+   * @param searchUrl the search url to use.
+   */
+  void setSearchDescriptionUrl(const std::string& searchDescriptionUrl) { this->searchDescriptionUrl = searchDescriptionUrl; }
+
+  /**
+   * Set the library to dump.
+   *
+   * @param library The library to dump.
+   */
+  void setLibrary(Library library) { this->library = library; }
+
+ protected:
+  kiwix::Library library;
+  std::string id;
+  std::string title;
+  std::string date;
+  std::string rootLocation;
+  std::string searchDescriptionUrl;
+
+ private:
+  pugi::xml_node handleBook(Book book, pugi::xml_node root_node);
+};
+}
+
+#endif // KIWIX_OPDS_DUMPER_H

include/reader.h

@@ -20,85 +20,486 @@
 #ifndef KIWIX_READER_H
 #define KIWIX_READER_H
 
-#include <zim/zim.h>
-#include <zim/file.h>
-#include <zim/article.h>
-#include <zim/fileiterator.h>
 #include <stdio.h>
-#include <string>
+#include <zim/article.h>
+#include <zim/file.h>
+#include <zim/fileiterator.h>
+#include <zim/zim.h>
 #include <exception>
-#include <sstream>
 #include <map>
+#include <sstream>
+#include <string>
+#include "common.h"
+#include "entry.h"
 #include "common/pathTools.h"
 #include "common/stringTools.h"
 
 using namespace std;
 
-namespace kiwix {
+namespace kiwix
+{
 
-  class Reader {
+/**
+ * The Reader class is the class who allow to get an entry content from a zim
+ * file.
+ */
+class Reader
+{
+ public:
+  /**
+   * Create a Reader to read a zim file specified by zimFilePath.
+   *
+   * @param zimFilePath The path to the zim file to read.
+   *                    The zim file can be splitted (.zimaa, .zimab, ...).
+   *                    In this case, the file path must still point to the
+   *                    unsplitted path as if the file were not splitted
+   *                    (.zim extesion).
+   */
+  Reader(const string zimFilePath);
+  ~Reader();
 
-  public:
-    Reader(const string zimFilePath);
-    ~Reader();
+  /**
+   * Get the number of "displayable" entries in the zim file.
+   *
+   * @return If the zim file has a /M/Counter metadata, return the number of
+   *         entries with the 'text/html' MIMEtype specified in the metadata.
+   *         Else return the number of entries in the 'A' namespace.
+   */
+  unsigned int getArticleCount() const;
 
-    void reset();
-    unsigned int getArticleCount() const;
-    unsigned int getMediaCount() const;
-    unsigned int getGlobalCount() const;
-    string getZimFilePath() const;
-    string getId() const;
-    string getRandomPageUrl() const;
-    string getFirstPageUrl() const;
-    string getMainPageUrl() const;
-    bool getMetatag(const string &url, string &content) const;
-    string getTitle() const;
-    string getDescription() const;
-    string getLanguage() const;
-    string getName() const;
-    string getTags() const;
-    string getDate() const;
-    string getCreator() const;
-    string getPublisher() const;
-    string getOrigId() const;
-    bool getFavicon(string &content, string &mimeType) const;
-    bool getPageUrlFromTitle(const string &title, string &url) const;
-    bool getMimeTypeByUrl(const string &url, string &mimeType) const;
-    bool getContentByUrl(const string &url, string &content, unsigned int &contentLength, string &contentType) const;
-    bool getContentByEncodedUrl(const string &url, string &content, unsigned int &contentLength, string &contentType, string &baseUrl) const;
-    bool getContentByEncodedUrl(const string &url, string &content, unsigned int &contentLength, string &contentType) const;
-    bool getContentByDecodedUrl(const string &url, string &content, unsigned int &contentLength, string &contentType, string &baseUrl) const;
-    bool getContentByDecodedUrl(const string &url, string &content, unsigned int &contentLength, string &contentType) const;
-    bool searchSuggestions(const string &prefix, unsigned int suggestionsCount, const bool reset = true);
-    bool searchSuggestionsSmart(const string &prefix, unsigned int suggestionsCount);
-    bool urlExists(const string &url) const;
-    bool hasFulltextIndex() const;
-    std::vector<std::string> getTitleVariants(const std::string &title) const;
-    bool getNextSuggestion(string &title);
-    bool getNextSuggestion(string &title, string &url);
-    bool canCheckIntegrity() const;
-    bool isCorrupted() const;
-    bool parseUrl(const string &url, char *ns, string &title) const;
-    unsigned int getFileSize() const;
-    zim::File* getZimFileHandler() const;
-    bool getArticleObjectByDecodedUrl(const string &url, zim::Article &article) const;
+  /**
+   * Get the number of media in the zim file.
+   *
+   * @return If the zim file has a /M/Counter metadata, return the number of
+   *         entries with the 'image/jpeg', 'image/gif' and 'image/png' in
+   *         the metadata.
+   *         Else return the number of entries in the 'I' namespace.
+   */
+  unsigned int getMediaCount() const;
 
-  protected:
-    zim::File* zimFileHandler;
-    zim::size_type firstArticleOffset;
-    zim::size_type lastArticleOffset;
-    zim::size_type currentArticleOffset;
-    zim::size_type nsACount;
-    zim::size_type nsICount;
-    std::string zimFilePath;
-    
-    std::vector< std::vector<std::string> > suggestions;
-    std::vector< std::vector<std::string> >::iterator suggestionsOffset;
+  /**
+   * Get the number of all entries in the zim file.
+   *
+   * @return Return the number of all the entries, whatever their MIMEtype or
+   *         their namespace.
+   */
+  unsigned int getGlobalCount() const;
 
-  private:
-    std::map<const std::string, unsigned int> parseCounterMetadata() const;
-  };
+  /**
+   * Get the path of the zim file.
+   *
+   * @return the path of the zim file as given in the constructor.
+   */
+  string getZimFilePath() const;
 
+  /**
+   * Get the Id of the zim file.
+   *
+   * @return The uuid stored in the zim file.
+   */
+  string getId() const;
+
+  /**
+   * Get the url of a random page.
+   *
+   * Deprecated : Use `getRandomPage` instead.
+   *
+   * @return Url of a random page. The page is picked from all entries in
+   *         the 'A' namespace.
+   *         The main page is excluded from the potential results.
+   */
+  DEPRECATED string getRandomPageUrl() const;
+
+  /**
+   * Get a random page.
+   *
+   * @return A random Entry. The entry is picked from all entries in
+   *         the 'A' namespace.
+   *         The main entry is excluded from the potential results.
+   */
+  Entry getRandomPage() const;
+
+  /**
+   * Get the url of the first page.
+   *
+   * Deprecated : Use `getFirstPage` instead.
+   *
+   * @return Url of the first entry in the 'A' namespace.
+   */
+  DEPRECATED string getFirstPageUrl() const;
+
+  /**
+   * Get the entry of the first page.
+   *
+   * @return The first entry in the 'A' namespace.
+   */
+  Entry getFirstPage() const;
+
+  /**
+   * Get the url of the main page.
+   *
+   * Deprecated : Use `getMainPage` instead.
+   *
+   * @return Url of the main page as specified in the zim file.
+   */
+  DEPRECATED string getMainPageUrl() const;
+
+  /**
+   * Get the entry of the main page.
+   *
+   * @return Entry of the main page as specified in the zim file.
+   */
+  Entry getMainPage() const;
+
+  /**
+   * Get the content of a metadata.
+   *
+   * @param[in]  name The name of the metadata.
+   * @param[out] value The value will be set to the content of the metadata.
+   * @return True if it was possible to get the content of the metadata.
+   */
+  bool getMetatag(const string& name, string& value) const;
+
+  /**
+   * Get the title of the zim file.
+   *
+   * @return The title of zim file as specified in the zim metadata.
+   *         If no title has been set, return a title computed from the
+   *         file path.
+   */
+  string getTitle() const;
+
+  /**
+   * Get the description of the zim file.
+   *
+   * @return The description of the zim file as specified in the zim metadata.
+   *         If no description has been set, return the subtitle.
+   */
+  string getDescription() const;
+
+  /**
+   * Get the language of the zim file.
+   *
+   * @return The language of the zim file as specified in the zim metadata.
+   */
+  string getLanguage() const;
+
+  /**
+   * Get the name of the zim file.
+   *
+   * @return The name of the zim file as specified in the zim metadata.
+   */
+  string getName() const;
+
+  /**
+   * Get the tags of the zim file.
+   *
+   * @return The tags of the zim file as specified in the zim metadata.
+   */
+  string getTags() const;
+
+  /**
+   * Get the date of the zim file.
+   *
+   * @return The date of the zim file as specified in the zim metadata.
+   */
+  string getDate() const;
+
+  /**
+   * Get the creator of the zim file.
+   *
+   * @return The creator of the zim file as specified in the zim metadata.
+   */
+  string getCreator() const;
+
+  /**
+   * Get the publisher of the zim file.
+   *
+   * @return The publisher of the zim file as specified in the zim metadata.
+   */
+  string getPublisher() const;
+
+  /**
+   * Get the origId of the zim file.
+   *
+   * The origId is only used in the case of patch zim file and is the Id
+   * of the original zim file.
+   *
+   * @return The origId of the zim file as specified in the zim metadata.
+   */
+  string getOrigId() const;
+
+  /**
+   * Get the favicon of the zim file.
+   *
+   * @param[out] content The content of the favicon.
+   * @param[out] mimeType The mimeType of the favicon.
+   * @return True if a favicon has been found.
+   */
+  bool getFavicon(string& content, string& mimeType) const;
+
+  /**
+   * Get an entry associated to an path.
+   *
+   * @param path The path of the entry.
+   * @return The entry.
+   * @throw NoEntry If no entry correspond to the path.
+   */
+  Entry getEntryFromPath(const std::string& path) const;
+
+  /**
+   * Get an entry associated to an url encoded path.
+   *
+   * Equivalent to `getEntryFromPath(urlDecode(path));`
+   *
+   * @param path The url encoded path.
+   * @return The entry.
+   * @throw NoEntry If no entry correspond to the path.
+   */
+  Entry getEntryFromEncodedPath(const std::string& path) const;
+
+  /**
+   * Get un entry associated to a title.
+   *
+   * @param title The title.
+   * @return The entry
+   * throw NoEntry If no entry correspond to the url.
+   */
+  Entry getEntryFromTitle(const std::string& title) const;
+
+  /**
+   * Get the url of a page specified by a title.
+   *
+   * @param[in] title the title of the page.
+   * @param[out] url the url of the page.
+   * @return True if the page can be found.
+   */
+  DEPRECATED bool getPageUrlFromTitle(const string& title, string& url) const;
+
+  /**
+   * Get the mimetype of a entry specified by a url.
+   *
+   * @param[in] url the url of the entry.
+   * @param[out] mimeType the mimeType of the entry.
+   * @return True if the mimeType has been found.
+   */
+  DEPRECATED bool getMimeTypeByUrl(const string& url, string& mimeType) const;
+
+  /**
+   * Get the content of an entry specifed by a url.
+   *
+   * Alias to `getContentByEncodedUrl`
+   */
+  DEPRECATED bool getContentByUrl(const string& url,
+                       string& content,
+                       string& title,
+                       unsigned int& contentLength,
+                       string& contentType) const;
+
+  /**
+   * Get the content of an entry specified by a url encoded url.
+   *
+   * Equivalent to getContentByDecodedUrl(urlDecode(url), ...).
+   */
+  DEPRECATED bool getContentByEncodedUrl(const string& url,
+                              string& content,
+                              string& title,
+                              unsigned int& contentLength,
+                              string& contentType,
+                              string& baseUrl) const;
+
+  /**
+   * Get the content of an entry specified by an url encoded url.
+   *
+   * Equivalent to getContentByEncodedUrl but without baseUrl.
+   */
+  DEPRECATED bool getContentByEncodedUrl(const string& url,
+                              string& content,
+                              string& title,
+                              unsigned int& contentLength,
+                              string& contentType) const;
+
+  /**
+   * Get the content of an entry specified by a url.
+   *
+   * @param[in] url The url of the entry.
+   * @param[out] content The content of the entry.
+   * @param[out] title the title of the entry.
+   * @param[out] contentLength The size of the entry (size of content).
+   * @param[out] contentType The mimeType of the entry.
+   * @param[out] baseUrl Return the true url of the entry.
+   *                     If the specified entry is a redirection, contains
+   *                     the url of the targeted entry.
+   * @return True if the entry has been found.
+   */
+  DEPRECATED bool getContentByDecodedUrl(const string& url,
+                              string& content,
+                              string& title,
+                              unsigned int& contentLength,
+                              string& contentType,
+                              string& baseUrl) const;
+  /**
+   * Get the content of an entry specified by a url.
+   *
+   * Equivalent to getContentByDecodedUrl but withou the baseUrl.
+   */
+  DEPRECATED bool getContentByDecodedUrl(const string& url,
+                              string& content,
+                              string& title,
+                              unsigned int& contentLength,
+                              string& contentType) const;
+
+  /**
+   * Search for entries with title starting with prefix (case sensitive).
+   *
+   * Suggestions are stored in an internal vector and can be retrieved using
+   * `getNextSuggestion` method.
+   *
+   * @param prefix The prefix to search.
+   * @param suggestionsCount How many suggestions to search for.
+   * @param reset If true, remove previous suggestions in the internal vector.
+   *              If false, add suggestions to the internal vector
+   *              (until internal vector size is suggestionCount (or no more
+   *               suggestion))
+   * @return True if some suggestions where added to the internal vector.
+   */
+  bool searchSuggestions(const string& prefix,
+                         unsigned int suggestionsCount,
+                         const bool reset = true);
+
+  /**
+   * Search for entries for the given prefix.
+   *
+   * If the zim file has a internal fulltext index, the suggestions will be
+   * searched using it.
+   * Else the suggestions will be search using `searchSuggestions` while trying
+   * to be smart about case sensitivity (using `getTitleVariants`).
+   *
+   * In any case, suggestions are stored in an internal vector and can be
+   * retrieved using `getNextSuggestion` method.
+   * The internal vector will be reset.
+   *
+   * @param prefix The prefix to search for.
+   * @param suggestionsCount How many suggestions to search for.
+   */
+  bool searchSuggestionsSmart(const string& prefix,
+                              unsigned int suggestionsCount);
+
+  /**
+   * Check if the url exists in the zim file.
+   *
+   * Deprecated : Use `pathExists` instead.
+   *
+   * @param url the url to check.
+   * @return True if the url exits in the zim file.
+   */
+  DEPRECATED bool urlExists(const string& url) const;
+
+  /**
+   * Check if the path exists in the zim file.
+   *
+   * @param path the path to check.
+   * @return True if the path exists in the zim file.
+   */
+  bool pathExists(const string& path) const;
+
+  /**
+   * Check if the zim file has a embedded fulltext index.
+   *
+   * @return True if the zim file has a embedded fulltext index
+   *         and is not split (else the fulltext is not accessible).
+   */
+  bool hasFulltextIndex() const;
+
+  /**
+   * Get potential case title variations for a title.
+   *
+   * @param title a title.
+   * @return the list of variantions.
+   */
+  std::vector<std::string> getTitleVariants(const std::string& title) const;
+
+  /**
+   * Get the next suggestion title.
+   *
+   * @param[out] title the title of the suggestion.
+   * @return True if title has been set.
+   */
+  bool getNextSuggestion(string& title);
+
+  /**
+   * Get the next suggestion title and url.
+   *
+   * @param[out] title the title of the suggestion.
+   * @param[out] url the url of the suggestion.
+   * @return True if title and url have been set.
+   */
+  bool getNextSuggestion(string& title, string& url);
+
+  /**
+   * Get if we can check zim file integrity (has a checksum).
+   *
+   * @return True if zim file have a checksum.
+   */
+  bool canCheckIntegrity() const;
+
+  /**
+   * Check is zim file is corrupted.
+   *
+   * @return True if zim file is corrupted.
+   */
+  bool isCorrupted() const;
+
+  /**
+   * Parse a full url into a namespace and url.
+   *
+   * @param[in] url The full url ("/N/url").
+   * @param[out] ns The namespace (N).
+   * @param[out] title The url (url).
+   * @return True
+   */
+  DEPRECATED bool parseUrl(const string& url, char* ns, string& title) const;
+
+  /**
+   * Return the total size of the zim file.
+   *
+   * If zim file is split, return the sum of all parts' size.
+   *
+   * @return Size of the size file is KiB.
+   */
+  unsigned int getFileSize() const;
+
+  /**
+   * Get the zim file handler.
+   *
+   * @return The libzim file handler.
+   */
+  zim::File* getZimFileHandler() const;
+
+  /**
+   * Get the zim article object associated to a url.
+   *
+   * @param[in] url The url of the article.
+   * @param[out] article The libzim article object.
+   * @return True if the url is good (article.good()).
+   */
+  DEPRECATED bool getArticleObjectByDecodedUrl(const string& url,
+                                    zim::Article& article) const;
+
+ protected:
+  zim::File* zimFileHandler;
+  zim::size_type firstArticleOffset;
+  zim::size_type lastArticleOffset;
+  zim::size_type nsACount;
+  zim::size_type nsICount;
+  std::string zimFilePath;
+
+  std::vector<std::vector<std::string>> suggestions;
+  std::vector<std::vector<std::string>>::iterator suggestionsOffset;
+
+ private:
+  std::map<const std::string, unsigned int> parseCounterMetadata() const;
+};
 }
 
 #endif

include/searcher.h

@@ -22,72 +22,208 @@
 
 #include <stdio.h>
 #include <stdlib.h>
-#include <string>
+#include <unicode/putil.h>
 #include <algorithm>
-#include <vector>
-#include <locale>
 #include <cctype>
+#include <locale>
+#include <string>
+#include <vector>
 #include <vector>
 #include "common/pathTools.h"
 #include "common/stringTools.h"
-#include <unicode/putil.h>
 #include "kiwix_config.h"
 
 using namespace std;
 
-namespace kiwix {
-  class Reader;
-  class Result {
-    public:
-      virtual ~Result() {};
-      virtual std::string get_url() = 0;
-      virtual std::string get_title() = 0;
-      virtual int get_score() = 0;
-      virtual std::string get_snippet() = 0;
-      virtual int get_wordCount() = 0;
-      virtual int get_size() = 0;
-  };
+namespace kiwix
+{
+class Reader;
+class Result
+{
+ public:
+  virtual ~Result(){};
+  virtual std::string get_url() = 0;
+  virtual std::string get_title() = 0;
+  virtual int get_score() = 0;
+  virtual std::string get_snippet() = 0;
+  virtual std::string get_content() = 0;
+  virtual int get_wordCount() = 0;
+  virtual int get_size() = 0;
+  virtual int get_readerIndex() = 0;
+};
 
+struct SearcherInternal;
+/**
+ * The Searcher class is reponsible to do different kind of search using the
+ * fulltext index.
+ *
+ * Historically, there are two kind of fulltext index :
+ *  - The legacy one, is the external fulltext index. A directory stored outside
+ *    of the zim file.
+ *  - The new one, a embedded fulltext index in the zim file.
+ *
+ * Legacy external fulltext index has to be considered as obsolet format with
+ * less functionnalities:
+ *  - No multi zim search ;
+ *  - No geo_search ;
+ *  - No suggestions search ;
+ *
+ * To reflect this, there is two Search creation "API":
+ *  - One for the external fulltext index, using the constructor taking a
+ *    xapianDirectoryPath) ;
+ *  - One for the embedded fulltext index, using a "empty" constructor and the
+ *  `add_reader` method".
+ *
+ *  On top of that, the Searcher may (if compiled with ctpp2) be used to
+ *  generate a html page for the search result. This use a template that need a
+ *  humanReaderName. This feature is only used by kiwix-serve and this should be
+ *  move outside of Searcher (and with a better API). If you don't use the html
+ *  rendering (getHtml method), you better should simply ignore the different
+ *  humanReadeableName attributes (or give an empty string).
+ */
+class Searcher
+{
+ public:
+  /**
+   * The default constructor.
+   *
+   * @param humanReadableName The global zim's humanReadableName.
+   *                          Used to generate pagination links.
+   */
+  Searcher(const string& humanReadableName = "");
 
-  struct SearcherInternal;
-  class Searcher {
+  /**
+   * The constructor for legacy external fulltext index.
+   *
+   * @param xapianDirectoryPath The path to the external index directory.
+   * @param reader The reader associated to the external index.
+   *               It will be used retrive the article content or generate
+   *               the snippet.
+   * @param humanReadableName The humanReadableName for the zim.
+   */
+  Searcher(const string& xapianDirectoryPath,
+           Reader* reader,
+           const string& humanReadableName);
+  ~Searcher();
 
-  public:
-    Searcher(const string &xapianDirectoryPath, Reader* reader);
-    ~Searcher();
+  /**
+   * Add a reader (containing embedded fulltext index) to the search.
+   *
+   * @param reader The Reader for the zim containing the fulltext index.
+   * @param humanReaderName The human readable name of the reader.
+   * @return true if the reader has been added.
+   *         false if the reader cannot be added (no embedded fulltext index present)
+   */
+  bool add_reader(Reader* reader, const std::string& humanReaderName);
 
-    void search(std::string &search, unsigned int resultStart,
-		unsigned int resultEnd, const bool verbose=false);
-    Result* getNextResult();
-    void restart_search();
-    unsigned int getEstimatedResultCount();
-    bool setProtocolPrefix(const std::string prefix);
-    bool setSearchProtocolPrefix(const std::string prefix);
-    void reset();
-    void setContentHumanReadableId(const string &contentHumanReadableId);
+  /**
+   * Start a search on the zim associated to the Searcher.
+   *
+   * Search results should be retrived using the getNextResult method.
+   *
+   * @param search The search query.
+   * @param resultStart the start offset of the search results (used for pagination).
+   * @param resultEnd the end offset of the search results (used for pagination).
+   * @param verbose print some info on stdout if true.
+   */
+  void search(std::string& search,
+              unsigned int resultStart,
+              unsigned int resultEnd,
+              const bool verbose = false);
+
+  /**
+   * Start a geographique search.
+   * The search return result for entry in a disc of center latitude/longitude
+   * and radius distance.
+   *
+   * Search results should be retrived using the getNextResult method.
+   *
+   * @param latitude The latitude of the center point.
+   * @param longitude The longitude of the center point.
+   * @param distance The radius of the disc.
+   * @param resultStart the start offset of the search results (used for pagination).
+   * @param resultEnd the end offset of the search results (used for pagination).
+   * @param verbose print some info on stdout if true.
+   */
+  void geo_search(float latitude, float longitude, float distance,
+                  unsigned int resultStart,
+                  unsigned int resultEnd,
+                  const bool verbose = false);
+
+  /**
+   * Start a suggestion search.
+   * The search made depend of the "version" of the embedded index.
+   *  - If the index is newer enough and have a title namespace, the search is
+   *    made in the titles only.
+   *  - Else the search is made on the whole article content.
+   * In any case, the search is made "partial" (as adding '*' at the end of the query)
+   *
+   * @param search The search query.
+   * @param verbose print some info on stdout if true.
+   */
+  void suggestions(std::string& search, const bool verbose = false);
+
+  /**
+   * Get the next result of a started search.
+   * This is the method to use to loop hover the search results.
+   */
+  Result* getNextResult();
+
+  /**
+   * Restart the previous search.
+   * Next call to getNextResult will return the first result.
+   */
+  void restart_search();
+
+  /**
+   * Get a estimation of the result count.
+   */
+  unsigned int getEstimatedResultCount();
+
+  /**
+   * Set protocol prefix.
+   * Only used by getHtml.
+   */
+  bool setProtocolPrefix(const std::string prefix);
+
+  /**
+   * Set search protocol prefix.
+   * Only used by getHtml.
+   */
+  bool setSearchProtocolPrefix(const std::string prefix);
 
 #ifdef ENABLE_CTPP2
-    string getHtml();
+  /**
+   * Generate the html page with the resutls of the search.
+   */
+  string getHtml();
 #endif
-    
-  protected:
-    std::string beautifyInteger(const unsigned int number);
-    void closeIndex() ;
-    void searchInIndex(string &search, const unsigned int resultStart,
-	               const unsigned int resultEnd, const bool verbose=false);
 
-    Reader* reader;
-    SearcherInternal* internal;
-    std::string searchPattern;
-    std::string protocolPrefix;
-    std::string searchProtocolPrefix;
-    std::string template_ct2;
-    unsigned int resultCountPerPage;
-    unsigned int estimatedResultCount;
-    unsigned int resultStart;
-    unsigned int resultEnd;
-    std::string contentHumanReadableId;
-  };
+ protected:
+  std::string beautifyInteger(const unsigned int number);
+  void closeIndex();
+  void searchInIndex(string& search,
+                     const unsigned int resultStart,
+                     const unsigned int resultEnd,
+                     const bool verbose = false);
+
+  std::vector<Reader*> readers;
+  std::vector<std::string> humanReaderNames;
+  SearcherInternal* internal;
+  std::string searchPattern;
+  std::string protocolPrefix;
+  std::string searchProtocolPrefix;
+  unsigned int resultCountPerPage;
+  unsigned int estimatedResultCount;
+  unsigned int resultStart;
+  unsigned int resultEnd;
+  std::string contentHumanReadableId;
+
+ private:
+  void reset();
+
+};
+
 
 }
 

include/xapianSearcher.h

@@ -21,70 +21,78 @@
 #define KIWIX_XAPIAN_SEARCHER_H
 
 #include <xapian.h>
-#include "searcher.h"
 #include "reader.h"
+#include "searcher.h"
 
 #include <map>
 #include <string>
 
 using namespace std;
 
-namespace kiwix {
+namespace kiwix
+{
+class XapianSearcher;
 
-  class XapianSearcher;
+class XapianResult : public Result
+{
+ public:
+  XapianResult(XapianSearcher* searcher, Xapian::MSetIterator& iterator);
+  virtual ~XapianResult(){};
 
-  class XapianResult : public Result {
-    public:
-      XapianResult(XapianSearcher* searcher, Xapian::MSetIterator& iterator);
-      virtual ~XapianResult() {};
+  virtual std::string get_url();
+  virtual std::string get_title();
+  virtual int get_score();
+  virtual std::string get_snippet();
+  virtual std::string get_content();
+  virtual int get_wordCount();
+  virtual int get_size();
+  virtual int get_readerIndex() { return 0; };
 
-      virtual std::string get_url();
-      virtual std::string get_title();
-      virtual int get_score();
-      virtual std::string get_snippet();
-      virtual int get_wordCount();
-      virtual int get_size();
+ private:
+  XapianSearcher* searcher;
+  Xapian::MSetIterator iterator;
+  Xapian::Document document;
+};
 
-    private:
-      XapianSearcher* searcher;
-      Xapian::MSetIterator iterator;
-      Xapian::Document document;
-  };
+class NoXapianIndexInZim : public exception
+{
+  virtual const char* what() const throw()
+  {
+    return "There is no fulltext index in the zim file";
+  }
+};
 
-  class NoXapianIndexInZim: public exception {
-    virtual const char* what() const throw() {
-      return "There is no fulltext index in the zim file";
-    }
-  };
+class XapianSearcher
+{
+  friend class XapianResult;
 
-  class XapianSearcher {
-    friend class XapianResult;
-  public:
-    XapianSearcher(const string &xapianDirectoryPath, Reader* reader);
-    virtual ~XapianSearcher() {};
-    void searchInIndex(string &search, const unsigned int resultStart, const unsigned int resultEnd, 
-		       const bool verbose=false);
-    virtual Result* getNextResult();
-    void restart_search();
+ public:
+  XapianSearcher(const string& xapianDirectoryPath, Reader* reader);
+  virtual ~XapianSearcher(){};
+  void searchInIndex(string& search,
+                     const unsigned int resultStart,
+                     const unsigned int resultEnd,
+                     const bool verbose = false);
+  virtual Result* getNextResult();
+  void restart_search();
 
-    Xapian::MSet results;
+  Xapian::MSet results;
 
-  protected:
-    void closeIndex();
-    void openIndex(const string &xapianDirectoryPath);
-    void setup_queryParser();
-
-    Reader* reader;
-    Xapian::Database readableDatabase;
-    std::string language;
-    std::string stopwords;
-    Xapian::QueryParser queryParser;
-    Xapian::Stem stemmer;
-    Xapian::SimpleStopper stopper;
-    Xapian::MSetIterator current_result;
-    std::map<std::string, int> valuesmap;
-  };
+ protected:
+  void closeIndex();
+  void openIndex(const string& xapianDirectoryPath);
+  void setup_queryParser();
 
+  Reader* reader;
+  Xapian::Database readableDatabase;
+  std::string language;
+  std::string stopwords;
+  Xapian::QueryParser queryParser;
+  Xapian::Stem stemmer;
+  Xapian::SimpleStopper stopper;
+  Xapian::MSetIterator current_result;
+  std::map<std::string, int> valuesmap;
+};
 }
 
 #endif

kiwix.pc.in

@@ -4,7 +4,7 @@ includedir=${prefix}/include
 
 Name: libkiwix
 Description: A library that contains a lot of things used by used by other kiwix programs
-Version: 1.0
+Version: @version@
 Requires: @requires@
 Libs: -L${libdir} -lkiwix @extra_libs@
 Cflags: -I${includedir}/ @extra_cflags@

meson.build

@@ -1,15 +1,18 @@
-project('kiwixlib', 'cpp',
-  version : '0.2.0',
+project('kiwix-lib', 'cpp',
+  version : '2.0.0',
   license : 'GPL',
-  default_options : ['c_std=c11', 'cpp_std=c++11'])
+  default_options : ['c_std=c11', 'cpp_std=c++11', 'werror=true'])
 
 compiler = meson.get_compiler('cpp')
 find_library_in_compiler = meson.version().version_compare('>=0.31.0')
 
+static_deps = get_option('android') or get_option('default_library') == 'static'
+
 thread_dep = dependency('threads')
-libicu_dep = dependency('icu-i18n')
-libzim_dep = dependency('libzim')
-pugixml_dep = dependency('pugixml')
+libicu_dep = dependency('icu-i18n', static:static_deps)
+libzim_dep = dependency('libzim', version : '>=3.3.0', static:static_deps)
+pugixml_dep = dependency('pugixml', static:static_deps)
+libaria2_dep = dependency('libaria2', static:static_deps)
 
 ctpp2_include_path = ''
 has_ctpp2_dep = false
@@ -46,8 +49,14 @@ else
   ctpp2_include_args = ['-I'+ctpp2_include_path]
   if compiler.has_header('ctpp2/CTPP2Logger.hpp', args:ctpp2_include_args)
     ctpp2_include_dir = include_directories(ctpp2_include_path, is_system:true)
-    ctpp2_lib_path = ctpp2_prefix_install+'/lib'
-    ctpp2_lib = compiler.find_library('ctpp2', dirs:ctpp2_lib_path)
+    ctpp2_lib_path = join_paths(ctpp2_prefix_install, get_option('libdir'))
+    message(ctpp2_lib_path)
+    ctpp2_lib = compiler.find_library('ctpp2', dirs:ctpp2_lib_path, required:false)
+    if not ctpp2_lib.found()
+      ctpp2_lib_path = join_paths(ctpp2_prefix_install, 'lib')
+      message(ctpp2_lib_path)
+      ctpp2_lib = compiler.find_library('ctpp2', dirs:ctpp2_lib_path)
+    endif
     ctpp2_link_args = ['-L'+ctpp2_lib_path, '-lctpp2']
     if meson.is_cross_build() and host_machine.system() == 'windows'
       iconv_lib = compiler.find_library('iconv', required:false)
@@ -62,9 +71,9 @@ else
   endif
 endif
 
-xapian_dep = dependency('xapian-core', required:false)
+xapian_dep = dependency('xapian-core', required:false, static:static_deps)
 
-all_deps = [thread_dep, libicu_dep, libzim_dep, xapian_dep, pugixml_dep]
+all_deps = [thread_dep, libicu_dep, libzim_dep, xapian_dep, pugixml_dep, libaria2_dep]
 if has_ctpp2_dep
   all_deps += [ctpp2_dep]
 endif
@@ -80,7 +89,7 @@ subdir('scripts')
 subdir('static')
 subdir('src')
 
-pkg_requires = ['libzim', 'icu-i18n', 'pugixml']
+pkg_requires = ['libzim', 'icu-i18n', 'pugixml', 'libaria2']
 if xapian_dep.found()
     pkg_requires += ['xapian-core']
 endif
@@ -99,6 +108,7 @@ pkg_conf.set('prefix', get_option('prefix'))
 pkg_conf.set('requires', ' '.join(pkg_requires))
 pkg_conf.set('extra_libs', ' '.join(extra_libs))
 pkg_conf.set('extra_cflags', extra_cflags)
+pkg_conf.set('version', meson.project_version())
 configure_file(output : 'kiwix.pc',
                configuration : pkg_conf,
                input : 'kiwix.pc.in',

scripts/ctpp2c.sh

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+
+
+ctpp2c=$1
+SOURCE=$(pwd)/$2
+DEST=$3
+
+$ctpp2c $SOURCE $DEST

scripts/kiwix-compile-resources

@@ -1,5 +1,24 @@
 #!/usr/bin/env python3
 
+'''
+Copyright 2016 Matthieu Gautier <mgautier@kymeria.fr>
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 3 of the License, or any
+later version.
+
+This program 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
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301, USA.
+'''
+
 import argparse
 import os.path
 import re
@@ -38,12 +57,21 @@ extern const std::string {identifier};
 {namespaces_close}"""
 
 class Resource:
-    def __init__(self, base_dir, filename):
+    def __init__(self, base_dirs, filename):
         filename = filename.strip()
         self.filename = filename
         self.identifier = full_identifier(filename)
-        with open(os.path.join(base_dir, filename), 'rb') as f:
-            self.data = f.read()
+        found = False
+        for base_dir in base_dirs:
+            try:
+                with open(os.path.join(base_dir, filename), 'rb') as f:
+                    self.data = f.read()
+                found = True
+                break
+            except FileNotFoundError:
+                continue
+        if not found:
+            raise Exception("Impossible to found {}".format(filename))
 
     def dump_impl(self):
         nb_row = len(self.data)//16 + (1 if len(self.data) % 16 else 0)
@@ -78,16 +106,8 @@ master_c_template = """//This file is automaically generated. Do not modify it.
 
 #include <stdlib.h>
 #include <fstream>
-#include <stdexcept>
 #include "{include_file}"
 
-class ResourceNotFound : public std::runtime_error {{
-  public:
-    ResourceNotFound(const std::string& what_arg):
-      std::runtime_error(what_arg)
-    {{ }};
-}};
-
 static std::string init_resource(const char* name, const unsigned char* content, int len)
 {{
     char * resPath = getenv(name);
@@ -125,11 +145,19 @@ master_h_template = """//This file is automaically generated. Do not modify it.
 #define KIWIX_{BASENAME}
 
 #include <string>
+#include <stdexcept>
 
 namespace RESOURCE {{
     {RESOURCES}
 }};
 
+class ResourceNotFound : public std::runtime_error {{
+  public:
+    ResourceNotFound(const std::string& what_arg):
+      std::runtime_error(what_arg)
+    {{ }};
+}};
+
 const std::string& getResource_{basename}(const std::string& name);
 
 #define getResource(a) (getResource_{basename}(a))
@@ -151,13 +179,18 @@ if __name__ == "__main__":
                         help='The Cpp file name to generate')
     parser.add_argument('--hfile',
                         help='The h file name to generate')
+    parser.add_argument('--source_dir',
+                        help="Additional directory where to look for resources.",
+                        action='append')
     parser.add_argument('resource_file',
                         help='The list of resources to compile.')
     args = parser.parse_args()
 
     base_dir = os.path.dirname(os.path.realpath(args.resource_file))
+    source_dir = args.source_dir or []
     with open(args.resource_file, 'r') as f:
-        resources = [Resource(base_dir, filename) for filename in f.readlines()]
+        resources = [Resource([base_dir]+source_dir, filename)
+                        for filename in f.readlines()]
 
     h_identifier = to_identifier(os.path.basename(args.hfile))
     with open(args.hfile, 'w') as f:

scripts/meson.build

@@ -1,4 +1,5 @@
 
-res_compiler = find_program('compile_resources.py')
+res_compiler = find_program('kiwix-compile-resources')
+intermediate_ctpp2c = find_program('ctpp2c.sh')
 
 install_data(res_compiler.path(), install_dir:get_option('bindir'))

src/android/gen_kiwix.sh

@@ -4,8 +4,13 @@ set -e
 
 BUILD_PATH=$(pwd)
 
-javac -d $BUILD_PATH/src/android $1 $2 $3 $4
+echo "javac -d $BUILD_PATH/src/android $@"
+javac -d $BUILD_PATH/src/android/ "$@"
+
 
 cd $BUILD_PATH/src/android
+echo "javah -jni org.kiwix.kiwixlib"
 javah -jni org.kiwix.kiwixlib.JNIKiwix
+javah -jni org.kiwix.kiwixlib.JNIKiwixReader
+javah -jni org.kiwix.kiwixlib.JNIKiwixSearcher
 cd $BUILD_PATH

src/android/kiwix.cpp

@@ -1,485 +1,44 @@
+/*
+ * Copyright (C) 2013 Emmanuel Engelhart <kelson@kiwix.org>
+ * Copyright (C) 2017 Matthieu Gautier <mgautier@kymeria.fr>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU  General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * any later version.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ */
+
 #include <jni.h>
 #include "org_kiwix_kiwixlib_JNIKiwix.h"
 
-#include <stdio.h>
-#include <string.h>
-
 #include <iostream>
 #include <string>
 
 #include "unicode/putil.h"
-#include "reader.h"
-#include "searcher.h"
-#include "common/base64.h"
 
-#include <android/log.h>
-#define  LOGI(...)  __android_log_print(ANDROID_LOG_INFO, "kiwix", __VA_ARGS__)
+#include "utils.h"
 
-#include <xapian.h>
-#include <zim/zim.h>
-#include <zim/file.h>
-#include <zim/article.h>
-#include <zim/error.h>
+pthread_mutex_t globalLock = PTHREAD_RECURSIVE_MUTEX_INITIALIZER;
 
-/* global variables */
-kiwix::Reader *reader = NULL;
-kiwix::Searcher *searcher = NULL;
-
-static pthread_mutex_t readerLock = PTHREAD_MUTEX_INITIALIZER;
-static pthread_mutex_t searcherLock = PTHREAD_MUTEX_INITIALIZER;
-
-/* c2jni type conversion functions */
-jboolean c2jni(const bool &val) {
-  return val ? JNI_TRUE : JNI_FALSE;
-}
-
-jstring c2jni(const std::string &val, JNIEnv *env) {
-  return env->NewStringUTF(val.c_str());
-}
-
-jint c2jni(const int val) {
-  return (jint)val;
-}
-
-jint c2jni(const unsigned val) {
-  return (unsigned)val;
-}
-
-/* jni2c type conversion functions */
-bool jni2c(const jboolean &val) {
-  return val == JNI_TRUE;
-}
-
-std::string jni2c(const jstring &val, JNIEnv *env) {
-  return std::string(env->GetStringUTFChars(val, 0));
-}
-
-int jni2c(const jint val) {
-  return (int)val;
-}
-
-/* Method to deal with variable passed by reference */
-void setStringObjValue(const std::string &value, const jobject obj, JNIEnv *env) {
-  jclass objClass = env->GetObjectClass(obj);
-  jfieldID objFid = env->GetFieldID(objClass, "value", "Ljava/lang/String;");
-  env->SetObjectField(obj, objFid, c2jni(value, env));
-}
-
-void setIntObjValue(const int value, const jobject obj, JNIEnv *env) {
-  jclass objClass = env->GetObjectClass(obj);
-  jfieldID objFid = env->GetFieldID(objClass, "value", "I");
-  env->SetIntField(obj, objFid, value);
-}
-
-void setBoolObjValue(const bool value, const jobject obj, JNIEnv *env) {
-  jclass objClass = env->GetObjectClass(obj);
-  jfieldID objFid = env->GetFieldID(objClass, "value", "Z");
-  env->SetIntField(obj, objFid, c2jni(value));
-}
-
-/* Kiwix library functions */
-JNIEXPORT jstring JNICALL Java_org_kiwix_kiwixlib_JNIKiwix_getMainPage(JNIEnv *env, jobject obj) {
-  jstring url;
-  
-  pthread_mutex_lock(&readerLock);
-  if (reader != NULL) {
-    try {
-      std::string cUrl = reader->getMainPageUrl();
-      url = c2jni(cUrl, env);
-    } catch (...) {
-      std::cerr << "Unable to get ZIM main page" << std::endl;
-    }
-  }
-  pthread_mutex_unlock(&readerLock);
-  
-  return url;
-}
-
-JNIEXPORT jstring JNICALL Java_org_kiwix_kiwixlib_JNIKiwix_getId(JNIEnv *env, jobject obj) {
-  jstring id;
-  
-  pthread_mutex_lock(&readerLock);
-  if (reader != NULL) {
-    try {
-      std::string cId = reader->getId();
-      id = c2jni(cId, env);
-    } catch (...) {
-      std::cerr << "Unable to get ZIM id" << std::endl;
-    }
-  }
-  pthread_mutex_unlock(&readerLock);
-  
-  return id;
-}
-
-JNIEXPORT jint JNICALL Java_org_kiwix_kiwixlib_JNIKiwix_getFileSize(JNIEnv *env, jobject obj) {
-  jint size;
-  
-  pthread_mutex_lock(&readerLock);
-  if (reader != NULL) {
-    try {
-      int cSize = reader->getFileSize();
-      size = c2jni(cSize);
-    } catch (...) {
-      std::cerr << "Unable to get ZIM file size" << std::endl;
-    }
-  }
-  pthread_mutex_unlock(&readerLock);
-  
-  return size;
-}
-
-JNIEXPORT jstring JNICALL Java_org_kiwix_kiwixlib_JNIKiwix_getCreator(JNIEnv *env, jobject obj) {
-  jstring creator;
-  
-  pthread_mutex_lock(&readerLock);
-  if (reader != NULL) {
-    try {
-      std::string cCreator = reader->getCreator();
-      creator = c2jni(cCreator, env);
-    } catch (...) {
-      std::cerr << "Unable to get ZIM creator" << std::endl;
-    }
-  }
-  pthread_mutex_unlock(&readerLock);
-  
-  return creator;
-}
-
-JNIEXPORT jstring JNICALL Java_org_kiwix_kiwixlib_JNIKiwix_getPublisher(JNIEnv *env, jobject obj) {
-  jstring publisher;
-  
-  pthread_mutex_lock(&readerLock);
-  if (reader != NULL) {
-    try {
-      std::string cPublisher = reader->getPublisher();
-      publisher = c2jni(cPublisher, env);
-    } catch (...) {
-      std::cerr << "Unable to get ZIM creator" << std::endl;
-    }
-  }
-  pthread_mutex_unlock(&readerLock);
-  
-  return publisher;
-}
-
-JNIEXPORT jstring JNICALL Java_org_kiwix_kiwixlib_JNIKiwix_getName(JNIEnv *env, jobject obj) {
-  jstring name;
-  
-  pthread_mutex_lock(&readerLock);
-  if (reader != NULL) {
-    try {
-      std::string cName = reader->getName();
-      name = c2jni(cName, env);
-    } catch (...) {
-      std::cerr << "Unable to get ZIM name" << std::endl;
-    }
-  }
-  pthread_mutex_unlock(&readerLock);
-  
-  return name;
-}
-
-
-JNIEXPORT jstring JNICALL Java_org_kiwix_kiwixlib_JNIKiwix_getFavicon(JNIEnv *env, jobject obj) {
-  jstring favicon;
-  
-  pthread_mutex_lock(&readerLock);
-  if (reader != NULL) {
-    try {
-      std::string cContent;
-      std::string cMime;
-      reader->getFavicon(cContent, cMime);
-      favicon = c2jni(base64_encode(reinterpret_cast<const unsigned char*>(cContent.c_str()), cContent.length()), env);
-    } catch (...) {
-      std::cerr << "Unable to get ZIM favicon" << std::endl;
-    }
-  }
-  pthread_mutex_unlock(&readerLock);
-  
-  return favicon;
-}
-
-JNIEXPORT jstring JNICALL Java_org_kiwix_kiwixlib_JNIKiwix_getDate(JNIEnv *env, jobject obj) {
-  jstring date;
-  
-  pthread_mutex_lock(&readerLock);
-  if (reader != NULL) {
-    try {
-      std::string cDate = reader->getDate();
-      date = c2jni(cDate, env);
-    } catch (...) {
-      std::cerr << "Unable to get ZIM date" << std::endl;
-    }
-  }
-  pthread_mutex_unlock(&readerLock);
-  
-  return date;
-}
-
-JNIEXPORT jstring JNICALL Java_org_kiwix_kiwixlib_JNIKiwix_getLanguage(JNIEnv *env, jobject obj) {
-  jstring language;
-  
-  pthread_mutex_lock(&readerLock);
-  if (reader != NULL) {
-    try {
-      std::string cLanguage = reader->getLanguage();
-      language = c2jni(cLanguage, env);
-    } catch (...) {
-      std::cerr << "Unable to get ZIM language" << std::endl;
-    }
-  }
-  pthread_mutex_unlock(&readerLock);
-  
-  return language;
-}
-
-JNIEXPORT jstring JNICALL Java_org_kiwix_kiwixlib_JNIKiwix_getMimeType(JNIEnv *env, jobject obj, jstring url) {
-  jstring mimeType;
-  
-  pthread_mutex_lock(&readerLock);
-  if (reader != NULL) {
-    std::string cUrl = jni2c(url, env);
-    try {
-      std::string cMimeType;
-      reader->getMimeTypeByUrl(cUrl, cMimeType);
-      mimeType = c2jni(cMimeType, env);
-    } catch (...) {
-      std::cerr << "Unable to get mime-type for url " << cUrl << std::endl;
-    }
-  }
-  pthread_mutex_unlock(&readerLock);
-  
-  return mimeType;
-}
-
-JNIEXPORT jboolean JNICALL Java_org_kiwix_kiwixlib_JNIKiwix_loadZIM(JNIEnv *env, jobject obj, jstring path) {
-  jboolean retVal = JNI_TRUE;
-  std::string cPath = jni2c(path, env);
-
-  pthread_mutex_lock(&readerLock);
-  try {
-    if (reader != NULL) delete reader;
-    reader = new kiwix::Reader(cPath);
-  } catch (...) {
-    std::cerr << "Unable to load ZIM " << cPath << std::endl;
-    reader = NULL;
-    retVal = JNI_FALSE;
-  }
-  pthread_mutex_unlock(&readerLock);
-
-  return retVal;
-}
-
-JNIEXPORT jbyteArray JNICALL Java_org_kiwix_kiwixlib_JNIKiwix_getContent(JNIEnv *env, jobject obj, jstring url, jobject mimeTypeObj, jobject sizeObj) {
-
-  /* Default values */
-  setStringObjValue("", mimeTypeObj, env);
-  setIntObjValue(0, sizeObj, env);
-  jbyteArray data = env->NewByteArray(0);
-
-  /* Retrieve the content */
-  if (reader != NULL) {
-    std::string cUrl = jni2c(url, env);
-    std::string cData;
-    std::string cMimeType;
-    unsigned int cSize = 0;
-
-    pthread_mutex_lock(&readerLock);
-    try {
-      if (reader->getContentByUrl(cUrl, cData, cSize, cMimeType)) {
-        data = env->NewByteArray(cSize);
-        env->SetByteArrayRegion(data, 0, cSize, reinterpret_cast<const jbyte*>(cData.c_str()));
-        setStringObjValue(cMimeType, mimeTypeObj, env);
-        setIntObjValue(cSize, sizeObj, env);
-      }
-    } catch (...) {
-      std::cerr << "Unable to get content for url " << cUrl << std::endl;
-    }
-    pthread_mutex_unlock(&readerLock);
-  }
-  
-  return data;
-}
-
-JNIEXPORT jboolean JNICALL Java_org_kiwix_kiwixlib_JNIKiwix_searchSuggestions
-(JNIEnv *env, jobject obj, jstring prefix, jint count) {
-  jboolean retVal = JNI_FALSE;
-  std::string cPrefix = jni2c(prefix, env);
-  unsigned int cCount = jni2c(count);
-
-  pthread_mutex_lock(&readerLock);
-  try {
-    if (reader != NULL) {
-      if (reader->searchSuggestionsSmart(cPrefix, cCount)) {
-        retVal = JNI_TRUE;
-      }
-    }
-  } catch (...) {
-    std::cerr << "Unable to search suggestions for pattern " << cPrefix << std::endl;
-  }
-  pthread_mutex_unlock(&readerLock);
-
-  return retVal;
-}
-
-JNIEXPORT jboolean JNICALL Java_org_kiwix_kiwixlib_JNIKiwix_getNextSuggestion
-(JNIEnv *env, jobject obj, jobject titleObj) {
-  jboolean retVal = JNI_FALSE;
-  std::string cTitle;
-
-  pthread_mutex_lock(&readerLock);
-  try {
-    if (reader != NULL) {
-      if (reader->getNextSuggestion(cTitle)) {
-        setStringObjValue(cTitle, titleObj, env);
-        retVal = JNI_TRUE;
-      }
-    }
-  } catch (...) {
-    std::cerr << "Unable to get next suggestion" << std::endl;
-  }
-  pthread_mutex_unlock(&readerLock);
-
-  return retVal;
-}
-
-JNIEXPORT jboolean JNICALL Java_org_kiwix_kiwixlib_JNIKiwix_getPageUrlFromTitle
-(JNIEnv *env, jobject obj, jstring title, jobject urlObj) {
-  jboolean retVal = JNI_FALSE;
-  std::string cTitle = jni2c(title, env);
-  std::string cUrl;
-
-  pthread_mutex_lock(&readerLock);
-  try {
-    if (reader != NULL) {
-      if (reader->getPageUrlFromTitle(cTitle, cUrl)) {
-        setStringObjValue(cUrl, urlObj, env);
-        retVal = JNI_TRUE;
-      }
-    }
-  } catch (...) {
-    std::cerr << "Unable to get URL for title " << cTitle << std::endl;
-  }
-  pthread_mutex_unlock(&readerLock);
-    
-  return retVal;
-}
-
-JNIEXPORT jboolean JNICALL Java_org_kiwix_kiwixlib_JNIKiwix_getTitle
-(JNIEnv *env , jobject obj, jobject titleObj) {
-  jboolean retVal = JNI_FALSE;
-  std::string cTitle;
-
-  pthread_mutex_lock(&readerLock);
-  try {
-    if (reader != NULL) {
-      std::string cTitle = reader->getTitle();
-      setStringObjValue(cTitle, titleObj, env);
-      retVal = JNI_TRUE;
-    }
-  } catch (...) {
-    std::cerr << "Unable to get ZIM title" << std::endl;
-  }
-  pthread_mutex_unlock(&readerLock);
-
-  return retVal;
-
-}
-
-JNIEXPORT jstring JNICALL Java_org_kiwix_kiwixlib_JNIKiwix_getDescription(JNIEnv *env, jobject obj) {
-  jstring description;
-  
-  pthread_mutex_lock(&readerLock);
-  if (reader != NULL) {
-    try {
-      std::string cDescription = reader->getDescription();
-      description = c2jni(cDescription, env);
-    } catch (...) {
-      std::cerr << "Unable to get ZIM description" << std::endl;
-    }
-  }
-  pthread_mutex_unlock(&readerLock);
-  
-  return description;
-}
-
-JNIEXPORT jboolean JNICALL Java_org_kiwix_kiwixlib_JNIKiwix_getRandomPage
-(JNIEnv *env, jobject obj, jobject urlObj) {
-  jboolean retVal = JNI_FALSE;
-  std::string cUrl;
-
-  pthread_mutex_lock(&readerLock);
-  try {
-    if (reader != NULL) {
-      std::string cUrl = reader->getRandomPageUrl();
-      setStringObjValue(cUrl, urlObj, env);
-      retVal = JNI_TRUE;
-    }
-  } catch (...) {
-    std::cerr << "Unable to get random page" << std::endl;
-  }
-  pthread_mutex_unlock(&readerLock);
-
-  return retVal;
-}
-
-JNIEXPORT void JNICALL Java_org_kiwix_kiwixlib_JNIKiwix_setDataDirectory
-  (JNIEnv *env, jobject obj, jstring dirStr) {
+JNIEXPORT void JNICALL Java_org_kiwix_kiwixlib_JNIKiwix_setDataDirectory(
+    JNIEnv* env, jobject obj, jstring dirStr)
+{
   std::string cPath = jni2c(dirStr, env);
 
-  pthread_mutex_lock(&readerLock); 
+  Lock l;
   try {
     u_setDataDirectory(cPath.c_str());
   } catch (...) {
     std::cerr << "Unable to set data directory " << cPath << std::endl;
   }
-  pthread_mutex_unlock(&readerLock);
 }
-
-JNIEXPORT jboolean JNICALL Java_org_kiwix_kiwixlib_JNIKiwix_loadFulltextIndex(JNIEnv *env, jobject obj, jstring path) {
-  jboolean retVal = JNI_TRUE;
-  std::string cPath = jni2c(path, env);
-
-  pthread_mutex_lock(&searcherLock);
-  searcher = NULL;
-  try {
-    if (searcher != NULL) delete searcher;
-    searcher = new kiwix::Searcher(cPath, reader);
-  } catch (...) {
-    searcher = NULL;
-    retVal = JNI_FALSE;
-    std::cerr << "Unable to load full text index " << cPath << std::endl;
-  }
-  pthread_mutex_unlock(&searcherLock);
-
-  return retVal;
-}
-
-JNIEXPORT jstring JNICALL Java_org_kiwix_kiwixlib_JNIKiwix_indexedQuery
-  (JNIEnv *env, jclass obj, jstring query, jint count) {
-  std::string cQuery = jni2c(query, env);
-  unsigned int cCount = jni2c(count);
-  kiwix::Result *p_result;
-  std::string result;
-      
-  pthread_mutex_lock(&searcherLock);
-  try {
-    if (searcher != NULL) {
-      searcher->search(cQuery, 0, count);
-      while ( (p_result = searcher->getNextResult()) &&
-	     !(p_result->get_title().empty()) &&
-	     !(p_result->get_url().empty())) {
-	result += p_result->get_title() + "\n";
-	delete p_result;
-      }
-    }
-  } catch (...) {
-    std::cerr << "Unable to make indexed query " << cQuery << std::endl;
-  }
-  pthread_mutex_unlock(&searcherLock);
-
-  return env->NewStringUTF(result.c_str());
-}
-
-

src/android/kiwixreader.cpp

@@ -0,0 +1,399 @@
+/*
+ * Copyright (C) 2013 Emmanuel Engelhart <kelson@kiwix.org>
+ * Copyright (C) 2017 Matthieu Gautier <mgautier@kymeria.fr>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU  General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * any later version.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ */
+
+
+#include <jni.h>
+#include <zim/file.h>
+#include "org_kiwix_kiwixlib_JNIKiwixReader.h"
+
+#include "common/base64.h"
+#include "reader.h"
+#include "utils.h"
+
+/* Kiwix Reader JNI functions */
+JNIEXPORT jlong JNICALL Java_org_kiwix_kiwixlib_JNIKiwixReader_getNativeReader(
+    JNIEnv* env, jobject obj, jstring filename)
+{
+  std::string cPath = jni2c(filename, env);
+
+  Lock l;
+  kiwix::Reader* reader = nullptr;
+  try {
+    reader = new kiwix::Reader(cPath);
+  } catch (...) {
+    std::cerr << "Unable to load ZIM " << cPath << std::endl;
+    reader = NULL;
+  }
+
+  return reinterpret_cast<jlong>(new Handle<kiwix::Reader>(reader));
+}
+
+JNIEXPORT void JNICALL
+Java_org_kiwix_kiwixlib_JNIKiwixReader_dispose(JNIEnv* env, jobject obj)
+{
+  Handle<kiwix::Reader>::dispose(env, obj);
+}
+
+#define READER (Handle<kiwix::Reader>::getHandle(env, obj))
+
+/* Kiwix library functions */
+JNIEXPORT jstring JNICALL
+Java_org_kiwix_kiwixlib_JNIKiwixReader_getMainPage(JNIEnv* env, jobject obj)
+{
+  jstring url;
+
+  try {
+    std::string cUrl = READER->getMainPage().getPath();
+    url = c2jni(cUrl, env);
+  } catch (...) {
+    std::cerr << "Unable to get ZIM main page" << std::endl;
+  }
+  return url;
+}
+
+JNIEXPORT jstring JNICALL
+Java_org_kiwix_kiwixlib_JNIKiwixReader_getId(JNIEnv* env, jobject obj)
+{
+  jstring id;
+
+  try {
+    std::string cId = READER->getId();
+    id = c2jni(cId, env);
+  } catch (...) {
+    std::cerr << "Unable to get ZIM id" << std::endl;
+  }
+
+  return id;
+}
+
+JNIEXPORT jint JNICALL
+Java_org_kiwix_kiwixlib_JNIKiwixReader_getFileSize(JNIEnv* env, jobject obj)
+{
+  jint size;
+
+  try {
+    int cSize = READER->getFileSize();
+    size = c2jni(cSize);
+  } catch (...) {
+    std::cerr << "Unable to get ZIM file size" << std::endl;
+  }
+
+  return size;
+}
+
+JNIEXPORT jstring JNICALL
+Java_org_kiwix_kiwixlib_JNIKiwixReader_getCreator(JNIEnv* env, jobject obj)
+{
+  jstring creator;
+
+  try {
+    std::string cCreator = READER->getCreator();
+    creator = c2jni(cCreator, env);
+  } catch (...) {
+    std::cerr << "Unable to get ZIM creator" << std::endl;
+  }
+
+  return creator;
+}
+
+JNIEXPORT jstring JNICALL
+Java_org_kiwix_kiwixlib_JNIKiwixReader_getPublisher(JNIEnv* env, jobject obj)
+{
+  jstring publisher;
+
+  try {
+    std::string cPublisher = READER->getPublisher();
+    publisher = c2jni(cPublisher, env);
+  } catch (...) {
+    std::cerr << "Unable to get ZIM creator" << std::endl;
+  }
+  return publisher;
+}
+
+JNIEXPORT jstring JNICALL
+Java_org_kiwix_kiwixlib_JNIKiwixReader_getName(JNIEnv* env, jobject obj)
+{
+  jstring name;
+
+  try {
+    std::string cName = READER->getName();
+    name = c2jni(cName, env);
+  } catch (...) {
+    std::cerr << "Unable to get ZIM name" << std::endl;
+  }
+  return name;
+}
+
+JNIEXPORT jstring JNICALL
+Java_org_kiwix_kiwixlib_JNIKiwixReader_getFavicon(JNIEnv* env, jobject obj)
+{
+  jstring favicon;
+
+  try {
+    std::string cContent;
+    std::string cMime;
+    READER->getFavicon(cContent, cMime);
+    favicon = c2jni(
+        base64_encode(reinterpret_cast<const unsigned char*>(cContent.c_str()),
+                      cContent.length()),
+        env);
+  } catch (...) {
+    std::cerr << "Unable to get ZIM favicon" << std::endl;
+  }
+  return favicon;
+}
+
+JNIEXPORT jstring JNICALL
+Java_org_kiwix_kiwixlib_JNIKiwixReader_getDate(JNIEnv* env, jobject obj)
+{
+  jstring date;
+
+  try {
+    std::string cDate = READER->getDate();
+    date = c2jni(cDate, env);
+  } catch (...) {
+    std::cerr << "Unable to get ZIM date" << std::endl;
+  }
+  return date;
+}
+
+JNIEXPORT jstring JNICALL
+Java_org_kiwix_kiwixlib_JNIKiwixReader_getLanguage(JNIEnv* env, jobject obj)
+{
+  jstring language;
+
+  try {
+    std::string cLanguage = READER->getLanguage();
+    language = c2jni(cLanguage, env);
+  } catch (...) {
+    std::cerr << "Unable to get ZIM language" << std::endl;
+  }
+
+  return language;
+}
+
+JNIEXPORT jstring JNICALL Java_org_kiwix_kiwixlib_JNIKiwixReader_getMimeType(
+    JNIEnv* env, jobject obj, jstring url)
+{
+  jstring mimeType;
+
+  std::string cUrl = jni2c(url, env);
+  try {
+    auto entry = READER->getEntryFromEncodedPath(cUrl);
+    auto cMimeType = entry.getMimetype();
+    mimeType = c2jni(cMimeType, env);
+  } catch (...) {
+    std::cerr << "Unable to get mime-type for url " << cUrl << std::endl;
+  }
+  return mimeType;
+}
+
+JNIEXPORT jbyteArray JNICALL Java_org_kiwix_kiwixlib_JNIKiwixReader_getContent(
+    JNIEnv* env, jobject obj, jstring url, jobject titleObj, jobject mimeTypeObj, jobject sizeObj)
+{
+  /* Default values */
+  setStringObjValue("", titleObj, env);
+  setStringObjValue("", mimeTypeObj, env);
+  setIntObjValue(0, sizeObj, env);
+  jbyteArray data = env->NewByteArray(0);
+
+  /* Retrieve the content */
+  std::string cUrl = jni2c(url, env);
+  unsigned int cSize = 0;
+
+  try {
+    auto entry = READER->getEntryFromEncodedPath(cUrl);
+    entry = entry.getFinalEntry();
+    cSize = entry.getSize();
+    setIntObjValue(cSize, sizeObj, env);
+
+    data = env->NewByteArray(cSize);
+    env->SetByteArrayRegion(
+        data, 0, cSize, reinterpret_cast<const jbyte*>(entry.getBlob().data()));
+
+    setStringObjValue(entry.getMimetype(), mimeTypeObj, env);
+    setStringObjValue(entry.getTitle(), titleObj, env);
+  } catch (...) {
+    std::cerr << "Unable to get content for url " << cUrl << std::endl;
+  }
+
+  return data;
+}
+
+JNIEXPORT jbyteArray JNICALL Java_org_kiwix_kiwixlib_JNIKiwixReader_getContentPart(
+    JNIEnv* env, jobject obj, jstring url, jint offset, jint len, jobject sizeObj)
+{
+  jbyteArray data = env->NewByteArray(0);
+  setIntObjValue(0, sizeObj, env);
+
+  /* Default values */
+  /* Retrieve the content */
+  std::string cUrl = jni2c(url, env);
+  unsigned int cOffset = jni2c(offset);
+  unsigned int cLen = jni2c(len);
+  try {
+    auto entry = READER->getEntryFromEncodedPath(cUrl);
+    entry = entry.getFinalEntry();
+
+    if (cLen == 0) {
+      setIntObjValue(entry.getSize(), sizeObj, env);
+    } else if (cOffset+cLen < entry.getSize()) {
+      auto blob = entry.getBlob(cOffset, cLen);
+      data = env->NewByteArray(cLen);
+      env->SetByteArrayRegion(
+          data, 0, cLen, reinterpret_cast<const jbyte*>(blob.data()));
+      setIntObjValue(cLen, sizeObj, env);
+    }
+  } catch (...) {
+     std::cerr << "Unable to get partial content for url " << cUrl
+               << "(" << cOffset << ":" << cLen << ")" << std::endl;
+  }
+  return data;
+}
+
+JNIEXPORT jobject JNICALL
+Java_org_kiwix_kiwixlib_JNIKiwixReader_getDirectAccessInformation(
+    JNIEnv* env, jobject obj, jstring url)
+{
+   jclass classPair = env->FindClass("org/kiwix/kiwixlib/Pair");
+   jmethodID midPairinit = env->GetMethodID(classPair, "<init>", "()V");
+   jobject pair = env->NewObject(classPair, midPairinit);
+   setPairObjValue("", 0, pair, env);
+
+   std::string cUrl = jni2c(url, env);
+   try {
+    auto entry = READER->getEntryFromEncodedPath(cUrl);
+    entry = entry.getFinalEntry();
+    auto part_info = entry.getDirectAccessInfo();
+    setPairObjValue(part_info.first, part_info.second, pair, env);
+  } catch (...) {
+    std::cerr << "Unable to locate direct access information for url " << cUrl
+              << std::endl;
+
+  }
+  return pair;
+}
+
+JNIEXPORT jboolean JNICALL
+Java_org_kiwix_kiwixlib_JNIKiwixReader_searchSuggestions(JNIEnv* env,
+                                                         jobject obj,
+                                                         jstring prefix,
+                                                         jint count)
+{
+  jboolean retVal = JNI_FALSE;
+  std::string cPrefix = jni2c(prefix, env);
+  unsigned int cCount = jni2c(count);
+
+  try {
+    if (READER->searchSuggestionsSmart(cPrefix, cCount)) {
+      retVal = JNI_TRUE;
+    }
+  } catch (...) {
+    std::cerr << "Unable to search suggestions for pattern " << cPrefix
+              << std::endl;
+  }
+
+  return retVal;
+}
+
+JNIEXPORT jboolean JNICALL
+Java_org_kiwix_kiwixlib_JNIKiwixReader_getNextSuggestion(JNIEnv* env,
+                                                         jobject obj,
+                                                         jobject titleObj)
+{
+  jboolean retVal = JNI_FALSE;
+  std::string cTitle;
+
+  try {
+    if (READER->getNextSuggestion(cTitle)) {
+      setStringObjValue(cTitle, titleObj, env);
+      retVal = JNI_TRUE;
+    }
+  } catch (...) {
+    std::cerr << "Unable to get next suggestion" << std::endl;
+  }
+
+  return retVal;
+}
+
+JNIEXPORT jboolean JNICALL
+Java_org_kiwix_kiwixlib_JNIKiwixReader_getPageUrlFromTitle(JNIEnv* env,
+                                                           jobject obj,
+                                                           jstring title,
+                                                           jobject urlObj)
+{
+  std::string cTitle = jni2c(title, env);
+
+  try {
+    auto entry = READER->getEntryFromTitle(cTitle);
+    entry = entry.getFinalEntry();
+    setStringObjValue(entry.getPath(), urlObj, env);
+    return JNI_TRUE;
+  } catch (...) {
+    std::cerr << "Unable to get URL for title " << cTitle << std::endl;
+  }
+
+  return JNI_FALSE;
+}
+
+JNIEXPORT jstring JNICALL Java_org_kiwix_kiwixlib_JNIKiwixReader_getTitle(
+    JNIEnv* env, jobject obj)
+{
+  jstring title;
+
+  try {
+    std::string cTitle = READER->getTitle();
+    title = c2jni(cTitle, env);
+  } catch (...) {
+    std::cerr << "Unable to get ZIM title" << std::endl;
+  }
+  return title;
+}
+
+JNIEXPORT jstring JNICALL
+Java_org_kiwix_kiwixlib_JNIKiwixReader_getDescription(JNIEnv* env, jobject obj)
+{
+  jstring description;
+
+  try {
+    std::string cDescription = READER->getDescription();
+    description = c2jni(cDescription, env);
+  } catch (...) {
+    std::cerr << "Unable to get ZIM description" << std::endl;
+  }
+  return description;
+}
+
+JNIEXPORT jboolean JNICALL Java_org_kiwix_kiwixlib_JNIKiwixReader_getRandomPage(
+    JNIEnv* env, jobject obj, jobject urlObj)
+{
+  jboolean retVal = JNI_FALSE;
+  std::string cUrl;
+
+  try {
+    std::string cUrl = READER->getRandomPage().getPath();
+    setStringObjValue(cUrl, urlObj, env);
+    retVal = JNI_TRUE;
+  } catch (...) {
+    std::cerr << "Unable to get random page" << std::endl;
+  }
+
+  return retVal;
+}

src/android/kiwixsearcher.cpp

@@ -0,0 +1,124 @@
+/*
+ * Copyright (C) 2013 Emmanuel Engelhart <kelson@kiwix.org>
+ * Copyright (C) 2017 Matthieu Gautier <mgautier@kymeria.fr>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU  General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * any later version.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ */
+
+
+#include <zim/file.h>
+#include "org_kiwix_kiwixlib_JNIKiwixSearcher.h"
+#include "org_kiwix_kiwixlib_JNIKiwixSearcher_Result.h"
+
+#include "reader.h"
+#include "searcher.h"
+#include "utils.h"
+
+#define SEARCHER (Handle<kiwix::Searcher>::getHandle(env, obj))
+#define RESULT (Handle<kiwix::Result>::getHandle(env, obj))
+
+
+JNIEXPORT void JNICALL
+Java_org_kiwix_kiwixlib_JNIKiwixSearcher_dispose(JNIEnv* env, jobject obj)
+{
+  Handle<kiwix::Searcher>::dispose(env, obj);
+}
+
+/* Kiwix Reader JNI functions */
+JNIEXPORT jlong JNICALL
+Java_org_kiwix_kiwixlib_JNIKiwixSearcher_getNativeHandle(JNIEnv* env,
+                                                          jobject obj)
+{
+  kiwix::Searcher* searcher = new kiwix::Searcher();
+  return reinterpret_cast<jlong>(new Handle<kiwix::Searcher>(searcher));
+}
+
+/* Kiwix library functions */
+JNIEXPORT void JNICALL Java_org_kiwix_kiwixlib_JNIKiwixSearcher_addReader(
+    JNIEnv* env, jobject obj, jobject reader)
+{
+  auto searcher = SEARCHER;
+
+  searcher->add_reader(*(Handle<kiwix::Reader>::getHandle(env, reader)), "");
+}
+
+JNIEXPORT void JNICALL Java_org_kiwix_kiwixlib_JNIKiwixSearcher_search(
+    JNIEnv* env, jobject obj, jstring query, jint count)
+{
+  std::string cquery = jni2c(query, env);
+  unsigned int ccount = jni2c(count);
+
+  SEARCHER->search(cquery, 0, ccount);
+}
+
+JNIEXPORT jobject JNICALL
+Java_org_kiwix_kiwixlib_JNIKiwixSearcher_getNextResult(JNIEnv* env,
+                                                         jobject obj)
+{
+  jobject result = nullptr;
+
+  kiwix::Result* cresult = SEARCHER->getNextResult();
+  if (cresult != nullptr) {
+    jclass resultclass
+        = env->FindClass("org/kiwix/kiwixlib/JNIKiwixSearcher$Result");
+    jmethodID ctor = env->GetMethodID(
+        resultclass, "<init>", "(Lorg/kiwix/kiwixlib/JNIKiwixSearcher;JLorg/kiwix/kiwixlib/JNIKiwixSearcher;)V");
+    result = env->NewObject(resultclass, ctor, obj, reinterpret_cast<jlong>(new Handle<kiwix::Result>(cresult)), obj);
+  }
+  return result;
+}
+
+JNIEXPORT void JNICALL Java_org_kiwix_kiwixlib_JNIKiwixSearcher_00024Result_dispose(
+    JNIEnv* env, jobject obj)
+{
+  Handle<kiwix::Result>::dispose(env, obj);
+}
+
+JNIEXPORT jstring JNICALL
+Java_org_kiwix_kiwixlib_JNIKiwixSearcher_00024Result_getUrl(JNIEnv* env,
+                                                        jobject obj)
+{
+  try {
+    return c2jni(RESULT->get_url(), env);
+  } catch (...) {
+    return nullptr;
+  }
+}
+
+JNIEXPORT jstring JNICALL
+Java_org_kiwix_kiwixlib_JNIKiwixSearcher_00024Result_getTitle(JNIEnv* env,
+                                                          jobject obj)
+{
+  try {
+    return c2jni(RESULT->get_title(), env);
+  } catch (...) {
+    return nullptr;
+  }
+}
+
+JNIEXPORT jstring JNICALL
+Java_org_kiwix_kiwixlib_JNIKiwixSearcher_00024Result_getSnippet(JNIEnv* env,
+                                                            jobject obj)
+{
+  return c2jni(RESULT->get_snippet(), env);
+}
+
+JNIEXPORT jstring JNICALL
+Java_org_kiwix_kiwixlib_JNIKiwixSearcher_00024Result_getContent(JNIEnv* env,
+                                                            jobject obj)
+{
+  return c2jni(RESULT->get_content(), env);
+}

src/android/meson.build

@@ -3,14 +3,25 @@ jni_generator = find_program('gen_kiwix.sh')
 
 kiwix_jni = custom_target('jni',
   input: ['org/kiwix/kiwixlib/JNIKiwix.java',
+          'org/kiwix/kiwixlib/JNIKiwixReader.java',
+          'org/kiwix/kiwixlib/JNIKiwixSearcher.java',
           'org/kiwix/kiwixlib/JNIKiwixInt.java',
           'org/kiwix/kiwixlib/JNIKiwixString.java',
-          'org/kiwix/kiwixlib/JNIKiwixBool.java'],
-  output: ['org_kiwix_kiwixlib_JNIKiwix.h'],
+          'org/kiwix/kiwixlib/JNIKiwixBool.java',
+          'org/kiwix/kiwixlib/JNIKiwixException.java',
+          'org/kiwix/kiwixlib/Pair.java'],
+  output: ['org_kiwix_kiwixlib_JNIKiwix.h',
+           'org_kiwix_kiwixlib_JNIKiwixReader.h',
+           'org_kiwix_kiwixlib_JNIKiwixSearcher.h',
+           'org_kiwix_kiwixlib_JNIKiwixSearcher_Result.h'],
   command:[jni_generator, '@INPUT@']
 )
 
-kiwix_sources += ['android/kiwix.cpp', kiwix_jni]
+kiwix_sources += [
+    'android/kiwix.cpp',
+    'android/kiwixreader.cpp',
+    'android/kiwixsearcher.cpp',
+    kiwix_jni]
 
 install_subdir('org', install_dir: 'kiwix-lib/java')
 install_subdir('res', install_dir: 'kiwix-lib')

src/android/org/kiwix/kiwixlib/JNIKiwix.java

@@ -1,5 +1,6 @@
 /*
- * Copyright 2013
+ * Copyright (C) 2013 Emmanuel Engelhart <kelson@kiwix.org>
+ * Copyright (C) 2017 Matthieu Gautier <mgautier@kymeria.fr>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU  General Public License as published by
@@ -19,59 +20,12 @@
 
 package org.kiwix.kiwixlib;
 
+import org.kiwix.kiwixlib.JNIKiwixReader;
 import org.kiwix.kiwixlib.JNIKiwixString;
-import org.kiwix.kiwixlib.JNIKiwixBool;
-import org.kiwix.kiwixlib.JNIKiwixInt;
 
-public class JNIKiwix {
-
-  static {
-    System.loadLibrary("kiwix");
-  }
-
-  public native String getMainPage();
-
-  public native String getId();
-
-  public native String getLanguage();
-
-  public native String getMimeType(String url);
-
-  public native boolean loadZIM(String path);
-
-    public native boolean loadFulltextIndex(String path);
-    
-  public native byte[] getContent(String url, JNIKiwixString mimeType, JNIKiwixInt size);
-
-  public native boolean searchSuggestions(String prefix, int count);
-
-  public native boolean getNextSuggestion(JNIKiwixString title);
-
-  public native boolean getPageUrlFromTitle(String title, JNIKiwixString url);
-
-  public native boolean getTitle(JNIKiwixString title);
-
-  public native String getDescription();
-
-  public native String getDate();
-
-  public native String getFavicon();
-
-  public native String getCreator();
-
-  public native String getPublisher();
-
-  public native String getName();
-
-  public native int getFileSize();
-
-  public native int getArticleCount();
-
-  public native int getMediaCount();
-
-  public native boolean getRandomPage(JNIKiwixString url);
+public class JNIKiwix
+{
+  static { System.loadLibrary("kiwix"); }
 
   public native void setDataDirectory(String icuDataDir);
-
-  public static native String indexedQuery(String db, int count);
 }

src/android/org/kiwix/kiwixlib/JNIKiwixBool.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013
+ * Copyright (C) 2013 Emmanuel Engelhart <kelson@kiwix.org>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU  General Public License as published by
@@ -19,7 +19,7 @@
 
 package org.kiwix.kiwixlib;
 
-public class JNIKiwixBool {
-
+public class JNIKiwixBool
+{
   public boolean value;
 }

src/android/org/kiwix/kiwixlib/JNIKiwixException.java

@@ -0,0 +1,27 @@
+/*
+ * Copyright (C) 2017 Matthieu Gautier <mgautier@kymeria.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU  General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * any later version.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ */
+
+package org.kiwix.kiwixlib;
+
+public class JNIKiwixException extends Exception
+{
+  public JNIKiwixException(String message) {
+    super(message);
+  }
+}

src/android/org/kiwix/kiwixlib/JNIKiwixInt.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013
+ * Copyright (C) 2013 Emmanuel Engelhart <kelson@kiwix.org>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU  General Public License as published by
@@ -19,8 +19,7 @@
 
 package org.kiwix.kiwixlib;
 
-public class JNIKiwixInt {
-
+public class JNIKiwixInt
+{
   public int value;
 }
-

src/android/org/kiwix/kiwixlib/JNIKiwixReader.java

@@ -0,0 +1,127 @@
+/*
+ * Copyright (C) 2013 Emmanuel Engelhart <kelson@kiwix.org>
+ * Copyright (C) 2017 Matthieu Gautier <mgautier@kymeria.fr>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU  General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * any later version.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ */
+
+package org.kiwix.kiwixlib;
+
+import org.kiwix.kiwixlib.JNIKiwixException;
+import org.kiwix.kiwixlib.JNIKiwixString;
+import org.kiwix.kiwixlib.JNIKiwixInt;
+import org.kiwix.kiwixlib.JNIKiwixSearcher;
+import org.kiwix.kiwixlib.Pair;
+
+public class JNIKiwixReader
+{
+  public native String getMainPage();
+
+  public native String getTitle();
+
+  public native String getId();
+
+  public native String getLanguage();
+
+  public native String getMimeType(String url);
+
+  public native byte[] getContent(String url,
+                                  JNIKiwixString title,
+                                  JNIKiwixString mimeType,
+                                  JNIKiwixInt size);
+
+  /**
+   * getContentPart.
+   *
+   * Get only a part of the content of the article.
+   * Return a byte array of `len` size starting from offset `offset`.
+   * Set `size` to the number of bytes read
+   * (`len` if everything is ok, 0 in case of error).
+   * If `len` == 0, no bytes are read but `size` is set to the total size of the
+   * article.
+   */
+  public native byte[] getContentPart(String url,
+                                      int offest,
+                                      int len,
+                                      JNIKiwixInt size);
+
+  /**
+   * getDirectAccessInformation.
+   *
+   * Return information giving where the content is located in the zim file.
+   *
+   * Some contents (binary content) are stored uncompressed in the zim file.
+   * Knowing this information, it could be interesting to directly open
+   * the zim file (or zim part) and directly read the content from it (and so
+   * bypassing the libzim).
+   *
+   * Return a `Pair` (filename, offset) where the content is located.
+   *
+   * If the content cannot be directly accessed (content is compressed or zim
+   * file is cut in the middle of the content), the filename is an empty string
+   * and offset is zero.
+   */
+  public native Pair getDirectAccessInformation(String url);
+
+  public native boolean searchSuggestions(String prefix, int count);
+
+  public native boolean getNextSuggestion(JNIKiwixString title);
+
+  public native boolean getPageUrlFromTitle(String title, JNIKiwixString url);
+
+  public native String getDescription();
+
+  public native String getDate();
+
+  public native String getFavicon();
+
+  public native String getCreator();
+
+  public native String getPublisher();
+
+  public native String getName();
+
+  public native int getFileSize();
+
+  public native int getArticleCount();
+
+  public native int getMediaCount();
+
+  public native boolean getRandomPage(JNIKiwixString url);
+
+  public JNIKiwixSearcher search(String query, int count)
+  {
+    JNIKiwixSearcher searcher = new JNIKiwixSearcher();
+    searcher.addKiwixReader(this);
+    searcher.search(query, count);
+    return searcher;
+  }
+
+  public JNIKiwixReader(String filename) throws JNIKiwixException
+  {
+    nativeHandle = getNativeReader(filename);
+    if (nativeHandle == 0) {
+        throw new JNIKiwixException("Cannot open zimfile "+filename);
+    }
+  }
+  public JNIKiwixReader() {
+
+  }
+  public native void dispose();
+
+  private native long getNativeReader(String filename);
+  private long nativeHandle;
+}

src/android/org/kiwix/kiwixlib/JNIKiwixSearcher.java

@@ -0,0 +1,67 @@
+/*
+ * Copyright (C) 2013 Emmanuel Engelhart <kelson@kiwix.org>
+ * Copyright (C) 2017 Matthieu Gautier <mgautier@kymeria.fr>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU  General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * any later version.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ */
+
+
+package org.kiwix.kiwixlib;
+
+import org.kiwix.kiwixlib.JNIKiwixReader;
+import java.util.Vector;
+
+public class JNIKiwixSearcher
+{
+  public class Result
+  {
+    private long nativeHandle;
+    private JNIKiwixSearcher searcher;
+    public Result(long handle, JNIKiwixSearcher _searcher)
+    {
+      nativeHandle = handle;
+      searcher = _searcher;
+    }
+    public native String getUrl();
+    public native String getTitle();
+    public native String getContent();
+    public native String getSnippet();
+    public native void dispose();
+  }
+
+  public JNIKiwixSearcher()
+  {
+    nativeHandle = getNativeHandle();
+    usedReaders = new Vector();
+  }
+  public native void dispose();
+
+  private native long getNativeHandle();
+  private long nativeHandle;
+  private Vector usedReaders;
+
+  public native void addReader(JNIKiwixReader reader);
+  public void addKiwixReader(JNIKiwixReader reader)
+  {
+    addReader(reader);
+    usedReaders.addElement(reader);
+  };
+
+  public native void search(String query, int count);
+
+  public native Result getNextResult();
+  public native boolean hasMoreResult();
+}

src/android/org/kiwix/kiwixlib/JNIKiwixString.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013
+ * Copyright (C) 2013 Emmanuel Engelhart <kelson@kiwix.org>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU  General Public License as published by
@@ -19,7 +19,7 @@
 
 package org.kiwix.kiwixlib;
 
-public class JNIKiwixString {
-
+public class JNIKiwixString
+{
   public String value;
 }

src/android/org/kiwix/kiwixlib/Pair.java

@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) 2017 Matthieu Gautier <mgautier@kymeria.fr>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU  General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * any later version.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ */
+
+package org.kiwix.kiwixlib;
+
+public class Pair
+{
+  public String filename;
+  public int offset;
+}

src/android/utils.h

@@ -0,0 +1,150 @@
+/*
+ * Copyright (C) 2013 Emmanuel Engelhart <kelson@kiwix.org>
+ * Copyright (C) 2017 Matthieu Gautier <mgautier@kymeria.fr>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU  General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * any later version.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ */
+
+
+#ifndef _ANDROID_JNI_UTILS_H
+#define _ANDROID_JNI_UTILS_H
+
+#include <jni.h>
+
+#include <pthread.h>
+#include <string>
+
+extern pthread_mutex_t globalLock;
+
+inline jfieldID getHandleField(JNIEnv* env, jobject obj)
+{
+  jclass c = env->GetObjectClass(obj);
+  // J is the type signature for long:
+  return env->GetFieldID(c, "nativeHandle", "J");
+}
+
+class Lock
+{
+ protected:
+  pthread_mutex_t* lock;
+
+ public:
+  Lock() : lock(&globalLock) { pthread_mutex_lock(lock); }
+  Lock(const Lock&) = delete;
+  Lock& operator=(const Lock&) = delete;
+  Lock(Lock&& other) : lock(&globalLock) { other.lock = nullptr; }
+  virtual ~Lock()
+  {
+    if (lock) {
+      pthread_mutex_unlock(lock);
+    }
+  }
+};
+
+template <class T>
+class LockedHandle;
+
+template <class T>
+class Handle
+{
+ protected:
+  T* h;
+
+ public:
+  Handle(T* h) : h(h){};
+
+  // No destructor. This must and will be handled by dispose method.
+
+  static LockedHandle<T> getHandle(JNIEnv* env, jobject obj)
+  {
+    jlong handle = env->GetLongField(obj, getHandleField(env, obj));
+    return LockedHandle<T>(reinterpret_cast<Handle<T>*>(handle));
+  }
+
+  static void dispose(JNIEnv* env, jobject obj)
+  {
+    auto lHandle = getHandle(env, obj);
+    auto handle = lHandle.h;
+    delete handle->h;
+    delete handle;
+  }
+  friend class LockedHandle<T>;
+};
+
+template <class T>
+struct LockedHandle : public Lock {
+  Handle<T>* h;
+  LockedHandle(Handle<T>* h) : h(h) {}
+  T* operator->() { return h->h; }
+  T* operator*() { return h->h; }
+  operator bool() const { return (h->h != nullptr); }
+};
+
+/* c2jni type conversion functions */
+inline jboolean c2jni(const bool& val) { return val ? JNI_TRUE : JNI_FALSE; }
+inline jstring c2jni(const std::string& val, JNIEnv* env)
+{
+  return env->NewStringUTF(val.c_str());
+}
+
+inline jint c2jni(const int val) { return (jint)val; }
+inline jint c2jni(const unsigned val) { return (unsigned)val; }
+/* jni2c type conversion functions */
+inline bool jni2c(const jboolean& val) { return val == JNI_TRUE; }
+inline std::string jni2c(const jstring& val, JNIEnv* env)
+{
+  const char* chars = env->GetStringUTFChars(val, 0);
+  std::string ret(chars);
+  env->ReleaseStringUTFChars(val, chars);
+  return ret;
+}
+
+inline int jni2c(const jint val) { return (int)val; }
+/* Method to deal with variable passed by reference */
+inline void setStringObjValue(const std::string& value,
+                              const jobject obj,
+                              JNIEnv* env)
+{
+  jclass objClass = env->GetObjectClass(obj);
+  jfieldID objFid = env->GetFieldID(objClass, "value", "Ljava/lang/String;");
+  env->SetObjectField(obj, objFid, c2jni(value, env));
+}
+
+inline void setIntObjValue(const int value, const jobject obj, JNIEnv* env)
+{
+  jclass objClass = env->GetObjectClass(obj);
+  jfieldID objFid = env->GetFieldID(objClass, "value", "I");
+  env->SetIntField(obj, objFid, value);
+}
+
+inline void setBoolObjValue(const bool value, const jobject obj, JNIEnv* env)
+{
+  jclass objClass = env->GetObjectClass(obj);
+  jfieldID objFid = env->GetFieldID(objClass, "value", "Z");
+  env->SetIntField(obj, objFid, c2jni(value));
+}
+
+inline void setPairObjValue(const std::string& filename, const int offset,
+                            const jobject obj, JNIEnv* env)
+{
+  jclass objClass = env->GetObjectClass(obj);
+  jfieldID filenameFid = env->GetFieldID(objClass, "filename", "Ljava/lang/String;");
+  env->SetObjectField(obj, filenameFid, c2jni(filename, env));
+  jfieldID offsetFid = env->GetFieldID(objClass, "offset", "I");
+  env->SetIntField(obj, offsetFid, offset);
+}
+
+#endif // _ANDROID_JNI_UTILS_H

src/common/networkTools.cpp

@@ -19,44 +19,56 @@
 
 #include <common/networkTools.h>
 
-std::map<std::string, std::string> kiwix::getNetworkInterfaces() {
+
+
+std::map<std::string, std::string> kiwix::getNetworkInterfaces()
+{
   std::map<std::string, std::string> interfaces;
 
 #ifdef _WIN32
   SOCKET sd = WSASocket(AF_INET, SOCK_DGRAM, 0, 0, 0, 0);
-  if (sd == SOCKET_ERROR) {
-    std::cerr << "Failed to get a socket. Error " << WSAGetLastError() <<
-      std::endl;
+  if (sd == (SOCKET)SOCKET_ERROR) {
+    std::cerr << "Failed to get a socket. Error " << WSAGetLastError()
+              << std::endl;
     return interfaces;
   }
 
   INTERFACE_INFO InterfaceList[20];
   unsigned long nBytesReturned;
-  if (WSAIoctl(sd, SIO_GET_INTERFACE_LIST, 0, 0, &InterfaceList,
-	       sizeof(InterfaceList), &nBytesReturned, 0, 0) == SOCKET_ERROR) {
-    std::cerr << "Failed calling WSAIoctl: error " << WSAGetLastError() <<
-      std::endl;
+  if (WSAIoctl(sd,
+               SIO_GET_INTERFACE_LIST,
+               0,
+               0,
+               &InterfaceList,
+               sizeof(InterfaceList),
+               &nBytesReturned,
+               0,
+               0)
+      == SOCKET_ERROR) {
+    std::cerr << "Failed calling WSAIoctl: error " << WSAGetLastError()
+              << std::endl;
     return interfaces;
   }
 
   int nNumInterfaces = nBytesReturned / sizeof(INTERFACE_INFO);
   for (int i = 0; i < nNumInterfaces; ++i) {
-    sockaddr_in *pAddress;
-    pAddress = (sockaddr_in *) & (InterfaceList[i].iiAddress);
+    sockaddr_in* pAddress;
+    pAddress = (sockaddr_in*)&(InterfaceList[i].iiAddress);
 
     /* Add to the map */
     std::string interfaceName = std::string(inet_ntoa(pAddress->sin_addr));
     std::string interfaceIp = std::string(inet_ntoa(pAddress->sin_addr));
-    interfaces.insert(std::pair<std::string, std::string>(interfaceName, interfaceIp));
+    interfaces.insert(
+        std::pair<std::string, std::string>(interfaceName, interfaceIp));
   }
 #else
   /* Get Network interfaces information */
   char buf[16384];
   struct ifconf ifconf;
   int fd = socket(PF_INET, SOCK_DGRAM, 0); /* Only IPV4 */
-  ifconf.ifc_len=sizeof buf;
-  ifconf.ifc_buf=buf;
-  if(ioctl(fd, SIOCGIFCONF, &ifconf)!=0) {
+  ifconf.ifc_len = sizeof buf;
+  ifconf.ifc_buf = buf;
+  if (ioctl(fd, SIOCGIFCONF, &ifconf) != 0) {
     perror("ioctl(SIOCGIFCONF)");
     exit(EXIT_FAILURE);
   }
@@ -64,73 +76,86 @@ std::map<std::string, std::string> kiwix::getNetworkInterfaces() {
   /* Go through each interface */
   int i;
   size_t len;
-  struct ifreq *ifreq;
+  struct ifreq* ifreq;
   ifreq = ifconf.ifc_req;
-  for (i = 0; i < ifconf.ifc_len; ) {
+  for (i = 0; i < ifconf.ifc_len;) {
     if (ifreq->ifr_addr.sa_family == AF_INET) {
       /* Get the network interface ip */
-      char host[128] = { 0 };
-      const int error = getnameinfo(&(ifreq->ifr_addr), sizeof ifreq->ifr_addr,
-                                    host, sizeof host,
-                                    0, 0, NI_NUMERICHOST);
+      char host[128] = {0};
+      const int error = getnameinfo(&(ifreq->ifr_addr),
+                                    sizeof ifreq->ifr_addr,
+                                    host,
+                                    sizeof host,
+                                    0,
+                                    0,
+                                    NI_NUMERICHOST);
       if (!error) {
         std::string interfaceName = std::string(ifreq->ifr_name);
         std::string interfaceIp = std::string(host);
         /* Add to the map */
-        interfaces.insert(std::pair<std::string, std::string>(interfaceName, interfaceIp));
+        interfaces.insert(
+            std::pair<std::string, std::string>(interfaceName, interfaceIp));
       } else {
         perror("getnameinfo()");
       }
     }
 
-    /* some systems have ifr_addr.sa_len and adjust the length that
-     * way, but not mine. weird */
+/* some systems have ifr_addr.sa_len and adjust the length that
+ * way, but not mine. weird */
 #ifndef __linux__
-    len=IFNAMSIZ + ifreq->ifr_addr.sa_len;
+    len = IFNAMSIZ + ifreq->ifr_addr.sa_len;
 #else
-    len=sizeof *ifreq;
+    len = sizeof *ifreq;
 #endif
-    ifreq=(struct ifreq*)((char*)ifreq+len);
-    i+=len;
+    ifreq = (struct ifreq*)((char*)ifreq + len);
+    i += len;
   }
 #endif
   return interfaces;
 }
 
-std::string kiwix::getBestPublicIp() {
+std::string kiwix::getBestPublicIp()
+{
   std::map<std::string, std::string> interfaces = kiwix::getNetworkInterfaces();
 
 #ifndef _WIN32
-  const char* const prioritizedNames[] =
-      { "eth0", "eth1", "wlan0", "wlan1", "en0", "en1" };
+  const char* const prioritizedNames[]
+      = {"eth0", "eth1", "wlan0", "wlan1", "en0", "en1"};
   const int count = (sizeof prioritizedNames) / (sizeof prioritizedNames[0]);
   for (int i = 0; i < count; ++i) {
-    std::map<std::string, std::string>::const_iterator it =
-        interfaces.find(prioritizedNames[i]);
-    if (it != interfaces.end())
+    std::map<std::string, std::string>::const_iterator it
+        = interfaces.find(prioritizedNames[i]);
+    if (it != interfaces.end()) {
       return it->second;
+    }
   }
 #endif
 
   for (std::map<std::string, std::string>::iterator iter = interfaces.begin();
-      iter != interfaces.end(); ++iter) {
+       iter != interfaces.end();
+       ++iter) {
     std::string interfaceIp = iter->second;
-    if (interfaceIp.length() >= 7 && interfaceIp.substr(0, 7) == "192.168")
+    if (interfaceIp.length() >= 7 && interfaceIp.substr(0, 7) == "192.168") {
       return interfaceIp;
+    }
   }
 
   for (std::map<std::string, std::string>::iterator iter = interfaces.begin();
-      iter != interfaces.end(); ++iter) {
+       iter != interfaces.end();
+       ++iter) {
     std::string interfaceIp = iter->second;
-    if (interfaceIp.length() >= 7 && interfaceIp.substr(0, 7) == "172.16.")
+    if (interfaceIp.length() >= 7 && interfaceIp.substr(0, 7) == "172.16.") {
       return interfaceIp;
+    }
   }
 
   for (std::map<std::string, std::string>::iterator iter = interfaces.begin();
-      iter != interfaces.end(); ++iter) {
+       iter != interfaces.end();
+       ++iter) {
     std::string interfaceIp = iter->second;
-    if (interfaceIp.length() >= 3 && interfaceIp.substr(0, 3) == "10.")
+    if (interfaceIp.length() >= 3 && interfaceIp.substr(0, 3) == "10.") {
       return interfaceIp;
+    }
   }
 
   return "127.0.0.1";

src/common/otherTools.cpp

@@ -19,10 +19,11 @@
 
 #include <common/otherTools.h>
 
-void kiwix::sleep(unsigned int milliseconds) {
+void kiwix::sleep(unsigned int milliseconds)
+{
 #ifdef _WIN32
-      Sleep(milliseconds);
+  Sleep(milliseconds);
 #else
-      usleep(1000 * milliseconds);
+  usleep(1000 * milliseconds);
 #endif
 }

src/common/pathTools.cpp

@@ -20,13 +20,13 @@
 #include <common/pathTools.h>
 
 #ifdef __APPLE__
-#include <mach-o/dyld.h>
 #include <limits.h>
+#include <mach-o/dyld.h>
 #elif _WIN32
+#include <direct.h>
 #include <windows.h>
 #include "shlwapi.h"
-#include <direct.h>
-#define getcwd _getcwd // stupid MSFT "deprecation" warning
+#define getcwd _getcwd  // stupid MSFT "deprecation" warning
 #endif
 
 #ifdef _WIN32
@@ -47,7 +47,8 @@
 #define PATH_MAX 1024
 #endif
 
-bool isRelativePath(const string &path) {
+bool isRelativePath(const string& path)
+{
 #ifdef _WIN32
   return path.empty() || path.substr(1, 2) == ":\\" ? false : true;
 #else
@@ -55,19 +56,21 @@ bool isRelativePath(const string &path) {
 #endif
 }
 
-string computeRelativePath(const string path, const string absolutePath) {
+string computeRelativePath(const string path, const string absolutePath)
+{
   std::vector<std::string> pathParts = kiwix::split(path, SEPARATOR);
-  std::vector<std::string> absolutePathParts = kiwix::split(absolutePath, SEPARATOR);
+  std::vector<std::string> absolutePathParts
+      = kiwix::split(absolutePath, SEPARATOR);
 
   unsigned int commonCount = 0;
-  while (commonCount < pathParts.size() && 
-	 commonCount < absolutePathParts.size() && 
-	 pathParts[commonCount] == absolutePathParts[commonCount]) {
+  while (commonCount < pathParts.size()
+         && commonCount < absolutePathParts.size()
+         && pathParts[commonCount] == absolutePathParts[commonCount]) {
     if (!pathParts[commonCount].empty()) {
       commonCount++;
     }
   }
-  
+
   string relativePath;
 #ifdef _WIN32
   /* On Windows you have a token more because the root is represented
@@ -77,10 +80,10 @@ string computeRelativePath(const string path, const string absolutePath) {
   }
 #endif
 
-  for (unsigned int i = commonCount ; i < pathParts.size() ; i++) {
+  for (unsigned int i = commonCount; i < pathParts.size(); i++) {
     relativePath += "../";
   }
-  for (unsigned int i = commonCount ; i < absolutePathParts.size() ; i++) {
+  for (unsigned int i = commonCount; i < absolutePathParts.size(); i++) {
     relativePath += absolutePathParts[i];
     relativePath += i + 1 < absolutePathParts.size() ? "/" : "";
   }
@@ -89,11 +92,12 @@ string computeRelativePath(const string path, const string absolutePath) {
 }
 
 /* Warning: the relative path must be with slashes */
-string computeAbsolutePath(const string path, const string relativePath) {
+string computeAbsolutePath(const string path, const string relativePath)
+{
   string absolutePath;
 
   if (path.empty()) {
-    char *path=NULL;
+    char* path = NULL;
     size_t size = 0;
 
 #ifdef _WIN32
@@ -104,15 +108,17 @@ string computeAbsolutePath(const string path, const string relativePath) {
 
     absolutePath = string(path) + SEPARATOR;
   } else {
-    absolutePath = path.substr(path.length() - 1, 1) == SEPARATOR ? path : path + SEPARATOR;
+    absolutePath = path.substr(path.length() - 1, 1) == SEPARATOR
+                       ? path
+                       : path + SEPARATOR;
   }
 
 #if _WIN32
-  char *cRelativePath = _strdup(relativePath.c_str());
+  char* cRelativePath = _strdup(relativePath.c_str());
 #else
-  char *cRelativePath = strdup(relativePath.c_str());
+  char* cRelativePath = strdup(relativePath.c_str());
 #endif
-  char *token = strtok(cRelativePath, "/");
+  char* token = strtok(cRelativePath, "/");
 
   while (token != NULL) {
     if (string(token) == "..") {
@@ -121,8 +127,9 @@ string computeAbsolutePath(const string path, const string relativePath) {
     } else if (strcmp(token, ".") && strcmp(token, "")) {
       absolutePath += string(token);
       token = strtok(NULL, "/");
-      if (token != NULL)
-	absolutePath += SEPARATOR;
+      if (token != NULL) {
+        absolutePath += SEPARATOR;
+      }
     } else {
       token = strtok(NULL, "/");
     }
@@ -131,31 +138,38 @@ string computeAbsolutePath(const string path, const string relativePath) {
   return absolutePath;
 }
 
-string removeLastPathElement(const string path, const bool removePreSeparator, const bool removePostSeparator) {
+string removeLastPathElement(const string path,
+                             const bool removePreSeparator,
+                             const bool removePostSeparator)
+{
   string newPath = path;
   size_t offset = newPath.find_last_of(SEPARATOR);
-  if (removePreSeparator && 
+  if (removePreSeparator &&
 #ifndef _WIN32
-      offset != newPath.find_first_of(SEPARATOR) && 
+      offset != newPath.find_first_of(SEPARATOR) &&
 #endif
-      offset == newPath.length()-1) {
+      offset == newPath.length() - 1) {
     newPath = newPath.substr(0, offset);
     offset = newPath.find_last_of(SEPARATOR);
   }
-  newPath = removePostSeparator ? newPath.substr(0, offset) : newPath.substr(0, offset+1);
+  newPath = removePostSeparator ? newPath.substr(0, offset)
+                                : newPath.substr(0, offset + 1);
   return newPath;
 }
 
-string appendToDirectory(const string &directoryPath, const string &filename) {
+string appendToDirectory(const string& directoryPath, const string& filename)
+{
   string newPath = directoryPath + SEPARATOR + filename;
   return newPath;
 }
 
-string getLastPathElement(const string &path) {
+string getLastPathElement(const string& path)
+{
   return path.substr(path.find_last_of(SEPARATOR) + 1);
 }
 
-unsigned int getFileSize(const string &path) {
+unsigned int getFileSize(const string& path)
+{
 #ifdef _WIN32
   struct _stat filestatus;
   _stat(path.c_str(), &filestatus);
@@ -167,12 +181,29 @@ unsigned int getFileSize(const string &path) {
   return filestatus.st_size / 1024;
 }
 
-string getFileSizeAsString(const string &path) {
-  ostringstream convert; convert << getFileSize(path);
+string getFileSizeAsString(const string& path)
+{
+  ostringstream convert;
+  convert << getFileSize(path);
   return convert.str();
 }
 
-bool fileExists(const string &path) {
+string getFileContent(const string& path)
+{
+  std::ifstream f(path, std::ios::in|std::ios::ate);
+  std::string content;
+  if (f.is_open()) {
+    auto size = f.tellg();
+    content.reserve(size);
+    f.seekg(0, std::ios::beg);
+    content.assign((std::istreambuf_iterator<char>(f)),
+                    std::istreambuf_iterator<char>());
+  }
+  return content;
+}
+
+bool fileExists(const string& path)
+{
 #ifdef _WIN32
   return PathFileExists(path.c_str());
 #else
@@ -187,7 +218,8 @@ bool fileExists(const string &path) {
 #endif
 }
 
-bool makeDirectory(const string &path) {
+bool makeDirectory(const string& path)
+{
 #ifdef _WIN32
   int status = _mkdir(path.c_str());
 #else
@@ -196,19 +228,44 @@ bool makeDirectory(const string &path) {
   return status == 0;
 }
 
+string makeTmpDirectory()
+{
+#ifdef _WIN32
+  char cbase[MAX_PATH+1];
+  int base_len = GetTempPath(MAX_PATH+1, cbase);
+  UUID uuid;
+  UuidCreate(&uuid);
+  char* dir_name;
+  UuidToString(&uuid, reinterpret_cast<unsigned char**>(&dir_name));
+  string dir(cbase, base_len);
+  dir += dir_name;
+  _mkdir(dir.c_str());
+  RpcStringFree(reinterpret_cast<unsigned char**>(&dir_name));
+#else
+  string base = "/tmp";
+  auto _template = base + "/kiwix-lib_XXXXXX";
+  char* _template_array = new char[_template.size()+1];
+  memcpy(_template_array, _template.c_str(), _template.size());
+  string dir = mkdtemp(_template_array);
+  delete[] _template_array;
+#endif
+  return dir;
+}
+
 /* Try to create a link and if does not work then make a copy */
-bool copyFile(const string &sourcePath, const string &destPath) {
+bool copyFile(const string& sourcePath, const string& destPath)
+{
   try {
 #ifndef _WIN32
     if (link(sourcePath.c_str(), destPath.c_str()) != 0) {
 #endif
-	std::ifstream infile(sourcePath.c_str(), std::ios_base::binary);
-	std::ofstream outfile(destPath.c_str(), std::ios_base::binary);
-	outfile << infile.rdbuf();
+      std::ifstream infile(sourcePath.c_str(), std::ios_base::binary);
+      std::ofstream outfile(destPath.c_str(), std::ios_base::binary);
+      outfile << infile.rdbuf();
 #ifndef _WIN32
     }
 #endif
-  } catch (exception &e) {
+  } catch (exception& e) {
     cerr << e.what() << endl;
     return false;
   }
@@ -216,18 +273,19 @@ bool copyFile(const string &sourcePath, const string &destPath) {
   return true;
 }
 
-string getExecutablePath() {
+string getExecutablePath()
+{
   char binRootPath[PATH_MAX];
-  
+
 #ifdef _WIN32
-  GetModuleFileName( NULL, binRootPath, PATH_MAX);
+  GetModuleFileName(NULL, binRootPath, PATH_MAX);
   return std::string(binRootPath);
 #elif __APPLE__
   uint32_t max = (uint32_t)PATH_MAX;
   _NSGetExecutablePath(binRootPath, &max);
   return std::string(binRootPath);
 #else
-  ssize_t size =  readlink("/proc/self/exe", binRootPath, PATH_MAX);
+  ssize_t size = readlink("/proc/self/exe", binRootPath, PATH_MAX);
   if (size != -1) {
     return std::string(binRootPath, size);
   }
@@ -236,7 +294,8 @@ string getExecutablePath() {
   return "";
 }
 
-bool writeTextFile(const string &path, const string &content) {
+bool writeTextFile(const string& path, const string& content)
+{
   std::ofstream file;
   file.open(path.c_str());
   file << content;
@@ -244,8 +303,9 @@ bool writeTextFile(const string &path, const string &content) {
   return true;
 }
 
-string getCurrentDirectory() {
-  char* a_cwd = getcwd(NULL,0);
+string getCurrentDirectory()
+{
+  char* a_cwd = getcwd(NULL, 0);
   string s_cwd(a_cwd);
   free(a_cwd);
   return s_cwd;

src/common/regexTools.cpp

@@ -21,10 +21,11 @@
 
 std::map<std::string, RegexMatcher*> regexCache;
 
-RegexMatcher *buildRegex(const std::string &regex) {
-  RegexMatcher *matcher;
+RegexMatcher* buildRegex(const std::string& regex)
+{
+  RegexMatcher* matcher;
   std::map<std::string, RegexMatcher*>::iterator itr = regexCache.find(regex);
-  
+
   /* Regex is in cache */
   if (itr != regexCache.end()) {
     matcher = itr->second;
@@ -42,22 +43,26 @@ RegexMatcher *buildRegex(const std::string &regex) {
 }
 
 /* todo */
-void freeRegexCache() {
+void freeRegexCache()
+{
 }
-
-bool matchRegex(const std::string &content, const std::string &regex) {
+bool matchRegex(const std::string& content, const std::string& regex)
+{
   ucnv_setDefaultName("UTF-8");
   UnicodeString ucontent = UnicodeString(content.c_str());
-  RegexMatcher *matcher = buildRegex(regex);
+  RegexMatcher* matcher = buildRegex(regex);
   matcher->reset(ucontent);
   return matcher->find();
 }
 
-std::string replaceRegex(const std::string &content, const std::string &replacement, const std::string &regex) {
+std::string replaceRegex(const std::string& content,
+                         const std::string& replacement,
+                         const std::string& regex)
+{
   ucnv_setDefaultName("UTF-8");
   UnicodeString ucontent = UnicodeString(content.c_str());
   UnicodeString ureplacement = UnicodeString(replacement.c_str());
-  RegexMatcher *matcher = buildRegex(regex);
+  RegexMatcher* matcher = buildRegex(regex);
   matcher->reset(ucontent);
   UErrorCode status = U_ZERO_ERROR;
   UnicodeString uresult = matcher->replaceAll(ureplacement, status);
@@ -66,16 +71,19 @@ std::string replaceRegex(const std::string &content, const std::string &replacem
   return tmp;
 }
 
-std::string appendToFirstOccurence(const std::string &content, const  std::string regex, const std::string &replacement) {
+std::string appendToFirstOccurence(const std::string& content,
+                                   const std::string regex,
+                                   const std::string& replacement)
+{
   ucnv_setDefaultName("UTF-8");
   UnicodeString ucontent = UnicodeString(content.c_str());
   UnicodeString ureplacement = UnicodeString(replacement.c_str());
-  RegexMatcher *matcher = buildRegex(regex);
+  RegexMatcher* matcher = buildRegex(regex);
   matcher->reset(ucontent);
 
   if (matcher->find()) {
     UErrorCode status = U_ZERO_ERROR;
-    ucontent.insert(matcher->end(status), ureplacement);   
+    ucontent.insert(matcher->end(status), ureplacement);
     std::string tmp;
     ucontent.toUTF8String(tmp);
     return tmp;
@@ -83,4 +91,3 @@ std::string appendToFirstOccurence(const std::string &content, const  std::strin
 
   return content;
 }
-

src/common/stringTools.cpp

@@ -19,32 +19,36 @@
 
 #include <common/stringTools.h>
 
-#include <unicode/translit.h>
 #include <unicode/normlzr.h>
-#include <unicode/ustring.h>
 #include <unicode/rep.h>
-#include <unicode/uniset.h>
+#include <unicode/translit.h>
 #include <unicode/ucnv.h>
+#include <unicode/uniset.h>
+#include <unicode/ustring.h>
 
 /* tell ICU where to find its dat file (tables) */
-void kiwix::loadICUExternalTables() {
+void kiwix::loadICUExternalTables()
+{
 #ifdef __APPLE__
-    std::string executablePath = getExecutablePath();
-    std::string executableDirectory = removeLastPathElement(executablePath);
-    std::string datPath = computeAbsolutePath(executableDirectory, "icudt49l.dat");
-    try {
-        u_setDataDirectory(datPath.c_str());
-    } catch (exception &e) {
-        std::cerr << e.what() << std::endl;
-    }
+  std::string executablePath = getExecutablePath();
+  std::string executableDirectory = removeLastPathElement(executablePath);
+  std::string datPath
+      = computeAbsolutePath(executableDirectory, "icudt49l.dat");
+  try {
+    u_setDataDirectory(datPath.c_str());
+  } catch (exception& e) {
+    std::cerr << e.what() << std::endl;
+  }
 #endif
 }
 
-std::string kiwix::removeAccents(const std::string &text) {
+std::string kiwix::removeAccents(const std::string& text)
+{
   loadICUExternalTables();
   ucnv_setDefaultName("UTF-8");
   UErrorCode status = U_ZERO_ERROR;
-  Transliterator *removeAccentsTrans = Transliterator::createInstance("Lower; NFD; [:M:] remove; NFC", UTRANS_FORWARD, status);
+  Transliterator* removeAccentsTrans = Transliterator::createInstance(
+      "Lower; NFD; [:M:] remove; NFC", UTRANS_FORWARD, status);
   UnicodeString ustring = UnicodeString(text.c_str());
   removeAccentsTrans->transliterate(ustring);
   delete removeAccentsTrans;
@@ -56,7 +60,8 @@ std::string kiwix::removeAccents(const std::string &text) {
 #ifndef __ANDROID__
 
 /* Prepare integer for display */
-std::string kiwix::beautifyInteger(const unsigned int number) {
+std::string kiwix::beautifyInteger(const unsigned int number)
+{
   std::stringstream numberStream;
   numberStream << number;
   std::string numberString = numberStream.str();
@@ -70,148 +75,228 @@ std::string kiwix::beautifyInteger(const unsigned int number) {
   return numberString;
 }
 
-std::string kiwix::beautifyFileSize(const unsigned int number) {
-  if (number > 1024*1024) {
-    return kiwix::beautifyInteger(number/(1024*1024)) + " GB";
+std::string kiwix::beautifyFileSize(const unsigned int number)
+{
+  if (number > 1024 * 1024) {
+    return kiwix::beautifyInteger(number / (1024 * 1024)) + " GB";
   } else {
-    return kiwix::beautifyInteger(number/1024 !=
-				  0 ? number/1024 : 1) + " MB";
+    return kiwix::beautifyInteger(number / 1024 != 0 ? number / 1024 : 1)
+           + " MB";
   }
 }
 
-void kiwix::printStringInHexadecimal(UnicodeString s) {
+void kiwix::printStringInHexadecimal(UnicodeString s)
+{
   std::cout << std::showbase << std::hex;
-  for (int i=0; i<s.length(); i++) {
+  for (int i = 0; i < s.length(); i++) {
     char c = (char)((s.getTerminatedBuffer())[i]);
-    if (c & 0x80)
+    if (c & 0x80) {
       std::cout << (c & 0xffff) << " ";
-    else
+    } else {
       std::cout << c << " ";
+    }
   }
   std::cout << std::endl;
 }
 
-void kiwix::printStringInHexadecimal(const char *s) {
+void kiwix::printStringInHexadecimal(const char* s)
+{
   std::cout << std::showbase << std::hex;
   for (char const* pc = s; *pc; ++pc) {
-    if (*pc & 0x80)
+    if (*pc & 0x80) {
       std::cout << (*pc & 0xffff);
-    else
+    } else {
       std::cout << *pc;
+    }
     std::cout << ' ';
   }
   std::cout << std::endl;
 }
 
-void kiwix::stringReplacement(std::string& str, const std::string& oldStr, const std::string& newStr) {
+void kiwix::stringReplacement(std::string& str,
+                              const std::string& oldStr,
+                              const std::string& newStr)
+{
   size_t pos = 0;
-  while((pos = str.find(oldStr, pos)) != std::string::npos) {
+  while ((pos = str.find(oldStr, pos)) != std::string::npos) {
     str.replace(pos, oldStr.length(), newStr);
     pos += newStr.length();
   }
 }
 
 /* Encode string to avoid XSS attacks */
-std::string kiwix::encodeDiples(const std::string& str) {
+std::string kiwix::encodeDiples(const std::string& str)
+{
   std::string result = str;
   kiwix::stringReplacement(result, "<", "&lt;");
   kiwix::stringReplacement(result, ">", "&gt;");
   return result;
 }
 
-// Urlencode
-//based on javascript encodeURIComponent()
-
-std::string char2hex(char dec) {
-  char dig1 = (dec&0xF0)>>4;
-  char dig2 = (dec&0x0F);
-  if ( 0<= dig1 && dig1<= 9) dig1+=48;    //0,48inascii
-  if (10<= dig1 && dig1<=15) dig1+=97-10; //a,97inascii
-  if ( 0<= dig2 && dig2<= 9) dig2+=48;
-  if (10<= dig2 && dig2<=15) dig2+=97-10;
-
-  std::string r;
-  r.append( &dig1, 1);
-  r.append( &dig2, 1);
-  return r;
-}
-
-std::string kiwix::urlEncode(const std::string &c) {
-  std::string escaped="";
-  int max = c.length();
-  for(int i=0; i<max; i++)
-    {
-      if ( (48 <= c[i] && c[i] <= 57) ||//0-9
-	   (65 <= c[i] && c[i] <= 90) ||//abc...xyz
-	   (97 <= c[i] && c[i] <= 122) || //ABC...XYZ
-	   (c[i]=='~' || c[i]=='!' || c[i]=='*' || c[i]=='(' || c[i]==')' || c[i]=='\'')
-	   )
-        {
-	  escaped.append( &c[i], 1);
-        }
-      else
-        {
-	  escaped.append("%");
-	  escaped.append( char2hex(c[i]) );//converts char 255 to string "ff"
-        }
-    }
-  return escaped;
-}
-
 #endif
 
-static char charFromHex(std::string a) {
-  std::istringstream Blat(a);
-  int Z;
-  Blat >> std::hex >> Z;
-  return char (Z);
+/* urlEncode() based on javascript encodeURI() &
+   encodeURIComponent(). Mostly code from rstudio/httpuv (GPLv3) */
+
+bool isReservedUrlChar(char c)
+{
+  switch (c) {
+  case ';':
+  case ',':
+  case '/':
+  case '?':
+  case ':':
+  case '@':
+  case '&':
+  case '=':
+  case '+':
+  case '$':
+    return true;
+  default:
+    return false;
+  }
 }
 
-std::string kiwix::urlDecode(const std::string &originalUrl) {
-  std::string url = originalUrl;
-  std::string::size_type pos = 0;
-  while ((pos = url.find('%', pos)) != std::string::npos &&
-	 pos + 2 < url.length()) {
-    url.replace(pos, 3, 1, charFromHex(url.substr(pos + 1, 2)));
-    ++pos;
+bool needsEscape(char c, bool encodeReserved)
+{
+  if (c >= 'a' && c <= 'z')
+    return false;
+  if (c >= 'A' && c <= 'Z')
+    return false;
+  if (c >= '0' && c <= '9')
+    return false;
+  if (isReservedUrlChar(c))
+    return encodeReserved;
+  switch (c) {
+  case '-':
+  case '_':
+  case '.':
+  case '!':
+  case '~':
+  case '*':
+  case '\'':
+  case '(':
+  case ')':
+    return false;
   }
-  return url;
+  return true;
+}
+
+int hexToInt(char c) {
+  switch (c) {
+  case '0': return 0;
+  case '1': return 1;
+  case '2': return 2;
+  case '3': return 3;
+  case '4': return 4;
+  case '5': return 5;
+  case '6': return 6;
+  case '7': return 7;
+  case '8': return 8;
+  case '9': return 9;
+  case 'A': case 'a': return 10;
+  case 'B': case 'b': return 11;
+  case 'C': case 'c': return 12;
+  case 'D': case 'd': return 13;
+  case 'E': case 'e': return 14;
+  case 'F': case 'f': return 15;
+  default: return -1;
+  }
+}
+
+std::string kiwix::urlEncode(const std::string& value, bool encodeReserved)
+{
+  std::ostringstream os;
+  os << std::hex << std::uppercase;
+  for (std::string::const_iterator it = value.begin();
+       it != value.end();
+       it++) {
+
+    if (!needsEscape(*it, encodeReserved)) {
+      os << *it;
+    } else {
+      os << '%' << std::setw(2) << static_cast<unsigned int>(static_cast<unsigned char>(*it));
+    }
+  }
+  return os.str();
+}
+
+std::string kiwix::urlDecode(const std::string& value, bool component)
+{
+  std::ostringstream os;
+  for (std::string::const_iterator it = value.begin();
+       it != value.end();
+       it++) {
+
+    // If there aren't enough characters left for this to be a
+    // valid escape code, just use the character and move on
+    if (it > value.end() - 3) {
+      os << *it;
+      continue;
+    }
+
+    if (*it == '%') {
+      char hi = *(++it);
+      char lo = *(++it);
+      int iHi = hexToInt(hi);
+      int iLo = hexToInt(lo);
+      if (iHi < 0 || iLo < 0) {
+	// Invalid escape sequence
+	os << '%' << hi << lo;
+	continue;
+      }
+      char c = (char)(iHi << 4 | iLo);
+      if (!component && isReservedUrlChar(c)) {
+	os << '%' << hi << lo;
+      } else {
+	os << c;
+      }
+    } else {
+      os << *it;
+    }
+  }
+
+  return os.str();
 }
 
 /* Split string in a token array */
-std::vector<std::string> kiwix::split(const std::string & str,
-                                      const std::string & delims=" *-")
+std::vector<std::string> kiwix::split(const std::string& str,
+                                      const std::string& delims = " *-")
 {
   std::string::size_type lastPos = str.find_first_not_of(delims, 0);
   std::string::size_type pos = str.find_first_of(delims, lastPos);
   std::vector<std::string> tokens;
 
-  while (std::string::npos != pos || std::string::npos != lastPos)
-    {
-      tokens.push_back(str.substr(lastPos, pos - lastPos));
-      lastPos = str.find_first_not_of(delims, pos);
-      pos     = str.find_first_of(delims, lastPos);
-    }
+  while (std::string::npos != pos || std::string::npos != lastPos) {
+    tokens.push_back(str.substr(lastPos, pos - lastPos));
+    lastPos = str.find_first_not_of(delims, pos);
+    pos = str.find_first_of(delims, lastPos);
+  }
 
   return tokens;
 }
 
-std::vector<std::string> kiwix::split(const char* lhs, const char* rhs){
-  const std::string m1 (lhs), m2 (rhs);
+std::vector<std::string> kiwix::split(const char* lhs, const char* rhs)
+{
+  const std::string m1(lhs), m2(rhs);
   return split(m1, m2);
 }
 
-std::vector<std::string> kiwix::split(const char* lhs, const std::string& rhs){
+std::vector<std::string> kiwix::split(const char* lhs, const std::string& rhs)
+{
   return split(lhs, rhs.c_str());
 }
 
-std::vector<std::string> kiwix::split(const std::string& lhs, const char* rhs){
+std::vector<std::string> kiwix::split(const std::string& lhs, const char* rhs)
+{
   return split(lhs.c_str(), rhs);
 }
 
-std::string kiwix::ucFirst (const std::string &word) {
-  if (word.empty())
+std::string kiwix::ucFirst(const std::string& word)
+{
+  if (word.empty()) {
     return "";
+  }
 
   std::string result;
 
@@ -223,9 +308,11 @@ std::string kiwix::ucFirst (const std::string &word) {
   return result;
 }
 
-std::string kiwix::ucAll (const std::string &word) {
-  if (word.empty())
+std::string kiwix::ucAll(const std::string& word)
+{
+  if (word.empty()) {
     return "";
+  }
 
   std::string result;
 
@@ -235,9 +322,11 @@ std::string kiwix::ucAll (const std::string &word) {
   return result;
 }
 
-std::string kiwix::lcFirst (const std::string &word) {
-  if (word.empty())
+std::string kiwix::lcFirst(const std::string& word)
+{
+  if (word.empty()) {
     return "";
+  }
 
   std::string result;
 
@@ -249,9 +338,11 @@ std::string kiwix::lcFirst (const std::string &word) {
   return result;
 }
 
-std::string kiwix::lcAll (const std::string &word) {
-  if (word.empty())
+std::string kiwix::lcAll(const std::string& word)
+{
+  if (word.empty()) {
     return "";
+  }
 
   std::string result;
 
@@ -261,9 +352,11 @@ std::string kiwix::lcAll (const std::string &word) {
   return result;
 }
 
-std::string kiwix::toTitle (const std::string &word) {
-  if (word.empty())
+std::string kiwix::toTitle(const std::string& word)
+{
+  if (word.empty()) {
     return "";
+  }
 
   std::string result;
 
@@ -274,6 +367,7 @@ std::string kiwix::toTitle (const std::string &word) {
   return result;
 }
 
-std::string kiwix::normalize (const std::string &word) {
+std::string kiwix::normalize(const std::string& word)
+{
   return kiwix::lcAll(word);
 }

src/downloader.cpp

@@ -0,0 +1,112 @@
+/*
+ * Copyright 2018 Matthieu Gautier <mgautier@kymeria.fr>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU  General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * any later version.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ */
+
+#include "downloader.h"
+#include "common/pathTools.h"
+
+#include <unistd.h>
+#include <iostream>
+
+namespace kiwix
+{
+
+pthread_mutex_t Downloader::globalLock = PTHREAD_MUTEX_INITIALIZER;
+
+
+/* Constructor */
+Downloader::Downloader()
+{
+  aria2::SessionConfig config;
+  config.downloadEventCallback = Downloader::downloadEventCallback;
+  config.userData = this;
+  tmpDir = makeTmpDirectory();
+  aria2::KeyVals options;
+  options.push_back(std::pair<std::string, std::string>("dir", tmpDir));
+  session = aria2::sessionNew(options, config);
+}
+
+
+/* Destructor */
+Downloader::~Downloader()
+{
+  aria2::sessionFinal(session);
+  rmdir(tmpDir.c_str());
+}
+
+
+int Downloader::downloadEventCallback(aria2::Session* session,
+                                      aria2::DownloadEvent event,
+                                      aria2::A2Gid gid,
+                                      void* userData)
+{
+  Downloader* downloader = static_cast<Downloader*>(userData);
+
+  auto fileHandle = downloader->fileHandle;
+  auto dh = aria2::getDownloadHandle(session, gid);
+
+  if (!dh) {
+    return 0;
+  }
+
+  switch (event) {
+    case aria2::EVENT_ON_DOWNLOAD_COMPLETE:
+      {
+        if (dh->getNumFiles() > 0) {
+          auto f = dh->getFile(1);
+          fileHandle->path = f.path;
+          fileHandle->success = true;
+        }
+      }
+      break;
+    case aria2::EVENT_ON_DOWNLOAD_ERROR:
+      {
+        fileHandle->success = false;
+      }
+      break;
+    default:
+      break;
+  }
+  aria2::deleteDownloadHandle(dh);
+  return 0;
+}
+
+DownloadedFile Downloader::download(const std::string& url) {
+  pthread_mutex_lock(&globalLock);
+  DownloadedFile fileHandle;
+  try {
+    std::vector<std::string> uris = {url};
+    aria2::KeyVals options;
+    aria2::A2Gid gid;
+    int ret;
+    DownloadedFile fileHandle;
+    
+    ret = aria2::addUri(session, &gid, uris, options);
+    if (ret < 0) {
+      std::cerr << "Failed to download" << std::endl;
+    } else {
+      this->fileHandle = &fileHandle;
+      aria2::run(session, aria2::RUN_DEFAULT);
+    }
+  } catch (...) {};
+  this->fileHandle = nullptr;
+  pthread_mutex_unlock(&globalLock);
+  return fileHandle;
+}
+
+}

src/entry.cpp

@@ -0,0 +1,138 @@
+/*
+ * Copyright 2011 Emmanuel Engelhart <kelson@kiwix.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU  General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * any later version.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ */
+
+#include "reader.h"
+#include <time.h>
+
+#include <zim/search.h>
+
+namespace kiwix
+{
+
+Entry::Entry(zim::Article article)
+  : article(article)
+{
+}
+
+#define RETURN_IF_INVALID(WHAT) if(!good()) { return (WHAT); }
+
+std::string Entry::getPath() const
+{
+  RETURN_IF_INVALID("");
+  return article.getLongUrl();
+}
+
+std::string Entry::getTitle() const
+{
+  RETURN_IF_INVALID("");
+  return article.getTitle();
+}
+
+std::string Entry::getContent() const
+{
+  RETURN_IF_INVALID("");
+  return article.getData();
+}
+
+zim::Blob Entry::getBlob(offset_type offset) const
+{
+  RETURN_IF_INVALID(zim::Blob());
+  return article.getData(offset);
+}
+
+zim::Blob Entry::getBlob(offset_type offset, size_type size) const
+{
+  RETURN_IF_INVALID(zim::Blob());
+  return article.getData(offset, size);
+}
+
+std::pair<std::string, offset_type> Entry::getDirectAccessInfo() const
+{
+  RETURN_IF_INVALID(std::make_pair("", 0));
+  return article.getDirectAccessInformation();
+}
+
+size_type Entry::getSize() const
+{
+  RETURN_IF_INVALID(0);
+  return article.getArticleSize();
+}
+
+std::string Entry::getMimetype() const
+{
+  RETURN_IF_INVALID("");
+  try {
+    return article.getMimeType();
+  } catch (exception& e) {
+    return "application/octet-stream";
+  }
+}
+
+bool Entry::isRedirect() const
+{
+  RETURN_IF_INVALID(false);
+  return article.isRedirect();
+}
+
+bool Entry::isLinkTarget() const
+{
+  RETURN_IF_INVALID(false);
+  return article.isLinktarget();
+}
+
+bool Entry::isDeleted() const
+{
+  RETURN_IF_INVALID(false);
+  return article.isDeleted();
+}
+
+Entry Entry::getRedirectEntry() const
+{
+  RETURN_IF_INVALID(Entry());
+  if ( !article.isRedirect() ) {
+    throw NoEntry();
+  }
+
+  auto targeted_article = article.getRedirectArticle();
+  if ( !targeted_article.good()) {
+    throw NoEntry();
+  }
+  return targeted_article;
+}
+
+Entry Entry::getFinalEntry() const
+{
+  RETURN_IF_INVALID(Entry());
+  if (final_article.good()) {
+    return final_article;
+  }
+
+  int loopCounter = 42;
+  final_article = article;
+  while (final_article.isRedirect() && loopCounter--) {
+    final_article = final_article.getRedirectArticle();
+    if ( !final_article.good()) {
+      throw NoEntry();
+    }
+  }
+
+  return final_article;
+}
+
+}

src/library.cpp

@@ -19,125 +19,136 @@
 
 #include "library.h"
 
-namespace kiwix {
+namespace kiwix
+{
+/* Constructor */
+Book::Book() : readOnly(false)
+{
+}
+/* Destructor */
+Book::~Book()
+{
+}
+/* Sort functions */
+bool Book::sortByLastOpen(const kiwix::Book& a, const kiwix::Book& b)
+{
+  return atoi(a.last.c_str()) > atoi(b.last.c_str());
+}
 
-  /* Constructor */
-  Book::Book():
-    readOnly(false) {
-  }
-  
-  /* Destructor */
-  Book::~Book() {
-  }
+bool Book::sortByTitle(const kiwix::Book& a, const kiwix::Book& b)
+{
+  return strcmp(a.title.c_str(), b.title.c_str()) < 0;
+}
 
-  /* Sort functions */
-  bool Book::sortByLastOpen(const kiwix::Book &a, const kiwix::Book &b) {
-    return atoi(a.last.c_str()) > atoi(b.last.c_str());
-  }
+bool Book::sortByDate(const kiwix::Book& a, const kiwix::Book& b)
+{
+  return strcmp(a.date.c_str(), b.date.c_str()) > 0;
+}
 
-  bool Book::sortByTitle(const kiwix::Book &a, const kiwix::Book &b) {
-    return strcmp(a.title.c_str(), b.title.c_str()) < 0;
-  }
+bool Book::sortBySize(const kiwix::Book& a, const kiwix::Book& b)
+{
+  return atoi(a.size.c_str()) < atoi(b.size.c_str());
+}
 
-  bool Book::sortByDate(const kiwix::Book &a, const kiwix::Book &b) {
-    return strcmp(a.date.c_str(), b.date.c_str()) > 0;
-  }
+bool Book::sortByPublisher(const kiwix::Book& a, const kiwix::Book& b)
+{
+  return strcmp(a.publisher.c_str(), b.publisher.c_str()) < 0;
+}
 
-  bool Book::sortBySize(const kiwix::Book &a, const kiwix::Book &b) {
-    return atoi(a.size.c_str()) < atoi(b.size.c_str());
-  }
+bool Book::sortByCreator(const kiwix::Book& a, const kiwix::Book& b)
+{
+  return strcmp(a.creator.c_str(), b.creator.c_str()) < 0;
+}
 
-  bool Book::sortByPublisher(const kiwix::Book &a, const kiwix::Book &b) {
-    return strcmp(a.publisher.c_str(), b.publisher.c_str()) < 0;
-  }
+bool Book::sortByLanguage(const kiwix::Book& a, const kiwix::Book& b)
+{
+  return strcmp(a.language.c_str(), b.language.c_str()) < 0;
+}
 
-  bool Book::sortByCreator(const kiwix::Book &a, const kiwix::Book &b) {
-    return strcmp(a.creator.c_str(), b.creator.c_str()) < 0;
-  }
-
-  bool Book::sortByLanguage(const kiwix::Book &a, const kiwix::Book &b) {
-    return strcmp(a.language.c_str(), b.language.c_str()) < 0;
-  }
-
-  std::string Book::getHumanReadableIdFromPath() {
-    std::string id = pathAbsolute;
-    if (!id.empty()) {
-      kiwix::removeAccents(id);
+std::string Book::getHumanReadableIdFromPath()
+{
+  std::string id = pathAbsolute;
+  if (!id.empty()) {
+    kiwix::removeAccents(id);
 
 #ifdef _WIN32
-      id = replaceRegex(id, "", "^.*\\\\");
+    id = replaceRegex(id, "", "^.*\\\\");
 #else
-      id = replaceRegex(id, "", "^.*/");
+    id = replaceRegex(id, "", "^.*/");
 #endif
 
-      id = replaceRegex(id, "", "\\.zim[a-z]*$");
-      id = replaceRegex(id, "_", " ");
-      id = replaceRegex(id, "plus", "\\+");
-    }
-    return id;
+    id = replaceRegex(id, "", "\\.zim[a-z]*$");
+    id = replaceRegex(id, "_", " ");
+    id = replaceRegex(id, "plus", "\\+");
   }
-
-  /* Constructor */
-  Library::Library():
-    version(KIWIX_LIBRARY_VERSION) {
-  }
-  
-  /* Destructor */
-  Library::~Library() {
-  }
-
-  bool Library::addBook(const Book &book) {
-
-    /* Try to find it */
-    std::vector<kiwix::Book>::iterator itr;
-    for ( itr = this->books.begin(); itr != this->books.end(); ++itr ) {
-      if (itr->id == book.id) {
-	if (!itr->readOnly) {
-	  itr->readOnly = book.readOnly;
-	  
-	  if (itr->path.empty())
-	    itr->path = book.path;
-	  
-	  if (itr->pathAbsolute.empty()) 
-	    itr->pathAbsolute = book.pathAbsolute;
-	  
-	  if (itr->url.empty())
-	    itr->url = book.url;
-
-	  if (itr->tags.empty())
-	    itr->tags = book.tags;
-
-	  if (itr->name.empty())
-	    itr->name = book.name;
-	  
-	  if (itr->indexPath.empty()) {
-	    itr->indexPath = book.indexPath;
-	    itr->indexType = book.indexType;
-	  }
-	  
-	  if (itr->indexPathAbsolute.empty()) {
-	    itr->indexPathAbsolute = book.indexPathAbsolute;
-	    itr->indexType = book.indexType;
-	  }
-	  
-	  if (itr->faviconMimeType.empty()) {
-	    itr->favicon = book.favicon;
-	    itr->faviconMimeType = book.faviconMimeType;
-	  }
-	}
-
-	return false;
-      }
-    }
-
-    /* otherwise */
-    this->books.push_back(book);
-    return true;
-  }
-
-  bool Library::removeBookByIndex(const unsigned int bookIndex) {
-    books.erase(books.begin()+bookIndex);
-    return true;
-  }
-
+  return id;
+}
+
+/* Constructor */
+Library::Library() : version(KIWIX_LIBRARY_VERSION)
+{
+}
+/* Destructor */
+Library::~Library()
+{
+}
+bool Library::addBook(const Book& book)
+{
+  /* Try to find it */
+  std::vector<kiwix::Book>::iterator itr;
+  for (itr = this->books.begin(); itr != this->books.end(); ++itr) {
+    if (itr->id == book.id) {
+      if (!itr->readOnly) {
+        itr->readOnly = book.readOnly;
+
+        if (itr->path.empty()) {
+          itr->path = book.path;
+        }
+
+        if (itr->pathAbsolute.empty()) {
+          itr->pathAbsolute = book.pathAbsolute;
+        }
+
+        if (itr->url.empty()) {
+          itr->url = book.url;
+        }
+
+        if (itr->tags.empty()) {
+          itr->tags = book.tags;
+        }
+
+        if (itr->name.empty()) {
+          itr->name = book.name;
+        }
+
+        if (itr->indexPath.empty()) {
+          itr->indexPath = book.indexPath;
+          itr->indexType = book.indexType;
+        }
+
+        if (itr->indexPathAbsolute.empty()) {
+          itr->indexPathAbsolute = book.indexPathAbsolute;
+          itr->indexType = book.indexType;
+        }
+
+        if (itr->faviconMimeType.empty()) {
+          itr->favicon = book.favicon;
+          itr->faviconMimeType = book.faviconMimeType;
+        }
+      }
+
+      return false;
+    }
+  }
+
+  /* otherwise */
+  this->books.push_back(book);
+  return true;
+}
+
+bool Library::removeBookByIndex(const unsigned int bookIndex)
+{
+  books.erase(books.begin() + bookIndex);
+  return true;
+}
 }

src/meson.build

@@ -1,7 +1,10 @@
 kiwix_sources = [
   'library.cpp',
   'manager.cpp',
+  'opds_dumper.cpp',
+  'downloader.cpp',
   'reader.cpp',
+  'entry.cpp',
   'searcher.cpp',
   'common/base64.cpp',
   'common/pathTools.cpp',
@@ -41,4 +44,5 @@ kiwixlib = library('kiwix',
                    dependencies : all_deps,
                    version: meson.project_version(),
                    install: true,
-                   install_dir: install_dir)
+                   install_dir: install_dir,
+                   install_rpath: '$ORIGIN')

src/opds_dumper.cpp

@@ -0,0 +1,135 @@
+/*
+ * Copyright 2017 Matthieu Gautier <mgautier@kymeria.fr>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU  General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * any later version.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ */
+
+#include "opds_dumper.h"
+
+namespace kiwix
+{
+/* Constructor */
+OPDSDumper::OPDSDumper(Library library)
+  : library(library)
+{
+}
+/* Destructor */
+OPDSDumper::~OPDSDumper()
+{
+}
+
+struct xml_string_writer: pugi::xml_writer
+{
+    std::string result;
+
+    virtual void write(const void* data, size_t size)
+    {
+        result.append(static_cast<const char*>(data), size);
+    }
+};
+
+std::string node_to_string(pugi::xml_node node)
+{
+    xml_string_writer writer;
+    node.print(writer, "  ");
+
+    return writer.result;
+}
+
+std::string gen_date_str()
+{
+  auto now = time(0);
+  auto tm = localtime(&now);
+
+  std::stringstream is;
+  is << std::setw(2) << std::setfill('0')
+     << 1900+tm->tm_year << "-"
+     << std::setw(2) << std::setfill('0') << tm->tm_mon << "-"
+     << std::setw(2) << std::setfill('0') << tm->tm_mday << "T"
+     << std::setw(2) << std::setfill('0') << tm->tm_hour << ":"
+     << std::setw(2) << std::setfill('0') << tm->tm_min << ":"
+     << std::setw(2) << std::setfill('0') << tm->tm_sec << "Z";
+  return is.str();
+}
+
+#define ADD_TEXT_ENTRY(node, child, value) (node).append_child((child)).append_child(pugi::node_pcdata).set_value((value).c_str())
+
+pugi::xml_node OPDSDumper::handleBook(Book book, pugi::xml_node root_node) {
+  auto entry_node = root_node.append_child("entry");
+  ADD_TEXT_ENTRY(entry_node, "title", book.title);
+  ADD_TEXT_ENTRY(entry_node, "id", "urn:uuid:"+book.id);
+  ADD_TEXT_ENTRY(entry_node, "icon", rootLocation + "/meta?name=favicon&content=" + book.getHumanReadableIdFromPath());
+  ADD_TEXT_ENTRY(entry_node, "updated", date);
+  ADD_TEXT_ENTRY(entry_node, "summary", book.description);
+
+  auto content_node = entry_node.append_child("link");
+  content_node.append_attribute("type") = "text/html";
+  content_node.append_attribute("href") = (rootLocation + "/" + book.getHumanReadableIdFromPath()).c_str();
+
+  auto author_node = entry_node.append_child("author");
+  ADD_TEXT_ENTRY(author_node, "name", book.creator);
+
+  if (! book.url.empty()) {
+    auto acquisition_link = entry_node.append_child("link");
+    acquisition_link.append_attribute("rel") = "http://opds-spec.org/acquisition/open-access";
+    acquisition_link.append_attribute("type") = "application/x-zim";
+    acquisition_link.append_attribute("href") = book.url.c_str();
+  }
+
+  if (! book.faviconMimeType.empty() ) {
+    auto image_link = entry_node.append_child("link");
+    image_link.append_attribute("rel") = "http://opds-spec.org/image/thumbnail";
+    image_link.append_attribute("type") = book.faviconMimeType.c_str();
+    image_link.append_attribute("href") = (rootLocation + "/meta?name=favicon&content=" + book.getHumanReadableIdFromPath()).c_str();
+  }
+  return entry_node;
+}
+
+string OPDSDumper::dumpOPDSFeed()
+{
+  date = gen_date_str();
+  pugi::xml_document doc;
+
+  auto root_node = doc.append_child("feed");
+  root_node.append_attribute("xmlns") = "http://www.w3.org/2005/Atom";
+  root_node.append_attribute("xmlns:opds") = "http://opds-spec.org/2010/catalog";
+
+  ADD_TEXT_ENTRY(root_node, "id", id);
+
+  ADD_TEXT_ENTRY(root_node, "title", title);
+  ADD_TEXT_ENTRY(root_node, "updated", date);
+
+  auto self_link_node = root_node.append_child("link");
+  self_link_node.append_attribute("rel") = "self";
+  self_link_node.append_attribute("href") = "";
+  self_link_node.append_attribute("type") = "application/atom+xml";
+
+
+  if (!searchDescriptionUrl.empty() ) {
+    auto search_link = root_node.append_child("link");
+    search_link.append_attribute("rel") = "search";
+    search_link.append_attribute("type") = "application/opensearchdescription+xml";
+    search_link.append_attribute("href") = searchDescriptionUrl.c_str();
+  }
+
+  for (auto book: library.books) {
+    handleBook(book, root_node);
+  }
+
+  return node_to_string(root_node);
+}
+
+}

src/searcher.cpp

@@ -17,10 +17,13 @@
  * MA 02110-1301, USA.
  */
 
+
+#include <cmath>
+
 #include "searcher.h"
-#include "xapianSearcher.h"
-#include "reader.h"
 #include "kiwixlib-resources.h"
+#include "reader.h"
+#include "xapianSearcher.h"
 
 #include <zim/search.h>
 
@@ -33,268 +36,430 @@
 using namespace CTPP;
 #endif
 
+#define MAX_SEARCH_LEN 140
 
-namespace kiwix {
+namespace kiwix
+{
+class _Result : public Result
+{
+ public:
+  _Result(zim::Search::iterator& iterator);
+  virtual ~_Result(){};
 
-  class _Result : public Result {
-    public:
-      _Result(Searcher* searcher, zim::Search::iterator& iterator);
-      virtual ~_Result() {};
+  virtual std::string get_url();
+  virtual std::string get_title();
+  virtual int get_score();
+  virtual std::string get_snippet();
+  virtual std::string get_content();
+  virtual int get_wordCount();
+  virtual int get_size();
+  virtual int get_readerIndex();
 
-      virtual std::string get_url();
-      virtual std::string get_title();
-      virtual int get_score();
-      virtual std::string get_snippet();
-      virtual int get_wordCount();
-      virtual int get_size();
+ private:
+  zim::Search::iterator iterator;
+};
 
-    private:
-      Searcher* searcher;
-      zim::Search::iterator iterator;
-  };
+struct SearcherInternal {
+  const zim::Search* _search;
+  XapianSearcher* _xapianSearcher;
+  zim::Search::iterator current_iterator;
 
-  struct SearcherInternal {
-    const zim::Search *_search;
-    XapianSearcher *_xapianSearcher;
-    zim::Search::iterator current_iterator;
-
-
-    SearcherInternal() :
-      _search(NULL),
-      _xapianSearcher(NULL)
-    {}
-    ~SearcherInternal() {
-        if ( _search != NULL )
-            delete _search;
-        if ( _xapianSearcher != NULL )
-            delete _xapianSearcher;
-    }
-
-  };
-
-  /* Constructor */
-  Searcher::Searcher(const string &xapianDirectoryPath, Reader* reader) :
-    reader(reader),
-    internal(new SearcherInternal()),
-    searchPattern(""),
-    protocolPrefix("zim://"),
-    searchProtocolPrefix("search://?"),
-    resultCountPerPage(0),
-    estimatedResultCount(0),
-    resultStart(0),
-    resultEnd(0)
+  SearcherInternal() : _search(NULL), _xapianSearcher(NULL) {}
+  ~SearcherInternal()
   {
-    template_ct2 = RESOURCE::results_ct2;
-    loadICUExternalTables();
-    if ( !reader || !reader->hasFulltextIndex() ) {
-        internal->_xapianSearcher = new XapianSearcher(xapianDirectoryPath, reader);
+    if (_search != NULL) {
+      delete _search;
+    }
+    if (_xapianSearcher != NULL) {
+      delete _xapianSearcher;
     }
   }
-  
-  /* Destructor */
-  Searcher::~Searcher() {
-      delete internal;
+};
+
+/* Constructor */
+Searcher::Searcher(const string& xapianDirectoryPath,
+                   Reader* reader,
+                   const string& humanReadableName)
+    : internal(new SearcherInternal()),
+      searchPattern(""),
+      protocolPrefix("zim://"),
+      searchProtocolPrefix("search://?"),
+      resultCountPerPage(0),
+      estimatedResultCount(0),
+      resultStart(0),
+      resultEnd(0),
+      contentHumanReadableId(humanReadableName)
+{
+  loadICUExternalTables();
+  if (!reader || !reader->hasFulltextIndex()) {
+    internal->_xapianSearcher = new XapianSearcher(xapianDirectoryPath, reader);
   }
-  
-  /* Search strings in the database */
-  void Searcher::search(std::string &search, unsigned int resultStart,
-			unsigned int resultEnd, const bool verbose) {
-    this->reset();
+  this->humanReaderNames.push_back(humanReadableName);
+}
 
-    if (verbose == true) {
-      cout << "Performing query `" << search << "'" << endl;
-    }
+Searcher::Searcher(const std::string& humanReadableName)
+    : internal(new SearcherInternal()),
+      searchPattern(""),
+      protocolPrefix("zim://"),
+      searchProtocolPrefix("search://?"),
+      resultCountPerPage(0),
+      estimatedResultCount(0),
+      resultStart(0),
+      resultEnd(0),
+      contentHumanReadableId(humanReadableName)
+{
+  loadICUExternalTables();
+}
 
-    /* If resultEnd & resultStart inverted */
-    if (resultStart > resultEnd) {
-      resultEnd += resultStart;
-      resultStart = resultEnd - resultStart;
-      resultEnd -= resultStart; 
-    }
+/* Destructor */
+Searcher::~Searcher()
+{
+  delete internal;
+}
 
-    /* Try to find results */
-    if (resultStart != resultEnd) {
+bool Searcher::add_reader(Reader* reader, const std::string& humanReadableName)
+{
+  if (!reader->hasFulltextIndex()) {
+      return false;
+  }
+  this->readers.push_back(reader);
+  this->humanReaderNames.push_back(humanReadableName);
+  return true;
+}
 
-      /* Avoid big researches */
-      this->resultCountPerPage = resultEnd - resultStart;
-      if (this->resultCountPerPage > 70) {
-	resultEnd = resultStart + 70;
-	this->resultCountPerPage = 70;
-      }
+/* Search strings in the database */
+void Searcher::search(std::string& search,
+                      unsigned int resultStart,
+                      unsigned int resultEnd,
+                      const bool verbose)
+{
+  this->reset();
 
-      /* Perform the search */
-      this->searchPattern = search;
-      this->resultStart = resultStart;
-      this->resultEnd = resultEnd;
-      string unaccentedSearch = removeAccents(search);
-      if ( internal->_xapianSearcher ) {
-        internal->_xapianSearcher->searchInIndex(unaccentedSearch, resultStart, resultEnd, verbose);
-        this->estimatedResultCount = internal->_xapianSearcher->results.get_matches_estimated();
-      } else {
-        internal->_search = this->reader->getZimFileHandler()->search(unaccentedSearch, resultStart, resultEnd);
-        internal->current_iterator = internal->_search->begin();
-        this->estimatedResultCount = internal->_search->get_matches_estimated();
-      }
-    }
-
-    return;
+  if (verbose == true) {
+    cout << "Performing query `" << search << "'" << endl;
   }
 
-  void Searcher::restart_search() {
-    if ( internal->_xapianSearcher ) {
-      internal->_xapianSearcher->restart_search();
+  /* If resultEnd & resultStart inverted */
+  if (resultStart > resultEnd) {
+    resultEnd += resultStart;
+    resultStart = resultEnd - resultStart;
+    resultEnd -= resultStart;
+  }
+
+  /* Try to find results */
+  if (resultStart != resultEnd) {
+    /* Avoid big researches */
+    this->resultCountPerPage = resultEnd - resultStart;
+    if (this->resultCountPerPage > MAX_SEARCH_LEN) {
+      resultEnd = resultStart + MAX_SEARCH_LEN;
+      this->resultCountPerPage = MAX_SEARCH_LEN;
+    }
+
+    /* Perform the search */
+    this->searchPattern = search;
+    this->resultStart = resultStart;
+    this->resultEnd = resultEnd;
+    string unaccentedSearch = removeAccents(search);
+    if (internal->_xapianSearcher) {
+      internal->_xapianSearcher->searchInIndex(
+          unaccentedSearch, resultStart, resultEnd, verbose);
+      this->estimatedResultCount
+          = internal->_xapianSearcher->results.get_matches_estimated();
     } else {
+      std::vector<const zim::File*> zims;
+      for (auto current = this->readers.begin(); current != this->readers.end();
+           current++) {
+        if ( (*current)->hasFulltextIndex() ) {
+            zims.push_back((*current)->getZimFileHandler());
+        }
+      }
+      zim::Search* search = new zim::Search(zims);
+      search->set_query(unaccentedSearch);
+      search->set_range(resultStart, resultEnd);
+      internal->_search = search;
       internal->current_iterator = internal->_search->begin();
+      this->estimatedResultCount = internal->_search->get_matches_estimated();
     }
   }
 
-  Result* Searcher::getNextResult() {
-    if ( internal->_xapianSearcher ) {
-      return internal->_xapianSearcher->getNextResult();
-    } else if (internal->current_iterator != internal->_search->end()) {
-      Result* result = new _Result(this, internal->current_iterator);
-      internal->current_iterator++;
-      return result;
-    }
-    return NULL;
+  return;
+}
+
+
+void Searcher::geo_search(float latitude, float longitude, float distance,
+                          unsigned int resultStart,
+                          unsigned int resultEnd,
+                          const bool verbose)
+{
+  this->reset();
+
+  if (verbose == true) {
+    cout << "Performing geo query `" << distance << "&(" << latitude << ";" << longitude << ")'" << endl;
   }
 
+  /* If resultEnd & resultStart inverted */
+  if (resultStart > resultEnd) {
+    resultEnd += resultStart;
+    resultStart = resultEnd - resultStart;
+    resultEnd -= resultStart;
+  }
 
-  /* Reset the results */
-  void Searcher::reset() {
-    this->estimatedResultCount = 0;
-    this->searchPattern = "";
+  /* Try to find results */
+  if (resultStart == resultEnd) {
     return;
   }
 
-  /* Return the result count estimation */
-  unsigned int Searcher::getEstimatedResultCount() {
-    return this->estimatedResultCount;
+  if (internal->_xapianSearcher) {
+    return;
   }
 
-  bool Searcher::setProtocolPrefix(const std::string prefix) {
-    this->protocolPrefix = prefix;
-    return true;
+  /* Avoid big researches */
+  this->resultCountPerPage = resultEnd - resultStart;
+  if (this->resultCountPerPage > MAX_SEARCH_LEN) {
+    resultEnd = resultStart + MAX_SEARCH_LEN;
+    this->resultCountPerPage = MAX_SEARCH_LEN;
   }
 
-  bool Searcher::setSearchProtocolPrefix(const std::string prefix) {
-    this->searchProtocolPrefix = prefix;
-    return true;
+  /* Perform the search */
+  std::ostringstream oss;
+  oss << "Articles located less than " << distance << " meters of " << latitude << ";" << longitude;
+  this->searchPattern = oss.str();
+  this->resultStart = resultStart;
+  this->resultEnd = resultEnd;
+
+  std::vector<const zim::File*> zims;
+  for (auto current = this->readers.begin(); current != this->readers.end();
+       current++) {
+    zims.push_back((*current)->getZimFileHandler());
+  }
+  zim::Search* search = new zim::Search(zims);
+  search->set_query("");
+  search->set_georange(latitude, longitude, distance);
+  search->set_range(resultStart, resultEnd);
+  internal->_search = search;
+  internal->current_iterator = internal->_search->begin();
+  this->estimatedResultCount = internal->_search->get_matches_estimated();
+}
+
+
+void Searcher::restart_search()
+{
+  if (internal->_xapianSearcher) {
+    internal->_xapianSearcher->restart_search();
+  } else if (internal->_search) {
+    internal->current_iterator = internal->_search->begin();
+  }
+}
+
+Result* Searcher::getNextResult()
+{
+  if (internal->_xapianSearcher) {
+    return internal->_xapianSearcher->getNextResult();
+  } else if (internal->_search &&
+             internal->current_iterator != internal->_search->end()) {
+    Result* result = new _Result(internal->current_iterator);
+    internal->current_iterator++;
+    return result;
+  }
+  return NULL;
+}
+
+/* Reset the results */
+void Searcher::reset()
+{
+  this->estimatedResultCount = 0;
+  this->searchPattern = "";
+  return;
+}
+
+void Searcher::suggestions(std::string& search, const bool verbose)
+{
+  this->reset();
+
+  if (verbose == true) {
+    cout << "Performing suggestion query `" << search << "`" << endl;
   }
 
-  void Searcher::setContentHumanReadableId(const string &contentHumanReadableId) {
-    this->contentHumanReadableId = contentHumanReadableId;
-  }
+  this->searchPattern = search;
+  this->resultStart = 0;
+  this->resultEnd = 10;
+  string unaccentedSearch = removeAccents(search);
 
-  _Result::_Result(Searcher* searcher, zim::Search::iterator& iterator):
-    searcher(searcher),
-    iterator(iterator)
-  {
+  if (internal->_xapianSearcher) {
+    /* [TODO] Suggestion on a external database ?
+     * We do not support that. */
+    this->estimatedResultCount = 0;
+  } else {
+    std::vector<const zim::File*> zims;
+    for (auto current = this->readers.begin(); current != this->readers.end();
+         current++) {
+      zims.push_back((*current)->getZimFileHandler());
+    }
+    zim::Search* search = new zim::Search(zims);
+    search->set_query(unaccentedSearch);
+    search->set_range(resultStart, resultEnd);
+    search->set_suggestion_mode(true);
+    internal->_search = search;
+    internal->current_iterator = internal->_search->begin();
+    this->estimatedResultCount = internal->_search->get_matches_estimated();
   }
+}
 
-  std::string _Result::get_url() {
-    return iterator.get_url();
+/* Return the result count estimation */
+unsigned int Searcher::getEstimatedResultCount()
+{
+  return this->estimatedResultCount;
+}
+
+bool Searcher::setProtocolPrefix(const std::string prefix)
+{
+  this->protocolPrefix = prefix;
+  return true;
+}
+
+bool Searcher::setSearchProtocolPrefix(const std::string prefix)
+{
+  this->searchProtocolPrefix = prefix;
+  return true;
+}
+
+_Result::_Result(zim::Search::iterator& iterator)
+    : iterator(iterator)
+{
+}
+
+std::string _Result::get_url()
+{
+  return iterator.get_url();
+}
+std::string _Result::get_title()
+{
+  return iterator.get_title();
+}
+int _Result::get_score()
+{
+  return iterator.get_score();
+}
+std::string _Result::get_snippet()
+{
+  return iterator.get_snippet();
+}
+std::string _Result::get_content()
+{
+  if (iterator->good()) {
+    return iterator->getData();
   }
-
-  std::string _Result::get_title() {
-    return iterator.get_title();
-  }
-
-  int _Result::get_score() {
-    return iterator.get_score();
-  }
-
-  std::string _Result::get_snippet() {
-    return iterator.get_snippet();
-  }
-
-  int _Result::get_size() {
-      return iterator.get_size();
-  }
-
-  int _Result::get_wordCount() {
-      return iterator.get_wordCount();
-  }
-
+  return "";
+}
+int _Result::get_size()
+{
+  return iterator.get_size();
+}
+int _Result::get_wordCount()
+{
+  return iterator.get_wordCount();
+}
+int _Result::get_readerIndex()
+{
+  return iterator.get_fileIndex();
+}
 #ifdef ENABLE_CTPP2
-  
-  string Searcher::getHtml() {
 
-    SimpleVM oSimpleVM;
+string Searcher::getHtml()
+{
+  SimpleVM oSimpleVM(
+      1024, //iIMaxFunctions (default value)
+      4096, //iIMaxArgStackSize (default value)
+      4096, //iIMaxCodeStackSize (default value)
+      10240 * 2 //iIMaxSteps (default*2)
+  );
 
-    // Fill data
-    CDT oData;
-    CDT resultsCDT(CDT::ARRAY_VAL);
+  // Fill data
+  CDT oData;
+  CDT resultsCDT(CDT::ARRAY_VAL);
 
-    this->restart_search();
-    Result * p_result = NULL;
-    while ( (p_result = this->getNextResult()) ) {
-      CDT result;
-      result["title"] = p_result->get_title();
-      result["url"] = p_result->get_url();
-      result["snippet"] = p_result->get_snippet();
+  this->restart_search();
+  Result* p_result = NULL;
+  while ((p_result = this->getNextResult())) {
+    CDT result;
+    result["title"] = p_result->get_title();
+    result["url"] = p_result->get_url();
+    result["snippet"] = p_result->get_snippet();
+    result["contentId"] = humanReaderNames[p_result->get_readerIndex()];
 
-      if (p_result->get_size() >= 0)
-        result["size"] = kiwix::beautifyInteger(p_result->get_size());
-
-      if (p_result->get_wordCount() >= 0)
-        result["wordCount"] = kiwix::beautifyInteger(p_result->get_wordCount());
-
-      resultsCDT.PushBack(result);
-      delete p_result;
+    if (p_result->get_size() >= 0) {
+      result["size"] = kiwix::beautifyInteger(p_result->get_size());
     }
-    this->restart_search();
-    oData["results"] = resultsCDT;
 
-    // pages
-    CDT pagesCDT(CDT::ARRAY_VAL);
-
-    unsigned int pageStart = this->resultStart / this->resultCountPerPage >= 5 ? this->resultStart / this->resultCountPerPage - 4 : 0;
-    unsigned int pageCount = this->estimatedResultCount / this->resultCountPerPage + 1 - pageStart;
-
-    if (pageCount > 10)
-      pageCount = 10;
-    else if (pageCount == 1)
-      pageCount = 0;
-
-    for (unsigned int i=pageStart; i<pageStart+pageCount; i++) {
-      CDT page;
-      page["label"] = i + 1;
-      page["start"] = i * this->resultCountPerPage;
-      page["end"] = (i+1) * this->resultCountPerPage;
-
-      if (i * this->resultCountPerPage == this->resultStart)
-    page["selected"] = true;
-
-      pagesCDT.PushBack(page);
+    if (p_result->get_wordCount() >= 0) {
+      result["wordCount"] = kiwix::beautifyInteger(p_result->get_wordCount());
     }
-    oData["pages"] = pagesCDT;
-
-    oData["count"] = kiwix::beautifyInteger(this->estimatedResultCount);
-    oData["searchPattern"] = kiwix::encodeDiples(this->searchPattern);
-    oData["searchPatternEncoded"] = urlEncode(this->searchPattern);
-    oData["resultStart"] = this->resultStart + 1;
-    oData["resultEnd"] = (this->resultEnd > this->estimatedResultCount ? this->estimatedResultCount : this->resultEnd);
-    oData["resultRange"] = this->resultCountPerPage;
-    oData["resultLastPageStart"] = this->estimatedResultCount > this->resultCountPerPage ? this->estimatedResultCount - this->resultCountPerPage : 0;
-    oData["protocolPrefix"] = this->protocolPrefix;
-    oData["searchProtocolPrefix"] = this->searchProtocolPrefix;
-    oData["contentId"] = this->contentHumanReadableId;
-
-    VMStringLoader oLoader(template_ct2.c_str(), template_ct2.size());
-
-    FileLogger oLogger(stderr);
-
-    // DEBUG only (write output to stdout)
-    // oSimpleVM.Run(oData, oLoader, stdout, oLogger);
-
-    std::string sResult;
-    oSimpleVM.Run(oData, oLoader, sResult, oLogger);
-
-    return sResult;
 
+    resultsCDT.PushBack(result);
+    delete p_result;
   }
+  this->restart_search();
+  oData["results"] = resultsCDT;
+
+  // pages
+  CDT pagesCDT(CDT::ARRAY_VAL);
+
+  unsigned int pageStart
+      = this->resultStart / this->resultCountPerPage >= 5
+            ? this->resultStart / this->resultCountPerPage - 4
+            : 0;
+  unsigned int pageCount
+      = this->estimatedResultCount / this->resultCountPerPage + 1 - pageStart;
+
+  if (pageCount > 10) {
+    pageCount = 10;
+  } else if (pageCount == 1) {
+    pageCount = 0;
+  }
+
+  for (unsigned int i = pageStart; i < pageStart + pageCount; i++) {
+    CDT page;
+    page["label"] = i + 1;
+    page["start"] = i * this->resultCountPerPage;
+    page["end"] = (i + 1) * this->resultCountPerPage;
+
+    if (i * this->resultCountPerPage == this->resultStart) {
+      page["selected"] = true;
+    }
+
+    pagesCDT.PushBack(page);
+  }
+  oData["pages"] = pagesCDT;
+
+  oData["count"] = kiwix::beautifyInteger(this->estimatedResultCount);
+  oData["searchPattern"] = kiwix::encodeDiples(this->searchPattern);
+  oData["searchPatternEncoded"] = urlEncode(this->searchPattern);
+  oData["resultStart"] = this->resultStart + 1;
+  oData["resultEnd"] = (this->resultEnd > this->estimatedResultCount
+                            ? this->estimatedResultCount
+                            : this->resultEnd);
+  oData["resultRange"] = this->resultCountPerPage;
+  oData["resultLastPageStart"]
+      = this->estimatedResultCount > this->resultCountPerPage
+            ? std::round(this->estimatedResultCount / this->resultCountPerPage) * this->resultCountPerPage
+            : 0;
+  oData["protocolPrefix"] = this->protocolPrefix;
+  oData["searchProtocolPrefix"] = this->searchProtocolPrefix;
+  oData["contentId"] = this->contentHumanReadableId;
+
+  std::string template_ct2 = RESOURCE::results_ct2;
+  VMStringLoader oLoader(template_ct2.c_str(), template_ct2.size());
+
+  FileLogger oLogger(stderr);
+
+  // DEBUG only (write output to stdout)
+  // oSimpleVM.Run(oData, oLoader, stdout, oLogger);
+
+  std::string sResult;
+  oSimpleVM.Run(oData, oLoader, sResult, oLogger);
+
+  return sResult;
+}
 
 #endif
-
 }

src/xapian/myhtmlparse.h

@@ -40,6 +40,7 @@ class MyHtmlParser : public HtmlParser {
 	void process_text(const string &text);
 	void opening_tag(const string &tag);
 	void closing_tag(const string &tag);
+        using HtmlParser::parse_html;
 	void parse_html(const string &text, const string &charset_,
 			bool charset_from_meta_);
 	MyHtmlParser() :

src/xapianSearcher.cpp

@@ -18,196 +18,212 @@
  */
 
 #include "xapianSearcher.h"
-#include "xapian/myhtmlparse.h"
-#include <zim/zim.h>
-#include <zim/file.h>
+#include <sys/types.h>
+#include <unicode/locid.h>
+#include <unistd.h>
 #include <zim/article.h>
 #include <zim/error.h>
-#include <sys/types.h>
-#include <unistd.h>
-#include <unicode/locid.h>
+#include <zim/file.h>
+#include <zim/zim.h>
+#include "xapian/myhtmlparse.h"
 
 #include <vector>
 
-namespace kiwix {
-
-std::map<std::string, int> read_valuesmap(const std::string &s) {
-    std::map<std::string, int> result;
-    std::vector<std::string> elems = split(s, ";");
-    for(std::vector<std::string>::iterator elem = elems.begin();
-        elem != elems.end();
-        elem++)
-    {
-        std::vector<std::string> tmp_elems = split(*elem, ":");
-        result.insert( std::pair<std::string, int>(tmp_elems[0], atoi(tmp_elems[1].c_str())) );
-    }
-    return result;
+namespace kiwix
+{
+std::map<std::string, int> read_valuesmap(const std::string& s)
+{
+  std::map<std::string, int> result;
+  std::vector<std::string> elems = split(s, ";");
+  for (std::vector<std::string>::iterator elem = elems.begin();
+       elem != elems.end();
+       elem++) {
+    std::vector<std::string> tmp_elems = split(*elem, ":");
+    result.insert(
+        std::pair<std::string, int>(tmp_elems[0], atoi(tmp_elems[1].c_str())));
+  }
+  return result;
 }
 
-  /* Constructor */
-  XapianSearcher::XapianSearcher(const string &xapianDirectoryPath, Reader* reader)
+/* Constructor */
+XapianSearcher::XapianSearcher(const string& xapianDirectoryPath,
+                               Reader* reader)
     : reader(reader)
-  {
-    this->openIndex(xapianDirectoryPath);
-  }
+{
+  this->openIndex(xapianDirectoryPath);
+}
 
-  /* Open Xapian readable database */
-  void XapianSearcher::openIndex(const string &directoryPath) {
-    this->readableDatabase = Xapian::Database(directoryPath);
-    this->valuesmap = read_valuesmap(this->readableDatabase.get_metadata("valuesmap"));
-    this->language = this->readableDatabase.get_metadata("language");
-    this->stopwords = this->readableDatabase.get_metadata("stopwords");
-    setup_queryParser();
-  }
-  
-  /* Close Xapian writable database */
-  void XapianSearcher::closeIndex() {
-    return;
-  }
+/* Open Xapian readable database */
+void XapianSearcher::openIndex(const string& directoryPath)
+{
+  this->readableDatabase = Xapian::Database(directoryPath);
+  this->valuesmap
+      = read_valuesmap(this->readableDatabase.get_metadata("valuesmap"));
+  this->language = this->readableDatabase.get_metadata("language");
+  this->stopwords = this->readableDatabase.get_metadata("stopwords");
+  setup_queryParser();
+}
 
-  void XapianSearcher::setup_queryParser()
-  {
-    queryParser.set_database(readableDatabase);
-    if ( ! language.empty() )
-    {
-        /* Build ICU Local object to retrieve ISO-639 language code (from
-           ISO-639-3) */
-        icu::Locale languageLocale(language.c_str());
+/* Close Xapian writable database */
+void XapianSearcher::closeIndex()
+{
+  return;
+}
+void XapianSearcher::setup_queryParser()
+{
+  queryParser.set_database(readableDatabase);
+  if (!language.empty()) {
+    /* Build ICU Local object to retrieve ISO-639 language code (from
+       ISO-639-3) */
+    icu::Locale languageLocale(language.c_str());
 
-        /* Configuring language base steemming */
-        try {
-          stemmer = Xapian::Stem(languageLocale.getLanguage());
-          queryParser.set_stemmer(stemmer);
-          queryParser.set_stemming_strategy(Xapian::QueryParser::STEM_ALL);
-        } catch (...) {
-          std::cout << "No steemming for language '" << languageLocale.getLanguage() << "'" << std::endl;
-        }
-    }
-
-    if ( ! stopwords.empty() )
-    {
-        std::string stopWord;
-        std::istringstream file(this->stopwords);
-        while (std::getline(file, stopWord, '\n')) {
-          this->stopper.add(stopWord);
-        }
-        queryParser.set_stopper(&(this->stopper));
+    /* Configuring language base steemming */
+    try {
+      stemmer = Xapian::Stem(languageLocale.getLanguage());
+      queryParser.set_stemmer(stemmer);
+      queryParser.set_stemming_strategy(Xapian::QueryParser::STEM_ALL);
+    } catch (...) {
+      std::cout << "No steemming for language '" << languageLocale.getLanguage()
+                << "'" << std::endl;
     }
   }
-  
-  /* Search strings in the database */
-  void XapianSearcher::searchInIndex(string &search, const unsigned int resultStart, 
-				     const unsigned int resultEnd, const bool verbose) {
-    /* Create the query */
-    Xapian::Query query = queryParser.parse_query(search);    
 
-    /* Create the enquire object */
-    Xapian::Enquire enquire(this->readableDatabase);
-    enquire.set_query(query);
-
-    /* Get the results */
-    this->results = enquire.get_mset(resultStart, resultEnd - resultStart);
-    this->current_result = this->results.begin();
-  }
-
-  /* Get next result */
-  Result* XapianSearcher::getNextResult() {
-    if (this->current_result != this->results.end()) {
-      XapianResult* result = new XapianResult(this, this->current_result);
-      this->current_result++;
-      return result;
+  if (!stopwords.empty()) {
+    std::string stopWord;
+    std::istringstream file(this->stopwords);
+    while (std::getline(file, stopWord, '\n')) {
+      this->stopper.add(stopWord);
     }
-    return NULL;
+    queryParser.set_stopper(&(this->stopper));
   }
+}
 
-  void XapianSearcher::restart_search() {
-    this->current_result = this->results.begin();
+/* Search strings in the database */
+void XapianSearcher::searchInIndex(string& search,
+                                   const unsigned int resultStart,
+                                   const unsigned int resultEnd,
+                                   const bool verbose)
+{
+  /* Create the query */
+  Xapian::Query query = queryParser.parse_query(search);
+
+  /* Create the enquire object */
+  Xapian::Enquire enquire(this->readableDatabase);
+  enquire.set_query(query);
+
+  /* Get the results */
+  this->results = enquire.get_mset(resultStart, resultEnd - resultStart);
+  this->current_result = this->results.begin();
+}
+
+/* Get next result */
+Result* XapianSearcher::getNextResult()
+{
+  if (this->current_result != this->results.end()) {
+    XapianResult* result = new XapianResult(this, this->current_result);
+    this->current_result++;
+    return result;
   }
+  return NULL;
+}
 
-  XapianResult::XapianResult(XapianSearcher* searcher, Xapian::MSetIterator& iterator):
-    searcher(searcher),
-    iterator(iterator),
-    document(iterator.get_document())
-  {
+void XapianSearcher::restart_search()
+{
+  this->current_result = this->results.begin();
+}
+
+XapianResult::XapianResult(XapianSearcher* searcher,
+                           Xapian::MSetIterator& iterator)
+    : searcher(searcher), iterator(iterator), document(iterator.get_document())
+{
+}
+
+std::string XapianResult::get_url()
+{
+  return document.get_data();
+}
+std::string XapianResult::get_title()
+{
+  if (searcher->valuesmap.empty()) {
+    /* This is the old legacy version. Guess and try */
+    return document.get_value(0);
+  } else if (searcher->valuesmap.find("title") != searcher->valuesmap.end()) {
+    return document.get_value(searcher->valuesmap["title"]);
   }
+  return "";
+}
 
-  std::string XapianResult::get_url() {
-    return document.get_data();
+int XapianResult::get_score()
+{
+  return iterator.get_percent();
+}
+std::string XapianResult::get_snippet()
+{
+  if (searcher->valuesmap.empty()) {
+    /* This is the old legacy version. Guess and try */
+    std::string stored_snippet = document.get_value(1);
+    if (!stored_snippet.empty()) {
+      return stored_snippet;
+    }
+    /* Let's continue here, and see if we can genenate one */
+  } else if (searcher->valuesmap.find("snippet") != searcher->valuesmap.end()) {
+    return document.get_value(searcher->valuesmap["snippet"]);
   }
-
-  std::string XapianResult::get_title() {
-      if ( searcher->valuesmap.empty() )
-      {
-          /* This is the old legacy version. Guess and try */
-          return document.get_value(0);
-      }
-      else if ( searcher->valuesmap.find("title") != searcher->valuesmap.end() )
-      {
-          return document.get_value(searcher->valuesmap["title"]);
-      }
-      return "";
+  /* No reader, no snippet */
+  if (!searcher->reader) {
+    return "";
   }
-
-  int XapianResult::get_score() {
-    return iterator.get_percent();
+  /* Get the content of the article to generate a snippet.
+     We parse it and use the html dump to avoid remove html tags in the
+     content and be able to nicely cut the text at random place. */
+  MyHtmlParser htmlParser;
+  std::string content = get_content();
+  if (content.empty()) {
+    return content;
   }
-
-  std::string XapianResult::get_snippet() {
-      if ( searcher->valuesmap.empty() )
-      {
-          /* This is the old legacy version. Guess and try */
-          std::string stored_snippet = document.get_value(1);
-          if ( ! stored_snippet.empty() )
-              return stored_snippet;
-          /* Let's continue here, and see if we can genenate one */
-      }
-      else if ( searcher->valuesmap.find("snippet") != searcher->valuesmap.end() )
-      {
-          return document.get_value(searcher->valuesmap["snippet"]);
-      }
-      /* No reader, no snippet */
-      if ( ! searcher->reader )
-          return "";
-      /* Get the content of the article to generate a snippet.
-         We parse it and use the html dump to avoid remove html tags in the
-         content and be able to nicely cut the text at random place. */
-      MyHtmlParser htmlParser;
-      std::string content;
-      unsigned int contentLength;
-      std::string contentType;
-      searcher->reader->getContentByUrl(get_url(), content, contentLength, contentType);
-      try {
-          htmlParser.parse_html(content, "UTF-8", true);
-      } catch (...) {}
-      return searcher->results.snippet(htmlParser.dump, 500);
+  try {
+    htmlParser.parse_html(content, "UTF-8", true);
+  } catch (...) {
   }
+  return searcher->results.snippet(htmlParser.dump, 500);
+}
 
-  int XapianResult::get_size() {
-      if ( searcher->valuesmap.empty() )
-      {
-          /* This is the old legacy version. Guess and try */
-          return document.get_value(2).empty() == true ? -1 : atoi(document.get_value(2).c_str());
-      }
-      else if ( searcher->valuesmap.find("size") != searcher->valuesmap.end() )
-      {
-          return atoi(document.get_value(searcher->valuesmap["size"]).c_str());
-      }
-      /* The size is never used. Do we really want to get the content and
-         calculate the size ? */
-      return -1;
+std::string XapianResult::get_content()
+{
+  if (!searcher->reader) {
+    return "";
   }
+  auto entry = searcher->reader->getEntryFromEncodedPath(get_url());
+  return entry.getContent();
+}
 
-  int XapianResult::get_wordCount() {
-      if ( searcher->valuesmap.empty() )
-      {
-          /* This is the old legacy version. Guess and try */
-          return document.get_value(3).empty() == true ? -1 : atoi(document.get_value(3).c_str());
-      }
-      else if ( searcher->valuesmap.find("wordcount") != searcher->valuesmap.end() )
-      {
-          return atoi(document.get_value(searcher->valuesmap["wordcount"]).c_str());
-      }
-      return -1;
+int XapianResult::get_size()
+{
+  if (searcher->valuesmap.empty()) {
+    /* This is the old legacy version. Guess and try */
+    return document.get_value(2).empty() == true
+               ? -1
+               : atoi(document.get_value(2).c_str());
+  } else if (searcher->valuesmap.find("size") != searcher->valuesmap.end()) {
+    return atoi(document.get_value(searcher->valuesmap["size"]).c_str());
   }
+  /* The size is never used. Do we really want to get the content and
+     calculate the size ? */
+  return -1;
+}
 
-} // Kiwix namespace
+int XapianResult::get_wordCount()
+{
+  if (searcher->valuesmap.empty()) {
+    /* This is the old legacy version. Guess and try */
+    return document.get_value(3).empty() == true
+               ? -1
+               : atoi(document.get_value(3).c_str());
+  } else if (searcher->valuesmap.find("wordcount")
+             != searcher->valuesmap.end()) {
+    return atoi(document.get_value(searcher->valuesmap["wordcount"]).c_str());
+  }
+  return -1;
+}
+
+}  // Kiwix namespace

static/meson.build

@@ -1,7 +1,27 @@
 
 
+ctpp2c = find_program('ctpp2c', required:false)
+
+if ctpp2c.found()
+  search_result_template = custom_target('result_template',
+    input: 'results.tmpl',
+    output: 'results.ct2',
+    command: [intermediate_ctpp2c, ctpp2c, '@INPUT@', '@OUTPUT@']
+ )
+ resources_list = 'resources_list_ctpp2.txt'
+ resources_depends = [search_result_template]
+else
+ resources_list = 'resources_list_noctpp2.txt'
+ resources_depends = []
+endif
+
 lib_resources = custom_target('resources',
-  input: 'resources_list.txt',
+  input: resources_list,
   output: ['kiwixlib-resources.cpp', 'kiwixlib-resources.h'],
-  command:[res_compiler, '--cxxfile', '@OUTPUT0@', '--hfile', '@OUTPUT1@', '@INPUT@']
-)
+  command:[res_compiler,
+           '--cxxfile', '@OUTPUT0@',
+           '--hfile', '@OUTPUT1@',
+           '--source_dir', '@OUTDIR@',
+           '@INPUT@'],
+  depends: resources_depends
+)

static/resources_list_noctpp2.txt

@@ -0,0 +1,3 @@
+stopwords/en
+stopwords/he
+stopwords/fra

static/results.tmpl

@@ -0,0 +1,159 @@
+<!DOCTYPE html>
+<html xmlns="http://www.w3.org/1999/xhtml">
+  <head>
+    <meta content="text/html; charset=utf-8" http-equiv="content-type" />
+    <style type="text/css">
+      body{
+      color: #00000;
+      font: small/normal Arial,Helvetica,Sans-Serif;
+      margin-top: 0.5em;
+      font-size: 90%;
+      }
+
+      a{
+      color: #04c;
+      }
+
+      a:visited {
+      color: #639
+      }
+
+      a:hover {
+      text-decoration: underline
+      }
+
+      .header {
+      font-size: 120%;
+      }
+
+      ul {
+      margin:0;
+      padding:0
+      }
+
+      .results {
+      font-size: 110%;
+      }
+
+      .results li {
+      list-style-type:none;
+      margin-top: 0.5em;
+      }
+
+      .results a {
+      font-size: 110%;
+      text-decoration: underline
+      }
+
+      cite {
+      font-style:normal;
+      word-wrap:break-word;
+      display: block;
+      font-size: 100%;
+      }
+
+      .informations {
+      color: #388222;
+      font-size: 100%;
+      }
+
+      .footer {
+      padding: 0;
+      margin-top: 1em;
+      width: 100%;
+      float: left
+      }
+
+      .footer a, .footer span {
+      display: block;
+      padding: .3em .7em;
+      margin: 0 .38em 0 0;
+      text-align:center;
+      text-decoration: none;
+      }
+
+      .footer a:hover {
+      background: #ededed;
+      }
+
+      .footer ul, .footer li {
+      list-style:none;
+      margin: 0;
+      padding: 0;
+      }
+
+      .footer li {
+      float: left;
+      }
+
+      .selected {
+      background: #ededed;
+      }
+
+    </style>
+    <title>Search: <TMPL_var searchPattern></title>
+  </head>
+  <body bgcolor="white">
+    <div class="header">
+      <TMPL_if results>
+        Results
+        <b>
+          <TMPL_var resultStart>-<TMPL_var resultEnd>
+        </b> of <b>
+          <TMPL_var count>
+        </b> for <b>
+          <TMPL_var searchPattern>
+        </b>
+      <TMPL_else>
+        No results were found for <b><TMPL_var searchPattern></b>
+      </TMPL_if>
+    </div>
+
+    <div class="results">
+      <ul>
+        <TMPL_foreach results as result>
+          <li>
+            <a href="<TMPL_var protocolPrefix><TMPL_var result.contentId>/<TMPL_var result.url>">
+              <TMPL_var result.title>
+            </a>
+            <cite>
+              <TMPL_if result.snippet>
+                <TMPL_var result.snippet>...
+              </TMPL_if>
+            </cite>
+            <TMPL_if wordCount>
+              <div class="informations"><TMPL_var wordCount> words</div>
+            </TMPL_if>
+          </li>
+        </TMPL_foreach>
+      </ul>
+    </div>
+
+    <div class="footer">
+      <ul>
+        <TMPL_if (resultLastPageStart>0)>
+          <li>
+            <a href="<TMPL_var searchProtocolPrefix>pattern=<TMPL_var searchPatternEncoded><TMPL_if contentId>&content=<TMPL_var contentId></TMPL_if>&start=0&end=<TMPL_var resultRange>">
+              ◀
+            </a>
+          </li>
+        </TMPL_if>
+        <TMPL_foreach pages as page>
+          <li>
+            <a <TMPL_if page.selected>class="selected"</TMPL_if>
+               href="<TMPL_var searchProtocolPrefix>pattern=<TMPL_var searchPatternEncoded><TMPL_if contentId>&content=<TMPL_var contentId></TMPL_if>&start=<TMPL_var page.start>&end=<TMPL_var page.end>">
+              <TMPL_var page.label>
+            </a>
+          </li>
+        </TMPL_foreach>
+        <TMPL_if (resultLastPageStart>0)>
+          <li>
+            <a href="<TMPL_var searchProtocolPrefix>pattern=<TMPL_var searchPatternEncoded><TMPL_if contentId>&content=<TMPL_var contentId></TMPL_if>&start=<TMPL_var resultLastPageStart>&end=<TMPL_var (resultLastPageStart+resultRange)>">
+              ▶
+            </a>
+          </li>
+        </TMPL_if>
+      </ul>
+    </div>
+  </body>
+</html>

travis/compile.sh

@@ -29,7 +29,12 @@ case ${PLATFORM} in
 esac
 
 cd ${TRAVIS_BUILD_DIR}
-export PKG_CONFIG_PATH=${INSTALL_DIR}/lib/x86_64-linux-gnu/pkgconfig
+if [[ "${TRAVIS_OS_NAME}" == "osx" ]]
+then
+  export PKG_CONFIG_PATH=${INSTALL_DIR}/lib/pkgconfig
+else
+  export PKG_CONFIG_PATH=${INSTALL_DIR}/lib/x86_64-linux-gnu/pkgconfig
+fi
 meson . build -Dctpp2-install-prefix=${INSTALL_DIR} ${MESON_OPTION}
 cd build
 ninja

travis/install_deps.sh

@@ -3,41 +3,27 @@
 set -e
 
 REPO_NAME=${TRAVIS_REPO_SLUG#*/}
-ARCHIVE_NAME=deps_${PLATFORM}_${REPO_NAME}.tar.gz
-
-# Packages.
-case ${PLATFORM} in
-     "native_static")
-         PACKAGES="gcc cmake libbz2-dev ccache zlib1g-dev uuid-dev libctpp2-dev"
-         ;;
-     "native_dyn")
-         PACKAGES="gcc cmake libbz2-dev ccache zlib1g-dev uuid-dev libctpp2-dev libmicrohttpd-dev"
-         ;;
-     "win32_static")
-         PACKAGES="g++-mingw-w64-i686 gcc-mingw-w64-i686 gcc-mingw-w64-base mingw-w64-tools ccache"
-         ;;
-     "win32_dyn")
-         PACKAGES="g++-mingw-w64-i686 gcc-mingw-w64-i686 gcc-mingw-w64-base mingw-w64-tools ccache"
-         ;;
-     "android_arm")
-         PACKAGES="gcc cmake ccache"
-         ;;
-     "android_arm64")
-         PACKAGES="gcc cmake ccache"
-         ;;
-esac
-
-sudo apt-get update -qq
-sudo apt-get install -qq python3-pip ${PACKAGES}
-pip3 install meson
+ARCHIVE_NAME=deps_${TRAVIS_OS_NAME}_${PLATFORM}_${REPO_NAME}.tar.gz
 
 # Ninja
 cd $HOME
-git clone git://github.com/ninja-build/ninja.git
-cd ninja
-git checkout release
-./configure.py --bootstrap
-sudo cp ninja /bin
+if [[ "$TRAVIS_OS_NAME" == "osx" ]]
+then
+  brew update
+  brew upgrade python3
+  pip3 install meson==0.43.0
+
+  wget https://github.com/ninja-build/ninja/releases/download/v1.8.2/ninja-mac.zip
+  unzip ninja-mac.zip ninja
+else
+  pip3 install --user meson==0.43.0
+
+  wget https://github.com/ninja-build/ninja/releases/download/v1.8.2/ninja-linux.zip
+  unzip ninja-linux.zip ninja
+fi
+
+mkdir -p $HOME/bin
+cp ninja $HOME/bin
 
 # Dependencies comming from kiwix-build.
 cd ${HOME}