Beispiel #1
1
	void parse_ref_response(Message message, double** data){
		Element ReferenceDataResponse = message.asElement();
		ReferenceDataResponse.print(std::cout);
		if (ReferenceDataResponse.hasElement("responseError")){
			OutputDebugString(L"ERROR");
			return;
		}
		Element securityDataArray = message.getElement("securityData");
		int numItems = securityDataArray.numValues();
		double array[11];
		int sequenceNum;
		for (int i = 0; i < numItems; i++){
			Element securityData = securityDataArray.getValueAsElement(i);
			sequenceNum = securityData.getElementAsInt32("sequenceNumber");
			Element fieldData = securityData.getElement("fieldData");
			Datetime  maturity = fieldData.getElementAsDatetime("MATURITY"); 
			array[0] = (maturity.year()); //0
			array[1] = (maturity.month()); //1
			array[2] = (maturity.day()); //2
			Datetime  issue_dt = fieldData.getElementAsDatetime("ISSUE_DT"); 
			array[3] = (maturity.year() - issue_dt.year()); //3
			//newRow.push_back(issue_dt.month());
			//newRow.push_back(issue_dt.day());
			array[4] = (fieldData.getElementAsFloat64("DUR_ADJ_MID")); //4
			array[5] = (fieldData.getElementAsFloat64("LAST_PRICE")); //5
			array[6] = (fieldData.getElementAsFloat64("PX_LAST_EOD")); //6
			array[7] = (fieldData.getElementAsFloat64("YLD_YTM_MID")); //7
			array[8] = (fieldData.getElementAsFloat64("ASSET_SWAP_SPD_MID")); //8
			array[9] = (fieldData.getElementAsFloat64("BB_Z_SPREAD_TO_OIS_DISC_MID")); //9
			array[10] = (fieldData.getElementAsFloat64("BB_Z_SPREAD_TO_OIS_DISC_MID")); //10
		}
		for (int j = 0; j < 11; j++){
			data[sequenceNum][j] = array[j];
		}
	}
Beispiel #2
0
// CLASS METHODS
DatetimeTz CurrentTime::asDatetimeTz()
{
    Datetime now = utc();
    bsls::TimeInterval offset = LocalTimeOffset::localTimeOffset(now);
    now.addSeconds(offset.totalSeconds());

    BSLS_ASSERT((-1440                 < offset.totalMinutes()) && 
                (offset.totalMinutes() < 1440));
    return DatetimeTz(now, static_cast<int>(offset.totalMinutes()));
}
Beispiel #3
0
DatetimeList HKU_API getDateRange(const Datetime& start, const Datetime& end) {
    DatetimeList result;
    bd::date start_day = start.date();
    bd::date end_day = end.date();
    bd::date_period dp(start_day, end_day);
    bd::day_iterator iter = dp.begin();
    for (; iter != dp.end(); ++iter) {
        result.push_back(*iter);
    }
    return result;
}
Beispiel #4
0
 vector<int> retrieve(string s, string e, string gra) {
     Datetime start = parse(s);
     Datetime end = parse(e);
     start.setdefault(gra, true);
     end.setdefault(gra, false);
     auto iter = m.lower_bound(start);
     auto jter = m.upper_bound(end);
     vector<int> res;
     for(auto i = iter; i != jter; ++i)
         res.push_back(i->second);
     return res;
 }
Beispiel #5
0
void CheckOuterInstance(const Outer_Class& x)
{
    UT_ASSERT(x.booleanScalar_value()); //  == true
    UT_ASSERT(x.uint8Scalar_value() == 8);
    UT_ASSERT(x.sint8Scalar_value() == -8);
    UT_ASSERT(x.uint16Scalar_value() == 16);
    UT_ASSERT(x.sint16Scalar_value() == -16);
    UT_ASSERT(x.uint32Scalar_value() == 32);
    UT_ASSERT(x.sint32Scalar_value() == -32);
    UT_ASSERT(x.uint64Scalar_value() == 64);
    UT_ASSERT(x.sint64Scalar_value() == -64);
    UT_ASSERT(Close(x.real32Scalar_value(), 32.32));
    UT_ASSERT(Close(x.real64Scalar_value(), 64.64));
    UT_ASSERT(x.char16Scalar_value() == 16);

    {
        Datetime datetimeScalar;
        datetimeScalar.Set(MI_T("20091231120030.123456+360"));
        UT_ASSERT(x.datetimeScalar_value() == datetimeScalar);
    }

    UT_ASSERT(x.stringScalar_value() == ZT("string"));

    CheckInnerInstance(x.instanceScalar_value());

    UT_ASSERT(CheckArray<Boolean>::func(x.booleanArray_value(), true, false));
    UT_ASSERT(CheckArray<Uint8>::func(x.uint8Array_value(), 8, 8));
    UT_ASSERT(CheckArray<Sint8>::func(x.sint8Array_value(), -8, -8));
    UT_ASSERT(CheckArray<Uint16>::func(x.uint16Array_value(), 16, 16));
    UT_ASSERT(CheckArray<Sint16>::func(x.sint16Array_value(), -16, -16));
    UT_ASSERT(CheckArray<Uint32>::func(x.uint32Array_value(), 32, 32));
    UT_ASSERT(CheckArray<Sint32>::func(x.sint32Array_value(), -32, -32));
    UT_ASSERT(CheckArray<Uint64>::func(x.uint64Array_value(), 64, 64));
    UT_ASSERT(CheckArray<Sint64>::func(x.sint64Array_value(), -64, -64));
    UT_ASSERT(CheckArray<Real32>::func(x.real32Array_value(), 32.32f, 32.32f));
    UT_ASSERT(CheckArray<Real64>::func(x.real64Array_value(), 64.64, 64.64));
    UT_ASSERT(CheckArray<Char16>::func(x.char16Array_value(), 16, 16));
    UT_ASSERT(CheckArray<String>::func(x.stringArray_value(), 
        String(ZT("string")), String(ZT("string"))));

    {
        Datetime dt;
        dt.Set(ZT("20091231120030.123456+360"));
        UT_ASSERT(CheckArray<Datetime>::func(x.datetimeArray_value(), dt, dt));
    }

    {
        UT_ASSERT(x.instanceArray_value().GetSize() == 2);
        CheckInnerInstance(x.instanceArray_value()[0]);
        CheckInnerInstance(x.instanceArray_value()[1]);
    }
}
Beispiel #6
0
// [[Rcpp::export]]
List Datetime_get_functions(Datetime x) {
    Datetime dt = Datetime(x);
    return List::create(Named("year") = dt.getYear(),
                        Named("month") = dt.getMonth(),
                        Named("day") = dt.getDay(),
                        Named("wday") = dt.getWeekday(),
                        Named("hour") = dt.getHours(),
                        Named("minute") = dt.getMinutes(),
                        Named("second") = dt.getSeconds(),
                        Named("microsec") = dt.getMicroSeconds());
}
    void processMessage(Message &msg) {
        Element data = msg.getElement(BAR_DATA).getElement(BAR_TICK_DATA);
        int numBars = data.numValues();
        std::cout <<"Response contains " << numBars << " bars" << std::endl;
        std::cout <<"Datetime\t\tOpen\t\tHigh\t\tLow\t\tClose" <<
            "\t\tNumEvents\tVolume" << std::endl;
        for (int i = 0; i < numBars; ++i) {
            Element bar = data.getValueAsElement(i);
            Datetime time = bar.getElementAsDatetime(TIME);
            assert(time.hasParts(DatetimeParts::DATE
                               | DatetimeParts::HOURS
                               | DatetimeParts::MINUTES));
            double open = bar.getElementAsFloat64(OPEN);
            double high = bar.getElementAsFloat64(HIGH);
            double low = bar.getElementAsFloat64(LOW);
            double close = bar.getElementAsFloat64(CLOSE);
            int numEvents = bar.getElementAsInt32(NUM_EVENTS);
            long long volume = bar.getElementAsInt64(VOLUME);

            std::cout.setf(std::ios::fixed, std::ios::floatfield);
            std::cout << time.month() << '/' << time.day() << '/' << time.year()
                << " " << time.hours() << ":" << time.minutes()
                <<  "\t\t" << std::showpoint
                << std::setprecision(3) << open << "\t\t"
                << high << "\t\t"
                << low <<  "\t\t"
                << close <<  "\t\t"
                << numEvents <<  "\t\t"
                << std::noshowpoint
                << volume << std::endl;
        }
    }
Beispiel #8
0
KRecord Stock::
getKRecordByDate(const Datetime& datetime, KQuery::KType ktype) const {
    size_t startix = 0, endix = 0;
    KQuery query = KQueryByDate(datetime, Datetime(datetime.number() + 1), ktype);
    if (getIndexRange(query, startix, endix)) {
        return getKRecord(startix, ktype);
    }

    return Null<KRecord>();
}
Beispiel #9
0
const double bbgDatetimeToPOSIX(const Datetime& dt) {
  boost::gregorian::date bbg_boost_date(dt.year(),dt.month(),dt.day());
  boost::posix_time::time_duration td =
    boost::posix_time::hours(dt.hours()) +
    boost::posix_time::minutes(dt.minutes()) +
    boost::posix_time::seconds(dt.seconds()) +
    boost::posix_time::milliseconds(dt.milliseconds());

  boost::posix_time::ptime bbg_ptime(bbg_boost_date,td);
  struct tm tm_time(to_tm(bbg_ptime));
  return static_cast<double>(mktime(&tm_time));
}
Beispiel #10
0
    void setDatetime(MYSQL_BIND& bind, const Datetime& data)
    {
      reserve(bind, sizeof(MYSQL_TIME));
      memset(bind.buffer, 0, sizeof(MYSQL_TIME));

      MYSQL_TIME* ts = static_cast<MYSQL_TIME*>(bind.buffer);
      ts->year = data.getYear();
      ts->month = data.getMonth();
      ts->day = data.getDay();
      ts->hour = data.getHour();
      ts->minute = data.getMinute();
      ts->second = data.getSecond();

      bind.buffer_type = MYSQL_TYPE_DATE;
      bind.is_null = 0;
    }
Beispiel #11
0
Datetime Datetime::today() {
    Datetime x = Datetime::now();
    return Datetime(x.year(), x.month(), x.day());
}
PriceList HistoryFinanceReader
::getHistoryFinanceInfo(Datetime date, 
        const string& market, const string& code) {
    string funcname(" [HistoryFinanceReader::getHistoryFinanceInfo]");
    PriceList result;

    string filename(m_dir + "/gpcw" 
                   + boost::lexical_cast<string>(date.number() / 10000)
                   + ".dat");
    FILE *fp = fopen(filename.c_str(), "rb");
    if (NULL == fp) {
        HKU_INFO("Can't found " << filename << funcname);
        return result;
    }

    unsigned int report_date = 0;  
    unsigned short max_count = 0;
    unsigned long report_size = 0;
    
    char header_buf[20];
    if (!fread(header_buf, 1, 20, fp)) {
        HKU_ERROR("read data failed! " << filename << funcname);
        fclose(fp);
        return result;
    }

    memcpy(&report_date, header_buf + 2, 4);
    memcpy(&max_count, header_buf + 6, 2);
    memcpy(&report_size, header_buf + 12, 4);

    char stock_code[7];
    hku_uint32 address = 0;
    for (int i = 0; i < max_count; i++) {
        if (!fread(stock_code, 1, 7, fp)) {
            HKU_ERROR("read stock_code failed! " << filename << funcname);
            fclose(fp);
            return result;
        }

        if (!fread(&address, 4, 1, fp)) {
            HKU_ERROR("read stock_item address failed! " << filename << funcname);
            fclose(fp);
            return result;
        }

        stock_code[6] = '\0';
        if (strcmp(stock_code, code.c_str()) == 0) {
            break;
        }
    }

    if (address != 0) {
        const int MAX_COL_NUM = 350;
        float result_buffer[MAX_COL_NUM];
        int report_fields_count = int(report_size / 4);
        if (report_fields_count >= MAX_COL_NUM) {
            HKU_WARN("Over MAX_COL_NUM! " << filename << funcname);
            report_fields_count = MAX_COL_NUM;
        }
        
        fseek(fp, address, SEEK_SET);

        if (!fread(result_buffer, 4, report_fields_count, fp)) {
            HKU_ERROR("read col data failed! " << filename << funcname);
            fclose(fp);
            return result;
        }

        result.reserve(report_fields_count);
        price_t null_price = Null<price_t>();
        for (int i = 0; i < report_fields_count; i++) {
            if (result_buffer[i] == 0xf8f8f8f8) {
                result.push_back(null_price);
            } else {
                result.push_back(result_buffer[i]);
            }
        }
    
    } else {
        HKU_ERROR("Invalid address(0)! " << filename << funcname);
    }

    fclose(fp);
    return result;
}
Beispiel #13
0
//根据调度判断是否允许发送
bool CAlertMain::IsScheduleMatch(string strSchedule)
{
	if(strSchedule == "")
		return true;

	bool bReturn = false;	
	Datetime tm;
	int nDay;
	int nHour;	
	int nMin;  	
	nDay = tm.getDayOfWeek();
	nHour = tm.getHour();
	nMin = tm.getMinute();
	printf("%d:%d:%d ",nDay,nHour,nMin);

	//"Type"  "绝对任务计划"	"相对任务计划" 不存在"绝对任务计划"的情况, 应该在emailset.exe里屏蔽掉
	OBJECT hTask = GetTask(strSchedule);
	
	//if(GetTaskValue("Type", hTask) == "相对任务计划")
	{
		//相对调度条件参数
			
		char buf[256];
		string temp1 = "Allow";
		itoa(nDay, buf, 10);
		temp1 += buf;
		string temp = GetTaskValue(temp1, hTask);
		
		if(strcmp(temp.c_str(), "1") == 0)
		{				
			//允许	
			int nTaskStartHour = 0, nTaskEndHour = 0, nTaskStartMin = 0, nTaskEndMin = 0;
			int nTaskStart = 0, nTaskEnd = 0, nInput = 0;

			//开始
			temp1 = "start";
			temp1 += buf;
			std::list<string> pTmpList;	
			temp = GetTaskValue(temp1, hTask);
			CAlertMain::ParserToken(pTmpList, temp.c_str(), ":");

			sscanf(pTmpList.front().c_str(), "%d", &nTaskStartHour);
			sscanf(pTmpList.back().c_str(), "%d", &nTaskStartMin);
			
			//结束
			pTmpList.clear();
			temp1 = "end";
			temp1 += buf;
			temp = GetTaskValue(temp1, hTask);
			CAlertMain::ParserToken(pTmpList, temp.c_str(), ":");

			sscanf(pTmpList.front().c_str(), "%d", &nTaskEndHour);
			sscanf(pTmpList.back().c_str(), "%d", &nTaskEndMin);

			//比较
			nTaskStart = nTaskStartHour * 60 + nTaskStartMin;
			nTaskEnd = nTaskEndHour * 60 + nTaskEndMin;
			nInput = nHour * 60 +  nMin;

			if(nInput >= nTaskStart && nInput <= nTaskEnd)
				bReturn = true;
		}
		else
		{
			//禁止返回 false;
		}
	}

	return bReturn;
}
Beispiel #14
0
TEST(Datetime, defaultCtor) {
    Datetime time;

    ASSERT_EQ(time_t_to_str(std::time(0)), time.toString());
}
Beispiel #15
0
const double bbgDateToPOSIX(const Datetime& bbg_date) {
  boost::gregorian::date bbg_boost_date(bbg_date.year(),bbg_date.month(),bbg_date.day());
  struct tm tm_time(to_tm(bbg_boost_date));
  return static_cast<double>(mktime(&tm_time));
}
Beispiel #16
0
const int bbgDateToJulianDate(const Datetime& bbg_date) {
  const boost::gregorian::date r_epoch(1970,1,1);
  boost::gregorian::date bbg_boost_date(bbg_date.year(),bbg_date.month(),bbg_date.day());
  boost::gregorian::date_period dp(r_epoch,bbg_boost_date);
  return static_cast<int>(dp.length().days());
}