Princeec13/mql5
Watch
0
0
Fork
You've already forked mql5
 1
Code Issues Pull requests 1 Projects Releases Packages Wiki Activity Actions
mql5/Include/Indicators/TimeSeries.mqh

1552 lines
60 KiB
MQL5
RawPermalinkNormal ViewHistory

new files added
2025-08-05 01:57:33 -04:00
//+------------------------------------------------------------------+
//| TimeSeries.mqh |
//| Copyright 2000-2025, MetaQuotes Ltd. |
//| https://www.mql5.com |
//+------------------------------------------------------------------+
#include "Series.mqh"
#include <Arrays\ArrayInt.mqh>
#include <Arrays\ArrayLong.mqh>
#include <Arrays\ArrayDatetime.mqh>
//+------------------------------------------------------------------+
//| Class CPriceSeries. |
//| Purpose: Base class of price series. |
//| Derives from class CSeries. |
//+------------------------------------------------------------------+
class CPriceSeries : public CSeries
{
public:
CPriceSeries(void);
~CPriceSeries(void);
//--- method of creation
virtual bool BufferResize(const int size);
//--- methods for searching extremum
virtual int MinIndex(const int start,const int count) const;
virtual double MinValue(const int start,const int count,int &index) const;
virtual int MaxIndex(const int start,const int count) const;
virtual double MaxValue(const int start,const int count,int &index) const;
//--- methods of access to data
double GetData(const int index) const;
//--- method of refreshing of the data
virtual void Refresh(const int flags=OBJ_ALL_PERIODS);
};
//+------------------------------------------------------------------+
//| Constructor |
//+------------------------------------------------------------------+
CPriceSeries::CPriceSeries(void)
{
}
//+------------------------------------------------------------------+
//| Destructor |
//+------------------------------------------------------------------+
CPriceSeries::~CPriceSeries(void)
{
}
//+------------------------------------------------------------------+
//| Set size of buffer |
//+------------------------------------------------------------------+
bool CPriceSeries::BufferResize(const int size)
{
if(size>m_buffer_size && !CSeries::BufferResize(size))
return(false);
//-- history is avalible
CDoubleBuffer *buff=At(0);
//--- check pointer
if(buff==NULL)
return(false);
//--
buff.Size(size);
//--- ok
return(true);
}
//+------------------------------------------------------------------+
//| Find minimum of specified buffer |
//+------------------------------------------------------------------+
int CPriceSeries::MinIndex(const int start,const int count) const
{
CDoubleBuffer *buff=At(0);
//--- check
if(buff==NULL)
return(-1);
//---
return(buff.Minimum(start,count));
}
//+------------------------------------------------------------------+
//| Find minimum of specified buffer |
//+------------------------------------------------------------------+
double CPriceSeries::MinValue(const int start,const int count,int &index) const
{
int idx=MinIndex(start,count);
double res=EMPTY_VALUE;
//--- check
if(idx!=-1)
{
CDoubleBuffer *buff=At(0);
res=buff.At(idx);
index=idx;
}
//---
return(res);
}
//+------------------------------------------------------------------+
//| Find maximum of specified buffer |
//+------------------------------------------------------------------+
int CPriceSeries::MaxIndex(const int start,const int count) const
{
CDoubleBuffer *buff=At(0);
//--- check
if(buff==NULL)
return(-1);
//---
return(buff.Maximum(start,count));
}
//+------------------------------------------------------------------+
//| Find maximum of specified buffer |
//+------------------------------------------------------------------+
double CPriceSeries::MaxValue(const int start,const int count,int &index) const
{
int idx=MaxIndex(start,count);
double res=EMPTY_VALUE;
//--- check
if(idx!=-1)
{
CDoubleBuffer *buff=At(0);
res=buff.At(idx);
index=idx;
}
//---
return(res);
}
//+------------------------------------------------------------------+
//| Method to access data |
//+------------------------------------------------------------------+
double CPriceSeries::GetData(const int index) const
{
CDoubleBuffer *buff=At(0);
//--- check
if(buff==NULL)
{
Print(__FUNCTION__,": invalid buffer");
return(EMPTY_VALUE);
}
//---
return(buff.At(index));
}
//+------------------------------------------------------------------+
//| Refreshing of the data |
//+------------------------------------------------------------------+
void CPriceSeries::Refresh(const int flags)
{
CDoubleBuffer *buff=At(0);
//--- check
if(buff==NULL)
return;
//--- refresh of buffers
if(!(flags&m_timeframe_flags))
{
if(m_refresh_current)
buff.RefreshCurrent();
}
else
buff.Refresh();
}
//+------------------------------------------------------------------+
//| Class COpenBuffer. |
//| Purpose: Class of buffer of open price series. |
//| Derives from class CDoubleBuffer. |
//+------------------------------------------------------------------+
class COpenBuffer : public CDoubleBuffer
{
public:
COpenBuffer(void);
~COpenBuffer(void);
//--- method of refreshing of the data buffer
virtual bool Refresh(void);
virtual bool RefreshCurrent(void);
};
//+------------------------------------------------------------------+
//| Constructor |
//+------------------------------------------------------------------+
COpenBuffer::COpenBuffer(void)
{
}
//+------------------------------------------------------------------+
//| Destructor |
//+------------------------------------------------------------------+
COpenBuffer::~COpenBuffer(void)
{
}
//+------------------------------------------------------------------+
//| Refreshing of the data buffer |
//+------------------------------------------------------------------+
bool COpenBuffer::Refresh(void)
{
m_data_total=CopyOpen(m_symbol,m_period,0,m_size,m_data);
//---
return(m_data_total>0);
}
//+------------------------------------------------------------------+
//| Refreshing of the data buffer |
//+------------------------------------------------------------------+
bool COpenBuffer::RefreshCurrent(void)
{
double array[1];
//---
if(CopyOpen(m_symbol,m_period,0,1,array)==1 && m_data_total>0)
{
m_data[0]=array[0];
return(true);
}
//--- error
return(false);
}
//+------------------------------------------------------------------+
//| Class CiOpen. |
//| Purpose: Class of open series. |
//| Derives from class CPriceSeries. |
//+------------------------------------------------------------------+
class CiOpen : public CPriceSeries
{
public:
CiOpen(void);
~CiOpen(void);
//--- method of creation
bool Create(const string symbol,const ENUM_TIMEFRAMES period);
//--- methods of access to data
double GetData(const int index) const { return(CPriceSeries::GetData(index)); }
int GetData(const int start_pos,const int count,double &buffer[]) const;
int GetData(const datetime start_time,const int count,double &buffer[]) const;
int GetData(const datetime start_time,const datetime stop_time,double &buffer[]) const;
};
//+------------------------------------------------------------------+
//| Constructor |
//+------------------------------------------------------------------+
CiOpen::CiOpen(void)
{
m_name="Open";
}
//+------------------------------------------------------------------+
//| Destructor |
//+------------------------------------------------------------------+
CiOpen::~CiOpen(void)
{
}
//+------------------------------------------------------------------+
//| Creation of open series |
//+------------------------------------------------------------------+
bool CiOpen::Create(const string symbol,const ENUM_TIMEFRAMES period)
{
CDoubleBuffer *buff;
//--- check history
if(!SetSymbolPeriod(symbol,period))
return(false);
//--- create
if((buff=new COpenBuffer)==NULL)
return(false);
//--- add
if(!Add(buff))
{
delete buff;
return(false);
}
//--- tune
buff.SetSymbolPeriod(m_symbol,m_period);
//--- ok
return(true);
}
//+------------------------------------------------------------------+
//| API access method "Copying the open buffer by specifying |
//| start position and number of elements" |
//+------------------------------------------------------------------+
int CiOpen::GetData(const int start_pos,const int count,double &buffer[]) const
{
return(CopyOpen(m_symbol,m_period,start_pos,count,buffer));
}
//+------------------------------------------------------------------+
//| API access method "Copying the open buffer by specifying |
//| start time and number of elements" |
//+------------------------------------------------------------------+
int CiOpen::GetData(const datetime start_time,const int count,double &buffer[]) const
{
return(CopyOpen(m_symbol,m_period,start_time,count,buffer));
}
//+------------------------------------------------------------------+
//| API access method "Copying the open buffer by specifying |
//| start and end time" |
//+------------------------------------------------------------------+
int CiOpen::GetData(const datetime start_time,const datetime stop_time,double &buffer[]) const
{
return(CopyOpen(m_symbol,m_period,start_time,stop_time,buffer));
}
//+------------------------------------------------------------------+
//| Class CHighBuffer. |
//| Purpose: Class of buffer of high price series. |
//| Derives from class CDoubleBuffer. |
//+------------------------------------------------------------------+
class CHighBuffer : public CDoubleBuffer
{
public:
CHighBuffer(void);
~CHighBuffer(void);
//--- method of refreshing of the data buffer
virtual bool Refresh(void);
virtual bool RefreshCurrent(void);
};
//+------------------------------------------------------------------+
//| Constructor |
//+------------------------------------------------------------------+
CHighBuffer::CHighBuffer(void)
{
}
//+------------------------------------------------------------------+
//| Destructor |
//+------------------------------------------------------------------+
CHighBuffer::~CHighBuffer(void)
{
}
//+------------------------------------------------------------------+
//| Refreshing of data buffer |
//+------------------------------------------------------------------+
bool CHighBuffer::Refresh(void)
{
m_data_total=CopyHigh(m_symbol,m_period,0,m_size,m_data);
//---
return(m_data_total>0);
}
//+------------------------------------------------------------------+
//| Refreshing of data buffer |
//+------------------------------------------------------------------+
bool CHighBuffer::RefreshCurrent(void)
{
double array[1];
//---
if(CopyHigh(m_symbol,m_period,0,1,array)>0 && m_data_total>0)
{
m_data[0]=array[0];
return(true);
}
//--- error
return(false);
}
//+------------------------------------------------------------------+
//| Class CiHigh. |
//| Purpose: Class of high series. |
//| Derives from class CPriceSeries. |
//+------------------------------------------------------------------+
class CiHigh : public CPriceSeries
{
public:
CiHigh(void);
~CiHigh(void);
//--- method of creation
bool Create(const string symbol,const ENUM_TIMEFRAMES period);
//--- methods of access to data
double GetData(const int index) const { return(CPriceSeries::GetData(index)); }
int GetData(const int start_pos,const int count,double &buffer[]) const;
int GetData(const datetime start_time,const int count,double &buffer[]) const;
int GetData(const datetime start_time,const datetime stop_time,double &buffer[]) const;
};
//+------------------------------------------------------------------+
//| Constructor |
//+------------------------------------------------------------------+
CiHigh::CiHigh(void)
{
m_name="High";
}
//+------------------------------------------------------------------+
//| Destructor |
//+------------------------------------------------------------------+
CiHigh::~CiHigh(void)
{
}
//+------------------------------------------------------------------+
//| Creation of high series |
//+------------------------------------------------------------------+
bool CiHigh::Create(const string symbol,const ENUM_TIMEFRAMES period)
{
CDoubleBuffer *buff;
//--- check history
if(!SetSymbolPeriod(symbol,period))
return(false);
//--- create
if((buff=new CHighBuffer)==NULL)
return(false);
//--- add
if(!Add(buff))
{
delete buff;
return(false);
}
//--- tune
buff.SetSymbolPeriod(m_symbol,m_period);
//--- ok
return(true);
}
//+------------------------------------------------------------------+
//| API access method "Copying the high buffer by specifying |
//| start position and number of elements" |
//+------------------------------------------------------------------+
int CiHigh::GetData(const int start_pos,const int count,double &buffer[]) const
{
return(CopyHigh(m_symbol,m_period,start_pos,count,buffer));
}
//+------------------------------------------------------------------+
//| API access method "Copying the high buffer for the initial |
//| time and the number of elements" |
//+------------------------------------------------------------------+
int CiHigh::GetData(const datetime start_time,const int count,double &buffer[]) const
{
return(CopyHigh(m_symbol,m_period,start_time,count,buffer));
}
//+------------------------------------------------------------------+
//| API access method "Copying the high buffer by specifying |
//| start and end time" |
//+------------------------------------------------------------------+
int CiHigh::GetData(const datetime start_time,const datetime stop_time,double &buffer[]) const
{
return(CopyHigh(m_symbol,m_period,start_time,stop_time,buffer));
}
//+------------------------------------------------------------------+
//| Class CLowBuffer. |
//| Purpose: Class of buffer of low price series. |
//| Derives from class CPriceBuffer. |
//+------------------------------------------------------------------+
class CLowBuffer : public CDoubleBuffer
{
public:
CLowBuffer(void);
~CLowBuffer(void);
//--- method of refreshing of the data buffer
virtual bool Refresh(void);
virtual bool RefreshCurrent(void);
};
//+------------------------------------------------------------------+
//| Constructor |
//+------------------------------------------------------------------+
CLowBuffer::CLowBuffer(void)
{
}
//+------------------------------------------------------------------+
//| Destructor |
//+------------------------------------------------------------------+
CLowBuffer::~CLowBuffer(void)
{
}
//+------------------------------------------------------------------+
//| Refreshing of data buffer |
//+------------------------------------------------------------------+
bool CLowBuffer::Refresh(void)
{
m_data_total=CopyLow(m_symbol,m_period,0,m_size,m_data);
//---
return(m_data_total>0);
}
//+------------------------------------------------------------------+
//| Refreshing of data buffer |
//+------------------------------------------------------------------+
bool CLowBuffer::RefreshCurrent(void)
{
double array[1];
//---
if(CopyLow(m_symbol,m_period,0,1,array)>0 && m_data_total>0)
{
m_data[0]=array[0];
return(true);
}
//--- error
return(false);
}
//+------------------------------------------------------------------+
//| Class CiLow. |
//| Purpose: Class of low series. |
//| Derives from class CPriceSeries. |
//+------------------------------------------------------------------+
class CiLow : public CPriceSeries
{
public:
CiLow(void);
~CiLow(void);
//--- method of creation
bool Create(const string symbol,const ENUM_TIMEFRAMES period);
//--- methods of access to data
double GetData(const int index) const { return(CPriceSeries::GetData(index)); }
int GetData(const int start_pos,const int count,double &buffer[]) const;
int GetData(const datetime start_time,const int count,double &buffer[]) const;
int GetData(const datetime start_time,const datetime stop_time,double &buffer[]) const;
};
//+------------------------------------------------------------------+
//| Constructor |
//+------------------------------------------------------------------+
CiLow::CiLow(void)
{
m_name="Low";
}
//+------------------------------------------------------------------+
//| Destructor |
//+------------------------------------------------------------------+
CiLow::~CiLow(void)
{
}
//+------------------------------------------------------------------+
//| Creation of low series |
//+------------------------------------------------------------------+
bool CiLow::Create(const string symbol,const ENUM_TIMEFRAMES period)
{
CDoubleBuffer *buff;
//--- check history
if(!SetSymbolPeriod(symbol,period))
return(false);
//--- create
if((buff=new CLowBuffer)==NULL)
return(false);
//--- add
if(!Add(buff))
{
delete buff;
return(false);
}
//--- tune
buff.SetSymbolPeriod(m_symbol,m_period);
//--- ok
return(true);
}
//+------------------------------------------------------------------+
//| API access method "Copying the low buffer by specifying |
//| start position and number of elements" |
//+------------------------------------------------------------------+
int CiLow::GetData(const int start_pos,const int count,double &buffer[]) const
{
return(CopyLow(m_symbol,m_period,start_pos,count,buffer));
}
//+------------------------------------------------------------------+
//| API access method "Copying the low buffer for the initial |
//| time and the number of elements" |
//+------------------------------------------------------------------+
int CiLow::GetData(const datetime start_time,const int count,double &buffer[]) const
{
return(CopyLow(m_symbol,m_period,start_time,count,buffer));
}
//+------------------------------------------------------------------+
//| API access method "Copying the low buffer for the initial |
//| and final time" |
//+------------------------------------------------------------------+
int CiLow::GetData(const datetime start_time,const datetime stop_time,double &buffer[]) const
{
return(CopyLow(m_symbol,m_period,start_time,stop_time,buffer));
}
//+------------------------------------------------------------------+
//| Class CCloseBuffer. |
//| Purpose: Class of buffer of low price series. |
//| Derives from class CPriceBuffer. |
//+------------------------------------------------------------------+
class CCloseBuffer : public CDoubleBuffer
{
public:
CCloseBuffer(void);
~CCloseBuffer(void);
//--- method of refreshing of data buffer
virtual bool Refresh(void);
virtual bool RefreshCurrent(void);
};
//+------------------------------------------------------------------+
//| Constructor |
//+------------------------------------------------------------------+
CCloseBuffer::CCloseBuffer(void)
{
}
//+------------------------------------------------------------------+
//| Destructor |
//+------------------------------------------------------------------+
CCloseBuffer::~CCloseBuffer(void)
{
}
//+------------------------------------------------------------------+
//| Refreshing of data buffer |
//+------------------------------------------------------------------+
bool CCloseBuffer::Refresh(void)
{
m_data_total=CopyClose(m_symbol,m_period,0,m_size,m_data);
//---
return(m_data_total>0);
}
//+------------------------------------------------------------------+
//| Refreshing of the data buffer |
//+------------------------------------------------------------------+
bool CCloseBuffer::RefreshCurrent(void)
{
double array[1];
//---
if(CopyClose(m_symbol,m_period,0,1,array)>0 && m_data_total>0)
{
m_data[0]=array[0];
return(true);
}
//--- error
return(false);
}
//+------------------------------------------------------------------+
//| Class CiClose. |
//| Purpose: Class of close series. |
//| Derives from class CPriceSeries. |
//+------------------------------------------------------------------+
class CiClose : public CPriceSeries
{
public:
CiClose(void);
~CiClose(void);
//--- method of creation
bool Create(const string symbol,const ENUM_TIMEFRAMES period);
//--- methods of access to data
double GetData(const int index) const { return(CPriceSeries::GetData(index)); }
int GetData(const int start_pos,const int count,double &buffer[]) const;
int GetData(const datetime start_time,const int count,double &buffer[]) const;
int GetData(const datetime start_time,const datetime stop_time,double &buffer[]) const;
};
//+------------------------------------------------------------------+
//| Constructor |
//+------------------------------------------------------------------+
CiClose::CiClose(void)
{
m_name="Close";
}
//+------------------------------------------------------------------+
//| Destructor |
//+------------------------------------------------------------------+
CiClose::~CiClose(void)
{
}
//+------------------------------------------------------------------+
//| Creation of the close series |
//+------------------------------------------------------------------+
bool CiClose::Create(const string symbol,const ENUM_TIMEFRAMES period)
{
CDoubleBuffer *buff;
//--- check history
if(!SetSymbolPeriod(symbol,period))
return(false);
//--- create
if((buff=new CCloseBuffer)==NULL)
return(false);
//--- add
if(!Add(buff))
{
delete buff;
return(false);
}
//--- tune
buff.SetSymbolPeriod(m_symbol,m_period);
//--- ok
return(true);
}
//+------------------------------------------------------------------+
//| API access method "Copying the close buffer by specifying |
//| start position and number of elements" |
//+------------------------------------------------------------------+
int CiClose::GetData(const int start_pos,const int count,double &buffer[]) const
{
return(CopyClose(m_symbol,m_period,start_pos,count,buffer));
}
//+------------------------------------------------------------------+
//| API access method "Copying the close buffer by specifying |
//| start time and number of elements" |
//+------------------------------------------------------------------+
int CiClose::GetData(const datetime start_time,const int count,double &buffer[]) const
{
return(CopyClose(m_symbol,m_period,start_time,count,buffer));
}
//+------------------------------------------------------------------+
//| API access method "Copying the close buffer by specifying |
//| start and end time" |
//+------------------------------------------------------------------+
int CiClose::GetData(const datetime start_time,const datetime stop_time,double &buffer[]) const
{
return(CopyClose(m_symbol,m_period,start_time,stop_time,buffer));
}
//+------------------------------------------------------------------+
//| Class CSpreadBuffer. |
//| Purpose: Class of buffer of spread series. |
//| Derives from class CArrayInt. |
//+------------------------------------------------------------------+
class CSpreadBuffer : public CArrayInt
{
protected:
string m_symbol; // symbol
ENUM_TIMEFRAMES m_period; // period
int m_freshed_data; // number of refreshed data
int m_size; // size of used history
public:
CSpreadBuffer(void);
~CSpreadBuffer(void);
//--- methods of access to protected data
void Size(const int size) { m_size=size; }
//--- methods of access to data
int At(const int index) const;
//--- method of refreshing of the data buffer
virtual bool Refresh(void);
virtual bool RefreshCurrent(void);
//--- methods of tuning
void SetSymbolPeriod(const string symbol,const ENUM_TIMEFRAMES period);
};
//+------------------------------------------------------------------+
//| Constructor |
//+------------------------------------------------------------------+
CSpreadBuffer::CSpreadBuffer(void) : m_symbol(""),
m_period(WRONG_VALUE),
m_freshed_data(0),
m_size(DEFAULT_BUFFER_SIZE)
{
ArraySetAsSeries(m_data,true);
}
//+------------------------------------------------------------------+
//| Destructor |
//+------------------------------------------------------------------+
CSpreadBuffer::~CSpreadBuffer(void)
{
}
//+------------------------------------------------------------------+
//| Access to data on the position |
//+------------------------------------------------------------------+
int CSpreadBuffer::At(const int index) const
{
//--- check
if(index>=m_data_total)
return(0);
//---
return(CArrayInt::At(index));
}
//+------------------------------------------------------------------+
//| Refreshing of data buffer |
//+------------------------------------------------------------------+
bool CSpreadBuffer::Refresh(void)
{
m_freshed_data=CopySpread(m_symbol,m_period,0,m_size,m_data);
//---
if(m_freshed_data>0)
{
m_data_total=ArraySize(m_data);
return(true);
}
//--- error
return(false);
}
//+------------------------------------------------------------------+
//| Refreshing of the data buffer |
//+------------------------------------------------------------------+
bool CSpreadBuffer::RefreshCurrent(void)
{
int array[1];
//---
if(CopySpread(m_symbol,m_period,0,1,array)==1 && m_data_total>0)
{
m_data[0]=array[0];
return(true);
}
//--- error
return(false);
}
//+------------------------------------------------------------------+
//| Set symbol and period |
//+------------------------------------------------------------------+
void CSpreadBuffer::SetSymbolPeriod(const string symbol,const ENUM_TIMEFRAMES period)
{
m_symbol=(symbol==NULL) ? ChartSymbol() : symbol;
m_period=(period==0) ? ChartPeriod() : period;
}
//+------------------------------------------------------------------+
//| Class CiSpread. |
//| Purpose: Class of spread series. |
//| Derives from class CSeries. |
//+------------------------------------------------------------------+
class CiSpread : public CSeries
{
public:
CiSpread(void);
~CiSpread(void);
//--- method of creation
bool Create(const string symbol,const ENUM_TIMEFRAMES period);
virtual bool BufferResize(const int size);
//--- methods of access to data
int GetData(const int index) const;
int GetData(const int start_pos,const int count,int &buffer[]) const;
int GetData(const datetime start_time,const int count,int &buffer[]) const;
int GetData(const datetime start_time,const datetime stop_time,int &buffer[]) const;
//--- method of refreshing of the data
virtual void Refresh(const int flags=OBJ_ALL_PERIODS);
};
//+------------------------------------------------------------------+
//| Constructor |
//+------------------------------------------------------------------+
CiSpread::CiSpread(void)
{
m_name="Spread";
}
//+------------------------------------------------------------------+
//| Destructor |
//+------------------------------------------------------------------+
CiSpread::~CiSpread(void)
{
}
//+------------------------------------------------------------------+
//| Creating of the spread series |
//+------------------------------------------------------------------+
bool CiSpread::Create(const string symbol,const ENUM_TIMEFRAMES period)
{
CSpreadBuffer *buff;
//--- check history
if(!SetSymbolPeriod(symbol,period))
return(false);
//--- create
if((buff=new CSpreadBuffer)==NULL)
return(false);
//--- add
if(!Add(buff))
{
delete buff;
return(false);
}
//--- tune
buff.SetSymbolPeriod(m_symbol,m_period);
//--- ok
return(true);
}
//+------------------------------------------------------------------+
//| Method to access data |
//+------------------------------------------------------------------+
int CiSpread::GetData(const int index) const
{
CSpreadBuffer *buff=At(0);
//--- check
if(buff==NULL)
{
Print(__FUNCTION__,": invalid buffer");
return(0);
}
//---
return(buff.At(index));
}
//+------------------------------------------------------------------+
//| API access method "Copying the spread buffer by specifying |
//| start position and number of elements" |
//+------------------------------------------------------------------+
int CiSpread::GetData(const int start_pos,const int count,int &buffer[]) const
{
return(CopySpread(m_symbol,m_period,start_pos,count,buffer));
}
//+------------------------------------------------------------------+
//| API access method "Copying the spread buffer by specifying |
//| start time and number of elements" |
//+------------------------------------------------------------------+
int CiSpread::GetData(const datetime start_time,const int count,int &buffer[]) const
{
return(CopySpread(m_symbol,m_period,start_time,count,buffer));
}
//+------------------------------------------------------------------+
//| API access method "Copying the spread buffer by specifying |
//| start and end time" |
//+------------------------------------------------------------------+
int CiSpread::GetData(const datetime start_time,const datetime stop_time,int &buffer[]) const
{
return(CopySpread(m_symbol,m_period,start_time,stop_time,buffer));
}
//+------------------------------------------------------------------+
//| Set size buffer |
//+------------------------------------------------------------------+
bool CiSpread::BufferResize(const int size)
{
if(size>m_buffer_size && !CSeries::BufferResize(size))
return(false);
//-- history is avalible
CSpreadBuffer *buff=At(0);
//--- check pointer
if(buff==NULL)
return(false);
//---
buff.Size(size);
//--- ok
return(true);
}
//+------------------------------------------------------------------+
//| Refreshing of data |
//+------------------------------------------------------------------+
void CiSpread::Refresh(const int flags)
{
CSpreadBuffer *buff=At(0);
//--- check
if(buff==NULL)
return;
//--- refresh buffer
if(!(flags&m_timeframe_flags))
{
if(m_refresh_current)
buff.RefreshCurrent();
}
else
buff.Refresh();
}
//+------------------------------------------------------------------+
//| Class CTimeBuffer. |
//| Purpose: Class of buffer of time series. |
//| Derives from class CArrayLong. |
//+------------------------------------------------------------------+
class CTimeBuffer : public CArrayDatetime
{
protected:
string m_symbol; // symbol
ENUM_TIMEFRAMES m_period; // period
int m_freshed_data; // number of refreshed data
int m_size; // size of used history
public:
CTimeBuffer(void);
~CTimeBuffer(void);
//--- methods of access to protected data
void Size(const int size) { m_size=size; }
//--- methods of access to data
datetime At(const int index) const;
//--- method of refreshing of the data buffer
virtual bool Refresh(void);
virtual bool RefreshCurrent(void);
//--- methods of tuning
void SetSymbolPeriod(const string symbol,const ENUM_TIMEFRAMES period);
};
//+------------------------------------------------------------------+
//| Constructor |
//+------------------------------------------------------------------+
CTimeBuffer::CTimeBuffer(void) : m_symbol(""),
m_period(WRONG_VALUE),
m_freshed_data(0),
m_size(DEFAULT_BUFFER_SIZE)
{
ArraySetAsSeries(m_data,true);
}
//+------------------------------------------------------------------+
//| Destructor |
//+------------------------------------------------------------------+
CTimeBuffer::~CTimeBuffer(void)
{
}
//+------------------------------------------------------------------+
//| Access to data in a position |
//+------------------------------------------------------------------+
datetime CTimeBuffer::At(const int index) const
{
//--- check
if(index>=m_data_total)
return(0);
//---
return((datetime)CArrayDatetime::At(index));
}
//+------------------------------------------------------------------+
//| Refreshing of data buffer |
//+------------------------------------------------------------------+
bool CTimeBuffer::Refresh(void)
{
m_freshed_data=CopyTime(m_symbol,m_period,0,m_size,m_data);
//---
if(m_freshed_data>0)
{
m_data_total=ArraySize(m_data);
return(true);
}
//--- error
return(false);
}
//+------------------------------------------------------------------+
//| Refreshing of data buffer |
//+------------------------------------------------------------------+
bool CTimeBuffer::RefreshCurrent(void)
{
datetime array[1];
//---
if(CopyTime(m_symbol,m_period,0,1,array)==1 && m_data_total>0)
{
m_data[0]=array[0];
return(true);
}
//--- error
return(false);
}
//+------------------------------------------------------------------+
//| Set symbol and period |
//+------------------------------------------------------------------+
void CTimeBuffer::SetSymbolPeriod(const string symbol,const ENUM_TIMEFRAMES period)
{
m_symbol=(symbol==NULL) ? ChartSymbol() : symbol;
m_period=(period==0) ? ChartPeriod() : period;
}
//+------------------------------------------------------------------+
//| Class CiTime. |
//| Purpose: Class of time series. |
//| Derives from class CSeries. |
//+------------------------------------------------------------------+
class CiTime : public CSeries
{
public:
CiTime(void);
~CiTime(void);
//--- method of creation
bool Create(const string symbol,const ENUM_TIMEFRAMES period);
virtual bool BufferResize(const int size);
//--- methods of access to data
datetime GetData(const int index) const;
int GetData(const int start_pos,const int count,datetime &buffer[]) const;
int GetData(const datetime start_time,const int count,datetime &buffer[]) const;
int GetData(const datetime start_time,const datetime stop_time,datetime &buffer[]) const;
//--- method of refreshing of the data
virtual void Refresh(const int flags=OBJ_ALL_PERIODS);
};
//+------------------------------------------------------------------+
//| Constructor |
//+------------------------------------------------------------------+
CiTime::CiTime(void)
{
m_name="Time";
}
//+------------------------------------------------------------------+
//| Destructor |
//+------------------------------------------------------------------+
CiTime::~CiTime(void)
{
}
//+------------------------------------------------------------------+
//| Creating of the time series |
//+------------------------------------------------------------------+
bool CiTime::Create(const string symbol,const ENUM_TIMEFRAMES period)
{
CTimeBuffer *buff;
//--- check history
if(!SetSymbolPeriod(symbol,period))
return(false);
//--- create
if((buff=new CTimeBuffer)==NULL)
return(false);
//--- add
if(!Add(buff))
{
delete buff;
return(false);
}
//--- tune
buff.SetSymbolPeriod(m_symbol,m_period);
//--- ok
return(true);
}
//+------------------------------------------------------------------+
//| Method to access data |
//+------------------------------------------------------------------+
datetime CiTime::GetData(const int index) const
{
CTimeBuffer *buff=At(0);
//--- check
if(buff==NULL)
{
Print(__FUNCTION__,": invalid buffer");
return(0);
}
//---
return((datetime)buff.At(index));
}
//+------------------------------------------------------------------+
//| API access method "Copying the time buffer by specifying |
//| start position and number of elements" |
//+------------------------------------------------------------------+
int CiTime::GetData(const int start_pos,const int count,datetime &buffer[]) const
{
return(CopyTime(m_symbol,m_period,start_pos,count,buffer));
}
//+------------------------------------------------------------------+
//| API access method "Copying the time buffer by specifying |
//| start time and number of elements" |
//+------------------------------------------------------------------+
int CiTime::GetData(const datetime start_time,const int count,datetime &buffer[]) const
{
return(CopyTime(m_symbol,m_period,start_time,count,buffer));
}
//+------------------------------------------------------------------+
//| API access method "Copying the time buffer by specifying |
//| start and end time" |
//+------------------------------------------------------------------+
int CiTime::GetData(const datetime start_time,const datetime stop_time,datetime &buffer[]) const
{
return(CopyTime(m_symbol,m_period,start_time,stop_time,buffer));
}
//+------------------------------------------------------------------+
//| Set size buffer |
//+------------------------------------------------------------------+
bool CiTime::BufferResize(const int size)
{
if(size>m_buffer_size && !CSeries::BufferResize(size))
return(false);
//-- history is avalible
CTimeBuffer *buff=At(0);
//--- check pointer
if(buff==NULL)
return(false);
//---
buff.Size(size);
//--- ok
return(true);
}
//+------------------------------------------------------------------+
//| Refreshing of data |
//+------------------------------------------------------------------+
void CiTime::Refresh(const int flags)
{
CTimeBuffer *buff=At(0);
//--- check
if(buff==NULL)
return;
//--- refresh buffers
if(!(flags&m_timeframe_flags))
{
if(m_refresh_current)
buff.RefreshCurrent();
}
else
buff.Refresh();
}
//+------------------------------------------------------------------+
//| Class CTickVolumeBuffer. |
//| Purpose: Class of buffer of tick volume series. |
//| Derives from class CArrayLong. |
//+------------------------------------------------------------------+
class CTickVolumeBuffer : public CArrayLong
{
protected:
string m_symbol; // symbol
ENUM_TIMEFRAMES m_period; // period
int m_freshed_data; // number of refreshed data
int m_size; // size of used history
public:
CTickVolumeBuffer(void);
~CTickVolumeBuffer(void);
//--- methods of access to protected data
void Size(const int size) { m_size=size; }
//--- methods of access to data
long At(const int index) const;
//--- method of refreshing of the data buffer
virtual bool Refresh(void);
virtual bool RefreshCurrent(void);
//--- methods of tuning
void SetSymbolPeriod(const string symbol,const ENUM_TIMEFRAMES period);
};
//+------------------------------------------------------------------+
//| Constructor |
//+------------------------------------------------------------------+
CTickVolumeBuffer::CTickVolumeBuffer(void) : m_symbol(""),
m_period(WRONG_VALUE),
m_freshed_data(0),
m_size(DEFAULT_BUFFER_SIZE)
{
ArraySetAsSeries(m_data,true);
}
//+------------------------------------------------------------------+
//| Destructor |
//+------------------------------------------------------------------+
CTickVolumeBuffer::~CTickVolumeBuffer(void)
{
}
//+------------------------------------------------------------------+
//| Access to data in a position |
//+------------------------------------------------------------------+
long CTickVolumeBuffer::At(const int index) const
{
//--- check
if(index>=m_data_total)
return(0);
//---
return((datetime)CArrayLong::At(index));
}
//+------------------------------------------------------------------+
//| Refreshing of data buffer |
//+------------------------------------------------------------------+
bool CTickVolumeBuffer::Refresh(void)
{
m_freshed_data=CopyTickVolume(m_symbol,m_period,0,m_size,m_data);
//---
if(m_freshed_data>0)
{
m_data_total=ArraySize(m_data);
return(true);
}
//--- error
return(false);
}
//+------------------------------------------------------------------+
//| Refreshing of data buffer |
//+------------------------------------------------------------------+
bool CTickVolumeBuffer::RefreshCurrent(void)
{
long array[1];
//---
if(CopyTickVolume(m_symbol,m_period,0,1,array)==1 && m_data_total>0)
{
m_data[0]=array[0];
return(true);
}
//--- error
return(false);
}
//+------------------------------------------------------------------+
//| Set symbol and period |
//+------------------------------------------------------------------+
void CTickVolumeBuffer::SetSymbolPeriod(const string symbol,const ENUM_TIMEFRAMES period)
{
m_symbol=(symbol==NULL) ? ChartSymbol() : symbol;
m_period=(period==0) ? ChartPeriod() : period;
}
//+------------------------------------------------------------------+
//| Class CiTickVolume. |
//| Purpose: Class of tick volume series. |
//| Derives from class CSeries. |
//+------------------------------------------------------------------+
class CiTickVolume : public CSeries
{
public:
CiTickVolume(void);
~CiTickVolume(void);
//--- method of creation
bool Create(const string symbol,const ENUM_TIMEFRAMES period);
virtual bool BufferResize(const int size);
//--- methods of access to data
long GetData(const int index) const;
int GetData(const int start_pos,const int count,long &buffer[]) const;
int GetData(const datetime start_time,const int count,long &buffer[]) const;
int GetData(const datetime start_time,const datetime stop_time,long &buffer[]) const;
//--- method of refreshing of the data
virtual void Refresh(const int flags=OBJ_ALL_PERIODS);
};
//+------------------------------------------------------------------+
//| Constructor |
//+------------------------------------------------------------------+
CiTickVolume::CiTickVolume(void)
{
m_name="Volume";
}
//+------------------------------------------------------------------+
//| Destructor |
//+------------------------------------------------------------------+
CiTickVolume::~CiTickVolume(void)
{
}
//+------------------------------------------------------------------+
//| Creation of the tick volume series |
//+------------------------------------------------------------------+
bool CiTickVolume::Create(const string symbol,const ENUM_TIMEFRAMES period)
{
CTickVolumeBuffer *buff;
//--- check history
if(!SetSymbolPeriod(symbol,period))
return(false);
//--- create
if((buff=new CTickVolumeBuffer)==NULL)
return(false);
//--- add
if(!Add(buff))
{
delete buff;
return(false);
}
//--- tune
buff.SetSymbolPeriod(m_symbol,m_period);
//--- ok
return(true);
}
//+------------------------------------------------------------------+
//| Method to access data |
//+------------------------------------------------------------------+
long CiTickVolume::GetData(const int index) const
{
CTickVolumeBuffer *buff=At(0);
//--- check
if(buff==NULL)
{
Print(__FUNCTION__,": invalid buffer");
return(0);
}
//---
return(buff.At(index));
}
//+------------------------------------------------------------------+
//| API access method "Copying the tick volume buffer by specifying |
//| start position and number of elements" |
//+------------------------------------------------------------------+
int CiTickVolume::GetData(const int start_pos,const int count,long &buffer[]) const
{
return(CopyTickVolume(m_symbol,m_period,start_pos,count,buffer));
}
//+------------------------------------------------------------------+
//| API access method "Copying the tick volume buffer by specifying |
//| start time and number of elements" |
//+------------------------------------------------------------------+
int CiTickVolume::GetData(const datetime start_time,const int count,long &buffer[]) const
{
return(CopyTickVolume(m_symbol,m_period,start_time,count,buffer));
}
//+------------------------------------------------------------------+
//| API access method "Copying the tick volume buffer by specifying |
//| start and end time" |
//+------------------------------------------------------------------+
int CiTickVolume::GetData(const datetime start_time,const datetime stop_time,long &buffer[]) const
{
return(CopyTickVolume(m_symbol,m_period,start_time,stop_time,buffer));
}
//+------------------------------------------------------------------+
//| Set size buffer |
//+------------------------------------------------------------------+
bool CiTickVolume::BufferResize(const int size)
{
if(size>m_buffer_size && !CSeries::BufferResize(size))
return(false);
//-- history is avalible
CTickVolumeBuffer *buff=At(0);
//--- check pointer
if(buff==NULL)
return(false);
//--
buff.Size(size);
//--- ok
return(true);
}
//+------------------------------------------------------------------+
//| Refreshing of data |
//+------------------------------------------------------------------+
void CiTickVolume::Refresh(const int flags)
{
CTickVolumeBuffer *buff=At(0);
//--- check
if(buff==NULL)
return;
//--- refresh buffers
if(!(flags&m_timeframe_flags))
{
if(m_refresh_current)
buff.RefreshCurrent();
}
else
buff.Refresh();
}
//+------------------------------------------------------------------+
//| Class CRealVolumeBuffer. |
//| Purpose: Class of buffer of real volume series. |
//| Derives from class CArrayLong. |
//+------------------------------------------------------------------+
class CRealVolumeBuffer : public CArrayLong
{
protected:
string m_symbol; // symbol
ENUM_TIMEFRAMES m_period; // period
int m_freshed_data; // number of refreshed data
int m_size; // size of used history
public:
CRealVolumeBuffer(void);
~CRealVolumeBuffer(void);
//--- methods of access to protected data
void Size(const int size) { m_size=size; }
//--- methods of access to data
long At(const int index) const;
//--- method of refreshing of the data buffer
virtual bool Refresh(void);
virtual bool RefreshCurrent(void);
//--- methods of tuning
void SetSymbolPeriod(const string symbol,const ENUM_TIMEFRAMES period);
};
//+------------------------------------------------------------------+
//| Constructor |
//+------------------------------------------------------------------+
CRealVolumeBuffer::CRealVolumeBuffer(void) : m_symbol(""),
m_period(WRONG_VALUE),
m_freshed_data(0),
m_size(DEFAULT_BUFFER_SIZE)
{
ArraySetAsSeries(m_data,true);
}
//+------------------------------------------------------------------+
//| Destructor |
//+------------------------------------------------------------------+
CRealVolumeBuffer::~CRealVolumeBuffer(void)
{
}
//+------------------------------------------------------------------+
//| Access to data in a position |
//+------------------------------------------------------------------+
long CRealVolumeBuffer::At(const int index) const
{
//--- check
if(index>=m_data_total)
return(0);
//---
return((datetime)CArrayLong::At(index));
}
//+------------------------------------------------------------------+
//| Refreshing of data buffer |
//+------------------------------------------------------------------+
bool CRealVolumeBuffer::Refresh(void)
{
m_freshed_data=CopyRealVolume(m_symbol,m_period,0,m_size,m_data);
//---
if(m_freshed_data>0)
{
m_data_total=ArraySize(m_data);
return(true);
}
//--- error
return(false);
}
//+------------------------------------------------------------------+
//| Refreshing of data buffer |
//+------------------------------------------------------------------+
bool CRealVolumeBuffer::RefreshCurrent(void)
{
long array[1];
//---
if(CopyRealVolume(m_symbol,m_period,0,1,array)==1 && m_data_total>0)
{
m_data[0]=array[0];
return(true);
}
//--- error
return(false);
}
//+------------------------------------------------------------------+
//| Set symbol and period |
//+------------------------------------------------------------------+
void CRealVolumeBuffer::SetSymbolPeriod(const string symbol,const ENUM_TIMEFRAMES period)
{
m_symbol=(symbol==NULL) ? ChartSymbol() : symbol;
m_period=(period==0) ? ChartPeriod() : period;
}
//+------------------------------------------------------------------+
//| Class CiRealVolume. |
//| Purpose: Class of real volume series. |
//| Derives from class CSeries. |
//+------------------------------------------------------------------+
class CiRealVolume : public CSeries
{
public:
CiRealVolume(void);
~CiRealVolume(void);
//--- method of creation
bool Create(const string symbol,const ENUM_TIMEFRAMES period);
virtual bool BufferResize(const int size);
//--- methods of access to data
long GetData(const int index) const;
int GetData(const int start_pos,const int count,long &buffer[]) const;
int GetData(const datetime start_time,const int count,long &buffer[]) const;
int GetData(const datetime start_time,const datetime stop_time,long &buffer[]) const;
//--- method of refreshing of the data
virtual void Refresh(const int flags=OBJ_ALL_PERIODS);
};
//+------------------------------------------------------------------+
//| Constructor |
//+------------------------------------------------------------------+
CiRealVolume::CiRealVolume(void)
{
m_name="RealVolume";
}
//+------------------------------------------------------------------+
//| Destructor |
//+------------------------------------------------------------------+
CiRealVolume::~CiRealVolume(void)
{
}
//+------------------------------------------------------------------+
//| Creation of the real volume series |
//+------------------------------------------------------------------+
bool CiRealVolume::Create(const string symbol,const ENUM_TIMEFRAMES period)
{
CRealVolumeBuffer *buff;
//--- check history
if(!SetSymbolPeriod(symbol,period))
return(false);
//--- create
if((buff=new CRealVolumeBuffer)==NULL)
return(false);
//--- add
if(!Add(buff))
{
delete buff;
return(false);
}
//--- tune
buff.SetSymbolPeriod(m_symbol,m_period);
//--- ok
return(true);
}
//+------------------------------------------------------------------+
//| Method to access data |
//+------------------------------------------------------------------+
long CiRealVolume::GetData(const int index) const
{
CRealVolumeBuffer *buff=At(0);
//--- check
if(buff==NULL)
{
Print(__FUNCTION__,": invalid buffer");
return(0);
}
//---
return(buff.At(index));
}
//+------------------------------------------------------------------+
//| API access method "Copying the real volume buffer by specifying |
//| start position and number of elements" |
//+------------------------------------------------------------------+
int CiRealVolume::GetData(const int start_pos,const int count,long &buffer[]) const
{
return(CopyRealVolume(m_symbol,m_period,start_pos,count,buffer));
}
//+------------------------------------------------------------------+
//| API access method "Copying the real volume buffer by specifying |
//| start time and number of elements" |
//+------------------------------------------------------------------+
int CiRealVolume::GetData(const datetime start_time,const int count,long &buffer[]) const
{
return(CopyRealVolume(m_symbol,m_period,start_time,count,buffer));
}
//+------------------------------------------------------------------+
//| API access method "Copying the real volume buffer by specifying |
//| start and end time" |
//+------------------------------------------------------------------+
int CiRealVolume::GetData(const datetime start_time,const datetime stop_time,long &buffer[]) const
{
return(CopyRealVolume(m_symbol,m_period,start_time,stop_time,buffer));
}
//+------------------------------------------------------------------+
//| Set size buffer |
//+------------------------------------------------------------------+
bool CiRealVolume::BufferResize(const int size)
{
if(size>m_buffer_size && !CSeries::BufferResize(size))
return(false);
//-- history is avalible
CRealVolumeBuffer *buff=At(0);
//--- check pointer
if(buff==NULL)
return(false);
//--
buff.Size(size);
//--- ok
return(true);
}
//+------------------------------------------------------------------+
//| Refreshing of data |
//+------------------------------------------------------------------+
void CiRealVolume::Refresh(const int flags)
{
CRealVolumeBuffer *buff=At(0);
//--- check
if(buff==NULL)
return;
//--- refresh buffers
if(!(flags&m_timeframe_flags))
{
if(m_refresh_current)
buff.RefreshCurrent();
}
else
buff.Refresh();
}
//+------------------------------------------------------------------+
Reference in a new issueCopy permalink