dmitry_env/ATP/robotrader/robotrader/RTOrder.h

/***************************************************************************
*    
*                       Copyright (c) 2007-2010  Argo SE, Inc. All rights reserved. 
*
* The following source code, and the ideas, expressions and concepts
* incorporated therein, as well as the ideas, expressions and concepts of
* any other material (whether tangible or intangible) disclosed in
* conjunction with this source code, are the exclusive and proprietary
* property, and constitutes confidential information, of Argo SE, Inc.
* Accordingly, the user of this source code
* agrees that it shall continue to be bound by the terms and conditions of
* any and all confidentiality agreements executed with Argo SE, Inc.
* concerning the disclosure of the source code and any other materials in 
* conjunction therewith. 
*
*/

#pragma once
    // exch_lib
#include <exch_lib/OrderEntry.h>

#include "RTExchangeType.h"
    // stl
#include <list>


namespace RT
{
 
/*
* @class RTOrder
*
* @brief Represents Order Info needed for sending orders via OrderHelper interface
*/
class RTOrder
{
public:

        RTOrder();
    virtual ~RTOrder();

    void original_qty(int original_qty) { original_qty_ = original_qty;}        
    int  original_qty() const {return original_qty_;}

    void remaining_qty(int remaining_qty){remaining_qty_ = remaining_qty;}      
    int  remaining_qty() const {return remaining_qty_;}

    void last_qty(int last_qty){last_qty_ = last_qty;}  
    int  last_qty() const {return last_qty_;}

        int total_fill_qty() const { return total_fill_qty_; }
        void total_fill_qty(int val) { total_fill_qty_ = val; }

        void stop_price(int stop_price){stop_price_ = stop_price;}
    int  stop_price()const {return stop_price_;}

    void price(int price){price_ = price;}      
    int  price()const {return price_;}

    void last_price(int last_price){last_price_ = last_price;}  
    int  last_price()const {return last_price_;}

    const std::string& symbol() const{return symbol_;}  
    void symbol(const std::string& symbol){symbol_ = symbol;}

    const std::string& sec_id() const{return sec_id_;}  
    void sec_id(const std::string& sec_id){sec_id_ = sec_id;}

    const std::string& currency() const { return currency_; }
    void currency(const std::string& val) { currency_ = val; }

    const std::string& trader_id() const {return trader_id_;}
    void trader_id(const std::string& lp){trader_id_ = lp;}

    TimeInForce tif() const {return time_in_force_;}
    void tif(TimeInForce time_in_force){time_in_force_ = time_in_force;}

    OrderSide side() const {return side_;}
    void side(OrderSide side){side_ = side;}
    
    OrderType type() const {return type_;}
    void type(OrderType type){type_ = type;}

    OrderState state() const {return state_;}
    void state(OrderState state);

        OrderState state_prev() const { return state_prev_; }
        void state_prev(OrderState val) { state_prev_ = val; }

        bool state_is_active();
        void state_prev_store();
        void state_restore();
        void state_prev_clean();

        const std::string& cl_id() const {return cl_id_;}
    void cl_id (const std::string& id) {cl_id_ = id;}

    const std::string& orig_cl_id() const {return orig_cl_id_;}
    void orig_cl_id (const std::string& id) {orig_cl_id_ = id;}

    const std::string& text() const {return text_;}
    void text (const std::string& id) {text_ = id;}

    const std::string& exchange_id() const {return exchange_id_;}
    void exchange_id (const std::string& exchange_id) {exchange_id_ = exchange_id;}

        const std::string& orig_exchange_id() const {return orig_exchange_id_;}
        void orig_exchange_id (const std::string& orig_exchange_id) {orig_exchange_id_ = orig_exchange_id;}

    char exchange_char() const { return exchange_char_; }
    void exchange_char(char val) { exchange_char_ = val; }

    time_t init_time() const {return init_time_;}
    void init_time(time_t t) {init_time_ = t;}

    time_t last_time() const {return last_time_;}
    void last_time(time_t t) {last_time_ = t;}

        time_t effective_time() const {return effective_time_;}
        void effective_time(time_t t) {effective_time_ = t;}

        const std::string& account() const {return account_;}
    void account (const std::string& account) {account_ = account;}

    const std::string& sender_sub_id() const {return sender_sub_id_;}
    void sender_sub_id (const std::string& sender_sub_id) {sender_sub_id_ = sender_sub_id;}

    const std::string& cl_ordid_in_cancel() const {return cl_ordid_in_cancel_;}
    void cl_ordid_in_cancel (const std::string& cl_ordid_in_cancel) {cl_ordid_in_cancel_ = cl_ordid_in_cancel;}

    replace_order_type_t replace_order_type () const {return replace_type_;}
    void replace_order_type (replace_order_type_t type) {replace_type_ = type;}

    ExchangeType exchange_type() const {return exch_type_;}
    void exchange_type(ExchangeType type) {exch_type_ = type;}

    const std::string& exchange_name() const {return exchange_name_;}
    void exchange_name (const std::string& id) {exchange_name_ = id;}

    std::string market_exchange_name() const { return market_exchange_name_; }
        void market_exchange_name(std::string val) { market_exchange_name_ = val; }

        std::string security_sub_type() const { return security_sub_type_; }
    void security_sub_type(const std::string & sst) { security_sub_type_ = sst; }
   
        int     denominator()const {return denominator_; }
        void denominator(const int denominator){ denominator_ = denominator; }
        
        const std::string& root_exchange_id()                   {return root_exchange_id_;}
        void root_exchange_id(const std::string& value) {root_exchange_id_ = value;}

        const std::string& underlying_symbol()                  {return underlying_symbol_;}
        void underlying_symbol(const std::string& value){underlying_symbol_ = value;}


    void max_show(int val){max_show_ = val;}    
    int  max_show()const {return max_show_;}

        bool is_automated_trading_system()                              { return is_automated_trading_system_; }
        void is_automated_trading_system(bool val)              { is_automated_trading_system_ = val; }

        const std::string& trader_location()                    {return trader_location_;}
        void trader_location(const std::string& value)  {trader_location_ = value;}
protected:

    std::string security_sub_type_; // Spread, Butterfly, Condor etc

    std::string  adapter_name_; 
    std::string  exchange_name_;
    std::string  market_exchange_name_;

        ExchangeType exch_type_;
    CoreModeType exch_mode_;

    std::string trader_id_;

    
    std::string cl_id_;
    std::string orig_cl_id_;
    std::string exchange_id_;
        std::string orig_exchange_id_;

    char                exchange_char_;
    
        OrderType   type_ ;     
    TimeInForce time_in_force_ ;        
    OrderState  state_ ;        
        OrderState  state_prev_ ;
    OrderSide   side_;
    replace_order_type_t replace_type_;

    int price_;
    int stop_price_;
    int last_price_;    
    int original_qty_;
    int remaining_qty_;
    int last_qty_;
        int total_fill_qty_;

        time_t init_time_;
    time_t last_time_;
   
        time_t effective_time_;

    std::string text_;
    std::string sender_sub_id_;
    std::string on_behalf_of_comp_id_;
    std::string cl_ordid_in_cancel_;

    std::string account_;
    std::string symbol_;
    std::string sec_id_;
    std::string currency_;

        int                     denominator_;

        std::string     root_exchange_id_;
        std::string     underlying_symbol_;

        int max_show_;

        bool                    is_automated_trading_system_;
        std::string             trader_location_;
};

}

---