int InsertCommand::execute( ossSocket & sock, std::vector<std::string> & argVec )
{
int rc = EDB_OK;
if( argVec.size() <1 )
{
return getError(EDB_INSERT_INVALID_ARGUMENT);
}
_jsonString = argVec[0];
if( !sock.isConnected() )
{
return getError(EDB_SOCK_NOT_CONNECT);
}
rc = sendOrder( sock, msgBuildInsert );
PD_RC_CHECK ( rc, PDERROR, "Failed to send order, rc = %d", rc ) ;
rc = recvReply( sock );
PD_RC_CHECK ( rc, PDERROR, "Failed to receive reply, rc = %d", rc ) ;
rc = handleReply();
PD_RC_CHECK ( rc, PDERROR, "Failed to receive reply, rc = %d", rc ) ;
done :
return rc;
error :
goto done ;
}
void p3ZeroReserveRS::sendOrderBook( const std::string & uid )
{
{
RsStackMutex askMutex( m_asks->m_order_mutex );
for( OrderBook::OrderIterator it = m_asks->begin(); it != m_asks->end(); it++ ){
sendOrder( uid, *it );
}
}
{
RsStackMutex bidMutex( m_bids->m_order_mutex );
for( OrderBook::OrderIterator it = m_bids->begin(); it != m_bids->end(); it++ ){
sendOrder( uid, *it );
}
}
sendItem( new RsZeroReserveMsgItem( RsZeroReserveMsgItem::SENT_ORDERBOOK, "" ) );
}
void Reception::run(void) {
Kitchen *to_send;
while (!this->_orders.empty()) {
bool taken(false);
this->_kitchens.sort(Misc::sortByOrders);
for (std::list<Kitchen>::iterator it = this->_kitchens.begin(); it != this->_kitchens.end(); it++) {
if (it->canTakeOrder()) {
it->takeOrder();
it->push(this->_orders.front());
to_send = &(*it);
taken = true;
break;
}
}
if (!taken) {
to_send = createKitchen();
to_send->push(this->_orders.front());
}
sendOrder(to_send);
this->pop();
}
this->_currentKitchen = NULL;
}
int main(int argc, char *argv[])
{
QApplication::setGraphicsSystem("raster");
QApplication a(argc, argv);
QTextCodec::setCodecForTr(QTextCodec::codecForLocale());
QString privatePathQt(QApplication::applicationDirPath());
QString path(privatePathQt);
path = QDir::toNativeSeparators(path);
Server server;
if (!server.listen(QHostAddress::Any, 6177)) {
std::cerr << "Failed to bind to port" << std::endl;
return 1;
}
QDeclarativeView view;
view.engine()->setOfflineStoragePath(path);
QObject::connect((QObject*)view.engine(), SIGNAL(quit()), &a, SLOT(quit()));
view.setSource(QUrl("qrc:/qml/main.qml"));
view.show();
QString md5;
QString dbname="DemoDB";
QByteArray ba;
ba = QCryptographicHash::hash (dbname.toAscii(), QCryptographicHash::Md5);
md5.append(ba.toHex());
md5.append(".sqlite");
path.append(QDir::separator()).append("Databases");
path.append(QDir::separator()).append(md5);
QSqlDatabase db = QSqlDatabase::addDatabase("QSQLITE");
db.setDatabaseName(path);
if (!db.open()) {
std::cerr << "Cannot open database" << std::endl;
return 1;
}
OrderManager orderManager;
view.rootContext()->setContextProperty("server", &server);
view.rootContext()->setContextProperty("orderManager", &orderManager);
Client client;
QObject::connect(&orderManager, SIGNAL(send()), &client, SLOT(sendOrder()));
QObject::connect(&server, SIGNAL(paied(quint32)), &orderManager, SLOT(payOrder(quint32)));
DeviceManager deviceManager;
QObject::connect(&deviceManager, SIGNAL(registerSignal()), &client, SLOT(sendRegistration()));
view.rootContext()->setContextProperty("deviceManager", &deviceManager);
deviceManager.registerDevice();
return a.exec();
}
int QuitCommand::execute( ossSocket & sock, std::vector<std::string> & argVec )
{
int ret = EDB_OK;
if( !sock.isConnected() )
{
return getError(EDB_SOCK_NOT_CONNECT);
}
ret = sendOrder( sock, 0 );
//sock.close();
ret = handleReply();
return ret;
}
int SnapshotCommand::execute( ossSocket & sock, std::vector<std::string> &argVec)
{
int rc = EDB_OK;
if( !sock.isConnected() )
{
return getError(EDB_SOCK_NOT_CONNECT);
}
rc = sendOrder( sock, OP_SNAPSHOT );
PD_RC_CHECK ( rc, PDERROR, "Failed to send order, rc = %d", rc);
rc = recvReply( sock );
PD_RC_CHECK ( rc, PDERROR, "Failed to receive reply, rc = %d", rc);
rc = handleReply();
PD_RC_CHECK ( rc, PDERROR, "Failed to receive reply, rc = %d", rc);
done :
return rc;
error :
goto done ;
}
void p3ZeroReserveRS::publishOrder( OrderBook::Order * order, RsZeroReserveOrderBookItem * item )
{
std::list< std::string > sendList;
m_peers->getOnlineList(sendList);
for(std::list< std::string >::const_iterator it = sendList.begin(); it != sendList.end(); it++ ){
if( (*it) == getOwnId() ) continue;
if( item && (*it) == item->PeerId() ) continue; // don't return to sender
Credit c( *it, Currency::currencySymbols[ order->m_currency ] );
c.loadPeer();
// do not route orders we cannot at least fill to 10%
if( order->m_orderType == OrderBook::Order::ASK && ( order->m_purpose != OrderBook::Order::CANCEL || order->m_purpose != OrderBook::Order::FILLED ) ){
if( c.getMyAvailable() < order->m_amount * 0.1 ) continue;
}
else{
if( c.getPeerAvailable() < order->m_amount * 0.1 ) continue;
}
sendOrder( *it, order );
}
}
void Kitchen::run()
{
bool done = false;
std::string trame;
std::string cmd;
this->throwCounter();
while (!done)
{
trame = getOrder();
std::vector<std::string> untrame = Trame::unpack(trame);
if (untrame.size() > 0)
{
cmd = Trame::getCmd(trame);
if (cmd == "GetStat")
sendOrder(buildStat());
else if (cmd == "GetPizza")
this->chief->preparePizza(trame);
else if (cmd == "Destroy")
done = true;
}
}
}
void Player::update()
{
m_controller.update();
m_gui->updateChildren(m_controller, Vec(0, 0), m_drawDim);
if(m_controller.pressed(SELECT) && !m_gui->isInside(m_controller.mousePos()))
{
m_A = screenToWorld(mousePos());
m_selecting = true;
}
if(m_controller.down(SELECT))
m_B = screenToWorld(mousePos());
else
{
m_A = m_B;
m_selecting = false;
}
if(m_selecting)
{
m_selection = m_world.selectEntitiesInRect(this, m_A, m_B);
}
if(!m_gui->isInside(m_controller.mousePos()) && m_selection.size() > 0)
sendOrder();
}
INT32U cbd_reciple_data::getData(INT8U type)
{
switch(type)
{
///***********************************running time******************************************
case TYPE_RUNTIME:
setModePid(0x01, 0x1f);
sendOrder();
return char_meger(m_cData[3], m_cData[4]);
break;
///***********************************vehicle speed*****************************************
case TYPE_VSPEED:
setModePid(0x01, 0x0d);
sendOrder();
m_nSpeed = m_cData[3];
AvSpeedBufSave();
if(m_nSpeed<150)
return (INT32U)m_nSpeed;
else return m_cSpeedBuf[AVERAGENUM-1];
break;
///***********************************average vehicle speed *******************************
case TYPE_AVSPEED:
return AvSpeedCount();
break;
///***********************************mileage***********************************************
case TYPE_MILEAGE:
setModePid(0x01, 0x31);
sendOrder();
return (char_meger(m_cData[3], m_cData[4]) - m_nMileage_init);
break;
///***********************************InstantaneousFuelConsumption**************************
case TYPE_FUELCON:
setModePid(0x01, 0x10);
sendOrder();
return char_meger(m_cData[3], m_cData[4]);
break;
///***********************************engine speed******************************************
case TYPE_ENGINE_SPEED:
setModePid(0x01, 0x0c);
sendOrder();
return (char_meger(m_cData[3], m_cData[4])/4);
break;
///***********************************oil temperature***************************************
case TYPE_OILTEMP:
setModePid(0x01, 0x05);
sendOrder();
return (m_cData[3] - 40);
break;
///***********************************cooltant temperature**********************************
case TYPE_COOLTEMP:
setModePid(0x01, 0x05);
sendOrder();
return (m_cData[3] - 40);
break;
///***********************************something else ? *************************************
default:
;
}
}
