//------------------------------------------------------------------------------------------------------------------------// void CMarketDataProvider::SubscribeRisksSingle(const CTicker& ticker) { IRisksProviderPtr spProvider = GetRisksProvider(); try { if (static_cast<bool>(spProvider)) { ITicker request; ticker.CopyTo(request); _com_util::CheckError(spProvider->raw_SubscribeRisks(&request)); SysFreeString(request.Symbol); SysFreeString(request.Exchange); m_bInRequestMode = true; } } catch (_com_error& err) { TRACE_COM_ERROR(err); } catch (...) { TRACE_UNKNOWN_ERROR(); } return; }
//------------------------------------------------------------------------------------------------------------------------// void CMarketDataProvider::UnSubscribeQuote() { try { IPriceProviderPtr spPriceProvider = GetPriceProvider(); if (static_cast<bool>(spPriceProvider)) { if (m_bInSubscribeMode) { spPriceProvider->raw_UnSubscribeQuote(); m_bInSubscribeMode = false; } } } catch (_com_error& err) { TRACE_COM_ERROR(err); } catch (...) { TRACE_UNKNOWN_ERROR(); }; return; }
//------------------------------------------------------------------------------------------------------------------------// void CMarketDataProvider::SubscribeQuotesSingle(const CTicker& ticker) { IPriceProviderPtr spPriceProvider = GetPriceProvider(); try { if (static_cast<bool>(spPriceProvider)) { QuoteUpdateParams request; ticker.CopyTo(request); _com_util::CheckError(spPriceProvider->raw_SubscribeQuote(&request)); SysFreeString(request.Symbol); SysFreeString(request.Exchange); m_bInRequestMode = true; } } catch (_com_error& err) { if (static_cast<bool>(spPriceProvider)) spPriceProvider->raw_CancelLastQuote(); TRACE_COM_ERROR(err); } catch (...) { TRACE_UNKNOWN_ERROR(); }; return; }
//-----------------------------------------------------------------------------------------------------// void CMarketDataProvider::Disconnect() { try { IPriceProviderPtr spPriceProvider = GetPriceProvider(); if(static_cast<bool>(spPriceProvider)) { DispQuotes::DispEventUnadvise(spPriceProvider); DispRisks::DispEventUnadvise(spPriceProvider); Sleep(1000L); CancelLastQuote(); m_bInSubscribeMode = false; m_bInRequestMode = false; spPriceProvider->Disconnect(); SetPriceProvider(NULL); } } catch(_com_error& err) { TRACE_COM_ERROR(err); } catch(...) { TRACE_UNKNOWN_ERROR(); }; }
BOOL Sp::Open(LPCTSTR lpcszConn,int nTimeout,BOOL bAsync) { try { m_conn.CreateInstance("ADODB.Connection"); if (nTimeout > 0) m_conn->ConnectionTimeout = nTimeout; HRESULT hr = m_conn->Open(lpcszConn,L"",L"",bAsync ? adAsyncConnect : adConnectUnspecified); if (SUCCEEDED(hr)) { return TRUE; } else { TRACE(_T("Sp::Open exception Hr:0x%X\n"),hr); m_conn = NULL; return FALSE; } } catch (_com_error &ex) { m_conn = NULL; TRACE_COM_ERROR(ex); return FALSE; } }
//----------------------------------------------------------------------------------// void CTradesCache::LoadTrades() { try { if (static_cast<bool>(m_spTradeChannel)) { BSTR bstrConnectionString; if (GetSettingsImpl().get() == NULL) utils::ThrowErrorNoSetErrorInfo(E_POINTER, L"Failed to GetSettings."); GetSettingsImpl()->GetDBConnection(&bstrConnectionString); SetConnectionString(bstrConnectionString); HRESULT hr = m_spTradeChannel->put_DatabaseString(bstrConnectionString); hr = m_spTradeChannel->LoadTrades(0, GetMain(), VARIANT_FALSE); if(FAILED(hr)) utils::ThrowErrorNoSetErrorInfo(hr, L"Failed to LoadTrades."); } } catch (_com_error& err){ std::ostringstream out_stream; out_stream << "Exception occured while loading trades."; TRACE_COM_ERROR(LOG4CPLUS_ERROR, VS::Log, err, std::string(out_stream.str())); } catch (...){ std::ostringstream out_stream; out_stream<<"Unknown C++ exception occured while loading trades."; TRACE_UNKNOWN_ERROR(LOG4CPLUS_ERROR, VS::Log, std::string(out_stream.str())); ATLASSERT(FALSE); } };
//--------------------------------------------------------------------------------// void CSyntheticEquity::AddComponent(IBasketAssetComponentPtr spComponent) { try { if (static_cast<bool>(spComponent) && static_cast<bool>(m_spComponents)) { IAssetPtr spAsset = NULL; //_CHK(spComponent->get_Asset(&spAsset), _T("Fail to get Asset.")); if (static_cast<bool>(spAsset)) { LONG lID = 0; BSTR bsSymbol = NULL; IBasketAssetComponentPtr spAdded = NULL; spAsset->get_ID(&lID); spAsset->get_Symbol(&bsSymbol); _CHK(m_spComponents->Add(lID, bsSymbol, spComponent.GetInterfacePtr(), &spAdded), _T("Fail to add synthetic component.")); } } } catch (_com_error& err) { TRACE_COM_ERROR(err); } catch (...) { TRACE_UNKNOWN_ERROR(); }; };
BOOL Sp::IsConnected(void) { try { return (m_conn->State == adStateOpen); } catch (_com_error &ex) { TRACE_COM_ERROR(ex); return FALSE; } }
void Sp::Close(BOOL bCancel) { try { if (bCancel) m_conn->Cancel(); m_conn = NULL; } catch (_com_error &ex) { TRACE_COM_ERROR(ex); } }
//--------------------------------------------------------------------------------// STDMETHODIMP CCalculationSettingsAtom::put_CurveInterpolationType(LONG newVal){ try { CCalculationSettingsSingleton::Instance()->set_interpolation_type(newVal); } catch (_com_error& err){ TRACE_COM_ERROR(err); return E_FAIL; } catch (...){ TRACE_UNKNOWN_ERROR(); return E_FAIL; }; return S_OK; };
//--------------------------------------------------------------------------------------// void CMarketDataProvider::Subscribe(RequestVector& request) { HRESULT hr = S_OK; try { IBatchPriceProviderPtr spBatchPriceProvider = GetBatchPriceProvider(); if (static_cast<bool>(spBatchPriceProvider)) { CComRecPtr<QuoteUpdateParams, &LIBID_PRICEPROVIDERSLib> RequestInfo; RequestInfo.Init(); long outSize = static_cast<long>(request.size()); SAFEARRAYBOUND sab = { outSize, 0 }; LPSAFEARRAY psa = ::SafeArrayCreateEx( VT_RECORD, 1, &sab, (PVOID) RequestInfo.GetRecordInfo() ); if(psa) { QuoteUpdateParams* pvOutData = NULL; if(SUCCEEDED(hr = ::SafeArrayAccessData(psa, (void**)&pvOutData))) { memset(pvOutData, 0, outSize * sizeof(QuoteUpdateParams)); int j = 0; for (RequestVector::iterator it = request.begin(); it != request.end(); ++it) { (*it).CopyTo(pvOutData[j]); j++; } ::SafeArrayUnaccessData(psa); } } _com_util::CheckError(spBatchPriceProvider->raw_SubscribeMultipleQuotes(&psa)); ::SafeArrayDestroy(psa); m_bInSubscribeMode = true; } } catch (_com_error& err) { TRACE_COM_ERROR(err); } catch (...) { TRACE_UNKNOWN_ERROR(); }; return; };
//--------------------------------------------------------------------------------// STDMETHODIMP CCalculationSettingsAtom::put_Normal(DOUBLE Value){ try{ CCalculationSettingsSingleton::Instance()->setNormal(double(Value)); } catch (_com_error& err){ TRACE_COM_ERROR(err); return E_FAIL; } catch (...){ TRACE_UNKNOWN_ERROR(); return E_FAIL; }; return S_OK; };
//--------------------------------------------------------------------------------// STDMETHODIMP CCalculationSettingsAtom::put_GreeksCalculationMode(LONG newVal) { try { CCalculationSettingsSingleton::Instance()->SetGreeksCalculationMode(static_cast<IvRmCore::GreeksCalculationModeEnum>(newVal)); } catch (_com_error& err) { TRACE_COM_ERROR(err); return E_FAIL; } catch (...) { TRACE_UNKNOWN_ERROR(); }; return S_OK; };
//--------------------------------------------------------------------------------// STDMETHODIMP CCalculationSettingsAtom::put_PriceRoundingRule(LONG newVal) { try { CCalculationSettingsSingleton::Instance()->SetPriceRoundingRule(newVal); } catch (_com_error& err) { TRACE_COM_ERROR(err); return E_FAIL; } catch (...) { TRACE_UNKNOWN_ERROR(); return E_FAIL; } return S_OK; };
//--------------------------------------------------------------------------------// STDMETHODIMP CCalculationSettingsAtom::put_UseTheoVolaIfBadMarketVola(LONG newVal) { try { CCalculationSettingsSingleton::Instance()->SetUseTheoVolaIfBadMarketVola(newVal > 0 ? true : false); } catch (_com_error& err) { TRACE_COM_ERROR(err); return E_FAIL; } catch (...) { TRACE_UNKNOWN_ERROR(); return E_FAIL; } return S_OK; };
//--------------------------------------------------------------------------------// STDMETHODIMP CCalculationSettingsAtom::get_CurveInterpolationType(LONG* pRetVal){ if (pRetVal == NULL) return E_POINTER; try{ *pRetVal = CCalculationSettingsSingleton::Instance()->interpolation_type(); } catch (_com_error& err){ TRACE_COM_ERROR(err); return E_FAIL; } catch (...){ TRACE_UNKNOWN_ERROR(); return E_FAIL; }; return S_OK; };
//------------------------------------------------------------------------------------------------------ STDMETHODIMP CEtsDivColl::Reload(void) { try { CDBConnection dbConnection; if(!dbConnection.IsOpened()) dbConnection.Open(CGenegalSettings::GetDBConnectionString(), 10, 120, 300, 300); if (dbConnection.IsOpened()) { Clear(); CStoredProc<> db(dbConnection, L"usp_Dividends_Get"); //push parameters db << m_nAssetID; CClientRecordset rs; rs.Open(db); DATE dtDividendDate; DOUBLE dDividendAmmount; for(rs.MoveFirst(); !rs.IsEOF(); ++rs) { dtDividendDate = (vt_date)rs[L"DivYtes"]; dDividendAmmount = rs[L"DivAmnt"]; _CHK(AddNonUnique(dtDividendDate, dDividendAmmount), _T("Fail to Add Dividend payment date.")); }; dbConnection.Close(); }; } catch (_com_error& err) { TRACE_COM_ERROR(err); } catch (...) { TRACE_UNKNOWN_ERROR(); } return S_OK; }
//-----------------------------------------------------------------------------------------------------// void CMarketDataProvider::Connect() { try { if(GetPriceProvider()) Disconnect(); IPriceProviderPtr spPriceProvider; _com_util::CheckError(spPriceProvider.CreateInstance(__uuidof(DataFeedBatchPriceInfo))); IProviderPtr spProvider = spPriceProvider; //spProvider->Type = 10; spPriceProvider->Connect(); IProvidersPtr spProvidersInfo; _com_util::CheckError(spProvidersInfo.CreateInstance(CLSID_Providers)); _com_util::CheckError(spProvidersInfo->Initialize()); IProviderDataPtr spProviderInfo; //_com_util::CheckError(spProvidersInfo->GetProvider(spProvider->Type,&spProviderInfo)); _com_util::CheckError(DispQuotes::DispEventAdvise(spPriceProvider/*, &IID_IBatchPriceProvider*/)); // can't connect error occure _com_util::CheckError(DispRisks::DispEventAdvise(spPriceProvider/*, &IID_IRisksProvider*/)); // can't connect error occure SetPriceProvider(spPriceProvider); m_dwCooke = NULL; CComGITPtr<IPriceProvider> ptrProviderGIT(m_spPriceProvider.GetInterfacePtr()); m_dwCooke = ptrProviderGIT.Detach(); } catch(_com_error& err) { Disconnect(); TRACE_COM_ERROR(err); } catch(...) { TRACE_UNKNOWN_ERROR(); } };
//--------------------------------------------------------------------------------// STDMETHODIMP CCalculationSettingsAtom::get_GreeksCalculationMode(LONG* pRetVal) { if (pRetVal == NULL) return E_POINTER; try { *pRetVal = static_cast<LONG>(CCalculationSettingsSingleton::Instance()->GetGreeksCalculationMode()); } catch (_com_error& err) { TRACE_COM_ERROR(err); return E_FAIL; } catch (...) { TRACE_UNKNOWN_ERROR(); }; return S_OK; };
//--------------------------------------------------------------------------------// STDMETHODIMP CCalculationSettingsAtom::get_Normal(DOUBLE* RetVal){ if (RetVal == NULL) return E_POINTER; try{ *RetVal = CCalculationSettingsSingleton::Instance()->getNormal(); } catch (_com_error& err){ TRACE_COM_ERROR(err); return E_FAIL; } catch (...){ TRACE_UNKNOWN_ERROR(); return E_FAIL; }; return S_OK; };
//-----------------------------------------------------------------------------------------------------// void CMarketDataProvider::GetRisksUpdate() { HRESULT hr = S_OK; try { IRisksProviderPtr spProvider = GetRisksProvider(); if (static_cast<bool>(spProvider)) { SAFEARRAY* pSafeArray = spProvider->GetRisksUpdates(); if(pSafeArray) { IRisksFullInfo* pvData = NULL; if( SUCCEEDED( hr = ::SafeArrayAccessData( pSafeArray, (void**)&pvData) ) ) { long lLBound = 0; long lUBound = 0; HRESULT hRes = SafeArrayGetLBound(pSafeArray, 1L, &lLBound); hRes = SafeArrayGetUBound(pSafeArray, 1L, &lUBound); long lArraySize = lUBound - lLBound ; for(int i = 0; i<= lArraySize; ++i) _AcceptRisks(pvData[i].Ticker, pvData[i].Risks); ::SafeArrayUnaccessData(pSafeArray); } ::SafeArrayDestroy(pSafeArray); } } } catch (_com_error& err) { TRACE_COM_ERROR(err); } catch (...) { TRACE_UNKNOWN_ERROR(); } return; };
//--------------------------------------------------------------------------------// STDMETHODIMP CCalculationSettingsAtom::get_PriceTolerance(DOUBLE* pRetVal) { if (pRetVal == NULL) return E_POINTER; try { *pRetVal = static_cast<DOUBLE>(CCalculationSettingsSingleton::Instance()->GetPriceTolerance()); } catch (_com_error& err) { TRACE_COM_ERROR(err); return E_FAIL; } catch (...) { TRACE_UNKNOWN_ERROR(); return E_FAIL; }; return S_OK; };
//-----------------------------------------------------------------------------------------------------// STDMETHODIMP CMarketDataProvider::_AcceptQuote(const QuoteUpdateParams& Params, QuoteUpdateInfo& Info) { HRESULT __Result = E_FAIL; try { CTicker ticker(Params); CQuote quote(Info); AcceptQuote(ticker, quote); __Result = S_OK; } catch (_com_error& err) { TRACE_COM_ERROR(err); } catch (...) { TRACE_UNKNOWN_ERROR(); } return __Result; };
//---------------------------------------------------------------------------------------------// STDMETHODIMP CMmTradeChannel::GetData(IEtsFilterData* ipFilter, IMmTradeInfoColl** ipResult) { try { __CHECK_POINTER(ipFilter); IEtsFilterDataPtr spFilter = NULL; spFilter.Attach(ipFilter, true); if (!ipResult) return E_POINTER; if(*ipResult){ (*ipResult)->Release(); *ipResult = NULL; }; IMmTradeInfoCollPtr spResult = IMmTradeInfoCollPtr(__uuidof(MmTradeInfoColl)); *ipResult = (IMmTradeInfoColl*)spResult; if (*ipResult) (*ipResult)->AddRef(); if (*ipResult){ CTradeInfoViewData filteredTrades; FilterData(spFilter, filteredTrades); if (filteredTrades.size() > 0){ CTradeInfoViewData::iterator it = filteredTrades.begin(); CTradeInfoViewData::iterator itEnd = filteredTrades.end(); for (; it != itEnd; it++) { long lTradeID = 0L; _CHK((*it)->get_TradeID(&lTradeID), _T("Fail to get trade id.")); DATE dtTradeDate = 0.; _CHK((*it)->get_TradeDate(&dtTradeDate), _T("Fail to get TradeDate.")); IMmTradeInfoAtomPtr spReturnPtr = NULL; IMmTradeInfoAtomPtr spTrade = (*it); spResult->Add(lTradeID, dtTradeDate, spTrade, &spReturnPtr); /*_CHK((*ipResult)->Add(lTradeID, dtTradeDate, spTrade, &spReturnPtr), _T("Fail to Add trade to collection."));*/ } } }; } catch (_com_error& err) { TRACE_COM_ERROR(err); ATLASSERT(FALSE); throw; } catch (...) { TRACE_UNKNOWN_ERROR(); ATLASSERT(FALSE); throw; }; return S_OK; };
//----------------------------------------------------------------------------------// bool CTradesCache::ProcessTradeForAnalytics(CTradePtr spTrade){ if (spTrade.get()){ long lStep = 0; IRisks retRisks; try{ retRisks = spTrade->m_spContract->Calculate(NULL, NULL); } catch (_com_error& err){ std::ostringstream out_stream; out_stream << "Analytical data for trade ["; out_stream << spTrade->m_nTradeID; out_stream<< "] has not been ready at this moment. It will be respocessed one more time by queue."; TRACE_COM_ERROR(LOG4CPLUS_WARN, VS::Log, err, std::string(out_stream.str())); return false; } try{ //format xml to pass to DB lStep = 1; _bstr_t bstrXML; bstrXML.Attach(GetXMLString(&retRisks, spTrade)); lStep = 2; //save to DB InitializeDB(); CStoredProc<CClientRecordset> rs(GetDBConnection(), L"usp_ContractAnalytics_Save"); rs << bstrXML; lStep = 3; rs.Open(); lStep = 4; rs.Close(); return true; } catch (_com_error& err){ std::ostringstream out_stream; out_stream<<"Exception occured while ProcessTradeForAnalytics().\n\tStep = " << lStep; out_stream<<"\n\tTradeID = " << spTrade->m_nTradeID; TRACE_COM_ERROR(LOG4CPLUS_ERROR, VS::Log, err, std::string(out_stream.str())); return false; } catch (...){ std::ostringstream out_stream; out_stream<<"Unknown C++ exception occured while ProcessTradeForAnalytics().\n\tStep = " << lStep; out_stream<<"\n\tTradeID = " << spTrade->m_nTradeID; TRACE_UNKNOWN_ERROR(LOG4CPLUS_ERROR, VS::Log, std::string(out_stream.str())); return false; } } return false; };