BeazCode/Include/MQL4/Trade/SymbolInfo.mqh

<EFBFBD><EFBFBD>//+------------------------------------------------------------------+
//|                                                   SymbolInfo.mqh |
//|                   Copyright 2009-2020, MetaQuotes Software Corp. |
//|                                              http://www.mql5.com |
//|                                      Copyright 2022, Yuriy Bykov |
//|                               https://www.mql5.com/ru/code/38861 |
//|                               https://www.mql5.com/en/code/39161 |
//+------------------------------------------------------------------+
#property copyright "Copyright 2022, Yuriy Bykov"
#property link      "https://www.mql5.com/ru/users/antekov"
#property version   "1.00"
#property strict

#include <Object.mqh>

enum ENUM_SYMBOL_EXPIRATION_MODE {
   SYMBOL_EXPIRATION_GTC = 1, // @45@ 459AB28B5;5= =5>3@0=8G5==> ?> 2@5<5=8 4> O2=>9 53> >B<5=K
   SYMBOL_EXPIRATION_DAY = 2, // @45@ 459AB28B5;5= 4> :>=F0 4=O
   SYMBOL_EXPIRATION_SPECIFIED = 4, // !@>: 8AB5G5=8O C:07K205BAO 2 >@45@5
   SYMBOL_EXPIRATION_SPECIFIED_DAY = 8, // 5=L 8AB5G5=8O C:07K205BAO 2 >@45@5
};

enum ENUM_SYMBOL_TYPE_FILLING {
   SYMBOL_FILLING_FOK = 1,
   SYMBOL_FILLING_IOC = 2,
   SYMBOL_FILLING_RETURN = 4
};

enum ENUM_SYMBOL_ORDER_MODE {
   SYMBOL_ORDER_MARKET = 1, //  07@5H5=K @K=>G=K5 >@45@0 (Buy 8 Sell)
   SYMBOL_ORDER_LIMIT = 2, //  07@5H5=K ;8<8B=K5 >@45@0 (Buy Limit 8 Sell Limit)
   SYMBOL_ORDER_STOP = 4, //  07@5H5=K AB>?->@45@0 (Buy Stop 8 Sell Stop)
   SYMBOL_ORDER_STOP_LIMIT = 8, //  07@5H5=K AB>?-;8<8B >@45@0 (Buy Stop Limit 8 Sell Stop Limit)
   SYMBOL_ORDER_SL = 16, //  07@5H5=0 CAB0=>2:0 Stop Loss
   SYMBOL_ORDER_TP = 32, //  07@5H5=0 CAB0=>2:0 Take Profit
   SYMBOL_ORDER_CLOSEBY = 64 //  07@5H5=85 =0 70:@KB85 ?>78F88 A ?><>ILN 2AB@5G=>9   B> 5ABL >B:@KB>9 2 ?@>B82>?>;>6=>< =0?@02;5=88 ?> B><C 65 8=AB@C<5=BC. !2>9AB2> 70405BAO 4;O AG5B>2 A E5468=3>2>9 A8AB5<>9 CG5B0
};

//+------------------------------------------------------------------+
//| Class CSymbolInfo.                                               |
//| Appointment: Class for access to symbol info.                    |
//|              Derives from class CObject.                         |
//+------------------------------------------------------------------+
class CSymbolInfo : public CObject {
protected:
   string            m_name;                       // symbol name
   MqlTick           m_tick;                       // structure of tick;
   double            m_point;                      // symbol point
   double            m_tick_value;                 // symbol tick value
   double            m_tick_value_profit;          // symbol tick value profit
   double            m_tick_value_loss;            // symbol tick value loss
   double            m_tick_size;                  // symbol tick size
   double            m_contract_size;              // symbol contract size
   double            m_lots_min;                   // symbol lots min
   double            m_lots_max;                   // symbol lots max
   double            m_lots_step;                  // symbol lots step
   double            m_lots_limit;                 // symbol lots limit
   double            m_swap_long;                  // symbol swap long
   double            m_swap_short;                 // symbol swap short
   int               m_digits;                     // symbol digits
   int               m_order_mode;                 // symbol valid orders
   ENUM_SYMBOL_TRADE_EXECUTION m_trade_execution;  // symbol trade execution
   //ENUM_SYMBOL_CALC_MODE m_trade_calcmode;         // symbol trade calcmode
   ENUM_SYMBOL_TRADE_MODE m_trade_mode;            // symbol trade mode
   int               m_swap_mode;                  // symbol swap mode
   ENUM_DAY_OF_WEEK  m_swap3;                      // symbol swap3
   double            m_margin_initial;             // symbol margin initial
   double            m_margin_maintenance;         // symbol margin maintenance
   bool              m_margin_hedged_use_leg;      // calculate hedged margin using larger leg
   double            m_margin_hedged;              // symbol margin hedged
   int               m_trade_time_flags;           // symbol trade time flags
   int               m_trade_fill_flags;           // symbol trade fill flags

public:
   CSymbolInfo(void);
   ~CSymbolInfo(void);
   //--- methods of access to protected data
   string            Name(void) const {
      return(m_name);
   }
   bool              Name(const string name);
   bool              Refresh(void);
   bool              RefreshRates(void);
   //--- fast access methods to the integer symbol propertyes
   bool              Select(void) const;
   bool              Select(const bool select);
   bool              IsSynchronized(void) const;
   //--- volumes
   ulong             Volume(void)     const {
      return(m_tick.volume);
   }
   ulong             VolumeHigh(void) const;
   ulong             VolumeLow(void)  const;
   //--- miscellaneous
   datetime          Time(void)           const {
      return(m_tick.time);
   }
   int               Spread(void)         const;
   bool              SpreadFloat(void)    const;
   int               TicksBookDepth(void) const;
   //--- trade levels
   int               StopsLevel(void)  const;
   int               FreezeLevel(void) const;
   //--- fast access methods to the double symbol propertyes
   //--- bid parameters
   double            Bid(void)      const {
      return(m_tick.bid);
   }
   double            BidHigh(void)  const;
   double            BidLow(void)   const;
   //--- ask parameters
   double            Ask(void)      const {
      return(m_tick.ask);
   }
   double            AskHigh(void)  const;
   double            AskLow(void)   const;
   //--- last parameters
   double            Last(void)     const {
      return(m_tick.last);
   }
   double            LastHigh(void) const;
   double            LastLow(void)  const;
   //--- fast access methods to the mix symbol propertyes
   int               OrderMode(void) const {
      return(m_order_mode);
   }
   //--- terms of trade
   //ENUM_SYMBOL_CALC_MODE TradeCalcMode(void)        const {
   //   return(m_trade_calcmode);
   //}
   string            TradeCalcModeDescription(void) const;
   ENUM_SYMBOL_TRADE_MODE TradeMode(void)           const {
      return(m_trade_mode);
   }
   string            TradeModeDescription(void)     const;
   //--- execution terms of trade
   ENUM_SYMBOL_TRADE_EXECUTION TradeExecution(void)  const {
      return(m_trade_execution);
   }
   string            TradeExecutionDescription(void) const;
   //--- swap terms of trade
   //ENUM_SYMBOL_SWAP_MODE SwapMode(void)                 const {
   //   return(m_swap_mode);
   //}
   string            SwapModeDescription(void)          const;
   ENUM_DAY_OF_WEEK  SwapRollover3days(void)            const {
      return(m_swap3);
   }
   string            SwapRollover3daysDescription(void) const;
   //--- dates for futures
   datetime          StartTime(void)      const;
   datetime          ExpirationTime(void) const;
   //--- margin parameters
   double            MarginInitial(void)      const {
      return(m_margin_initial);
   }
   double            MarginMaintenance(void)  const {
      return(m_margin_maintenance);
   }
   bool              MarginHedgedUseLeg(void) const {
      return(m_margin_hedged_use_leg);
   }
   double            MarginHedged(void)       const {
      return(m_margin_hedged);
   }
   //--- left for backward compatibility
   double            MarginLong(void)      const {
      return(0.0);
   }
   double            MarginShort(void)     const {
      return(0.0);
   }
   double            MarginLimit(void)     const {
      return(0.0);
   }
   double            MarginStop(void)      const {
      return(0.0);
   }
   double            MarginStopLimit(void) const {
      return(0.0);
   }
   //--- trade flags parameters
   int               TradeTimeFlags(void)  const {
      return(m_trade_time_flags);
   }
   int               TradeFillFlags(void)  const {
      return(m_trade_fill_flags);
   }
   //--- tick parameters
   int               Digits(void)          const {
      return(m_digits);
   }
   double            Point(void)           const {
      return(m_point);
   }
   double            TickValue(void)       const {
      return(m_tick_value);
   }
   double            TickValueProfit(void) const {
      return(m_tick_value_profit);
   }
   double            TickValueLoss(void)   const {
      return(m_tick_value_loss);
   }
   double            TickSize(void)        const {
      return(m_tick_size);
   }
   //--- lots parameters
   double            ContractSize(void) const {
      return(m_contract_size);
   }
   double            LotsMin(void)      const {
      return(m_lots_min);
   }
   double            LotsMax(void)      const {
      return(m_lots_max);
   }
   double            LotsStep(void)     const {
      return(m_lots_step);
   }
   double            LotsLimit(void)    const {
      return(m_lots_limit);
   }
   //--- swaps
   double            SwapLong(void)  const {
      return(m_swap_long);
   }
   double            SwapShort(void) const {
      return(m_swap_short);
   }
   //--- fast access methods to the string symbol propertyes
   string            CurrencyBase(void)   const;
   string            CurrencyProfit(void) const;
   string            CurrencyMargin(void) const;
   string            Bank(void)           const;
   string            Description(void)    const;
   string            Path(void)           const;
   //--- session information
   long              SessionDeals(void)            const;
   long              SessionBuyOrders(void)        const;
   long              SessionSellOrders(void)       const;
   double            SessionTurnover(void)         const;
   double            SessionInterest(void)         const;
   double            SessionBuyOrdersVolume(void)  const;
   double            SessionSellOrdersVolume(void) const;
   double            SessionOpen(void)             const;
   double            SessionClose(void)            const;
   double            SessionAW(void)               const;
   double            SessionPriceSettlement(void)  const;
   double            SessionPriceLimitMin(void)    const;
   double            SessionPriceLimitMax(void)    const;
   //--- access methods to the API MQL5 functions
   bool              InfoInteger(const ENUM_SYMBOL_INFO_INTEGER prop_id, long& var) const;
   bool              InfoDouble(const ENUM_SYMBOL_INFO_DOUBLE prop_id, double& var) const;
   bool              InfoString(const ENUM_SYMBOL_INFO_STRING prop_id, string& var) const;
   bool              InfoMarginRate(const ENUM_ORDER_TYPE order_type, double& initial_margin_rate, double& maintenance_margin_rate) const;
   //--- service methods
   double            NormalizePrice(const double price) const;
   bool              CheckMarketWatch(void);
};
//+------------------------------------------------------------------+
//| Constructor                                                      |
//+------------------------------------------------------------------+
CSymbolInfo::CSymbolInfo(void) : m_name(NULL),
   m_point(0.0),
   m_tick_value(0.0),
   m_tick_value_profit(0.0),
   m_tick_value_loss(0.0),
   m_tick_size(0.0),
   m_contract_size(0.0),
   m_lots_min(0.0),
   m_lots_max(0.0),
   m_lots_step(0.0),
   m_swap_long(0.0),
   m_swap_short(0.0),
   m_digits(0),
   m_order_mode(0),
   m_trade_execution(0),
   //m_trade_calcmode(0),
   m_trade_mode(0),
   m_swap_mode(0),
   m_swap3(0),
   m_margin_initial(0.0),
   m_margin_maintenance(0.0),
   m_margin_hedged_use_leg(false),
   m_margin_hedged(0.0),
   m_trade_time_flags(0),
   m_trade_fill_flags(0) {
}
//+------------------------------------------------------------------+
//| Destructor                                                       |
//+------------------------------------------------------------------+
CSymbolInfo::~CSymbolInfo(void) {
}
//+------------------------------------------------------------------+
//| Set name                                                         |
//+------------------------------------------------------------------+
bool CSymbolInfo::Name(const string name) {
   string symbol_name = StringLen(name) > 0 ? name : _Symbol;
//--- check previous set name
   if(m_name != symbol_name) {
      m_name = symbol_name;
      if(IsTesting() && symbol_name != _Symbol) {
         return(false);
      }
      //---
      if(!CheckMarketWatch())
         return(false);
      //---
      if(!Refresh()) {
         m_name = "";
         Print(__FUNCTION__ + ": invalid data of symbol '" + symbol_name + "'");
         return(false);
      }
   }
//--- succeed
   return(true);
}
//+------------------------------------------------------------------+
//| Refresh cached data                                              |
//+------------------------------------------------------------------+
bool CSymbolInfo::Refresh(void) {
   long tmp_long = 0;
//---
   if(!SymbolInfoDouble(m_name, SYMBOL_POINT, m_point))
      return(false);
   if(!SymbolInfoDouble(m_name, SYMBOL_TRADE_TICK_VALUE, m_tick_value))
      return(false);
   if(!SymbolInfoDouble(m_name, SYMBOL_TRADE_TICK_VALUE, m_tick_value_profit))
      return(false);
   if(!SymbolInfoDouble(m_name, SYMBOL_TRADE_TICK_VALUE, m_tick_value_loss))
      return(false);
   if(!SymbolInfoDouble(m_name, SYMBOL_TRADE_TICK_SIZE, m_tick_size))
      return(false);
   if(!SymbolInfoDouble(m_name, SYMBOL_TRADE_CONTRACT_SIZE, m_contract_size))
      return(false);
   if(!SymbolInfoDouble(m_name, SYMBOL_VOLUME_MIN, m_lots_min))
      return(false);
   if(!SymbolInfoDouble(m_name, SYMBOL_VOLUME_MAX, m_lots_max))
      return(false);
   if(!SymbolInfoDouble(m_name, SYMBOL_VOLUME_STEP, m_lots_step))
      return(false);
   //if(!SymbolInfoDouble(m_name, SYMBOL_VOLUME_LIMIT, m_lots_limit))
   //   return(false);
   m_lots_limit = 100000;
   if(!SymbolInfoDouble(m_name, SYMBOL_SWAP_LONG, m_swap_long))
      return(false);
   if(!SymbolInfoDouble(m_name, SYMBOL_SWAP_SHORT, m_swap_short))
      return(false);
   if(!SymbolInfoInteger(m_name, SYMBOL_DIGITS, tmp_long))
      return(false);
   m_digits = (int)tmp_long;
   //if(!SymbolInfoInteger(m_name, SYMBOL_ORDER_MODE, tmp_long))
   //   return(false);
   //m_order_mode = (int)tmp_long;
   if(!SymbolInfoInteger(m_name, SYMBOL_TRADE_EXEMODE, tmp_long))
      return(false);
   m_trade_execution = (ENUM_SYMBOL_TRADE_EXECUTION)tmp_long;
   //if(!SymbolInfoInteger(m_name, SYMBOL_TRADE_CALC_MODE, tmp_long))
   //   return(false);
   //m_trade_calcmode = (ENUM_SYMBOL_CALC_MODE)tmp_long;
   if(!SymbolInfoInteger(m_name, SYMBOL_TRADE_MODE, tmp_long))
      return(false);
   m_trade_mode = (ENUM_SYMBOL_TRADE_MODE)tmp_long;
   if(!SymbolInfoInteger(m_name, SYMBOL_SWAP_MODE, tmp_long))
      return(false);
   m_swap_mode = (int)tmp_long;
   if(!SymbolInfoInteger(m_name, SYMBOL_SWAP_ROLLOVER3DAYS, tmp_long))
      return(false);
   m_swap3 = (ENUM_DAY_OF_WEEK)tmp_long;
   if(!SymbolInfoDouble(m_name, SYMBOL_MARGIN_INITIAL, m_margin_initial))
      return(false);
   if(!SymbolInfoDouble(m_name, SYMBOL_MARGIN_MAINTENANCE, m_margin_maintenance))
      return(false);
   //if(!SymbolInfoDouble(m_name, SYMBOL_MARGIN_HEDGED, m_margin_hedged))
   //   return(false);
   //if(!SymbolInfoInteger(m_name, SYMBOL_MARGIN_HEDGED_USE_LEG, tmp_long))
   //   return(false);
   //m_margin_hedged_use_leg = (bool)tmp_long;
   //if(!SymbolInfoInteger(m_name, SYMBOL_EXPIRATION_MODE, tmp_long))
   //   return(false);
   //m_trade_time_flags = (int)tmp_long;
   //if(!SymbolInfoInteger(m_name, SYMBOL_FILLING_MODE, tmp_long))
   //   return(false);
   //m_trade_fill_flags = (int)tmp_long;
//--- succeed
   return(true);
}
//+------------------------------------------------------------------+
//| Refresh cached data                                              |
//+------------------------------------------------------------------+
bool CSymbolInfo::RefreshRates(void) {
   return(SymbolInfoTick(m_name, m_tick));
}
//+------------------------------------------------------------------+
//| Get the property value "SYMBOL_SELECT"                           |
//+------------------------------------------------------------------+
bool CSymbolInfo::Select(void) const {
   return((bool)SymbolInfoInteger(m_name, SYMBOL_SELECT));
}
//+------------------------------------------------------------------+
//| Set the property value "SYMBOL_SELECT"                           |
//+------------------------------------------------------------------+
bool CSymbolInfo::Select(const bool select) {
   return(SymbolSelect(m_name, select));
}
//+------------------------------------------------------------------+
//| Check synchronize symbol                                         |
//+------------------------------------------------------------------+
bool CSymbolInfo::IsSynchronized(void) const {
   return(SymbolIsSynchronized(m_name));
}
//+------------------------------------------------------------------+
//| Get the property value "SYMBOL_VOLUMEHIGH"                       |
//+------------------------------------------------------------------+
ulong CSymbolInfo::VolumeHigh(void) const {
   return(SymbolInfoInteger(m_name, SYMBOL_VOLUMEHIGH));
}
//+------------------------------------------------------------------+
//| Get the property value "SYMBOL_VOLUMELOW"                        |
//+------------------------------------------------------------------+
ulong CSymbolInfo::VolumeLow(void) const {
   return(SymbolInfoInteger(m_name, SYMBOL_VOLUMELOW));
}
//+------------------------------------------------------------------+
//| Get the property value "SYMBOL_SPREAD"                           |
//+------------------------------------------------------------------+
int CSymbolInfo::Spread(void) const {
   return((int)SymbolInfoInteger(m_name, SYMBOL_SPREAD));
}
//+------------------------------------------------------------------+
//| Get the property value "SYMBOL_SPREAD_FLOAT"                     |
//+------------------------------------------------------------------+
bool CSymbolInfo::SpreadFloat(void) const {
   return((bool)SymbolInfoInteger(m_name, SYMBOL_SPREAD_FLOAT));
}
//+------------------------------------------------------------------+
//| Get the property value "SYMBOL_TICKS_BOOKDEPTH"                  |
//+------------------------------------------------------------------+
int CSymbolInfo::TicksBookDepth(void) const {
   return((int)SymbolInfoInteger(m_name, SYMBOL_TICKS_BOOKDEPTH));
}
//+------------------------------------------------------------------+
//| Get the property value "SYMBOL_TRADE_STOPS_LEVEL"                |
//+------------------------------------------------------------------+
int CSymbolInfo::StopsLevel(void) const {
   return((int)SymbolInfoInteger(m_name, SYMBOL_TRADE_STOPS_LEVEL));
}
//+------------------------------------------------------------------+
//| Get the property value "SYMBOL_TRADE_FREEZE_LEVEL"               |
//+------------------------------------------------------------------+
int CSymbolInfo::FreezeLevel(void) const {
   return((int)SymbolInfoInteger(m_name, SYMBOL_TRADE_FREEZE_LEVEL));
}
//+------------------------------------------------------------------+
//| Get the property value "SYMBOL_BIDHIGH"                          |
//+------------------------------------------------------------------+
double CSymbolInfo::BidHigh(void) const {
   return(SymbolInfoDouble(m_name, SYMBOL_BIDHIGH));
}
//+------------------------------------------------------------------+
//| Get the property value "SYMBOL_BIDLOW"                           |
//+------------------------------------------------------------------+
double CSymbolInfo::BidLow(void) const {
   return(SymbolInfoDouble(m_name, SYMBOL_BIDLOW));
}
//+------------------------------------------------------------------+
//| Get the property value "SYMBOL_ASKHIGH"                          |
//+------------------------------------------------------------------+
double CSymbolInfo::AskHigh(void) const {
   return(SymbolInfoDouble(m_name, SYMBOL_ASKHIGH));
}
//+------------------------------------------------------------------+
//| Get the property value "SYMBOL_ASKLOW"                           |
//+------------------------------------------------------------------+
double CSymbolInfo::AskLow(void) const {
   return(SymbolInfoDouble(m_name, SYMBOL_ASKLOW));
}
//+------------------------------------------------------------------+
//| Get the property value "SYMBOL_LASTHIGH"                         |
//+------------------------------------------------------------------+
double CSymbolInfo::LastHigh(void) const {
   return(SymbolInfoDouble(m_name, SYMBOL_LASTHIGH));
}
//+------------------------------------------------------------------+
//| Get the property value "SYMBOL_LASTLOW"                          |
//+------------------------------------------------------------------+
double CSymbolInfo::LastLow(void) const {
   return(SymbolInfoDouble(m_name, SYMBOL_LASTLOW));
}
/*
//+------------------------------------------------------------------+
//| Get the property value "SYMBOL_TRADE_CALC_MODE" as string        |
//+------------------------------------------------------------------+
string CSymbolInfo::TradeCalcModeDescription(void) const {
   string str;
//---
   switch(m_trade_calcmode) {
   case SYMBOL_CALC_MODE_FOREX:
      str = "Calculation of profit and margin for Forex";
      break;
   case SYMBOL_CALC_MODE_CFD:
      str = "Calculation of collateral and earnings for CFD";
      break;
   case SYMBOL_CALC_MODE_FUTURES:
      str = "Calculation of collateral and profits for futures";
      break;
   case SYMBOL_CALC_MODE_CFDINDEX:
      str = "Calculation of collateral and earnings for CFD on indices";
      break;
   case SYMBOL_CALC_MODE_CFDLEVERAGE:
      str = "Calculation of collateral and earnings for the CFD when trading with leverage";
      break;
   case SYMBOL_CALC_MODE_EXCH_STOCKS:
      str = "Calculation for exchange stocks";
      break;
   case SYMBOL_CALC_MODE_EXCH_FUTURES:
      str = "Calculation for exchange futures";
      break;
   case SYMBOL_CALC_MODE_EXCH_FUTURES_FORTS:
      str = "Calculation for FORTS futures";
      break;
   default:
      str = "Unknown calculation mode";
   }
//--- result
   return(str);
}
*/
//+------------------------------------------------------------------+
//| Get the property value "SYMBOL_TRADE_MODE" as string             |
//+------------------------------------------------------------------+
string CSymbolInfo::TradeModeDescription(void) const {
   string str;
//---
   switch(m_trade_mode) {
   case SYMBOL_TRADE_MODE_DISABLED:
      str = "Disabled";
      break;
   case SYMBOL_TRADE_MODE_LONGONLY:
      str = "Long only";
      break;
   case SYMBOL_TRADE_MODE_SHORTONLY:
      str = "Short only";
      break;
   case SYMBOL_TRADE_MODE_CLOSEONLY:
      str = "Close only";
      break;
   case SYMBOL_TRADE_MODE_FULL:
      str = "Full access";
      break;
   default:
      str = "Unknown trade mode";
   }
//--- result
   return(str);
}
//+------------------------------------------------------------------+
//| Get the property value "SYMBOL_TRADE_EXEMODE" as string          |
//+------------------------------------------------------------------+
string CSymbolInfo::TradeExecutionDescription(void) const {
   string str;
//---
   switch(m_trade_execution) {
   case SYMBOL_TRADE_EXECUTION_REQUEST:
      str = "Trading on request";
      break;
   case SYMBOL_TRADE_EXECUTION_INSTANT:
      str = "Trading on live streaming prices";
      break;
   case SYMBOL_TRADE_EXECUTION_MARKET:
      str = "Execution of orders on the market";
      break;
   case SYMBOL_TRADE_EXECUTION_EXCHANGE:
      str = "Exchange execution";
      break;
   default:
      str = "Unknown trade execution";
   }
//--- result
   return(str);
}

/*
//+------------------------------------------------------------------+
//| Get the property value "SYMBOL_SWAP_MODE" as string              |
//+------------------------------------------------------------------+
string CSymbolInfo::SwapModeDescription(void) const {
   string str;
//---
   switch(m_swap_mode) {
   case SYMBOL_SWAP_MODE_DISABLED:
      str = "No swaps";
      break;
   case SYMBOL_SWAP_MODE_POINTS:
      str = "Swaps are calculated in points";
      break;
   case SYMBOL_SWAP_MODE_CURRENCY_SYMBOL:
      str = "Swaps are calculated in base currency";
      break;
   case SYMBOL_SWAP_MODE_CURRENCY_MARGIN:
      str = "Swaps are calculated in margin currency";
      break;
   case SYMBOL_SWAP_MODE_CURRENCY_DEPOSIT:
      str = "Swaps are calculated in deposit currency";
      break;
   case SYMBOL_SWAP_MODE_INTEREST_CURRENT:
      str = "Swaps are calculated as annual interest using the current price";
      break;
   case SYMBOL_SWAP_MODE_INTEREST_OPEN:
      str = "Swaps are calculated as annual interest using the open price";
      break;
   case SYMBOL_SWAP_MODE_REOPEN_CURRENT:
      str = "Swaps are charged by reopening positions at the close price";
      break;
   case SYMBOL_SWAP_MODE_REOPEN_BID:
      str = "Swaps are charged by reopening positions at the Bid price";
      break;
   default:
      str = "Unknown swap mode";
   }
//--- result
   return(str);
}
*/
//+------------------------------------------------------------------+
//| Get the property value "SYMBOL_SWAP_ROLLOVER3DAYS" as string     |
//+------------------------------------------------------------------+
string CSymbolInfo::SwapRollover3daysDescription(void) const {
   string str;
//---
   switch(m_swap3) {
   case SUNDAY:
      str = "Sunday";
      break;
   case MONDAY:
      str = "Monday";
      break;
   case TUESDAY:
      str = "Tuesday";
      break;
   case WEDNESDAY:
      str = "Wednesday";
      break;
   case THURSDAY:
      str = "Thursday";
      break;
   case FRIDAY:
      str = "Friday";
      break;
   case SATURDAY:
      str = "Saturday";
      break;
   default:
      str = "Unknown";
   }
//--- result
   return(str);
}
//+------------------------------------------------------------------+
//| Get the property value "SYMBOL_START_TIME"                       |
//+------------------------------------------------------------------+
datetime CSymbolInfo::StartTime(void) const {
   return((datetime)SymbolInfoInteger(m_name, SYMBOL_START_TIME));
}
//+------------------------------------------------------------------+
//| Get the property value "SYMBOL_EXPIRATION_TIME"                  |
//+------------------------------------------------------------------+
datetime CSymbolInfo::ExpirationTime(void) const {
   return((datetime)SymbolInfoInteger(m_name, SYMBOL_EXPIRATION_TIME));
}
//+------------------------------------------------------------------+
//| Get the property value "SYMBOL_CURRENCY_BASE"                    |
//+------------------------------------------------------------------+
string CSymbolInfo::CurrencyBase(void) const {
   return(SymbolInfoString(m_name, SYMBOL_CURRENCY_BASE));
}
//+------------------------------------------------------------------+
//| Get the property value "SYMBOL_CURRENCY_PROFIT"                  |
//+------------------------------------------------------------------+
string CSymbolInfo::CurrencyProfit(void) const {
   return(SymbolInfoString(m_name, SYMBOL_CURRENCY_PROFIT));
}
//+------------------------------------------------------------------+
//| Get the property value "SYMBOL_CURRENCY_MARGIN"                  |
//+------------------------------------------------------------------+
string CSymbolInfo::CurrencyMargin(void) const {
   return(SymbolInfoString(m_name, SYMBOL_CURRENCY_MARGIN));
}
//+------------------------------------------------------------------+
//| Get the property value "SYMBOL_BANK"                             |
//+------------------------------------------------------------------+
string CSymbolInfo::Bank(void) const {
   return(SymbolInfoString(m_name, SYMBOL_BANK));
}
//+------------------------------------------------------------------+
//| Get the property value "SYMBOL_DESCRIPTION"                      |
//+------------------------------------------------------------------+
string CSymbolInfo::Description(void) const {
   return(SymbolInfoString(m_name, SYMBOL_DESCRIPTION));
}
//+------------------------------------------------------------------+
//| Get the property value "SYMBOL_PATH"                             |
//+------------------------------------------------------------------+
string CSymbolInfo::Path(void) const {
   return(SymbolInfoString(m_name, SYMBOL_PATH));
}
//+------------------------------------------------------------------+
//| Get the property value "SYMBOL_SESSION_DEALS"                    |
//+------------------------------------------------------------------+
long CSymbolInfo::SessionDeals(void) const {
   return(SymbolInfoInteger(m_name, SYMBOL_SESSION_DEALS));
}
//+------------------------------------------------------------------+
//| Get the property value "SYMBOL_SESSION_BUY_ORDERS"               |
//+------------------------------------------------------------------+
long CSymbolInfo::SessionBuyOrders(void) const {
   return(SymbolInfoInteger(m_name, SYMBOL_SESSION_BUY_ORDERS));
}
//+------------------------------------------------------------------+
//| Get the property value "SYMBOL_SESSION_SELL_ORDERS"              |
//+------------------------------------------------------------------+
long CSymbolInfo::SessionSellOrders(void) const {
   return(SymbolInfoInteger(m_name, SYMBOL_SESSION_SELL_ORDERS));
}
//+------------------------------------------------------------------+
//| Get the property value "SYMBOL_SESSION_TURNOVER"                 |
//+------------------------------------------------------------------+
double CSymbolInfo::SessionTurnover(void) const {
   return(SymbolInfoDouble(m_name, SYMBOL_SESSION_TURNOVER));
}
//+------------------------------------------------------------------+
//| Get the property value "SYMBOL_SESSION_INTEREST"                 |
//+------------------------------------------------------------------+
double CSymbolInfo::SessionInterest(void) const {
   return(SymbolInfoDouble(m_name, SYMBOL_SESSION_INTEREST));
}
//+------------------------------------------------------------------+
//| Get the property value "SYMBOL_SESSION_BUY_ORDERS_VOLUME"        |
//+------------------------------------------------------------------+
double CSymbolInfo::SessionBuyOrdersVolume(void) const {
   return(SymbolInfoDouble(m_name, SYMBOL_SESSION_BUY_ORDERS_VOLUME));
}
//+------------------------------------------------------------------+
//| Get the property value "SYMBOL_SESSION_SELL_ORDERS_VOLUME"       |
//+------------------------------------------------------------------+
double CSymbolInfo::SessionSellOrdersVolume(void) const {
   return(SymbolInfoDouble(m_name, SYMBOL_SESSION_SELL_ORDERS_VOLUME));
}
//+------------------------------------------------------------------+
//| Get the property value "SYMBOL_SESSION_OPEN"                     |
//+------------------------------------------------------------------+
double CSymbolInfo::SessionOpen(void) const {
   return(SymbolInfoDouble(m_name, SYMBOL_SESSION_OPEN));
}
//+------------------------------------------------------------------+
//| Get the property value "SYMBOL_SESSION_CLOSE"                    |
//+------------------------------------------------------------------+
double CSymbolInfo::SessionClose(void) const {
   return(SymbolInfoDouble(m_name, SYMBOL_SESSION_CLOSE));
}
//+------------------------------------------------------------------+
//| Get the property value "SYMBOL_SESSION_AW"                       |
//+------------------------------------------------------------------+
double CSymbolInfo::SessionAW(void) const {
   return(SymbolInfoDouble(m_name, SYMBOL_SESSION_AW));
}
//+------------------------------------------------------------------+
//| Get the property value "SYMBOL_SESSION_PRICE_SETTLEMENT"         |
//+------------------------------------------------------------------+
double CSymbolInfo::SessionPriceSettlement(void) const {
   return(SymbolInfoDouble(m_name, SYMBOL_SESSION_PRICE_SETTLEMENT));
}
//+------------------------------------------------------------------+
//| Get the property value "SYMBOL_SESSION_PRICE_LIMIT_MIN"          |
//+------------------------------------------------------------------+
double CSymbolInfo::SessionPriceLimitMin(void) const {
   return(SymbolInfoDouble(m_name, SYMBOL_SESSION_PRICE_LIMIT_MIN));
}
//+------------------------------------------------------------------+
//| Get the property value "SYMBOL_SESSION_PRICE_LIMIT_MAX"          |
//+------------------------------------------------------------------+
double CSymbolInfo::SessionPriceLimitMax(void) const {
   return(SymbolInfoDouble(m_name, SYMBOL_SESSION_PRICE_LIMIT_MAX));
}
//+------------------------------------------------------------------+
//| Access functions SymbolInfoInteger(...)                          |
//+------------------------------------------------------------------+
bool CSymbolInfo::InfoInteger(const ENUM_SYMBOL_INFO_INTEGER prop_id, long &var) const {
   return(SymbolInfoInteger(m_name, prop_id, var));
}
//+------------------------------------------------------------------+
//| Access functions SymbolInfoDouble(...)                           |
//+------------------------------------------------------------------+
bool CSymbolInfo::InfoDouble(const ENUM_SYMBOL_INFO_DOUBLE prop_id, double &var) const {
   return(SymbolInfoDouble(m_name, prop_id, var));
}
//+------------------------------------------------------------------+
//| Access functions SymbolInfoString(...)                           |
//+------------------------------------------------------------------+
bool CSymbolInfo::InfoString(const ENUM_SYMBOL_INFO_STRING prop_id, string &var) const {
   return(SymbolInfoString(m_name, prop_id, var));
}

/*
//+------------------------------------------------------------------+
//| Access functions SymbolInfoMarginRate(...)                           |
//+------------------------------------------------------------------+
bool CSymbolInfo::InfoMarginRate(const ENUM_ORDER_TYPE order_type, double& initial_margin_rate, double& maintenance_margin_rate) const {
   return(SymbolInfoMarginRate(m_name, order_type, initial_margin_rate, maintenance_margin_rate));
}
*/
//+------------------------------------------------------------------+
//| Normalize price                                                  |
//+------------------------------------------------------------------+
double CSymbolInfo::NormalizePrice(const double price) const {
   if(m_tick_size != 0)
      return(NormalizeDouble(MathRound(price / m_tick_size) * m_tick_size, m_digits));
//---
   return(NormalizeDouble(price, m_digits));
}
//+------------------------------------------------------------------+
//| Checks if symbol is selected in the MarketWatch                  |
//| and adds symbol to the MarketWatch, if necessary                 |
//+------------------------------------------------------------------+
bool CSymbolInfo::CheckMarketWatch(void) {
//--- check if symbol is selected in the MarketWatch
   if(!Select()) {
      if(!Select(true)) {
         if(!IsTesting()) {
            printf(__FUNCTION__ + ": Error adding symbol %d", GetLastError());
            return(false);
         }
      }
   }
//--- succeed
   return(true);
}
//+------------------------------------------------------------------+