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);
}
}
