dmitry_env/ATP/robotrader/robotrader/RTRobotStateInfo.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

#include "RobotHelperInterfaces.h"
#include "RTPosition.h"
#include "RTOrder.h"
#include "RTExchangeType.h"
#include "RTInstrument.h"

#include <map>

namespace RT
{
        enum RobotStatus
        {
                enUndefined,
                enRobotCreated,
                enRobotStarted,
                enRobotRunning,
                enRobotSuspended,
                enRobotStopped,
                enRobotClosed,
                enRobotInitialized,
                enRobotError,
                enMaxRobotState
        };

        static char* RobotStatusStr[]=
        {
                "Undefined",
                "Created",
                "Started",
                "Running",
                "Suspended",
                "Stopped",
                "Closed",
                "Initialized",
                "Error",
                "Undefined"
        };

        struct RobotState
        {
                RobotState():
                        status_(enRobotCreated)
                        ,status_str_("Created")
                {}

                RobotStatus status_;
                std::string status_str_;
        };

        struct RobotTypeParameter
        {
                std::string name_;
                std::string value_;
                std::string description_;
                std::string type_;

                void init()
                {
                        name_="";
                        value_="";
                        description_="";
                        type_="";
                }
                void to_xml(std::ostream& stream)
                {
                        stream<<"<PARAMETR>";
                        stream<<"<PName>"<<name_.c_str() <<"</PName>";
                        stream<<"<PValue>"<< value_.c_str()<<"</PValue>";
                        stream<<"<PDescription>"<<description_.c_str() <<"</PDescription>";
                        stream<<"<PType>"<<type_.c_str() <<"</PType>";
                        stream<<"</PARAMETR>";
                }
        };
        typedef std::list<RobotTypeParameter> ParametersList;

        typedef std::map<std::string,RTOrder*> OrderList;
        typedef std::pair<std::string,std::string> StrPair;
        typedef std::list<StrPair> StrPairList;

        class RTRobotStateInfo
        {
        public:
                RTRobotStateInfo(){}

                //accessors
                const std::string& name()               {return name_;}
                const std::string& robot_id()   {return robot_id_;}
                const std::string& account()    {return account_;}
                const std::string& exchange_account()   {return exchange_account_;}

                RobotState& robot_state()       {return robot_state_;}
                
                ParametersList& parameters()    {return parameters_;}
                PositionList&   positions()     {return position_list_;}
                OrderList&              order_list()    {return order_list_;}
                
                //mutators 
                void name(const std::string& name)                      {name_=name;}
                void robot_id(const std::string& robot_id)      {robot_id_=robot_id;}
                void account(const std::string& account)        {account_=account;}
                void exchange_account(const std::string& account)       {exchange_account_=account;}
                void robot_state(const RobotState& state)       {robot_state_=state;}

                void parameters(ParametersList& params)         {parameters_=params;}
                void positions(PositionList& pos_list)          {position_list_=pos_list;}
                void order_list(OrderList& order_list)          {order_list_=order_list;}
                        
        private:
                std::string             name_;
                std::string             robot_id_;
                std::string             account_;
                std::string             exchange_account_;

                RobotState              robot_state_;

                ParametersList  parameters_;
                PositionList    position_list_;
                OrderList               order_list_;
        };
}

---