1 files changed, 136 insertions, 136 deletions

diff --git a/src/common/src/linear_disk_cache.h b/src/common/src/linear_disk_cache.h
index d33ee7820..da5d6b9b4 100644
--- a/src/common/src/linear_disk_cache.h
+++ b/src/common/src/linear_disk_cache.h
@@ -30,7 +30,7 @@ template <typename K, typename V>
 class LinearDiskCacheReader
 {
 public:
-	virtual void Read(const K &key, const V *value, u32 value_size) = 0;
+    virtual void Read(const K &key, const V *value, u32 value_size) = 0;
 };
 
 // Dead simple unsorted key-value store with append functionality.
@@ -49,143 +49,143 @@ template <typename K, typename V>
 class LinearDiskCache
 {
 public:
-	// return number of read entries
-	u32 OpenAndRead(const char *filename, LinearDiskCacheReader<K, V> &reader)
-	{
-		using std::ios_base;
-
-		// close any currently opened file
-		Close();
-		m_num_entries = 0;
-
-		// try opening for reading/writing
-		OpenFStream(m_file, filename, ios_base::in | ios_base::out | ios_base::binary);
-
-		m_file.seekg(0, std::ios::end);
-		std::fstream::pos_type end_pos = m_file.tellg();
-		m_file.seekg(0, std::ios::beg);
-		std::fstream::pos_type start_pos = m_file.tellg();
-		std::streamoff file_size = end_pos - start_pos;
-		
-		if (m_file.is_open() && ValidateHeader())
-		{
-			// good header, read some key/value pairs
-			K key;
-
-			V *value = NULL;
-			u32 value_size;
-			u32 entry_number;
-
-			std::fstream::pos_type last_pos = m_file.tellg();
-
-			while (Read(&value_size))
-			{
-				std::streamoff next_extent = (last_pos - start_pos) + sizeof(value_size) + value_size;
-				if (next_extent > file_size)
-					break;
-
-				delete[] value;
-				value = new V[value_size];
-
-				// read key/value and pass to reader
-				if (Read(&key) &&
-					Read(value, value_size) && 
-					Read(&entry_number) &&
-					entry_number == m_num_entries+1)
- 				{
-					reader.Read(key, value, value_size);
-				}
-				else
-				{
-					break;
-				}
-
-				m_num_entries++;
-				last_pos = m_file.tellg();
-			}
-			m_file.seekp(last_pos);
-			m_file.clear();
-
-			delete[] value;
-			return m_num_entries;
-		}
-
-		// failed to open file for reading or bad header
-		// close and recreate file
-		Close();
-		m_file.open(filename, ios_base::out | ios_base::trunc | ios_base::binary);
-		WriteHeader();
-		return 0;
-	}
-	
-	void Sync()
-	{
-		m_file.flush();
-	}
-
-	void Close()
-	{
-		if (m_file.is_open())
-			m_file.close();
-		// clear any error flags
-		m_file.clear();
-	}
-
-	// Appends a key-value pair to the store.
-	void Append(const K &key, const V *value, u32 value_size)
-	{
-		// TODO: Should do a check that we don't already have "key"? (I think each caller does that already.)
-		Write(&value_size);
-		Write(&key);
-		Write(value, value_size);
-		m_num_entries++;
-		Write(&m_num_entries);
-	}
+    // return number of read entries
+    u32 OpenAndRead(const char *filename, LinearDiskCacheReader<K, V> &reader)
+    {
+        using std::ios_base;
+
+        // close any currently opened file
+        Close();
+        m_num_entries = 0;
+
+        // try opening for reading/writing
+        OpenFStream(m_file, filename, ios_base::in | ios_base::out | ios_base::binary);
+
+        m_file.seekg(0, std::ios::end);
+        std::fstream::pos_type end_pos = m_file.tellg();
+        m_file.seekg(0, std::ios::beg);
+        std::fstream::pos_type start_pos = m_file.tellg();
+        std::streamoff file_size = end_pos - start_pos;
+        
+        if (m_file.is_open() && ValidateHeader())
+        {
+            // good header, read some key/value pairs
+            K key;
+
+            V *value = NULL;
+            u32 value_size;
+            u32 entry_number;
+
+            std::fstream::pos_type last_pos = m_file.tellg();
+
+            while (Read(&value_size))
+            {
+                std::streamoff next_extent = (last_pos - start_pos) + sizeof(value_size) + value_size;
+                if (next_extent > file_size)
+                    break;
+
+                delete[] value;
+                value = new V[value_size];
+
+                // read key/value and pass to reader
+                if (Read(&key) &&
+                    Read(value, value_size) && 
+                    Read(&entry_number) &&
+                    entry_number == m_num_entries+1)
+                 {
+                    reader.Read(key, value, value_size);
+                }
+                else
+                {
+                    break;
+                }
+
+                m_num_entries++;
+                last_pos = m_file.tellg();
+            }
+            m_file.seekp(last_pos);
+            m_file.clear();
+
+            delete[] value;
+            return m_num_entries;
+        }
+
+        // failed to open file for reading or bad header
+        // close and recreate file
+        Close();
+        m_file.open(filename, ios_base::out | ios_base::trunc | ios_base::binary);
+        WriteHeader();
+        return 0;
+    }
+    
+    void Sync()
+    {
+        m_file.flush();
+    }
+
+    void Close()
+    {
+        if (m_file.is_open())
+            m_file.close();
+        // clear any error flags
+        m_file.clear();
+    }
+
+    // Appends a key-value pair to the store.
+    void Append(const K &key, const V *value, u32 value_size)
+    {
+        // TODO: Should do a check that we don't already have "key"? (I think each caller does that already.)
+        Write(&value_size);
+        Write(&key);
+        Write(value, value_size);
+        m_num_entries++;
+        Write(&m_num_entries);
+    }
 
 private:
-	void WriteHeader()
-	{
-		Write(&m_header);
-	}
-
-	bool ValidateHeader()
-	{
-		char file_header[sizeof(Header)];
-
-		return (Read(file_header, sizeof(Header))
-			&& !memcmp((const char*)&m_header, file_header, sizeof(Header)));
-	}
-
-	template <typename D>
-	bool Write(const D *data, u32 count = 1)
-	{
-		return m_file.write((const char*)data, count * sizeof(D)).good();
-	}
-
-	template <typename D>
-	bool Read(const D *data, u32 count = 1)
-	{
-		return m_file.read((char*)data, count * sizeof(D)).good();
-	}
-
-	struct Header
-	{
-		Header()
-			: id(*(u32*)"DCAC")
-			, key_t_size(sizeof(K))
-			, value_t_size(sizeof(V))
-		{
-			memcpy(ver, scm_rev_git_str, 40);
-		}
-
-		const u32 id;
-		const u16 key_t_size, value_t_size;
-		char ver[40];
-
-	} m_header;
-
-	std::fstream m_file;
-	u32 m_num_entries;
+    void WriteHeader()
+    {
+        Write(&m_header);
+    }
+
+    bool ValidateHeader()
+    {
+        char file_header[sizeof(Header)];
+
+        return (Read(file_header, sizeof(Header))
+            && !memcmp((const char*)&m_header, file_header, sizeof(Header)));
+    }
+
+    template <typename D>
+    bool Write(const D *data, u32 count = 1)
+    {
+        return m_file.write((const char*)data, count * sizeof(D)).good();
+    }
+
+    template <typename D>
+    bool Read(const D *data, u32 count = 1)
+    {
+        return m_file.read((char*)data, count * sizeof(D)).good();
+    }
+
+    struct Header
+    {
+        Header()
+            : id(*(u32*)"DCAC")
+            , key_t_size(sizeof(K))
+            , value_t_size(sizeof(V))
+        {
+            memcpy(ver, scm_rev_git_str, 40);
+        }
+
+        const u32 id;
+        const u16 key_t_size, value_t_size;
+        char ver[40];
+
+    } m_header;
+
+    std::fstream m_file;
+    u32 m_num_entries;
 };
 
 #endif  // _LINEAR_DISKCACHE