QTradeProgram/FTAPI/FTAPI.cpp

#include "FTAPI.h"
#include "FTSPI.h"
#include "FTAPIImp.h"

FTAPI_Conn::FTAPI_Conn()
{
	m_pImp = new FTAPIImp(this);
	If_Do(IsNotNullPtr(m_pImp), m_pImp->SetProgrammingLanguage("C++"));
}

FTAPI_Conn::~FTAPI_Conn()
{
	UnregisterConnSpi();
	delete m_pImp;
}

void FTAPI_Conn::SetClientInfo(const char* szClientID, i32_t nClientVer)
{
	If_ReturnVoid(IsNullPtr(m_pImp));
	return m_pImp->SetClientInfo(szClientID, nClientVer);
}

void FTAPI_Conn::SetRSAPrivateKey(const char* szRSAPrivateKey)
{
	If_ReturnVoid(IsNullPtr(m_pImp));
	return m_pImp->SetRSAPrivateKey(szRSAPrivateKey);
}

bool FTAPI_Conn::InitConnect(const char* szIPAddr, u16_t nPort, bool bEnableEncrypt)
{
	If_Return(IsNullPtr(m_pImp), false);
	return m_pImp->InitConnect(szIPAddr, nPort, bEnableEncrypt);
}

u64_t FTAPI_Conn::GetConnectID()
{
	If_Return(IsNullPtr(m_pImp), 0);
	return m_pImp->GetConnectID();
}

bool FTAPI_Conn::Close()
{
	If_Return(IsNullPtr(m_pImp), false);
	return m_pImp->Close();
}

void FTAPI_Conn::RegisterConnSpi(FTSPI_Conn* pSpi)
{
	If_ReturnVoid(IsNullPtr(m_pImp));
	return m_pImp->RegisterConnSpi(pSpi);
}

void FTAPI_Conn::UnregisterConnSpi()
{
	If_ReturnVoid(IsNullPtr(m_pImp));
	return m_pImp->UnregisterConnSpi();
}

/////////////////////////////////////////////////////////////////////////////////
//行情

FTAPI_Qot::FTAPI_Qot()
{
}

FTAPI_Qot::~FTAPI_Qot()
{
	UnregisterQotSpi();
}

void FTAPI_Qot::RegisterQotSpi(FTSPI_Qot* pSpi)
{
	If_ReturnVoid(IsNullPtr(m_pImp));
	return m_pImp->RegisterQotSpi(pSpi);
}

void FTAPI_Qot::UnregisterQotSpi()
{
	If_ReturnVoid(IsNullPtr(m_pImp));
	return m_pImp->UnregisterQotSpi();
}

u32_t FTAPI_Qot::Sub(const Qot_Sub::Request &stReq)
{
	If_Return(IsNullPtr(m_pImp), 0);
	return m_pImp->Sub(stReq);
}

u32_t FTAPI_Qot::GetGlobalState(const GetGlobalState::Request &stReq)
{
	If_Return(IsNullPtr(m_pImp), 0);
	return m_pImp->GetGlobalState(stReq);
}

u32_t FTAPI_Qot::RegQotPush(const Qot_RegQotPush::Request &stReq)
{
	If_Return(IsNullPtr(m_pImp), 0);
	return m_pImp->RegQotPush(stReq);
}

u32_t FTAPI_Qot::GetSubInfo(const Qot_GetSubInfo::Request &stReq)
{
	If_Return(IsNullPtr(m_pImp), 0);
	return m_pImp->GetSubInfo(stReq);
}

u32_t FTAPI_Qot::GetTicker(const Qot_GetTicker::Request &stReq)
{
	If_Return(IsNullPtr(m_pImp), 0);
	return m_pImp->GetTicker(stReq);
}

u32_t FTAPI_Qot::GetBasicQot(const Qot_GetBasicQot::Request &stReq)
{
	If_Return(IsNullPtr(m_pImp), 0);
	return m_pImp->GetBasicQot(stReq);
}

u32_t FTAPI_Qot::GetOrderBook(const Qot_GetOrderBook::Request &stReq)
{
	If_Return(IsNullPtr(m_pImp), 0);
	return m_pImp->GetOrderBook(stReq);
}

u32_t FTAPI_Qot::GetKL(const Qot_GetKL::Request &stReq)
{
	If_Return(IsNullPtr(m_pImp), 0);
	return m_pImp->GetKL(stReq);
}

u32_t FTAPI_Qot::GetRT(const Qot_GetRT::Request &stReq)
{
	If_Return(IsNullPtr(m_pImp), 0);
	return m_pImp->GetRT(stReq);
}

u32_t FTAPI_Qot::GetBroker(const Qot_GetBroker::Request &stReq)
{
	If_Return(IsNullPtr(m_pImp), 0);
	return m_pImp->GetBroker(stReq);
}

u32_t FTAPI_Qot::RequestRehab(const Qot_RequestRehab::Request &stReq)
{
	If_Return(IsNullPtr(m_pImp), 0);
	return m_pImp->RequestRehab(stReq);
}

u32_t FTAPI_Qot::RequestHistoryKL(const Qot_RequestHistoryKL::Request &stReq)
{
	If_Return(IsNullPtr(m_pImp), 0);
	return m_pImp->RequestHistoryKL(stReq);
}

u32_t FTAPI_Qot::RequestHistoryKLQuota(const Qot_RequestHistoryKLQuota::Request &stReq)
{
	If_Return(IsNullPtr(m_pImp), 0);
	return m_pImp->RequestHistoryKLQuota(stReq);
}

u32_t FTAPI_Qot::GetTradeDate(const Qot_GetTradeDate::Request &stReq)
{
	If_Return(IsNullPtr(m_pImp), 0);
	return m_pImp->GetTradeDate(stReq);
}

u32_t FTAPI_Qot::GetStaticInfo(const Qot_GetStaticInfo::Request &stReq)
{
	If_Return(IsNullPtr(m_pImp), 0);
	return m_pImp->GetStaticInfo(stReq);
}

u32_t FTAPI_Qot::GetSecuritySnapshot(const Qot_GetSecuritySnapshot::Request &stReq)
{
	If_Return(IsNullPtr(m_pImp), 0);
	return m_pImp->GetSecuritySnapshot(stReq);
}

u32_t FTAPI_Qot::GetPlateSet(const Qot_GetPlateSet::Request &stReq)
{
	If_Return(IsNullPtr(m_pImp), 0);
	return m_pImp->GetPlateSet(stReq);
}

u32_t FTAPI_Qot::GetPlateSecurity(const Qot_GetPlateSecurity::Request &stReq)
{
	If_Return(IsNullPtr(m_pImp), 0);
	return m_pImp->GetPlateSecurity(stReq);
}

u32_t FTAPI_Qot::GetReference(const Qot_GetReference::Request &stReq)
{
	If_Return(IsNullPtr(m_pImp), 0);
	return m_pImp->GetReference(stReq);
}

u32_t FTAPI_Qot::GetOwnerPlate(const Qot_GetOwnerPlate::Request &stReq)
{
	If_Return(IsNullPtr(m_pImp), 0);
	return m_pImp->GetOwnerPlate(stReq);
}

u32_t FTAPI_Qot::GetHoldingChangeList(const Qot_GetHoldingChangeList::Request &stReq)
{
	If_Return(IsNullPtr(m_pImp), 0);
	return m_pImp->GetHoldingChangeList(stReq);
}

u32_t FTAPI_Qot::GetOptionChain(const Qot_GetOptionChain::Request &stReq)
{
	If_Return(IsNullPtr(m_pImp), 0);
	return m_pImp->GetOptionChain(stReq);
}

u32_t FTAPI_Qot::GetWarrant(const Qot_GetWarrant::Request &stReq)
{
	If_Return(IsNullPtr(m_pImp), 0);
	return m_pImp->GetWarrant(stReq);
}

u32_t FTAPI_Qot::GetCapitalFlow(const Qot_GetCapitalFlow::Request &stReq)
{
	If_Return(IsNullPtr(m_pImp), 0);
	return m_pImp->GetCapitalFlow(stReq);
}

u32_t FTAPI_Qot::GetCapitalDistribution(const Qot_GetCapitalDistribution::Request &stReq)
{
	If_Return(IsNullPtr(m_pImp), 0);
	return m_pImp->GetCapitalDistribution(stReq);
}

u32_t FTAPI_Qot::GetUserSecurity(const Qot_GetUserSecurity::Request &stReq)
{
	If_Return(IsNullPtr(m_pImp), 0);
	return m_pImp->GetUserSecurity(stReq);
}

u32_t FTAPI_Qot::ModifyUserSecurity(const Qot_ModifyUserSecurity::Request &stReq)
{
	If_Return(IsNullPtr(m_pImp), 0);
	return m_pImp->ModifyUserSecurity(stReq);
}

u32_t FTAPI_Qot::StockFilter(const Qot_StockFilter::Request &stReq)
{
	If_Return(IsNullPtr(m_pImp), 0);
	return m_pImp->StockFilter(stReq);
}

Futu::u32_t Futu::FTAPI_Qot::GetCodeChange(const Qot_GetCodeChange::Request &stReq)
{
	If_Return(IsNullPtr(m_pImp), 0);
	return m_pImp->GetCodeChange(stReq);
}

u32_t FTAPI_Qot::GetIpoList(const Qot_GetIpoList::Request &stReq)
{
	If_Return(IsNullPtr(m_pImp), 0);
	return m_pImp->GetIpoList(stReq);
}

u32_t FTAPI_Qot::GetFutureInfo(const Qot_GetFutureInfo::Request &stReq)
{
	If_Return(IsNullPtr(m_pImp), 0);
	return m_pImp->GetFutureInfo(stReq);
}

u32_t FTAPI_Qot::RequestTradeDate(const Qot_RequestTradeDate::Request &stReq)
{
	If_Return(IsNullPtr(m_pImp), 0);
	return m_pImp->RequestTradeDate(stReq);
}

Futu::u32_t FTAPI_Qot::SetPriceReminder(const Qot_SetPriceReminder::Request &stReq)
{
	If_Return(IsNullPtr(m_pImp), 0);
	return m_pImp->SetPriceReminder(stReq);
}

Futu::u32_t FTAPI_Qot::GetPriceReminder(const Qot_GetPriceReminder::Request &stReq)
{
	If_Return(IsNullPtr(m_pImp), 0);
	return m_pImp->GetPriceReminder(stReq);
}

Futu::u32_t FTAPI_Qot::GetUserSecurityGroup(const Qot_GetUserSecurityGroup::Request &stReq)
{
	If_Return(IsNullPtr(m_pImp), 0);
	return m_pImp->GetUserSecurityGroup(stReq);
}

Futu::u32_t FTAPI_Qot::GetMarketState(const Qot_GetMarketState::Request &stReq)
{
	If_Return(IsNullPtr(m_pImp), 0);
	return m_pImp->GetMarketState(stReq);
}

Futu::u32_t FTAPI_Qot::GetOptionExpirationDate(const Qot_GetOptionExpirationDate::Request &stReq)
{
	If_Return(IsNullPtr(m_pImp), 0);
	return m_pImp->GetOptionExpirationDate(stReq);
}

/////////////////////////////////////////////////////////////////////////////////
//交易

FTAPI_Trd::FTAPI_Trd()
{
}

FTAPI_Trd::~FTAPI_Trd()
{
	UnregisterTrdSpi();
}

void FTAPI_Trd::RegisterTrdSpi(FTSPI_Trd* pSpi)
{
	If_ReturnVoid(IsNullPtr(m_pImp));
	return m_pImp->RegisterTrdSpi(pSpi);
}

void FTAPI_Trd::UnregisterTrdSpi()
{
	If_ReturnVoid(IsNullPtr(m_pImp));
	return m_pImp->UnregisterTrdSpi();
}

bool FTAPI_Trd::GetPacketID(Common::PacketID &stPacketID)
{
	If_Return(IsNullPtr(m_pImp), false);
	return m_pImp->GetPacketID(stPacketID);
}

u32_t FTAPI_Trd::GetAccList(const Trd_GetAccList::Request &stReq)
{
	If_Return(IsNullPtr(m_pImp), 0);
	return m_pImp->GetAccList(stReq);
}

u32_t FTAPI_Trd::UnlockTrade(const Trd_UnlockTrade::Request &stReq)
{
	If_Return(IsNullPtr(m_pImp), 0);
	return m_pImp->UnlockTrade(stReq);
}

u32_t FTAPI_Trd::SubAccPush(const Trd_SubAccPush::Request &stReq)
{
	If_Return(IsNullPtr(m_pImp), 0);
	return m_pImp->SubAccPush(stReq);
}

u32_t FTAPI_Trd::GetFunds(const Trd_GetFunds::Request &stReq)
{
	If_Return(IsNullPtr(m_pImp), 0);
	return m_pImp->GetFunds(stReq);
}

u32_t FTAPI_Trd::GetPositionList(const Trd_GetPositionList::Request &stReq)
{
	If_Return(IsNullPtr(m_pImp), 0);
	return m_pImp->GetPositionList(stReq);
}

u32_t FTAPI_Trd::GetMaxTrdQtys(const Trd_GetMaxTrdQtys::Request &stReq)
{
	If_Return(IsNullPtr(m_pImp), 0);
	return m_pImp->GetMaxTrdQtys(stReq);
}

u32_t FTAPI_Trd::GetOrderList(const Trd_GetOrderList::Request &stReq)
{
	If_Return(IsNullPtr(m_pImp), 0);
	return m_pImp->GetOrderList(stReq);
}

u32_t FTAPI_Trd::PlaceOrder(const Trd_PlaceOrder::Request &stReq)
{
	If_Return(IsNullPtr(m_pImp), 0);
	return m_pImp->PlaceOrder(stReq);
}

u32_t FTAPI_Trd::ModifyOrder(const Trd_ModifyOrder::Request &stReq)
{
	If_Return(IsNullPtr(m_pImp), 0);
	return m_pImp->ModifyOrder(stReq);
}

u32_t FTAPI_Trd::GetOrderFillList(const Trd_GetOrderFillList::Request &stReq)
{
	If_Return(IsNullPtr(m_pImp), 0);
	return m_pImp->GetOrderFillList(stReq);
}

u32_t FTAPI_Trd::GetHistoryOrderList(const Trd_GetHistoryOrderList::Request &stReq)
{
	If_Return(IsNullPtr(m_pImp), 0);
	return m_pImp->GetHistoryOrderList(stReq);
}

u32_t FTAPI_Trd::GetHistoryOrderFillList(const Trd_GetHistoryOrderFillList::Request &stReq)
{
	If_Return(IsNullPtr(m_pImp), 0);
	return m_pImp->GetHistoryOrderFillList(stReq);
}

u32_t FTAPI_Trd::GetMarginRatio(const Trd_GetMarginRatio::Request &stReq)
{
	If_Return(IsNullPtr(m_pImp), 0);
	return m_pImp->GetMarginRatio(stReq);
}

u32_t FTAPI_Trd::GetOrderFee(const Trd_GetOrderFee::Request& stReq)
{
    If_Return(IsNullPtr(m_pImp), 0);
    return m_pImp->GetOrderFee(stReq);
}

FTAPI_Qot* FTAPI::CreateQotApi()
{
	return new FTAPI_Qot();
}

void FTAPI::ReleaseQotApi(FTAPI_Qot* pQot)
{
	delete pQot;
}

FTAPI_Trd* FTAPI::CreateTrdApi()
{
	return new FTAPI_Trd();
}

void FTAPI::ReleaseTrdApi(FTAPI_Trd* pTrd)
{
	delete pTrd;
}

void FTAPI::Init()
{
	FTAPIChannel_Init();
}

void FTAPI::UnInit()
{
	FTAPIChannel_UnInit();
}