inline void do_rjsmc (
vsmc::Sampler<T> &sampler, const std::string &,
std::ostream &zconst_file, const std::string &,
typename MoveType::alpha_type::value_type alpha_config,
typename MoveType::proposal_type::value_type proposal_config,
std::size_t repeat)
{
sampler.move(MoveType(alpha_config, proposal_config), false);
std::vector<double> cn(MaxCompNum);
std::vector<double> w(sampler.size());
for (std::size_t i = 0; i != cn.size(); ++i)
cn[i] = 0;
for (std::size_t i = 0; i != repeat; ++i) {
if (repeat > 1)
std::cout << "Run: " << i + 1 << std::endl;
sampler.initialize();
while (sampler.particle().value().state(0, 0).alpha() < 1)
sampler.iterate();
sampler.particle().weight_set().read_weight(&w[0]);
for (typename vsmc::Sampler<T>::size_type j = 0;
j != sampler.size(); ++j)
cn[sampler.particle().value().state(j, 0).comp_num() - 1] += w[j];
for (std::size_t j = 0; j != cn.size(); ++j)
zconst_file << cn[j] << ' ';
zconst_file << std::endl;
}
}
QVariant Certificate::detailResult(Certificate::Details detail) const
{
switch(detail) {
case Details::EXPIRATION_DATE : return expirationDate ();
case Details::ACTIVATION_DATE : return activationDate ();
case Details::REQUIRE_PRIVATE_KEY_PASSWORD : return requirePrivateKeyPassword ();
case Details::PUBLIC_SIGNATURE : return publicSignature ();
case Details::VERSION_NUMBER : return versionNumber ();
case Details::SERIAL_NUMBER : return serialNumber ();
case Details::ISSUER : return issuer ();
case Details::SUBJECT_KEY_ALGORITHM : return subjectKeyAlgorithm ();
case Details::CN : return cn ();
case Details::N : return n ();
case Details::O : return o ();
case Details::SIGNATURE_ALGORITHM : return signatureAlgorithm ();
case Details::MD5_FINGERPRINT : return md5Fingerprint ();
case Details::SHA1_FINGERPRINT : return sha1Fingerprint ();
case Details::PUBLIC_KEY_ID : return publicKeyId ();
case Details::ISSUER_DN : return issuerDn ();
case Details::NEXT_EXPECTED_UPDATE_DATE : return nextExpectedUpdateDate ();
case Details::OUTGOING_SERVER : return outgoingServer ();
case Details::COUNT__:
Q_ASSERT(false);
};
return QVariant();
}
// this should work if Internet Exploiter is installed
extern long wxCharsetToCodepage(const wxChar *name)
{
if (!name)
return GetACP();
long CP = -1;
wxString path(wxT("MIME\\Database\\Charset\\"));
wxString cn(name);
// follow the alias loop
for ( ;; )
{
wxRegKey key(wxRegKey::HKCR, path + cn);
if (!key.Exists())
break;
// two cases: either there's an AliasForCharset string,
// or there are Codepage and InternetEncoding dwords.
// The InternetEncoding gives us the actual encoding,
// the Codepage just says which Windows character set to
// use when displaying the data.
if (key.HasValue(wxT("InternetEncoding")) &&
key.QueryValue(wxT("InternetEncoding"), &CP))
break;
// no encoding, see if it's an alias
if (!key.HasValue(wxT("AliasForCharset")) ||
!key.QueryValue(wxT("AliasForCharset"), cn))
break;
}
return CP;
}
int main (int argc, char **argv)
{
ros::init(argc, argv, "clothoid_main");
ros::NodeHandle nh;
ClothoidMainNode cn(nh);
ros::spin();
}
int main (int argc, char **argv)
{
#include "options_main.hpp"
#include "gmm_options.hpp"
std::size_t BurninNum;
std::size_t IterNum;
Config
.add("burnin_num", "Number of burin iterations", &BurninNum, 10000)
.add("iter_num", "Number of recored iterations", &IterNum, 10000);
#include "options_process.hpp"
//////////////////////////////////////////////////////////////////////
vsmc::Sampler<gmm_state> sampler(Repeat);
sampler.particle().value().ordered() = true;
sampler
.init(gmm_init_rjmcmc())
.mcmc(gmm_move_mu(), true)
.mcmc(gmm_move_lambda(), true)
.mcmc(gmm_move_weight(), true)
.mcmc(gmm_rj_sc<gmm_logodds_flat>(), true)
.mcmc(gmm_rj_bd<gmm_logodds_flat>(), true);
data_info info(DataNum, DataFile.c_str());
sampler.initialize(&info);
for (std::size_t d = 0; d != BurninNum; ++d) {
if (!(d % 1000)) std::cout << "Burnin: " << d << std::endl;
sampler.iterate();
}
std::vector<std::vector<std::size_t> > cn(Repeat);
for (std::size_t i = 0; i != Repeat; ++i)
cn[i].resize(MaxCompNum);
for (std::size_t d = 0; d != IterNum; ++d) {
if (!(d % 1000)) std::cout << "Iter: " << d << std::endl;
sampler.iterate();
for (std::size_t r = 0; r != Repeat; ++r)
++cn[r][sampler.particle().value().state(r,0).comp_num() - 1];
}
//////////////////////////////////////////////////////////////////////
std::string zconst_file_name("rjmcmc." + Suffix);
std::ofstream zconst_file;
zconst_file.open(zconst_file_name.c_str());
for (std::size_t r = 0; r != Repeat; ++r) {
for (std::size_t d = 0; d != MaxCompNum; ++d)
zconst_file << cn[r][d] / static_cast<double>(IterNum) << ' ';
zconst_file << '\n';
}
zconst_file.close();
zconst_file.clear();
//////////////////////////////////////////////////////////////////////
return 0;
}
// *****************************************************************************
// * *
// * Function: dropOneTable *
// * *
// * Drops a table and all its dependent objects. *
// * *
// *****************************************************************************
// * *
// * Parameters: *
// * *
// * <cliInterface> ExeCliInterface & In *
// * is a reference to an Executor CLI interface handle. *
// * *
// * <catalogName> const char * In *
// * is the catalog of the table to drop. *
// * *
// * <schemaName> const char * In *
// * is the schema of the table to drop. *
// * *
// * <objectName> const char * In *
// * is the name of the table to drop. *
// * *
// * <isVolatile> bool In *
// * is true if the object is volatile or part of a volatile schema. *
// * *
// *****************************************************************************
// * *
// * Returns: bool *
// * *
// * true: Could not drop table or one of its dependent objects. *
// * false: Drop successful or could not set CQD for NATable cache reload. *
// * *
// *****************************************************************************
static bool dropOneTable(
ExeCliInterface & cliInterface,
const char * catalogName,
const char * schemaName,
const char * objectName,
bool isVolatile)
{
char buf [1000];
bool someObjectsCouldNotBeDropped = false;
char volatileString[20] = {0};
Lng32 cliRC = 0;
if (isVolatile)
strcpy(volatileString,"VOLATILE");
if (ComIsTrafodionExternalSchemaName(schemaName))
str_sprintf(buf,"DROP EXTERNAL TABLE \"%s\" FOR \"%s\".\"%s\".\"%s\" CASCADE",
objectName,catalogName,schemaName,objectName);
else
str_sprintf(buf,"DROP %s TABLE \"%s\".\"%s\".\"%s\" CASCADE",
volatileString,catalogName,schemaName,objectName);
ULng32 savedParserFlags = Get_SqlParser_Flags(0xFFFFFFFF);
try
{
Set_SqlParser_Flags(INTERNAL_QUERY_FROM_EXEUTIL);
cliRC = cliInterface.executeImmediate(buf);
}
catch (...)
{
// Restore parser flags settings to what they originally were
Assign_SqlParser_Flags(savedParserFlags);
throw;
}
// Restore parser flags settings to what they originally were
Set_SqlParser_Flags(INTERNAL_QUERY_FROM_EXEUTIL);
if (cliRC < 0 && cliRC != -CAT_OBJECT_DOES_NOT_EXIST_IN_TRAFODION)
someObjectsCouldNotBeDropped = true;
// remove NATable entry for this table
CorrName cn(objectName,STMTHEAP,schemaName,catalogName);
ActiveSchemaDB()->getNATableDB()->removeNATable(cn,
NATableDB::REMOVE_FROM_ALL_USERS, COM_BASE_TABLE_OBJECT);
return someObjectsCouldNotBeDropped;
}
PointViewSet Stage::execute(PointTableRef table)
{
//printf("called %s\n", this->classname());
log()->setLevel(LogLevel::Enum::Debug);
std::string cn(this->classname());
log()->setLeader(cn + " Stage::execute");
log()->get(LogLevel::Debug) << "Called by class " << std::endl;
table.layout()->finalize();
PointViewSet views;
if (m_inputs.empty())
{
log()->get(LogLevel::Debug) << "if block, class" << std::endl;
views.insert(PointViewPtr(new PointView(table)));
}
else
{
for (size_t i = 0; i < m_inputs.size(); ++i)
{
log()->get(LogLevel::Debug) << "block, class"
<< "input number "<< i << std::endl;
log()->get(LogLevel::Debug) << "if block, class" << std::endl;
Stage *prev = m_inputs[i];
PointViewSet temp = prev->execute(table);
views.insert(temp.begin(), temp.end());
}
}
PointViewSet outViews;
std::vector<StageRunnerPtr> runners;
ready(table);
for (auto const& it : views)
{
log()->get(LogLevel::Debug) << "run, class" << std::endl;
StageRunnerPtr runner(new StageRunner(this, it));
runners.push_back(runner);
runner->run();
}
for (auto const& it : runners)
{
log()->get(LogLevel::Debug) << "wait, class" << std::endl;
StageRunnerPtr runner(it);
PointViewSet temp = runner->wait();
outViews.insert(temp.begin(), temp.end());
}
l_done(table);
done(table);
return outViews;
}
RcppExport SEXP GetAllPoints(SEXP x,SEXP n,SEXP c) {
try {
Rcpp::XPtr< flann::Index<flann::L2<float> > > index(x);
Rcpp::NumericVector npoints(n);
Rcpp::NumericVector cn(c);
int colNum = cn[0];
float *data = new float[colNum];
for(int i=0;i<colNum;i++) {
data[i] = 0;
i++;
}
flann::Matrix<float> dataset = flann::Matrix<float>(data,1,colNum);
delete [] data;
std::vector< std::vector<int> > indices;
std::vector< std::vector<float> > dists;
index->knnSearch(dataset,indices,dists,npoints[0],flann::SearchParams(-1));
std::sort (indices[0].begin(), indices[0].end());
Rcpp::NumericMatrix results(indices[0].size(), colNum);
Rcpp::IntegerVector rownames;
int num = indices[0].size();
//#pragma omp parallel for ordered schedule(dynamic)
for(int i=0;i<num;i++) {
float* indexPoint = index->getPoint(indices[0][i]);
for(int j=0;j<colNum;j++) {
results(i,j)=(*(indexPoint+j));
}
//#pragma omp ordered
rownames.push_back(indices[0][i]);
}
Rcpp::List dimnms = Rcpp::List::create(rownames, Rcpp::Range(1,colNum));
results.attr("dimnames") = dimnms;
return results;
} catch( std::exception &ex ) { // or use END_RCPP macro
forward_exception_to_r( ex );
} catch(...) {
::Rf_error( "c++ exception (unknown reason)" );
}
return R_NilValue; // -Wall
}
void CTableFrameSink::logCard( WORD wChairID )
{
IServerUserItem *pIServerUserItem=m_pITableFrame->GetServerUserItem(wChairID);
if(pIServerUserItem == NULL) return;
m_oLog.Log(TEXT("玩家：%s 机器人[%s] 手牌：[%s%s][%s%s][%s%s][%s%s][%s%s] 牌型：%s") , pIServerUserItem->GetAccounts() , pIServerUserItem->IsAndroidUser()?"是":"否" ,
cn(m_cbHandCardData[wChairID][0]),vn(m_cbHandCardData[wChairID][0]),cn(m_cbHandCardData[wChairID][1]),vn(m_cbHandCardData[wChairID][1]),cn(m_cbHandCardData[wChairID][2]),vn(m_cbHandCardData[wChairID][2]),
cn(m_cbHandCardData[wChairID][3]),vn(m_cbHandCardData[wChairID][3]),cn(m_cbHandCardData[wChairID][4]),vn(m_cbHandCardData[wChairID][4]) , CardTypeName(m_GameLogic.GetBestCardType(m_cbHandCardData[wChairID],MAX_COUNT)));
m_oLog.Log(TEXT("玩家：%s 机器人[%s] 奖励牌：[%s%s][%s%s][%s%s][%s%s][%s%s] 相同牌数：%d" ) , pIServerUserItem->GetAccounts() , pIServerUserItem->IsAndroidUser()?"是":"否" ,
cn(m_cbRewardCardData[wChairID][0]),vn(m_cbRewardCardData[wChairID][0]),cn(m_cbRewardCardData[wChairID][1]),vn(m_cbRewardCardData[wChairID][1]),cn(m_cbRewardCardData[wChairID][2]),vn(m_cbRewardCardData[wChairID][2]),
cn(m_cbRewardCardData[wChairID][3]),vn(m_cbRewardCardData[wChairID][3]),cn(m_cbRewardCardData[wChairID][4]),vn(m_cbRewardCardData[wChairID][4]),m_GameLogic.GetSameCount(m_cbHandCardData[wChairID], m_cbRewardCardData[wChairID]) );
}
vector<colorNode> generateColors(int clr){
vector<colorNode> colornodes;
if(currentState->depth==0){
colorNode cn(clr,1);
colornodes.push_back(cn);
return colornodes;
}
for(int k=0;k<board_Size;k++){
if(colorCount[k]<board_Size){
double y=(board_Size*board_Size-count);
double x=(board_Size-colorCount[k]);
double p=x/y;
colorNode cn(color[k],p);
colornodes.push_back(cn);
}
else{
break;
}
}
return colornodes;
}
//static
void CSensProblem::copySensItemToParameterGroup(const CSensItem * si, CCopasiParameterGroup *pg)
{
CCommonName cn("");
if (!pg) return; if (!si) return;
if (si->isSingleObject())
cn = si->getSingleObjectCN();
pg->setValue("SingleObject", cn);
pg->setValue("ObjectListType", (unsigned C_INT32)si->getListType());
}
CorbaNameExList getIt()
{
CorbaNameExList t;
int i = 0;
while (i < 2000000)
{
CorbaNameEx cn(i, 2, 3, "namexxxxx");
t.push_back(cn);
i = i + 1;
}
return t;
};
void
OCSPCache::LogWithCerts(const char* aMessage, const CERTCertificate* aCert,
const CERTCertificate* aIssuerCert)
{
#ifdef PR_LOGGING
if (PR_LOG_TEST(gCertVerifierLog, PR_LOG_DEBUG)) {
mozilla::pkix::ScopedPtr<char, mozilla::psm::PORT_Free_string>
cn(CERT_GetCommonName(&aCert->subject));
mozilla::pkix::ScopedPtr<char, mozilla::psm::PORT_Free_string>
cnIssuer(CERT_GetCommonName(&aIssuerCert->subject));
PR_LOG(gCertVerifierLog, PR_LOG_DEBUG, (aMessage, cn.get(), cnIssuer.get()));
}
#endif
}
int main(int argc, char **argv) {
int tilt = 30;
int skip = 30;
pcl::console::parse_argument(argc, argv, "-skip", skip);
pcl::console::parse_argument(argc, argv, "-tilt", tilt);
ros::init(argc, argv, "convert_node");
ConvertNode cn(tilt, skip);
ros::spin();
return 0;
}
static String condition_file_name(LString * file_name)
{
int len_name = (int) strcspn(file_name->c_str(), ".");
if ((len_name > 10) || ( len_name <= 0))
len_name = 10;
char *conditioned_name = new char[len_name + 1];
strncpy(conditioned_name, file_name->c_str(), len_name);
conditioned_name[len_name] = (char)NULL;
int illegal_char_off;
while ((illegal_char_off = strspn(conditioned_name,legal_var_name_chars)) < len_name)
{
conditioned_name[illegal_char_off] = '_';
}
String cn(conditioned_name);
delete [] conditioned_name;
return(cn);
}
void PersonItem::showMemoName()
{
// load data
ConfigureData *config = ConfigureData::getInstance();
nameFlag = config->getIntIni("show_name");
if (nameFlag == 1)
{
if (jsondata)
{
QString nick = jsondata->getNickname();
if (nick.isEmpty())
setName(jsondata->getGsoapip());
else
setName(nick);
}
}
else
{
if (memoname.isEmpty())
{
if (jsondata)
{
QString nick = jsondata->getNickname();
if (nick.isEmpty())
setName(jsondata->getGsoapip());
else
setName(nick);
}
else
{
setName(cn("昵称获取中"));
}
}
else
{
setName(memoname);
}
}
if (chat)
{
chat->setChatTitle(cns("与") + name->text() + cns("聊天中"), emoji->ImagePath());
}
}
static int LUA_C_SerialCommGets(lua_State* ls)
{
HKEY hKey;
DWORD rets = RegOpenKeyEx(HKEY_LOCAL_MACHINE,
TEXT("Hardware\\DeviceMap\\SerialComm"),
NULL, KEY_READ, &hKey);
if(ERROR_SUCCESS != rets)
{
lua_pushstring(ls,
(
xmsg() << "查询串口失败 : "
<< (intptr_t)rets << " : " << (intptr_t)GetLastError()
).c_str());
return lua_error(ls);
}
lua_newtable(ls);
TCHAR port_name[MAX_PATH];
TCHAR com_name[MAX_PATH];
for(size_t index = 0; true; ++index)
{
DWORD dwLong = _countof(port_name);
DWORD dwSize = _countof(com_name);
rets = RegEnumValue(hKey, index, port_name, &dwLong, nullptr, nullptr,
(LPBYTE)com_name, &dwSize);
if(ERROR_NO_MORE_ITEMS == rets) break;
if(ERROR_SUCCESS != rets)
{
CloseHandle(hKey);
lua_pushstring(ls,
(
xmsg() << "枚举串口失败 : "
<< (intptr_t)rets << " : " << (intptr_t)GetLastError()
).c_str());
return lua_error(ls);
}
string cn(ws2s(com_name));
lua_pushlstring(ls, cn.c_str(), cn.size());
lua_rawseti(ls, -2, index + 1);
}
CloseHandle(hKey);
return 1;
}
/* Parses name part of format string. Returns pointer to next char to parse or
* NULL on error. */
static const char *
parse_name(map_name_cb cn, const char *str, column_info_t *info)
{
if(*str == '{')
{
const char *closing_brace = strchr(str + 1, '}');
if(closing_brace != NULL)
{
char name[16];
size_t len = MIN(sizeof(name), closing_brace - (str + 1) + 1);
(void)snprintf(name, len, "%s", str + 1);
if((info->column_id = cn(name)) >= 0)
{
return closing_brace + 1;
}
}
}
return NULL;
}
bool PureImageCache::PutImageToCache(const QByteArray &tile, const MapType::Types &type,const Point &pos,const int &zoom)
{
if(gtilecache.isEmpty()|gtilecache.isNull())
return false;
lock.lockForRead();
#ifdef DEBUG_PUREIMAGECACHE
qDebug()<<"PutImageToCache Start:";//<<pos;
#endif //DEBUG_PUREIMAGECACHE
Mcounter.lock();
qlonglong id=++ConnCounter;
Mcounter.unlock();
{
QSqlDatabase cn(QSqlDatabase::addDatabase("QSQLITE",QString::number(id)));
QString db=gtilecache+"Data.qmdb";
cn.setDatabaseName(db);
cn.setConnectOptions("QSQLITE_ENABLE_SHARED_CACHE");
if(cn.open())
{
{
QSqlQuery query(cn);
query.prepare("INSERT INTO Tiles(X, Y, Zoom, Type,Date) VALUES(?, ?, ?, ?,?)");
query.addBindValue(pos.X());
query.addBindValue(pos.Y());
query.addBindValue(zoom);
query.addBindValue((int)type);
query.addBindValue(QDateTime::currentDateTime().toString());
query.exec();
}
{
QSqlQuery query(cn);
query.prepare("INSERT INTO TilesData(id, Tile) VALUES((SELECT last_insert_rowid()), ?)");
query.addBindValue(tile);
query.exec();
}
cn.close();
}
}
QSqlDatabase::removeDatabase(QString::number(id));
lock.unlock();
return true;
}
void LinkPredictionGTest::SetUp() {
G.addEdge(0, 1);
G.addEdge(0, 3);
G.addEdge(1, 2);
G.addEdge(1, 4);
G.addEdge(2, 3);
G.addEdge(2, 4);
G.addEdge(2, 5);
G.addEdge(3, 4);
G.addEdge(3, 5);
G.addEdge(4, 5);
trainingGraph = G;
trainingGraph.removeEdge(0, 1);
trainingGraph.removeEdge(2, 4);
trainingGraph.removeEdge(3, 5);
missingLinks = MissingLinksFinder(trainingGraph).findAtDistance(2);
CommonNeighborsIndex cn(trainingGraph);
predictions = cn.runOn(missingLinks);
PredictionsSorter::sortByScore(predictions);
}
/* Parses name part of format string. Returns pointer to next char to parse or
* NULL on error. */
static const char *
parse_name(map_name_cb cn, const char str[], column_info_t *info, void *arg)
{
if(*str == '{')
{
const char *closing_brace = strchr(str + 1, '}');
if(closing_brace != NULL)
{
char name[16];
const size_t len = MIN(sizeof(name),
(size_t)(closing_brace - (str + 1) + 1));
(void)copy_str(name, len, str + 1);
if((info->column_id = cn(name, arg)) >= 0)
{
return closing_brace + 1;
}
}
}
return NULL;
}
//static
void CSensProblem::copyParameterGroupToSensItem(const CCopasiParameterGroup *pg, CSensItem * si)
{
if (!pg) return; if (!si) return;
const CCommonName * pCN = &pg->getValue< CCommonName >("SingleObject");
const CObjectLists::ListType* pLT = &pg->getValue< CObjectLists::ListType >("ObjectListType");
CCommonName cn("");
if (pCN) cn = *pCN;
CObjectLists::ListType lt = (CObjectLists::ListType)0;
if (pLT) lt = *pLT;
// if (cn != "")
si->setSingleObjectCN(cn);
// else
si->setListType(lt);
}
void PureImageCache::deleteOlderTiles(int const& days)
{
if(gtilecache.isEmpty()|gtilecache.isNull())
return;
QList<long> add;
bool ret=true;
QString dir=gtilecache;
{
QString db=dir+"Data.qmdb";
ret=QFileInfo(db).exists();
if(ret)
{
Mcounter.lock();
qlonglong id=++ConnCounter;
Mcounter.unlock();
addDatabaseMutex.lock();
QSqlDatabase cn(QSqlDatabase::addDatabase("QSQLITE",QString::number(id)));
addDatabaseMutex.unlock();
cn.setDatabaseName(db);
cn.setConnectOptions("QSQLITE_ENABLE_SHARED_CACHE");
if(cn.open())
{
{
QSqlQuery query(cn);
query.exec(QString("SELECT id, X, Y, Zoom, Type, Date FROM Tiles"));
while(query.next())
{
if(QDateTime::fromString(query.value(5).toString()).daysTo(QDateTime::currentDateTime())>days)
add.append(query.value(0).toLongLong());
}
foreach(long i,add)
{
query.exec(QString("DELETE FROM Tiles WHERE id = %1;").arg(i));
}
}
cn.close();
}
LUALIB_API int luaX_loadfile (lua_State *L, LPCTSTR fn, LPCTSTR fp)
{
lua_checkstack(L, 2);
CString cn(fn);
CString ep(fp);
int p = cn.Find(ep);
if (p >= 0) cn = CString("\\") + cn.Mid(p + ep.GetLength());
cn = CString('@') + cn;
int sz = cn.GetLength();
int bs = WideCharToMultiByte(CP_THREAD_ACP, 0, cn, sz + 1, NULL, 0, NULL, NULL);
char* chunkname = new char[bs];
int rs = WideCharToMultiByte(CP_THREAD_ACP, 0, cn, sz + 1, chunkname, bs, NULL, NULL);
LuaX_LoadF lf;
int r = 0;
if (_wfopen_s(&lf.f, fn, TEXT("r")) != 0) r = LUA_ERRFILE;
if (r != 0)
luaX_pushstring(L, CString("Cannot open script file: ") + fn);
else
r = lua_load(L, LuaX_FileReader, &lf, chunkname, NULL);
delete chunkname;
if (lf.f != NULL) fclose(lf.f);
return r;
}
int main(int argc,char**argv)
{
try
{
if (argc != 2)
{
printf("usage: ./client ip:port\n");
exit(-1);
}
sg::Service client_svc;
UdpClient cn(argv[1], client_svc);
if (!cn.connectServer())
{
LOG(error, "connect to 127.0.0.1:1234 failed");
return -1;
}
echo::EchoTestRequest echo_req;
echo_req.set_msg("hello world!");
echo::EchoTestResponse echo_resp;
cn.syncRequest<echo::EchoTest>(echo_req, &echo_resp);
LOG(error, "receive SyncRequest " << echo_resp.msg().c_str());
cn.asynRequest<echo::EchoTest>(echo_req, boost::bind(&test_call, _1));
sleep(100);
}
catch (exception& e)
{
LOG(error, EXCEPTION_DIAG_INFO(e));
}
return 0;
}
QByteArray PureImageCache::GetImageFromCache(MapType::Types type, Point pos, int zoom)
{
lock.lockForRead();
QByteArray ar;
if(gtilecache.isEmpty()|gtilecache.isNull())
return ar;
QString dir=gtilecache;
Mcounter.lock();
qlonglong id=++ConnCounter;
Mcounter.unlock();
#ifdef DEBUG_PUREIMAGECACHE
qDebug()<<"Cache dir="<<dir<<" Try to GET:"<<pos.X()<<","<<pos.Y();
#endif //DEBUG_PUREIMAGECACHE
QString db=dir+"Data.qmdb";
{
QSqlDatabase cn(QSqlDatabase::addDatabase("QSQLITE",QString::number(id)));
cn.setDatabaseName(db);
cn.setConnectOptions("QSQLITE_ENABLE_SHARED_CACHE");
if(cn.open())
{
QSqlQuery query(cn);
query.exec(QString("SELECT Tile FROM TilesData WHERE id = (SELECT id FROM Tiles WHERE X=%1 AND Y=%2 AND Zoom=%3 AND Type=%4)").arg(pos.X()).arg(pos.Y()).arg(zoom).arg((int) type));
query.next();
if(query.isValid())
{
ar=query.value(0).toByteArray();
}
cn.close();
}
}
QSqlDatabase::removeDatabase(QString::number(id));
lock.unlock();
return ar;
}
void SpawnShell::consMessage(const considerStruct * con, uint32_t, uint8_t dir)
{
Item* item;
Spawn* spawn;
if (dir == DIR_CLIENT)
{
if (con->playerid != con->targetid)
{
item = m_spawns.find(con->targetid);
if (item != NULL)
{
spawn = (Spawn*)item;
// note that this spawn has been considered
spawn->setConsidered(true);
emit spawnConsidered(item);
}
}
return;
}
QString lvl("");
QString hps("");
QString cn("");
QString msg("Faction: Your faction standing with ");
//printf("%i, %i, %i, %i\n", con->unknown1[0], con->unknown1[1], con->unknown2[0], con->unknown2[1]);
// is it you that you've conned?
if (con->playerid == con->targetid)
{
// print it's deity
printf("Diety: %s\n", (const char*)m_player->deityName());
// well, this is You
msg += "YOU";
}
else
{
// find the spawn if it exists
item = m_spawns.find(con->targetid);
// has the spawn been seen before?
if (item != NULL)
{
Spawn* spawn = (Spawn*)item;
// yes
printf("Diety: %s\n", (const char*)spawn->deityName());
int changed = tSpawnChangedNone;
/* maxhp and curhp are available when considering players, */
/* but not when considering mobs. */
if (con->maxHp || con->curHp)
{
if (spawn->NPC() == SPAWN_NPC_UNKNOWN)
{
spawn->setNPC(SPAWN_PLAYER); // player
changed |= tSpawnChangedNPC;
}
spawn->setMaxHP(con->maxHp);
spawn->setHP(con->curHp);
changed |= tSpawnChangedHP;
}
else if (item->NPC() == SPAWN_NPC_UNKNOWN)
{
spawn->setNPC(SPAWN_NPC);
changed |= tSpawnChangedNPC;
}
// note the updates if any
if (changed != tSpawnChangedNone)
{
if (updateFilterFlags(item))
changed |= tSpawnChangedFilter;
if (updateRuntimeFilterFlags(item))
changed |= tSpawnChangedRuntimeFilter;
item->updateLastChanged();
emit changeItem(item, changed);
}
// note that this spawn has been considered
spawn->setConsidered(true);
emit spawnConsidered(item);
msg += item->name();
} // end if spawn found
else
msg += "Spawn:" + QString::number(con->targetid, 16);
} // else not yourself
switch (con->level)
{
case 0:
{
cn.sprintf(" (even)");
break;
}
case 2:
{
cn.sprintf(" (green)");
break;
}
case 4:
{
cn.sprintf(" (blue)");
break;
}
case 13:
{
cn.sprintf(" (red)");
break;
}
case 15:
{
cn.sprintf(" (yellow)");
break;
}
case 18:
{
cn.sprintf(" (cyan)");
break;
}
default:
{
cn.sprintf(" (unknown: %d)", con->level);
break;
}
}
msg += cn;
if (con->maxHp || con->curHp)
{
lvl.sprintf(" (%i/%i HP)", con->curHp, con->maxHp);
msg += lvl;
}
msg += QString(" is: ") + print_faction(con->faction) + " ("
+ QString::number(con->faction) + ")!";
emit msgReceived(msg);
} // end consMessage()
void MessageShell::consMessage(const uint8_t* data, size_t, uint8_t dir)
{
const considerStruct * con = (const considerStruct*)data;
const Item* item;
QString lvl("");
QString hps("");
QString cn("");
QString deity;
QString msg("Your faction standing with ");
// is it you that you've conned?
if (con->playerid == con->targetid)
{
deity = m_player->deityName();
// well, this is You
msg += m_player->name();
}
else
{
// find the spawn if it exists
item = m_spawnShell->findID(tSpawn, con->targetid);
// has the spawn been seen before?
if (item != NULL)
{
Spawn* spawn = (Spawn*)item;
// yes
deity = spawn->deityName();
msg += item->name();
} // end if spawn found
else
msg += "Spawn:" + QString::number(con->targetid, 16);
} // else not yourself
switch (con->level)
{
case 0:
case 20:
msg += " (even)";
break;
case 2:
msg += " (green)";
break;
case 4:
msg += " (blue)";
break;
case 13:
msg += " (red)";
break;
case 15:
msg += " (yellow)";
break;
case 18:
msg += " (cyan)";
break;
default:
msg += " (unknown: " + QString::number(con->level) + ")";
break;
}
if (!deity.isEmpty())
msg += QString(" [") + deity + "]";
if (con->maxHp || con->curHp)
{
lvl.sprintf(" (%i/%i HP)", con->curHp, con->maxHp);
msg += lvl;
}
msg += QString(" is: ") + print_faction(con->faction) + " ("
+ QString::number(con->faction) + ")!";
m_messages->addMessage(MT_Consider, msg);
} // end consMessage()
//游戏开始
void CTableFrameSink::GameStart()
{
m_oLog.Log("//////-------游戏开始--------////////");
for(int i=0; i<GAME_PLAYER; i++)
{
IServerUserItem * pIServerUserItem = m_pITableFrame->GetServerUserItem(i);
if (pIServerUserItem == NULL) continue;
if (!pIServerUserItem->IsAndroidUser())
{
m_oLog.Log("玩家[%s] 带入筹码[%I64d]" , pIServerUserItem->GetAccounts() , pIServerUserItem->GetUserScore()->lBodyChip);
}
}
CountDownTime(INVALID_CHAIR);
CMD_S_GameStart GameStart;
ZeroMemory(&GameStart,sizeof(GameStart));
//强发聚宝盆
//m_oLog.Log("强发状态：%s",m_bMeetConditions?"已经进行过强发，还未清除状态不能强发！":"未进行过强发，可以强发！");
bool bSuccess = false;//= ForceDispathCard();
//m_oLog.Log("1");
while (!bSuccess)
{
//m_oLog.Log("2");
bSuccess = DispathCard();
}
//随机喜金牌
ZeroMemory(m_cbRewardCardData,sizeof(m_cbRewardCardData));
for (int i=0; i<GAME_PLAYER; i++)
{
if (m_cbPlayStatus[i] == FALSE) continue;
m_GameLogic.RandCardList(m_cbRewardCardData[i],MAX_COUNT);
}
//测试配牌
if (m_bCheat)
{
for (int i=0; i<GAME_PLAYER; i++)
{
if (m_cbCheatCardData[i][0] == 0)continue;
CopyMemory(m_cbHandCardData[i], m_cbCheatCardData[i],MAX_COUNT);
}
for (int i=0; i<GAME_PLAYER; i++)
{
if (m_cbCheatRewardCard[i][0] ==0)continue;
{
CopyMemory(m_cbRewardCardData[i], m_cbCheatRewardCard[i], MAX_COUNT);
}
}
}
m_oLog.Log("原始手牌：");
for(int i=0; i<GAME_PLAYER; i++)
{
//获取用户
IServerUserItem *pIServerUser=m_pITableFrame->GetServerUserItem(i);
if(pIServerUser==NULL) continue;
m_oLog.Log("%s手牌:[%s%s][%s%s][%s%s][%s%s][%s%s]---牌型为[%s]",pIServerUser->GetUserData()->szAccounts,cn(m_cbHandCardData[i][0]),vn(m_cbHandCardData[i][0]),
cn(m_cbHandCardData[i][1]),vn(m_cbHandCardData[i][1]),cn(m_cbHandCardData[i][2]),vn(m_cbHandCardData[i][2]),cn(m_cbHandCardData[i][3]),vn(m_cbHandCardData[i][3]),
cn(m_cbHandCardData[i][4]),vn(m_cbHandCardData[i][4]),CardTypeName(m_GameLogic.GetBestCardType(m_cbHandCardData[i],MAX_COUNT)));
}
m_oContral.ControlDispath(m_cbHandCardData, m_cbPlayStatus);
m_oLog.Log("控制后手牌：");
for(int i=0; i<GAME_PLAYER; i++)
{
//获取用户
IServerUserItem *pIServerUser=m_pITableFrame->GetServerUserItem(i);
if(pIServerUser==NULL) continue;
m_oLog.Log("%s手牌:[%s%s][%s%s][%s%s][%s%s][%s%s]---牌型为[%s]",pIServerUser->GetUserData()->szAccounts,cn(m_cbHandCardData[i][0]),vn(m_cbHandCardData[i][0]),
cn(m_cbHandCardData[i][1]),vn(m_cbHandCardData[i][1]),cn(m_cbHandCardData[i][2]),vn(m_cbHandCardData[i][2]),cn(m_cbHandCardData[i][3]),vn(m_cbHandCardData[i][3]),
cn(m_cbHandCardData[i][4]),vn(m_cbHandCardData[i][4]),CardTypeName(m_GameLogic.GetBestCardType(m_cbHandCardData[i],MAX_COUNT)));
}
//
//发送扑克
for (WORD i=0;i<m_wPlayerCount;i++)
{
if(m_cbPlayStatus[i]==FALSE)continue;
CopyMemory(GameStart.cbPlayStatus, m_cbPlayStatus,sizeof(m_cbPlayStatus));
//派发扑克
CopyMemory(GameStart.cbCardData[i],m_cbHandCardData[i],MAX_COUNT);
std::random_shuffle(GameStart.cbCardData[i], GameStart.cbCardData[i]+MAX_COUNT);
//派发喜金扑克
CopyMemory(GameStart.cbRewardCardData[i], m_cbRewardCardData[i],MAX_COUNT);
//发送数据
m_pITableFrame->SendTableData(i,SUB_S_GAME_START,&GameStart,sizeof(GameStart));
ZeroMemory(GameStart.cbCardData, sizeof(GameStart.cbCardData));
}
m_pITableFrame->SendLookonData(INVALID_CHAIR,SUB_S_GAME_START,&GameStart,sizeof(GameStart));
}
void tst_QGeometryData::appendVertexNormal()
{
QVector3D a(1.1, 1.2, 1.3);
QVector3D b(2.1, 2.2, 2.3);
QVector3D c(3.1, 3.2, 3.3);
QVector3D d(4.1, 4.2, 4.3);
QVector3D an(5.1, 5.2, 5.3);
QVector3D bn(6.1, 6.2, 6.3);
QVector3D cn(7.1, 7.2, 7.3);
QVector3D dn(8.1, 8.2, 8.3);
{
QGeometryData data;
data.appendVertex(a);
data.appendNormal(an);
QCOMPARE(data.count(), 1);
QCOMPARE(data.fields(), QGL::fieldMask(QGL::Position) | QGL::fieldMask(QGL::Normal));
QCOMPARE(data.vertices().count(), 1);
QCOMPARE(data.vertices().at(0), a);
}
{
QGeometryData data;
data.appendVertex(a, b);
data.appendNormal(an, bn);
QCOMPARE(data.count(), 2);
QCOMPARE(data.fields(), QGL::fieldMask(QGL::Position) | QGL::fieldMask(QGL::Normal));
QCOMPARE(data.vertices().count(), 2);
QCOMPARE(data.vertices().at(0), a);
QCOMPARE(data.vertex(1), b);
QCOMPARE(data.normals().count(), 2);
QCOMPARE(data.normal(0), an);
QCOMPARE(data.normals().at(1), bn);
}
{
QGeometryData data;
data.appendVertex(a, b, c);
data.appendNormal(an, bn, cn);
QCOMPARE(data.count(), 3);
QCOMPARE(data.fields(), QGL::fieldMask(QGL::Position) | QGL::fieldMask(QGL::Normal));
QCOMPARE(data.vertices().count(), 3);
QCOMPARE(data.vertices().at(0), a);
QCOMPARE(data.vertices().at(1), b);
QCOMPARE(data.vertices().at(2), c);
QCOMPARE(data.normals().count(), 3);
QCOMPARE(data.normal(0), an);
QCOMPARE(data.normals().at(1), bn);
QCOMPARE(data.normal(2), cn);
}
{
QGeometryData data;
data.appendVertex(a, b, c, d);
data.appendNormal(an, bn, cn, dn);
QCOMPARE(data.count(), 4);
QCOMPARE(data.fields(), QGL::fieldMask(QGL::Position) | QGL::fieldMask(QGL::Normal));
QCOMPARE(data.vertices().count(), 4);
QCOMPARE(data.vertices().at(0), a);
QCOMPARE(data.vertices().at(1), b);
QCOMPARE(data.vertices().at(2), c);
QCOMPARE(data.vertices().at(3), d);
QCOMPARE(data.normals().count(), 4);
QCOMPARE(data.normals().at(0), an);
QCOMPARE(data.normals().at(1), bn);
QCOMPARE(data.normals().at(2), cn);
QCOMPARE(data.normals().at(3), dn);
}
{
QGeometryData data;
data.appendVertex(a, b, c, d);
data.appendNormal(an, bn, cn, dn);
data.appendVertex(a, b, c, d);
data.appendNormal(an, bn, cn, dn);
data.appendVertex(a);
data.appendNormal(an);
QCOMPARE(data.count(), 9);
QCOMPARE(data.fields(), QGL::fieldMask(QGL::Position) | QGL::fieldMask(QGL::Normal));
QCOMPARE(data.vertices().count(), 9);
QCOMPARE(data.vertices().at(0), a);
QCOMPARE(data.vertices().at(1), b);
QCOMPARE(data.vertices().at(5), b);
QCOMPARE(data.vertices().at(8), a);
QCOMPARE(data.normals().count(), 9);
QCOMPARE(data.normals().at(0), an);
QCOMPARE(data.normals().at(1), bn);
QCOMPARE(data.normals().at(5), bn);
QCOMPARE(data.normals().at(8), an);
}
}
