void testVariant() { // test default constructor { Variant var; ASSERT(var.isNull()); ASSERT(var.toBool() == false); } // test self assign { Variant var(String(_T("hallo"))); ASSERT(var.toString() == _T("hallo")); var = var; ASSERT(var.toString() == _T("hallo")); Variant var2(123); ASSERT(var2.toInt() == 123); var2 = var2; ASSERT(var2.toInt() == 123); } // test boolean constructor { Variant var(true); ASSERT(var.toBool() == true); } // test map constructor { HashMap<String, Variant> map; map.append(_T("dasd"), Variant(String(_T("yes")))); Variant var(map); ASSERT(((const Variant&)var).toMap().find(_T("dasd"))->toString() == _T("yes")); ASSERT(var.toMap().find(_T("dasd"))->toString() == _T("yes")); } // test copy construction of null variant { Variant null; ASSERT(null.isNull()); Variant copy(null); ASSERT(copy.isNull()); } // test list detaching { Variant var1; var1.toList().append(123); Variant var2(var1); List<Variant>& var2list = var2.toList(); ASSERT(var2list.size() == 1); var2list.clear(); ASSERT(((const Variant&)var1).toList().size() == 1); } }
void_t Main::controlUserBroker(uint32_t requestId, uint64_t entityId, uint32_t controlCode, const byte_t* data, size_t size) { switch(controlCode) { case meguco_user_broker_control_refresh_orders: { List<meguco_user_broker_order_entity> newOrders; if(!broker->loadOrders(newOrders)) { addLogMessage(meguco_log_error, broker->getLastError()); return (void_t)connection.sendControlResponse(requestId, 0); } Map<int64_t, meguco_user_broker_order_entity*> sortedNewOrders; for(List<meguco_user_broker_order_entity>::Iterator i = newOrders.begin(), end = newOrders.end(); i != end; ++i) sortedNewOrders.insert((*i).entity.time, &*i); HashMap<uint64_t, meguco_user_broker_order_entity> ordersMapByRaw; for(HashMap<uint64_t, meguco_user_broker_order_entity>::Iterator i = orders2.begin(), end = orders2.end(); i != end; ++i) { meguco_user_broker_order_entity& order = *i; ordersMapByRaw.append(order.raw_id, order); } orders2.clear(); for(Map<int64_t, meguco_user_broker_order_entity*>::Iterator i = sortedNewOrders.begin(), end = sortedNewOrders.end(); i != end; ++i) { meguco_user_broker_order_entity& order = **i; HashMap<uint64_t, meguco_user_broker_order_entity>::Iterator it = ordersMapByRaw.find(order.raw_id); if(it == ordersMapByRaw.end() || it->entity.id == 0) { // add uint64_t id; if(connection.add(userBrokerOrdersTableId, order.entity, id)) { order.entity.id = id; orders2.append(order.entity.id, order); } } else { // update order.entity.id = it->entity.id; if(Memory::compare(&*it, &order, sizeof(order)) != 0 && connection.update(userBrokerOrdersTableId, order.entity)) orders2.append(order.entity.id, order); else orders2.append(order.entity.id, *it); ordersMapByRaw.remove(it); } } for(HashMap<uint64_t, meguco_user_broker_order_entity>::Iterator i = ordersMapByRaw.begin(), end = ordersMapByRaw.end(); i != end; ++i) { // remove meguco_user_broker_order_entity& order = *i; if(!connection.remove(userBrokerOrdersTableId, order.entity.id)) orders2.append(order.entity.id, order); } } return (void_t)connection.sendControlResponse(requestId, 0, 0); case meguco_user_broker_control_refresh_transactions: { List<meguco_user_broker_transaction_entity> newTransactions; if(!broker->loadTransactions(newTransactions)) { addLogMessage(meguco_log_error, broker->getLastError()); return (void_t)connection.sendControlResponse(requestId, 0); } Map<int64_t, meguco_user_broker_transaction_entity*> sortedNewTransactions; for(List<meguco_user_broker_transaction_entity>::Iterator i = newTransactions.begin(), end = newTransactions.end(); i != end; ++i) sortedNewTransactions.insert((*i).entity.time, &*i); HashMap<uint64_t, meguco_user_broker_transaction_entity> transactionsapByRaw; for(HashMap<uint64_t, meguco_user_broker_transaction_entity>::Iterator i = transactions2.begin(), end = transactions2.end(); i != end; ++i) { meguco_user_broker_transaction_entity& transaction = *i; transactionsapByRaw.append(transaction.raw_id, transaction); } transactions2.clear(); for(Map<int64_t, meguco_user_broker_transaction_entity*>::Iterator i = sortedNewTransactions.begin(), end = sortedNewTransactions.end(); i != end; ++i) { meguco_user_broker_transaction_entity& transaction = **i; HashMap<uint64_t, meguco_user_broker_transaction_entity>::Iterator it = transactionsapByRaw.find(transaction.raw_id); if(it == transactionsapByRaw.end() || it->entity.id == 0) { // add uint64_t id; if(connection.add(userBrokerTransactionsTableId, transaction.entity, id)) { transaction.entity.id = id; transactions2.append(transaction.entity.id, transaction); } } else { // update transaction.entity.id = it->entity.id; if(Memory::compare(&*it, &transaction, sizeof(transaction)) != 0 && connection.update(userBrokerTransactionsTableId, transaction.entity)) transactions2.append(transaction.entity.id, transaction); else transactions2.append(transaction.entity.id, *it); transactionsapByRaw.remove(it); } } for(HashMap<uint64_t, meguco_user_broker_transaction_entity>::Iterator i = transactionsapByRaw.begin(), end = transactionsapByRaw.end(); i != end; ++i) { // remove meguco_user_broker_transaction_entity& transaction = *i; if(!connection.remove(userBrokerTransactionsTableId, transaction.entity.id)) transactions2.append(transaction.entity.id, transaction); } } return (void_t)connection.sendControlResponse(requestId, 0, 0); case meguco_user_broker_control_refresh_balance: { meguco_user_broker_balance_entity newBalance; if(!broker->loadBalance(newBalance)) { addLogMessage(meguco_log_error, broker->getLastError()); return (void_t)connection.sendControlResponse(requestId, 0); } if(this->balance.entity.id == 0) { uint64_t id; if(connection.add(userBrokerBalanceTableId, newBalance.entity, id)) newBalance.entity.id = id; } else { newBalance.entity.id = this->balance.entity.id; connection.update(userBrokerBalanceTableId, newBalance.entity); } this->balance = newBalance; } return (void_t)connection.sendControlResponse(requestId, (const byte_t*)&balance, sizeof(meguco_user_broker_balance_entity)); case meguco_user_broker_control_create_order: if(size < sizeof(meguco_user_broker_order_entity)) return (void_t)connection.sendControlResponse(requestId, zlimdb_error_invalid_request); { const meguco_user_broker_order_entity& args = *(const meguco_user_broker_order_entity*)data; meguco_user_broker_order_entity newOrder; if(!broker->createOrder((meguco_user_broker_order_type)args.type, args.price, args.amount, args.total, newOrder)) { addLogMessage(meguco_log_error, broker->getLastError()); return (void_t)connection.sendControlResponse(requestId, 0); } newOrder.state = meguco_user_broker_order_open; newOrder.timeout = args.timeout; // add entity to user brokers table uint64_t id; if(!connection.add(userBrokerOrdersTableId, newOrder.entity, id)) return (void_t)connection.sendControlResponse(requestId, (uint16_t)connection.getErrno()); newOrder.entity.id = id; orders2.append(id, newOrder); // return entity id return (void_t)connection.sendControlResponse(requestId, (const byte_t*)&newOrder, sizeof(meguco_user_broker_order_entity)); } case meguco_user_broker_control_cancel_order: case meguco_user_broker_control_remove_order: { HashMap<uint64_t, meguco_user_broker_order_entity>::Iterator it = orders2.find(entityId); if(it == orders2.end()) return (void_t)connection.sendControlResponse(requestId, zlimdb_error_entity_not_found); meguco_user_broker_order_entity& order = *it; // cancel order if(order.state == meguco_user_broker_order_open) { if(!broker->cancelOrder(order.raw_id)) { addLogMessage(meguco_log_error, broker->getLastError()); return (void_t)connection.sendControlResponse(requestId, 0); } } // update order state if(controlCode == meguco_user_broker_control_cancel_order) { order.state = meguco_user_broker_order_canceled; if(!connection.update(userBrokerOrdersTableId, order.entity)) return (void_t)connection.sendControlResponse(requestId, (uint16_t)connection.getErrno()); } else { if(!connection.remove(userBrokerOrdersTableId, order.entity.id)) return (void_t)connection.sendControlResponse(requestId, (uint16_t)connection.getErrno()); orders2.remove(it); } // send answer return (void_t)connection.sendControlResponse(requestId, 0, 0); } case meguco_user_broker_control_update_order: if(size < sizeof(meguco_user_broker_control_update_order_params)) return (void_t)connection.sendControlResponse(requestId, zlimdb_error_invalid_request); { HashMap<uint64_t, meguco_user_broker_order_entity>::Iterator it = orders2.find(entityId); if(it == orders2.end()) return (void_t)connection.sendControlResponse(requestId, zlimdb_error_entity_not_found); meguco_user_broker_order_entity& order = *it; const meguco_user_broker_control_update_order_params& params = *(const meguco_user_broker_control_update_order_params*)data; // cancel order if(!broker->cancelOrder(order.raw_id)) { addLogMessage(meguco_log_error, broker->getLastError()); return (void_t)connection.sendControlResponse(requestId, 0); } // create new order with same id meguco_user_broker_order_entity newOrder; if(!broker->createOrder((meguco_user_broker_order_type)order.type, params.price, params.amount, params.total, newOrder)) { addLogMessage(meguco_log_error, broker->getLastError()); order.state = meguco_user_broker_order_error; } else { newOrder.entity.id = order.entity.id; newOrder.timeout = order.timeout; order = newOrder; order.state = meguco_user_broker_order_open; } // update order state in table if(!connection.update(userBrokerOrdersTableId, order.entity)) return (void_t)connection.sendControlResponse(requestId, (uint16_t)connection.getErrno()); // send answer if(order.state == meguco_user_broker_order_error) return (void_t)connection.sendControlResponse(requestId, 0); else return (void_t)connection.sendControlResponse(requestId, 0, 0); } default: return (void_t)connection.sendControlResponse(requestId, zlimdb_error_invalid_request); } }