Esempio n. 1
0
/**
 * Reads the headers of a region file: chunk offsets/timestamps
 */
bool RegionFile::readHeaders(std::ifstream& file) {
	if (!file)
		return false;
	containing_chunks.clear();

	for (int i = 0; i < 1024; i++) {
		chunk_offsets[i] = 0;
		chunk_timestamps[i] = 0;
	}

	file.seekg(0, std::ios::end);
	int filesize = file.tellg();
	file.seekg(0, std::ios::beg);
	// make sure the region file has a header
	if (filesize < 8192) {
		return false;
	}

	for (int x = 0; x < 32; x++) {
		for (int z = 0; z < 32; z++) {
			file.seekg(4 * (x + z * 32), std::ios::beg);
			int tmp;
			file.read(reinterpret_cast<char*>(&tmp), 4);
			if (tmp == 0)
				continue;
			int offset = util::bigEndian32(tmp << 8) * 4096;
			//uint8_t sectors = ((uint8_t*) &tmp)[3];

			file.seekg(4096, std::ios::cur);
			int timestamp;
			file.read(reinterpret_cast<char*>(&timestamp), 4);
			timestamp = util::bigEndian32(timestamp);

			ChunkPos pos(x + regionpos.x * 32, z + regionpos.z * 32);
			if (rotation)
				pos.rotate(rotation);

			containing_chunks.insert(pos);

			chunk_offsets[z * 32 + x] = offset;
			chunk_timestamps[z * 32 + x] = timestamp;
		}
	}
	return true;
}
Esempio n. 2
0
File: Mz.cpp Progetto: cpzhang/zen
void Mz::decodeSubMesh( std::ifstream& f, int s )
{
	if (mVersion >= 20)
	{
		mSubmeshes.resize(s / sizeof(sSubMesh), sSubMeshWithName());
		size_t i = 0;
		while (s > 0)
		{
			f.read((char*)&mSubmeshes[i], sizeof(sSubMesh));
			f.read(mSubmeshes[i].name, mSubmeshes[i].nameLen);

			s -= (sizeof(sSubMesh) + mSubmeshes[i].nameLen);

			++i;
		}
		mSubmeshes.resize(i);
	} 
	else
	{
		mSubmeshes.resize(s / sizeof(sSubMeshWithName_V3), sSubMeshWithName());
		size_t i = 0;
		sSubMeshWithName_V3 v3;
		while (s > 0)
		{
			f.read((char*)&v3, sizeof(sSubMeshWithName_V3));
			memcpy(&mSubmeshes[i], &v3, sizeof(sSubMesh) - sizeof(u8));
			mSubmeshes[i].nameLen = strlen(v3.name);
			memcpy(mSubmeshes[i].name, v3.name, sizeof(mSubmeshes[i].name));
			s -= sizeof(sSubMeshWithName_V3);

			++i;
		}
	}
	for(int i = 0; i != mSubmeshes.size(); ++i)
	{
		sSubMeshWithName& s = mSubmeshes[i];
		for(int k = 0; k != 128; ++k)
		{
			if(s.name[k] == '|' || s.name[k] == ' ')
			{
				s.name[k] = '_';
			}
		}
	}
}
Esempio n. 3
0
void
Producer::populateSegments(std::ifstream& ifs)
{
  BOOST_ASSERT(m_segments.size() == 0);

  // calculate how many segments are needed
  std::streampos begin, end;
  begin = ifs.tellg();
  ifs.seekg(0, std::ios::end);
  end = ifs.tellg();

  int num_segments = (end-begin) / m_maxSegmentSize;
  if ((end-begin) % m_maxSegmentSize != 0)
    num_segments++;

  std::cout << "Size of the file: " << (end-begin) << " bytes." << std::endl;
  std::cout << "Maximum size of a segment: " << m_maxSegmentSize << " bytes." << std::endl;
  std::cout << "Number of segments: " << num_segments << std::endl;

  std::vector<uint8_t> buffer(m_maxSegmentSize);
  ifs.seekg(0, std::ios::beg);
  for (int i = 0; i < (end-begin) / m_maxSegmentSize; ++i) {
    ifs.read(reinterpret_cast<char*>(buffer.data()), m_maxSegmentSize);
    auto data = make_shared<Data>(Name(m_prefix).appendSegment(i));
    data->setFreshnessPeriod(m_freshnessPeriod);
    data->setContent(&buffer[0], m_maxSegmentSize);
    //std::cout << *data << std::endl;
    m_segments.push_back(data);
  }

  if ((end-begin) % m_maxSegmentSize != 0) {
    ifs.read(reinterpret_cast<char*>(buffer.data()), (end-begin) % m_maxSegmentSize);
    auto data = make_shared<Data>(Name(m_prefix).appendSegment(m_segments.size()));
    data->setFreshnessPeriod(m_freshnessPeriod);
    data->setContent(&buffer[0], (end-begin) % m_maxSegmentSize);
    //std::cout << *data << std::endl;
    m_segments.push_back(data);
  }

  auto finalBlockId = name::Component::fromSegment(m_segments.size() - 1);
  for (const auto& data : m_segments) {
    data->setFinalBlockId(finalBlockId);
    m_keyChain.sign(*data, m_signingInfo);
  }
}
Esempio n. 4
0
/*
 * Read a string from the file stream.
 */
std::string FileInput::ReadString8(std::ifstream &instr, int32_t len)
{
	char *buf = new char [len+1];
	instr.read(buf, len);
	buf[len]=0;
	std::string s=buf;
	delete[] buf;
	return s;
}
Esempio n. 5
0
	/**@brief read one char from file handle
	 *
	 * @return read a char read from file_
	 */
	inline const unsigned char nextChar()
	{
		char out;
		if (file_.read(&out, 1)) {
			return out;
		} else {
			throw Exception(__PRETTY_FUNCTION__, "Error reading file.");
		}
	}
static void loadVec3Array(std::ifstream& fin, std::vector<ml::vec3f>& array) {
    int array_size;
    fin.read((char*)(&array_size), sizeof(int));
    array.resize(array_size);
    for (int i = 0; i < array_size; ++i) {
        loadVec3(fin, array[i]);
    }
    return;
}
Esempio n. 7
0
// Helper function to read a null terminated c-str from an ifstream.
std::string readNullTermString(std::ifstream & fileHandle) {
	std::string value;
	while (true) {
		char c;
		fileHandle.read(&c, sizeof(char));
		if (c != '\0') { value.push_back(c); }
		else { return value; }
	}
}
Esempio n. 8
0
CartridgeHeader RomParser::parse(std::ifstream& rom)
{
    CartridgeHeader header;

    rom.seekg(0x100, std::ios::beg);
    rom.read((char*)&header, sizeof(CartridgeHeader));

    return header;
}
Esempio n. 9
0
ByteString read_bytes_from_stream(std::ifstream& stream, size_t size)
{
	char* cbuff = new char[size];
	stream.read(cbuff, size);
	ByteString bytes(reinterpret_cast<uint8_t*>(cbuff), size);
	delete[] cbuff;

	return bytes;
}
Esempio n. 10
0
unsigned char iReadByte (std::ifstream & ifile)
{
  // will read 1 byte from the file
    char b;

    ifile.read(&b, 1);

    return b;
}
Esempio n. 11
0
BitVector::BitVector(std::ifstream& file) :
  rank_index(0), select_index(0)
{
  file.read((char*)&(this->size), sizeof(this->size));
  file.read((char*)&(this->items), sizeof(this->items));
  file.read((char*)&(this->number_of_blocks), sizeof(this->number_of_blocks));
  file.read((char*)&(this->block_size), sizeof(this->block_size));

  usint* array_buffer = new usint[this->block_size * this->number_of_blocks];
  file.read((char*)(array_buffer), this->block_size * this->number_of_blocks * sizeof(usint));
  this->array = array_buffer;

  this->integer_bits = length(this->size);
  this->samples = new ReadBuffer(file, 2 * (this->number_of_blocks + 1), this->integer_bits);

  this->indexForRank();
  this->indexForSelect();
}
Esempio n. 12
0
binary_reader::market_message::market_message( std::ifstream& _in )
    : m_type(readValue<boost::uint32_t>(_in))
    , m_time(readValue<boost::uint32_t>(_in))
    , m_len(readValue<boost::uint32_t>(_in))
{
    m_msg = new char[m_len + 1];
    _in.read(&m_msg[0], m_len);
    m_msg[m_len] = '\0';
}
Esempio n. 13
0
bool VCFont::ParseCommon(std::ifstream& f)
{
	char blockType = ReadInt8(f);
	int blockSize = ReadInt32(f);

	f.read((char*) &Common, 15);
	
	return true;
}
Esempio n. 14
0
/*---------------------------------------------------------*/
bool NOMAD::Cache_File_Point::read ( std::ifstream & fin )
{
  reset();

  // 1. _eval_status:
  fin.read ( (char *) &_eval_status , sizeof(_eval_status) );
  if ( fin.fail() || _eval_status > 3 )
    return false;

  // 2. _n:
  fin.read ( (char *) &_n , sizeof(_n) );
  if ( fin.fail() || _n <= 0 ) {
    _n = 0;
    return false;
  }

  // 3. _m:
  fin.read ( (char *) &_m , sizeof(_m) );
  if ( fin.fail() || _m < 0 ) {
    _n = _m = 0;
    return false;
  }

  // 4. _m_def:
  fin.read ( (char *) &_m_def , sizeof(_m_def) );
  if ( fin.fail() || _m_def < 0 ) {
    _m_def = _n = _m = 0;
    return false;
  }

  // 5. _coords:
  _coords = new double [_n];
  fin.read ( (char *) _coords , _n*sizeof(double) );
  if ( fin.fail() ) {
    reset();
    return false;
  }

  if ( _m_def > 0 ) {

    // 6. _bb_def:
    _bbo_def = new double [_m_def];
    fin.read ( (char *) _bbo_def , _m_def*sizeof(double) );
    if ( fin.fail() ) {
      reset();
      return false;
    }
  
    // 7. _bbo_index:
    _bbo_index = new int [_m_def];
    fin.read ( (char *) _bbo_index , _m_def*sizeof(int) );
    if ( fin.fail() ) {
      reset();
      return false;
    }
  }

  return true;
}
bool WLMatLib::MATReader::readMatrixDouble( Eigen::MatrixXd* const matrix, const ElementInfo_t& element, std::ifstream& ifs,
                const FileInfo_t& info )
{
    // Check some errors //
    // ----------------- //
    if( matrix == NULL )
    {
        wlog::error( LIBNAME ) << "Matrix object is null!";
        return false;
    }

    if( info.fileSize <= static_cast< size_t >( element.posData ) )
    {
        wlog::error( LIBNAME ) << "Data position is beyond file end!";
        return false;
    }

    if( element.dataType != DataTypes::miMATRIX )
    {
        wlog::error( LIBNAME ) << "Data type is not a matrix: " << element.dataType;
        return false;
    }

    const mArrayType_t arrayType = ArrayFlags::getArrayType( element.arrayFlags );
    if( arrayType != ArrayTypes::mxDOUBLE_CLASS )
    {
        wlog::error( LIBNAME ) << "Numeric Types does not match!";
        return false;
    }

    const std::streampos pos = ifs.tellg();

    // Read data //
    // --------- //
    ifs.seekg( element.posData );
    mDataType_t type;
    mNumBytes_t bytes;
    if( !readTagField( &type, &bytes, ifs ) )
    {
        wlog::error( LIBNAME ) << "Could not read Data Element!";
        ifs.seekg( pos );
        return false;
    }
    if( type != DataTypes::miDOUBLE )
    {
        wlog::error( LIBNAME ) << "Numeric Types does not match or compressed data, which is not supported: " << type;
        ifs.seekg( pos );
        return false;
    }

    matrix->resize( element.rows, element.cols );
    ifs.read( ( char* )matrix->data(), bytes );

    nextElement( ifs, element.posData, bytes );
    return true;
}
Esempio n. 16
0
bool Archiver::readFooter(std::ifstream &tar) {
	String footer(12, '\0');
	const char FOOTER[] = "END ARCHIVE\0";
	if (tar.read(&footer[0], footer.length())) {
		for (unsigned char i = 0; i < footer.length(); i++)
			if (footer[i] != FOOTER[i]) return false;
		return true;
	}
	return false;
}
Esempio n. 17
0
bool Archiver::readHeader(std::ifstream &tar) {
	String header(8, '\0');
	const char HEADER[] = "ARCHIVE\0";
	if (tar.read(&header[0], header.length())) {
		for (unsigned char i = 0; i < header.length(); i++)
			if (header[i] != HEADER[i]) return false;
		return true;
	}
	return false;
}
Esempio n. 18
0
  /*
  ** Unserialize std::string
  */
  inline void			unserialize(std::ifstream &file, std::string & a)
  {
    int				    strSize;
    unserialize(file, strSize);
	char                *str = new char[strSize + 1]();
    file.read(str, strSize);
	str[strSize] = '\0';
	a.assign(str);
	delete[] str;
  }
Esempio n. 19
0
/**
Loads and checks both bitmap file and info headers.

@param[in] FileStream   The input file stream.
@param[out] FileHeader  The bitmap file header read from the file.
@param[out] InfoHeader  The bitmap info header read from the file.

@return One of #BitmapLoadStatus codes.
*/
static BitmapLoadStatus LoadAndValidateHeaders(std::ifstream& FileStream, BitmapFileHeader* FileHeader,
                                               BitmapInfoHeader* InfoHeader)
{
    FileStream.read(reinterpret_cast<char*>(FileHeader), sizeof(*FileHeader));
    if (FileStream.bad()) {
        return INVALID_FILE_HEADER;
    }

    if (!ValidateFileHeader(*FileHeader)) {
        return INVALID_FILE_HEADER;
    }

    FileStream.read(reinterpret_cast<char*>(InfoHeader), sizeof(*InfoHeader));
    if (FileStream.bad() || !ValidateInfoHeader(*InfoHeader)) {
        return INVALID_INFO_HEADER;
    }

    return LOAD_SUCCESS;
}
Esempio n. 20
0
int iReadInt(std::ifstream & ifile)
{
  // will use 4 bytes from the file to read an int (according to the MSG definition of int)
    unsigned char buf [4];

    ifile.read((char*)buf, 4);
    int iResult = (buf[0]<<24)+(buf[1]<<16)+(buf[2]<<8)+buf[3];

    return iResult;
}
Esempio n. 21
0
tile::tile(std::ifstream& file) : contours()
{
	int contourCount = 0;
	file.read((char*)&contourCount, 4);
	for(int i = 0; i < contourCount; i++)
	{
		contour c(file);
		contours.push_back(c);
	}
}
Esempio n. 22
0
std::unique_ptr<TorchStage> ParallelTable::loadFromFile(std::ifstream& file) {
  int n_nodes;
  file.read(reinterpret_cast<char*>(&n_nodes), sizeof(n_nodes));
  std::unique_ptr<ParallelTable> ret(new ParallelTable());
  ret->network_.reserve(n_nodes);
  for (int32_t i = 0; i < n_nodes; i++) {
    ret->network_.push_back(TorchStage::loadFromFile(file));
  }
  return std::unique_ptr<TorchStage>(std::move(ret));
}
Esempio n. 23
0
void STLFile::read_binary( std::ifstream &ifstr )
{
    // Skip header
    char buf[80];
    ifstr.read( buf, 80 );

    // Read number of triangles
    uint32_t tcount;
    ifstr.read( (char *)(&tcount), 4 );

    // Check if sensible
    if( tcount > 10000000 )
	throw( ErrorUnimplemented( ERROR_LOCATION, "Too high number of triangles" ) );
    _tri.reserve( tcount );

    // Read triangles
    for( uint32_t a = 0; a < tcount; a++ )
	_tri.push_back( Triangle( ifstr ) );
}
Esempio n. 24
0
static bool readIStat( std::ifstream &in, int sflg, char *flag )
{
  if ( sflg == CF_FLAG_SIZE )
  {
    in.read( flag, sflg );
    if ( !in )
      return true; // error
  }
  else
  {
    int istat;
    in.read( reinterpret_cast< char * >( &istat ), sflg );
    if ( !in )
      return true; // error
    else
      *flag = ( istat == 1 );
  }
  return false;
}
 void ReadSharedArray(std::ifstream &saIn) {
     std::cout << "reading a shared suffix array index." << std::endl;
     saIn.read((char*) &this->length, sizeof(int));
     indexHandle = "suffixarray.index." + shmIdTag;
     AllocateMappedShare(indexHandle, this->length + 1, indexShared, indexID);
     std::cout << "the shared index is: " << indexShared << std::endl;
     this->index = indexShared;
     std::cout << "the index used is: " << this->index << std::endl;
     this->ReadAllocatedArray(saIn);
 }
Esempio n. 26
0
  inline void load(std::ifstream& ifs, MatD& params){
    Real val = 0.0;
    
    for (int i = 0; i < params.cols(); ++i){
      for (int j = 0; j < params.rows(); ++j){
	ifs.read((char*)&val, sizeof(Real));
	params.coeffRef(j, i) = val;
      }
    }
  }
Esempio n. 27
0
std::string CMuleCollection::ReadString(std::ifstream& infile, int TagType = 0x02)
{
	if (TagType >= 0x11 && TagType <= 0x20) {
		std::vector<char> buffer(TagType - 0x10);
		infile.read(&buffer[0], TagType - 0x10);
		return buffer.empty() ?
			std::string() :
			std::string (buffer.begin(), buffer.end());
	}
	if (TagType == 0x02) {
		uint16_t TagStringSize = ReadInt<uint16_t>(infile);
		std::vector<char> buffer (TagStringSize);
		infile.read(&buffer[0], TagStringSize);
		return buffer.empty() ?
			std::string() :
			std::string (buffer.begin(), buffer.end());
	}
	return std::string();
}
Esempio n. 28
0
bool LightRecord::loadFromStream(std::ifstream& inStream)
{
  if (!inStream.good())
  {
    DuskLog() << "LightRecord::loadFromStream: ERROR: stream contains errors.\n";
    return false;
  }
  char ID_Buffer[256];
  uint32_t Header = 0;
  inStream.read((char*) &Header, sizeof(uint32_t));
  if (Header != cHeaderLight)
  {
    DuskLog() << "LightRecord::loadFromStream: ERROR: invalid record header.\n";
    return false;
  }
  //read ID length
  Header = 0;
  inStream.read((char*) &Header, sizeof(uint32_t));
  if (Header>255)
  {
    DuskLog() << "LightRecord::loadFromStream: ERROR: ID is longer than 255"
              << "characters.\n";
    return false;
  }
  //read ID
  memset(ID_Buffer, 0, Header+1);
  inStream.read(ID_Buffer, Header);
  if (!inStream.good())
  {
    DuskLog() << "LightRecord::loadFromStream: ERROR while reading light's"
              << " ID from stream.\n";
    return false;
  }
  ID_Buffer[Header] = '\0'; //make sure it's NUL-terminated
  ID = std::string(ID_Buffer);
  //read RGB and radius
  inStream.read((char*) &red, sizeof(float));
  inStream.read((char*) &green, sizeof(float));
  inStream.read((char*) &blue, sizeof(float));
  inStream.read((char*) &radius, sizeof(float));
  //read light type
  inStream.read((char*) &type, sizeof(Ogre::Light::LightTypes));
  if (!inStream.good())
  {
    DuskLog() << "LightRecord::loadFromStream: ERROR while reading light's"
              << " colour values from stream.\n";
    return false;
  }
  //normalise values, just to be safe
  normalise();
  return true;
}
Esempio n. 29
0
// biSize以外を読み込む.biSizeはヘッダ識別のために既に読み込んでいるはずだから飛ばす.
int LoadInfoHeader( std::ifstream& ifs, BITMAPINFOHEADER& header ) {
	ifs.read( reinterpret_cast< char* >( &header.biWidth ), 4 );
	ifs.read( reinterpret_cast< char* >( &header.biHeight ), 4 );
	ifs.read( reinterpret_cast< char* >( &header.biPlanes ), 2 );
	ifs.read( reinterpret_cast< char* >( &header.biBitCount ), 2 );
	ifs.read( reinterpret_cast< char* >( &header.biCompression ), 4 );
	ifs.read( reinterpret_cast< char* >( &header.biSizeImage ), 4 );
	ifs.read( reinterpret_cast< char* >( &header.biXPelsPerMeter ), 4 );
	ifs.read( reinterpret_cast< char* >( &header.biYPelsPerMeter ), 4 );
	ifs.read( reinterpret_cast< char* >( &header.biClrUsed ), 4 );
	ifs.read( reinterpret_cast< char* >( &header.biClrImportant ), 4 );
	return ifs.fail();
}
Esempio n. 30
0
/*!
\param[in] ifs input file stream
\param[out] in_mat mat to load
*/
bool readMatBinary(std::ifstream& ifs, cv::Mat& in_mat)
{
	if(!ifs.is_open()){
		return false;
	}
	
	int rows, cols, type;
	ifs.read((char*)(&rows), sizeof(int));
	if(rows==0){
		return true;
	}
	ifs.read((char*)(&cols), sizeof(int));
	ifs.read((char*)(&type), sizeof(int));

	in_mat.release();
	in_mat.create(rows, cols, type);
	ifs.read((char*)(in_mat.data), in_mat.elemSize() * in_mat.total());

	return true;
}