// constructor used on very first event to initialize market state (market summary event)
        public MarketState(Security security, TickData bid, TickData ask, TickData trade)
        {
            if (security == null)
                throw new ArgumentException("security object must not be null", "security");

            if (bid == null)
                throw new ArgumentException("TickData object for bid object must not be null", "bid");
            if (ask == null)
                throw new ArgumentException("TickData object for ask object must not be null", "ask");
            if (trade == null)
                throw new ArgumentException("TickData object for trade object must not be null", "bid");

            VolumeTdy = 0;
            OrderFlowTdy = 0;
            VolAtBidTdy = 0;
            VolAtAskTdy = 0;
            _securityObj = security;
            StateType = MktStateType.Summary;

            TimeStamp = bid.TimeStamp;
            FirstOfInterval = true;
            OnBidQuote(bid);
            SetBidOpen(bid);

            OnAskQuote(ask);
            SetAskOpen(ask);

            OnTrade(trade);
            SetTradeOpn(trade);

            SetMid();
            SetMidOpen();
        }
 public DataFactory(Security security)
 {
     _securityObj = security;
     SecurityName = security.Name;
     SecurityId = security.Id;
 }
        // constructor used for each successive data event after the initial market summary event
        public MarketState(Security security, MarketState previousMktState, TickData tickData)
        {
            VolumeTdy = 0;
            OrderFlowTdy = 0;
            VolAtBidTdy = 0;
            VolAtAskTdy = 0;
            _securityObj = security;

            if (previousMktState == null)
                throw new ArgumentException("Previous MarketState object must not be null", "previousMktState");

            if (tickData.TimeStamp == null)
                throw new ArgumentException("tickData.TimeStamp must not be null", "tickData.TimeStamp");

            TimeStamp = tickData.TimeStamp;

            FirstOfInterval = (tickData.TimeStamp.Subtract(previousMktState.TimeStamp).TotalSeconds > 0);

            CopyPrevState(previousMktState, FirstOfInterval);

            switch (tickData.Type)
            {
                case Type.Ask:
                    StateType = MktStateType.Ask;
                    OnAskQuote(tickData);
                    SetAskVolChg(previousMktState);
                    SetMid();
                    if (FirstOfInterval)
                    {
                        SetAskOpen(tickData);
                        SetMidOpen();
                    }
                    break;
                case Type.Bid:
                    StateType = MktStateType.Bid;
                    OnBidQuote(tickData);
                    SetBidVolChg(previousMktState);
                    SetMid();
                    if (FirstOfInterval)
                    {
                        SetBidOpen(tickData);
                        SetMidOpen();
                    }
                    break;
                case Type.Trade:
                    StateType = MktStateType.Trade;
                    OnTrade(tickData);
                    if (FirstOfInterval)
                    {
                        SetTradeOpn(tickData);
                    }
                    break;
                default:
                    throw new ArgumentException("TickData's 'Type' parameter must be of enum of type TickData.Type", "tickData");
            }

            if ((FirstOfInterval) || (Codes == null))
            {

                Codes = tickData.Codes;
            }
            else
            {
                if (tickData.Codes != null)
                {
                    if (tickData.Codes.Count > 0)
                    {
                        foreach (var code in tickData.Codes)
                        {
                            if (!Codes.ContainsKey(code.Key))
                                Codes.Add(code.Key, code.Value);
                        }
                    }
                }
            }
        }
        // constructor used to create a duplicate a state using a new timestamp
        public MarketState(Security security, MarketState previousMktState, DateTime timeStamp)
        {
            TimeStamp = DateTime.MinValue;
            VolumeTdy = 0;
            OrderFlowTdy = 0;
            VolAtBidTdy = 0;
            VolAtAskTdy = 0;
            _securityObj = security;

            if (security == null)
                throw new ArgumentException("security object must not be null", "security");

            if (previousMktState == null)
                throw new ArgumentException("Previous MarketState object must not be null", "previousMktState");

            if (timeStamp == null)
                throw new ArgumentException("timeStamp must not be null", "timeStamp");

            TimeStamp = timeStamp;
            FirstOfInterval = true;
            CopyPrevState(previousMktState, FirstOfInterval);
            StateType = MktStateType.Duplicate;
        }