C++ DataReader::read方法代码示例

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);
}

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);
}

void Observer::init(DataReader& reader)
{
    static const Card defaultCard(SUIT_LAST, RANK_LAST);
    reader.read(mGameCards, defaultCard);
    reader.read(mGameCardsCount);
    reader.read(mTrumpSuit);
    unsigned int playerAmount;
    reader.read(playerAmount);
    while (playerAmount--) {
        unsigned int playerIndex;
        reader.read(playerIndex);
        unsigned int cardsAmount;
        reader.read(cardsAmount);
        mPlayersCards[mPlayers[playerIndex]] = cardsAmount;
    }
    unsigned int rounds;
    reader.read(rounds);
    while (rounds--) {
        RoundData* roundData = new RoundData();
        loadRoundData(reader, *roundData);
        mRoundsData.push_back(roundData);
    }
    reader.read(mCurrentRoundIndex);
    mRestored = true;
    bool currentRoundDataExist;
    reader.read(currentRoundDataExist);
    if (currentRoundDataExist) {
        mCurrentRoundData = new RoundData();
        loadRoundData(reader, *mCurrentRoundData);
    }
}

void Observer::loadRoundData(DataReader& reader, RoundData& roundData){
    unsigned int players;
    reader.read(players);
    while (players--) {
        unsigned int playerIndex;
        reader.read(playerIndex);
        roundData.mPlayers.push_back(mPlayers[playerIndex]);
    }
    loadMap(reader, roundData.mDroppedCards);
    loadMap(reader, roundData.mPickedUpCards);
}

void Observer::loadMap(DataReader& reader, std::map<const PlayerId*, CardSet>& map)
{
    static const Card defaultCard(SUIT_LAST, RANK_LAST);
    unsigned int mapSize;
    reader.read(mapSize);
    while (mapSize--) {
        unsigned int playerIndex;
        reader.read(playerIndex);
        CardSet cards;
        reader.read(cards, defaultCard);
        map[mPlayers[playerIndex]] = cards;
    }
}

void ClientSocket::readInit(DataReader r)
{
	g.id = r.readInt();
	cout<<"got ID "<<g.id<<'\n';
	int w=r.readInt(), h=r.readInt();
	Area& a=g.area;
	a.w=w,a.h=h;
	a.a = new int[w*h];
	r.read(a.a, 4*w*h);
	int b = r.readInt();
	a.bases.resize(b);
	r.read(&a.bases[0], 4*b);
	cout<<"got map "<<a.w<<' '<<a.h<<'\n';
}

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 ClientSocket::readBullet(DataReader r)
{
    Bullet b;
    r.read(&b,sizeof(Bullet));
    double vol = distvol(length(g.player->loc-b.origin));;
	if (b.type==ROCKET) {
	}else if (b.type==SHOTGUN)
    {
		sounds.push_back(Sound(SHOTGUNSOUND, vol));
    }else if(b.type==BOUNCEGUN)
    {
		sounds.push_back(Sound(MACHINEGUNSOUND,vol));
    }else if(b.type==MACHINEGUN)//MACHINEGUN == FLAMEGUN
    {
        //if(-lastFlame+timef()>0.4){
            sounds.push_back(Sound(FLAMESOUND,vol));
            //lastFlame=timef();
        //}
    } else if (b.type==RAILGUN) {
		sounds.push_back(Sound(RAILSOUND,vol));
	}
    g.bullets_map.insert(b);
	//g.bullets.push_back(*(Bullet*)r.cur);
	//g.bulletIndex[g.bullets.back().id] = g.bullets.size()-1;
}

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 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";
}

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 ClientSocket::readDead(DataReader r){
    int n = r.readInt();
    for(int i=0;i<n;i++)
    {
        Unit u;
        r.read(&u,sizeof(Unit));
        u.shootTime = timef();
        g.deadUnits.push_back(u);
    }
}

void PartawareProvider::read(DataReader &reader) {
	reader.read(this->m_cmc_rays_count);
	reader.read(this->m_cmc_rays_theta);
	reader.read(this->m_vsi_rays_count);
	reader.read(this->m_geodestic_weight);
	reader.read(this->m_angular_weight);
	reader.read(this->m_vsi_weight);
	reader.read(this->m_graph);
}

void Engine::init(DataReader& reader, const std::vector<Player*> players, const std::vector<GameObserver*>& observers)
{
    // check that engine is not initialized yet
    assert(!mPlayerIdCounter);
    assert(mGeneratedIds.empty());
    assert(mPlayers.empty());
    assert(!mDeck);
    assert(mGameObservers.empty());

    // read players count
    std::vector<const PlayerId*>::size_type playersCount;
    reader.read(playersCount);

    assert(players.size() == playersCount);
    // add players
    for (std::vector<Player*>::const_iterator it = players.begin(); it != players.end(); ++it) {
        add(**it);
    }

    const Card defaultCard(SUIT_LAST, RANK_LAST);
    // read each player cards
    for (std::vector<const PlayerId*>::const_iterator it = mGeneratedIds.begin(); it != mGeneratedIds.end(); ++it) {
        CardSet& playerCards = mPlayersCards[*it];
        assert(playerCards.empty());
        reader.read(playerCards, defaultCard);
        mPlayers[*it]->cardsRestored(playerCards);
    }

    // read deck
    Deck deck;
    reader.read(deck, defaultCard);
    Suit trumpSuit;
    reader.read(trumpSuit);
    deck.setTrumpSuit(trumpSuit);
    setDeck(deck);

    // read current player index
    unsigned int currentPlayerindex;
    reader.read(currentPlayerindex);
    mCurrentPlayer = mGeneratedIds[currentPlayerindex];
    // read current round index
    reader.read(mRoundIndex);

    bool roundRunning;
    reader.read(roundRunning);
    if (roundRunning) {
        mCurrentRoundIndex = &mRoundIndex;
        // read current round data
        std::vector<const PlayerId*>::size_type attackersAmount;
        reader.read(attackersAmount);

        while (attackersAmount--) {
            unsigned int attackerIndex;
            reader.read(attackerIndex);
            mAttackers.push_back(mGeneratedIds[attackerIndex]);
        }
        unsigned int defenderIndex;
        reader.read(defenderIndex);
        mDefender = mGeneratedIds[defenderIndex];
        reader.read(mPassedCounter);
        unsigned int currentRoundAttackerIndex;
        reader.read(currentRoundAttackerIndex);
        mCurrentRoundAttackerId = mGeneratedIds[currentRoundAttackerIndex];

        std::vector<Card> attackCards;
        reader.read(attackCards, defaultCard);
        for (std::vector<Card>::iterator it = attackCards.begin(); it != attackCards.end(); ++it) {
            mTableCards.addAttackCard(*it);
        }

        std::vector<Card> defendCards;
        reader.read(defendCards, defaultCard);
        for (std::vector<Card>::iterator it = defendCards.begin(); it != defendCards.end(); ++it) {
            mTableCards.addDefendCard(*it);
        }
        reader.read(mMaxAttackCards);
        reader.read(mDefendFailed);
        mPickAttackCardFromTable = !mDefendFailed && attackCards.size() == defendCards.size() + 1;
    }

    // append observers
    mGameObservers.insert(mGameObservers.end(), observers.begin(), observers.end());

    std::map<const PlayerId*, unsigned int> playersCards;
    for (PlayerIds::const_iterator it = mGeneratedIds.begin(); it != mGeneratedIds.end(); ++it) {
        playersCards[*it] = mPlayersCards[*it].size();
    }
    std::for_each(mGameObservers.begin(), mGameObservers.end(), GameRestoredNotification(mGeneratedIds, playersCards, mDeck->size(), mDeck->trumpSuit(), mTableCards));

    // initialize observers
    unsigned int savedObservers;
    reader.read(savedObservers);
    assert(savedObservers == mGameObservers.size());
    for (std::vector<GameObserver*>::iterator it = mGameObservers.begin(); it != mGameObservers.end(); ++it) {
        unsigned int observerDataStart = reader.position();
        (*it)->init(reader);
        unsigned int actualObserverDataSize = reader.position() - observerDataStart;
        unsigned int expectedObserverDataSize;
        reader.read(expectedObserverDataSize);
        assert(actualObserverDataSize == expectedObserverDataSize);
//.........这里部分代码省略.........

void ClientSocket::readBCount(DataReader r)
{
	r.read(g.bcnt, 8*4);
	while(g.weapon && !g.bcnt[g.weapon]) --g.weapon;
}