Add new interface for creating new segments.

[cumulus.git] / store.h

diff --git a/store.h b/store.h
index 3725a9f..0cd2c4b 100644 (file)
--- a/store.h
+++ b/store.h
@@ -14,6 +14,7 @@
 #include <map>
 #include <string>
 #include <sstream>
+#include <vector>
 
 /* In memory datatype to represent key/value pairs of information, such as file
  * metadata.  Currently implemented as map<string, string>. */
@@ -97,10 +98,76 @@ private:
     FILE *f;
 };
 
+/* An OutputStream which is simply sends writes to another OutputStream, but
+ * does provide separate tracking of bytes written. */
+class WrapperOutputStream : public OutputStream {
+public:
+    explicit WrapperOutputStream(OutputStream &o);
+    virtual ~WrapperOutputStream() { }
+
+protected:
+    virtual void write_internal(const void *data, size_t len);
+
+private:
+    OutputStream &real;
+};
+
 /* Simple wrappers that encode integers using a StringOutputStream and return
  * the encoded result. */
 std::string encode_u16(uint16_t val);
 std::string encode_u32(uint32_t val);
 std::string encode_u64(uint64_t val);
 
+struct uuid {
+    uint8_t bytes[16];
+};
+
+/* A class which is used to pack multiple objects into a single segment, with a
+ * lookup table to quickly locate each object.  Call new_object() to get an
+ * OutputStream to which a new object may be written, and optionally
+ * finish_object() when finished writing the current object.  Only one object
+ * may be written to a segment at a time; if multiple objects must be written
+ * concurrently, they must be to different segments. */
+class SegmentWriter {
+public:
+    SegmentWriter(OutputStream *output, struct uuid u);
+    ~SegmentWriter();
+
+    struct uuid get_uuid() const { return id; }
+
+    // Start writing out a new object to this segment.
+    OutputStream *new_object();
+    void finish_object();
+
+    // Utility functions for generating and formatting UUIDs for display.
+    static struct uuid generate_uuid();
+    static std::string format_uuid(const struct uuid u);
+
+private:
+    typedef std::vector<std::pair<int64_t, int64_t> > object_table;
+
+    OutputStream *out;
+    struct uuid id;
+
+    int64_t object_start_offset;
+    OutputStream *object_stream;
+
+    object_table objects;
+};
+
+/* A SegmentStore, as the name suggests, is used to store the contents of many
+ * segments.  The SegmentStore internally tracks where data should be placed
+ * (such as a local directory or remote storage), and allows new segments to be
+ * easily created as needed. */
+class SegmentStore {
+public:
+    // New segments will be stored in the given directory.
+    SegmentStore(const std::string &path);
+
+    SegmentWriter *new_segment();
+
+private:
+    std::string directory;
+};
+
 #endif // _LBS_STORE_H