2144 lines
47 KiB
Plaintext
2144 lines
47 KiB
Plaintext
///////////////////////////////////////////////////////
|
|
//
|
|
// SaherElm IT Center MQL5 Class Library
|
|
// ----------------------------------------------
|
|
// Name: XSC121Provider
|
|
// Description: provides all Base Provider
|
|
// requirements For X121 ...
|
|
//
|
|
//
|
|
// Maintainer:
|
|
// ------------
|
|
// Hadi Khazaee Asl (hadi_khazaee_asl@yahoo.com)
|
|
//
|
|
//////////////////////////////////////////////////////
|
|
//
|
|
// Global Properties ...
|
|
#property library
|
|
#property copyright "Copyright 2023, SaherElm IT Center"
|
|
#property link "https://www.saherelm.ir"
|
|
#property version "1.00"
|
|
#property strict
|
|
|
|
//
|
|
// Imports ...
|
|
|
|
//
|
|
#include "../Helpers/x-saherelm.xcc.helper.mq5"
|
|
#include "../Helpers/x-saherelm.xct.helper.mq5"
|
|
#include "../Helpers/x-saherelm.xmc.helper.mq5"
|
|
#include "../Helpers/x-saherelm.xdon.helper.mq5"
|
|
#include "../Helpers/x-saherelm.xzg.helper.mq5"
|
|
#include "../Helpers/x-saherelm.xpv.helper.mq5"
|
|
#include "../Helpers/x-saherelm.xstr.helper.mq5"
|
|
#include "../Helpers/x-saherelm.xche.helper.mq5"
|
|
#include "../Helpers/x-saherelm.xosc.helper.mq5"
|
|
|
|
//
|
|
#include "../Classes/x-saherelm.xprovider.class.mq5"
|
|
#include "../Classes/x-saherelm.x121.xmcycle.class.mq5"
|
|
|
|
//
|
|
// Definitions ...
|
|
|
|
//
|
|
// Signallers ...
|
|
enum ENUM_X121_SIGNAL_PROVIDERS
|
|
{
|
|
//
|
|
NONE,
|
|
XSP,
|
|
XTEST,
|
|
X786,
|
|
X121,
|
|
X110,
|
|
X92,
|
|
};
|
|
|
|
//
|
|
// X121 Provider Inputs ...
|
|
class X121ProviderInputs : public XSCBaseProviderInpts
|
|
{
|
|
//
|
|
// Public ...
|
|
public:
|
|
//
|
|
// Props ...
|
|
|
|
//
|
|
string symbol;
|
|
ENUM_TIMEFRAMES period;
|
|
|
|
//
|
|
// S Market ...
|
|
ENUM_TIMEFRAMES sMarketPeriod; // Short Market Period
|
|
ENUM_X_PERIOD_METHOD sMarketMethod; // Short Market Period Method
|
|
string sMarketPrefix; // Short Market Prefix
|
|
|
|
//
|
|
// MEDIUM Market ...
|
|
ENUM_TIMEFRAMES mMarketPeriod; // Medium Market Period
|
|
ENUM_X_PERIOD_METHOD mMarketMethod; // Medium Market Period Method
|
|
string mMarketPrefix; // Medium Market Prefix
|
|
|
|
//
|
|
// LONG Market ...
|
|
ENUM_TIMEFRAMES lMarketPeriod; // Long Market Period
|
|
ENUM_X_PERIOD_METHOD lMarketMethod; // Long Market Period Method
|
|
string lMarketPrefix; // Long Market Prefix
|
|
|
|
//
|
|
// HIND Market ...
|
|
ENUM_TIMEFRAMES hMarketPeriod; // Hind Market Period
|
|
ENUM_X_PERIOD_METHOD hMarketMethod; // Hind Market Period Method
|
|
string hMarketPrefix; // Hind Market Prefix
|
|
|
|
//
|
|
// Indicators ...
|
|
XCCInputs ccInputs;
|
|
XCTInputs ctInputs;
|
|
XZGInputs zgInputs;
|
|
XPVInputs pvInputs;
|
|
XMCInputs mcInputs;
|
|
XICHInputs ichInputs;
|
|
XCHEInputs cheInputs;
|
|
XSTRInputs strInputs;
|
|
XDONInputs donInputs;
|
|
XOSCInputs oscInputs;
|
|
|
|
//
|
|
X121MCycleInputs cMarketInputs; // Curent Market Inputs
|
|
X121MCycleInputs sMarketInputs; // Short Market Inputs
|
|
X121MCycleInputs mMarketInputs; // Medium Market Inputs
|
|
X121MCycleInputs lMarketInputs; // Long Market Inputs
|
|
X121MCycleInputs hMarketInputs; // Hind Market Inputs
|
|
|
|
//
|
|
// Tools ...
|
|
|
|
//
|
|
// Initialize Input ...
|
|
bool Init()
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
// Validate Base Requirements ...
|
|
result =
|
|
//
|
|
IsSpecifiedValid(symbol) &&
|
|
IsSpecifiedValid(period) &&
|
|
IsSpecifiedValid(sMarketMethod, sMarketPeriod) &&
|
|
IsSpecifiedValid(mMarketMethod, mMarketPeriod) &&
|
|
IsSpecifiedValid(lMarketMethod, lMarketPeriod) &&
|
|
IsSpecifiedValid(hMarketMethod, hMarketPeriod)
|
|
//
|
|
;
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
if (!zgInputs.IsValid())
|
|
{
|
|
zgInputs.Default();
|
|
}
|
|
if (!pvInputs.IsValid())
|
|
{
|
|
pvInputs.Default();
|
|
}
|
|
if (!mcInputs.IsValid())
|
|
{
|
|
mcInputs.Default();
|
|
}
|
|
if (!cheInputs.IsValid())
|
|
{
|
|
cheInputs.Default();
|
|
}
|
|
if (!strInputs.IsValid())
|
|
{
|
|
strInputs.Default();
|
|
}
|
|
if (!donInputs.IsValid())
|
|
{
|
|
donInputs.Default();
|
|
}
|
|
if (!oscInputs.IsValid())
|
|
{
|
|
oscInputs.Default();
|
|
}
|
|
if (!ichInputs.IsValid())
|
|
{
|
|
ichInputs.Default();
|
|
}
|
|
|
|
// //
|
|
// if (!cMarketInputs.IsValid())
|
|
// {
|
|
// cMarketInputs.Default();
|
|
// }
|
|
// if (!sMarketInputs.IsValid())
|
|
// {
|
|
// sMarketInputs.Default();
|
|
// }
|
|
// if (!mMarketInputs.IsValid())
|
|
// {
|
|
// mMarketInputs.Default();
|
|
// }
|
|
// if (!lMarketInputs.IsValid())
|
|
// {
|
|
// lMarketInputs.Default();
|
|
// }
|
|
// if (!hMarketInputs.IsValid())
|
|
// {
|
|
// hMarketInputs.Default();
|
|
// }
|
|
|
|
//
|
|
// Initialize Market Inputs ...
|
|
|
|
//
|
|
// Current ...
|
|
cMarketInputs.mcInputs = this.mcInputs;
|
|
cMarketInputs.strInputs = this.strInputs;
|
|
cMarketInputs.oscInputs = this.oscInputs;
|
|
cMarketInputs.cheInputs = this.cheInputs;
|
|
cMarketInputs.ichInputs = this.ichInputs;
|
|
result = cMarketInputs.Init(
|
|
this.symbol,
|
|
this.period,
|
|
X_MARKET_CYCLE_SHORT,
|
|
this.period,
|
|
X_PERIOD_MANUALLY,
|
|
"HOST",
|
|
false //
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Short ...
|
|
sMarketInputs.mcInputs = this.mcInputs;
|
|
sMarketInputs.strInputs = this.strInputs;
|
|
sMarketInputs.oscInputs = this.oscInputs;
|
|
sMarketInputs.cheInputs = this.cheInputs;
|
|
sMarketInputs.ichInputs = this.ichInputs;
|
|
result = sMarketInputs.Init(
|
|
this.symbol,
|
|
this.period,
|
|
X_MARKET_CYCLE_SHORT,
|
|
this.sMarketPeriod,
|
|
this.sMarketMethod,
|
|
this.sMarketPrefix,
|
|
false //
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Medium ...
|
|
mMarketInputs.mcInputs = this.mcInputs;
|
|
mMarketInputs.strInputs = this.strInputs;
|
|
mMarketInputs.oscInputs = this.oscInputs;
|
|
mMarketInputs.cheInputs = this.cheInputs;
|
|
mMarketInputs.ichInputs = this.ichInputs;
|
|
result = mMarketInputs.Init(
|
|
this.symbol,
|
|
this.period,
|
|
X_MARKET_CYCLE_MEDIUM,
|
|
this.mMarketPeriod,
|
|
this.mMarketMethod,
|
|
this.mMarketPrefix,
|
|
false //
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Long ...
|
|
lMarketInputs.mcInputs = this.mcInputs;
|
|
lMarketInputs.strInputs = this.strInputs;
|
|
lMarketInputs.oscInputs = this.oscInputs;
|
|
lMarketInputs.cheInputs = this.cheInputs;
|
|
lMarketInputs.ichInputs = this.ichInputs;
|
|
result = lMarketInputs.Init(
|
|
this.symbol,
|
|
this.period,
|
|
X_MARKET_CYCLE_LONG,
|
|
this.lMarketPeriod,
|
|
this.lMarketMethod,
|
|
this.lMarketPrefix,
|
|
false //
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Hind ...
|
|
hMarketInputs.mcInputs = this.mcInputs;
|
|
hMarketInputs.strInputs = this.strInputs;
|
|
hMarketInputs.oscInputs = this.oscInputs;
|
|
hMarketInputs.cheInputs = this.cheInputs;
|
|
hMarketInputs.ichInputs = this.ichInputs;
|
|
result = hMarketInputs.Init(
|
|
this.symbol,
|
|
this.period,
|
|
X_MARKET_CYCLE_HIND,
|
|
this.hMarketPeriod,
|
|
this.hMarketMethod,
|
|
this.hMarketPrefix,
|
|
false //
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
result = IsValid();
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Validate Input ...
|
|
bool IsValid() override
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
result =
|
|
//
|
|
//
|
|
IsSpecifiedValid(symbol) &&
|
|
IsSpecifiedValid(period) &&
|
|
IsSpecifiedValid(sMarketMethod, sMarketPeriod) &&
|
|
IsSpecifiedValid(mMarketMethod, mMarketPeriod) &&
|
|
IsSpecifiedValid(lMarketMethod, lMarketPeriod) &&
|
|
IsSpecifiedValid(hMarketMethod, hMarketPeriod) &&
|
|
//
|
|
ccInputs.IsValid() &&
|
|
ctInputs.IsValid() &&
|
|
zgInputs.IsValid() &&
|
|
pvInputs.IsValid() &&
|
|
mcInputs.IsValid() &&
|
|
cheInputs.IsValid() &&
|
|
strInputs.IsValid() &&
|
|
donInputs.IsValid() &&
|
|
oscInputs.IsValid() &&
|
|
ichInputs.IsValid() &&
|
|
//
|
|
cMarketInputs.IsValid() &&
|
|
sMarketInputs.IsValid() &&
|
|
mMarketInputs.IsValid() &&
|
|
lMarketInputs.IsValid() &&
|
|
hMarketInputs.IsValid()
|
|
//
|
|
;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Cleanup ...
|
|
void Clean() override
|
|
{
|
|
//
|
|
symbol = NULL;
|
|
period = NULL;
|
|
|
|
//
|
|
sMarketPeriod = NULL;
|
|
sMarketMethod = X_PERIOD_NOTHING;
|
|
sMarketPrefix = NULL;
|
|
|
|
//
|
|
mMarketPeriod = NULL;
|
|
mMarketMethod = X_PERIOD_NOTHING;
|
|
mMarketPrefix = NULL;
|
|
|
|
//
|
|
lMarketPeriod = NULL;
|
|
lMarketMethod = X_PERIOD_NOTHING;
|
|
lMarketPrefix = NULL;
|
|
|
|
//
|
|
hMarketPeriod = NULL;
|
|
hMarketMethod = X_PERIOD_NOTHING;
|
|
hMarketPrefix = NULL;
|
|
|
|
//
|
|
ccInputs.Clean();
|
|
ctInputs.Clean();
|
|
zgInputs.Clean();
|
|
pvInputs.Clean();
|
|
mcInputs.Clean();
|
|
cheInputs.Clean();
|
|
strInputs.Clean();
|
|
donInputs.Clean();
|
|
oscInputs.Clean();
|
|
ichInputs.Clean();
|
|
//
|
|
cMarketInputs.Clean();
|
|
sMarketInputs.Clean();
|
|
mMarketInputs.Clean();
|
|
lMarketInputs.Clean();
|
|
hMarketInputs.Clean();
|
|
}
|
|
|
|
//
|
|
// Default ...
|
|
void Default() override
|
|
{
|
|
//
|
|
symbol = NULL;
|
|
period = NULL;
|
|
|
|
//
|
|
sMarketPeriod = NULL;
|
|
sMarketMethod = X_PERIOD_AUTO;
|
|
sMarketPrefix = NULL;
|
|
|
|
//
|
|
mMarketPeriod = NULL;
|
|
mMarketMethod = X_PERIOD_AUTO;
|
|
mMarketPrefix = NULL;
|
|
|
|
//
|
|
lMarketPeriod = NULL;
|
|
lMarketMethod = X_PERIOD_AUTO;
|
|
lMarketPrefix = NULL;
|
|
|
|
//
|
|
hMarketPeriod = NULL;
|
|
hMarketMethod = X_PERIOD_AUTO;
|
|
hMarketPrefix = NULL;
|
|
|
|
//
|
|
ccInputs.Default();
|
|
ctInputs.Default();
|
|
zgInputs.Default();
|
|
pvInputs.Default();
|
|
mcInputs.Default();
|
|
cheInputs.Default();
|
|
strInputs.Default();
|
|
donInputs.Default();
|
|
oscInputs.Default();
|
|
ichInputs.Default();
|
|
cMarketInputs.Default();
|
|
sMarketInputs.Default();
|
|
mMarketInputs.Default();
|
|
lMarketInputs.Default();
|
|
hMarketInputs.Default();
|
|
}
|
|
|
|
//
|
|
// Max ...
|
|
int Max() override
|
|
{
|
|
//
|
|
int result = 0;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Set Symbol ...
|
|
bool SetSymbol(string value)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
result = IsSpecifiedValid(value);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
symbol = value;
|
|
cMarketInputs.cycle.symbol = value;
|
|
sMarketInputs.cycle.symbol = value;
|
|
mMarketInputs.cycle.symbol = value;
|
|
lMarketInputs.cycle.symbol = value;
|
|
hMarketInputs.cycle.symbol = value;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Set Period ...
|
|
bool SetPeriod(ENUM_TIMEFRAMES value)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
result = IsSpecifiedValid(value);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
period = value;
|
|
cMarketInputs.cycle.period = value;
|
|
sMarketInputs.cycle.period = value;
|
|
mMarketInputs.cycle.period = value;
|
|
lMarketInputs.cycle.period = value;
|
|
hMarketInputs.cycle.period = value;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
};
|
|
|
|
//
|
|
// X121 Provider Market Conditions ...
|
|
class X121MarketConditions : public XSCBaseProviderMarketConditions
|
|
{
|
|
//
|
|
// Public ...
|
|
public:
|
|
//
|
|
string symbol; // Symbol
|
|
ENUM_TIMEFRAMES period; // Period
|
|
datetime time; // Time
|
|
|
|
//
|
|
X121MCycleConditions cMarketConditions; // Current Market Conditions
|
|
X121MCycleConditions sMarketConditions; // Short Market Conditions
|
|
X121MCycleConditions mMarketConditions; // Medium Market Conditions
|
|
X121MCycleConditions lMarketConditions; // Long Market Conditions
|
|
X121MCycleConditions hMarketConditions; // Hind Market Conditions
|
|
|
|
//
|
|
// Tools ...
|
|
|
|
//
|
|
// Cleanup ...
|
|
void Clear()
|
|
{
|
|
//
|
|
symbol = NULL;
|
|
period = NULL;
|
|
|
|
//
|
|
cMarketConditions.Clear();
|
|
sMarketConditions.Clear();
|
|
mMarketConditions.Clear();
|
|
lMarketConditions.Clear();
|
|
hMarketConditions.Clear();
|
|
}
|
|
|
|
//
|
|
void GenerateScore(
|
|
double &bullishScore, // Bullish Score
|
|
double &bearishScore, // Bearish Score
|
|
double cMarketMultiplier = 1, // Current Market Score Multiplier
|
|
double sMarketMultiplier = 1.1, // Short Market Score Multiplier
|
|
double mMarketMultiplier = 1.2, // Medium Market Score Multiplier
|
|
double lMarketMultiplier = 1.3, // Long Market Score Multiplier
|
|
double hMarketMultiplier = 1.4 // Hind Market Score Multiplier
|
|
)
|
|
{
|
|
//
|
|
// Current Market ...
|
|
double cMarketBullScore = 0;
|
|
double cMarketBearScore = 0;
|
|
cMarketConditions.GenerateScore(
|
|
cMarketBullScore,
|
|
cMarketBearScore,
|
|
cMarketMultiplier //
|
|
);
|
|
|
|
//
|
|
// Short Market ...
|
|
double sMarketBullScore = 0;
|
|
double sMarketBearScore = 0;
|
|
sMarketConditions.GenerateScore(
|
|
sMarketBullScore,
|
|
sMarketBearScore,
|
|
sMarketMultiplier //
|
|
);
|
|
|
|
//
|
|
// Medium Market ...
|
|
double mMarketBullScore = 0;
|
|
double mMarketBearScore = 0;
|
|
mMarketConditions.GenerateScore(
|
|
mMarketBullScore,
|
|
mMarketBearScore,
|
|
mMarketMultiplier //
|
|
);
|
|
|
|
//
|
|
// Long Market ...
|
|
double lMarketBullScore = 0;
|
|
double lMarketBearScore = 0;
|
|
lMarketConditions.GenerateScore(
|
|
lMarketBullScore,
|
|
lMarketBearScore,
|
|
lMarketMultiplier //
|
|
);
|
|
|
|
//
|
|
// Hind Market ...
|
|
double hMarketBullScore = 0;
|
|
double hMarketBearScore = 0;
|
|
hMarketConditions.GenerateScore(
|
|
hMarketBullScore,
|
|
hMarketBearScore,
|
|
hMarketMultiplier //
|
|
);
|
|
|
|
//
|
|
// Calculate Summary Scores ...
|
|
|
|
//
|
|
bullishScore =
|
|
//
|
|
cMarketBullScore +
|
|
sMarketBullScore +
|
|
mMarketBullScore +
|
|
lMarketBullScore +
|
|
hMarketBullScore
|
|
//
|
|
;
|
|
|
|
//
|
|
bearishScore =
|
|
//
|
|
cMarketBearScore +
|
|
sMarketBearScore +
|
|
mMarketBearScore +
|
|
lMarketBearScore +
|
|
hMarketBearScore
|
|
//
|
|
;
|
|
}
|
|
|
|
//
|
|
string GenerateSummary(
|
|
double cMarketMultiplier = 1, // Current Market Score Multiplier
|
|
double sMarketMultiplier = 1.1, // Short Market Score Multiplier
|
|
double mMarketMultiplier = 1.2, // Medium Market Score Multiplier
|
|
double lMarketMultiplier = 1.3, // Long Market Score Multiplier
|
|
double hMarketMultiplier = 1.4, // Hind Market Score Multiplier
|
|
const string separator = "\n", // Separator
|
|
string provided = NULL, // Additional Info about Type, Provider and Symbol
|
|
const bool ignoreFalseConditions = true // Ignore False Conditions
|
|
)
|
|
{
|
|
//
|
|
string result = NULL;
|
|
|
|
//
|
|
double bullScore = 0;
|
|
double bearScore = 0;
|
|
GenerateScore(
|
|
bullScore,
|
|
bearScore,
|
|
cMarketMultiplier,
|
|
sMarketMultiplier,
|
|
mMarketMultiplier,
|
|
lMarketMultiplier,
|
|
hMarketMultiplier //
|
|
);
|
|
|
|
//
|
|
string commonStr =
|
|
//
|
|
"Commons: " + separator +
|
|
"-----------------------------" + separator +
|
|
"Symbol: " + symbol + separator +
|
|
"Period: " + ToString(period) + separator +
|
|
"Time: " + ToString(TimeCurrent()) + separator +
|
|
"-----------" + separator +
|
|
"Cycles: " + separator +
|
|
"-----------" + separator +
|
|
sMarketConditions.GetTitle() + separator +
|
|
mMarketConditions.GetTitle() + separator +
|
|
lMarketConditions.GetTitle() + separator +
|
|
hMarketConditions.GetTitle() + separator +
|
|
"Scores: " + separator +
|
|
"-----------" + separator +
|
|
"Bullish: " + ToString(bullScore) + separator +
|
|
"Bearish: " + ToString(bearScore) + separator +
|
|
"-----------------------------" + separator +
|
|
//
|
|
// TODO: Add Scores Later ...
|
|
separator +
|
|
""
|
|
//
|
|
;
|
|
|
|
//
|
|
result =
|
|
//
|
|
"[" + GetToken() + "]" + separator +
|
|
(IsSpecifiedValid(provided) ? provided + separator : "") +
|
|
"-----------------------------" + separator +
|
|
commonStr +
|
|
""
|
|
//
|
|
;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
};
|
|
|
|
//
|
|
// Class ...
|
|
|
|
//
|
|
// X121 Provider Class ...
|
|
class XSCX121Provider : public XSCBaseProvider
|
|
{
|
|
//
|
|
// Public ...
|
|
public:
|
|
//
|
|
// Props ...
|
|
|
|
//
|
|
XSCXCCHelper *ccHelper; // Candle Clear
|
|
XSCXCTHelper *ctHelper; // Candle Timer
|
|
XSCXZGHelper *zgHelper; // ZigZag Helper
|
|
XSCXPVHelper *pvHelper; // Peaks and Vales Helper
|
|
XSCXDONHelper *donHelper; // Donchain Helper;
|
|
|
|
//
|
|
XSCX121Market *cMarket; // Current Market
|
|
XSCX121Market *sMarket; // Short Market
|
|
XSCX121Market *mMarket; // Medium Market
|
|
XSCX121Market *lMarket; // Long Market
|
|
XSCX121Market *hMarket; // Hind Market
|
|
|
|
//
|
|
// Constructor ...
|
|
XSCX121Provider(
|
|
string symbol, // Trading Symbol
|
|
ENUM_TIMEFRAMES period // Trading PEriod
|
|
) : XSCBaseProvider(symbol, period)
|
|
{
|
|
//
|
|
ccHelper = new XSCXCCHelper();
|
|
ctHelper = new XSCXCTHelper();
|
|
|
|
//
|
|
// Instantiate Helpers Classes ...
|
|
zgHelper = new XSCXZGHelper();
|
|
pvHelper = new XSCXPVHelper();
|
|
donHelper = new XSCXDONHelper();
|
|
|
|
//
|
|
// Instantiate X121 Market Cycles Classes ...
|
|
cMarket = new XSCX121Market();
|
|
sMarket = new XSCX121Market();
|
|
mMarket = new XSCX121Market();
|
|
lMarket = new XSCX121Market();
|
|
hMarket = new XSCX121Market();
|
|
|
|
//
|
|
mNumberOfItems = 15;
|
|
}
|
|
|
|
//
|
|
// Properties Gettr(s) / Setter(s) ...
|
|
|
|
//
|
|
// Overrides ...
|
|
|
|
//
|
|
// DeInit all Requirements ...
|
|
void DeInit() override
|
|
{
|
|
//
|
|
delete ccHelper;
|
|
delete ctHelper;
|
|
|
|
//
|
|
delete zgHelper;
|
|
delete pvHelper;
|
|
delete donHelper;
|
|
|
|
//
|
|
delete cMarket;
|
|
delete sMarket;
|
|
delete mMarket;
|
|
delete lMarket;
|
|
delete hMarket;
|
|
}
|
|
|
|
//
|
|
// Functions ...
|
|
|
|
//
|
|
// Init all Requirements ...
|
|
bool Init(X121ProviderInputs &inputs)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
// Validate ...
|
|
result = inputs.IsValid();
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
mInputs = inputs;
|
|
|
|
//
|
|
string mSymbol = GetSymbol();
|
|
ENUM_TIMEFRAMES mPeriod = GetPeriod();
|
|
|
|
//
|
|
// Init Indicators Helpers ...
|
|
|
|
//
|
|
// CT ...
|
|
result = ctHelper
|
|
.Init(
|
|
mSymbol,
|
|
mPeriod,
|
|
mInputs.ctInputs
|
|
//
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// CC ...
|
|
result = ccHelper
|
|
.Init(
|
|
mSymbol,
|
|
mPeriod,
|
|
mInputs.ccInputs
|
|
//
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// ZigZag ...
|
|
result = zgHelper
|
|
.Init(
|
|
mSymbol,
|
|
mPeriod,
|
|
mInputs.zgInputs
|
|
//
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// PV ...
|
|
result = pvHelper
|
|
.Init(
|
|
mSymbol,
|
|
mPeriod,
|
|
mInputs.pvInputs
|
|
//
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// DON ...
|
|
result = donHelper
|
|
.Init(
|
|
mSymbol,
|
|
mPeriod,
|
|
mInputs.donInputs
|
|
//
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Initialize X121 Market Cycles ...
|
|
|
|
//
|
|
// Current Market ...
|
|
result = cMarket
|
|
.Init(mInputs.cMarketInputs);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Short Market ...
|
|
result = sMarket
|
|
.Init(mInputs.sMarketInputs);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Medium Market ...
|
|
result = mMarket
|
|
.Init(mInputs.mMarketInputs);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Long Market ...
|
|
result = lMarket
|
|
.Init(mInputs.lMarketInputs);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Hind Market ...
|
|
result = hMarket
|
|
.Init(mInputs.hMarketInputs);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Set Default Position's Type ...
|
|
// Enable / Disable Long (Buy), Short (Sell) ...
|
|
void SetSignalTypeState(
|
|
ENUM_POSITION_TYPE type, // Which types are Signals be Targetted
|
|
bool state // Which State is going to Set
|
|
)
|
|
{
|
|
//
|
|
if (IsLong(type))
|
|
{
|
|
mIsLongEnable = state;
|
|
}
|
|
else
|
|
{
|
|
mIsShortEnable = state;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Set Signal Providers ...
|
|
void SetSignalProviderState(
|
|
ENUM_X121_SIGNAL_PROVIDERS provider, // Provider State
|
|
bool state // Which state is going to set ...
|
|
)
|
|
{
|
|
//
|
|
if (provider == NONE)
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
switch (provider)
|
|
{
|
|
//
|
|
case XSP:
|
|
mIsXSPSignalProviderEnable = state;
|
|
break;
|
|
|
|
//
|
|
case XTEST:
|
|
mIsXTESTSignalProviderEnable = state;
|
|
break;
|
|
|
|
//
|
|
case X786:
|
|
mIsX786SignalProviderEnable = state;
|
|
break;
|
|
|
|
//
|
|
case X121:
|
|
mIsX121SignalProviderEnable = state;
|
|
break;
|
|
|
|
//
|
|
case X110:
|
|
mIsX110SignalProviderEnable = state;
|
|
break;
|
|
|
|
//
|
|
case X92:
|
|
mIsX92SignalProviderEnable = state;
|
|
break;
|
|
}
|
|
}
|
|
|
|
//
|
|
void SetSignalProviderStates(
|
|
ENUM_X121_SIGNAL_PROVIDERS &providers[], // Collection of Providers ...
|
|
bool state // Which state is going to set ...
|
|
)
|
|
{
|
|
//
|
|
int providersCount = ArraySize(providers);
|
|
if (providersCount <= 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
for (int i = 0; i < providersCount; i++)
|
|
{
|
|
SetSignalProviderState(providers[i], state);
|
|
}
|
|
}
|
|
|
|
//
|
|
string GetTag()
|
|
{
|
|
//
|
|
string result = NULL;
|
|
|
|
//
|
|
result =
|
|
//
|
|
GetToken() +
|
|
"[" +
|
|
GetSymbol() +
|
|
"," +
|
|
ToString(GetPeriod()) +
|
|
"]"
|
|
//
|
|
;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
void GetMarketConditions(
|
|
X121MarketConditions &mConditions, // Market Conditions Result
|
|
int barIndex = 0 // Specified Bar Index
|
|
)
|
|
{
|
|
//
|
|
mConditions.Clear();
|
|
|
|
//
|
|
CalculateConditions(mConditions, barIndex);
|
|
}
|
|
|
|
//
|
|
// Check Market For Signal ...
|
|
bool HasSignal(
|
|
int barIndex,
|
|
XSignal &mSignal, // Hold's Signal if Exists ...
|
|
X121MarketConditions &mConditions // Hold's Market Conditions ...
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
// Validate Enable Process ...
|
|
result = !CanIgnoreProcess();
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
mWaitsUntilNewBar = false;
|
|
|
|
//
|
|
// Validate Enable Type of Signalling ...
|
|
result = mIsLongEnable || mIsShortEnable;
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Now we Have to Pass the Conditions to Each Signal Provider
|
|
// for Retrieving Signals Based On them ...
|
|
|
|
//
|
|
// Reading Market Conditions ...
|
|
GetMarketConditions(mConditions, barIndex);
|
|
// string mConditionsStr = mConditions.GenerateSummary();
|
|
// Print(mConditionsStr);
|
|
|
|
//
|
|
int signalPusher = 0;
|
|
bool hasLong = false;
|
|
bool hasShort = false;
|
|
string provider = "";
|
|
|
|
//
|
|
// Long ...
|
|
if (mIsLongEnable)
|
|
{
|
|
//
|
|
signalPusher = 0;
|
|
|
|
//
|
|
hasLong = HasSpecificSignal(
|
|
barIndex,
|
|
POSITION_TYPE_BUY,
|
|
provider,
|
|
signalPusher,
|
|
mConditions //
|
|
);
|
|
}
|
|
|
|
//
|
|
// Short ...
|
|
if (mIsShortEnable)
|
|
{
|
|
//
|
|
signalPusher = 0;
|
|
|
|
//
|
|
hasShort = HasSpecificSignal(
|
|
barIndex,
|
|
POSITION_TYPE_SELL,
|
|
provider,
|
|
signalPusher,
|
|
mConditions //
|
|
);
|
|
}
|
|
|
|
//
|
|
result = hasLong || hasShort;
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Prepare Signal ...
|
|
|
|
//
|
|
if (result)
|
|
{
|
|
//
|
|
// Here We Have to Prepare Signal ...
|
|
|
|
//
|
|
// TODO: Make this Configurable ...
|
|
string symbol = GetSymbol();
|
|
ENUM_TIMEFRAMES period = GetPeriod();
|
|
double tpPoint = 30;
|
|
double volume = 0.01;
|
|
double tpPrice = PointToPrice(
|
|
tpPoint,
|
|
symbol //
|
|
);
|
|
ENUM_POSITION_TYPE type = hasLong
|
|
? POSITION_TYPE_BUY
|
|
: POSITION_TYPE_SELL;
|
|
ENUM_X_ORDER_MODES mode = X_ORDER_MODE_MARKET;
|
|
double entry = GetEntry(
|
|
symbol,
|
|
type //
|
|
);
|
|
double tp = hasLong
|
|
? entry + tpPrice
|
|
: entry - tpPrice;
|
|
double sl = 0;
|
|
ENUM_X_SIGNAL_MANAGING_ACTIONS action = X_SIGNAL_USE_NOTHING;
|
|
|
|
//
|
|
result = mSignal.Prepare(
|
|
symbol,
|
|
provider,
|
|
period,
|
|
type,
|
|
mode,
|
|
entry,
|
|
volume,
|
|
action,
|
|
sl,
|
|
tp
|
|
//
|
|
);
|
|
|
|
//
|
|
if (result)
|
|
{
|
|
//
|
|
mWaitsUntilNewBar = true;
|
|
|
|
// //
|
|
// TODO:
|
|
// string providerTypeStr = GetSymbol() + ", " + provider + "(" + (hasLong ? "Long" : "Short") + ")";
|
|
// string mConditionsStr = mConditions.GenerateSummary(providerTypeStr, true);
|
|
// mConditionsCollector.Add(mConditionsStr);
|
|
// Print(mConditionsStr);
|
|
}
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
void Draw()
|
|
{
|
|
//
|
|
// ulong chID = 0;
|
|
|
|
//
|
|
string symbol = GetSymbol();
|
|
ENUM_TIMEFRAMES period = GetPeriod();
|
|
|
|
//
|
|
ulong chID = FindChartID(
|
|
symbol,
|
|
period);
|
|
if (chID < 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
int subWindow = 0;
|
|
|
|
//
|
|
int offset = 0;
|
|
|
|
//
|
|
cMarket.Draw(chID, subWindow, offset);
|
|
sMarket.Draw(chID, subWindow, offset);
|
|
mMarket.Draw(chID, subWindow, offset);
|
|
lMarket.Draw(chID, subWindow, offset);
|
|
hMarket.Draw(chID, subWindow, offset);
|
|
}
|
|
|
|
//
|
|
// Protected ...
|
|
protected:
|
|
//
|
|
X121ProviderInputs mInputs;
|
|
|
|
//
|
|
// Private ...
|
|
private:
|
|
//
|
|
// Props ...
|
|
|
|
//
|
|
int mNumberOfItems; // Number of Buffer Ites Read in Conditions ...
|
|
|
|
//
|
|
// Signallers ...
|
|
|
|
//
|
|
bool mIsLongEnable;
|
|
bool mIsShortEnable;
|
|
|
|
//
|
|
bool mIsXSPSignalProviderEnable;
|
|
bool mIsX92SignalProviderEnable;
|
|
bool mIsX786SignalProviderEnable;
|
|
bool mIsX121SignalProviderEnable;
|
|
bool mIsX110SignalProviderEnable;
|
|
bool mIsXTESTSignalProviderEnable;
|
|
|
|
//
|
|
//
|
|
// Detect Signal ...
|
|
bool HasSpecificSignal(
|
|
int barIndex, // Specified Bar Index ...
|
|
ENUM_POSITION_TYPE mType, // Specific Signal Type ...
|
|
string &provider, // Signal Provider ...
|
|
int &signalPusher, // Number Of Same Time Signals ...
|
|
X121MarketConditions &mConditions // Specified Market Conition ...
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
// Validate Signal Type is Enables ...
|
|
bool isLong = IsLong(mType);
|
|
result =
|
|
(isLong && mIsLongEnable) ||
|
|
(!isLong && mIsShortEnable);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Now we have to Filter based on Enabled Signal Providers ...
|
|
|
|
//
|
|
// Long ...
|
|
if (isLong && mIsLongEnable)
|
|
{
|
|
//
|
|
XSignal lSignal;
|
|
|
|
//
|
|
signalPusher = 0;
|
|
|
|
//
|
|
bool hasXSPSignal = false;
|
|
bool hasXTESTSignal = false;
|
|
bool hasX786Signal = false;
|
|
bool hasX121Signal = false;
|
|
bool hasX110Signal = false;
|
|
bool hasX92Signal = false;
|
|
|
|
//
|
|
// XPS ...
|
|
if (mIsXSPSignalProviderEnable)
|
|
{
|
|
//
|
|
hasXSPSignal = XSPHasSpecifiedLongSignal(
|
|
mConditions //
|
|
);
|
|
|
|
//
|
|
if (hasXSPSignal)
|
|
{
|
|
//
|
|
if (!IsValid(provider))
|
|
{
|
|
provider = ToString(XSP);
|
|
}
|
|
|
|
//
|
|
signalPusher++;
|
|
}
|
|
}
|
|
|
|
//
|
|
// XTEST ...
|
|
if (mIsXTESTSignalProviderEnable)
|
|
{
|
|
//
|
|
hasXTESTSignal = XTESTHasSpecifiedLongSignal(
|
|
mConditions //
|
|
);
|
|
|
|
//
|
|
if (hasXTESTSignal)
|
|
{
|
|
//
|
|
if (!IsValid(provider))
|
|
{
|
|
provider = ToString(XTEST);
|
|
}
|
|
|
|
//
|
|
signalPusher++;
|
|
}
|
|
}
|
|
|
|
//
|
|
// X786 ...
|
|
if (mIsX786SignalProviderEnable)
|
|
{
|
|
//
|
|
hasX786Signal = X786HasSpecifiedLongSignal(
|
|
mConditions //
|
|
);
|
|
|
|
//
|
|
if (hasX786Signal)
|
|
{
|
|
//
|
|
if (!IsValid(provider))
|
|
{
|
|
provider = ToString(X786);
|
|
}
|
|
|
|
//
|
|
signalPusher++;
|
|
}
|
|
}
|
|
|
|
//
|
|
// X121 ...
|
|
if (mIsX121SignalProviderEnable)
|
|
{
|
|
//
|
|
hasX121Signal = XSIHasSpecifiedLongSignal(
|
|
mConditions //
|
|
);
|
|
|
|
//
|
|
if (hasX121Signal)
|
|
{
|
|
//
|
|
if (!IsValid(provider))
|
|
{
|
|
provider = ToString(X121);
|
|
}
|
|
|
|
//
|
|
signalPusher++;
|
|
}
|
|
}
|
|
|
|
//
|
|
// X110 ...
|
|
if (mIsX110SignalProviderEnable)
|
|
{
|
|
//
|
|
hasX110Signal = XTSFIHasSpecifiedLongSignal(
|
|
mConditions //
|
|
);
|
|
|
|
//
|
|
if (hasX110Signal)
|
|
{
|
|
//
|
|
if (!IsValid(provider))
|
|
{
|
|
provider = ToString(X110);
|
|
}
|
|
|
|
//
|
|
signalPusher++;
|
|
}
|
|
}
|
|
|
|
//
|
|
// X92 ...
|
|
if (mIsX92SignalProviderEnable)
|
|
{
|
|
//
|
|
hasX92Signal = XOBDLHHasSpecifiedLongSignal(
|
|
mConditions //
|
|
);
|
|
|
|
//
|
|
if (hasX92Signal)
|
|
{
|
|
//
|
|
if (!IsValid(provider))
|
|
{
|
|
provider = ToString(X92);
|
|
}
|
|
|
|
//
|
|
signalPusher++;
|
|
}
|
|
}
|
|
|
|
//
|
|
result =
|
|
//
|
|
hasXSPSignal
|
|
//
|
|
||
|
|
//
|
|
hasXTESTSignal
|
|
//
|
|
||
|
|
//
|
|
hasX786Signal
|
|
//
|
|
||
|
|
//
|
|
hasX121Signal
|
|
//
|
|
||
|
|
//
|
|
hasX110Signal
|
|
//
|
|
||
|
|
//
|
|
hasX92Signal
|
|
//
|
|
;
|
|
|
|
//
|
|
if (result)
|
|
{
|
|
return result;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Short ...
|
|
if (!isLong && mIsShortEnable)
|
|
{
|
|
//
|
|
XSignal sSignal;
|
|
|
|
//
|
|
signalPusher = 0;
|
|
|
|
//
|
|
bool hasXSPSignal = false;
|
|
bool hasXTESTSignal = false;
|
|
bool hasX786Signal = false;
|
|
bool hasX121Signal = false;
|
|
bool hasX110Signal = false;
|
|
bool hasX92Signal = false;
|
|
|
|
//
|
|
// XSP ...
|
|
if (mIsXSPSignalProviderEnable)
|
|
{
|
|
//
|
|
hasXSPSignal = XSPHasSpecifiedShortSignal(
|
|
mConditions //
|
|
);
|
|
|
|
//
|
|
if (hasXSPSignal)
|
|
{
|
|
//
|
|
if (!IsValid(provider))
|
|
{
|
|
provider = ToString(XSP);
|
|
}
|
|
|
|
//
|
|
signalPusher++;
|
|
}
|
|
}
|
|
|
|
//
|
|
// XTEST ...
|
|
if (mIsXTESTSignalProviderEnable)
|
|
{
|
|
//
|
|
hasXTESTSignal = XTESTHasSpecifiedShortSignal(
|
|
mConditions //
|
|
);
|
|
|
|
//
|
|
if (hasXTESTSignal)
|
|
{
|
|
//
|
|
if (!IsValid(provider))
|
|
{
|
|
provider = ToString(XTEST);
|
|
}
|
|
|
|
//
|
|
signalPusher++;
|
|
}
|
|
}
|
|
|
|
//
|
|
// X786 ...
|
|
if (mIsX786SignalProviderEnable)
|
|
{
|
|
//
|
|
hasX786Signal = X786HasSpecifiedShortSignal(
|
|
mConditions //
|
|
);
|
|
|
|
//
|
|
if (hasX786Signal)
|
|
{
|
|
//
|
|
if (!IsValid(provider))
|
|
{
|
|
provider = ToString(X786);
|
|
}
|
|
|
|
//
|
|
signalPusher++;
|
|
}
|
|
}
|
|
|
|
//
|
|
// X121 ...
|
|
if (mIsX121SignalProviderEnable)
|
|
{
|
|
//
|
|
hasX121Signal = XSIHasSpecifiedShortSignal(
|
|
mConditions //
|
|
);
|
|
|
|
//
|
|
if (hasX121Signal)
|
|
{
|
|
//
|
|
if (!IsValid(provider))
|
|
{
|
|
provider = ToString(X121);
|
|
}
|
|
|
|
//
|
|
signalPusher++;
|
|
}
|
|
}
|
|
|
|
//
|
|
// X110 ...
|
|
if (mIsX110SignalProviderEnable)
|
|
{
|
|
//
|
|
hasX110Signal = XTSFIHasSpecifiedShortSignal(
|
|
mConditions //
|
|
);
|
|
|
|
//
|
|
if (hasX110Signal)
|
|
{
|
|
//
|
|
if (!IsValid(provider))
|
|
{
|
|
provider = ToString(X110);
|
|
}
|
|
|
|
//
|
|
signalPusher++;
|
|
}
|
|
}
|
|
|
|
//
|
|
// X92 ...
|
|
if (mIsX92SignalProviderEnable)
|
|
{
|
|
//
|
|
hasX92Signal = X92HasSpecifiedShortSignal(
|
|
mConditions //
|
|
);
|
|
|
|
//
|
|
if (hasX92Signal)
|
|
{
|
|
//
|
|
if (!IsValid(provider))
|
|
{
|
|
provider = ToString(X92);
|
|
}
|
|
|
|
//
|
|
signalPusher++;
|
|
}
|
|
}
|
|
|
|
//
|
|
result =
|
|
//
|
|
hasXSPSignal
|
|
//
|
|
||
|
|
//
|
|
hasXTESTSignal
|
|
//
|
|
||
|
|
//
|
|
hasX786Signal
|
|
//
|
|
||
|
|
//
|
|
hasX121Signal
|
|
//
|
|
||
|
|
//
|
|
hasX110Signal
|
|
//
|
|
||
|
|
//
|
|
hasX92Signal
|
|
//
|
|
;
|
|
|
|
//
|
|
if (result)
|
|
{
|
|
return result;
|
|
}
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
void CalculateConditions(
|
|
X121MarketConditions &mConditions, // Market Conditions Result
|
|
int barIndex = 0 // Specified Bar Index
|
|
) {
|
|
//
|
|
// cMarket
|
|
// sMarket
|
|
// mMarket
|
|
// lMarket
|
|
// hMarket
|
|
}
|
|
|
|
//
|
|
// Signalling based On Signallers ...
|
|
|
|
//
|
|
// XSP ...
|
|
|
|
//
|
|
bool XSPHasSpecifiedLongSignal(
|
|
X121MarketConditions &mConditions //
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
bool XTESTHasSpecifiedLongSignal(
|
|
X121MarketConditions &mConditions //
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
bool X786HasSpecifiedLongSignal(
|
|
X121MarketConditions &mConditions //
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
bool XSIHasSpecifiedLongSignal(
|
|
X121MarketConditions &mConditions //
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
bool XTSFIHasSpecifiedLongSignal(
|
|
X121MarketConditions &mConditions //
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
bool XOBDLHHasSpecifiedLongSignal(
|
|
X121MarketConditions &mConditions //
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
bool XSPHasSpecifiedShortSignal(
|
|
X121MarketConditions &mConditions //
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
bool XTESTHasSpecifiedShortSignal(
|
|
X121MarketConditions &mConditions //
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
bool X786HasSpecifiedShortSignal(
|
|
X121MarketConditions &mConditions //
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
bool XSIHasSpecifiedShortSignal(
|
|
X121MarketConditions &mConditions //
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
bool XTSFIHasSpecifiedShortSignal(
|
|
X121MarketConditions &mConditions //
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
bool X92HasSpecifiedShortSignal(
|
|
X121MarketConditions &mConditions //
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
};
|
|
|
|
//
|
|
// Tools ...
|
|
|
|
//
|
|
// Model Provider Descriptor ...
|
|
struct X121ProviderDescriptor
|
|
{
|
|
//
|
|
string symbol; // Trading Symbol
|
|
ENUM_TIMEFRAMES period; // Trading Timeframe
|
|
bool allowLong; // Allow Long Signals
|
|
bool allowShort; // Allow Short Signals
|
|
ENUM_X121_SIGNAL_PROVIDERS signallers[]; // Allowed Signal Providers
|
|
|
|
//
|
|
X121ProviderInputs inputs;
|
|
XSCX121Provider *provider;
|
|
|
|
//
|
|
XSignal signal;
|
|
X121MarketConditions conditions;
|
|
|
|
//
|
|
// Tools ...
|
|
|
|
//
|
|
bool Init()
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
result = this.Init(
|
|
this.symbol,
|
|
this.period,
|
|
this.signallers,
|
|
this.allowLong,
|
|
this.allowShort //
|
|
);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
bool Init(
|
|
ENUM_X121_SIGNAL_PROVIDERS &mSignallers[], // Allowed Signal Providers
|
|
bool mAllowLong = true, // Allow Long Signals
|
|
bool mAllowShort = true // Allow Short Signals
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
result = this.Init(
|
|
this.symbol,
|
|
this.period,
|
|
mSignallers,
|
|
mAllowLong,
|
|
mAllowShort //
|
|
);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
bool Init(
|
|
string mSymbol, // Trading Symbol
|
|
ENUM_TIMEFRAMES mPeriod, // Trading Timeframe
|
|
ENUM_X121_SIGNAL_PROVIDERS &mSignallers[], // Allowed Signal Providers
|
|
bool mAllowLong = true, // Allow Long Signals
|
|
bool mAllowShort = true // Allow Short Signals
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
result =
|
|
//
|
|
inputs.IsValid() &&
|
|
IsValid(mSymbol) &&
|
|
IsValid(mPeriod) &&
|
|
(allowLong || allowShort) &&
|
|
ArraySize(mSignallers) > 0
|
|
//
|
|
;
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
this.symbol = mSymbol;
|
|
this.period = mPeriod;
|
|
this.allowLong = mAllowLong;
|
|
this.allowShort = mAllowShort;
|
|
|
|
//
|
|
ENUM_X121_SIGNAL_PROVIDERS tmp[];
|
|
Copy(
|
|
mSignallers,
|
|
tmp //
|
|
);
|
|
Copy(
|
|
tmp,
|
|
this.signallers //
|
|
);
|
|
|
|
//
|
|
// Instantiate Provider ...
|
|
provider = new XSCX121Provider(
|
|
this.symbol,
|
|
this.period //
|
|
);
|
|
|
|
//
|
|
// Set Long/Short State ...
|
|
|
|
//
|
|
provider
|
|
.SetSignalTypeState(
|
|
POSITION_TYPE_BUY,
|
|
this.allowLong //
|
|
);
|
|
|
|
//
|
|
provider
|
|
.SetSignalTypeState(
|
|
POSITION_TYPE_SELL,
|
|
this.allowShort //
|
|
);
|
|
|
|
//
|
|
// Enable Required Signallers ...
|
|
provider
|
|
.SetSignalProviderStates(
|
|
this.signallers,
|
|
true //
|
|
);
|
|
|
|
//
|
|
// Now Must to Initialize Provider ...
|
|
result = provider.Init(
|
|
this.inputs //
|
|
);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Cleanup ...
|
|
void Clean()
|
|
{
|
|
//
|
|
signal.Clean();
|
|
conditions.Clear();
|
|
}
|
|
|
|
//
|
|
// Validate ...
|
|
bool IsValid(bool validateInputs = true)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
result =
|
|
//
|
|
IsValid(symbol) &&
|
|
IsValid(period) &&
|
|
(validateInputs
|
|
? inputs.IsValid()
|
|
: true) &&
|
|
(allowLong || allowShort) &&
|
|
ArraySize(signallers) > 0
|
|
//
|
|
;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Check Signal ...
|
|
bool HasSignal(int barIndex = 0)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
result = inputs.IsValid();
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Clear Signal and Conditions ...
|
|
Clean();
|
|
|
|
//
|
|
result = provider.HasSignal(
|
|
barIndex,
|
|
signal,
|
|
conditions //
|
|
);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
};
|
|
|
|
//
|
|
void GetAllX121SignalProviders(ENUM_X121_SIGNAL_PROVIDERS &result[])
|
|
{
|
|
//
|
|
Clean(result);
|
|
|
|
//
|
|
Add(NONE, result);
|
|
Add(XSP, result);
|
|
Add(XTEST, result);
|
|
Add(X786, result);
|
|
Add(X121, result);
|
|
Add(X110, result);
|
|
Add(X92, result);
|
|
}
|
|
|
|
//
|
|
string ToString(ENUM_X121_SIGNAL_PROVIDERS value)
|
|
{
|
|
return EnumToString(value);
|
|
}
|
|
|
|
//
|
|
ENUM_X121_SIGNAL_PROVIDERS ToX121SignalProvider(string content)
|
|
{
|
|
//
|
|
ENUM_X121_SIGNAL_PROVIDERS result = NONE;
|
|
|
|
//
|
|
if (!IsValid(content))
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
if (content == ToString(NONE))
|
|
{
|
|
result = NONE;
|
|
}
|
|
else if (content == ToString(XSP))
|
|
{
|
|
result = XSP;
|
|
}
|
|
else if (content == ToString(XTEST))
|
|
{
|
|
result = XTEST;
|
|
}
|
|
else if (content == ToString(X786))
|
|
{
|
|
result = X786;
|
|
}
|
|
else if (content == ToString(X121))
|
|
{
|
|
result = X121;
|
|
}
|
|
else if (content == ToString(X110))
|
|
{
|
|
result = X110;
|
|
}
|
|
else if (content == ToString(X92))
|
|
{
|
|
result = X92;
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
// |