/** * Add or remove waiting times from an order. * @param tile Not used. * @param flags Operation to perform. * @param p1 Various bitstuffed elements * - p1 = (bit 0-19) - Vehicle with the orders to change. * - p1 = (bit 20-27) - Order index to modify. * - p1 = (bit 28) - Whether to change the waiting time or the travelling * time. * @param p2 The amount of time to wait. * - p2 = (bit 0-15) - Waiting or travelling time as specified by p1 bit 28 * @param text unused * @return the cost of this operation or an error */ CommandCost CmdChangeTimetable(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text) { VehicleID veh = GB(p1, 0, 20); Vehicle *v = Vehicle::GetIfValid(veh); if (v == NULL || !v->IsPrimaryVehicle()) return CMD_ERROR; CommandCost ret = CheckOwnership(v->owner); if (ret.Failed()) return ret; VehicleOrderID order_number = GB(p1, 20, 8); Order *order = v->GetOrder(order_number); if (order == NULL || order->IsType(OT_IMPLICIT)) return CMD_ERROR; bool is_journey = HasBit(p1, 28); int wait_time = order->wait_time; int travel_time = order->travel_time; if (is_journey) { travel_time = GB(p2, 0, 16); } else { wait_time = GB(p2, 0, 16); } if (wait_time != order->wait_time) { switch (order->GetType()) { case OT_GOTO_STATION: if (order->GetNonStopType() & ONSF_NO_STOP_AT_DESTINATION_STATION) return_cmd_error(STR_ERROR_TIMETABLE_NOT_STOPPING_HERE); break; case OT_CONDITIONAL: break; default: return_cmd_error(STR_ERROR_TIMETABLE_ONLY_WAIT_AT_STATIONS); } } if (travel_time != order->travel_time && order->IsType(OT_CONDITIONAL)) return CMD_ERROR; if (flags & DC_EXEC) { if (wait_time != order->wait_time) ChangeTimetable(v, order_number, wait_time, false); if (travel_time != order->travel_time) ChangeTimetable(v, order_number, travel_time, true); } return CommandCost(); }
void OrderBook::runOrderBook() { Order orderToExecute; while(open){ if(orders.try_pop(orderToExecute)){ switch(orderToExecute.m_type) { case LIMIT_SELL: //std::cout << "limit sell :" << std::endl; processLimitSellOrder(orderToExecute); break; case LIMIT_BUY: //std::cout << "limit buy : " << std::endl; processLimitBuyOrder(orderToExecute); break; case MARKET_SELL: //std::cout << "market sell" << std::endl; processMarketSellOrder(orderToExecute); break; case MARKET_BUY: //std::cout << "market buy" << std::endl; processMarketBuyOrder(orderToExecute); break; case CANCEL_BUY: //std::cout << "cancel buy" << std::endl; processBuyCancellation(orderToExecute.m_owner, orderToExecute.m_globalOrderIdentifier, orderToExecute.getPrice(), orderToExecute.m_time); break; case CANCEL_SELL: //std::cout << "cancel sell" << std::endl; processSellCancellation(orderToExecute.m_owner, orderToExecute.m_globalOrderIdentifier, orderToExecute.getPrice(), orderToExecute.m_time); break; case CLEAR_OB: /*cleanOrderBook(); setDefaultBidAsk(orderToExecute.m_newBid, orderToExecute.m_newAsk);*/ break; default: break; } m_linkToMarket->updateCurrentTime(orderToExecute.m_time); m_linkToMarket->notifyAllAgents(); if(orderToExecute.getOwner() == 3) nbOrderMM++; nbOrder++; } } }
bool Path::Load(pugi::xml_node const& aPathNode) { mName = aPathNode.attribute("name").value(); mStartPosition.x = static_cast<float>(aPathNode.child("start_point").attribute("x").as_float()); mStartPosition.y = static_cast<float>(aPathNode.child("start_point").attribute("y").as_int()); for(pugi::xml_node const& aOrderNode : aPathNode.children("order")) { Order o; if(!o.Load(aOrderNode)) { std::cout << "Could not load order on path" << std::endl; assert(0); return false; } mOrders.push_back(o); } return true; }
OrderList PgsqlDataProvider::getOrders(OrderType type, string methodName, uint32_t stockId) { OrderList orderList; nontransaction command(*conn); string query = "SELECT id, broker_id, stock_id, amount, price FROM " + methodName + "(" + to_string(stockId) + ");"; result queryResult(command.exec(query)); if (verbose) cout << "Result of " << query << ": " << endl; ResultIterator endIterator = queryResult.end(); for (ResultIterator iterator = queryResult.begin(); iterator != endIterator; ++iterator) { Order order; order.setId(iterator[0].as<uint64_t>()); order.setType(type); order.setBrokerId(iterator[1].as<uint32_t>()); order.setStockId(iterator[2].as<uint32_t>()); order.setAmount(iterator[3].as<uint32_t>()); order.setPrice(Decimal(iterator[4].as<string>())); orderList.push_back(order); } if (verbose) cout << orderList.size() << " orders. " << endl; return orderList; }
void MainWindow::onOrderTaken() { ui->answer->setText("^"); enableInput(); int id = factory->take_order(); if(id == -1) { ui->orderInfo->setText(""); disableInput(); } else { factory->remove_order(id); Order* order = factory->get_order_in_progress(); QStringList words; for (std::string word : order->get_words()) { words << QString(word.c_str()); } ui->orderInfo->setText(words.join(", ")); ui->takeOrder->setDisabled(true); } }
void Fleet::doOnceATurn(){ Game* game = Game::getGame(); IGObject * pob = game->getObjectManager()->getObject(obj->getParent()); uint32_t obT_Planet = game->getObjectTypeManager()->getObjectTypeByName("Planet"); if(pob->getType() == obT_Planet && ((Planet*)(pob->getObjectBehaviour()))->getOwner() == getOwner()){ IntegerObjectParam* damage = ((IntegerObjectParam*)(obj->getParameter(4,2))); if(damage->getValue() != 0){ damage->setValue(0); obj->touchModTime(); } } game->getObjectManager()->doneWithObject(obj->getParent()); Order* order = game->getOrderManager()->getOrderQueue(((OrderQueueObjectParam*)(obj->getParameter(3,1)))->getQueueId())->getFirstOrder(); if(order == NULL || order->getType() != game->getOrderManager()->getOrderTypeByName("Move")){ setVelocity(Vector3d(0,0,0)); } }
void OrderMatcher::matchOrders(TradeList& tradeList, OrderList& buyList, OrderList& sellList, Decimal price) { if (verbose) cout << endl << "Matching orders..." << endl; if (buyList.size() == 0 || sellList.size() == 0) return; Order buyOrder = buyList.front(); Order sellOrder = sellList.front(); bool finished = false; while (!finished && buyOrder.getPrice() >= price && sellOrder.getPrice() <= price) { uint32_t amount = std::min(buyOrder.getAmount(), sellOrder.getAmount()); Trade trade(amount, price, buyOrder, sellOrder); tradeList.push_back(trade); buyOrder.decreaseAmount(amount); sellOrder.decreaseAmount(amount); if (buyOrder.getAmount() == 0) { buyList.pop_front(); if (buyList.size() > 0) buyOrder = buyList.front(); else finished = true; } if (sellOrder.getAmount() == 0) { sellList.pop_front(); if (sellList.size() > 0) sellOrder = sellList.front(); else finished = true; } } }
int main() { GOOGLE_PROTOBUF_VERIFY_VERSION; Order order; initOrder(&order); // serialize object to string std::string order_str; order.SerializeToString(&order_str); std::cout << order_str << std::endl; std::string Order_debug = order.DebugString(); std::cout << Order_debug << std::endl; Order order_2; order_2.ParseFromString(order_str); google::protobuf::ShutdownProtobufLibrary(); return 0; }
void Position::HandleCommission( const Order& order ) { //std::cout << "Position Comm: " << m_row.dblCommissionPaid << "," << order.GetCommission(); double dblNewCommissionPaid = order.GetIncrementalCommission(); //std::cout << "," << dblNewCommissionPaid << std::endl; if ( 0 != dblNewCommissionPaid ) { m_row.dblCommissionPaid += dblNewCommissionPaid; OnUpdateCommissionForPortfolioManager( *this ); OnCommission( PositionDelta_delegate_t( *this, 0, dblNewCommissionPaid ) ); } }
bool BidOrOffer::Load(PacketBase& packet) { m_lstOrders.clear(); if (!packet.ReadString(m_strBidPrice, 10)) return false; int nOrderCount; if (!packet.ReadInt(nOrderCount, 4)) return false; while (--nOrderCount >= 0) { Order order; if (!order.Load(packet)) return false; m_lstOrders.push_back(order); } return true; }
void GameTraceCollector::CollectGameTraceForBuildAddon(const Unit unit) { Order order = unit->getOrder(); ActionType action; // PlaceAddon order has a special handling _ASSERTE(unit->isBeingConstructed()); LogInfo("(P%d,%s) %s[%d]: %s", unit->getPlayer()->getID(), unit->getPlayer()->getName().c_str(), unit->getType().getName().c_str(), unit->getID(), order.c_str()); LogInfo("Order PlaceAddon for %s will be collected", unit->getType().getName().c_str()); _ASSERTE(g_Database.ActionMapping.ContainsFirst(Orders::PlaceAddon.getID())); action = g_Database.ActionMapping.GetByFirst(Orders::PlaceAddon.getID()); PlanStepParameters actionParams = m_abstractor.GetAbstractedParameter(action, unit); GameTrace *pTrace = new GameTrace(Broodwar->getFrameCount(), action, actionParams, g_Game->Snapshot(), m_playerToObserve); SendGameTrace(pTrace); }
void Orderbook::insertOrdertoAsk(Order order) { Message *insertMessage = new Message(); // look for order price set (key & vector) in the ask map map<double, vector<Order>>::iterator orderInMap = Ask.find(order.getLimitPrice()); if (orderInMap == Ask.end()) // had not found { vector<Order> newVector; newVector.push_back(order); Ask.insert(pair <double, vector<Order>>(order.getLimitPrice(), newVector)); insertMessage->insertToNewMapPrice(order); } else // Map already has orders with same price { orderInMap->second.push_back(order); insertMessage->insertToVector(order, (int)orderInMap->second.size()); } delete insertMessage; }
void Orderbook::insertOrdertoBid(Order order) { Message *insertMessage = new Message(); // look for order price set (key & vector) in the bid map map<double, vector<Order>>::iterator orderInMap = Bid.find(order.getLimitPrice()); if (orderInMap == Bid.end()) // No existing price in map { vector<Order> newVector; newVector.push_back(order); Bid.insert(pair <double, vector<Order>>(order.getLimitPrice(), newVector)); insertMessage->insertToNewMapPrice(order); } else // Map already has orders with same price (put order in vector of orders (of the same price)) { orderInMap->second.push_back(order); insertMessage->insertToVector(order, (int)orderInMap->second.size()); } // Garbage removal delete insertMessage; }
void DocumentZALController::insertOrderData(Order order) { view->getLineOrderSymbol()->setText(order.getSymbol()); view->setContractorData(order.getContractor()); view->setLineIssueName(order.getIssueName()); view->setLineReceiveName(order.getReceiveName()); view->setLineDiscount(order.getDiscount()); view->setLineDocumentPlace(order.getDocumentPlace()); manager->setContractor(order.getContractor()); manager->setDocumentPositions(order.getDocumentPositions()); manager->countGoodsValue(view->getDiscountOrWaybillNo()->text().toDouble()); setGoodsValue(); addGood(); }
void OrderBook::displayBids() //Function to display Bids { deque<Order*> x1; Order* x = new Order(); if(BidBook.empty()) { cout<<"There are no Bid Orders. The book is empty"<<endl<<endl<<endl; return; } for(map<double,deque<Order*> >::iterator it=BidBook.begin(); it!=BidBook.end(); it++) { x1 = it->second; //Get Queue from that particular price and iterate over it for (deque<Order*>::iterator it2 = x1.begin(); it2!=x1.end(); it2++) { x = *it2; cout<<"Name: "<<x->getCounterParty()<<endl; cout<<"Security: "<<x->getSecurity()<<endl; cout<<"Type: "<<x->getType()<<endl; cout<<"Quantity: "<<x->getQuantity()<<endl; cout<<"Price: "<<x->getLimit()<<endl; } } return; }
void OrderBook::displayAsks() //Function to display Asks { deque<Order*> x1; Order* x = new Order(); if(AskBook.empty())//if its empty there is a special message { cout<<"There are no Ask Orders."<<endl<<endl<<endl; return; } //Using an iterator to run over the map and print out the corresponding object for(map<double,deque<Order*> >::iterator it=AskBook.begin(); it!=AskBook.end(); it++) { x1 = it->second; for (deque<Order*>::iterator it2 = x1.begin(); it2!=x1.end(); it2++)//run through entire deque and price elements { x = *it2;//store the order itself cout<<"Name: "<<x->getCounterParty()<<endl; cout<<"Security: "<<x->getSecurity()<<endl; cout<<"Type: "<<x->getType()<<endl; cout<<"Quantity: "<<x->getQuantity()<<endl; cout<<"Price: "<<x->getLimit()<<endl; } } return; }
void CtpTradeSpi::ReqOrderInsert(Order ord){ SYNC_PRINT << ("Execute Order (") << ord.GetInstrumentId() << ", " \ << ord.GetRefExchangePrice() << ", " \ << (ord.GetExchangeDirection() == THOST_FTDC_D_Buy ? "Buy)" : "Sell)"); ord.SetIdentityInfo(m_brokerID, m_userID, m_userID, m_orderRef); int nextOrderRef = atoi(m_orderRef); SPRINTF(m_orderRef, "%d", ++nextOrderRef); CThostFtdcInputOrderField ordstruct; bool success = ord.GetOrderOriginStruct(ordstruct); if (success){ SYNC_PRINT << "[Debug] 插入订单:" << CommonUtils::StringFromStruct(ordstruct); int ret = pUserApi->ReqOrderInsert(&ordstruct, ++requestId); SYNC_PRINT << "[Trade] 请求 | 插入订单..." << ((ret == 0) ? "成功" : "失败"); //if (ret) // g_OrderRunMtx.unlock(); } else{ SYNC_PRINT << "[Trade] Invalid OrderField construct"; } }
double BrokerWithVolumeBasedCommission::calculate_commission(const Order & order) const { const int volume = order.volume(); if (volume <= 40) { return 0.03; } else if (volume <= 80) { return 0.025; } return 0.02; }
int main() { map<int, string> menu; menu[1] = "waffless"; menu[2] = "pancakes"; menu[3] = "pizza"; menu[4] = "fries"; menu[5] = "burger"; menu[6] = "cheeseburger"; menu[7] = "pie"; menu[8] = "cake"; menu[9] = "brownie"; menu[10] = "cookie"; Order ordering; cout << "Welcome to 'The Rarest Pepe' What would you like to order today? (choose a #) \n" << endl; for (auto const& m : menu) { std::cout << m.first << ") " << m.second << '\n'; } while(true) { int food; string size; cin >> food; if(food != 0) { cout << "What size? (s)mall, (m)edium or (l)arge?" << endl; cin >> size; ordering.orderA(nameToSize(size), menu[food]); } else {
void Renderer::render(Order &order) { //Set background for(int x = 0; x < width_; x++) { for(int y = 0; y < height_; y++) { int pos = x + (y * width_); buffer_[pos] = colorBackground_.ABGR(); } } double width = width_ - marginLeft_ - marginRight_; double height = height_ - marginTop_ - marginBottom_; double ratio = width / height; int w, h; double wasted = grid::findBest(order.size(), ratio, w, h); double contentRatio = double(w) / double(h); double characterWidth = width / double(w); double characterHeight = height / double(h); int fontSize = contentRatio < ratio ? (int) characterHeight : (int) characterWidth; FT_Select_Charmap(face_, ft_encoding_unicode); FT_Set_Pixel_Sizes(face_, 0, fontSize); for(int i = 0; i < order.size(); i++) { int gridX = (i % w) * characterWidth + marginLeft_; int gridY = (i / w) * characterHeight + marginTop_; renderGlyph(face_, order.kanji(i).character()); drawGlyph(buffer_, width_, gridX, gridY, face_->glyph, fontSize, SRSColor(order.kanji(i).SRS())); } }
TEST(Order, Construotor) { const Order o(1, 1, 1, 1, 1, Date()); EXPECT_EQ(o.getOrderID(), 1); EXPECT_EQ(o.getCustomerID(), 1); EXPECT_EQ(o.getSKU(), 1); EXPECT_EQ(o.getQuantity(), 1); EXPECT_EQ(o.getPrice(), 1); // EXPECT_EQ(o.getDate().serializeDate(), Date().serializeDate()); }
int main() { // Instantiate order and queue Order *order = new Order(); order->queue = newQueue(); // Get the file if possible ifstream input; get_file( input ); // Confirmation number must start at 1 order->confirmation_number = 1; // Config current time order->current_time.tm_hour = 0; order->current_time.tm_min = 0; order->current_time.tm_sec = 0; // Config starting number of tickets used order->num_tickets_used = 0; // Set starting tick_time to compare with current time order->tick_time = order->current_time; // Continue to simulate processing the tickets until all tickets are processed while( order->num_tickets_used != NUM_TICKETS_AVAILABLE && ( !queue_empty(order->queue) || !input.eof() ) ) { // Simulate getting orders order->get_orders( input ); // Simulate processing the order order->process_order(); } // Delete dynamically allocated memory delete order->queue; delete order; return 0; }
//-------------------------------------------------------------------- // getKeyboardOrder //-------------------------------------------------------------------- bool getKeyboardOrder(Order &order) { order.reset(); char rep; read(0,&rep,1); // printf("read=%d\n", rep); switch (rep) { // motor case 27 : read(0,&rep,1); read(0,&rep,1); switch (rep) { case 'A' : handleForward(order); break; case 'B' : handleBackward(order); break; case 'D' : handleLeft(order); break; case 'C' : handleRight(order); break; } break; case '8' : handleForward(order); break; case '2' : handleBackward(order); break; case '4' : handleLeft(order); break; case '6' : handleRight(order); break; // emergency stop case '5' : case ' ' : setEmergencyStopOrder(order); break; case 'r' : case 'R' : order.resetRobotPos=true; order.motorReset=1; order.speedLeft=0; order.speedRight=0; break; case 'h' : case 'H' : showUsage(); break; case 'q': case 'Q': case '-': quitApplication = true; break; default: break; } checkMotorOrder(order); return true; }
void Market::match( Order& bid, Order& ask ) { double price = ask.getPrice(); long quantity = 0; if ( bid.getOpenQuantity() > ask.getOpenQuantity() ) quantity = ask.getOpenQuantity(); else quantity = bid.getOpenQuantity(); bid.execute( price, quantity ); ask.execute( price, quantity ); }
Order * Order::CreateOrder( int nOrderID,int nItemID, int nUserID, double fPriceOfEach, double fNumbers, QDate orderdate, QDate inputdate ) { Order *order = new Order(); if (nMaxID < nOrderID) { nMaxID = nOrderID; } order->OrderID(nOrderID); order->ItemID(nItemID); order->UserID(nUserID); order->PriceOfEach(fPriceOfEach); order->Numbers(fNumbers); order->OrderDate(orderdate); order->InputDate(inputdate); return order; }
QList<Order*> AccountTradeInfo::GetOrders(QDate const& oTradeDay) { QMutexLocker oLocker(&m_mLock); if(oTradeDay == m_pInstrument->GetTradeDay()) { return m_lTradeDayOrders; } QList<Order*> lOrders; if(!m_bOrderLoaded) { m_bOrderLoaded = true; LoadOrders(); } for(int nCount = 0 ; nCount < m_lOrders.size() ; nCount) { Order *pOrder = m_lOrders[nCount]; if(pOrder->GetTradeDay() == oTradeDay) { lOrders.append(pOrder); } } return lOrders; }
// Cancel an order void Orders::cancel_order() { int num_res_tickets; // Check if there are any orders to cancel. if (this->orders_list->is_empty()) { cout << "\nThere are no registred orders."; } else { int ref_nr, row, col; ref_nr = Tools::read_number("\nEnter your reference number", 2, this->highest_order_nr(), Tools::numbers); // Check if the order is in the list. if (this->orders_list->in_list(ref_nr)) { // Removes the object in the list with the ref nr // Need to minus the refnr by one because we started the index at 2 Order* order = (Order*) this->orders_list->remove_no(ref_nr - 1); // Checks if the tickets were picked up if (!order->get_picked_up()) { // Gets the screen object from the order Screen* screen = order->get_screen(); // Loops through seats ordered and sets the value back to "1" for (int i = 0; i < order->get_num_ordered_tickets(); ++i) { // Gets the row out of the seatnr row = int(order->get_seat_number(i) / 100); // Gets the col out of the seatnr col = order->get_seat_number(i) % 100; // Sets the position to "1" screen->get_auditorium_copy()->set_matrix_value(row, col, 1); } // Updates the number of orders --this->num_orders; // Updates the num reserved tickets (see the minus) num_res_tickets = -order->get_num_ordered_tickets(); order->update_num_reserved_tickets(num_res_tickets); // Writes the updates to file this->write_to_file(); _screens->write_to_file(); cout << "\nThe order with reference number " << ref_nr << " was canceled."; } else { cout << "\nThe tickets were already picked up."; this->orders_list->add(order); } } else { cout << "\nThe entered reference number does not exist."; } } }
// Collects tickets of an order bool Orders::collect() { int num_res_tickets, ref_nr; // Check if there are any orders to collect. if (this->orders_list->is_empty()) { cout << "\nThere are no registred orders."; return false; } ref_nr = Tools::read_number("\nEnter your reference number", 2, this->highest_order_nr(), Tools::numbers); // We need to minus the ref_nr by one because we started the index at 2 if (this->orders_list->in_list(ref_nr)) { // Removes the object in the list with the ref nr Order* order = (Order*) this->orders_list->remove_no(ref_nr - 1); // Adds the order back to the list this->orders_list->add(order); // Checks if the tickets were picked up if (!order->get_picked_up()) { // Sets the tickets to picked up order->set_picked_up(true); // Prints out the tickets order->print_tickets(); // Updates the num reserved tickets (see the minus) num_res_tickets = -order->get_num_ordered_tickets(); order->update_num_reserved_tickets(num_res_tickets); // Updates the num sold tickets num_res_tickets = order->get_num_ordered_tickets(); order->update_num_sold_tickets(num_res_tickets); // Prints out the matrix order->get_screen()->print_matrix(); // Writes updates to file this->write_to_file(); _screens->write_to_file(); } else { cout << "\nThe tickets were already picked up."; } } else { cout << "\nThe entered reference number does not exist."; } return true; }
void Market::erase( const Order& order ) { std::string id = order.getClientID(); if ( order.getSide() == Order::buy ) { BidOrders::iterator i; for ( i = m_bidOrders.begin(); i != m_bidOrders.end(); ++i ) if ( i->second.getClientID() == id ) { m_bidOrders.erase( i ); return ; } } else if ( order.getSide() == Order::sell ) { AskOrders::iterator i; for ( i = m_askOrders.begin(); i != m_askOrders.end(); ++i ) if ( i->second.getClientID() == id ) { m_askOrders.erase( i ); return ; } } }
void GameTraceCollector::CollectGameTraceForUnitOrder(const Unit unit) { Order order = unit->getOrder(); // Train order has a special handling _ASSERTE(unit->getOrder() != Orders::Train); _ASSERTE(unit->getOrder() != Orders::PlaceAddon); ActionType action; LogInfo("(P%d,%s) %s[%d]: %s", unit->getPlayer()->getID(), unit->getPlayer()->getName().c_str(), unit->getType().getName().c_str(), unit->getID(), order.c_str()); // We send traces only for actions recognized by the engine if (!g_Database.ActionMapping.TryGetByFirst(order.getID(), action)) { LogInfo("Order %s will not be collected, it is not supported order", order.c_str()); return; } else { LogInfo("Order %s will be collected", order.c_str()); } GameTrace *pTrace = nullptr; PlanStepParameters actionParams = m_abstractor.GetAbstractedParameter(action, unit); pTrace = new GameTrace(Broodwar->getFrameCount(), action, actionParams, g_Game->Snapshot(), m_playerToObserve); if (action == ACTIONEX_AttackEntity || action == ACTIONEX_AttackGround) { LogInfo("test"); } SendGameTrace(pTrace); }