dig.hpp

Go to the documentation of this file.

#pragma once
 
#include <map>
#include <vector>
 
#include "NNL/common/fixed_type.hpp"
#include "NNL/common/io.hpp"
 
namespace nnl {


namespace dig {

template <typename TData = Buffer>
struct TFileRecord {
  bool is_compressed = false;  
  u32 decompressed_size = 0;   
  u16 num_entries = 0;         
  TData buffer;                
};

using FileRecord = TFileRecord<Buffer>;

using FileRecordView = TFileRecord<BufferView>;

using Dig = std::vector<FileRecord>;
using DigView = std::vector<FileRecordView>;

bool IsOfType(BufferView buffer);
 
bool IsOfType(const std::filesystem::path& path);
 
bool IsOfType(Reader& f);
Dig Import(BufferView buffer);
 
Dig Import(const std::filesystem::path& path);
 
Dig Import(Reader& f);
DigView ImportView(BufferView buffer);

[[nodiscard]] Buffer Export(const Dig& cfcdig);
 
void Export(const Dig& cfcdig, const std::filesystem::path& path);
 
void Export(const Dig& cfcdig, Writer& f);
 
[[nodiscard]] Buffer Export(const DigView& cfcdig);
 
void Export(const DigView& cfcdig, const std::filesystem::path& path);
 
void Export(const DigView& cfcdig, Writer& f);


Buffer Decompress(BufferView buffer, u32 decompressed_size);
Buffer Compress(BufferView buffer);
 
namespace raw {
constexpr u32 kBlockSize = 0x800U;  
 
NNL_PACK(struct RFileRecord {
  u32 offset = 0;  // in blocks (*0x800)
  u32 compressed_size = 0;
  u16 num_entries = 0;
  u16 is_compressed = 0;
  u32 decompressed_size = 0;
});
 
static_assert(sizeof(RFileRecord) == 0x10);
 
template <typename TData = Buffer>
struct RDig {
  std::vector<RFileRecord> file_records;
 
  // Maps of offsets (used in the structures above) to their data:
  std::map<u32, TData> file_buffers;
};
 
RDig<Buffer> Parse(Reader& f);
 
RDig<BufferView> ParseView(BufferView f);
 
Dig Convert(RDig<Buffer>&& cfcdig);
 
DigView Convert(RDig<BufferView>&& cfcdig);
}  // namespace raw
 
}  // namespace dig

}  // namespace nnl