void BatchUpdaterBulletinClickReplicaAdapter::click(int userId, int bulletinId)  {

	MyUtil::IntSeq keyvalue;
	keyvalue.push_back(userId);
	keyvalue.push_back(bulletinId);
	_clientCS.getProxy(INDEX)->inc(keyvalue, 1, BulletinClickName);
}
Пример #2
0
MyUtil::IntSeq OfferCacheDataI::getIds(){
	MyUtil::IntSeq res;
	IceUtil::Mutex::Lock lock(_mutex);
	for(OfferDataNSeq::iterator iter=bestOffers.begin(); iter!=bestOffers.end(); ++iter){
		res.push_back(iter->userId);
	}
	for(OfferDataNSeq::iterator iter=offers.begin(); iter!=offers.end(); ++iter){
		res.push_back(iter->userId);
	}
	return res;
}
void ReloadTask::handle(){
  MyUtil::IntSeq buddies;
  try {
    buddies = BuddyByIdCacheAdapter::instance().getFriendListAsc( _id, -1 );
  } catch( Ice::Exception e ){
    MCE_WARN("[ReloadTask] id=" << _id << " found Ice::Exception : " << e.what() );
    return;
  } catch( ... ){
    MCE_WARN("[ReloadTask] id=" << _id << " found Ice::Exception" );
    return;
  }
  multimap<int, int> orderFriend;
  try{
    Statement sql;
    sql	<< "SELECT guest, UNIX_TIMESTAMP(time) AS time FROM relation_"
      << (_id % 100)
      << " WHERE host="
      << _id;

    ostringstream pattern;
    pattern << "relation_" << (_id % 100);

    QueryRunner("relation_buddycache", CDbRServer, pattern.str()).query(
        sql, OrderedListHandler( buddies, orderFriend, "time", "guest" ) );
  }catch(std::exception& e){
    MCE_WARN( "[ReloadTask] handle " << _id << " std::exception " << e.what() );
    return;
  }catch(...){
    MCE_WARN( "[ReloadTask] handle " << _id << " unknown exception." );
    return;
  }

  int time_now = (int)time(NULL);
  MyUtil::IntSeq times;
  ostringstream timestr;
  for( MyUtil::IntSeq::iterator itB=buddies.begin(); itB!=buddies.end(); ++itB ){
    times.push_back( time_now );
    timestr << time_now << " ";
  }

  for (multimap<int, int>::reverse_iterator itMap = orderFriend.rbegin(); itMap
      != orderFriend.rend(); ++itMap ){
    buddies.push_back(itMap->second);
    times.push_back(itMap->first);
    timestr << itMap->first << " ";
  }

  BuddyByAddTimeDataNPtr obj = new BuddyByAddTimeDataN;
  buddies.swap(obj->friends);
  times.swap(obj->times);

  MCE_INFO("[ReloadTask] id=" << _id << " friends.size()=" << obj->friends.size() << " times=" << timestr.str() );
  SetDataHelper::instance().invokeDelay(_id,obj,timestr.str());
}
Пример #4
0
void UserCounterI::sort() {
	map<int, int> m;
	for (unsigned int i = 0; i < types.size(); ++i) {
		m.insert(make_pair(types[i], values[i]));
	}
	MyUtil::IntSeq t;
	MyUtil::IntSeq v;
	for (map<int, int>::iterator i = m.begin(); i != m.end(); ++i) {
		t.push_back(i->first);
		v.push_back(i->second);
	}
	types = t;
	values = v;
}
Пример #5
0
//获取uid的好友用户中不是gid的粉丝的那些用户
MyUtil::IntSeq MutualFriendsCacheManagerI::getUnMutualFriends(int uid, const MyUtil::GlobalIdPtr& gid, int begin, int limit, const Ice::Current& current) {
	ostringstream msg;
	msg << "uid = " << uid << ", gid = " << GlobalIdTransfer::get(gid) << ", begin = " << begin << ", limit = " << limit;
	InvokeClient ic = InvokeClient::create(current, msg.str(), InvokeClient::INVOKE_LEVEL_INFO);

	MyUtil::IntSeq fids = getAllFansAsc(gid);
	MyUtil::IntSeq uids = getFriendsAsc(uid);
	MyUtil::IntSeq result;

	if (limit < -1 || begin < 0 || uid < 0) {
		return result;
	} else {
		int count = 0;
		int countLimit = (limit == -1) ? uids.size() : limit;
		MyUtil::IntSeq::iterator fit = fids.begin();
		MyUtil::IntSeq::iterator uit = uids.begin();

		while (fit != fids.end() && uit != uids.end() && count < countLimit + begin) {
			if (*fit < *uit) {
				fit++;
			} else if (*uit < *fit) {
				if(count >= begin){
					result.push_back(*uit);
				}
				count++;
				uit++;
			} else {
				fit++;
				uit++;
			}
		}
		return result;
	}
}
Пример #6
0
 void xce::distcache::userapicache::UpdateTask::handle() {
   if(xce::distcache::userapicache::DistUserApiCacheReloaderI::instance().getFilter()->filter(data_->userid))
   {
     xce::distcache::userapicache::UserApiCacheMemDataPtr datad = NULL;
     try {
       datad = GetNewData();
     } catch (std::exception e) {
       MCE_WARN("ReloadTask::handle exception: id=" << data_->userid << ", " << e.what());
     } catch (...) {
       MCE_WARN("ReloadTask::handle exception: id=" << data_->userid << ", Unknown exception");
     }
     if(datad)
     {
       try
       {
         xce::distcache::userapicache::DistUserApiCacheAdapter::instance().set(datad);
       }catch(...)
       {
         MCE_WARN("UpdateTask::handle set distcache Exception: id = " << data_->userid);
       }
     }
     xce::distcache::userapicache::DistUserApiCacheReloaderI::instance().getFilter()->remove(data_->userid);
   }else
   {
     MyUtil::IntSeq ids;
     ids.push_back(data_->userid);
     MCE_WARN("UpdateTask::handle muticall id = " << data_->userid);
     xce::distcache::userapicache::DistUserApiCacheReloaderI::instance().getFilter()->remove(ids);
     xce::distcache::userapicache::DistUserApiCacheReloaderI::instance().addDelayReloadIds(ids);
   }
 }
Пример #7
0
Ice::ObjectPtr UserApiCacheFactoryI::create(Ice::Long id) {
	MCE_WARN("UserApiCacheFactoryI::create -> No Hit For Id: "<<id);
	MyUtil::IntSeq ids;
	ids.push_back(id);
	UserApiCacheReloaderAdapter::instance().getProxy(0)->reload(ids);
        return NULL;
}
Пример #8
0
void RecentContactSet::updateDb(int ownerId,const ContactInfoSeq& contactInfos){
   	GetProps& props = GetProps::instance();
        string table = props.getTableName(ownerId);
        Statement sqlAdd;
	
	size_t guests_size = contactInfos.size() > size_t(GUESTS_SIZE) ? size_t(GUESTS_SIZE):contactInfos.size();
        MyUtil::IntSeq byteSeq;
        for ( size_t i = 0; i < guests_size; ++i ) {
                byteSeq.push_back((contactInfos[i]->guestId));
                byteSeq.push_back(time(NULL));
                byteSeq.push_back((contactInfos[i]->type));
        }

        sqlAdd << "REPLACE INTO " << table << "(" << COLUMN_HOST << ", " << COLUMN_GUESTS << ")" << "  values" << " ("<< ownerId << ","<<mysqlpp::quote<<IntSeqSerialize::serialize(byteSeq)<<")";

 //       QueryRunner(DB_SOURCE, CDbWServer, table).execute(sqlAdd);
          QueryRunner(DB_SOURCE, CDbWServer, table).schedule(sqlAdd);
}
Пример #9
0
MyUtil::IntSeq RecentlyOnlineBuddyData::get_most_recent(int limit) {
	IceUtil::Mutex::Lock lock(*this);
	MyUtil::IntSeq result;
	for (std::deque<int>::reverse_iterator it = _buddies.rbegin();
		(int) result.size()	< limit && it != _buddies.rend(); ++it) {
		if (find(result.begin(), result.end(), *it)!=result.end()) continue;
		result.push_back(*it);
	}
	return result;
}
Пример #10
0
// FriendRankLoaderFactory::create(Ice::Int userId) {{{
Ice::ObjectPtr FriendRankLoaderFactory::create(Ice::Int userId)
{
	MCE_INFO("FriendRankLoaderI::create single -> id: "<<userId);

	MyUtil::IntSeq ids;
	ids.push_back(userId);
	MyUtil::ObjectResultPtr results = create(ids);

	return results->data[userId];
}// }}}
Пример #11
0
void xce::compareinfo::CompareInfoReloaderI::reload(const MyUtil::IntSeq& ids, const Ice::Current& current) {
	ostringstream oss;
	oss << "CompareInfoReloaderI::reload -> size: "<<ids.size() << current.con->toString().substr(current.con->toString().find("remote",25));
	TimeCost tc = TimeCost::create(oss.str(), TimeCost::LOG_LEVEL_INFO);
	MyUtil::IntSeq tempids;
	for (MyUtil::IntSeq::const_iterator i=ids.begin(); i!=ids.end();++i){
		if (*i > 0) {
			tempids.push_back(*i);
		}
	}
	MyUtil::TaskManager::instance().execute(new ReloadTask(tempids, current));
}
Пример #12
0
void xce::usercache::UserCacheReloaderI::rebuildOnline(const MyUtil::IntSeq& ids, const Ice::Current& current) {
	ostringstream oss;
	oss << "UserCacheReloaderI::rebuildOnline -> size: "<< ids.size() << " " << current.con->toString().substr(current.con->toString().find("remote",25));
	TimeCost tc = TimeCost::create(oss.str(), TimeCost::LOG_LEVEL_INFO);
	MyUtil::IntSeq rebuildIds;
	for (MyUtil::IntSeq::const_iterator i=ids.begin(); i!=ids.end();++i){
		if (*i > 0) {
			rebuildIds.push_back(*i);
		}
	}

	RebuildOnline::instance().rebuild(rebuildIds);
}
Пример #13
0
void UserAdsCacheLoaderI::load(const MyUtil::IntSeq& ids, const Ice::Current& current) {
	MCE_DEBUG("UserAdsCacheLoaderI::load -> size: "<<ids.size()<<" " << current.con->toString().substr(current.con->toString().find("remote",25)));
	MyUtil::IntSeq is;
  for (MyUtil::IntSeq::const_iterator i = ids.begin(); i != ids.end(); ++i) {
    if (*i > 0) {
      is.push_back(*i);
    }
  }
  if (is.size() <= 0) {
    return ;
  }
  CacheLoader<UserAdsCacheManagerPrx>::instance().reload(is);
}
Пример #14
0
BuddyByOnlineTimeDataI::BuddyByOnlineTimeDataI( BuddyByOnlineTimeDataPtr data ){
  std::multimap<int, int> orderFriend;
  for (OnlineTimeSeq::const_iterator it = data->onlinetime.begin(); it
      != data->onlinetime.end(); ++it) {
    orderFriend.insert(make_pair<int,int>(it->time,it->userId));
  }
  MyUtil::IntSeq buddies;
  for (multimap<int, int>::reverse_iterator it = orderFriend.rbegin(); it
      != orderFriend.rend(); ++it ){
    buddies.push_back(it->second);
  }
  friends.swap( buddies );
}
Пример #15
0
MyUtil::IntSeq IPRecordData::get(int limit){
	IceUtil::Mutex::Lock lock(*this);
	if( limit < 0){
		return _users;
	}
	MyUtil::IntSeq result;
	for( MyUtil::IntSeq::reverse_iterator it = _users.rbegin(); it != _users.rend(); ++it ) {
		if (--limit < 0 ) {
			break;
		}
		result.push_back(*it);
	}
	return result;
}
Пример #16
0
void xce::distcache::userapicache::DistUserApiCacheReloaderI::reload(const MyUtil::IntSeq& ids, const Ice::Current& current) {
  ostringstream oss;
  oss << "DistUserApiCacheReloaderI::reload -> size: "<<ids.size()<< " " << current.con->toString().substr(current.con->toString().find("remote",25));
  MyUtil::TimeCost tc = MyUtil::TimeCost::create(oss.str(), MyUtil::TimeCost::LOG_LEVEL_INFO);
  oss<<"ids = ";
  MyUtil::IntSeq tempids;
  for (MyUtil::IntSeq::const_iterator i=ids.begin(); i!=ids.end();++i){
    if (*i > 0) {
      tempids.push_back(*i);
      oss<<*i<<" ";
    }
  }
  MCE_DEBUG(oss.str());
  MyUtil::TaskManager::instance().execute(new ReloadTask(tempids));
}
Пример #17
0
MyUtil::IntSeq TalkRightAdapter::batchVerify(int index, const VerifySeq& seq) {
	
	MyUtil::IntSeq res;
	
		try {
			res = getManager(abs(index) % getCluster())->batchVerify(seq);
			
		} catch(...) {
			for(size_t i = 0; i < seq.size(); ++i){
				res.push_back(seq.at(i)->index);
			}
		}
	
	return res;
}
Пример #18
0
int main(int argc, char* argv[]) {
	MyUtil::IntSeq ids;
	ids.push_back(68126);
	std::map<int, UserCachePtr> res = UserCacheAdapter::instance().GetUserCache(ids);
	cout << "id: " << res.find(68126)->second->id() << endl;
	cout << "name: " << res.find(68126)->second->name() << endl;
	cout << "status: " << res.find(68126)->second->status() << endl;
	cout << "tinyurl: " << res.find(68126)->second->tinyurl() << endl;
	cout << "state: " << res.find(68126)->second->state() << endl;
	cout << "gender: " << res.find(68126)->second->gender() << endl;
	cout << "online: " << res.find(68126)->second->online() << endl;
	cout << "level: " << res.find(68126)->second->level() << endl;
	cout << "univ: " << res.find(68126)->second->univ() << endl;
	cout << res.find(68126)->second->IsSelected() << endl;
	return 0;
}
Пример #19
0
Ice::ObjectPtr UserPhotosInfoFactoryI::create(Ice::Int id) {
  MCE_INFO("[UserPhotosInfoFactoryI::create] userId = " << id);
  vector<UserPhotosInfoPtr> ptrs;
  Statement sql;
  string tableName = TABLE_NAME + "_" + boost::lexical_cast<string>(id % TABLE_MOD);
  sql << "select " << COLUMN_USERID << ", " << COLUMN_PHOTOS << " from " << tableName << " where "
      << COLUMN_USERID << " = " << id;
  QueryRunner(DB_SOURCE, CDbRServer, tableName).query(sql, UserPhotosInfoResultHandlerI(ptrs));
  if (ptrs.empty() || (*ptrs.begin())->getPhotoInfos().empty()) {
    return EMPTY_USER_PHOTOS_INFO_PTR;
  } else {
    MyUtil::IntSeq userIds;
    userIds.push_back(id);
    FriendsRecentPhotosWriterAdapter::instance().reloadUserPhotos(userIds);
    return *ptrs.begin(); 
  }
}
Пример #20
0
MyUtil::IntSeq TalkRightAdapter::batchVerify(const VerifySeq& seq) {
	map<int, VerifySeq> vMap;
	for (size_t i = 0; i < seq.size(); ++i) {
		vMap[abs(seq.at(i)->to) % getCluster()].push_back(seq.at(i));
	}
	MyUtil::IntSeq res;
	for (map<int,VerifySeq>::iterator it = vMap.begin(); it != vMap.end(); ++it) {
		try {
			MyUtil::IntSeq tmp = getManager(it->first)->batchVerify(it->second);
			res.insert(res.end(),tmp.begin(),tmp.end());
		} catch(...) {
			for(size_t i = 0; i < it->second.size(); ++i){
				res.push_back(it->second.at(i)->index);
			}
		}
	}
	return res;
}
Пример #21
0
MyUtil::IntSeq MutualFriendsCacheManagerI::getFans(const MyUtil::GlobalIdPtr& gid, int begin, int limit, const Ice::Current& current) {
	ostringstream msg;
	msg << "gid = " << GlobalIdTransfer::get(gid) << ", begin = " << begin << ", limit = " << limit;
	InvokeClient ic = InvokeClient::create(current, msg.str(), InvokeClient::INVOKE_LEVEL_INFO);

	MyUtil::IntSeq fans = getAllFansAsc(gid);
	MyUtil::IntSeq result;
	if (limit < -1 || begin < 0) {
		return result;
	} else {
		MyUtil::IntSeq::iterator it = lower_bound(fans.begin(), fans.end(), gid);
		int countLimit = (limit == -1) ? fans.size() : limit;
		for (int count = 0; it != fans.end() && count < countLimit; it++) {
			result.push_back(*it);
			count++;
		}
		return result;
	}
}
Пример #22
0
MyUtil::IntSeq IPRecordData::getWithMask(int limit,::MyUtil::IntSeq mask){
	IceUtil::Mutex::Lock lock(*this);
	MyUtil::IntSeq result;
	if( limit == 0){
		return result;
	}
	std::sort( mask.begin(), mask.end(), std::less<int>() );
	for( MyUtil::IntSeq::reverse_iterator it = _users.rbegin(); it != _users.rend(); ++it ) {
		MyUtil::IntSeq::iterator itMask = lower_bound(mask.begin(),mask.end(),*it);
		if( itMask!=mask.end() && *itMask==*it){
			continue;
		}
		result.push_back(*it);
		if (--limit==0) {
			break;
		}
	}
	return result;
}
Пример #23
0
bool UserCacheReloadCallGuarantee::Redo(const std::vector<int>& ids) {
        if (ids.size() <= 0) {
                return true;
        }
	std::set<int> is;
	MyUtil::IntSeq idss;
        for (std::vector<int>::const_iterator i = ids.begin(); i != ids.end(); ++i) {
                is.insert(*i);
        }
	for (std::set<int>::const_iterator i = is.begin(); i != is.end(); ++i) {
		idss.push_back(*i);
	}
        try {
		xce::distcache::usercache::DistUserCacheReloaderAdapter::instance().getProxy(0)->reload(ids);
                return true;
        } catch (const Ice::Exception& e) {
                MCE_WARN("UserCacheReloadCallGuarantee::Redo -> exception distcache: " << e.what());
        } catch (...) {
                MCE_WARN("UserCacheReloadCallGuarantee::Redo -> unknown exception distcache");
        }
        return false;
}
Пример #24
0
MyUtil::IntSeq AccountFilterI::GetIdBySHA256(const MyUtil::StrSeq &digests, const Ice::Current &current) {
  ostringstream oss;
  oss << "digest.size: " << digests.size();
  InvokeClient ic = InvokeClient::create(current, oss.str(), InvokeClient::INVOKE_LEVEL_DEBUG);
  MyUtil::IntSeq result;
  MyUtil::StrSeq::const_iterator it = digests.begin();
  for(; it != digests.end(); ++it) {
    if(it->size() != SHA256::HEX_SIZE || !MyUtil::StrUtil::isXDigit(*it)) {
      MCE_WARN("AccountFilterI::GetIdBySHA256 invalid digest: " << *it << " ,size: " << it->size());
      continue;
    }
    string digest_lower = MyUtil::StrUtil::toLower(*it);
    int bucket = bucket_manager_.GetBucket(digest_lower);
    DigestMap& digest_map = buckets_[bucket];
    boost::shared_lock<boost::shared_mutex> read_lock(mutex_[bucket]);
    DigestMap::iterator it_digest = digest_map.find(digest_lower);
    if(it_digest != digest_map.end()) {
      BOOST_FOREACH(int id, it_digest->second.ids) {
        result.push_back(id);
      }
    }
  }
Пример #25
0
void CommonFriendCalculator::buildWeight(const MyUtil::Int2IntSeqMap& users, int weight) {
	MCE_DEBUG("build " << _userId << " size=" << users.size());
	try
	{
		for(MyUtil::Int2IntSeqMap::const_iterator i=users.begin();
				i!=users.end();
				++i)
		{
			for(MyUtil::IntSeq::const_iterator ui=i->second.begin();ui!=i->second.end();++ui)
			{
				_weightCount[*ui] += weight;
				MyUtil::Int2IntSeqMap::iterator sIt = _shareCount.find(*ui);
				if(sIt == _shareCount.end())
				{
					MyUtil::IntSeq firstShares;
					firstShares.push_back( i->first );
					_shareCount.insert(make_pair(*ui, firstShares));
				}
				else
				{
					sIt->second.push_back( i->first );
				}
			}
		}
	}
	catch(Ice::Exception& e)
	{
		MCE_WARN("buildUser IceException " << _userId << e.what());
	}
	catch(std::exception& e)
	{
		MCE_WARN("buildUser stdException " << _userId << e.what());
	}
	catch(...)
	{
		MCE_WARN("buildUser exception " << _userId);
	}
}
Пример #26
0
void IqHandlerI::changeBuddyGroupNotify(const BuddyItemPtr& bi, const Ice::Current&) {
  if(!bi){
    return;
  }
	MCE_DEBUG("IqHandlerI::changeBuddyGroupNotify --> host:"<<bi->host);
	MyUtil::IntSeq buddys;

	for (map<int,MyUtil::StrSeq>::iterator it = bi->items.begin(); it != bi->items.end(); ++it) {
		buddys.push_back(it->first);
	}
  TalkUserMap buddyInfo;
  try{
		buddyInfo = TalkCacheClient::instance().GetUserBySeqWithLoad(bi->host, buddys);
		if(buddyInfo.size() != buddys.size()){
			MCE_INFO("IqHandlerI::changeBuddyGroupNotify --> may be warn get from TalkCacheClient size is not equal actor = " << bi->host << " ids.size = " << buddys.size() << " map.size = " << buddyInfo.size());
		}else{
			MCE_INFO("IqHandlerI::changeBuddyGroupNotify --> success get from TalkCacheClient size is equal actor = " << bi->host << " ids.size = " << buddys.size() << " map.size = " << buddyInfo.size());
    }
	}catch(Ice::Exception& e){
    MCE_WARN("IqHandlerI::changeBuddyGroupNotify --> TalkCacheClient err, " << e);
  }
	
  MessageSeq mSeq;
  JidSeq jids;
  try{
	  //jids = OnlineCenterAdapter::instance().getUserJids(bi->host, 4);
	  jids = TalkFunStateAdapter::instance().getUserJids(bi->host, 4);
  }catch(Ice::Exception& e){
    MCE_WARN("IqHandlerI::changeBuddyGroupNotify-->OnlineCenterAdapter::getUserJids-->" << e);
  }
	for (size_t j = 0; j < jids.size(); ++j) {
		for (map<int,MyUtil::StrSeq>::iterator it = bi->items.begin(); it
				!= bi->items.end(); ++it) {
			xml_document doc;
			xml_node iqNode = doc.append_child();
			iqNode.set_name("iq");
			iqNode.append_attribute("type") = "set";
			iqNode.append_attribute("id") = (int)time(NULL);
			iqNode.append_attribute("to") = jidToString(jids.at(j)).c_str();

			xml_node queryNode = iqNode.append_child();
			queryNode.set_name("query");
			queryNode.append_attribute("xmlns") = "jabber:iq:roster";

			xml_node itemNode = queryNode.append_child();
			itemNode.set_name("item");
			ostringstream jos;
			jos << it->first << "@talk.xiaonei.com";
			itemNode.append_attribute("jid") = jos.str().c_str();//jid.c_str();

      TalkUserMap::iterator oit = buddyInfo.find(it->first);
			if (oit != buddyInfo.end()) {
				itemNode.append_attribute("name") = oit->second->name.c_str();
			} else {
				itemNode.append_attribute("name") = boost::lexical_cast<string>(it->first).c_str();
			}

			//itemNode.append_attribute("name") = name.c_str();
			itemNode.append_attribute("subscription") = "both";

			for (size_t k = 0; k < it->second.size(); ++k) {
				xml_node groupNode = itemNode.append_child();
				groupNode.set_name("group");
				groupNode.append_child(node_pcdata).set_value(it->second.at(k).c_str());
			}

			MessagePtr mPtr = new Message();
			//mPtr->from = new Jid();
			mPtr->from = jids.at(j);
			mPtr->to = jids.at(j);
			mPtr->type = IQ_SET;
			mPtr->msg = doc.xml();
			mSeq.push_back(mPtr);
			MCE_DEBUG("IqHandlerI::changeBuddyGroupNotify --> xml:"<<doc.xml());
		}
	}
	try{
		TalkDeliverAdapter::instance().deliver(mSeq);
	}catch(Ice::Exception& e){
		MCE_WARN("IqHandlerI::changeBuddyGroupNotify-->TalkDeliverAdapter::deliver-->err" << e);
	}
}
Пример #27
0
MyUtil::IntSeq OfferCreator::dedup(std::map<int, std::multimap<int, OfferDataN> >& typedWeightMap, 
										 							 const BackendDataPtr& bak, 
										 							 ostringstream& createLog, 
										 							 ostringstream& createDetail)
{
	struct timeval tvStart, tvStage1, tvEnd;
	gettimeofday( &tvStart, NULL );
	double linStart = ((double)tvStart.tv_sec * 1000000 + (double)tvStart.tv_usec);

	map<int, map<int, OfferDataN> > typedIdMap;				//map<type,map<id,offer>>;
	typedIdMap.insert(make_pair<int, map<int, OfferDataN> >(BaseTypeMix, map<int, OfferDataN>()));		//type:BaseTypeMix
	map<int, OfferDataN>& mixIdMap = typedIdMap[BaseTypeMix];		//&

	for (std::map<int, OfferDataNSeq>::iterator it = bak->_typedOfferDataNSeq.begin(); 
			it != bak->_typedOfferDataNSeq.end(); ++it) {				//it: <type,OfferDataNSeq> in bak
		//new <it->first,map<id,OfferDataN> > in typedIdMap
		typedIdMap.insert(make_pair<int, map<int, OfferDataN> >(it->first, map<int, OfferDataN>()));
		for (OfferDataNSeq::iterator it2 = it->second.begin(); 
				it2 != it->second.end(); ++it2) {				//it2: OfferDataN in bak
			map<int, OfferDataN>::iterator it3 = mixIdMap.find(it2->userId);			//it3: <id,OfferDataN> in mixIdMap
			if( it3 != mixIdMap.end() ){
				it3->second.weight += it2->weight + 10;
				it3->second.sign |= it2->sign;
				continue;
			}
			bool found = false;
			for (map<int, map<int, OfferDataN> >::iterator it4 = typedIdMap.begin(); 
					it4 != typedIdMap.end(); ++it4) {
				if (it4->first == BaseTypeMix) {
					continue;			//it4: <type,map<id,OfferDataN> > in typedIdMap without BaseTypeMix
				}
				map<int, OfferDataN>::iterator it5 = it4->second.find( it2->userId );//it5: <int,OfferDataN> in it4->second
				if (it5 != it4->second.end()) {
					it5->second.weight += it2->weight + 10;
					//it5->second.infos.insert( it2->infos.begin(), it2->infos.end() );
					it5->second.sign |= it2->sign;
					mixIdMap[it2->userId] = it5->second;
					it4->second.erase(it5);
					found = true;
					break;
				}
			}
			if (!found) {
				typedIdMap[it->first].insert(make_pair<int, OfferDataN>(it2->userId, *it2));
			}
		}
	}
	gettimeofday(&tvStage1, NULL);
	double linStage1 = ((double)tvStage1.tv_sec * 1000000 + (double)tvStage1.tv_usec);
	double linStage1Time = linStage1 - linStart;
	linStage1Time = linStage1Time / 1000000;
	createLog	<< " dedup(" << linStage1Time << "s/";

	MyUtil::IntSeq ids;
	for (map<int, map<int, OfferDataN> >::iterator it4 = typedIdMap.begin(); 
			it4 != typedIdMap.end(); ++it4 ) {
		typedWeightMap.insert(make_pair<int, multimap<int, OfferDataN> >(it4->first, multimap<int, OfferDataN>()));
		for (map<int, OfferDataN>::iterator it5 = it4->second.begin(); 
				it5 != it4->second.end(); ++it5) {
			typedWeightMap[it4->first].insert(multimap<int, OfferDataN>::value_type(it5->second.weight, it5->second));
			ids.push_back(it5->second.userId);
		}
	}

	gettimeofday(&tvEnd, NULL);
	double linEnd = ((double)tvEnd.tv_sec * 1000000 + (double)tvEnd.tv_usec);
	double linEndTime = linEnd - linStage1;
	linEndTime = linEndTime / 1000000;
	createLog	<< linEndTime << "s=";

	return ids;
}
Пример #28
0
xce::distcache::userapicache::UserApiCacheMemDataPtr xce::distcache::userapicache::UpdateTask::GetNewData() {
  xce::distcache::userapicache::UserApiCacheMemDataPtr data = xce::distcache::userapicache::DistUserApiCacheAdapter::instance().get(data_->userid);
  if(!data) 
  {
    MyUtil::IntSeq ids;
    ids.push_back(data_->userid);
    xce::distcache::userapicache::DistUserApiCacheReloaderI::instance().addDelayReloadIds(ids);
    return NULL;
  }
  MyUtil::Str2StrMap::const_iterator i;
  switch (data_->table) {
    case xce::userapicache::TABLEBORN:
      i = data_->data.find("BIRTH_DAY");
      if (i != data_->data.end()) {
        data->set_birthday(boost::lexical_cast<int>(i->second));
      }
      i = data_->data.find("GENDER");
      if (i != data_->data.end()) {
        data->set_gender(i->second);
      }
      i = data_->data.find("BIRTH_YEAR");
      if (i != data_->data.end()) {
        data->set_birthyear(boost::lexical_cast<int>(i->second));
      }
      i = data_->data.find("BIRTH_MONTH");
      if (i != data_->data.end()) {
        data->set_birthmonth(boost::lexical_cast<int>(i->second));
      }
      i = data_->data.find("HOME_CITY");
      if (i != data_->data.end()) {
        data->set_homecity(i->second);
      }
      i = data_->data.find("HOME_PROVINCE");
      if (i != data_->data.end()) {
        data->set_homeprovince(i->second);
      }
      break;
    case xce::userapicache::TABLESTAGE:
      i = data_->data.find("STAGE");
      if (i != data_->data.end()) {
        data->set_stage(boost::lexical_cast<int>(i->second));
      }
      i = data_->data.find("UNIV");
      if (i != data_->data.end()) {
        data->set_univ(boost::lexical_cast<int>(i->second));
      }
      break;
    case xce::userapicache::TABLESTATE:
      i = data_->data.find("LEVEL");
      if (i != data_->data.end()) {
        data->set_level(boost::lexical_cast<int>(i->second));
      }
      i = data_->data.find("STATE");
      if (i != data_->data.end()) {
        data->set_state(boost::lexical_cast<int>(i->second));
      }
      break;
    case xce::userapicache::TABLENAMES:
      i = data_->data.find("NAME");
      if (i != data_->data.end()) {
        data->set_name(i->second);
      }
      break;
    case xce::userapicache::TABLERIGHT:
      i = data_->data.find("AUTH");
      if (i != data_->data.end()) {
        data->set_auth(boost::lexical_cast<int>(i->second));
      }
      break;
    case xce::userapicache::TABLEPASSPORT:
      i = data_->data.find("STATUS");
      if (i != data_->data.end()) {
        data->set_status(boost::lexical_cast<int>(i->second));
      }
      break;
    case xce::userapicache::TABLEURL:
      i = data_->data.find("TINYURL");
      if (i != data_->data.end()) {
        data->set_tinyurl(i->second);
      }
      i = data_->data.find("MAINURL");
      if (i != data_->data.end()) {
        data->set_mainurl(i->second);
      }
      i = data_->data.find("HEADURL");
      if (i != data_->data.end()) {
        data->set_headurl(i->second);
      }
      break;
    case xce::userapicache::TABLECONFIG:
      i = data_->data.find("BASIC_CONFIG");
      if (i != data_->data.end()) {
        data->set_basicconfig(boost::lexical_cast<int>(i->second));
      }
      i = data_->data.find("STATUS_CONFIG");
      if (i != data_->data.end()) {
        data->set_statusconfig(boost::lexical_cast<int>(i->second));
      }
      i = data_->data.find("PROFILE_PRIVACY");
      if (i != data_->data.end()) {
        data->set_profileprivacy(i->second);
      }
      break;
    default:
      MCE_WARN("UpdateTask::GetNewData -> Oh, no!");
  }
  return data;
}