C++ DataReader类代码示例

bool TestDataReaders::TestCSVDataReader(SourceReader* sourceReader, vector<CSVDataType*> results) {
	bool ok = true;
	DataReader* dataReader = new CSVDataReader(sourceReader);

	for (int i = 0; i < results.size(); ++i) {
		CSVDataType* csvDataType = (CSVDataType*) dataReader->GetNextData();

		if (csvDataType == NULL || results[i] == NULL) {
			if (csvDataType != NULL || results[i] != NULL)
				ok = false;
		} else {
			if (csvDataType->GetColNames() != results[i]->GetColNames())
				ok = false;
			else {
				int size = csvDataType->GetColNames().size();
				for (int j = 0; j < size; ++j) {
					if (csvDataType->GetValue(j) != results[i]->GetValue(j)) {
						ok = false;
					}
				}
			}

			delete csvDataType;
		}
	}

	delete dataReader;
	return ok;
}

void SamplingProvider::read(DataReader &reader) {
    reader.read(this->m_sampling_radius);
    reader.read(this->m_curvatures);
    reader.read(this->m_barycentric_areas);
    reader.read(this->m_geodesics);
    reader.read(this->m_samples);
}

int
main(void)
{
	DataReader reader;
	std::vector<fv_t> data;
	std::vector<fv_t> test_data;
	std::vector<label_t> labels;
	std::vector<label_t> test_labels;
	category_index_t category_index;
	NearestCentroidClassifier centroid_classifier;
	TFIDFTransformer tfidf;
	long t = tick();
	long t_all = tick();
	Evaluation evaluation;
	
	if (!reader.open(TRAIN_DATA)) {
		fprintf(stderr, "cant read file\n");
		return -1;
	}
	reader.read(data, labels);
	printf("read %ld, %ld, %ldms\n", data.size(), labels.size(), tick() - t);
	reader.close();
	
	t = tick();
	srand(VT_SEED);
	build_category_index(category_index, data, labels);
	split_data(test_data, test_labels, data, labels, category_index, 0.05f);
	build_category_index(category_index, data, labels);
	printf("split train:%ld, test:%ld\n", data.size(), test_data.size());
	
	t = tick();
	tfidf.train(data);
	tfidf.transform(data);
	tfidf.transform(test_data);
	centroid_classifier.train(category_index, data);
	printf("build index %ldms\n", tick() -t );
	
	t = tick();
#ifdef _OPENMP
#pragma omp parallel for schedule(dynamic, 1)	
#endif
	for (int i = 0; i < (int)test_data.size(); ++i) {
		std::vector<int> topn_labels;
		centroid_classifier.predict(topn_labels, K, test_data[i]);
#ifdef _OPENMP
#pragma omp critical
#endif
		{
			evaluation.update(topn_labels, test_labels[i]);
			if (i % 1000 == 0) {
				print_evaluation(evaluation, i, t);
				t = tick();
			}
		}
	}
	printf("----\n");
	print_evaluation(evaluation, test_data.size(), t_all);
	
	return 0;
}

    void
SAMReader::readHeader(
    const char* fileName,
    ReaderContext& context)
{
    DataReader* data = DataSupplier::Default[false]->getDataReader(maxLineLen);
    if (! data->init(fileName)) {
        fprintf(stderr, "Unable to read file %s\n", fileName);
        soft_exit(1);
    }
    // todo: allow for larger headers
    _int64 headerSize = 1024 * 1024; // 1M header max
    char* buffer = data->readHeader(&headerSize);
    if (!parseHeader(fileName, buffer, buffer + headerSize, context.genome, &headerSize, &context.headerMatchesIndex)) {
        fprintf(stderr,"SAMReader: failed to parse header on '%s'\n",fileName);
        soft_exit(1);
    }
    _ASSERT(context.header == NULL);
    char* p = new char[headerSize + 1];
    memcpy(p, buffer, headerSize);
    p[headerSize] = 0;
    context.header = p;
    context.headerBytes = context.headerLength = headerSize;
    delete data;
}

std::unique_ptr<float []>
readVolumeData(const std::string& dtype, const std::string& fpath,
    size_t volx, size_t voly, size_t volz)
{
  bd::DataType t = bd::to_dataType(dtype);
  float* rawdata = nullptr;
  switch (t) {
  case bd::DataType::Float:
    {
      bd::DataReader<float, float> reader;
      reader.loadRaw3d(fpath, volx, voly, volz, false);
      rawdata = reader.takeOwnership();
      break;
    }
  case bd::DataType::UnsignedCharacter:
    {
      bd::DataReader<unsigned char, float> reader;
      reader.loadRaw3d(fpath, volx, voly, volz, false);
      rawdata = reader.takeOwnership();
      break;
    }
  case bd::DataType::UnsignedShort:
    {
      DataReader<unsigned short, float> reader;
      reader.loadRaw3d(fpath, volx, voly, volz, false);
      rawdata = reader.takeOwnership();
      break;
    }
  default:
    break;
  }

  return std::unique_ptr<float[]>(rawdata);
}

void Listener::pushDataPacket(DataReader& reader) {
	if (!_pDataWriter && !init())
		return;

	if(publication.publisher()) {
		if(ICE::ProcessSDPPacket(reader,(Peer&)*publication.publisher(),publication.publisher()->writer(),(Peer&)client,*_pDataWriter))
			return;
	}

	if(_pDataTypeName == typeid(reader).name()) {
		if(!_pDataWriter->writeMedia(Writer::DATA,0,reader.packet,*this))
			init();
		return;
	}

	shared_ptr<DataWriter> pWriter;
	_pDataWriter->createWriter(pWriter);
	if (!pWriter) {
		if(!_pDataWriter->writeMedia(Writer::DATA,0,reader.packet,*this))
			init();
		return;
	}
	
	UInt32 offset = pWriter->packet.size();
	reader.read(*pWriter);
	reader.reset();
	PacketReader packet(pWriter->packet.data(),pWriter->packet.size());
	packet.next(offset);
	if(!_pDataWriter->writeMedia(Writer::DATA,0,packet,*this))
		init();
}

void GeodesicProvider::read(DataReader &reader) {
	reader.read(this->m_source_vertices);
	reader.read(this->m_target_vertices);
	reader.read(this->m_algorithm_option);
	reader.read(this->m_subdivision_level);
	reader.read(this->m_geodesics);
}

bool Solver::read_results() {

    try {

        DataReader dr;

        dr.readAll(gyro::RESULT_FILE, *result_data);

        load(*result_data);

        msg = "Successfully finished!";
    }
    catch (ios_base::failure& ) {

        msg += "failed to read the output of the solver!";
        return FAILED;
    }
    catch (exception& e) {

        msg += "unexpected error ";
        msg += e.what();
        return FAILED;
    }

    return SUCCESS;
}

void ClientSocket::readName(DataReader r){
    int id = r.readInt();
    char buf[33];
    r.read(buf,32);
    if(g.names.size()<=id)g.names.resize(id+20);
    g.names[id] = buf;
    std::cout<<id<<" is "<<buf<<"\n";
}

int VertexLoaderX64::RunVertices(DataReader src, DataReader dst, int count)
{
	m_numLoadedVertices += count;
	return ((int (*)(u8*, u8*, int, const void*))region)(
		src.GetPointer(),
		dst.GetPointer(),
		count,
		memory_base_ptr);
}

void TextAssetExtractor::Extract(FileWriter& writer, DataReader& reader, size_t length)
{
	uint32_t len = reader.ReadNumber<uint32_t>();
	reader.Skip(len);
	reader.Align(4);

	len = reader.ReadNumber<uint32_t>();
	reader.WriteFile(writer, reader.Tell(), len);
}

	int Wav::loadMem(unsigned char *aMem, int aLength)
	{
		if (aMem == NULL || aLength <= 0)
			return INVALID_PARAMETER;

		DataReader dr;
        dr.open(aMem, aLength);
		return testAndLoadFile(&dr);
	}

	int Wav::load(const char *aFilename)
	{
		DataReader dr;
		if (!dr.open(aFilename))
        {
			return FILE_NOT_FOUND;
        }
		return testAndLoadFile(&dr);
	}

void ClientSocket::readItems(DataReader r)
{
	int n=r.readInt();
	Item it;
	for(int i=0; i<n; ++i) {
		r.read(&it, sizeof(it));
		g.items_map.insert(it);
	}
}

void Nikita()
{
    DataReader<int, string> reader;
    
    FibonacciTable<int, string> table;
    
    reader.getData( table );
    
    system( "pause" );
}