usage_tool.cpp

来自「股票分析源代码」· C++ 代码 · 共 966 行 · 第 1/2 页

		if (!isspace(*rev_iter))
		{
			break;
		}
		
		i_pos ++ ;
	}	
	if (i_pos>0)
	{
		str_out.erase(str_out.size()-i_pos);
	}
	
	return str_out;
}

std::string& gnu::str_trim(std::string& str)
{
	int i_pos = 0;
	
	string::iterator iter;
	for (iter=str.begin();iter!=str.end();iter++)
	{
		if (!isspace(*iter))
		{
			break;
		}
		
		i_pos ++ ;
	}	
	if (i_pos>0)
	{
		str.erase(str.begin(),iter);
	}
	
	i_pos = 0;
	
	string::reverse_iterator rev_iter;
	for (rev_iter=str.rbegin();rev_iter!=str.rend();rev_iter++)
	{
		if (!isspace(*rev_iter))
		{
			break;
		}
		
		i_pos ++ ;
	}	
	if (i_pos>0)
	{
		str.erase(str.size()-i_pos);
	}
	
	return str;
}

char gnu::get_input_char()
{
	char ch_return = 0;
	char c = 0;
	int i = 0;
	//cin.flush();
	while (cin.get(c))
	{
		if (i == 0)
		{
			ch_return = c;
		}
		
		if (c == CR)
		{
			break;	
		}
		
		i++ ;
	}	
	
	return ch_return;
}

std::string gnu::get_input_str()
{
	string str_return;
	
	char c = 0;	
	
	while (cin.get(c))
	{
		if (c == CR)
		{
			break;	
		}
		
		str_return += c;
	}	
	
	return str_return;
}

std::string gnu::get_passwd(const char* p_ch_prompt)
{
#ifdef _MINGW32_
	return get_passwd_win(p_ch_prompt);
#else
	return get_passwd_unix(p_ch_prompt);
#endif

}

#ifdef _MINGW32_

std::string get_passwd_win(const char* p_ch_prompt)
{
	string str_in;
	int ch; 
		
	while ((ch = getch()) != CR_CIN)
	{
		str_in += ch;
		if (p_ch_prompt != NULL)
		{
			printf("%s",p_ch_prompt);
		}		
	} 
	
	return str_in;
}

#else // unix , cygwin ,linux
int tty_raw(int fd)
{
	struct termio tmp_mode;
	if (ioctl(fd,TCGETA,(char*)&tmp_mode) < 0)
	{
		return -1;	
	}
	
	tty_mode = tmp_mode;
	
	tmp_mode.c_iflag = 0;
	tmp_mode.c_oflag &= ~OPOST;
	tmp_mode.c_lflag &= ~(ISIG|ICANON|ECHO);;
	tmp_mode.c_cflag &= ~(CSIZE|PARENB);
	tmp_mode.c_cc[VMIN] = 1;
	tmp_mode.c_cc[VTIME] = 1;
	
	if (ioctl(fd,TCSETA,(char*)&tmp_mode) < 0)
	{
		return -1;	
	}
	
	return 0;
}

int tty_reset(int fd)
{
	if (ioctl(fd,TCSETA,(char*)&tty_mode) < 0)
	{
		return -1;	
	}
	
	return 0;
}

std::string get_passwd_unix(const char* p_ch_prompt)
{
	string str_in;
	//int ch = 0; 
	int fd = 0;
	
	if ((fd=open("/dev/tty",O_RDWR)) >= 0)
	{
		tty_raw(fd);
	}
	
	char c = 0;
	while(cin.get(c))
	{
		if (c == CR_CIN)
		{
			break;
		} else
		{
			str_in += c;
			if (p_ch_prompt != NULL)
			{
				printf("%s",p_ch_prompt);
			}			
			//printf("%d",c);
		}			
	}	
	
	if (fd >= 0)
	{
		tty_reset(fd);
	}
	
	return str_in;	
}

#endif //#ifdef _MINGW32_


bool gnu::str_split(const char* SOURCE, const char* DELIMITERS, std::vector<std::string>& vect_str)
{
	bool isTrue = false;
	
	if (SOURCE == NULL)
	{
		return isTrue;	
	}
	
	vect_str.clear();
	
	int i_len = strlen(SOURCE);
	int i_len_d = strlen(DELIMITERS);
	char* p_SOURCE = new char[i_len+i_len_d+64];
	char* p_chr_split ;
	
	strcpy(p_SOURCE,SOURCE);
	
	p_chr_split = strtok(p_SOURCE,DELIMITERS);	
	if (p_chr_split != NULL)
	{			
		isTrue = true;
		vect_str.push_back(p_chr_split);
		while ((p_chr_split=strtok(NULL,DELIMITERS)) != NULL)
		{
			vect_str.push_back(p_chr_split);
		}	
	} else
	{
		delete [] p_SOURCE;
		return isTrue;	
	}
	
	delete [] p_SOURCE;
	
	return isTrue;
}

/*
**  TRIM.C - Remove leading, trailing, & excess embedded spaces
**
**  public domain by Bob Stout
*/
char* gnu::trim(char *str)
{
      char *ibuf = str, *obuf = str;
      int i = 0, cnt = 0;

      /*
      **  Trap NULL
      */

      if (str)
      {
            /*
            **  Remove leading spaces (from RMLEAD.C)
            */

            for (ibuf = str; *ibuf && isspace(*ibuf); ++ibuf)
                  ;
            if (str != ibuf)
                  memmove(str, ibuf, ibuf - str);

            /*
            **  Collapse embedded spaces (from LV1WS.C)
            */

            while (*ibuf)
            {
                  if (isspace(*ibuf) && cnt)
                        ibuf++;
                  else
                  {
                        if (!isspace(*ibuf))
                              cnt = 0;
                        else
                        {
                              *ibuf = ' ';
                              cnt = 1;
                        }
                        obuf[i++] = *ibuf++;
                  }
            }
            obuf[i] = '\0';

            /*
            **  Remove trailing spaces (from RMTRAIL.C)
            */

            while (--i >= 0)
            {
                  if (!isspace(obuf[i]))
                        break;
            }
            obuf[++i] = '\0';
      }
      
      return str;
}

std::string gnu::space_append(const unsigned int i_str_len,const unsigned int i_max_len)
{
	string str_ret;
	
	if (i_str_len >= i_max_len)
	{
		return 	str_ret;
	}
	
	for (unsigned int i=i_str_len;i<i_max_len;i++)
	{
		str_ret += " ";
	}
	
	return str_ret;
}

int gnu::space_strip(const char *inp, char *retptr, const char *rej_set)
{
    size_t h_len, t_len;
    unsigned int loop;
    char* tmp = NULL;
    char* l_ptr = NULL;
    char* inptr = NULL;
    char* tmp1 = NULL;
    int newl = 0;
    char ch;

    if( NULL == inp )
    {
        printf("\nit is null string");
        return -1;
    }

    h_len = strspn(inp, rej_set);
    inptr = (char *)inp+h_len;

    tmp1 = (char *)calloc( sizeof(char), strlen(inptr)+1 );
    if( NULL == tmp1 )
    {
        printf("\ncan't get memory");
        return -1;
    }
    else
    {
        tmp = tmp1;
        l_ptr = inptr + strlen(inptr)-1;   //this 1 is '\0'
        for( loop = 0; loop < strlen(inptr)-1; loop++)
        {
            if( '\n' == *l_ptr )
            {
                l_ptr--;
                newl++;
                continue;
            }
            *tmp++ = *l_ptr--;
        }
        t_len = strspn(tmp1, rej_set);
        free(tmp1);
    }
    
    if( (strlen(inptr) - t_len - 1 - newl) < 0 )
    {
        printf("\nerror operator");
        return -1;
    }
    else
    {
        ch = *(inptr+strlen(inptr)-t_len-newl);
        *(inptr+strlen(inptr)-t_len-newl) = '\0';
        strncpy(retptr,inptr,strlen(inptr));
        *(retptr+strlen(inptr)) = '\0';
        *(inptr+strlen(inptr)-t_len-newl) = ch;
    }
    return 0;
}   //space_strip

std::string gnu::time_now(const char* p_ch_format)
{
	string str_format = "w";
	
	if (p_ch_format == NULL)
	{
		str_format = "%Y%m%d";
	} else
	{
		str_format = p_ch_format;
	}
	
	char p_ch_date_now[256];
	struct tm* p_tm_now = NULL;
	time_t tt_now = 0;
	
	memset(p_ch_date_now,'\0',sizeof(p_ch_date_now));
	
	tt_now = time(NULL);
	p_tm_now = localtime(&tt_now);
	strftime(p_ch_date_now ,sizeof(p_ch_date_now)-1 , str_format.c_str(),p_tm_now);
	
	return string(p_ch_date_now);
}

bool gnu::get_tm(struct tm& tm_time,const char* p_ch_time)
{
	bool isTrue = true;
	
	if (p_ch_time == NULL)
	{
		isTrue = false;
		return isTrue;
	}
		
	std::string str_tmp_time = "w";
	std::string str_tmp_md = "w";
	
	str_tmp_time = string(p_ch_time);
	
	if (str_tmp_time.size() < 8)
	{
		isTrue = false;
		return isTrue;
	}
		
	tm_time.tm_year = atoi(str_tmp_time.substr(0,4).c_str()) - 1900;
	
	// tm_time.tm_mon
	str_tmp_md = str_tmp_time.substr(4,2);
	//I18N_DEBUG(_("%s [%s:%l] str_tmp_time : %s \n"),str_tmp_time.c_str());
	//I18N_DEBUG(_("%s [%s:%l] str_tmp_md : %s \n"),str_tmp_md.c_str());
	if (str_tmp_md[0]=='0')
	{
		str_tmp_md = str_tmp_md[1];
	} 
	tm_time.tm_mon = atoi(str_tmp_md.c_str())-1;
	
	//tm_time.tm_mday
	str_tmp_md = str_tmp_time.substr(6,2);
	if (str_tmp_md[0]=='0')
	{
		str_tmp_md = str_tmp_md[1];
	}
	tm_time.tm_mday = atoi(str_tmp_md.c_str());	
	
	//I18N_DEBUG(_("%s [%s:%l] tm_time.tm_year : %d \n"),tm_time.tm_year);
	//I18N_DEBUG(_("%s [%s:%l] tm_time.tm_mon : %d \n"),tm_time.tm_mon);
	//I18N_DEBUG(_("%s [%s:%l] tm_time.tm_mday : %d \n"),tm_time.tm_mday);
	
	return isTrue;
}

bool gnu::diff_day(double& diff_time,const char* p_ch_time2,const char* p_ch_time1)
{
	bool isTrue = true;
	
	struct tm tm_last_time;
	struct tm tm_from_time;
	
	memset(&tm_last_time,0,sizeof(tm_last_time));
	memset(&tm_from_time,0,sizeof(tm_from_time));
	
	isTrue = get_tm(tm_last_time,p_ch_time2);
	if (!isTrue)
	{
		isTrue = false;
		return isTrue;	
	}
	
	isTrue = get_tm(tm_from_time,p_ch_time1);
	if (!isTrue)
	{
		isTrue = false;
		return isTrue;	
	}
		
	diff_time = difftime(mktime(&tm_last_time),mktime(&tm_from_time))/(60*60*24);
	
	//I18N_DEBUG(_("%s [%s:%l] diff_time : %f \n"),diff_time);
	
	return isTrue;
}