tdx_data.cpp

通达信数据源

#include "hbstock_dso_config.h"

#include <stdio.h>

#include <fstream> 
#include "tdx_data.h"
#include "gnu/usage_tool.h"

/* must be at the end of include */
#include "gnu/i18n_debug.h"

using namespace std;
using namespace hbstock2;
using namespace gnu;

//static const char* LOGFILE = gnu::FILENAME(__FILE__);
const int MAX_PATH_LEN = 256;
#define LOGFILE_Ptr gnu::FILENAME_Ptr(__FILE__).get()
static char LOGFILE[MAX_PATH_LEN];

TdxDataLoader::TdxDataLoader()
{	
	//get log file name
	strcpy(LOGFILE,LOGFILE_Ptr);
	
	const int MAX_PATH_LEN = 256;
	char location[MAX_PATH_LEN+1];
		
	AppConfig* p_app_config = AppConfigInst::instance();	
	strcpy(location,p_app_config->get_root_dir().c_str());
	
	bindtextdomain(HBSTOCK_DSO_PACKAGE, strcat(location,"/share/locale"));
	I18N_DEBUG(_DEBUG("%s\n"),_D("TdxDataLoader start..."));
	
	vect_market_ptr.reset(new VectMarket);	
	Market market;
	
	market.code = "SH";
	market.title = _D("Shang Hai");	
	vect_market_ptr->push_back(market);
	
	market.code = "SZ";
	market.title = _D("Shen Zhen");	
	vect_market_ptr->push_back(market);
	
	has_day_data = true;
	has_min5_data = false;
	
	set_name("tdx_data_loader");
	set_title(_D("tongdaxin dataloader"));
	set_version(HBSTOCK_DSO_VERSION);		
	
}


TdxDataLoader::~TdxDataLoader()
{	
	I18N_DEBUG(_D("%s [%s:%l] TdxDataLoader end.\n"));
}

void TdxDataLoader::init_inner()
{	
	init_config_parameter_key();	
	init_config_parameter();
	
	// set module config info
	m_module_config_ptr.reset(new ModuleConfig(get_name()));
	set_module_config_title();
	
	// check parameter is the newest version or not?
	string str_version_old = "w";
	if (m_module_config_ptr->get_value(m_version_key,str_version_old))
	{
		if (get_version() != str_version_old)
		{
			I18N_DEBUG(_D("%s [%s:%l] Update old version's config parameter.\n"));
			set_default_config_parameter();
		}
	} else
	{
		I18N_DEBUG(_D("%s [%s:%l] don't find config parameter, now set it to default config parameter.\n"));
		set_default_config_parameter();
	}
	
	reload_config_parameter();
	// debug config parameter
	/*	
	print_config_parameter();
	set_default_config_parameter();
	print_config_parameter();
	*/
	
}

void TdxDataLoader::set_module_config_title()
{
	gnu::VectConfigItem arr_item;
	gnu::ConfigItem item;
	item.type = 0;
	
	item.key = m_version_key;
	item.key_title = _D("Version");
	item.value = "1.0.0";	
	item.tip = _D("Version");
	item.type = 0;	
	arr_item.push_back(item);
	
	item.key = m_default_stock_sh_key;
	item.key_title = _D("Default Stocks of ShangHai");
	item.value = "60*";	
	item.tip = _D("Default Stocks of ShangHai,Format : 'stockcode*,*stockcode*' ,example : 60*");	
	item.type = 0;
	arr_item.push_back(item);
	
	item.key = m_default_stock_sz_key;
	item.key_title = _D("Default Stocks of ShenZhen");
	item.value = "000*,002*";	
	item.tip = _D("Default Stocks of ShenZhen,Format : 'stockcode*,*stockcode*' ,example : 000*,002*");	
	item.type = 0;
	arr_item.push_back(item);
	
	item.key = m_str_tdx_dir_key;
	item.key_title = _D("tdx installing directory");
	item.value = "D:/jcb_gx";
	//item.value = "/home/hbzhang/jcb_gx";
	item.tip = _D("tdx install directory,eg: D:/jcb_gx");	
	item.type = 8;
	arr_item.push_back(item);
	
	m_module_config_ptr->set_items_title(arr_item);
}

void TdxDataLoader::init_config_parameter_key()
{
	// set config key
	m_version_key = "version";	
	m_default_stock_sh_key = "default_stock_sh" ;	
	m_default_stock_sz_key = "default_stock_sz" ;
	m_str_tdx_dir_key = "tdx_dir";
	
}	
void TdxDataLoader::init_config_parameter()
{	
	m_str_tdx_dir = "D:/jcb_gx";
	m_default_stock_sh = "60*";
	m_default_stock_sz = "000*,002*";	
}

void TdxDataLoader::set_default_config_parameter()
{
	reload_config_parameter();	
	 
	m_module_config_ptr->remove_all();
	set_module_config_title();	
	init_config_parameter();
	
	m_module_config_ptr->set_value(m_str_tdx_dir_key,m_str_tdx_dir);
	m_module_config_ptr->set_value(m_version_key,get_version());
	m_module_config_ptr->set_value(m_default_stock_sh_key,m_default_stock_sh);
	m_module_config_ptr->set_value(m_default_stock_sz_key,m_default_stock_sz);
		
}

void TdxDataLoader::reload_config_parameter()
{	 
	string str_tmp = "w";
	
	m_module_config_ptr->refresh();
		
	if(m_module_config_ptr->get_value(m_default_stock_sh_key,str_tmp))
	{
		m_default_stock_sh = str_tmp;
	}
	
	if(m_module_config_ptr->get_value(m_default_stock_sz_key,str_tmp))
	{
		m_default_stock_sz = str_tmp;
	}
	
	if(m_module_config_ptr->get_value(m_str_tdx_dir_key,str_tmp))
	{
		m_str_tdx_dir = str_tmp;
	}	
}

void TdxDataLoader::print_config_parameter()
{
	ACE_DEBUG ((LM_DEBUG, "==============================================================\n"));
	
	ACE_DEBUG ((LM_DEBUG, "version : %s\n",get_version().c_str()));
	ACE_DEBUG ((LM_DEBUG, "tdx_dir : %s\n",m_str_tdx_dir.c_str()));
	ACE_DEBUG ((LM_DEBUG, "default_stock_sh : %s\n",m_default_stock_sh.c_str()));
	ACE_DEBUG ((LM_DEBUG, "default_stock_sz : %s\n",m_default_stock_sz.c_str()));	
	
	ACE_DEBUG ((LM_DEBUG, "==============================================================\n"));
}

int TdxDataLoader::info (ACE_TCHAR **str, size_t len) const
{	
	ACE_TCHAR* pchar_title = "tdx dataloader";	
	
	*str = new char[len];
	memset(*str,0,len);
	strncpy(*str,pchar_title,len);	
	
	return 0;
}

int TdxDataLoader::init (int argc, ACE_TCHAR *argv[])
{
	I18N_DEBUG(_DEBUG("%s\n"),_D("TdxDataLoader init..."));
	
	init_inner();
	
	return 0;
}

int TdxDataLoader::fini (void)
{

	return 0;	
}

const VectMarketPtr TdxDataLoader::get_support_market() const
{
	return vect_market_ptr;
}

bool TdxDataLoader::is_support_market(const std::string& market_code) const
{
	bool isTrue = false;
		
	for (unsigned int i=0;i<vect_market_ptr->size();i++)
	{
		if ((*vect_market_ptr)[i].code == str_toupper(market_code))
		{
			isTrue = true;
			break;
		}
	}
	
	return isTrue;
}

bool TdxDataLoader::is_support_day_data() const
{
	return has_day_data;
}

bool TdxDataLoader::is_support_min5_data() const 
{
	return has_min5_data;
}

bool TdxDataLoader::is_support_div(const std::string& str_market_code) const
{
	return false;
}	

std::string TdxDataLoader::get_day_data_dir(const std::string& str_market_code)
{	
	string str_tdx_day_data_dir = "w";	
		
	str_tdx_day_data_dir = m_str_tdx_dir + "/vipdoc/" + str_tolower(str_market_code) + "/lday";
	
	return str_tdx_day_data_dir;
}


bool TdxDataLoader::check_transform_stock_code(const std::string& str_stock_code_in,
    	std::string& str_stock_code_out,std::string& str_market_code)
{
	bool isTrue = false;
	
	if (str_stock_code_in.size()<3)
	{
		return isTrue;
	}
	
	std::vector<std::string> vect_str_stock_code;
	str_split(str_stock_code_in.c_str(),".",vect_str_stock_code);
	
	if (vect_str_stock_code.size() == 2)
	{
		str_market_code = vect_str_stock_code[0];
		str_stock_code_out = vect_str_stock_code[1];
		if (str_toupper(str_stock_code_out.substr(0,2)) != str_toupper(str_market_code))
		{
			str_stock_code_out = str_market_code + str_stock_code_out;
		}
		
		isTrue = true;
		return isTrue;
	} 
	
	string str_stock_code_tmp = str_toupper(str_stock_code_in);
	if ( str_stock_code_tmp == "SZZS")
	{
		isTrue = true;
		str_market_code = "SH";
		str_stock_code_out = str_market_code + "000001";
	} else if ( str_stock_code_tmp == "SZCZ")
	{
		isTrue = true;
		str_market_code = "SZ";
		str_stock_code_out = str_market_code + "399001";
	} else if ( str_stock_code_tmp == "SZZZ")
	{
		isTrue = true;
		str_market_code = "SZ";
		str_stock_code_out = str_market_code + "399106";
	} else if ( str_stock_code_tmp.substr(0,2) == "00") // stock A in SH
	{
		isTrue = true;
		str_market_code = "SZ";
		str_stock_code_out = str_market_code + str_stock_code_in;
	} else if ( str_stock_code_tmp.substr(0,2) == "60") // stock A in SH
	{
		isTrue = true;
		str_market_code = "SH";
		str_stock_code_out = str_market_code + str_stock_code_in;
	} else if ( str_stock_code_tmp.substr(0,3) == "500") // jijing  in SZ
	{
		isTrue = true;
		str_market_code = "SH";
		str_stock_code_out = str_market_code + str_stock_code_in;
	} else if ( str_stock_code_tmp.substr(0,3) == "900") // stock B in SH
	{
		isTrue = true;
		str_market_code = "SH";
		str_stock_code_out = str_market_code + str_stock_code_in;
	} else if ( str_stock_code_tmp.substr(0,2) == "39") // index in SZ
	{
		isTrue = true;
		str_market_code = "SZ";
		str_stock_code_out = str_market_code + str_stock_code_in;
	} else if ( str_stock_code_tmp.substr(0,3) == "200") // stock B in SZ
	{
		isTrue = true;
		str_market_code = "SZ";
		str_stock_code_out = str_market_code + str_stock_code_in;
	} else if ( str_stock_code_tmp.substr(0,2) == "18") // jijing  in SH
	{
		isTrue = true;
		str_market_code = "SZ";
		str_stock_code_out = str_market_code + str_stock_code_in;
	} else if ( str_stock_code_tmp.substr(0,2) == "16") // jijing  in SZ
	{
		isTrue = true;
		str_market_code = "SZ";
		str_stock_code_out = str_market_code + str_stock_code_in;
	}
	
	if (isTrue)
	{
		return isTrue;
	}
	
	string str_tdx_day_data_dir = "w";
	str_market_code = "SH";
	str_tdx_day_data_dir = get_day_data_dir(str_market_code);
	string str_file = str_tdx_day_data_dir + "/" + str_market_code + str_stock_code_in + ".day";
	//I18N_DEBUG(_("%s [%s:%l] str_file : %s \n"),str_file.c_str());
	
	std::ifstream ifs;
	std::ifstream ifs_sub;	
	ifs.open(str_file.c_str());
	if (!ifs)
	{
		str_market_code = "SZ";
		str_tdx_day_data_dir = get_day_data_dir(str_market_code);
		str_file = str_tdx_day_data_dir +  "/" + str_market_code + str_stock_code_in + ".day";
		//I18N_DEBUG(_("%s [%s:%l] str_file : %s \n"),str_file.c_str());
		
		ifs_sub.open(str_file.c_str());
		if (ifs_sub)
		{
			isTrue = true;
			str_market_code = "SZ";
			str_stock_code_out = str_market_code + str_stock_code_in;
			return isTrue;
		} 		
	} else
	{
		isTrue = true;
		str_market_code = "SH";
		str_stock_code_out = str_market_code + str_stock_code_in;
		return isTrue;
	}	
	
	//I18N_DEBUG(_("%s [%s:%l] str_stock_code_out : %s \n"),str_stock_code_out.c_str());
	
	return isTrue;
}

std::string TdxDataLoader::get_stock_code_of_index(const std::string& market_code)
{
	string str_stock_code = "SH.SH000001";
	
	if (str_toupper(market_code)=="SZ")
	{
		str_stock_code = "SZ.SZ399106";
	}
	
	return str_stock_code;
}

bool TdxDataLoader::get_stock_code(std::vector<std::string>& vect_stock_code,
    	const std::string& str_market_code,
    	const char* p_prefix_name)
    	throw (stock_data_exception)
{
	bool isTrue = false;

//#define _DEBUG_CHECK_ 1
	
	// init set --- start ----//
	vect_stock_code.clear();
	// init set --- end ----//
	
	if (str_toupper(str_market_code) != "SH" && str_toupper(str_market_code) != "SZ")
	{
		throw stock_data_exception(_D("Don't support the market!"));
	}

#ifdef	_DEBUG_CHECK_
	I18N_DEBUG(_("%s [%s:%l] TdxDataLoader::get_stock_code --> 1\n"));
#endif
	
	char p_prefix_name_temp[256];
	//const char* p_prefix_name_sh = "60*,900*";
	//const char* p_prefix_name_sz = "000*,002*,200*";
	//const char* p_prefix_name_sh = "SH60*";
	//const char* p_prefix_name_sz = "SZ000*,sz002*";
	memset(p_prefix_name_temp,0,sizeof(p_prefix_name));
	
	// check m_default_stock_sh and m_default_stock_sz
	m_default_stock_sh = gnu::str_toupper(gnu::str_trim(m_default_stock_sh));
	m_default_stock_sz = gnu::str_toupper(gnu::str_trim(m_default_stock_sz));
	
	string str_default_stock_tmp = "w";
	std::vector<std::string> vect_split_default_stock;
	
	str_split(m_default_stock_sh.c_str(),",",vect_split_default_stock);
	for (unsigned int i=0;i<vect_split_default_stock.size();i++)
	{
		if (i == 0)
		{
			str_default_stock_tmp = "SH" + vect_split_default_stock[i];
		} else
		{
			str_default_stock_tmp += ",SH" + vect_split_default_stock[i];
		}
	}
	m_default_stock_sh = str_default_stock_tmp ;
	
	str_split(m_default_stock_sz.c_str(),",",vect_split_default_stock);
	for (unsigned int i=0;i<vect_split_default_stock.size();i++)
	{
		if (i == 0)
		{
			m_default_stock_sz = "SZ" + vect_split_default_stock[i];
		} else
		{
			m_default_stock_sz += ",SZ" + vect_split_default_stock[i];
		}
	}
	
	std::vector<std::string> vect_split_name;
	
	if (p_prefix_name == NULL || strlen(p_prefix_name) == 0)
	{
		if (str_toupper(str_market_code) == "SH")
		{
			strcpy(p_prefix_name_temp,m_default_stock_sh.c_str());
		} else if (str_toupper(str_market_code) == "SZ")
		{
			strcpy(p_prefix_name_temp,m_default_stock_sz.c_str());
		}
	} else
	{
		str_split(str_toupper(p_prefix_name).c_str(),",",vect_split_name);