FileStreamer.h

Go to the documentation of this file.

#ifndef _MADARA_KNOWLEDGE_FILESTREAMER_H_
#define _MADARA_KNOWLEDGE_FILESTREAMER_H_
 
#include <string>
#include <fstream>
#include <vector>
#include "madara/knowledge/KnowledgeUpdateSettings.h"
#include "madara/knowledge/KnowledgeRecord.h"
#include "madara/utility/Utility.h"
#include "madara/utility/ScopedArray.h"
#include "madara/knowledge/containers/FlexMap.h"
#include "madara/logger/GlobalLogger.h"
 
namespace madara
{
namespace knowledge
{
class FileStreamer
{
public:
  FileStreamer() {}
 
  FileStreamer(
      const std::string& key, const std::string& filename, KnowledgeBase kb)
  {
    init(key, filename, kb);
  }
 
  inline void init(
      const std::string& key, const std::string& filename, KnowledgeBase kb)
  {
    // setup containers
    file_space.set_name(key, kb);
    file_space["size"].to_container(file_size);
    file_space["crc"].to_container(file_crc);
    file_space["contents"].to_container(file_fragments);
    file_fragments.clear();
 
    file_crc.set_name(file_space["crc"].get_name(), kb);
    file_size.set_name(file_space["size"].get_name(), kb);
 
    // setup file information
    filename_ = filename;
    file_crc = (KnowledgeRecord::Integer)utility::file_crc(filename);
    file_size = (KnowledgeRecord::Integer)utility::file_size(filename);
 
    stream_.open(filename, std::ios::in | std::ios::binary);
  }
 
  inline size_t load(size_t index, size_t frag_size = 60000)
  {
    size_t bytes_read = 0;
 
    if (stream_)
    {
      // seek to the index position in the file
      stream_.seekg((std::streampos)index * frag_size, std::ios::beg);
 
      // read the fragment into a local buffer
      std::vector<unsigned char> frag(frag_size);
      // char * frag = new char [frag_size];
      stream_.read((char*)frag.data(), frag_size);
      bytes_read = stream_.gcount();
      frag.resize(bytes_read);
 
      KnowledgeRecord record;
      record.emplace_file(std::move(frag));
 
      // set the file fragment into the KB
      file_fragments.set(std::to_string((unsigned long long)index), record);
      // file_fragments.emplace_file ()
    }
 
    return bytes_read;
  }
 
  inline uint32_t get_crc(void)
  {
    return (uint32_t)file_crc.to_integer();
  }
 
  inline size_t get_size(void)
  {
    return (size_t)file_size.to_integer();
  }
 
  inline std::string get_filename(void)
  {
    return filename_;
  }
 
  inline void clear_fragments(void)
  {
    file_fragments.clear();
  }
 
  inline void modify(void)
  {
    file_size.modify();
    file_crc.modify();
  }
 
  containers::FlexMap file_space;
 
  containers::Integer file_size;
 
  containers::Integer file_crc;
 
  containers::Map file_fragments;
 
private:
  std::string filename_;
 
  std::ifstream stream_;
};
}
}
 
#endif  // _MADARA_KNOWLEDGE_FILESTREAMER_H_