DOC: Basic documentation added

src/libloom/CMakeLists.txt

@@ -27,8 +27,6 @@ add_library(libloom
             taskfactory.h
             dictionary.cpp
             dictionary.h
-            databuilder.cpp
-            databuilder.h
             data.cpp
             data.h
             unpacking.cpp

src/libloom/compat.h

+/**
+  @file compat.h
+
+  This file provides some features from C++14.
+  In the current version it provides std::make_unique
+*/
+
 #ifndef LIBLOOM_COMPAT_H
 #define LIBLOOM_COMPAT_H
 

src/libloom/connection.h

@@ -16,6 +16,7 @@ namespace loom {
 
 class Connection;
 
+/** Base class for handling events emited by Connection */
 class ConnectionCallback
 {
     friend class Connection;
@@ -23,15 +24,21 @@ public:
     virtual ~ConnectionCallback();
 
 protected:
+    /** New connection is established. (Not used when connection created by 'accept'). */
     virtual void on_connection() { assert(0); }
+    /** An error has occured, error_code is from libuv. */
     virtual void on_error(int error_code);
+    /** The connection is closed. */
     virtual void on_close() = 0;
+    /** Raw data received */
     virtual void on_data_chunk(const char *buffer, size_t size) { assert(0); }
+    /** Raw data finished */
     virtual void on_data_finish() { assert(0); }
+    /** Message received */
     virtual void on_message(const char *buffer, size_t size) = 0;
 };
 
-
+/** Class representing TCP/IP connection */
 class Connection
 {    
 public:
@@ -51,6 +58,7 @@ public:
         return state;
     }
 
+    /** Set callback instance; the old one is forgotten. */
     void set_callback(ConnectionCallback *callback) {
         this->callback = callback;
     }

src/libloom/data.h

@@ -15,30 +15,52 @@ class Worker;
 class SendBuffer;
 class Connection;
 
+/** Base class for data objects */
 class Data
 {    
 public:
     virtual ~Data();
 
     virtual std::string get_type_name() const = 0;
+
+    /** Get size of data */
     virtual size_t get_size() = 0;
+
+    /** Get debugging info string */
     virtual std::string get_info() = 0;
+
+    /** Get length of data (when object is not indexable then returns 0) */
     virtual size_t get_length();
+
+    /** Get subobject at given index (0 ... get_length()) */
     virtual std::shared_ptr<Data> get_at_index(size_t index);
+
+    /** Get subobject slice at given indices (0 ... get_length()) */
     virtual std::shared_ptr<Data> get_slice(size_t from, size_t to);
 
+    /** Serialize object into send buffer */
     void serialize(Worker &worker, SendBuffer &buffer, std::shared_ptr<Data> &data_ptr);
-    virtual void init_message(Worker &worker, loomcomm::Data &msg) const;
-    virtual void serialize_data(Worker &worker, SendBuffer &buffer, std::shared_ptr<Data> &data_ptr) = 0;
 
+    /** Get pointer to raw data, returns nullptr when it is not possible */
     virtual char *get_raw_data(Worker &worker);
+
+    /** Returns a filename if data obeject is mapped from file, empty string otherwise */
     virtual std::string get_filename() const;
+
+protected:
+    /** Init serialization message */
+    virtual void init_message(Worker &worker, loomcomm::Data &msg) const;
+
+    /** Serialize content */
+    virtual void serialize_data(Worker &worker, SendBuffer &buffer, std::shared_ptr<Data> &data_ptr) = 0;
 };
 
+/** Base class for deserialization */
 class DataUnpacker
 {
 public:
     virtual ~DataUnpacker();
+
     virtual bool init(Worker &worker, Connection &connection, const loomcomm::Data &msg) = 0;
     virtual bool on_message(Connection &connection, const char *data, size_t size);
     virtual void on_data_chunk(const char *data, size_t size);

src/libloom/data/array.h

@@ -21,10 +21,10 @@ public:
 
     std::shared_ptr<Data>& get_ref_at_index(size_t index);
 
-    void serialize_data(Worker &worker, SendBuffer &buffer, std::shared_ptr<Data> &data_ptr);    
     std::string get_type_name() const;
 
-private:
+protected:
+    void serialize_data(Worker &worker, SendBuffer &buffer, std::shared_ptr<Data> &data_ptr);
     size_t length;
     std::unique_ptr<std::shared_ptr<Data>[]> items;
 };

src/libloom/data/externfile.h

@@ -26,12 +26,11 @@ public:
     }
 
     std::string get_info();
-    void serialize_data(Worker &worker, SendBuffer &buffer, std::shared_ptr<Data> &data_ptr);
-
     std::string get_filename() const;
 
 
-private:
+protected:
+    void serialize_data(Worker &worker, SendBuffer &buffer, std::shared_ptr<Data> &data_ptr);
 
     void open();
     void map(int fd, bool write);

src/libloom/data/index.h

@@ -27,10 +27,9 @@ public:
     std::shared_ptr<Data> get_at_index(size_t index);
     std::shared_ptr<Data> get_slice(size_t from, size_t to);
 
+protected:
     void serialize_data(Worker &worker, SendBuffer &buffer, std::shared_ptr<Data> &data_ptr);
 
-
-private:
     Worker &worker;
     std::shared_ptr<Data> data;
     size_t length;

src/libloom/data/rawdata.h

@@ -26,17 +26,16 @@ public:
     }
 
     std::string get_info();
-    void serialize_data(Worker &worker, SendBuffer &buffer, std::shared_ptr<Data> &data_ptr);
 
-    //char* init_memonly(size_t size);
     char* init_empty_file(Worker &worker, size_t size);
     void assign_filename(Worker &worker);
     void init_from_file(Worker &worker);
 
     std::string get_filename() const;
 
-private:
+protected:
 
+    void serialize_data(Worker &worker, SendBuffer &buffer, std::shared_ptr<Data> &data_ptr);
     void open(Worker &worker);
     void map(int fd, bool write);
 

src/libloom/databuilder.cpp

-
-//#include "databuilder.h"

src/libloom/databuilder.h

-/*#ifndef LIBLOOM_DATABUILDER_H
-#define LIBLOOM_DATABUILDER_H
-
-#include "data.h"
-
-#include <stdlib.h>
-#include <memory>
-#include <string.h>
-
-namespace loom {
-
-class Worker;
-class Data;
-
-class DataBuilder
-{
-public:
-    DataBuilder(Worker &worker, loom::Id id, size_t size, bool in_file)
-        : data(std::make_unique<Data>(id))
-    {
-        if (in_file) {
-            pointer = data->init_empty_file(worker, size);
-        } else {
-            pointer = data->init_memonly(size);
-        }
-    }
-
-    std::unique_ptr<Data> release_data() {
-        pointer = nullptr;
-        return std::move(data);
-    }
-
-    void add(const char *new_data, size_t size) {
-        memcpy(pointer, new_data, size);
-        pointer += size;
-    }
-
-public:
-    std::unique_ptr<Data> data;
-    char *pointer;
-
-};
-
-}
-
-#endif // LIBLOOM_DATABUILDER_H
-*/

src/libloom/dictionary.h

@@ -9,6 +9,7 @@
 
 namespace loom {
 
+/** Container for symbols */
 class Dictionary {
 
 public:

src/libloom/interconnect.cpp

@@ -3,7 +3,6 @@
 #include "loomcomm.pb.h"
 #include "log.h"
 #include "utils.h"
-#include "databuilder.h"
 
 #include <sstream>
 

src/libloom/interconnect.h

@@ -13,6 +13,7 @@ class Worker;
 class DataBuilder;
 class SendBuffer;
 
+/** Interconnection between workers */
 class InterConnection : public SimpleConnectionCallback
 {
 public:

src/libloom/log.h

@@ -4,6 +4,8 @@
 #include "spdlog/spdlog.h"
 
 namespace loom {
+
+    /** Main loom log */
     extern std::shared_ptr<spdlog::logger> llog;
 }
 

src/libloom/sendbuffer.h

@@ -15,6 +15,7 @@ namespace loom {
 
 class Data;
 
+/** Buffer for composing data that will be send over a connection */
 class SendBuffer {
 
 public:

src/libloom/task.h

@@ -9,6 +9,7 @@ namespace loom {
 
 class Worker;
 
+/** Class that repsents one task */
 class Task {
 
 public:

src/libloom/taskfactory.h

@@ -15,6 +15,7 @@ namespace loom {
 class Worker;
 class TaskInstance;
 
+/** Abstract class for creating task instances */
 class TaskFactory
 {
 public:

src/libloom/taskinstance.h

@@ -17,6 +17,7 @@ class Data;
 
 typedef std::vector<std::shared_ptr<Data>*> DataVector;
 
+/** Base class for task instance - an actual state of computation of a task */
 class TaskInstance
 {
 public:

src/libloom/tasks/rawdatatasks.cpp

 #include "rawdatatasks.h"
 
 #include "libloom/compat.h"
-#include "libloom/databuilder.h"
 #include "libloom/data/rawdata.h"
 #include "libloom/data/index.h"
 #include "libloom/data/externfile.h"

src/libloom/unpacking.h

@@ -8,6 +8,7 @@
 
 namespace loom {
 
+/** Base class for factory producing deserializers for data types */
 class UnpackFactory
 {
 public: