C++ TRACE_LOG函数代码示例

Contract::Contract(string spName)
{
	memset(debug,0,16);
	sprintf_s(debug,16,"ContractObject");
    this->spName = spName;
	InitializeCriticalSection(&cs);
	this->commodity = Commodity::findFor(spName);
	//TRACE_LOG("commodity findfor ok");
	orderCount = 0;
	if(this->isDomestic()) {
		TRACE_LOG("enter isDomestic part");
		fixName = "";
	    ronhonName = "";
		patsapiName = "";
	} else {
		//TRACE_LOG("begin getRonhonNameFor");
	    fixName = KnownContract::getFixNameFor(spName);
	    ronhonName = KnownContract::getRonhonNameFor(spName);
		patsapiName =  KnownContract::getPatsApiNameFor(spName);
		TRACE_LOG("spName = %s", spName.c_str());
		TRACE_LOG("patsapiName = %s", patsapiName.c_str());
	}
}

void Contract::loadOrderCount()
{
	TRACE_LOG("loadOrderCount.");
	ifstream file(getDateFileName());
    if(file.fail()) {
		TRACE_LOG("Read %s fail",getDateFileName().c_str());
		openFile();
		return;
	}

	string contractName;
	while(!file.eof()) 
	{
		file >> contractName;
		if (contractName.length() > 1)
		{
			Contract * c = Contract::get(contractName);
			c->increaseOrderCount(1);
		}
	}
	file.close();
	openFile();
}

int get_ranged_svr_list_callback(usr_info_t* p, uint8_t* body, uint32_t bodylen, int ret)
{
	//varify the respond data
    TRACE_LOG("get ranged callback");
	CHECK_VAL_GE(bodylen, sizeof(svr_list_t));

	svr_list_t* svrlist = reinterpret_cast<svr_list_t*>(body);

    //DEBUG_LOG("svrlist [%d %d]", svrlist->domain_id, svrlist->online_cnt);
	//chk if the pkg len is valid
	CHECK_VAL(bodylen, sizeof(svr_list_t) + svrlist->online_cnt * sizeof(svr_info_t)); 

    return send_ranged_svrlist(p, svrlist->svrs, svrlist->online_cnt);
}

el::lib_tcp_peer_info_t* el_async::connect( const std::string& ip, uint16_t port )
{
	int fd = el::lib_tcp_t::connect(ip, port, 1, false, 
		g_bench_conf->get_page_size_max(),
		g_bench_conf->get_page_size_max());
	if (-1 == fd){
		ERROR_LOG("[ip:%s, port:%u]", ip.c_str(), port);
	}else{
		TRACE_LOG("[ip:%s, port:%u, fd:%u]", ip.c_str(), port, fd);
		return g_net_server->get_server_epoll()->add_connect(fd, el::FD_TYPE_SVR, ip.c_str(), port);
	}

	return NULL;
}

/**
  * @brierf Send a request package to switch server, then get the respond, but do not parse it.
  * @param  uid. user id.
  * @param    friendcount. haw many friends.
  * @param    allfriendid. store the ids in an array
  * @return     int. 0 on success. less than 0 on error.
  */
int get_ranged_svr_list(usr_info_t* p, int start_id, int end_id)
{
    TRACE_LOG("enter get_ranged_svr_list");
    // pack up the request data
	int friendcount = 0;
    int idx = sizeof(svr_proto_t);
    taomee::pack_h(login_switch_sendbuf, static_cast<uint16_t>(0), idx);
    taomee::pack_h(login_switch_sendbuf, start_id, idx);
    taomee::pack_h(login_switch_sendbuf, end_id, idx);
    taomee::pack_h(login_switch_sendbuf, friendcount, idx);
    //taomee::pack(login_switch_sendbuf, allfriendid, friendcount * sizeof(userid_t), idx);
    init_switch_head(p, login_switch_sendbuf, idx, SWITCH_GET_RANGED_SVR_LIST);
    return send_to_switch(p, login_switch_sendbuf, idx);
}

void opcode_loadb(void)
{
  uint8_t *address = z_mem + (uint16_t)(op[0] + (int16_t)op[1]);

  TRACE_LOG("Opcode: LOADB.\n");

  read_z_result_variable();

  if (address > active_z_story->static_memory_end)
  {
    TRACE_LOG("Static memory end: %x.\n", active_z_story->static_memory_end);
    TRACE_LOG("Trying to loadb from %x which is above static memory.\n",
        address);
    set_variable(z_res_var, 0, false);
  }
  else
  {
    TRACE_LOG("Loading from %x to var %x.\n",
        *address,
        z_res_var);
    set_variable(z_res_var, *address, false);
  }
}

void* connector_callback(uint64_t conn, bool is_ok) {
    ERROR_LOG("收到连接器回调: %lld, 逻辑服务器为: %lld", conn, s_game_conn);
    if (conn == s_game_conn) {
        if (is_ok) {
            TRACE_LOG("连接器连接成功: %lld, 发起注册", conn);
            set_init_ok(true);
            regist_to_game();            
        } else {
            connect_gs();
        }
    }

    return NULL;
}

// not used now.
void SpPriceSource::SPAccountLogout()
{
	char szAccountLogout[256];
	memset(szAccountLogout, 0, sizeof(szAccountLogout));
	
	//get AccountLogout msg
	strcat_s(szAccountLogout, 256, "3122,0,");
	strcat_s(szAccountLogout, 256, SPInvestorId);
	strcat_s(szAccountLogout, 256, "\r\n");
	//e.g. 3122,0,1000 <MessageId>,<MessageType>,<AccNo><cr><lf>

	if(1 != m_cTcpClinet.TCPSend(szAccountLogout))
		TRACE_LOG("SpPriceSource: send msg failed");
}

int32_t fs_opr_t::connect(uint32_t address, int32_t port, const char* pswd, bool reconnect) {
    int32_t ret = IMS_FAIL_CONNECT;
    char ip[sizeof "255.255.255.255"];

    if (reconnect) {
        disconnect();
        ims_tool_t::inet_ntop(address, ip, sizeof "255.255.255.255");

        if (esl_connect(&_handle, ip, _port, NULL, _pswd) == ESL_SUCCESS) {
            TRACE_LOG("reconnect to FreeSWITCH [%s:%d] success", ip, _port);
            eval(RECORD_BASEDIR, _recordbase, LEN_256);
            ret = IMS_SUCCESS;
        } else {
            WARNING_LOG("reconnect to FreeSWITCH [%s:%d] failed(%s)", ip, _port, _handle.err);
        }
    } else {
        if (is_handle_valid()) {
            return IMS_SUCCESS;
        }

        strncpy(_pswd, pswd, LEN_16);
        _address = address;
        _port = port;

        ims_tool_t::inet_ntop(address, ip, sizeof "255.255.255.255");

        if (esl_connect(&_handle, ip, _port, NULL, _pswd) == ESL_SUCCESS) {
            TRACE_LOG("connect to FreeSWITCH [%s:%d] success", ip, _port);
            eval(RECORD_BASEDIR, _recordbase, LEN_256);
            ret = IMS_SUCCESS;
        } else {
            WARNING_LOG("connect to FreeSWITCH [%s:%d] failed(%s)", ip, _port, _handle.err);
        }
    }

    return ret;
}

void RohonDealer::placeOrder(Order *order)
{
    int ref;
    //放入map中,执行相应动作,开启等待线程
    TRACE_LOG("RohonDealer::placeOrder, orderid:%s.",order->getId().c_str());
    if(!started)
    {
        TRACE_LOG("RohonDealer::placeOrder failed. RohonDealer not started.");
        order->setRejected();
        return;
    }
    //放入map中
    EnterCriticalSection(&cs);
    RohonDealerInventory* pInventory = addInventory(order);
    if(pInventory == NULL)
    {   //orderID与正在处理中的重复，要拒绝这次下单请求
        LeaveCriticalSection(&cs);
        TRACE_LOG("RohonDealer::placeOrder failed. orderID is duplicated.");
        //order->setRejected();
        return;
    }
    //分配localRef
    ref = pUserSpi->getCurOrderRef();
    pInventory->localRef = ref;
    LeaveCriticalSection(&cs);
    //执行下单动作
    if(0 != pUserSpi->InsertOrder(ref,order))
    {   //下单直接失败
        EnterCriticalSection(&cs);
        delInventory(pInventory);
        LeaveCriticalSection(&cs);
        TRACE_LOG("RohonDealer::placeOrder failed. 下单直接失败");
        order->setRejected();
        return;
    }
    return;
}

int Gobang::handle_player_action(sprite_t* p, const uint8_t body[], int len)
{
	TRACE_LOG("Gobang Handle Player Action: uid=%u, grpid=%lu",
				p->id, m_gamegrp->id);

struct actpkg {
	uint32_t uid;
	Chess_Pos_Type row, col;
} __attribute__((__packed__));

	if ( started_check(p, len, sizeof(actpkg)) == -1 ) return -1;

	int i = 0;
	actpkg apkg;
	UNPKG_UINT(body, apkg.uid, i);
	UNPKG_UINT(body, apkg.row, i);
	UNPKG_UINT(body, apkg.col, i);
	if ( (p->id != apkg.uid) || (m_nxmover != apkg.uid) ) {
		ERROR_RETURN( ("UserID Mismatch, uid=%u, %u, %u",
						p->id, apkg.uid, m_nxmover), -1 );
	}

	REMOVE_TIMER(p, timerid);
	if ( place_chess(apkg.row, apkg.col) == -1 ) return -1;

	broadcast_action(body, p->id);
	++m_nsteps; // increase number of chesses placed

	std::vector<ChessCoord> adjchesses;
	if ( determine_winner(apkg.row, apkg.col, adjchesses) ) {
		notify_winner(p->id, adjchesses);
		m_nxmover = 0;
		send_game_score(p, 0, 1);

		DEBUG_LOG("Gobang Winner Determined\t[winner=%u]", p->id);
		return GER_end_of_game;
	} else if (draw()) {
		notify_winner(0);
		m_nxmover = 0;
		send_game_score(p, 2, 2);
		return GER_draw_game;
	}

	set_nxmover();
	sprite_t* op = get_sprite_from_gamegrp(m_nxmover, m_gamegrp);
	time_t exptm = time(0) + 62;
	timerid = ADD_TIMER_EVENT(op, on_timer_expire, 0, exptm);
	return 0;
}

void NokiaLinearVolumeItfCallback(XANokiaLinearVolumeItf /*caller*/,
                                  void* pContext,
                                  XAuint32 event,
                                  XAboolean /*eventBooleanData*/)
{
    switch (event) {
    case XA_NOKIALINEARVOLUME_EVENT_VOLUME_CHANGED:
        if (pContext)
            ((XARadioSessionImpl*)pContext)->VolumeChanged();
        break;
    default:
        TRACE_LOG((_L("NokiaLinearVolumeItfCallback: default")));
        break;
    }
}

void EngineObjectCallback(XAObjectItf /*caller*/,
                          const void */*pContext*/,
#ifdef PLUGIN_SYMBIAN_TRACE_ENABLED
                          XAuint32 event,
#else
                          XAuint32 /*event*/,
#endif /*PLUGIN_SYMBIAN_TRACE_ENABLED*/
                          XAresult /*result*/,
                          XAuint32 /*param*/,
                          void */*pInterface*/)
{
#ifdef PLUGIN_SYMBIAN_TRACE_ENABLED
    TRACE_LOG((_L("Engine object event: 0x%x\n"), (int)event));
#endif /*PLUGIN_SYMBIAN_TRACE_ENABLED*/
}

/*---------------------------------------------------------------------*/
int32_t
filter_init(Brick *brick, Linker_Intf *li)
{
	TRACE_BRICK_FUNC_START();
	brick->private_data = calloc(1, sizeof(FilterContext));
	if (brick->private_data == NULL) {
		TRACE_LOG("Can't create private context "
			  "for filter\n");
		TRACE_BRICK_FUNC_END();
		return -1;
	}
	li->type = SHARE;
	TRACE_BRICK_FUNC_END();
	return 1;
}

/*---------------------------------------------------------------------*/
int32_t
dup_init(Brick *brick, Linker_Intf *li)
{
	TRACE_BRICK_FUNC_START();
	brick->private_data = calloc(1, sizeof(linkdata));
	if (brick->private_data == NULL) {
		TRACE_LOG("Can't create private context "
			  "for duplicator\n");
		TRACE_BRICK_FUNC_END();
		return -1;
	}
	li->type = COPY;
	TRACE_BRICK_FUNC_END();
	return 1;
}