MFProtoOutputBufferProvider.h

/*
 * ThreadLocalBufferProvider.h
 *
 *  Created on: Apr 4, 2016
 *      Author: smork
 */

#ifndef _MFTHREADLOCALBUFFERPROVIDER_H_
#define _MFTHREADLOCALBUFFERPROVIDER_H_

#include <boost/thread.hpp>
#include <MFProtoOutputBuffer.h>
#include <MFProtoMsgWrapper.h>

#include <mfmarketdata/Logon.hpp>
#include <mfmarketdata/SecurityDefinitionRequest.hpp>
#include <mfmarketdata/MarketDataRequest.hpp>
#include <mfmarketdata/MarketDataRequestHistoric.hpp>
#include <mfmarketdata/RegisterForBatch.hpp>
#include <mfmarketdata/UnregisterForBatch.hpp>
#include <mfmarketdata/Logout.hpp>
#include <mfmarketdata/LogoutResponse.hpp>
#include <mfmarketdata/Heartbeat.hpp>

#include <mftrading/DecimalQtyNULL.hpp>
#include <mftrading/TradingSessionStatusRequest.hpp>
#include <mftrading/NewOrderSingle.hpp>
#include <mftrading/Logon.hpp>
#include <mftrading/MarketDefinitionRequest.hpp>
#include <mftrading/OrderCancelReplaceRequest.hpp>
#include <mftrading/OrderCancelRequest.hpp>
#include <mftrading/Logout.hpp>
#include <mftrading/LogoutResponse.hpp>
#include <mftrading/Heartbeat.hpp>
#include <mftrading/OrdType.hpp>
#include <mftrading/PriceNULL.hpp>
#include <mftrading/Side.hpp>
#include <mftrading/SubscriptionRequestType.hpp>
#include <mftrading/TimeInForce.hpp>

#include <mfstp_booking/Confirmation.hpp>
#include <mfstp_booking/DecimalQtyNULL.hpp>
#include <mfstp_booking/ExecType.hpp>
#include <mfstp_booking/Flags.hpp>
#include <mfstp_booking/GroupSizeEncoding.hpp>
#include <mfstp_booking/Heartbeat.hpp>
#include <mfstp_booking/Logon.hpp>
#include <mfstp_booking/LogonResponse.hpp>
#include <mfstp_booking/Logout.hpp>
#include <mfstp_booking/LogoutResponse.hpp>
#include <mfstp_booking/MessageHeader.hpp>
#include <mfstp_booking/PartyRole.hpp>
#include <mfstp_booking/PriceNULL.hpp>
#include <mfstp_booking/SecurityDefinition.hpp>
#include <mfstp_booking/SecurityDefinitionRequest.hpp>
#include <mfstp_booking/Side.hpp>
#include <mfstp_booking/SubscriptionRequestType.hpp>
#include <mfstp_booking/TradeCaptureReportAck.hpp>
#include <mfstp_booking/TradeCaptureReportRequest.hpp>
#include <mfstp_booking/TradeCaptureReportSpotForward.hpp>
#include <mfstp_booking/TradeCaptureReportSwap.hpp>
#include <mfstp_booking/TradeReportRejectReason.hpp>
#include <mfstp_booking/TrdRptStatus.hpp>

#include <mftradedaterollover/Logon.hpp>
#include <mftradedaterollover/LogonResponse.hpp>
#include <mftradedaterollover/Logout.hpp>
#include <mftradedaterollover/LogoutResponse.hpp>
#include <mftradedaterollover/Heartbeat.hpp>
#include <mftradedaterollover/TradeDateRequest.hpp>
#include <mftradedaterollover/TradeDateReport.hpp>
#include <mftradedaterollover/TradeDateType.hpp>
#include <mftradedaterollover/GroupSizeEncoding.hpp>
#include <mftradedaterollover/MessageHeader.hpp>


class MFProtoOutputBufferProvider {
 private:
  class Buffers;
  
  static boost::thread_specific_ptr<Buffers> buffers;

  static Buffers* getBuffers();

  class Buffers {
   public:
    MFProtoMsgWrapper<mfmarketdata::Logon> marketDataLogon;
    MFProtoMsgWrapper<mfmarketdata::SecurityDefinitionRequest>
        securityDefinitionRequest;
    MFProtoMsgWrapper<mfmarketdata::MarketDataRequest> marketDataRequest;
    MFProtoMsgWrapper<mfmarketdata::MarketDataRequestHistoric>
        marketDataRequestHistoric;
    MFProtoMsgWrapper<mfmarketdata::RegisterForBatch> registerForBatch;
    MFProtoMsgWrapper<mfmarketdata::UnregisterForBatch> unregisterForBatch;
    MFProtoMsgWrapper<mfmarketdata::Logout> marketDataLogout;
    MFProtoMsgWrapper<mfmarketdata::LogoutResponse> marketDataLogoutResponse;
    MFProtoMsgWrapper<mfmarketdata::Heartbeat> marketDataHeartbeat;

    MFProtoMsgWrapper<mftrading::TradingSessionStatusRequest>
        tradingSessionStatusRequest;
    MFProtoMsgWrapper<mftrading::NewOrderSingle> newOrderSingle;
    MFProtoMsgWrapper<mftrading::Logon> tradingLogon;
    MFProtoMsgWrapper<mftrading::MarketDefinitionRequest>
        marketDefinitionRequest;
    MFProtoMsgWrapper<mftrading::OrderCancelReplaceRequest>
        orderCancelReplaceRequest;
    MFProtoMsgWrapper<mftrading::OrderCancelRequest> orderCancelRequest;
    MFProtoMsgWrapper<mftrading::Logout> tradingLogout;
    MFProtoMsgWrapper<mftrading::LogoutResponse> tradingLogoutResponse;
    MFProtoMsgWrapper<mftrading::Heartbeat> tradingHeartbeat;

    MFProtoMsgWrapper<mfstp_booking::Logon> stpBookingLogon;
    MFProtoMsgWrapper<mfstp_booking::LogonResponse> stpBookingLogonResponse;
    MFProtoMsgWrapper<mfstp_booking::Logout> stpBookingLogout;
    MFProtoMsgWrapper<mfstp_booking::LogoutResponse> stpBookingLogoutResponse;
    MFProtoMsgWrapper<mfstp_booking::Heartbeat> stpBookingHeartbeat;
    MFProtoMsgWrapper<mfstp_booking::SecurityDefinition> stpBookingSecurityDefinition;
    MFProtoMsgWrapper<mfstp_booking::SecurityDefinitionRequest>  stpBookingSecurityDefinitionRequest;
    MFProtoMsgWrapper<mfstp_booking::TradeCaptureReportAck> stpBookingTradeCaptureReportAck;
    MFProtoMsgWrapper<mfstp_booking::TradeCaptureReportRequest> stpBookingTradeCaptureReportRequest;
    MFProtoMsgWrapper<mfstp_booking::TradeCaptureReportSpotForward> stpBookingTradeCaptureReportSpotForward;
    MFProtoMsgWrapper<mfstp_booking::TradeCaptureReportSwap> stpBookingTradeCaptureReportSwap;
    MFProtoMsgWrapper<mfstp_booking::Confirmation> stpBookingConfirmation;

    MFProtoMsgWrapper<mftradedaterollover::Logon> tradeDateRollOverLogon;
    MFProtoMsgWrapper<mftradedaterollover::LogonResponse> tradeDateRollOverLogonResponse;
    MFProtoMsgWrapper<mftradedaterollover::Logout> tradeDateRollOverLogout;
    MFProtoMsgWrapper<mftradedaterollover::LogoutResponse> tradeDateRollOverLogoutResponse;
    MFProtoMsgWrapper<mftradedaterollover::Heartbeat> tradeDateRollOverHeartbeat;
    MFProtoMsgWrapper<mftradedaterollover::TradeDateRequest> tradeDateRequest;
    MFProtoMsgWrapper<mftradedaterollover::TradeDateReport> tradeDateRollOverTradeDateReport;
  };

 public:

  static MFProtoMsgWrapper<mfmarketdata::Logon>& createMarketDataLogon() {
    getBuffers()->marketDataLogon.reset();
    return getBuffers()->marketDataLogon;
  }

  static MFProtoMsgWrapper<mfmarketdata::Logon>& getMarketDataLogon() {
    return getBuffers()->marketDataLogon;
  }

  static MFProtoMsgWrapper<mfmarketdata::SecurityDefinitionRequest>&
  createSecurityDefinitionRequest() {
    getBuffers()->securityDefinitionRequest.reset();
    return getBuffers()->securityDefinitionRequest;
  }

  static MFProtoMsgWrapper<mfmarketdata::SecurityDefinitionRequest>&
  getSecurityDefinitionRequest() {
    return getBuffers()->securityDefinitionRequest;
  }

  static MFProtoMsgWrapper<mfmarketdata::MarketDataRequest>&
  createMarketDataRequest() {
    getBuffers()->marketDataRequest.reset();
    return getBuffers()->marketDataRequest;
  }

  static MFProtoMsgWrapper<mfmarketdata::MarketDataRequest>&
  getMarketDataRequest() {
    return getBuffers()->marketDataRequest;
  }

  static MFProtoMsgWrapper<mfmarketdata::MarketDataRequestHistoric>&
  createMarketDataRequestHistoric(int numPairs) {
    size_t msgSize = mfmarketdata::MarketDataRequestHistoric::sbeBlockLength() +
            mfmarketdata::MarketDataRequestHistoric::NoRelatedSym::sbeHeaderSize() +
            (numPairs * mfmarketdata::MarketDataRequestHistoric::NoRelatedSym::sbeBlockLength());

    getBuffers()->marketDataRequestHistoric.reset(msgSize);
    return getBuffers()->marketDataRequestHistoric;
  }

  static MFProtoMsgWrapper<mfmarketdata::MarketDataRequestHistoric>&
  getMarketDataRequestHistoric() {
    return getBuffers()->marketDataRequestHistoric;
  }

  static MFProtoMsgWrapper<mfmarketdata::RegisterForBatch>&
  createRegisterForBatch(int numSecIDs) {
    // allocatation size is dependent on numSecIDs so calc here instead of using
    // the default
    size_t msgSize =
        mfmarketdata::RegisterForBatch::sbeBlockLength() +
        mfmarketdata::RegisterForBatch::NoSecurityIDs::sbeHeaderSize() +
        (numSecIDs *
         mfmarketdata::RegisterForBatch::NoSecurityIDs::sbeBlockLength());
    getBuffers()->registerForBatch.reset(msgSize);
    return getBuffers()->registerForBatch;
  }

  static MFProtoMsgWrapper<mfmarketdata::RegisterForBatch>&
  getRegisterForBatch() {
    return getBuffers()->registerForBatch;
  }

  static MFProtoMsgWrapper<mfmarketdata::UnregisterForBatch>&
  createUnregisterForBatch() {
    getBuffers()->unregisterForBatch.reset();
    return getBuffers()->unregisterForBatch;
  }

  static MFProtoMsgWrapper<mfmarketdata::UnregisterForBatch>&
  getUnregisterForBatch() {
    return getBuffers()->unregisterForBatch;
  }

  static MFProtoMsgWrapper<mfmarketdata::Logout>& createMarketDataLogout() {
    getBuffers()->marketDataLogout.reset();
    return getBuffers()->marketDataLogout;
  }

  static MFProtoMsgWrapper<mfmarketdata::Logout>& getMarketDataLogout() {
    return getBuffers()->marketDataLogout;
  }

  static MFProtoMsgWrapper<mfmarketdata::LogoutResponse>&
  createMarketDataLogoutResponse() {
    getBuffers()->marketDataLogoutResponse.reset();
    return getBuffers()->marketDataLogoutResponse;
  }

  static MFProtoMsgWrapper<mfmarketdata::LogoutResponse>&
  getMarketDataLogoutResponse() {
    return getBuffers()->marketDataLogoutResponse;
  }

  static MFProtoMsgWrapper<mfmarketdata::Heartbeat>&
  createMarketDataHeartbeat() {
    getBuffers()->marketDataHeartbeat.reset();
    return getBuffers()->marketDataHeartbeat;
  }

  static MFProtoMsgWrapper<mfmarketdata::Heartbeat>& getMarketDataHeartbeat() {
    return getBuffers()->marketDataHeartbeat;
  }

  // ---- Trading -------------

  static MFProtoMsgWrapper<mftrading::TradingSessionStatusRequest>&
  createTradingSessionStatusRequest() {
    getBuffers()->tradingSessionStatusRequest.reset();
    return getBuffers()->tradingSessionStatusRequest;
  }

  static MFProtoMsgWrapper<mftrading::TradingSessionStatusRequest>&
  getTradingSessionStatusRequest() {
    return getBuffers()->tradingSessionStatusRequest;
  }

  static MFProtoMsgWrapper<mftrading::NewOrderSingle>& createNewOrderSingle(
      const int nStratParams = 0
  ) {
    // Allocatation size is dependent on nStratParams so calc here instead of
    // using the default.
    // Note that we always want a single instance of the sbeHeaderSize() -
    // whether or not there
    // are any StrategyParametersGrp items
    const size_t msgSize =
        mftrading::NewOrderSingle::sbeBlockLength() +
        mftrading::NewOrderSingle::StrategyParametersGrp::sbeHeaderSize() +
        (nStratParams *
         mftrading::NewOrderSingle::StrategyParametersGrp::sbeBlockLength());
    getBuffers()->newOrderSingle.reset(msgSize);
    return getBuffers()->newOrderSingle;
  }

  static MFProtoMsgWrapper<mftrading::NewOrderSingle>& getNewOrderSingle() {
    return getBuffers()->newOrderSingle;
  }

  static MFProtoMsgWrapper<mftrading::Logon>& createTradingLogon() {
    getBuffers()->tradingLogon.reset();
    return getBuffers()->tradingLogon;
  }

  static MFProtoMsgWrapper<mftrading::Logon>& getTradingLogon() {
    return getBuffers()->tradingLogon;
  }

  static MFProtoMsgWrapper<mftrading::MarketDefinitionRequest>&
  createMarketDefinitionRequest() {
    getBuffers()->marketDefinitionRequest.reset();
    return getBuffers()->marketDefinitionRequest;
  }

  static MFProtoMsgWrapper<mftrading::MarketDefinitionRequest>&
  getMarketDefinitionRequest() {
    return getBuffers()->marketDefinitionRequest;
  }

  static MFProtoMsgWrapper<mftrading::OrderCancelReplaceRequest>&
  createOrderCancelReplaceRequest() {
    getBuffers()->orderCancelReplaceRequest.reset();
    return getBuffers()->orderCancelReplaceRequest;
  }

  static MFProtoMsgWrapper<mftrading::OrderCancelReplaceRequest>&
  getOrderCancelReplaceRequest() {
    return getBuffers()->orderCancelReplaceRequest;
  }

  static MFProtoMsgWrapper<mftrading::OrderCancelRequest>&
  createOrderCancelRequest() {
    getBuffers()->orderCancelRequest.reset();
    return getBuffers()->orderCancelRequest;
  }

  static MFProtoMsgWrapper<mftrading::OrderCancelRequest>&
  createOrderCancelRequest
  (
    const long         venueID,
    const long         securityID,
    const std::string& clOrdID,
    const std::string& origOrdID,
    const long         orderID
  ) {
    MFProtoMsgWrapper<mftrading::OrderCancelRequest>& orderCancelRequest =
        getBuffers()->orderCancelRequest;
    return orderCancelRequest;
  }

  static MFProtoMsgWrapper<mftrading::OrderCancelRequest>&
  getOrderCancelRequest() {
    return getBuffers()->orderCancelRequest;
  }

  static MFProtoMsgWrapper<mftrading::Logout>& createTradingLogout() {
    getBuffers()->tradingLogout.reset();
    return getBuffers()->tradingLogout;
  }

  static MFProtoMsgWrapper<mftrading::Logout>& getTradingLogout() {
    return getBuffers()->tradingLogout;
  }

  static MFProtoMsgWrapper<mftrading::LogoutResponse>&
  createTradingLogoutResponse() {
    getBuffers()->tradingLogoutResponse.reset();
    return getBuffers()->tradingLogoutResponse;
  }

  static MFProtoMsgWrapper<mftrading::LogoutResponse>&
  getTradingLogoutResponse() {
    return getBuffers()->tradingLogoutResponse;
  }

  static MFProtoMsgWrapper<mftrading::Heartbeat>& createTradingHeartbeat() {
    getBuffers()->tradingHeartbeat.reset();
    return getBuffers()->tradingHeartbeat;
  }

  static MFProtoMsgWrapper<mftrading::Heartbeat>& getTradingHeartbeat() {
    return getBuffers()->tradingHeartbeat;
  }

//------------ Stp Booking ----------------------------------------------

  static MFProtoMsgWrapper<mfstp_booking::Logon>& createStpBookingLogon() {
    getBuffers()->stpBookingLogon.reset();
    return getBuffers()->stpBookingLogon;
  }

  static MFProtoMsgWrapper<mfstp_booking::Logon>& getStpBookingLogon() {
    return getBuffers()->stpBookingLogon;
  }

  static MFProtoMsgWrapper<mfstp_booking::SecurityDefinitionRequest>&
    createStpBookingSecurityDefinitionRequest() {
    getBuffers()->securityDefinitionRequest.reset();
    return getBuffers()->stpBookingSecurityDefinitionRequest;
  }
  
  static MFProtoMsgWrapper<mfstp_booking::TradeCaptureReportSpotForward>& 
    createStpBookingTradeCaptureReportSpotForward(int numPartyIDs) {
    // allocatation size is dependent on numPartyIDs so calc here instead of using
    // the default
    size_t msgSize =
      mfstp_booking::TradeCaptureReportSpotForward::sbeBlockLength() +
      mfstp_booking::TradeCaptureReportSpotForward::NoPartyIDs::sbeHeaderSize() +
        (numPartyIDs *
          mfstp_booking::TradeCaptureReportSpotForward::NoPartyIDs::sbeBlockLength());
    getBuffers()->stpBookingTradeCaptureReportSpotForward.reset(msgSize);
    return getBuffers()->stpBookingTradeCaptureReportSpotForward;
  }

  static MFProtoMsgWrapper<mfstp_booking::TradeCaptureReportSpotForward>&
    getStpBookingTradeCaptureReportSpotForward() {
    return getBuffers()->stpBookingTradeCaptureReportSpotForward;
  }

  static MFProtoMsgWrapper<mfstp_booking::TradeCaptureReportSwap>& 
    createStpBookingTradeCaptureReportSwap(int numPartyIDs) {
    // allocatation size is dependent on numPartyIDs so calc here instead of using
    // the default
    size_t msgSize =
      mfstp_booking::TradeCaptureReportSwap::sbeBlockLength() +
      mfstp_booking::TradeCaptureReportSwap::NoPartyIDs::sbeHeaderSize() +
        (numPartyIDs *
          mfstp_booking::TradeCaptureReportSwap::NoPartyIDs::sbeBlockLength());
    getBuffers()->stpBookingTradeCaptureReportSwap.reset(msgSize);
    return getBuffers()->stpBookingTradeCaptureReportSwap;
  }

  static MFProtoMsgWrapper<mfstp_booking::TradeCaptureReportSwap>&
    getStpBookingTradeCaptureReportSwap() {
    return getBuffers()->stpBookingTradeCaptureReportSwap;
  }

  static MFProtoMsgWrapper<mfstp_booking::Confirmation>&
    createStpBookingConfirmation() {
    getBuffers()->stpBookingConfirmation.reset();
    return getBuffers()->stpBookingConfirmation;
  }

  static MFProtoMsgWrapper<mfstp_booking::Confirmation>&
    getStpBookingConfirmation() {
    return getBuffers()->stpBookingConfirmation;
  }

  static MFProtoMsgWrapper<mfstp_booking::Logout>& createStpBookingLogout() {
    getBuffers()->stpBookingLogout.reset();
    return getBuffers()->stpBookingLogout;
  }

  static MFProtoMsgWrapper<mfstp_booking::Logout>& getStpBookingLogout() {
    return getBuffers()->stpBookingLogout;
  }

  static MFProtoMsgWrapper<mfstp_booking::LogoutResponse>&
    createStpBookingLogoutResponse() {
    getBuffers()->stpBookingLogoutResponse.reset();
    return getBuffers()->stpBookingLogoutResponse;
  }

  static MFProtoMsgWrapper<mfstp_booking::LogoutResponse>&
    getStpBookingLogoutResponse() {
    return getBuffers()->stpBookingLogoutResponse;
  }

  static MFProtoMsgWrapper<mfstp_booking::Heartbeat>& createStpBookingHeartbeat() {
    getBuffers()->stpBookingHeartbeat.reset();
    return getBuffers()->stpBookingHeartbeat;
  }

  static MFProtoMsgWrapper<mfstp_booking::Heartbeat>& getStpBookingHeartbeat() {
    return getBuffers()->stpBookingHeartbeat;
  }


//------------ Trade Date Roll Over ----------------------------------------------

  static MFProtoMsgWrapper<mftradedaterollover::Logon>& createTradeDateRollOverLogon() {
    getBuffers()->tradeDateRollOverLogon.reset();
    return getBuffers()->tradeDateRollOverLogon;
  }

  static MFProtoMsgWrapper<mftradedaterollover::Logon>& getTradeDateRollOverLogon() {
    return getBuffers()->tradeDateRollOverLogon;
  }

  static MFProtoMsgWrapper<mftradedaterollover::TradeDateRequest>& getTradeDateRequest() {
    return getBuffers()->tradeDateRequest;
  }

  static MFProtoMsgWrapper<mftradedaterollover::TradeDateRequest>& createTradeDateRequest() {
    getBuffers()->tradeDateRequest.reset();
    return getBuffers()->tradeDateRequest;
  }

  static MFProtoMsgWrapper<mftradedaterollover::TradeDateReport>& getTradeDateRollOverTradeDateReport() {
    return getBuffers()->tradeDateRollOverTradeDateReport;
  }

  static MFProtoMsgWrapper<mftradedaterollover::Logout>& createTradeDateRollOverLogout() {
    getBuffers()->tradeDateRollOverLogout.reset();
    return getBuffers()->tradeDateRollOverLogout;
  }

  static MFProtoMsgWrapper<mftradedaterollover::Logout>& getTradeDateRollOverLogout() {
    return getBuffers()->tradeDateRollOverLogout;
  }

  static MFProtoMsgWrapper<mftradedaterollover::LogoutResponse>&
    createTradeDateRollOverLogoutResponse() {
    getBuffers()->tradeDateRollOverLogoutResponse.reset();
    return getBuffers()->tradeDateRollOverLogoutResponse;
  }

  static MFProtoMsgWrapper<mftradedaterollover::LogoutResponse>&
    getTradeDateRollOverLogoutResponse() {
    return getBuffers()->tradeDateRollOverLogoutResponse;
  }

  static MFProtoMsgWrapper<mftradedaterollover::Heartbeat>& createTradeDateRollOverHeartbeat() {
    getBuffers()->tradeDateRollOverHeartbeat.reset();
    return getBuffers()->tradeDateRollOverHeartbeat;
  }

  static MFProtoMsgWrapper<mftradedaterollover::Heartbeat>& getTradeDateRollOverHeartbeat() {
    return getBuffers()->tradeDateRollOverHeartbeat;
  }
};

#endif /* _MFTHREADLOCALBUFFERPROVIDER_H_ */