Pierre8rTeam
515 lines
44 KiB
Plaintext
515 lines
44 KiB
Plaintext
//+------------------------------------------------------------------+
|
|
//| Symbol.mqh |
|
|
//| Copyright 2016, Vasiliy Sokolov. |
|
|
//| http://www.mql5.com |
|
|
//+------------------------------------------------------------------+
|
|
#property copyright "Copyright 2016, Vasiliy Sokolov."
|
|
#property link "http://www.mql5.com"
|
|
#include <Object.mqh>
|
|
#include "MarketBook.mqh"
|
|
#include "Series.mqh"
|
|
#include "SessionInfo.mqh"
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| defines |
|
|
//+------------------------------------------------------------------+
|
|
class CSymbol : public CObject
|
|
{
|
|
private:
|
|
string m_symbol; // Symbol
|
|
ENUM_TIMEFRAMES m_period; // Timeframe
|
|
|
|
public:
|
|
CSymbol(void);
|
|
CSymbol(string symbol, ENUM_TIMEFRAMES period);
|
|
// Based series
|
|
CTime Time;
|
|
COpen Open;
|
|
CHigh High;
|
|
CLow Low;
|
|
CClose Close;
|
|
CVolume Volume;
|
|
CMarketBook MarketBook;
|
|
CSessionInfo SessionInfo;
|
|
// Based foo
|
|
bool InitSeries(string symbol,ENUM_TIMEFRAMES period);
|
|
bool Available(void);
|
|
string Name(void);
|
|
bool Name(string symbol);
|
|
ENUM_TIMEFRAMES Period(void);
|
|
bool Period(ENUM_TIMEFRAMES period);
|
|
// SymbolInfoInteger
|
|
bool SelectInMarketWatch(void);
|
|
bool SpreadFloat(void);
|
|
int Digits(void);
|
|
int Spread(void);
|
|
int StopLevel(void);
|
|
int FreezeLevel(void);
|
|
int FlagsExpirationOrders(void);
|
|
int FlagsExecutionOrders(void);
|
|
int FlagsAllowedOrders(void);
|
|
int IndexByTime(datetime time);
|
|
int BarsTotal(void);
|
|
ENUM_SYMBOL_CALC_MODE CalcContractType(void);
|
|
ENUM_SYMBOL_TRADE_MODE ExecuteOrderType(void);
|
|
ENUM_SYMBOL_TRADE_EXECUTION ExecuteDealsType(void);
|
|
ENUM_SYMBOL_SWAP_MODE CalcSwapMode(void);
|
|
ENUM_DAY_OF_WEEK DayOfSwap3x(void);
|
|
ENUM_SYMBOL_OPTION_MODE OptionType(void);
|
|
ENUM_SYMBOL_OPTION_RIGHT OptionRight(void);
|
|
datetime TimeOfLastQuote(void);
|
|
datetime StartDate(void);
|
|
datetime ExpirationDate(void);
|
|
// SymbolInfoDouble
|
|
double Ask(void);
|
|
double Bid(void);
|
|
double Last(void);
|
|
double StepToPrice(int price_step);
|
|
double PriceStep(void);
|
|
double OptionStrike(void);
|
|
double TickValue(void);
|
|
double ContractSize(void);
|
|
double VolumeContractMin(void);
|
|
double VolumeContractMax(void);
|
|
double VolumeContractStep(void);
|
|
double VolumeContractLimit(void);
|
|
double SwapLong(void);
|
|
double SwapShort();
|
|
double MarginInit(void);
|
|
double MarginMaintenance(void);
|
|
double MarginHedged(void);
|
|
// SymbolInfoString
|
|
string NameBasisSymbol(void);
|
|
string NameBasisCurrency(void);
|
|
string NameCurrencyProfit(void);
|
|
string NameCurrencyMargin(void);
|
|
string NameBank(void);
|
|
string Description(void);
|
|
string NameISIN(void);
|
|
string SymbolPath(void);
|
|
};
|
|
//+------------------------------------------------------------------+
|
|
//| Sets OHLCV series for the current instrument and timeframe |
|
|
//+------------------------------------------------------------------+
|
|
CSymbol::CSymbol(void)
|
|
{
|
|
m_symbol = ::Symbol();
|
|
m_period = ::Period();
|
|
InitSeries(Symbol(), ::Period());
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Returns the total number of bars of this symbol in the current |
|
|
//| timeframe |
|
|
//+------------------------------------------------------------------+
|
|
int CSymbol::BarsTotal(void)
|
|
{
|
|
int bars = Bars(this.Name(), this.Period());
|
|
return bars;
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Returns the bar index corresponding to the specified time |
|
|
//+------------------------------------------------------------------+
|
|
int CSymbol::IndexByTime(datetime time)
|
|
{
|
|
int bars = Bars(this.Name(), this.Period(), time, TimeCurrent());
|
|
return bars-1;
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Sets OHLCV series for the specified instrument and timeframe |
|
|
//+------------------------------------------------------------------+
|
|
CSymbol::CSymbol(string symbol, ENUM_TIMEFRAMES period)
|
|
{
|
|
m_symbol = symbol;
|
|
m_period = period;
|
|
InitSeries(symbol, period);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Returns the symbol |
|
|
//+------------------------------------------------------------------+
|
|
string CSymbol::Name(void)
|
|
{
|
|
return m_symbol;
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Sets the symbol |
|
|
//+------------------------------------------------------------------+
|
|
bool CSymbol::Name(string symbol)
|
|
{
|
|
m_symbol = symbol;
|
|
InitSeries(m_symbol, m_period);
|
|
return Available();
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Returns the period of the instrument |
|
|
//+------------------------------------------------------------------+
|
|
ENUM_TIMEFRAMES CSymbol::Period(void)
|
|
{
|
|
return m_period;
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Sets the period of the instrument |
|
|
//+------------------------------------------------------------------+
|
|
bool CSymbol::Period(ENUM_TIMEFRAMES period)
|
|
{
|
|
m_period = period;
|
|
InitSeries(m_symbol, m_period);
|
|
return Available();
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Sets OHLCV series for the current instrument and timeframe. |
|
|
//| Returns true if the symbol is available and false in the opposite|
|
|
//| case |
|
|
//+------------------------------------------------------------------+
|
|
bool CSymbol::InitSeries(string symbol,ENUM_TIMEFRAMES period)
|
|
{
|
|
m_symbol = symbol;
|
|
Time.Symbol(symbol);
|
|
Time.Timeframe(period);
|
|
Open.Symbol(symbol);
|
|
Open.Timeframe(period);
|
|
High.Symbol(symbol);
|
|
High.Timeframe(period);
|
|
Low.Symbol(symbol);
|
|
Low.Timeframe(period);
|
|
Close.Symbol(symbol);
|
|
Close.Timeframe(period);
|
|
Volume.Symbol(symbol);
|
|
Volume.Timeframe(period);
|
|
SessionInfo.Symbol(symbol);
|
|
return Time.Total() > 0;
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Returns true if the symbol is available for work and false |
|
|
//| otherwise |
|
|
//+------------------------------------------------------------------+
|
|
bool CSymbol::Available(void)
|
|
{
|
|
return Bars(m_symbol, m_period) > 0;
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| An indication that the symbol exists in the terminal |
|
|
//+------------------------------------------------------------------+
|
|
bool CSymbol::SelectInMarketWatch(void)
|
|
{
|
|
return (bool)SymbolInfoInteger(m_symbol, SYMBOL_SELECT);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| An indication of the floating spread |
|
|
//+------------------------------------------------------------------+
|
|
bool CSymbol::SpreadFloat(void)
|
|
{
|
|
return (bool)SymbolInfoInteger(m_symbol, SYMBOL_SPREAD_FLOAT);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Spread value in points |
|
|
//+------------------------------------------------------------------+
|
|
int CSymbol::Spread(void)
|
|
{
|
|
return (int)SymbolInfoInteger(m_symbol, SYMBOL_SPREAD);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Minimum distance in points from the current close price |
|
|
//| for setting Stop orders |
|
|
//+------------------------------------------------------------------+
|
|
int CSymbol::StopLevel(void)
|
|
{
|
|
return (int)SymbolInfoInteger(m_symbol, SYMBOL_TRADE_STOPS_LEVEL);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Freeze distance for trading operations (in points) |
|
|
//+------------------------------------------------------------------+
|
|
int CSymbol::FreezeLevel(void)
|
|
{
|
|
return (int)SymbolInfoInteger(m_symbol, SYMBOL_TRADE_FREEZE_LEVEL);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Flags of allowed order expiration modes |
|
|
//+------------------------------------------------------------------+
|
|
int CSymbol::FlagsExpirationOrders(void)
|
|
{
|
|
return (int)SymbolInfoInteger(m_symbol, SYMBOL_EXPIRATION_MODE);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Flags of allowed order execution modes |
|
|
//+------------------------------------------------------------------+
|
|
int CSymbol::FlagsExecutionOrders(void)
|
|
{
|
|
return (int)SymbolInfoInteger(m_symbol, SYMBOL_FILLING_MODE);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Flags of allowed order types |
|
|
//+------------------------------------------------------------------+
|
|
int CSymbol::FlagsAllowedOrders(void)
|
|
{
|
|
return (int)SymbolInfoInteger(m_symbol, SYMBOL_ORDER_MODE);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| An indication that the symbol is selected in Market Watch |
|
|
//+------------------------------------------------------------------+
|
|
int CSymbol::Digits(void)
|
|
{
|
|
int digits=(int)SymbolInfoInteger(m_symbol, SYMBOL_DIGITS);
|
|
return digits;
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Contract price calculation mode |
|
|
//+------------------------------------------------------------------+
|
|
ENUM_SYMBOL_CALC_MODE CSymbol::CalcContractType(void)
|
|
{
|
|
return (ENUM_SYMBOL_CALC_MODE)SymbolInfoInteger(m_symbol, SYMBOL_TRADE_CALC_MODE);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Order execution type |
|
|
//+------------------------------------------------------------------+
|
|
ENUM_SYMBOL_TRADE_MODE CSymbol::ExecuteOrderType(void)
|
|
{
|
|
return (ENUM_SYMBOL_TRADE_MODE)SymbolInfoInteger(m_symbol, SYMBOL_TRADE_MODE);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Deal execution type |
|
|
//+------------------------------------------------------------------+
|
|
ENUM_SYMBOL_TRADE_EXECUTION CSymbol::ExecuteDealsType(void)
|
|
{
|
|
return (ENUM_SYMBOL_TRADE_EXECUTION)SymbolInfoInteger(m_symbol, SYMBOL_TRADE_EXEMODE);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Swap calculation model |
|
|
//+------------------------------------------------------------------+
|
|
ENUM_SYMBOL_SWAP_MODE CSymbol::CalcSwapMode(void)
|
|
{
|
|
return (ENUM_SYMBOL_SWAP_MODE)SymbolInfoInteger(m_symbol, SYMBOL_SWAP_MODE);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Triple-day swap day |
|
|
//+------------------------------------------------------------------+
|
|
ENUM_DAY_OF_WEEK CSymbol::DayOfSwap3x(void)
|
|
{
|
|
return (ENUM_DAY_OF_WEEK)SymbolInfoInteger(m_symbol, SYMBOL_SWAP_ROLLOVER3DAYS);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Option type |
|
|
//+------------------------------------------------------------------+
|
|
ENUM_SYMBOL_OPTION_MODE CSymbol::OptionType(void)
|
|
{
|
|
return (ENUM_SYMBOL_OPTION_MODE)SymbolInfoInteger(m_symbol, SYMBOL_OPTION_MODE);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Option right (Call/Put) |
|
|
//+------------------------------------------------------------------+
|
|
ENUM_SYMBOL_OPTION_RIGHT CSymbol::OptionRight(void)
|
|
{
|
|
return (ENUM_SYMBOL_OPTION_RIGHT)SymbolInfoInteger(m_symbol, SYMBOL_OPTION_RIGHT);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Time of the last quote |
|
|
//+------------------------------------------------------------------+
|
|
datetime CSymbol::TimeOfLastQuote(void)
|
|
{
|
|
return (datetime)SymbolInfoInteger(m_symbol, SYMBOL_TIME);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Trading start date for an instrument |
|
|
//+------------------------------------------------------------------+
|
|
datetime CSymbol::StartDate(void)
|
|
{
|
|
return (datetime)SymbolInfoInteger(m_symbol, SYMBOL_START_TIME);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Trading end date for an instrument |
|
|
//+------------------------------------------------------------------+
|
|
datetime CSymbol::ExpirationDate(void)
|
|
{
|
|
return (datetime)SymbolInfoInteger(m_symbol, SYMBOL_EXPIRATION_TIME);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Returns Ask price. |
|
|
//+------------------------------------------------------------------+
|
|
double CSymbol::Ask(void)
|
|
{
|
|
double ask = SymbolInfoDouble(m_symbol, SYMBOL_ASK);
|
|
int digits = (int)SymbolInfoInteger(m_symbol, SYMBOL_DIGITS);
|
|
ask=NormalizeDouble(ask,digits);
|
|
return ask;
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Returns Bid price. |
|
|
//+------------------------------------------------------------------+
|
|
double CSymbol::Bid(void)
|
|
{
|
|
double bid = SymbolInfoDouble(m_symbol, SYMBOL_BID);
|
|
int digits = (int)SymbolInfoInteger(m_symbol, SYMBOL_DIGITS);
|
|
bid=NormalizeDouble(bid,digits);
|
|
return bid;
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Returns Last price. |
|
|
//+------------------------------------------------------------------+
|
|
double CSymbol::Last(void)
|
|
{
|
|
double last= SymbolInfoDouble(m_symbol,SYMBOL_LAST);
|
|
int digits =(int)SymbolInfoInteger(m_symbol,SYMBOL_DIGITS);
|
|
last=NormalizeDouble(last,digits);
|
|
return last;
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Returns price steps as the price. For example, passed value |
|
|
//| 3 on 5-digit EURUSD will be converted to 0.00003 |
|
|
//+------------------------------------------------------------------+
|
|
double CSymbol::StepToPrice(int price_step)
|
|
{
|
|
double price = SymbolInfoDouble(m_symbol, SYMBOL_POINT)*(double)price_step;
|
|
return price;
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Returns the minimum price change for the instrument, for example |
|
|
//| EURUSD 5-digit 0.00001 will be returned |
|
|
//+------------------------------------------------------------------+
|
|
double CSymbol::PriceStep(void)
|
|
{
|
|
double price = SymbolInfoDouble(m_symbol, SYMBOL_POINT);
|
|
return price;
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Returns option execution price |
|
|
//+------------------------------------------------------------------+
|
|
double CSymbol::OptionStrike(void)
|
|
{
|
|
return SymbolInfoDouble(m_symbol, SYMBOL_OPTION_STRIKE);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Returns the value of one tick expressed in the deposit currency |
|
|
//+------------------------------------------------------------------+
|
|
double CSymbol::TickValue(void)
|
|
{
|
|
return SymbolInfoDouble(m_symbol, SYMBOL_TRADE_TICK_VALUE);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| The size of one contract in the base contract units |
|
|
//+------------------------------------------------------------------+
|
|
double CSymbol::ContractSize(void)
|
|
{
|
|
return SymbolInfoDouble(m_symbol, SYMBOL_TRADE_CONTRACT_SIZE);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Minimum volume for deal execution in contracts |
|
|
//+------------------------------------------------------------------+
|
|
double CSymbol::VolumeContractMin(void)
|
|
{
|
|
return SymbolInfoDouble(m_symbol, SYMBOL_VOLUME_MIN);
|
|
}
|
|
//+-------------------------------------------------------------------+
|
|
//| Maximum volume for deal execution in contracts |
|
|
//+-------------------------------------------------------------------+
|
|
double CSymbol::VolumeContractMax(void)
|
|
{
|
|
return SymbolInfoDouble(m_symbol, SYMBOL_VOLUME_MAX);
|
|
}
|
|
//+-------------------------------------------------------------------+
|
|
//| The maximum allowed for this symbol total volume of an |
|
|
//| open position |
|
|
//+-------------------------------------------------------------------+
|
|
double CSymbol::VolumeContractLimit(void)
|
|
{
|
|
return SymbolInfoDouble(m_symbol, SYMBOL_VOLUME_LIMIT);
|
|
}
|
|
//+-------------------------------------------------------------------+
|
|
//| The minimum volume change step for deal execution |
|
|
//+-------------------------------------------------------------------+
|
|
double CSymbol::VolumeContractStep(void)
|
|
{
|
|
return SymbolInfoDouble(m_symbol, SYMBOL_VOLUME_STEP);
|
|
}
|
|
//+-------------------------------------------------------------------+
|
|
//| The value of swap charged for holding a long position with volume |
|
|
//| of one contract |
|
|
//+-------------------------------------------------------------------+
|
|
double CSymbol::SwapLong(void)
|
|
{
|
|
return SymbolInfoDouble(m_symbol, SYMBOL_SWAP_LONG);
|
|
}
|
|
//+-------------------------------------------------------------------+
|
|
//| The value of swap charged for holding a short position with volume|
|
|
//| of one contract |
|
|
//+-------------------------------------------------------------------+
|
|
double CSymbol::SwapShort(void)
|
|
{
|
|
return SymbolInfoDouble(m_symbol, SYMBOL_SWAP_SHORT);
|
|
}
|
|
//+-------------------------------------------------------------------+
|
|
//| The margin required to open a one-lot position |
|
|
//+-------------------------------------------------------------------+
|
|
double CSymbol::MarginInit(void)
|
|
{
|
|
return SymbolInfoDouble(m_symbol, SYMBOL_MARGIN_INITIAL);
|
|
}
|
|
//+-------------------------------------------------------------------+
|
|
//| The margin required to maintain one lot of an open position |
|
|
//+-------------------------------------------------------------------+
|
|
double CSymbol::MarginMaintenance(void)
|
|
{
|
|
return SymbolInfoDouble(m_symbol, SYMBOL_MARGIN_MAINTENANCE);
|
|
}
|
|
//+-------------------------------------------------------------------+
|
|
//| The margin required to maintain one lot of a hedged position |
|
|
//+-------------------------------------------------------------------+
|
|
double CSymbol::MarginHedged(void)
|
|
{
|
|
return SymbolInfoDouble(m_symbol, SYMBOL_MARGIN_HEDGED);
|
|
}
|
|
//+-------------------------------------------------------------------+
|
|
//| The name of the underlaying asset for a derivative symbol |
|
|
//+-------------------------------------------------------------------+
|
|
string CSymbol::NameBasisSymbol(void)
|
|
{
|
|
return SymbolInfoString(m_symbol, SYMBOL_BASIS);
|
|
}
|
|
//+-------------------------------------------------------------------+
|
|
//| The base currency of an instrument |
|
|
//+-------------------------------------------------------------------+
|
|
string CSymbol::NameBasisCurrency(void)
|
|
{
|
|
return SymbolInfoString(m_symbol, SYMBOL_CURRENCY_BASE);
|
|
}
|
|
//+-------------------------------------------------------------------+
|
|
//| Profit currency |
|
|
//+-------------------------------------------------------------------+
|
|
string CSymbol::NameCurrencyProfit(void)
|
|
{
|
|
return SymbolInfoString(m_symbol, SYMBOL_CURRENCY_PROFIT);
|
|
}
|
|
//+-------------------------------------------------------------------+
|
|
//| Margin currency |
|
|
//+-------------------------------------------------------------------+
|
|
string CSymbol::NameCurrencyMargin(void)
|
|
{
|
|
return SymbolInfoString(m_symbol, SYMBOL_CURRENCY_MARGIN);
|
|
}
|
|
//+-------------------------------------------------------------------+
|
|
//| The source of the current quote |
|
|
//+-------------------------------------------------------------------+
|
|
string CSymbol::NameBank(void)
|
|
{
|
|
return SymbolInfoString(m_symbol, SYMBOL_BANK);
|
|
}
|
|
//+-------------------------------------------------------------------+
|
|
//| The string description of a symbol |
|
|
//+-------------------------------------------------------------------+
|
|
string CSymbol::Description(void)
|
|
{
|
|
return SymbolInfoString(m_symbol, SYMBOL_DESCRIPTION);
|
|
}
|
|
//+-------------------------------------------------------------------+
|
|
//| The name of a trading symbol in the international |
|
|
//| system of securities identification numbers ISIN |
|
|
//+-------------------------------------------------------------------+
|
|
string CSymbol::NameISIN(void)
|
|
{
|
|
return SymbolInfoString(m_symbol, SYMBOL_ISIN);
|
|
}
|
|
//+-------------------------------------------------------------------+
|
|
//| Path in the symbol tree |
|
|
//+-------------------------------------------------------------------+
|
|
string CSymbol::SymbolPath(void)
|
|
{
|
|
return SymbolInfoString(m_symbol, SYMBOL_PATH);
|
|
} |