CacheEntryReader.cpp
CacheEntryWriter.cpp
CacheFile.cpp
- Compression.cpp
- Compressor.cpp
Config.cpp
Context.cpp
Counters.cpp
- Decompressor.cpp
Depfile.cpp
Fd.cpp
Hash.cpp
Lockfile.cpp
Logging.cpp
Manifest.cpp
- NullCompressor.cpp
- NullDecompressor.cpp
ProgressBar.cpp
Result.cpp
ResultDumper.cpp
TemporaryFile.cpp
ThreadPool.cpp
Util.cpp
- ZstdCompressor.cpp
- ZstdDecompressor.cpp
argprocessing.cpp
assertions.cpp
ccache.cpp
third_party_lib)
endif()
+add_subdirectory(compression)
add_subdirectory(core)
add_subdirectory(storage)
add_subdirectory(third_party)
#include "CacheEntryReader.hpp"
-#include "Compressor.hpp"
#include "fmtmacros.hpp"
+#include <compression/Compressor.hpp>
#include <core/exceptions.hpp>
#include "third_party/fmt/core.h"
memcpy(m_magic, header_bytes, sizeof(m_magic));
m_version = header_bytes[4];
- m_compression_type = Compression::type_from_int(header_bytes[5]);
+ m_compression_type = compression::type_from_int(header_bytes[5]);
m_compression_level = header_bytes[6];
Util::big_endian_to_int(header_bytes + 7, m_content_size);
}
m_checksum.update(header_bytes, sizeof(header_bytes));
- m_decompressor = Decompressor::create_from_type(m_compression_type, stream);
+ m_decompressor =
+ compression::Decompressor::create_from_type(m_compression_type, stream);
}
void
PRINT(dump_stream, "Version: {}\n", m_version);
PRINT(dump_stream,
"Compression type: {}\n",
- Compression::type_to_string(m_compression_type));
+ compression::type_to_string(m_compression_type));
PRINT(dump_stream, "Compression level: {}\n", m_compression_level);
PRINT(dump_stream, "Content size: {}\n", m_content_size);
}
#pragma once
#include "Checksum.hpp"
-#include "Decompressor.hpp"
#include "Util.hpp"
+#include <compression/Decompressor.hpp>
+
#include <cstdint>
#include <cstdio>
#include <memory>
uint8_t version() const;
// Get compression type.
- Compression::Type compression_type() const;
+ compression::Type compression_type() const;
// Get compression level.
int8_t compression_level() const;
uint64_t content_size() const;
private:
- std::unique_ptr<Decompressor> m_decompressor;
+ std::unique_ptr<compression::Decompressor> m_decompressor;
Checksum m_checksum;
uint8_t m_magic[4];
uint8_t m_version;
- Compression::Type m_compression_type;
+ compression::Type m_compression_type;
int8_t m_compression_level;
uint64_t m_content_size;
};
return m_version;
}
-inline Compression::Type
+inline compression::Type
CacheEntryReader::compression_type() const
{
return m_compression_type;
CacheEntryWriter::CacheEntryWriter(FILE* stream,
const uint8_t* magic,
uint8_t version,
- Compression::Type compression_type,
+ compression::Type compression_type,
int8_t compression_level,
uint64_t payload_size)
// clang-format off
- : m_compressor(
- Compressor::create_from_type(compression_type, stream, compression_level))
+ : m_compressor(compression::Compressor::create_from_type(
+ compression_type, stream, compression_level))
// clang-format on
{
uint8_t header_bytes[15];
#pragma once
#include "Checksum.hpp"
-#include "Compressor.hpp"
#include "Util.hpp"
+#include <compression/Compressor.hpp>
+
#include <cstdint>
#include <cstdio>
#include <memory>
CacheEntryWriter(FILE* stream,
const uint8_t* magic,
uint8_t version,
- Compression::Type compression_type,
+ compression::Type compression_type,
int8_t compression_level,
uint64_t payload_size);
void finalize();
private:
- std::unique_ptr<Compressor> m_compressor;
+ std::unique_ptr<compression::Compressor> m_compressor;
Checksum m_checksum;
};
#include "Config.hpp"
#include "AtomicFile.hpp"
-#include "Compression.hpp"
#include "MiniTrace.hpp"
#include "Sloppiness.hpp"
#include "Util.hpp"
#include "assertions.hpp"
#include "fmtmacros.hpp"
+#include <compression/types.hpp>
#include <core/exceptions.hpp>
#include <core/wincompat.hpp>
#include <util/expected.hpp>
CacheEntryWriter writer(atomic_manifest_file.stream(),
Manifest::k_magic,
Manifest::k_version,
- Compression::type_from_config(config),
- Compression::level_from_config(config),
+ compression::type_from_config(config),
+ compression::level_from_config(config),
payload_size);
writer.write<uint32_t>(mf.files.size());
for (const auto& file : mf.files) {
CacheEntryWriter writer(atomic_result_file.stream(),
k_magic,
k_version,
- Compression::type_from_config(m_ctx.config),
- Compression::level_from_config(m_ctx.config),
+ compression::type_from_config(m_ctx.config),
+ compression::level_from_config(m_ctx.config),
payload_size);
writer.write<uint8_t>(m_entries_to_write.size());
#include "Args.hpp"
#include "ArgsInfo.hpp"
#include "Checksum.hpp"
-#include "Compression.hpp"
#include "Context.hpp"
#include "Depfile.hpp"
#include "Fd.hpp"
#include "hashutil.hpp"
#include "language.hpp"
+#include <compression/types.hpp>
#include <core/exceptions.hpp>
#include <core/types.hpp>
#include <core/wincompat.hpp>
#include "Result.hpp"
#include "Statistics.hpp"
#include "ThreadPool.hpp"
-#include "ZstdCompressor.hpp"
#include "assertions.hpp"
#include "fmtmacros.hpp"
+#include <compression/ZstdCompressor.hpp>
#include <core/exceptions.hpp>
#include <core/wincompat.hpp>
#include <util/string.hpp>
std::unique_ptr<CacheEntryWriter>
create_writer(FILE* stream,
const CacheEntryReader& reader,
- Compression::Type compression_type,
+ compression::Type compression_type,
int8_t compression_level)
{
return std::make_unique<CacheEntryWriter>(stream,
auto old_stat = Stat::stat(cache_file.path(), Stat::OnError::log);
uint64_t content_size = reader->content_size();
int8_t wanted_level =
- level ? (*level == 0 ? ZstdCompressor::default_compression_level : *level)
- : 0;
+ level
+ ? (*level == 0 ? compression::ZstdCompressor::default_compression_level
+ : *level)
+ : 0;
if (reader->compression_level() == wanted_level) {
statistics.update(content_size, old_stat.size(), old_stat.size(), 0);
auto writer =
create_writer(atomic_new_file.stream(),
*reader,
- level ? Compression::Type::zstd : Compression::Type::none,
+ level ? compression::Type::zstd : compression::Type::none,
wanted_level);
char buffer[CCACHE_READ_BUFFER_SIZE];
--- /dev/null
+set(
+ sources
+ ${CMAKE_CURRENT_SOURCE_DIR}/Compressor.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/Decompressor.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/NullCompressor.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/NullDecompressor.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/ZstdCompressor.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/ZstdDecompressor.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/types.cpp
+)
+
+target_sources(ccache_lib PRIVATE ${sources})
#include <memory>
+namespace compression {
+
std::unique_ptr<Compressor>
-Compressor::create_from_type(Compression::Type type,
- FILE* stream,
- int8_t compression_level)
+Compressor::create_from_type(const Type type,
+ FILE* const stream,
+ const int8_t compression_level)
{
switch (type) {
- case Compression::Type::none:
+ case compression::Type::none:
return std::make_unique<NullCompressor>(stream);
- case Compression::Type::zstd:
+ case compression::Type::zstd:
return std::make_unique<ZstdCompressor>(stream, compression_level);
}
ASSERT(false);
}
+
+} // namespace compression
#pragma once
-#include "Compression.hpp"
+#include <compression/types.hpp>
#include <cstdint>
#include <cstdio>
#include <memory>
+namespace compression {
+
class Compressor
{
public:
// - type: The type.
// - stream: The stream to write to.
// - compression_level: Desired compression level.
- static std::unique_ptr<Compressor> create_from_type(Compression::Type type,
- FILE* stream,
- int8_t compression_level);
+ static std::unique_ptr<Compressor>
+ create_from_type(Type type, FILE* stream, int8_t compression_level);
// Get the actual compression level used for the compressed stream.
virtual int8_t actual_compression_level() const = 0;
// and throws Error if not.
virtual void finalize() = 0;
};
+
+} // namespace compression
#include "ZstdDecompressor.hpp"
#include "assertions.hpp"
+namespace compression {
+
std::unique_ptr<Decompressor>
-Decompressor::create_from_type(Compression::Type type, FILE* stream)
+Decompressor::create_from_type(Type type, FILE* stream)
{
switch (type) {
- case Compression::Type::none:
+ case compression::Type::none:
return std::make_unique<NullDecompressor>(stream);
- case Compression::Type::zstd:
+ case compression::Type::zstd:
return std::make_unique<ZstdDecompressor>(stream);
}
ASSERT(false);
}
+
+} // namespace compression
#pragma once
-#include "Compression.hpp"
+#include <compression/types.hpp>
#include <cstdio>
#include <memory>
+namespace compression {
+
class Decompressor
{
public:
// Parameters:
// - type: The type.
// - stream: The stream to read from.
- static std::unique_ptr<Decompressor> create_from_type(Compression::Type type,
+ static std::unique_ptr<Decompressor> create_from_type(Type type,
FILE* stream);
// Read data into a buffer from the compressed stream.
// and throws Error if not.
virtual void finalize() = 0;
};
+
+} // namespace compression
#include <core/exceptions.hpp>
-NullCompressor::NullCompressor(FILE* stream) : m_stream(stream)
+namespace compression {
+
+NullCompressor::NullCompressor(FILE* const stream) : m_stream(stream)
{
}
}
void
-NullCompressor::write(const void* data, size_t count)
+NullCompressor::write(const void* const data, const size_t count)
{
if (fwrite(data, 1, count, m_stream) != count) {
throw core::Error("failed to write to uncompressed stream");
throw core::Error("failed to finalize uncompressed stream");
}
}
+
+} // namespace compression
#pragma once
#include "Compressor.hpp"
-#include "NonCopyable.hpp"
+
+#include <NonCopyable.hpp>
#include <cstdio>
+namespace compression {
+
// A compressor of an uncompressed stream.
class NullCompressor : public Compressor, NonCopyable
{
private:
FILE* m_stream;
};
+
+} // namespace compression
#include <core/exceptions.hpp>
-NullDecompressor::NullDecompressor(FILE* stream) : m_stream(stream)
+namespace compression {
+
+NullDecompressor::NullDecompressor(FILE* const stream) : m_stream(stream)
{
}
void
-NullDecompressor::read(void* data, size_t count)
+NullDecompressor::read(void* const data, const size_t count)
{
if (fread(data, count, 1, m_stream) != 1) {
throw core::Error("failed to read from uncompressed stream");
throw core::Error("garbage data at end of uncompressed stream");
}
}
+
+} // namespace compression
#pragma once
#include "Decompressor.hpp"
-#include "NonCopyable.hpp"
+
+#include <NonCopyable.hpp>
#include <cstdio>
+namespace compression {
+
// A decompressor of an uncompressed stream.
class NullDecompressor : public Decompressor, NonCopyable
{
private:
FILE* m_stream;
};
+
+} // namespace compression
#include <algorithm>
-ZstdCompressor::ZstdCompressor(FILE* stream, int8_t compression_level)
+namespace compression {
+
+ZstdCompressor::ZstdCompressor(FILE* const stream, int8_t compression_level)
: m_stream(stream),
m_zstd_stream(ZSTD_createCStream())
{
}
void
-ZstdCompressor::write(const void* data, size_t count)
+ZstdCompressor::write(const void* const data, const size_t count)
{
m_zstd_in.src = data;
m_zstd_in.size = count;
m_zstd_out.pos = 0;
ret = ZSTD_compressStream(m_zstd_stream, &m_zstd_out, &m_zstd_in);
ASSERT(!(ZSTD_isError(ret)));
- size_t compressed_bytes = m_zstd_out.pos;
+ const size_t compressed_bytes = m_zstd_out.pos;
if (fwrite(buffer, 1, compressed_bytes, m_stream) != compressed_bytes
|| ferror(m_stream)) {
throw core::Error("failed to write to zstd output stream ");
m_zstd_out.size = sizeof(buffer);
m_zstd_out.pos = 0;
ret = ZSTD_endStream(m_zstd_stream, &m_zstd_out);
- size_t compressed_bytes = m_zstd_out.pos;
+ const size_t compressed_bytes = m_zstd_out.pos;
if (fwrite(buffer, 1, compressed_bytes, m_stream) != compressed_bytes
|| ferror(m_stream)) {
throw core::Error("failed to write to zstd output stream");
{
write(nullptr, 0);
}
+
+} // namespace compression
#pragma once
#include "Compressor.hpp"
-#include "NonCopyable.hpp"
+
+#include <NonCopyable.hpp>
#include <zstd.h>
#include <cstdint>
+namespace compression {
+
// A compressor of a Zstandard stream.
class ZstdCompressor : public Compressor, NonCopyable
{
ZSTD_outBuffer m_zstd_out;
int8_t m_compression_level;
};
+
+} // namespace compression
#include <core/exceptions.hpp>
-ZstdDecompressor::ZstdDecompressor(FILE* stream)
+namespace compression {
+
+ZstdDecompressor::ZstdDecompressor(FILE* const stream)
: m_stream(stream),
m_input_size(0),
m_input_consumed(0),
m_zstd_stream(ZSTD_createDStream()),
m_reached_stream_end(false)
{
- size_t ret = ZSTD_initDStream(m_zstd_stream);
+ const size_t ret = ZSTD_initDStream(m_zstd_stream);
if (ZSTD_isError(ret)) {
ZSTD_freeDStream(m_zstd_stream);
throw core::Error("failed to initialize zstd decompression stream");
}
void
-ZstdDecompressor::read(void* data, size_t count)
+ZstdDecompressor::read(void* const data, const size_t count)
{
size_t bytes_read = 0;
while (bytes_read < count) {
m_zstd_out.dst = static_cast<uint8_t*>(data) + bytes_read;
m_zstd_out.size = count - bytes_read;
m_zstd_out.pos = 0;
- size_t ret = ZSTD_decompressStream(m_zstd_stream, &m_zstd_out, &m_zstd_in);
+ const size_t ret =
+ ZSTD_decompressStream(m_zstd_stream, &m_zstd_out, &m_zstd_in);
if (ZSTD_isError(ret)) {
throw core::Error("failed to read from zstd input stream");
}
throw core::Error("garbage data at end of zstd input stream");
}
}
+
+} // namespace compression
#include <cstdint>
+namespace compression {
+
// A decompressor of a Zstandard stream.
class ZstdDecompressor : public Decompressor
{
ZSTD_outBuffer m_zstd_out;
bool m_reached_stream_end;
};
+
+} // namespace compression
// this program; if not, write to the Free Software Foundation, Inc., 51
// Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
-#include "Compression.hpp"
-
-#include "Config.hpp"
-#include "Context.hpp"
-#include "assertions.hpp"
+#include "types.hpp"
+#include <Config.hpp>
+#include <Context.hpp>
+#include <assertions.hpp>
#include <core/exceptions.hpp>
-namespace Compression {
+namespace compression {
int8_t
level_from_config(const Config& config)
}
Type
-type_from_int(uint8_t type)
+type_from_int(const uint8_t type)
{
switch (type) {
case static_cast<uint8_t>(Type::none):
}
std::string
-type_to_string(Type type)
+type_to_string(const Type type)
{
switch (type) {
case Type::none:
ASSERT(false);
}
-} // namespace Compression
+} // namespace compression
class Config;
-namespace Compression {
+namespace compression {
enum class Type : uint8_t {
none = 0,
Type type_from_int(uint8_t type);
-std::string type_to_string(Compression::Type type);
+std::string type_to_string(Type type);
-} // namespace Compression
+} // namespace compression
test_Args.cpp
test_AtomicFile.cpp
test_Checksum.cpp
- test_Compression.cpp
test_Config.cpp
test_Counters.cpp
test_Depfile.cpp
test_argprocessing.cpp
test_ccache.cpp
test_compopt.cpp
+ test_compression_types.cpp
test_hashutil.cpp
test_util_Tokenizer.cpp
test_util_expected.cpp
// this program; if not, write to the Free Software Foundation, Inc., 51
// Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
-#include "../src/Compression.hpp"
-#include "../src/Compressor.hpp"
-#include "../src/Decompressor.hpp"
#include "../src/File.hpp"
#include "TestUtil.hpp"
+#include <compression/Compressor.hpp>
+#include <compression/Decompressor.hpp>
+#include <compression/types.hpp>
+
#include "third_party/doctest.h"
#include <cstring>
+using compression::Compressor;
+using compression::Decompressor;
using TestUtil::TestContext;
TEST_SUITE_BEGIN("NullCompression");
-TEST_CASE("Compression::Type::none roundtrip")
+TEST_CASE("compression::Type::none roundtrip")
{
TestContext test_context;
File f("data.uncompressed", "w");
auto compressor =
- Compressor::create_from_type(Compression::Type::none, f.get(), 1);
+ Compressor::create_from_type(compression::Type::none, f.get(), 1);
CHECK(compressor->actual_compression_level() == 0);
compressor->write("foobar", 6);
compressor->finalize();
f.open("data.uncompressed", "r");
auto decompressor =
- Decompressor::create_from_type(Compression::Type::none, f.get());
+ Decompressor::create_from_type(compression::Type::none, f.get());
char buffer[4];
decompressor->read(buffer, 4);
// this program; if not, write to the Free Software Foundation, Inc., 51
// Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
-#include "../src/Compression.hpp"
-#include "../src/Compressor.hpp"
-#include "../src/Decompressor.hpp"
#include "../src/File.hpp"
#include "TestUtil.hpp"
+#include <compression/Compressor.hpp>
+#include <compression/Decompressor.hpp>
+#include <compression/types.hpp>
+
#include "third_party/doctest.h"
#include <cstring>
+using compression::Compressor;
+using compression::Decompressor;
using TestUtil::TestContext;
TEST_SUITE_BEGIN("ZstdCompression");
-TEST_CASE("Small Compression::Type::zstd roundtrip")
+TEST_CASE("Small compression::Type::zstd roundtrip")
{
TestContext test_context;
File f("data.zstd", "wb");
auto compressor =
- Compressor::create_from_type(Compression::Type::zstd, f.get(), 1);
+ Compressor::create_from_type(compression::Type::zstd, f.get(), 1);
CHECK(compressor->actual_compression_level() == 1);
compressor->write("foobar", 6);
compressor->finalize();
f.open("data.zstd", "rb");
auto decompressor =
- Decompressor::create_from_type(Compression::Type::zstd, f.get());
+ Decompressor::create_from_type(compression::Type::zstd, f.get());
char buffer[4];
decompressor->read(buffer, 4);
"failed to read from zstd input stream");
}
-TEST_CASE("Large compressible Compression::Type::zstd roundtrip")
+TEST_CASE("Large compressible compression::Type::zstd roundtrip")
{
TestContext test_context;
File f("data.zstd", "wb");
auto compressor =
- Compressor::create_from_type(Compression::Type::zstd, f.get(), 1);
+ Compressor::create_from_type(compression::Type::zstd, f.get(), 1);
for (size_t i = 0; i < 1000; i++) {
compressor->write(data, sizeof(data));
}
f.open("data.zstd", "rb");
auto decompressor =
- Decompressor::create_from_type(Compression::Type::zstd, f.get());
+ Decompressor::create_from_type(compression::Type::zstd, f.get());
char buffer[sizeof(data)];
for (size_t i = 0; i < 1000; i++) {
"failed to read from zstd input stream");
}
-TEST_CASE("Large uncompressible Compression::Type::zstd roundtrip")
+TEST_CASE("Large uncompressible compression::Type::zstd roundtrip")
{
TestContext test_context;
File f("data.zstd", "wb");
auto compressor =
- Compressor::create_from_type(Compression::Type::zstd, f.get(), 1);
+ Compressor::create_from_type(compression::Type::zstd, f.get(), 1);
compressor->write(data, sizeof(data));
compressor->finalize();
f.open("data.zstd", "rb");
auto decompressor =
- Decompressor::create_from_type(Compression::Type::zstd, f.get());
+ Decompressor::create_from_type(compression::Type::zstd, f.get());
char buffer[sizeof(data)];
decompressor->read(buffer, sizeof(buffer));
-// Copyright (C) 2019-2020 Joel Rosdahl and other contributors
+// Copyright (C) 2019-2021 Joel Rosdahl and other contributors
//
// See doc/AUTHORS.adoc for a complete list of contributors.
//
// this program; if not, write to the Free Software Foundation, Inc., 51
// Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
-#include "../src/Compression.hpp"
#include "../src/Config.hpp"
+#include <compression/types.hpp>
+
#include "third_party/doctest.h"
-TEST_SUITE_BEGIN("Compression");
+TEST_SUITE_BEGIN("compression");
-TEST_CASE("Compression::level_from_config")
+TEST_CASE("compression::level_from_config")
{
Config config;
- CHECK(Compression::level_from_config(config) == 0);
+ CHECK(compression::level_from_config(config) == 0);
}
-TEST_CASE("Compression::type_from_config")
+TEST_CASE("compression::type_from_config")
{
Config config;
- CHECK(Compression::type_from_config(config) == Compression::Type::zstd);
+ CHECK(compression::type_from_config(config) == compression::Type::zstd);
}
-TEST_CASE("Compression::type_from_int")
+TEST_CASE("compression::type_from_int")
{
- CHECK(Compression::type_from_int(0) == Compression::Type::none);
- CHECK(Compression::type_from_int(1) == Compression::Type::zstd);
- CHECK_THROWS_WITH(Compression::type_from_int(2), "Unknown type: 2");
+ CHECK(compression::type_from_int(0) == compression::Type::none);
+ CHECK(compression::type_from_int(1) == compression::Type::zstd);
+ CHECK_THROWS_WITH(compression::type_from_int(2), "Unknown type: 2");
}
-TEST_CASE("Compression::type_to_string")
+TEST_CASE("compression::type_to_string")
{
- CHECK(Compression::type_to_string(Compression::Type::none) == "none");
- CHECK(Compression::type_to_string(Compression::Type::zstd) == "zstd");
+ CHECK(compression::type_to_string(compression::Type::none) == "none");
+ CHECK(compression::type_to_string(compression::Type::zstd) == "zstd");
}
TEST_SUITE_END();
projects / thirdparty / ccache.git / commitdiff
