src/document.cpp

   1 #include "document.h"
   2 #include "bezier.h"
   3 #include <cstdio>
   4
   5 using namespace IPDF;
   6 using namespace std;
   7
   8 //TODO: Make this work for variable sized Reals
   9
  10 // Loads an std::vector<T> of size num_elements from a file.
  11 template<typename T>
  12 static void LoadStructVector(FILE *src_file, size_t num_elems, std::vector<T>& dest)
  13 {
  14         size_t structsread = 0;
  15         dest.resize(num_elems);
  16         structsread = fread(dest.data(), sizeof(T), num_elems, src_file);
  17         if (structsread != num_elems)
  18                 Fatal("Only read %u structs (expected %u)!", structsread, num_elems);
  19 }
  20
  21 // Saves an std::vector<T> to a file. Size must be saves separately.
  22 template<typename T>
  23 static void SaveStructVector(FILE *dst_file, std::vector<T>& src)
  24 {
  25         size_t written = 0;
  26         written = fwrite(src.data(), sizeof(T), src.size(), dst_file);
  27         if (written != src.size())
  28                 Fatal("Only wrote %u structs (expected %u)!", written, src.size());
  29 }
  30
  31 static void WriteChunkHeader(FILE *dst_file, DocChunkTypes type, uint32_t size)
  32 {
  33         size_t written = 0;
  34         written = fwrite(&type, sizeof(type), 1, dst_file);
  35         if (written != 1)
  36                 Fatal("Could not write Chunk header! (ID)");
  37         written = fwrite(&size, sizeof(size), 1, dst_file);
  38         if (written != 1)
  39                 Fatal("Could not write Chunk header (size)!");
  40 }
  41
  42 static bool ReadChunkHeader(FILE *src_file, DocChunkTypes& type, uint32_t& size)
  43 {
  44         if (fread(&type, sizeof(DocChunkTypes), 1, src_file) != 1)
  45                 return false;
  46         if (fread(&size, sizeof(uint32_t), 1, src_file) != 1)
  47                 return false;
  48         return true;
  49 }
  50
  51 void Document::Save(const string & filename)
  52 {
  53         Debug("Saving document to file \"%s\"...", filename.c_str());
  54         FILE * file = fopen(filename.c_str(), "w");
  55         if (file == NULL)
  56                 Fatal("Couldn't open file \"%s\" - %s", filename.c_str(), strerror(errno));
  57
  58         size_t written;
  59         Debug("Number of objects (%u)...", ObjectCount());
  60         WriteChunkHeader(file, CT_NUMOBJS, sizeof(m_count));
  61         written = fwrite(&m_count, sizeof(m_count), 1, file);
  62         if (written != 1)
  63                 Fatal("Failed to write number of objects!");
  64
  65         Debug("Object types...");
  66         WriteChunkHeader(file, CT_OBJTYPES, m_objects.types.size() * sizeof(ObjectType));
  67         SaveStructVector<ObjectType>(file, m_objects.types);
  68
  69         Debug("Object bounds...");
  70         WriteChunkHeader(file, CT_OBJBOUNDS, m_objects.bounds.size() * sizeof(Rect));
  71         SaveStructVector<Rect>(file, m_objects.bounds);
  72
  73         Debug("Object data indices...");
  74         WriteChunkHeader(file, CT_OBJINDICES, m_objects.data_indices.size() * sizeof(unsigned));
  75         SaveStructVector<unsigned>(file, m_objects.data_indices);
  76
  77         Debug("Bezier data...");
  78         WriteChunkHeader(file, CT_OBJBEZIERS, m_objects.beziers.size() * sizeof(uint8_t));
  79         SaveStructVector<Bezier>(file, m_objects.beziers);
  80
  81         int err = fclose(file);
  82         if (err != 0)
  83                 Fatal("Failed to close file \"%s\" - %s", filename.c_str(), strerror(err));
  84
  85         Debug("Successfully saved %u objects to \"%s\"", ObjectCount(), filename.c_str());
  86 }
  87
  88 void Document::Load(const string & filename)
  89 {
  90         m_objects.bounds.clear();
  91         m_count = 0;
  92         if (filename == "")
  93         {
  94                 Debug("Loaded empty document.");
  95                 return;
  96         }
  97         Debug("Loading document from file \"%s\"", filename.c_str());
  98         FILE * file = fopen(filename.c_str(), "r");
  99         if (file == NULL)
 100                 Fatal("Couldn't open file \"%s\"", filename.c_str(), strerror(errno));
 101
 102         size_t read;
 103
 104         DocChunkTypes chunk_type;
 105         uint32_t chunk_size;
 106         while (ReadChunkHeader(file, chunk_type, chunk_size))
 107         {
 108                 switch(chunk_type)
 109                 {
 110                 case CT_NUMOBJS:
 111                         read = fread(&m_count, sizeof(m_count), 1, file);
 112                         if (read != 1)
 113                                 Fatal("Failed to read number of objects!");
 114                         Debug("Number of objects: %u", ObjectCount());
 115                         break;
 116                 case CT_OBJTYPES:
 117                         Debug("Object types...");
 118                         LoadStructVector<ObjectType>(file, chunk_size/sizeof(ObjectType), m_objects.types);
 119                         break;
 120                 case CT_OBJBOUNDS:
 121                         Debug("Object bounds...");
 122                         LoadStructVector<Rect>(file, chunk_size/sizeof(Rect), m_objects.bounds);
 123                         break;
 124                 case CT_OBJINDICES:
 125                         Debug("Object data indices...");
 126                         LoadStructVector<unsigned>(file, chunk_size/sizeof(unsigned), m_objects.data_indices);
 127                         break;
 128                 case CT_OBJBEZIERS:
 129                         Debug("Bezier data...");
 130                         LoadStructVector<Bezier>(file, chunk_size/sizeof(Bezier), m_objects.beziers);
 131                         break;
 132                 }
 133         }
 134         Debug("Successfully loaded %u objects from \"%s\"", ObjectCount(), filename.c_str());
 135 }
 136
 137 void Document::Add(ObjectType type, const Rect & bounds, unsigned data_index)
 138 {
 139         m_objects.types.push_back(type);
 140         m_objects.bounds.push_back(bounds);
 141         m_objects.data_indices.push_back(data_index);
 142         ++m_count; // Why can't we just use the size of types or something?
 143 }
 144
 145 unsigned Document::AddBezierData(const Bezier & bezier)
 146 {
 147         m_objects.beziers.push_back(bezier);
 148         return m_objects.beziers.size()-1;
 149 }
 150
 151
 152 void Document::DebugDumpObjects()
 153 {
 154         Debug("Objects for Document %p are:", this);
 155         for (unsigned id = 0; id < ObjectCount(); ++id)
 156         {
 157                 Debug("%u. \tType: %u\tBounds: %s", id, m_objects.types[id], m_objects.bounds[id].Str().c_str());
 158         }
 159 }
 160
 161 bool Document::operator==(const Document & equ) const
 162 {
 163         return (ObjectCount() == equ.ObjectCount()
 164                 && memcmp(m_objects.bounds.data(), equ.m_objects.bounds.data(), ObjectCount() * sizeof(Rect)) == 0
 165                 && memcmp(m_objects.data_indices.data(), equ.m_objects.data_indices.data(), ObjectCount() * sizeof(unsigned)) == 0
 166                 && memcmp(m_objects.beziers.data(), equ.m_objects.beziers.data(), m_objects.beziers.size() * sizeof(Bezier)) == 0);
 167 }