133 lines
2.8 KiB
C++
133 lines
2.8 KiB
C++
#include "DataIngestionLayer.h"
|
|
#include "CommandlineInterface.h"
|
|
#include "Configuration.h"
|
|
#include <iostream>
|
|
#include <istream>
|
|
#include <fstream>
|
|
#include <sstream>
|
|
#include <cstring>
|
|
|
|
using namespace IO;
|
|
|
|
void DataIngestionLayer::Init() {
|
|
|
|
// Set our istream
|
|
switch (Configuration::inputFrom) {
|
|
|
|
// Are we reading from stdin?
|
|
case Configuration::INPUT_FROM::STDIN:
|
|
|
|
// Redirect our istream to stdin
|
|
in = &std::cin;
|
|
break;
|
|
|
|
// Are we reading from a file?
|
|
case Configuration::INPUT_FROM::FILE:
|
|
|
|
// Open the file
|
|
ifs.open(
|
|
Configuration::inputFilename,
|
|
std::ios::in | std::ios::binary
|
|
);
|
|
|
|
// A little bit of error handling
|
|
if (!ifs.good()) {
|
|
throw std::runtime_error( "Unable to open infilestream!");
|
|
}
|
|
|
|
// Redirect our istream to this infilestream
|
|
in = &ifs;
|
|
break;
|
|
|
|
// Are we reading from a parameter?
|
|
case Configuration::INPUT_FROM::PARAMETER:
|
|
|
|
// Create an instringstream with our parameter
|
|
iss = std::istringstream(
|
|
CommandlineInterface::Get()["--intext"].GetString()
|
|
);
|
|
|
|
// Redirect our istream to this instringstream
|
|
in = &iss;
|
|
|
|
break;
|
|
}
|
|
|
|
initialized = true;
|
|
reachedEof = false;
|
|
|
|
// Temporary
|
|
std::size_t n_last_bytes_read = 0;
|
|
char buf[64];
|
|
do {
|
|
memset(buf, 0, sizeof(buf));
|
|
in->read(buf, sizeof(buf));
|
|
n_last_bytes_read = in->gcount();
|
|
std::cout << buf;
|
|
|
|
} while(n_last_bytes_read == 64);
|
|
|
|
|
|
return;
|
|
}
|
|
|
|
void DataIngestionLayer::ReadBlock() {
|
|
if (!initialized) {
|
|
throw std::runtime_error("Attempted to read on uninitialized DataIngestionLayer!");
|
|
}
|
|
|
|
if (!reachedEof) {
|
|
// Create buffer to read into
|
|
char buf[Block::BLOCK_SIZE];
|
|
memset(buf, 0, sizeof(buf));
|
|
|
|
// Read
|
|
in->read(buf, sizeof(buf));
|
|
|
|
// Fetch how much we've read
|
|
const std::size_t n_bytes_read = in->gcount();
|
|
|
|
// Is this fewer bytes than we requested?
|
|
if (n_bytes_read < sizeof(buf)) {
|
|
// Yes: EOF reached.
|
|
reachedEof = true;
|
|
}
|
|
|
|
// Construct a Block from this buf
|
|
Block block;
|
|
block.FromByteString(std::string(buf));
|
|
|
|
// Enqueue it
|
|
blocks.emplace(block);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
bool DataIngestionLayer::ReachedEOF() {
|
|
return reachedEof;
|
|
}
|
|
|
|
bool DataIngestionLayer::IsBlockReady() {
|
|
return blocks.size() > 0;
|
|
}
|
|
|
|
Block DataIngestionLayer::GetNextBlock() {
|
|
if (!IsBlockReady()) {
|
|
throw std::runtime_error("Attempted to get the next block, but there are none left!");
|
|
}
|
|
|
|
// Why... why not just return a T in pop()???
|
|
const Block popped = blocks.front();
|
|
blocks.pop();
|
|
return popped;
|
|
}
|
|
|
|
std::istream* DataIngestionLayer::in;
|
|
std::ifstream DataIngestionLayer::ifs;
|
|
std::istringstream DataIngestionLayer::iss;
|
|
bool DataIngestionLayer::reachedEof = false;
|
|
bool DataIngestionLayer::initialized = false;
|
|
std::queue<Block> DataIngestionLayer::blocks;
|
|
|