Export SnappyFile class to its own file.

[apitrace] / trace_file.cpp

diff --git a/trace_file.cpp b/trace_file.cpp
index 74cc3829e2b4ce5a18a3d69beb614e90b87ed6de..758ecd78c264d6e218b001473489394607da4b8f 100644 (file)
--- a/trace_file.cpp
+++ b/trace_file.cpp
@@ -1,63 +1,18 @@
 #include "trace_file.hpp"
 
+#include "trace_snappyfile.hpp"
+
 #include <assert.h>
 #include <string.h>
 
 #include <zlib.h>
-#include <snappy.h>
 
 #include "os.hpp"
 
 #include <iostream>
-#include <set>
 
 using namespace Trace;
 
-#define SNAPPY_BYTE1 'a'
-#define SNAPPY_BYTE2 't'
-
-static void cleanupHandler(int sig);
-
-class FileCleanup
-{
-public:
-    FileCleanup()
-    {
-        OS::CatchInterrupts(cleanupHandler);
-    }
-
-    ~FileCleanup()
-    {
-        flush();
-        m_files.clear();
-    }
-
-    void addFile(Trace::File *file)
-    {
-        m_files.insert(file);
-    }
-    void removeFile(Trace::File *file)
-    {
-        m_files.erase(file);
-    }
-
-    void flush()
-    {
-        std::set<Trace::File*>::const_iterator itr;
-        for (itr = m_files.begin(); itr != m_files.end(); ++itr) {
-            (*itr)->flush(File::FlushDeep);
-        }
-    }
-
-private:
-    std::set<Trace::File*> m_files;
-};
-static FileCleanup s_cleaner;
-
-static void cleanupHandler(int sig)
-{
-    s_cleaner.flush();
-}
 
 File::File(const std::string &filename,
            File::Mode mode)
@@ -99,9 +54,6 @@ bool File::open(const std::string &filename, File::Mode mode)
     m_isOpened = rawOpen(filename, mode);
     m_mode = mode;
 
-    if (m_isOpened) {
-        s_cleaner.addFile(this);
-    }
     return m_isOpened;
 }
 
@@ -126,7 +78,6 @@ void File::close()
     if (m_isOpened) {
         rawClose();
         m_isOpened = false;
-        s_cleaner.removeFile(this);
     }
 }
 
@@ -220,168 +171,3 @@ void ZLibFile::rawFlush(FlushType type)
 {
     gzflush(m_gzFile, Z_SYNC_FLUSH);
 }
-
-SnappyFile::SnappyFile(const std::string &filename,
-                              File::Mode mode)
-    : File(),
-      m_cache(0),
-      m_cachePtr(0),
-      m_cacheSize(0)
-{
-    m_compressedCache = new char[SNAPPY_CHUNK_SIZE];
-}
-
-SnappyFile::~SnappyFile()
-{
-    delete [] m_compressedCache;
-}
-
-bool SnappyFile::rawOpen(const std::string &filename, File::Mode mode)
-{
-    std::ios_base::openmode fmode = std::fstream::binary;
-    if (mode == File::Write) {
-        fmode |= (std::fstream::out | std::fstream::trunc);
-        createCache(SNAPPY_CHUNK_SIZE);
-    } else if (mode == File::Read) {
-        fmode |= std::fstream::in;
-    }
-
-    m_stream.open(filename.c_str(), fmode);
-
-    //read in the initial buffer if we're reading
-    if (m_stream.is_open() && mode == File::Read) {
-        // read the snappy file identifier
-        unsigned char byte1, byte2;
-        m_stream >> byte1;
-        m_stream >> byte2;
-        assert(byte1 == SNAPPY_BYTE1 && byte2 == SNAPPY_BYTE2);
-
-        flushCache();
-    } else if (m_stream.is_open() && mode == File::Write) {
-        // write the snappy file identifier
-        m_stream << SNAPPY_BYTE1;
-        m_stream << SNAPPY_BYTE2;
-    }
-    return m_stream.is_open();
-}
-
-bool SnappyFile::rawWrite(const void *buffer, int length)
-{
-    if (freeCacheSize() > length) {
-        memcpy(m_cachePtr, buffer, length);
-        m_cachePtr += length;
-    } else if (freeCacheSize() == length) {
-        memcpy(m_cachePtr, buffer, length);
-        m_cachePtr += length;
-        flushCache();
-    } else {
-        int sizeToWrite = length;
-
-        while (sizeToWrite >= freeCacheSize()) {
-            int endSize = freeCacheSize();
-            int offset = length - sizeToWrite;
-            memcpy(m_cachePtr, (char*)buffer + offset, endSize);
-            sizeToWrite -= endSize;
-            m_cachePtr += endSize;
-            flushCache();
-        }
-        if (sizeToWrite) {
-            int offset = length - sizeToWrite;
-            memcpy(m_cachePtr, (char*)buffer + offset, sizeToWrite);
-            m_cachePtr += sizeToWrite;
-        }
-    }
-
-    return true;
-}
-
-bool SnappyFile::rawRead(void *buffer, int length)
-{
-    if (m_stream.eof()) {
-        return false;
-    }
-    if (freeCacheSize() > length) {
-        memcpy(buffer, m_cachePtr, length);
-        m_cachePtr += length;
-    } else if (freeCacheSize() == length) {
-        memcpy(buffer, m_cachePtr, length);
-        m_cachePtr += length;
-        flushCache();
-    } else {
-        int sizeToRead = length;
-        int offset = 0;
-        while (sizeToRead) {
-            int chunkSize = std::min(freeCacheSize(), sizeToRead);
-            offset = length - sizeToRead;
-            memcpy((char*)buffer + offset, m_cachePtr, chunkSize);
-            m_cachePtr += chunkSize;
-            sizeToRead -= chunkSize;
-            if (sizeToRead > 0)
-                flushCache();
-            if (!m_cacheSize)
-                break;
-        }
-    }
-
-    return true;
-}
-
-int SnappyFile::rawGetc()
-{
-    int c = 0;
-    if (!rawRead(&c, 1))
-        return -1;
-    return c;
-}
-
-void SnappyFile::rawClose()
-{
-    flushCache();
-    m_stream.close();
-    delete [] m_cache;
-    m_cache = NULL;
-    m_cachePtr = NULL;
-}
-
-void SnappyFile::rawFlush(FlushType type)
-{
-    if (type == FlushDeep) {
-        flushCache();
-    }
-    m_stream.flush();
-}
-
-void SnappyFile::flushCache()
-{
-    if (m_mode == File::Write) {
-        size_t compressedLength;
-
-        ::snappy::RawCompress(m_cache, SNAPPY_CHUNK_SIZE - freeCacheSize(),
-                              m_compressedCache, &compressedLength);
-
-        m_stream << compressedLength;
-        m_stream.write(m_compressedCache, compressedLength);
-        m_cachePtr = m_cache;
-    } else if (m_mode == File::Read) {
-        if (m_stream.eof())
-            return;
-        //assert(m_cachePtr == m_cache + m_cacheSize);
-        size_t compressedLength;
-        m_stream >> compressedLength;
-        m_stream.read((char*)m_compressedCache, compressedLength);
-        ::snappy::GetUncompressedLength(m_compressedCache, compressedLength,
-                                        &m_cacheSize);
-        if (m_cache)
-            delete [] m_cache;
-        createCache(m_cacheSize);
-        ::snappy::RawUncompress(m_compressedCache, compressedLength,
-                                m_cache);
-    }
-}
-
-void SnappyFile::createCache(size_t size)
-{
-    m_cache = new char[size];
-    m_cachePtr = m_cache;
-    m_cacheSize = size;
-}