void showRelocatability() {
int i;
#ifdef RUNTIME_RELOC_CHECKS
goto_len = calculateRelocatability(handler_sizes);
#endif
if(goto_len >= 0)
printf("Dispatch sequence is relocatable\n");
else
printf("Dispatch sequence is not relocatable (%s)\n", reason(goto_len));
for(i = 0; i < HANDLERS; i++) {
int j;
printf("Opcodes at depth %d: \n", i);
for(j = 0; j < LABELS_SIZE; j++) {
int size = handler_sizes[i][j];
if(size >= 0)
printf("%d : is relocatable\n", j);
else
printf("%d : is not relocatable (%s)\n", j, reason(size));
}
}
}
void DelayedTrick::onEffect(const CardEffectStruct &effect) const
{
Room *room = effect.to->getRoom();
CardMoveReason reason(CardMoveReason::S_REASON_USE, effect.to->objectName(), getSkillName(), QString());
room->moveCardTo(this, NULL, Player::PlaceTable, reason, true);
LogMessage log;
log.from = effect.to;
log.type = "#DelayedTrick";
log.arg = effect.card->objectName();
room->sendLog(log);
JudgeStruct judge_struct = judge;
judge_struct.who = effect.to;
room->judge(judge_struct);
if (judge_struct.isBad()) {
takeEffect(effect.to);
if (room->getCardOwner(getEffectiveId()) == NULL) {
CardMoveReason reason(CardMoveReason::S_REASON_NATURAL_ENTER, QString());
room->throwCard(this, reason, NULL);
}
} else if (movable) {
onNullified(effect.to);
} else {
if (room->getCardOwner(getEffectiveId()) == NULL) {
CardMoveReason reason(CardMoveReason::S_REASON_NATURAL_ENTER, QString());
room->throwCard(this, reason, NULL);
}
}
}
/** \brief callback notified by host2ip_t when the result is known
*/
bool ipcountry_t::neoip_host2ip_cb(void *cb_userptr, host2ip_vapi_t &cb_host2ip_vapi
, const inet_err_t &inet_err
, const std::vector<ip_addr_t> &result_arr) throw()
{
// display the result
KLOG_DBG("enter host2ip returned err=" << inet_err << " with " << result_arr.size() << " ip_addr_t"
<< " for hostname=" << host2ip->hostname());
// if the host2ip failed to return an ip address, notify the caller
if( inet_err.failed() || result_arr.empty() ){
std::string reason("unable to resolve the ip_addr_t " + ipaddr().to_string());
return notify_callback(inet_err_t(inet_err_t::ERROR, reason), std::string());
}
// create an alias on the result_ipaddr
const ip_addr_t result_ipaddr = result_arr[0];
// log to debug
KLOG_DBG("result=" << result_ipaddr);
// convert the result_ipaddr into a country code
const char * country_ptr = ipaddr2countrycode(result_ipaddr);
if( !country_ptr ){
std::string reason("Internal error. the return ip_addr_t is NOT a ISO3166 code. ip_addr=" + result_ipaddr.to_string());
return notify_callback(inet_err_t(inet_err_t::ERROR, reason), std::string());
}
// notify the caller of the successfull result
std::string country_code = country_ptr;
return notify_callback(inet_err_t::OK, country_code);
}
// Handler called when a physical interface is no longer active in a LAG.
void on_lag_member_del(eos::intf_id_t lag, eos::intf_id_t member) {
// Custom application code to react to a physical interface
// leaving a LAG for any reason. For example, to get the reason:
auto stat = eth_lag_intf_mgr_->eth_lag_intf_membership_status(member);
std::string reason(stat.reason()); // e.g., 'not link up'
t.trace8("ApplicationAgent on_lag_member_del: %s deleted from %s",
member.to_string().c_str(), lag.to_string().c_str());
}
void DelayedTrick::onNullified(ServerPlayer *target) const
{
Room *room = target->getRoom();
RoomThread *thread = room->getThread();
if (movable) {
QList<ServerPlayer *> players = room->getOtherPlayers(target);
players << target;
ServerPlayer *next = NULL; //next meaning this next one
bool next2next = false; //it's meaning another next(a second next) is necessary
foreach (ServerPlayer *player, players) {
if (player->containsTrick(objectName()))
continue;
const ProhibitSkill *skill = room->isProhibited(target, player, this);
if (skill) {
LogMessage log;
log.type = "#SkillAvoid";
log.from = player;
log.arg = skill->objectName();
log.arg2 = objectName();
room->sendLog(log);
room->broadcastSkillInvoke(skill->objectName());
continue;
}
next = player;
CardMoveReason reason(CardMoveReason::S_REASON_TRANSFER, target->objectName(), QString(), getSkillName(), QString());
room->moveCardTo(this, target, player, Player::PlaceDelayedTrick, reason, true);
if (target == player)
break;
CardUseStruct use;
use.from = NULL;
use.to << player;
use.card = this;
QVariant data = QVariant::fromValue(use);
thread->trigger(TargetConfirming, room, data);
CardUseStruct new_use = data.value<CardUseStruct>();
if (new_use.to.isEmpty()) {
next2next = true;
break;
}
thread->trigger(TargetConfirmed, room, data);
break;
}
//case:stop.
if (!next) {
CardMoveReason reason(CardMoveReason::S_REASON_TRANSFER, target->objectName(), QString(), getSkillName(), QString());
room->moveCardTo(this, target, target, Player::PlaceDelayedTrick, reason, true);
}
//case: next2next
if (next && next2next)
onNullified(next);
} else {
bool SyncObject::lockConditional(SyncType type, const char* from)
{
if (waitingThreads)
return false;
if (type == SYNC_SHARED)
{
while (true)
{
const AtomicCounter::counter_type oldState = lockState;
if (oldState < 0)
break;
const AtomicCounter::counter_type newState = oldState + 1;
if (lockState.compareExchange(oldState, newState))
{
WaitForFlushCache();
#ifdef DEV_BUILD
MutexLockGuard g(mutex, FB_FUNCTION);
#endif
reason(from);
return true;
}
}
}
else
{
ThreadSync* thread = ThreadSync::findThread();
fb_assert(thread);
if (thread == exclusiveThread)
{
++monitorCount;
reason(from);
return true;
}
while (waiters == 0)
{
const AtomicCounter::counter_type oldState = lockState;
if (oldState != 0)
break;
if (lockState.compareExchange(oldState, -1))
{
WaitForFlushCache();
exclusiveThread = thread;
reason(from);
return true;
}
}
}
return false;
}
void DelayedTrick::onEffect(const CardEffectStruct &effect) const
{
Room *room = effect.to->getRoom();
CardMoveReason reason(CardMoveReason::S_REASON_USE, effect.to->objectName(), getSkillName(), QString());
room->moveCardTo(this, NULL, Player::PlaceTable, reason, true);
LogMessage log;
log.from = effect.to;
log.type = "#DelayedTrick";
log.arg = effect.card->objectName();
room->sendLog(log);
JudgeStruct judge_struct = judge;
judge_struct.who = effect.to;
room->judge(judge_struct);
if (judge_struct.negative == judge_struct.isBad()) {
if (effect.to->isAlive())
takeEffect(effect.to);
if (room->getCardOwner(getEffectiveId()) == NULL) {
CardMoveReason reason(CardMoveReason::S_REASON_NATURAL_ENTER, QString());
room->throwCard(this, reason, NULL);
}
} else if (movable) {
onNullified(effect.to);
} else if (returnable && effect.to->isAlive()) {
if (room->getCardOwner(getEffectiveId()) == NULL) {
if (isVirtualCard()) {
Card *delayTrick = Sanguosha->cloneCard(objectName());
WrappedCard *vs_card = Sanguosha->getWrappedCard(getEffectiveId());
vs_card->setSkillName(getSkillName());
vs_card->takeOver(delayTrick);
room->broadcastUpdateCard(room->getAlivePlayers(), vs_card->getId(), vs_card);
}
CardsMoveStruct move;
move.card_ids << getEffectiveId();
move.to = effect.to;
move.to_place = Player::PlaceDelayedTrick;
room->moveCardsAtomic(move, true);
}
}
else {
if (room->getCardOwner(getEffectiveId()) == NULL) {
CardMoveReason reason(CardMoveReason::S_REASON_NATURAL_ENTER, QString());
room->throwCard(this, reason, NULL);
}
}
}
std::string FSData::processRequestForInfo(LLUUID requester, std::string message, std::string name, LLUUID sessionid)
{
std::string detectstring = "/reqsysinfo";
if(!message.find(detectstring) == 0)
{
return message;
}
if(!(is_support(requester)||is_developer(requester)))
{
return message;
}
std::string outmessage("I am requesting information about your system setup.");
std::string reason("");
if(message.length() > detectstring.length())
{
reason = std::string(message.substr(detectstring.length()));
//there is more to it!
outmessage = std::string("I am requesting information about your system setup for this reason : " + reason);
reason = "The reason provided was : " + reason;
}
LLSD args;
args["REASON"] = reason;
args["NAME"] = name;
args["FROMUUID"] = requester;
args["SESSIONID"] = sessionid;
LLNotifications::instance().add("FireStormReqInfo", args, LLSD(), callbackReqInfo);
return outmessage;
}
void EquipCard::onUse(Room *room, const CardUseStruct &card_use) const
{
CardUseStruct use = card_use;
ServerPlayer *player = use.from;
if (use.to.isEmpty())
use.to << player;
if (!use.to.contains(player)) {
LogMessage log;
log.from = player;
log.to = use.to;
log.type = "#UseCard";
log.card_str = use.card->toString();
room->sendLog(log);
}
QVariant data = QVariant::fromValue(use);
RoomThread *thread = room->getThread();
thread->trigger(PreCardUsed, room, data);
CardMoveReason reason(CardMoveReason::S_REASON_USE, player->objectName(), QString(), card_use.card->getSkillName(), QString());
CardsMoveStruct move(card_use.card->getEffectiveId(), NULL, Player::PlaceTable, reason);
room->moveCardsAtomic(move, true);
thread->trigger(CardUsed, room, data);
thread->trigger(CardFinished, room, data);
}
void DelayedTrick::onNullified(ServerPlayer *target) const{
Room *room = target->getRoom();
if(movable){
QList<ServerPlayer *> players = room->getOtherPlayers(target);
players << target;
foreach(ServerPlayer *player, players){
if(player->containsTrick(objectName()))
continue;
const ProhibitSkill *skill = room->isProhibited(target, player, this);
if(skill){
LogMessage log;
log.type = "#SkillAvoid";
log.from = player;
log.arg = skill->objectName();
log.arg2 = objectName();
room->sendLog(log);
room->broadcastSkillInvoke(skill->objectName());
continue;
}
CardMoveReason reason(CardMoveReason::S_REASON_TRANSFER, target->objectName(), QString(), this->getSkillName(), QString());
room->moveCardTo(this, target, player, Player::PlaceDelayedTrick, reason, true);
break;
}
}
else{
void Debugger::didExecuteProgram(CallFrame* callFrame)
{
if (m_isPaused)
return;
PauseReasonDeclaration reason(*this, PausedAtEndOfProgram);
updateCallFrame(callFrame, AttemptPause);
// Detach may have been called during pauseIfNeeded.
if (!m_currentCallFrame)
return;
VMEntryFrame* topVMEntryFrame = m_vm.topVMEntryFrame;
CallFrame* callerFrame = m_currentCallFrame->callerFrame(topVMEntryFrame);
// Returning from a program, could be eval(), there was at least one expression on the statement we are returning to.
m_pastFirstExpressionInStatement = true;
// Treat stepping over the end of a program like a step-out.
if (m_currentCallFrame == m_pauseOnCallFrame) {
m_pauseOnCallFrame = callerFrame;
m_pauseAtNextOpportunity = true;
}
updateCallFrame(callerFrame, NoPause);
// Do not continue stepping into an unknown future program.
if (!m_currentCallFrame)
clearNextPauseState();
}
void Debugger::returnEvent(CallFrame* callFrame)
{
if (m_isPaused)
return;
{
PauseReasonDeclaration reason(*this, PausedBeforeReturn);
updateCallFrame(callFrame, AttemptPause);
}
// Detach may have been called during pauseIfNeeded.
if (!m_currentCallFrame)
return;
VMEntryFrame* topVMEntryFrame = m_vm.topVMEntryFrame;
CallFrame* callerFrame = m_currentCallFrame->callerFrame(topVMEntryFrame);
// Returning from a call, there was at least one expression on the statement we are returning to.
m_pastFirstExpressionInStatement = true;
// Treat stepping over a return statement like a step-out.
if (m_currentCallFrame == m_pauseOnCallFrame) {
m_pauseOnCallFrame = callerFrame;
m_pauseOnStepOut = true;
}
updateCallFrame(callerFrame, NoPause);
}
bool trigger(TriggerEvent, Room *room, ServerPlayer *player, QVariant &data) const
{
DamageStruct damage = data.value<DamageStruct>();
if (damage.card && damage.card->isKindOf("Slash")
&& damage.by_user && !damage.chain && !damage.transfer && !damage.to->isAllNude()
&& player->askForSkillInvoke(this, data)) {
room->broadcastSkillInvoke(objectName(), 1);
LogMessage log;
log.type = "#Yishi";
log.from = player;
log.arg = objectName();
log.to << damage.to;
room->sendLog(log);
int card_id = room->askForCardChosen(player, damage.to, "hej", objectName());
if (room->getCardPlace(card_id) == Player::PlaceDelayedTrick)
room->broadcastSkillInvoke(objectName(), 2);
else if (room->getCardPlace(card_id) == Player::PlaceEquip)
room->broadcastSkillInvoke(objectName(), 3);
else
room->broadcastSkillInvoke(objectName(), 4);
CardMoveReason reason(CardMoveReason::S_REASON_EXTRACTION, player->objectName());
room->obtainCard(player, Sanguosha->getCard(card_id), reason, room->getCardPlace(card_id) != Player::PlaceHand);
return true;
}
return false;
}
TEST_F(SyncTailTest, MultiApplyReturnsBadValueOnNullOperationContext) {
auto writerPool = SyncTail::makeWriterPool();
auto op = makeCreateCollectionOplogEntry({Timestamp(Seconds(1), 0), 1LL});
auto status = multiApply(nullptr, writerPool.get(), {op}, noopApplyOperationFn).getStatus();
ASSERT_EQUALS(ErrorCodes::BadValue, status);
ASSERT_STRING_CONTAINS(status.reason(), "invalid operation context");
}
void RendeCard::use(Room *room, ServerPlayer *source, QList<ServerPlayer *> &targets) const{
ServerPlayer *target = targets.first();
int old_value = source->getMark("rende");
QList<int> rende_list;
if (old_value > 0)
rende_list = StringList2IntList(source->property("rende").toString().split("+"));
else
rende_list = source->handCards();
foreach (int id, this->subcards)
rende_list.removeOne(id);
room->setPlayerProperty(source, "rende", IntList2StringList(rende_list).join("+"));
CardMoveReason reason(CardMoveReason::S_REASON_GIVE, source->objectName(), target->objectName(), "rende", QString());
room->obtainCard(target, this, reason, false);
int new_value = old_value + subcards.length();
room->setPlayerMark(source, "rende", new_value);
if (old_value < 2 && new_value >= 2) {
RecoverStruct recover;
recover.card = this;
recover.who = source;
room->recover(source, recover);
}
if (room->getMode() == "04_1v3" && source->getMark("rende") >= 2) return;
if (source->isKongcheng() || source->isDead() || rende_list.isEmpty()) return;
room->addPlayerHistory(source, "RendeCard", -1);
if (!room->askForUseCard(source, "@@rende", "@rende-give", -1, Card::MethodNone))
room->addPlayerHistory(source, "RendeCard");
}
void DelayedTrick::onUse(Room *room, const CardUseStruct &card_use) const
{
CardUseStruct use = card_use;
WrappedCard *wrapped = Sanguosha->getWrappedCard(this->getEffectiveId());
use.card = wrapped;
QVariant data = QVariant::fromValue(use);
RoomThread *thread = room->getThread();
thread->trigger(PreCardUsed, room, use.from, data);
use = data.value<CardUseStruct>();
LogMessage log;
log.from = use.from;
log.to = use.to;
log.type = "#UseCard";
log.card_str = toString();
room->sendLog(log);
CardMoveReason reason(CardMoveReason::S_REASON_USE, use.from->objectName(), use.to.first()->objectName(), this->getSkillName(), QString());
room->moveCardTo(this, use.to.first(), Player::PlaceDelayedTrick, reason, true);
thread->trigger(CardUsed, room, use.from, data);
use = data.value<CardUseStruct>();
thread->trigger(CardFinished, room, use.from, data);
}
virtual bool onPhaseChange(ServerPlayer *wangyi) const{
if(!wangyi->isWounded())
return false;
if(wangyi->getPhase() == Player::Start || wangyi->getPhase() == Player::Finish){
if(!wangyi->askForSkillInvoke(objectName()))
return false;
Room *room = wangyi->getRoom();
room->broadcastSkillInvoke(objectName(), 1);
JudgeStruct judge;
judge.pattern = QRegExp("(.*):(club|spade):(.*)");
judge.good = true;
judge.reason = objectName();
judge.who = wangyi;
room->judge(judge);
if(judge.isGood()){
int x = wangyi->getLostHp();
wangyi->drawCards(x); //It should be preview, not draw
ServerPlayer *target = room->askForPlayerChosen(wangyi, room->getAllPlayers(), objectName());
if (target == wangyi)
room->broadcastSkillInvoke(objectName(), 2);
else if (target->getGeneralName().contains("machao"))
room->broadcastSkillInvoke(objectName(), 4);
else
room->broadcastSkillInvoke(objectName(), 3);
QList<const Card *> miji_cards = wangyi->getHandcards().mid(wangyi->getHandcardNum() - x);
foreach(const Card *card, miji_cards){
CardMoveReason reason(CardMoveReason::S_REASON_GIVE, wangyi->objectName());
reason.m_playerId == target->objectName();
room->obtainCard(target, card, reason, false);
}
}
BOOLEAN Disasoc(Signal_t *signal)
{
FrmDesc_t *pfrmDesc;
Frame_t *rdu;
MacAddr_t Sta;
ReasonCode Rsn;
U8 vapId = 0;
ZDEBUG("Disasoc");
pfrmDesc = signal->frmInfo.frmDesc;
rdu = pfrmDesc->mpdu;
memcpy((U8 *)&Sta, (U8 *)(addr2(rdu)), 6);
Rsn = (ReasonCode)(reason(rdu));
if(memcmp(addr1(rdu), (U8*)&mBssId, 6)){ //Not for this BSSID
freeFdesc(pfrmDesc);
return TRUE;
}
UpdateStaStatus(&Sta, STATION_STATE_DIS_ASOC, vapId);
freeFdesc(pfrmDesc);
//here to handle disassoc ind.
pdot11Obj->StatusNotify(STA_DISASSOCIATED, (U8 *)&Sta);
return TRUE;
}
virtual bool trigger(TriggerEvent, Room* room, ServerPlayer *player, QVariant &data) const{
if(player->isNude())
return false;
QList<ServerPlayer *> caopis = room->findPlayersBySkillName(objectName());
foreach(ServerPlayer *caopi, caopis){
if(caopi->isAlive() && room->askForSkillInvoke(caopi, objectName(), data)){
if(player->isCaoCao()){
room->broadcastSkillInvoke(objectName(), 3);
}else if(player->isMale())
room->broadcastSkillInvoke(objectName(), 1);
else
room->broadcastSkillInvoke(objectName(), 2);
caopi->obtainCard(player->getWeapon());
caopi->obtainCard(player->getArmor());
caopi->obtainCard(player->getDefensiveHorse());
caopi->obtainCard(player->getOffensiveHorse());
DummyCard *all_cards = player->wholeHandCards();
if(all_cards){
CardMoveReason reason(CardMoveReason::S_REASON_RECYCLE, caopi->objectName());
room->obtainCard(caopi, all_cards, reason, false);
delete all_cards;
}
break;
}
}
return false;
}
std::string PhoenixViewerLink::processRequestForInfo(LLUUID requester, std::string message, std::string name, LLUUID sessionid)
{
std::string detectstring = "/reqsysinfo";
if(!message.find(detectstring)==0)
{
//llinfos << "sysinfo was not found in this message, it was at " << message.find("/sysinfo") << " pos." << llendl;
return message;
}
if(!(is_support(requester)||is_developer(requester)))
{
return message;
}
std::string my_name;
gAgent.buildFullname(my_name);
//llinfos << "sysinfo was found in this message, it was at " << message.find("/sysinfo") << " pos." << llendl;
std::string outmessage("I am requesting information about your system setup.");
std::string reason("");
if(message.length()>detectstring.length())
{
reason = std::string(message.substr(detectstring.length()));
//there is more to it!
outmessage = std::string("I am requesting information about your system setup for this reason : "+reason);
reason = "The reason provided was : "+reason;
}
LLSD args;
args["REASON"] =reason;
args["NAME"] = name;
args["FROMUUID"]=requester;
args["SESSIONID"]=sessionid;
LLNotifications::instance().add("PhoenixReqInfo",args,LLSD(), callbackPhoenixReqInfo);
return outmessage;
}
virtual bool onPhaseChange(ServerPlayer *player) const{
if(player->getPhase() == Player::Start){
Room *room = player->getRoom();
player->setMark("juao", 0);
ServerPlayer *xuyou = room->findPlayerBySkillName(objectName());
foreach (int card_id, player->getPile("hautain")){
if(!xuyou)
{
CardMoveReason reason(CardMoveReason::S_REASON_REMOVE_FROM_PILE, QString(), "hautain", QString());
room->throwCard(Sanguosha->getCard(card_id), reason, NULL);
}
else
room->obtainCard(player, card_id);
}
if(!xuyou)
return false;
LogMessage log;
log.type = "#JuaoObtain";
log.from = player;
log.arg = objectName();
log.to << xuyou;
room->sendLog(log);
player->skip(Player::Draw);
}
TEST_F(CacheReaderTest, RefreshErrorsIfCacheIsEmpty) {
auto catalogClient = Grid::get(operationContext())->catalogClient(operationContext());
KeysCollectionCacheReader reader("test", catalogClient);
auto status = reader.refresh(operationContext()).getStatus();
ASSERT_EQ(ErrorCodes::KeyNotFound, status.code());
ASSERT_FALSE(status.reason().empty());
}
void HuangtianCard::use(Room *room, ServerPlayer *source, QList<ServerPlayer *> &targets) const
{
ServerPlayer *zhangjiao = targets.first();
if (zhangjiao->hasLordSkill("huangtian")) {
room->setPlayerFlag(zhangjiao, "HuangtianInvoked");
if (!zhangjiao->isLord() && zhangjiao->hasSkill("weidi"))
room->broadcastSkillInvoke("weidi");
else {
int index = qrand() % 2 + 1;
if (Player::isNostalGeneral(zhangjiao, "zhangjiao"))
index += 2;
room->broadcastSkillInvoke("huangtian", index);
}
room->notifySkillInvoked(zhangjiao, "huangtian");
CardMoveReason reason(CardMoveReason::S_REASON_GIVE, source->objectName(), zhangjiao->objectName(), "huangtian", QString());
room->obtainCard(zhangjiao, this, reason);
QList<ServerPlayer *> zhangjiaos;
QList<ServerPlayer *> players = room->getOtherPlayers(source);
foreach (ServerPlayer *p, players) {
if (p->hasLordSkill("huangtian") && !p->hasFlag("HuangtianInvoked"))
zhangjiaos << p;
}
if (zhangjiaos.isEmpty())
room->setPlayerFlag(source, "ForbidHuangtian");
}
/***********************************************************************
* called when initiated connection process yields a result
***********************************************************************/
void GameClient::ZCom_cbConnectResult( ZCom_ConnID _id, eZCom_ConnectResult _result, ZCom_BitStream &_reply )
{
m_zoi_id = _id;
m_id = _reply.getInt(32);
std::string reason(_reply.getStringStatic());
std::stringstream strs;
strs<<"Game Client: The connection process for: "<<m_zoi_id<<" returned with resultcode "<<_result<<", the reply was "<<reason;
LogHandler::getInstance()->LogToFile(strs.str(), 2);
if ( _result != eZCom_ConnAccepted )
{
m_connected = false;
if(reason == "")
reason = "Server not reachable";
InternalWorkpile::getInstance()->AddEvent(new GameErrorMessageEvent("Problem connecting to game server " + m_servername + " - " + reason));
}
else
{
m_connected = true;
ZCom_requestDownstreamLimit(m_zoi_id, m_downpacketpersecond, m_downbyteperpacket);
#ifndef _ZOID_USED_NEW_VERSION_
ZCom_requestZoidMode( m_zoi_id, 1 );
#else
ZCom_changeObjectChannelSubscription( m_zoi_id, 1, eZCom_Subscribe );
#endif
}
}
void SessionCatalog::onStepUp(OperationContext* opCtx) {
DBDirectClient client(opCtx);
const size_t initialExtentSize = 0;
const bool capped = false;
const bool maxSize = 0;
BSONObj result;
if (client.createCollection(NamespaceString::kSessionTransactionsTableNamespace.ns(),
initialExtentSize,
capped,
maxSize,
&result)) {
return;
}
const auto status = getStatusFromCommandResult(result);
if (status == ErrorCodes::NamespaceExists) {
return;
}
uasserted(status.code(),
str::stream() << "Failed to create the "
<< NamespaceString::kSessionTransactionsTableNamespace.ns()
<< " collection due to "
<< status.reason());
}
static multibyte_string_type create_message_(char const* msg, DWORD code, int id, ff_char_t const* resourceType)
{
static const char string0[] = "could not load bundle resource corresponding to identifier ";
static const char string1[] = ": ";
char num_[21];
char const* num = stlsoft::integer_to_string(&num_[0], STLSOFT_NUM_ELEMENTS(num_), id);
winstl::error_desc_a reason(code);
multibyte_string_type message;
if(0 != code)
{
message.reserve(STLSOFT_NUM_ELEMENTS(string0) + 21 + STLSOFT_NUM_ELEMENTS(string1) + reason.size());
}
else
{
message.reserve(STLSOFT_NUM_ELEMENTS(string0) + 21);
}
message += string0;
message += num;
if(0 != code)
{
message += string1;
message += reason;
}
return message;
}
void RfbInitializer::initVersion()
{
char initVersionMsg[] = "RFB 003.008\n";
char clientVersionMsg[13];
size_t msgLen = 12;
m_output->writeFully(initVersionMsg, msgLen);
m_input->readFully(clientVersionMsg, msgLen);
clientVersionMsg[12] = 0;
m_minorVerNum = getProtocolMinorVersion(clientVersionMsg);
try {
checkForLoopback();
// Checking for a ban before auth and then after.
checkForBan();
} catch (Exception &e) {
if (m_minorVerNum == 3) {
m_output->writeUInt32(0);
} else {
m_output->writeUInt8(0);
}
AnsiStringStorage reason(&StringStorage(e.getMessage()));
unsigned int reasonLen = (unsigned int)reason.getLength();
_ASSERT(reasonLen == reason.getLength());
m_output->writeUInt32(reasonLen);
m_output->writeFully(reason.getString(), reasonLen);
throw;
}
}
void EquipCard::use(Room *room, ServerPlayer *source, QList<ServerPlayer *> &targets) const
{
if (targets.isEmpty()) {
CardMoveReason reason(CardMoveReason::S_REASON_USE, source->objectName(), QString(), this->getSkillName(), QString());
room->moveCardTo(this, NULL, Player::DiscardPile, reason, true);
}
int equipped_id = Card::S_UNKNOWN_CARD_ID;
ServerPlayer *target = targets.first();
if (target->getEquip(location()))
equipped_id = target->getEquip(location())->getEffectiveId();
QList<CardsMoveStruct> exchangeMove;
CardsMoveStruct move1(getEffectiveId(), target, Player::PlaceEquip,
CardMoveReason(CardMoveReason::S_REASON_USE, target->objectName()));
exchangeMove.push_back(move1);
if (equipped_id != Card::S_UNKNOWN_CARD_ID) {
CardsMoveStruct move2(equipped_id, NULL, Player::DiscardPile,
CardMoveReason(CardMoveReason::S_REASON_CHANGE_EQUIP, target->objectName()));
exchangeMove.push_back(move2);
}
LogMessage log;
log.from = target;
log.type = "$Install";
log.card_str = QString::number(getEffectiveId());
room->sendLog(log);
room->moveCardsAtomic(exchangeMove, true);
}
void DelayedTrick::onUse(Room *room, const CardUseStruct &card_use) const
{
CardUseStruct use = card_use;
WrappedCard *wrapped = Sanguosha->getWrappedCard(getEffectiveId());
use.card = wrapped;
LogMessage log;
log.from = use.from;
log.to = use.to;
log.type = "#UseCard";
log.card_str = toString();
room->sendLog(log);
QVariant data = QVariant::fromValue(use);
RoomThread *thread = room->getThread();
thread->trigger(PreCardUsed, room, data);
//CardMoveReason reason(CardMoveReason::S_REASON_USE, use.from->objectName(), use.to.first()->objectName(), getSkillName(), QString());
//room->moveCardTo(this, use.from, use.to.first(), Player::PlaceDelayedTrick, reason, true);
CardMoveReason reason(CardMoveReason::S_REASON_USE, use.from->objectName(), QString(), card_use.card->getSkillName(), QString());
CardsMoveStruct move(card_use.card->getEffectiveId(), NULL, Player::PlaceTable, reason);
room->moveCardsAtomic(move, true);
//show hidden after move Event to avoid filter card
use.from->showHiddenSkill(getSkillName());
thread->trigger(CardUsed, room, data);
thread->trigger(CardFinished, room, data);
}
void Debugger::callEvent(CallFrame* callFrame)
{
if (m_isPaused)
return;
PauseReasonDeclaration reason(*this, PausedAfterCall);
updateCallFrameAndPauseIfNeeded(callFrame);
}