void level2_execution_engine::send_order(const ats::stop_order& order)
{
auto it = sim_books_.find(order.symbol());
const ats::exchange_order_book& book = it->second.get_order_book();
on_order_status_changed(ats::order_status_pending_new_message(order.id(), current_time()));
if (order.side() == ats::order_side::Buy || order.side() == ats::order_side::BuyCover)
{
if (!book.asks().empty() && order.price() <= book.best_ask()->price)
on_order_status_changed(ats::order_status_filled_message(order.id(), current_time(), book.best_ask()->price, order.quantity()));
else
{
stops_buy_.insert(std::make_pair(order.price(), order));
add_order(order);
// orders_.insert(std::make_pair(order.id(), std::make_shared<ats::stop_order>(order)));
}
}
else
{
if (!book.bids().empty() && order.price() >= book.best_bid()->price)
on_order_status_changed(ats::order_status_filled_message(order.id(), current_time(), book.best_bid()->price, order.quantity()));
else
{
stops_sell_.insert(std::make_pair(order.price(), order));
add_order(order);
// orders_.insert(std::make_pair(order.id(), std::make_shared<ats::stop_order>(order)));
}
}
}
void level2_execution_engine::send_order(const ats::limit_order& order)
{
auto it = sim_books_.find(order.symbol());
if (it != sim_books_.cend())
{
add_order(order);
it->second.add_order(order);
}
}
/**
* check_buttons:
*
* Checks all UI buttons and updates the order queue.
*
* Returns: 1 if new orders are present, or 0.
*
*/
int ui_check_buttons(void) {
for (int button = 0; button < N_BUTTONS; button++) {
for (int floor = 0; floor < N_FLOORS; floor++) {
if (elev_get_button_signal(button, floor)) {
elev_set_button_lamp(button, floor, 1);
add_order(button, floor);
}
}
}
}
int p_add_order(request *rqt, int client_sockfd){
response rsp;
memset(&rsp, '\0', sizeof(response));
if(add_order(&rqt->u, &rqt->t))
rsp.rs = rs_success;
else
rsp.rs = rs_failure;
srv_send_response(&rsp, client_sockfd);
}
int Student::add_order(const Order &new_order){
bool found = false;
for (auto order : my_orders){
if(order == new_order){
found = true;
continue;
}
}
if(!found){
my_orders.push_back(new_order);
if(new_order.get_required() != nullptr)
add_order(*(new_order.get_required()));
}
return my_orders.size();
}
void book_t::handle_message(const std::string & msg)
{
int timestamp;
char msg_type; // 'A' for add or 'R' for reduce
std::string id_str;
order_id_t id;
int size; // number of shares
std::stringstream is(msg); // input stream
is >> timestamp >> msg_type >> id_str;
if (timestamp < 0)
{
throw invalid_timestamp(timestamp);
}
id = order_id_from_str(id_str);
if (id < 0)
{
throw invalid_order_id(timestamp, id);
}
if ('A' == msg_type)
{
char ch; // side character 'B' or 'S'
price_t price;
is >> ch >> price >> size;
if ('B' != ch && 'S' != ch)
{
throw invalid_side(timestamp, ch);
}
if (price <= 0)
{
throw invalid_price(timestamp, price);
}
if (size <= 0)
{
throw invalid_size(timestamp, size);
}
side_t side = side_from_char(ch);
add_order(timestamp, id, side, price, size);
}
struct order_info *read_order(FILE *ifp){
char *full = NULL;
char *title = NULL;
char *price = NULL;
char *customer = NULL;
char *category = NULL;
size_t len = 0;
struct order_info *s;
if (!feof(ifp))
{
getline(&full, &len, ifp);
full = strtok(full, "\n");
char *temp;
temp = full;
title = strtok(temp, "|");
price = strtok(NULL, "|");
customer = strtok(NULL, "|");
category = strtok(NULL, "|");
add_order(title, price, customer, category);
}
else return NULL;
s = malloc(sizeof(struct customer_info));
s->title = malloc(strlen(title) + 1);
strcpy(s->title, title);
s->price = atof(price);
s->customer = malloc(strlen(customer) + 1);
strcpy(s->customer, customer);
s->category = malloc(strlen(category) + 1);
strcpy(s->category, category);
s->next = NULL;
return s;
}
inline bool
Depth<SIZE>::replace_order(
Price current_price,
Price new_price,
Quantity current_qty,
Quantity new_qty,
bool is_bid
)
{
bool erased = false;
// If the price is unchanged, modify this level only
if (current_price == new_price) {
int32_t qty_delta = ((int32_t)new_qty) - current_qty;
// Only change order qty. If this closes order, a cancel callback will also be fired
change_qty_order(current_price, qty_delta, is_bid);
// Else this is a price change
} else {
// Add the new order quantity first, and possibly insert a new level
add_order(new_price, new_qty, is_bid);
// Remove the old order quantity, and possibly erase a level
erased = close_order(current_price, current_qty, is_bid);
}
return erased;
}
/*
* Constructor calls its parent class Process constructor
* to set highest priority. This ensure Batch will be first
* at chef_fac queue.
*/
Batch::Batch(Order *ord): Process(HIGHEST_PRIORITY)
{
id = all_batch_cntr++;
add_order(ord);
}
// 显示车次信息页面
static void traininfo_menu(int num){
int index=1;
int i_traininfo=0;
int order_result=0;
int ticket_result=0;
char t_num[20];
char ticket_num[10];
char commend[1];
time_t now;
erase();
cbreak();
noecho();
mvprintw(3, 25, "%s", "欢迎访问模拟铁路订票系统！");
mvprintw(5, 1, "%s", "火车编号");
mvprintw(5, 11, "%s", "日期");
mvprintw(5, 21, "%s", "车次号");
mvprintw(5, 29, "%s", "出发站");
mvprintw(5, 37, "%s", "到达站");
mvprintw(5, 45, "%s", "出发时间");
mvprintw(5, 55, "%s", "到达时间");
mvprintw(5, 65, "%s", "票价");
mvprintw(5, 71, "%s", "余票张数");
for(;num!=0;num--){
mvprintw(num+5, 1, "%d", static_traininfo[num-1].tid);
mvprintw(num+5, 11, "%d/%d/%d", static_message.ticket_data.departure_date.tm_year+1900, static_message.ticket_data.departure_date.tm_mon+1, static_message.ticket_data.departure_date.tm_mday);
mvprintw(num+5, 21, "%s", static_traininfo[num-1].t_num);
mvprintw(num+5, 29, "%s", static_traininfo[num-1].originator);
mvprintw(num+5, 37, "%s", static_traininfo[num-1].terminal);
mvprintw(num+5, 45, "%d:%d:%d", static_traininfo[num-1].departure_time.tm_hour, static_traininfo[num-1].departure_time.tm_min, static_traininfo[num-1].departure_time.tm_sec);
mvprintw(num+5, 55, "%d:%d:%d", static_traininfo[num-1].arrival_time.tm_hour, static_traininfo[num-1].arrival_time.tm_min, static_traininfo[num-1].arrival_time.tm_sec);
static_message.ticket_data=get_ticket(static_traininfo[num-1].tid, &(static_message.ticket_data.departure_date));
static_ticket[num-1]=static_message.ticket_data;
mvprintw(num+5, 65, "%d", static_ticket[num-1].price);
mvprintw(num+5, 71, "%d", static_ticket[num-1].num);
}
mvprintw(20, 30, "%s", "1. 订票");
mvprintw(20, 50, "%s", "2. 返回上一页");
refresh();
while(index){
commend[0]=getch();
switch(commend[0]){
case '1':
echo();
nocbreak();
mvprintw(21, 30, "请输入车次号:");
getstr(t_num);
mvprintw(22, 30, "请输入张数:");
getstr(ticket_num);
static_message.order_data.num=atoi(ticket_num);
while(strcmp(static_traininfo[i_traininfo].t_num, t_num))
i_traininfo++;
static_message.order_data.uid=static_message.userinfo_data.uid;
static_message.order_data.tid=static_traininfo[i_traininfo].tid;
static_message.order_data.departure_date=static_message.ticket_data.departure_date;
static_message.order_data.price=static_ticket[i_traininfo].price*static_message.order_data.num;
time(&now);
static_message.order_data.rise_time=*(localtime(&now));
static_message.order_data.state=STATE_BEFORE_PAYMENT;
static_ticket[i_traininfo].num-=static_message.order_data.num;
order_result=add_order(static_message.order_data);
ticket_result=modify_ticket(static_ticket[i_traininfo]);
if(order_result&&ticket_result){
mvprintw(23, 30, "%s", "订票成功,返回主界面中...！");
}else{
mvprintw(23, 30, "%s", "订票失败,返回主界面中...！");
}
refresh();
sleep(3);
main_menu();
index=0;
break;
case '2':
echo();
nocbreak();
main_menu();
index=0;
break;
default: mvprintw(23, 30, "%s", "无效的命令!"); break;
}
}
}
int
main(int argc, char *argv[])
{
int cflag = 0, fflag = 0, Cflag = 0;
char *domain, *host = NULL, *srcdomain = NULL;
char *tid = NULL, *prog = NULL, *ipadd = NULL;
char *port = NULL, *map = NULL;
int status, xfr_status, ch, srvport;
u_int32_t ordernum, new_ordernum;
struct ypall_callback callback;
CLIENT *client = NULL;
extern char *optarg;
yp_get_default_domain(&domain);
while ((ch = getopt(argc, argv, "cd:fh:s:C:")) != -1)
switch (ch) {
case 'c':
cflag++;
break;
case 'd':
if (strchr(optarg, '/')) /* Ha ha, we are not listening */
break;
domain = optarg;
break;
case 'f':
fflag++;
break;
case 'h':
host = optarg;
break;
case 's':
if (strchr(optarg, '/')) /* Ha ha, we are not listening */
break;
srcdomain = optarg;
break;
case 'C':
if (optind + 3 >= argc)
usage();
Cflag++;
tid = optarg;
prog = argv[optind++];
ipadd = argv[optind++];
port = argv[optind++];
break;
default:
usage();
break;
}
status = YPPUSH_SUCC;
if (optind + 1 != argc)
usage();
map = argv[optind];
if (status > 0) {
ypopenlog();
yplog("ypxfr: Arguments:");
yplog("YP clear to local: %s", (cflag) ? "no" : "yes");
yplog(" Force transfer: %s", (fflag) ? "yes" : "no");
yplog(" domain: %s", domain);
yplog(" host: %s", host);
yplog(" source domain: %s", srcdomain);
yplog(" transid: %s", tid);
yplog(" prog: %s", prog);
yplog(" port: %s", port);
yplog(" ipadd: %s", ipadd);
yplog(" map: %s", map);
if (fflag != 0) {
ordernum = 0;
} else {
status = get_local_ordernum(domain, map, &ordernum);
}
}
if (status > 0) {
yplog("Get Master");
if (host == NULL) {
if (srcdomain == NULL) {
status = yp_master(domain, map, &host);
} else {
status = yp_master(srcdomain, map, &host);
}
if (status == 0) {
status = YPPUSH_SUCC;
} else {
status = -status;
}
}
}
/* XXX this is raceable if portmap has holes! */
if (status > 0) {
yplog("Check for reserved port on host: %s", host);
srvport = getrpcport(host, YPPROG, YPVERS, IPPROTO_TCP);
if (srvport >= IPPORT_RESERVED)
status = YPPUSH_REFUSED;
}
if (status > 0) {
yplog("Connect host: %s", host);
client = yp_bind_host(host, YPPROG, YPVERS, 0, 1);
status = get_remote_ordernum(client, domain, map,
ordernum, &new_ordernum);
}
if (status == YPPUSH_SUCC) {
char tmpmapname[MAXPATHLEN];
int fd;
/* Create temporary db */
snprintf(tmpmapname, sizeof tmpmapname,
"%s/%s/ypdbXXXXXXXXXX", YP_DB_PATH, domain);
fd = mkstemp(tmpmapname);
if (fd == -1)
status = YPPUSH_DBM;
else
close(fd);
if (status > 0) {
db = create_db(domain, map, tmpmapname);
if (db == NULL)
status = YPPUSH_DBM;
}
/* Add ORDER */
if (status > 0)
status = add_order(db, new_ordernum);
/* Add MASTER */
if (status > 0)
status = add_master(client, domain, map, db);
/* Add INTERDOMAIN */
if (status > 0)
status = add_interdomain(client, domain, map, db);
/* Add SECURE */
if (status > 0)
status = add_secure(client, domain, map, db);
if (status > 0) {
callback.foreach = ypxfr_foreach;
status = get_map(client, domain, map, &callback);
}
/* Close db */
if (db != NULL)
ypdb_close(db);
/* Rename db */
if (status > 0) {
status = install_db(domain, map, tmpmapname);
} else {
unlink(tmpmapname);
status = YPPUSH_SUCC;
}
}
xfr_status = status;
if (client != NULL)
clnt_destroy(client);
/* YP_CLEAR */
if (!cflag) {
client = yp_bind_local(YPPROG, YPVERS);
status = send_clear(client);
clnt_destroy(client);
}
if (Cflag > 0) {
/* Send Response */
client = yp_bind_host(ipadd, atoi(prog), 1, atoi(port), 0);
status = send_reply(client, xfr_status, atoi(tid));
clnt_destroy(client);
}
return (0);
}
//定义所有客户端请求命令的处理函数
void exec_request(const message_data message_request){
message_data message_response;
int end_index=0;
char log[250];
message_response=message_request;
message_response.response=s_success;
switch(message_request.request){
case c_add_userinfo:
if(!add_userinfo(message_request.userinfo_data)){
message_response.response=s_failure;
sprintf(log, " 用户 %s 注册失败.", message_request.userinfo_data.u_name);
sys_log(log);
}else{
sprintf(log, " 用户 %s 注册成功.", message_request.userinfo_data.u_name);
sys_log(log);
}
break;
case c_get_userinfo:
message_response.userinfo_data=get_userinfo(message_request.userinfo_data.u_name, message_request.userinfo_data.pwd);
userinfo userinfo_cmp;
memset(&userinfo_cmp, 0, sizeof(userinfo_cmp));
if(!memcmp(&userinfo_cmp, &(message_response.userinfo_data), sizeof(userinfo)))
{
message_response.response=s_failure;
sprintf(log, "获取用户 %s 资料失败.", message_request.userinfo_data.u_name);
sys_log(log);
}else{
sprintf(log, " 获取用户 %s 资料成功.", message_request.userinfo_data.u_name);
sys_log(log);
}
break;
case c_modify_userinfo:
if(!modify_userinfo(message_request.userinfo_data))
{
message_response.response=s_failure;
sprintf(log, "修改用户 %s 资料失败.", message_request.userinfo_data.u_name);
sys_log(log);
}else{
sprintf(log, " 修改用户 %s 资料成功.", message_request.userinfo_data.u_name);
sys_log(log);
}
break;
case c_get_traininfo_by_t_num:
message_response.traininfo_data=get_traininfo_by_t_num(message_request.traininfo_data.t_num);
traininfo traininfo_cmp;
memset(&traininfo_cmp, 0, sizeof(traininfo_cmp));
if(!memcmp(&traininfo_cmp, &(message_response.traininfo_data), sizeof(traininfo))){
message_response.response=s_failure;
sprintf(log, "用户 %s 获取车次 %s 信息失败.", message_request.userinfo_data.u_name, message_request.traininfo_data.t_num);
sys_log(log);
}else{
sprintf(log, "用户 %s 获取车次 %s 信息成功.", message_request.userinfo_data.u_name, message_request.traininfo_data.t_num);
sys_log(log);
}
break;
case c_get_traininfo_by_o_and_t:
while(!end_index){
message_response.traininfo_data=get_traininfo_by_o_and_t(message_request.traininfo_data.originator, message_request.traininfo_data.terminal);
traininfo traininfo_cmp;
memset(&traininfo_cmp, 0, sizeof(traininfo_cmp));
if(!memcmp(&traininfo_cmp, &(message_response.traininfo_data), sizeof(traininfo))){
message_response.response=s_failure;
end_index=1;
}else{
if(!send_response_to_client(message_response)){
fprintf(stderr, "Server Warning: fail to response to %d. \n", message_response.client_pid);
sprintf(log, "用户 %s 获取车次 %s 信息失败.", message_request.userinfo_data.u_name, message_response.traininfo_data.t_num);
sys_log(log);
}else{
sprintf(log, "用户 %s 获取车次 %s 信息成功.", message_request.userinfo_data.u_name, message_response.traininfo_data.t_num);
sys_log(log);
}
}
}
break;
case c_get_ticket:
message_response.ticket_data=get_ticket(message_request.ticket_data.tid, &(message_request.ticket_data.departure_date));
ticket ticket_cmp;
memset(&ticket_cmp, 0, sizeof(ticket_cmp));
if(!memcmp(&ticket_cmp, &(message_response.ticket_data), sizeof(ticket)))
message_response.response=s_failure;
break;
case c_modify_ticket:
if(!modify_ticket(message_request.ticket_data))
message_response.response=s_failure;
break;
case c_add_order:
if(!add_order(message_request.order_data)){
message_response.response=s_failure;
sprintf(log, "用户 %s 购买 Tid 为 %d 的车次火车票 %d 张失败.", message_request.userinfo_data.u_name, message_request.order_data.tid, message_request.order_data.num);
sys_log(log);
}else{
sprintf(log, "用户 %s 购买 Tid 为 %d 的车次火车票 %d 张成功.", message_request.userinfo_data.u_name, message_request.order_data.tid, message_request.order_data.num);
sys_log(log);
}
break;
case c_get_orders:
while(!end_index){
message_response.order_data=get_orders(message_request.order_data.uid);
orders order_cmp;
memset(&order_cmp, 0, sizeof(order_cmp));
if(!memcmp(&order_cmp, &(message_response.order_data), sizeof(orders))){
message_response.response=s_failure;
end_index=1;
}else{
if(!send_response_to_client(message_response)){
fprintf(stderr, "Server Warning: fail to response to %d. \n", message_response.client_pid);
sprintf(log, "获取用户 %s 订单 %d 信息失败.", message_request.userinfo_data.u_name, message_response.order_data.oid);
sys_log(log);
}else{
sprintf(log, "获取用户 %s 订单 %d 信息成功.", message_request.userinfo_data.u_name, message_response.order_data.oid);
sys_log(log);
}
}
}
break;
case c_modify_order:
if(!modify_order(message_request.order_data)){
message_response.response=s_failure;
sprintf(log, "修改用户 %s 订单 %d 信息失败.", message_request.userinfo_data.u_name, message_request.order_data.oid);
sys_log(log);
}else{
sprintf(log, "修改用户 %s 订单 %d 信息成功.", message_request.userinfo_data.u_name, message_request.order_data.oid);
sys_log(log);
}
break;
default:
message_response.response=s_failure;
break;
}
if(!send_response_to_client(message_response)){
fprintf(stderr, "Server Warning: fail to response to %d. \n", message_response.client_pid);
return;
}
return;
}
