do_portfolio.cpp

股票分析源代码

			
			// add pfl_data to map
			std::vector<std::string> vect_str;
			str_split(pfl_data.code,".",vect_str);	
			if (vect_str.size()<2)
			{
				continue;
			}	
			
			//find pfl_sum_data
			//pfl_sum_data_temp_ptr = map_pfl_sum_data[vect_str[0]];
			pfl_sum_data_temp_ptr = find_map_pfl_sum_data(gnu::str_toupper(vect_str[0]),
				map_pfl_sum_data);	
			if (pfl_sum_data_temp_ptr.get() == NULL)
			{
				continue;
			}
			
			// test if found in vect_pfl_data
			bool is_found = false;
			is_found =binary_search(pfl_sum_data_temp_ptr->vect_pfl_data_ptr->begin(),
				pfl_sum_data_temp_ptr->vect_pfl_data_ptr->end(),
				pfl_data,hbstock2::PflDataSort);
			if (!is_found)
			{
				pfl_sum_data_temp_ptr->vect_pfl_data_ptr->push_back(pfl_data);
				//pfl_data_source.vect_cmb_init_stock.push_back(cmb_init_stock);
				stable_sort(pfl_sum_data_temp_ptr->vect_pfl_data_ptr->begin(),
					pfl_sum_data_temp_ptr->vect_pfl_data_ptr->end(),
					hbstock2::PflDataSort);
			}
			
			
		}	//for (unsigned int i=0;i<vect_selectordata_ptr->size();i++)	
	} // for (iter=map_data.begin();iter != map_data.end();iter++)
	
}
	
void hbstock2::treat_portfolio(MapPflSumData& map_pfl_sum_data,
	const unsigned int pfltool_id,	
	const char* p_ch_date,
	const char* p_file_name)
{
	PflObjectManger* p_manger = PflObjectMangerInst::instance();
	//PflObjectManger::DllObjectPtr pfl_tool_ptr;
	PortfolioToolPtr pfl_tool_ptr;
	//PflObjectManger::SetDllObjectPtr set_pfl_tool_ptr;
	
	// find pfl tool
	if (pfltool_id == 0)
	{		
		pfl_tool_ptr = p_manger->get_default_dllobject();
		if (pfl_tool_ptr.get() != NULL)
		{		  	
		  	I18N_DEBUG(_("%s [%s:%l] using portfplio tool : %s.\n"),pfl_tool_ptr->get_title().c_str());	
		  	
		} else
		{
			I18N_DEBUG(_("%s [%s:%l] Can't find Portfolio Tool. system exit.\n"));	
			return;
		}
		
	} else
	{
		pfl_tool_ptr = p_manger->get_dllobject(pfltool_id);
		
		if (pfl_tool_ptr.get() == NULL)
		{
			I18N_DEBUG(_("%s [%s:%l] Portfolio Tool is NULL. system exit.\n"));	
			return;
		}
	} //if (pfltool_id == 0)
	
	//pfl_tool_ptr->print_config_parameter();
	
	// sort data
	MapPflSumData::const_iterator iter;
	PflSumDataPtr pfl_sum_data_ptr;
		
	for (iter=map_pfl_sum_data.begin();iter != map_pfl_sum_data.end();iter++)
	{		
		pfl_sum_data_ptr = iter->second;
		
		if (pfl_sum_data_ptr->vect_pfl_data_ptr->size() == 0)
		{
			continue;	
		}
		
		stable_sort(pfl_sum_data_ptr->vect_pfl_data_ptr->begin(),
			pfl_sum_data_ptr->vect_pfl_data_ptr->end(),
			hbstock2::PflDataSort_selector_name);
	}
	
	// do portfolio	
	if (!pfl_tool_ptr->prepare())
	{
		I18N_INFO(_("%s %s return false when run prepare,\nIt means no need to run do_portfolio,system exit.\n"),
			pfl_tool_ptr->get_title().c_str());
		
		return;			
	}
	
	if (!pfl_tool_ptr->do_portfolio(map_pfl_sum_data))
	{
		I18N_INFO(_("%s don't find portfolio,system exit.\n"));
				
		return;			
	}
	
	if (!pfl_tool_ptr->post(map_pfl_sum_data))
	{
		I18N_INFO(_("%s don't find portfolio in post,system exit.\n"));
				
		return;			
	}
	
	// print result
	string str_out_file = "w";	
	std::ofstream ofs;
	
	char p_ch_date_tmp[256];
	struct tm* p_tm_now = NULL;
	time_t tt_now = 0;
	
	memset(p_ch_date_tmp,'\0',sizeof(p_ch_date_tmp));
	
	if (p_ch_date != NULL)
	{
		strcpy(p_ch_date_tmp,p_ch_date);
	} else
	{
		tt_now = time(NULL);
		p_tm_now = localtime(&tt_now);
		strftime(p_ch_date_tmp ,sizeof(p_ch_date_tmp)-1 , "%Y%m%d",p_tm_now);
	}
	
	print_pfl_result(cout,map_pfl_sum_data,pfl_tool_ptr);
	
	// get root_dir
	AppConfig* p_app_config = AppConfigInst::instance();
	
	if (p_file_name == NULL)
	{
		str_out_file = p_app_config->get_root_dir() + "/pfl_result" + string("/pfl-") + string(p_ch_date_tmp) + ".txt" ;
	} else
	{
		str_out_file = p_app_config->get_root_dir() + "/pfl_result" + "/" + string(p_file_name)  + "-" + string(p_ch_date_tmp) + ".txt" ;
	}
	
	
	ofs.open(str_out_file.c_str(),ofstream::app);
	if (!ofs)
	{
		cout << _("Can't Open file : ") << str_out_file << _(" to write!") << endl;
		
		return;
	}
		
	print_pfl_result(ofs,map_pfl_sum_data,pfl_tool_ptr,"\t");
	ofs.close();
	
	cout << endl << _("System also has written result to file : ") << str_out_file << endl;
	
}

void hbstock2::print_pfl_result(std::ostream& ofs ,const MapPflSumData& map_pfl_sum_data,
	const PortfolioToolPtr& pfl_tool_ptr,	
	const char* p_ch_prefix)
{	
	bool is_print_bad_stock_of_userdefined = false;
	bool is_print_bad_stock_of_selector = false;
	
	AppConfig* p_app_config = AppConfigInst::instance();
	string str_section = "general";
	string str_key = "is_print_bad_stock_of_userdefined";
	int i_print_bad_stock = 0;
	p_app_config->get_value(str_section,str_key,i_print_bad_stock,i_print_bad_stock);
	is_print_bad_stock_of_userdefined = (bool) i_print_bad_stock;
	
	str_key = "is_print_bad_stock_of_selector";
	i_print_bad_stock = 1;
	p_app_config->get_value(str_section,str_key,i_print_bad_stock,i_print_bad_stock);
	is_print_bad_stock_of_selector = (bool) i_print_bad_stock;
	
	ofs << "\n\t\t\t"<< _("Portfolio Result") << std::fixed << std::setprecision(2) << endl;
	
	ofs << "=================================================================================================" << endl;
	ofs << _("Portfolio Tool    : ") << pfl_tool_ptr->get_title() 
		<< " (" << pfl_tool_ptr->get_version() << ")" << endl;		
	ofs << "=================================================================================================" << endl;
		
	MapPflSumData::const_iterator iter;
	PflSumDataPtr pfl_sum_data_ptr;
		
	for (iter=map_pfl_sum_data.begin();iter != map_pfl_sum_data.end();iter++)
	{		
		pfl_sum_data_ptr = iter->second;
		pring_pfl_market_info_text(ofs,pfl_sum_data_ptr,
			is_print_bad_stock_of_userdefined,
			is_print_bad_stock_of_selector);			
		
	}	
	
	ofs << _("Note : 'X' is represent the stock is no stock data or stock data is invalid .") << endl;
	ofs << _("       '-' is represent the stock is not in portfolios .") << endl;
	
	ofs << "=================================================================================================" << endl;
	
}

void hbstock2::create_pfl_config_file(const char* p_ch_pfl_config_file_name)
{
	std::ofstream ofs;
	
	ofs.open(p_ch_pfl_config_file_name);
	if (!ofs)
	{
		
		I18N_ERROR(_("%s [%s:%l] Can't open pfl_data_file : %s to write.\n"),p_ch_pfl_config_file_name);		
		return;
	}
		
	ofs << "[pfl_y]" << endl;
	ofs << "\"title\"=\"" << _("Prapared Stocks") << "\"" << endl;
	ofs << "[pfl_z]" << endl;
	ofs << "\"title\"=\"" << _("buy Stocks") << "\"" << endl;
	ofs << endl;
	
	ofs.close();
}

void hbstock2::pring_pfl_market_info_text(std::ostream& ofs,
	const PflSumDataPtr& pfl_sum_data_ptr,
	const bool is_print_bad_stock_of_userdefined,
	const bool is_print_bad_stock_of_selector )
{
	if (pfl_sum_data_ptr->vect_pfl_data_ptr->size() == 0)
	{
		ofs << _("Data Source       : ") << pfl_sum_data_ptr->market_title 
			<< _(" (No Stocks Found)")
			<< endl;
		ofs << "------------------------------------------------------------------------------------------------" << endl;
		
		return;
	}
	
	unsigned int i_curr_day_size = 0;
	
	float f_rate_previous = 0;
	float f_rate_current = 0;
	float f_rate_diff = 0;
	bool is_found_prev = false;
	bool is_found_curr = false;
	bool is_no_data_prev = false;
	bool is_no_data_curr = false;
	
	bool is_printed_line_found = false;
	bool is_printed_line = false;
	
	ofs << _("Data Source       : ") << pfl_sum_data_ptr->market_title << endl;
	ofs << _("Treate Stocks     : ") << pfl_sum_data_ptr->vect_pfl_data_ptr->size() << endl;
	ofs << _("Use Index         : ") << pfl_sum_data_ptr->index_code << endl;
	
	ofs << _("Input Time        : ") << pfl_sum_data_ptr->input_day << endl;
	ofs << _("Calculate Time    : ") << pfl_sum_data_ptr->curr_day << endl;
	//ofs << _("Data Length       : ") << pfl_sum_data_ptr->pfl_day_len << endl;
	ofs << "------------------------------------------------------------------------------------------------" << endl;
			
		
	bool is_prev_invalid = false;
	bool is_curr_invalid = false;
					
	// current day
	i_curr_day_size = pfl_sum_data_ptr->vect_pfl_data_ptr->size();
	
	ofs << _("Current Day Portfolio Result (") 
		<< pfl_sum_data_ptr->curr_day
		<< _(") : ") << endl;
	ofs << "------------------------------------------------------------------------------------------------" << endl;
	ofs << _("No.\tStock Code\tPeriod\t\tSelector\t")
		<< pfl_sum_data_ptr->prev_day << "\t"
		<< pfl_sum_data_ptr->curr_day << "\t(+/-)" << endl;
	
	VectPflDataPtr vect_pfl_data_ptr;
	unsigned int i_max_len_slt_title = 15;
	
	vect_pfl_data_ptr = pfl_sum_data_ptr->vect_pfl_data_ptr;
	for (unsigned int z=0;z<i_curr_day_size;z++)
	{
		is_found_prev = (*vect_pfl_data_ptr)[z].is_included_prev_data;
		is_found_curr = (*vect_pfl_data_ptr)[z].is_included_curr_data;
		
		is_no_data_prev = (*vect_pfl_data_ptr)[z].is_no_data_prev;
		is_no_data_curr = (*vect_pfl_data_ptr)[z].is_no_data_curr;
				
		f_rate_previous = (*vect_pfl_data_ptr)[z].rate_prev_day;
		f_rate_current =  (*vect_pfl_data_ptr)[z].rate_curr_day;
		
		if(!is_printed_line_found)
		{
			if (is_found_prev && !is_found_curr)
			{				
				is_printed_line_found = true;
				ofs << "------------------------------------------------------------------------------------------------" << endl;
			}	
		}
		
		if (!is_printed_line)
		{
			if (!is_found_prev && !is_found_curr)
			{
				is_printed_line = true;
				
				if (pfl_sum_data_ptr->is_user_defined_type)
				{
					if (is_print_bad_stock_of_userdefined )
					{
						ofs << "------------------------------------------------------------------------------------------------" << endl;
					} else
					{
						break;
					}
				} else // selector selected
				{
					if (is_print_bad_stock_of_selector )
					{
						ofs << "------------------------------------------------------------------------------------------------" << endl;
					} else
					{
						break;
					}
				} //if (pfl_sum_data_ptr->is_user_defined_type)
				
			} //if (!is_found_prev && !is_found_curr)	
		} // if (!is_printed_line)
		
		if (f_rate_previous < 0)
		{
			is_prev_invalid = true;
		}
			
		if (f_rate_current < 0)
		{
			is_curr_invalid = true;
		}
			
		ofs << (z+1) << "\t"
			<< (*vect_pfl_data_ptr)[z].code ;
		
		// print Period
		switch((*vect_pfl_data_ptr)[z].period_type)
		{
		case SHORT_LINE:
			ofs << "\t"	<< _("ShortLine") ;
			break;
		case MIDDLE_LINE:
			ofs << "\t"	<< _("MiddleLine") ;
			break;			
		case LONG_LINE:
			ofs << "\t"	<< _("LongLine") ;
			break;
		}
		
		// print selector name
		ofs << "\t"	<< (*vect_pfl_data_ptr)[z].selector_title ;
		ofs << gnu::space_append(strlen((*vect_pfl_data_ptr)[z].selector_title),i_max_len_slt_title);
		
		ofs	<< "\t";
								
		if (is_found_prev)
		{
			ofs << f_rate_previous << "%" ;
			
		} else
		{
			if (is_no_data_prev)
			{
				ofs << "  X";
			} else
			{
				ofs << "  -";
			}
		} //if (is_found_prev)
			
		if (is_found_prev && f_rate_previous < -100.0)
		{
			ofs	<< "\t";
		} else
		{
			ofs	<< "\t\t";
		}
			
		if (is_found_curr)
		{
			ofs	<< f_rate_current << "%";
				
		} else
		{
			if (is_no_data_curr)
			{
				ofs << "  X";
			} else
			{
				ofs << "  -";
			}			
		} //if (is_found_curr)	
			
		if (f_rate_current < -100.0)
		{
			ofs	<< "\t";
		} else
		{
			ofs	<< "\t\t";
		}
							
		f_rate_diff = (*vect_pfl_data_ptr)[z].rate_diff ;
		
		if (!is_found_curr && !is_found_prev)
		{
			ofs << "  -";
		} else
		{
			if (f_rate_diff > 0) // 0
			{
				ofs << "+";
			} 				
			ofs << f_rate_diff << "%";			
		}	
			
		ofs	<< endl;				
	} //for (unsigned int z=0;z<i_curr_day_size;z++)			
				
		
	if (is_prev_invalid)
	{	        
		ofs << "------------------------------------------------------------------------------------------------" << endl;
		ofs << _("Note : ") << pfl_sum_data_ptr->prev_day
			<< _(" has Ratio < 0, It's a invalid portfolios")  << endl;
	}
		
	if (is_curr_invalid)
	{	
		if (!is_prev_invalid)
		{
			ofs << "------------------------------------------------------------------------------------------------" << endl;
		}
					
		ofs << _("Note : ") << pfl_sum_data_ptr->curr_day
			<< _(" has Ratio < 0, It's a invalid portfolios")  << endl;
	}	
	
	ofs << "=================================================================================================" << endl;
}