std::ostream& operator<<(std::ostream& os, const TimestampedReward& tsf)
{
os << "TimestampedReward: " << to_simple_string(tsf.timestamp);
for( std::map<int,double>::const_iterator it = tsf.values.begin(); it!= tsf.values.end(); it++) {
os << ", " << it->first << ":" << it->second;
}
return os;
}
/**
* \brief Function to return the difference between localtime and UTC time (seconds)
* \return the difference time (seconds)
*/
long vishnu::diffLocaltimeUTCtime() {
//the current time
boost::posix_time::ptime now = boost::posix_time::microsec_clock::local_time();
time_t currentTime = string_to_time_t(to_simple_string(now));
long diff = currentTime-std::time(0);
return diff;
}
/**
* \brief Function to localtime into UTC (seconds)
* \return the diffence time (seconds)
*/
time_t vishnu::convertLocaltimeINUTCtime(const time_t& localtime) {
//the current time
boost::posix_time::ptime now = boost::posix_time::microsec_clock::local_time();
time_t currentTime = string_to_time_t(to_simple_string(now));
long diff = currentTime-std::time(0);
return (localtime-diff);
}
void TestStockTime::test1()
{
date d(2002,Feb,1); //an arbitrary date
//construct a time by adding up some durations durations
StockTime t1(d, hours(5)+minutes(4)+seconds(2)+millisec(1));
//construct a new time by subtracting some times
StockTime t2 = t1 - hours(5)- minutes(4)- seconds(2)- millisec(1);
//construct a duration by taking the difference between times
time_duration td = t2 - t1;
std::cout << to_simple_string(t2) << " - "
<< to_simple_string(t1) << " = "
<< to_simple_string(td) << std::endl;
}
bool TestLogger::log(const std::string& logName, const lib_module::LogSeverity severity, const std::string logMessage) const{
boost::posix_time::ptime t = boost::posix_time::microsec_clock::local_time();
std::string logTime = to_simple_string(t);
std::cout << "[" << logTime << "]" << "[" << test_logger::sevTypes[severity] << "]" << "[" << logName << "]"
<< logMessage << std::endl;
return true;
}
//logging function to write error message to file
void StorageConverter::logErrorMessage(string errorMessage){
if(LOGGING_MODE_ON == true){
ofstream writeToLogFile;
string currentTime = to_simple_string(second_clock::local_time());
writeToLogFile.open(LOG_FILE_NAME, ios::app);
writeToLogFile << currentTime << endl << errorMessage << endl;
writeToLogFile << endl;
writeToLogFile.close();
}
return;
}
/*!\ingroup time_format
*/
inline
std::string
to_iso_extended_string(ptime t)
{
std::string ts = gregorian::to_iso_extended_string(t.date());// + "T";
if(!t.time_of_day().is_special()) {
return ts + "T" + to_simple_string(t.time_of_day());
}
else {
return ts;
}
}
void MainWindow::displaySwingAddOrderHistory(TradeItem *tradeItem)
{
QStandardItem* item1 = new QStandardItem(QString("%0").arg(tradeItem->getOrderRefId()));
QStandardItem* item2 = new QStandardItem(QString(tradeItem->getQuoteId().c_str()));
QStandardItem* item3 = new QStandardItem(QString(to_simple_string(tradeItem->getTradeTime()).c_str()));
QStandardItem* item4 = new QStandardItem(QString("%0").arg(tradeItem->getBuySell()));
QStandardItem* item5 = new QStandardItem(QString("%0").arg(tradeItem->getTradePrice()));
QStandardItem* item6 = new QStandardItem(QString("%0").arg(tradeItem->getQty()));
QStandardItem* item7 = new QStandardItem(QString("%0").arg(tradeItem->getStatus()));
QList<QStandardItem *> data;
data << item1 << item2 << item3 << item4 << item5 << item6 << item7;
swingorderhistorymodel_->insertRow(0, data);
}
void Account::InitFliterConfig(const std::string& aFliterConfig)
{
boost::property_tree::ptree lpt;
read_xml(aFliterConfig,lpt);
FliterStruct fliter;
int iID;
int iTime;
std::string strStopTime;
std::string strStartTime;
m_FilterSetting.Time1 = lpt.get<int>("Time1");
m_FilterSetting.Time2 = lpt.get<int>("Time2");
m_FilterSetting.Time3 = lpt.get<int>("Time3");
iTime = lpt.get<int>("TotalTimeProfit.Time");
m_FilterSetting.TotalTimeProfit[iTime] = lpt.get<int>("TotalTimeProfit.Profit");
m_FilterSetting.TotalProfitStop = lpt.get<int>("TotalProfitStop");
strStopTime = to_simple_string(boost::gregorian::day_clock::local_day())+" "+lpt.get<std::string>("SignalFliter.Item.StopTime");
m_FilterSetting.StopTime = boost::posix_time::time_from_string(strStopTime);
strStartTime = to_simple_string(boost::gregorian::day_clock::local_day())+" "+lpt.get<std::string>("SignalFliter.Item.StartTime");
m_FilterSetting.StartTime = boost::posix_time::time_from_string(strStartTime);
}
void logTextview::writeLog(std::string const& _s)
{
// Add a timestamp.
boost::posix_time::ptime t(boost::posix_time::second_clock::local_time());
std::string timestamp = to_simple_string(t);
// Add the string.
Glib::ustring us("[" + timestamp + "] " + _s + "\n");
Gtk::TextIter iter = get_buffer()->end();
get_buffer()->insert(iter, us);
// Scroll to the end of the buffer.
scroll_to_mark(get_buffer()->create_mark("end", get_buffer()->end()), 0.0);
}
int main()
{
std::cout << "Hello world!" << std::endl;
while (true)
{
ptime now = second_clock::local_time();
date today = now.date();
std::cout << to_simple_string(now) << std::endl;
std::cout << to_iso_string(now) << std::endl;
}
return 0;
}
void TestSupportLibrary::compareTasks(Task firstTask, Task secondTask) {
Assert::AreEqual(firstTask.getTaskName(), secondTask.getTaskName());
Assert::AreEqual(firstTask.getTaskIsDone(), secondTask.getTaskIsDone());
compareTaskTags(firstTask.getTaskTags(), secondTask.getTaskTags());
Assert::AreEqual(to_simple_string(firstTask.getTaskStartTime()),
to_simple_string(secondTask.getTaskStartTime()));
Assert::AreEqual(to_simple_string(firstTask.getTaskEndTime()),
to_simple_string(secondTask.getTaskEndTime()));
Assert::AreEqual(to_simple_string(firstTask.getTaskDeadline()),
to_simple_string(secondTask.getTaskDeadline()));
return;
}
Mask::Mask(int timeInterval, bool customMask, string customMaskPath, bool downsampleMask, CamPixFmt format, bool updateMask):
mUpdateInterval(timeInterval), mUpdateMask(updateMask) {
mMaskToCreate = false;
updateStatus = false;
refDate = to_simple_string(boost::posix_time::second_clock::universal_time());
satMap = boost::circular_buffer<Mat>(2);
// Load a mask from file.
if(customMask) {
mOriginalMask = imread(customMaskPath, CV_LOAD_IMAGE_GRAYSCALE);
SaveImg::saveJPEG(mOriginalMask, "/home/fripon/mOriginalMask");
if(!mOriginalMask.data)
throw "Fail to load the mask from its path.";
if(downsampleMask)
pyrDown(mOriginalMask, mOriginalMask, Size(mOriginalMask.cols/2, mOriginalMask.rows/2));
mOriginalMask.copyTo(mCurrentMask);
}else{
mMaskToCreate = true;
}
// Estimate saturated value.
switch(format) {
case MONO12 :
saturatedValue = 4092;
break;
default :
saturatedValue = 254;
}
}
void MainWindow::displaySwingAddPositions(Position *position)
{
QStandardItem *data = new QStandardItem(QString(position->getQuoteId().c_str()));
list<TradeItem *> tradeList = position->getTradeList();
for(list<TradeItem *>::const_iterator it = tradeList.begin(); it != tradeList.end(); ++it)
{
QStandardItem* item1 = new QStandardItem(QString("%0").arg((*it)->getOrderRefId()));
QStandardItem* item2 = new QStandardItem(QString((*it)->getQuoteId().c_str()));
QStandardItem* item3 = new QStandardItem(QString(to_simple_string((*it)->getTradeTime()).c_str()));
QStandardItem* item4 = new QStandardItem(QString("%0").arg((*it)->getBuySell()));
QStandardItem* item5 = new QStandardItem(QString("%0").arg((*it)->getTradePrice()));
QStandardItem* item6 = new QStandardItem(QString("%0").arg((*it)->getQty()));
QStandardItem* item7 = new QStandardItem(QString("%0").arg((*it)->getStatus()));
QList<QStandardItem *> child;
child << item1 << item2 << item3 << item4 << item5 << item6 << item7;
data->appendRow(child);
}
swingpositionsmodel_->insertRow(0, data);
}
void ReservationConfirmationEMailSubjectInterfacePage::display(
std::ostream& stream,
const ReservationTransaction& resa,
VariablesMap& variables,
const server::Request* request /*= NULL*/
) const {
ParametersVector pv;
pv.push_back(to_simple_string((*resa.getReservations().begin())->getDepartureTime().date())); // 0
pv.push_back((*resa.getReservations().begin())->getDeparturePlaceName()); // 1
pv.push_back((*resa.getReservations().rbegin())->getArrivalPlaceName()); // 2
InterfacePage::_display(
stream
, pv
, variables
, static_cast<const void*>(&resa)
, request
);
}
void save(Archive & ar,
const posix_time::time_duration& td,
unsigned int version)
{
// serialize a bool so we know how to read this back in later
bool is_special = td.is_special();
ar & make_nvp("is_special", is_special);
if(is_special) {
std::string s = to_simple_string(td);
ar & make_nvp("sv_time_duration", s);
}
else {
// Write support for earlier versions allows for upgrade compatibility testing
// See load comments for version information
if (version == 0) {
save_td<int32_t>(ar, td);
} else {
save_td<int64_t>(ar, td);
}
}
}
void save(Archive & ar,
const posix_time::time_duration& td,
unsigned int /*version*/)
{
// serialize a bool so we know how to read this back in later
bool is_special = td.is_special();
ar & make_nvp("is_special", is_special);
if(is_special) {
std::string s = to_simple_string(td);
ar & make_nvp("sv_time_duration", s);
}
else {
typename posix_time::time_duration::hour_type h = td.hours();
typename posix_time::time_duration::min_type m = td.minutes();
typename posix_time::time_duration::sec_type s = td.seconds();
typename posix_time::time_duration::fractional_seconds_type fs = td.fractional_seconds();
ar & make_nvp("time_duration_hours", h);
ar & make_nvp("time_duration_minutes", m);
ar & make_nvp("time_duration_seconds", s);
ar & make_nvp("time_duration_fractional_seconds", fs);
}
}
//! Converts a date to a tm struct. Throws out_of_range exception if date is a special value
inline
std::tm to_tm(const date& d)
{
if(d.is_pos_infinity() || d.is_neg_infinity() || d.is_not_a_date()){
#if defined(USE_DATE_TIME_PRE_1_33_FACET_IO)
std::string s("tm unable to handle date value of " + to_simple_string(d));
throw std::out_of_range(s);
#else
std::stringstream ss;
ss << "tm unable to handle date value of " << d;
throw std::out_of_range(ss.str());
#endif // USE_DATE_TIME_PRE_1_33_FACET_IO
}
std::tm datetm;
boost::gregorian::date::ymd_type ymd = d.year_month_day();
datetm.tm_year = ymd.year-1900;
datetm.tm_mon = ymd.month-1;
datetm.tm_mday = ymd.day;
datetm.tm_wday = d.day_of_week();
datetm.tm_yday = d.day_of_year()-1;
datetm.tm_hour = datetm.tm_min = datetm.tm_sec = 0;
datetm.tm_isdst = -1; // negative because not enough info to set tm_isdst
return datetm;
}
void BoostDateTimeTestCase::test_gregorian_lastDayOftheMonths()
{
// get a month and a year from the user
boost::gregorian::greg_year year(2000);
boost::gregorian::greg_month month(1);
try
{
int y(2022), m(11);
year = boost::gregorian::greg_year(y);
month = boost::gregorian::greg_month(m);
}
catch(boost::gregorian::bad_year by)
{
std::cout << "Invalid Year Entered: " << by.what() << '\n'
<< "Using minimum values for month and year." << std::endl;
}
catch(boost::gregorian::bad_month bm)
{
std::cout << "Invalid Month Entered" << bm.what() << '\n'
<< "Using minimum value for month. " << std::endl;
}
boost::gregorian::date start_of_next_year(year + 1, boost::gregorian::Jan, 1);
boost::gregorian::date d(year, month, 1);
// add another month to d until we enter the next year.
while(d < start_of_next_year)
{
std::cout << to_simple_string(d.end_of_month()) << std::endl;
d += boost::gregorian::months(1);
}
}
WLogEntry& WLogEntry::operator<< (const WLogger::TimeStamp&)
{
std::string dt = to_simple_string(microsec_clock::local_time());
return *this << '[' << dt << ']';
}
std::ostream& operator<<(std::ostream& os, const TimestampedString& tss)
{
os << "TimestampedString: " << to_simple_string(tss.timestamp) << ", " << tss.text;
return os;
}
void DBLogPurgeAction::run(Request& request)
{
// Action
DBLogEntryTableSync::Purge(_dbLog->getFactoryKey(), _endDate);
// Log
DBLog::AddSimpleEntry(_dbLog->getFactoryKey(), DBLogEntry::DB_LOG_INFO, "Log purge -> " + to_simple_string(_endDate), request.getUser().get());
}
void
book_manager::run() {
try {
zmq::socket_t receiver(*_context, ZMQ_SUB);
const char* filter = "";
receiver.setsockopt(ZMQ_SUBSCRIBE, filter, strlen(filter));
receiver.bind(_connectAddr.c_str());
fprintf(stdout, "book_manager: connect address: %s\n", _connectAddr.c_str());
fprintf(stdout, "book_manager: stop requested: %d\n", _stopRequested);
capkproto::instrument_bbo bbo;
while (1 && _stopRequested == false) {
// Extract the message from protobufs
zmq::message_t msg;
receiver.recv(&msg);
bbo.ParseFromArray(msg.data(), msg.size());
//char mic[MIC_LEN];
//STRCPY5(mic, bbo.mic());
capk::venue_id_t bid_venue_id = bbo.bid_venue_id();
capk::venue_id_t ask_venue_id = bbo.ask_venue_id();
#ifdef DEBUG
fprintf(stderr, "BID VENUE_ID: %d ASK VENUE_ID: %d", bid_venue_id, ask_venue_id);
#endif
char sym[SYMBOL_LEN];
STRCPY8(sym, bbo.symbol());
double bid_size = bbo.bid_size();
double ask_size = bbo.ask_size();
double bid_price = bbo.bid_price();
double ask_price = bbo.ask_price();
#ifdef DEBUG
boost::posix_time::ptime time_start(boost::posix_time::microsec_clock::local_time());
#endif
bool found_symbol = false;
bool found_venue = false;
// Add the price to the correct orderbook
// That is, receive an update for a SINGLE symbol on a SINGLE mic
// so just blindly update it in the book
for (unsigned int i = 0; i < SYMBOL_COUNT; i++) {
if (strncmp(sym, instruments[i].symbol, SYMBOL_LEN) == 0) {
found_symbol = true;
for (unsigned int j = 0; j < VENUE_COUNT; j++) {
// update the specific book that the price came from
if (instruments[i].venues[j].venue_id != capk::kNULL_VENUE_ID &&
instruments[i].venues[j].venue_id == bid_venue_id && instruments[i].venues[j].venue_id == ask_venue_id) {
found_venue = true;
instruments[i].venues[j].bid_price = bid_price;
instruments[i].venues[j].ask_price = ask_price;
instruments[i].venues[j].bid_size = bid_size;
instruments[i].venues[j].ask_size = ask_size;
clock_gettime(CLOCK_MONOTONIC, &instruments[i].venues[j].last_update);
break;
}
}
}
}
if (!found_symbol) {
std::cerr << "No matching symbol(book_manager): " << sym << "\n";
}
if (!found_venue) {
std::cerr << "No matching venue(book_manager): BID("
<< bid_venue_id
<< ") ASK("
<< ask_venue_id
<< ")" << "\n";
}
// Now go through all the books and pick the bbo
// check the time since last update and reset if too long
double bb = INT_MIN;
double ba = INT_MAX;
//char* bbmic = 0;
//char* bamic = 0;
double bbvol = 0;
double bavol = 0;
capk::venue_id_t bb_venue_id = capk::kNULL_VENUE_ID;
capk::venue_id_t ba_venue_id = capk::kNULL_VENUE_ID;
timespec now;
std::string msg_str;
unsigned long last_update_millis;
// find the symbol and mic in the book structure
for (unsigned int i = 0; i < SYMBOL_COUNT; i++) {
if (strncmp(sym, instruments[i].symbol, SYMBOL_LEN) == 0) {
found_symbol = true;
for (unsigned int j = 0; j < VENUE_COUNT; j++) {
if(instruments[i].venues[j].venue_id != capk::kNULL_VENUE_ID) {
// check the elapsed time since last update
clock_gettime(CLOCK_MONOTONIC, &now);
last_update_millis =
capk::timespec_delta_millis(instruments[i].venues[j].last_update, now);
// was the item ever updated?
/*
if (isZeroTimespec(instruments[i].mics[j].last_update)) {
fprintf(stderr, "<%s:%s>: NEVER UPDATED\n",
instruments[i].mics[j].MIC_name,
instruments[i].symbol);
}
*/
fprintf(stderr, "<%d:%s>: %f@%f (last update: %lu ms)",
instruments[i].venues[j].venue_id,
instruments[i].symbol,
instruments[i].venues[j].bid_price,
instruments[i].venues[j].ask_price,
last_update_millis);
if (last_update_millis > UPDATE_TIMEOUT_MILLIS) {
fprintf(stderr, "*** TIMEOUT ****");
instrument_reset(instruments[i].venues[j]);
}
fprintf(stderr, "\n");
#ifdef DEBUG
std::cerr << "Last update: " << instruments[i].venues[j].last_update << std::endl;
std::cerr << "Now : " << now << std::endl;
timespec tdelta =
capk::timespec_delta(instruments[i].venues[j].last_update, now);
std::cerr << "Tdelta : " << tdelta << std::endl;
fprintf(stderr, "<%s:%s>: ms since last update: %lu\n",
instruments[i].symbol,
capk::venue_id_to_mic_string(instruments[i].venues[j].venue_id),
last_update_millis);
fprintf(stderr, "<%s:%s>: %f@%f\n",
capk::venue_id_to_mic_string(instruments[i].venues[j].venue_id),
instruments[i].symbol,
instruments[i].venues[j].bid_price,
instruments[i].venues[j].ask_price);
#endif
}
if (instruments[i].venues[j].bid_price > bb) {
bb = instruments[i].venues[j].bid_price;
bb_venue_id = instruments[i].venues[j].venue_id;
bbvol = instruments[i].venues[j].bid_size;
}
if (instruments[i].venues[j].ask_price < ba) {
ba = instruments[i].venues[j].ask_price;
ba_venue_id = instruments[i].venues[j].venue_id;
bavol = instruments[i].venues[j].ask_size;
}
}
}
}
// Setup BBO and re-broadcast
fprintf(stderr, "\n***\n<%s> BB: %d:%f-%f BA: %d:%f-%f\n***\n",
sym,
bb_venue_id,
bb,
bbvol,
ba_venue_id,
ba,
bavol);
capkproto::instrument_bbo ins_bbo;
ins_bbo.set_symbol(sym);
ins_bbo.set_bid_venue_id(bb_venue_id);
ins_bbo.set_bid_price(bb);
ins_bbo.set_bid_size(bbvol);
ins_bbo.set_ask_venue_id(ba_venue_id);
ins_bbo.set_ask_price(ba);
ins_bbo.set_ask_size(bavol);
int msgsize = bbo.ByteSize();
if (msgsize > MSGBUF_SIZ) {
fprintf(stderr, "**\nins_bbo msg too large for buffer - DROPPING MSG!\n***");
//s_send(*bcast_sock, "ERR");
continue;
}
else {
ins_bbo.SerializeToString(&msg_str);
#ifdef DEBUG
fprintf(stderr, "Sending %d bytes\n", msgsize);
fprintf(stderr, "Sending %s \n", ins_bbo.DebugString().c_str());
#endif
}
s_sendmore(*bcast_sock, sym);
s_send(*bcast_sock, msg_str);
#ifdef DEBUG
boost::posix_time::ptime time_end(boost::posix_time::microsec_clock::local_time());
boost::posix_time::time_duration duration(time_end - time_start);
fprintf(stderr, "BookUpdate Time(us) to recv and parse: %s\n", to_simple_string(duration).c_str());
#endif
}
}
catch (std::exception& e) {
std::cerr << "EXCEPTION: " << __FILE__ << __LINE__ << e.what();
}
}
int main(int argc, char ** argv) {
if (argc < 2) {
std::cout << "ps7a [input file]" << std::endl;
return -1;
}
std::ifstream inputfile(argv[1]); ///< Opens input file based on argv[1]
if (!inputfile) {
std::cout << "Could not open " << argv[1] << std::endl;
return -1;
}
std::ofstream outputfile; ///< Opens output file based on argv[1] w/ .rpt
std::string outputfilename = argv[1];
outputfilename += ".rpt";
outputfile.open(outputfilename.c_str());
if (!outputfile) {
std::cout << "Could not open output file" << std::endl;
return -1;
}
int linenum = 0; ///< Keeps track of line number in file
std::string temp; ///< Stores line to use regex with
bool test = false; ///< To help determine if failure or not
std::string tdatet; ///< Stores the terminating time
std::string datet; ///< Stores the beginning time
boost::regex expression(".*\\(log\\.c\\.166\\) server started");
boost::regex expression2("[0-9]{2}:[0-6][0-9]:[0-9]{2}");
boost::regex expression3
(".*oejs\\.AbstractConnector:Started SelectChannelConnector");
boost::smatch fmatch;
boost::smatch dmatch;
boost::smatch sumatch;
/**
* This while loop gets a line from the file
*
* It then increases the line count since the linenum starts at
* 0 but the file starts at line 1
*
* The loop then checks to see if we already found success denoted by test. If
* test is true we then check to see if we match the correct terminating command
* If the command matches using regex, we than extract the time and subtract it from
* The starting time, we set test to false, and we output all this to the file.
*
* If test is true and we find another instance of the server starting, there was a failure
*
* The most important part of this loop tests to see when (log.c.166) is called which
* is an instance of the server starting. We record the line number its on, when it starts
* and then we move on to our checks by setting test to true.
*
*/
while (std::getline(inputfile, temp)) {
++linenum;
if (test) {
if (boost::regex_search(temp, sumatch, expression3)) {
outputfile << " success";
tdatet = sumatch[0];
if (boost::regex_search(tdatet, dmatch, expression2)) {
tdatet = dmatch[0];
boost::posix_time::time_duration time2
(boost::posix_time::duration_from_string(datet));
boost::posix_time::time_duration time1
(boost::posix_time::duration_from_string(tdatet));
time2 = time1 - time2;
std::string time = to_simple_string(time2);
outputfile << " " << time << std::endl;
}
test = false;
} else {
if (boost::regex_search(temp, fmatch, expression)) {
outputfile << " failure" << std::endl;
test = false;
}
}
} else {
if (boost::regex_search(temp, fmatch, expression)) {
datet = fmatch[0];
if (boost::regex_search(datet, dmatch, expression2)) {
outputfile << linenum << " " << datet;
datet = dmatch[0];
test = true;
}
}
}
}
/**
*
* If for some reason we reach the end of the file and the server was never
* properly shutdown, we get a success as it will do that automatically.
*
*/
if (test) {
outputfile << " success" << std::endl;
}
outputfile.close();
inputfile.close();
return 0;
}
void
worker::run () {
try {
assert(_context != NULL);
assert(_connectAddr.c_str() != NULL);
fprintf(stdout, "worker: connect address: %s\n", _connectAddr.c_str());
fprintf(stdout, "worker: stop requested: %d\n", _stopRequested);
zmq::socket_t subscriber(*_context, ZMQ_SUB);
subscriber.connect(_connectAddr.c_str());
const char* filter = "";
subscriber.setsockopt(ZMQ_SUBSCRIBE, filter, strlen(filter));
//capkproto::instrument_bbo bbo;
_inproc = new zmq::socket_t(*_context, ZMQ_PUB);
assert(_inproc);
_inproc->connect(_inprocAddr.c_str());
zmq::message_t msg;
while (1 && _stopRequested == false) {
subscriber.recv(&msg);
#ifdef DEBUG
boost::posix_time::ptime time_start(boost::posix_time::microsec_clock::local_time());
#endif
int64_t more;
size_t more_size;
more_size = sizeof(more);
subscriber.getsockopt(ZMQ_RCVMORE, &more, &more_size);
// send to orderbook on inproc socket - no locks needed according to zmq
_inproc->send(msg, more ? ZMQ_SNDMORE : 0);
#ifdef DEBUG
boost::posix_time::ptime time_end(boost::posix_time::microsec_clock::local_time());
boost::posix_time::time_duration duration(time_end - time_start);
fprintf(stderr, "Inbound from md interface time to receive and parse: %s\n", to_simple_string(duration).c_str());
#endif
}
}
catch (std::exception& e) {
std::cerr << "EXCEPTION: " << __FILE__ << __LINE__ << e.what();
}
}
void solve_const_value_in_wherecondition(Node *&cur)
{
if(cur==NULL)return;
switch(cur->type)
{
case t_name:
{
Columns *col=(Columns *)cur;
}break;
case t_name_name:
{
Columns *col=(Columns *)cur;
}break;
case t_query_stmt:
{
}break;
case t_expr_cal:
{
Expr_cal *node=(Expr_cal*)cur;
solve_const_value_in_wherecondition(node->lnext);
solve_const_value_in_wherecondition(node->rnext);
}break;
case t_expr_func:
{
Expr_func* node=(Expr_func *)cur;
string datestr;
date constdate(from_string("1990-10-01"));
if(strcmp(node->funname,"FDATE_ADD")==0)
{
if(node->args->type==t_stringval)
{
datestr=string(((Expr *)node->args)->data);
Expr_func *datefunc=(Expr_func *)node->parameter1;
assert(((Expr *)datefunc->args)->type==t_intnum);
if(strcmp(datefunc->funname,"INTERVAL_DAY")==0)
{
date_duration dd(atof(((Expr *)datefunc->args)->data));
constdate=date(from_string(datestr))+dd;
// date_duration *dd=new date_duration(atof(((Expr *)datefunc->args)->data));
// constdate=from_string(datestr)+(*(date_duration *)dd);
}
else if(strcmp(datefunc->funname,"INTERVAL_WEEK")==0)
{
weeks dd(atof(((Expr *)datefunc->args)->data));
constdate=date(from_string(datestr))+dd;
}
else if(strcmp(datefunc->funname,"INTERVAL_MONTH")==0)
{
months dd(atof(((Expr *)datefunc->args)->data));
constdate=date(from_string(datestr))+dd;
}
else if(strcmp(datefunc->funname,"INTERVAL_YEAR")==0)
{
years dd(atof(((Expr *)datefunc->args)->data));
constdate=date(from_string(datestr))+dd;
}
else if(strcmp(datefunc->funname,"INTERVAL_QUARTER")==0)
{
months dd(atof(((Expr *)datefunc->args)->data)*3);
constdate=date(from_string(datestr))+dd;
}
datestr=to_iso_extended_string(constdate);
char *datechar=(char *)malloc(datestr.length()+2);
strcpy(datechar,datestr.c_str());
// SQLParse_log("the date result after date_add, string= %s ------------------\n",datechar);
//free(cur);
cur=(Node *)newExpr(t_stringval,datechar);
}
}
else if(strcmp(node->funname,"FDATE_SUB")==0)
{
if(node->args->type==t_stringval)
{
datestr=string(((Expr *)node->args)->data);
Expr_func *datefunc=(Expr_func *)node->parameter1;
assert(((Expr *)datefunc->args)->type==t_intnum);
if(strcmp(datefunc->funname,"INTERVAL_DAY")==0)
{
date_duration dd(atof(((Expr *)datefunc->args)->data));
constdate=date(from_string(datestr))-dd;
}
else if(strcmp(datefunc->funname,"INTERVAL_WEEK")==0)
{
weeks dd(atof(((Expr *)datefunc->args)->data));
constdate=date(from_string(datestr))-dd;
}
else if(strcmp(datefunc->funname,"INTERVAL_MONTH")==0)
{
months dd(atof(((Expr *)datefunc->args)->data));
constdate=date(from_string(datestr))-dd;
}
else if(strcmp(datefunc->funname,"INTERVAL_YEAR")==0)
{
years dd(atof(((Expr *)datefunc->args)->data));
constdate=date(from_string(datestr))-dd;
}
else if(strcmp(datefunc->funname,"INTERVAL_QUARTER")==0)
{
months dd(atof(((Expr *)datefunc->args)->data)*3);
constdate=date(from_string(datestr))-dd;
}
datestr=to_simple_string(constdate);
char *datechar=(char *)malloc(datestr.length()+2);
strcpy(datechar,datestr.c_str());
// SQLParse_log("the date result after date_sub, string= %s ------------------\n",datechar);
//free(cur);
cur=(Node *)newExpr(t_stringval,datechar);
}
}
else
{
}
}break;
case t_expr_list:
{
Expr_list * node=(Expr_list *)cur;
}break;
default:
{
SQLParse_log("solve_const_value_in_wherecondition can't know the type=%d\n",cur->type);
}
}
}
bool Mask::applyMask(Mat &currFrame) {
if(mMaskToCreate) {
mOriginalMask = Mat(currFrame.rows, currFrame.cols, CV_8UC1,Scalar(255));
mOriginalMask.copyTo(mCurrentMask);
mMaskToCreate = false;
}
if(mUpdateMask) {
if(updateStatus) {
if(mCurrentMask.rows != currFrame.rows || mCurrentMask.cols != currFrame.cols) {
throw "Mask's size is not correct according to frame's size.";
}
// Reference date.
refDate = to_simple_string(boost::posix_time::second_clock::universal_time());
Mat saturateMap = ImgProcessing::buildSaturatedMap(currFrame, saturatedValue);
// Dilatation of the saturated map.
int dilation_size = 10;
Mat element = getStructuringElement(MORPH_RECT, Size(2*dilation_size + 1, 2*dilation_size+1), Point(dilation_size, dilation_size));
cv::dilate(saturateMap, saturateMap, element);
satMap.push_back(saturateMap);
if(satMap.size() == 2) {
Mat temp = satMap.front() & satMap.back();
bitwise_not(temp,temp);
temp.copyTo(mCurrentMask, mOriginalMask);
}
Mat temp; currFrame.copyTo(temp, mCurrentMask);
temp.copyTo(currFrame);
updateStatus = false;
return true; // Mask not applied, only computed.
}
string nowDate = to_simple_string(boost::posix_time::second_clock::universal_time());
boost::posix_time::ptime t1(boost::posix_time::time_from_string(refDate));
boost::posix_time::ptime t2(boost::posix_time::time_from_string(nowDate));
boost::posix_time::time_duration td = t2 - t1;
long diffTime = td.total_seconds();
if(diffTime >= mUpdateInterval) {
updateStatus = true;
}
cout << "NEXT MASK : " << (mUpdateInterval - (int)diffTime) << "s" << endl;
}
if(!mCurrentMask.data || (mCurrentMask.rows != currFrame.rows && mCurrentMask.cols != currFrame.cols)) {
mMaskToCreate = true;
return true;
}
Mat temp; currFrame.copyTo(temp, mCurrentMask);
temp.copyTo(currFrame);
return false; // Mask applied.
}
int main( ) {
boost::posix_time::ptime t ( boost::posix_time::second_clock::local_time( ) ) ;
std::cout << to_simple_string( t ) << std::endl ;
return 0 ;
}
/*
* Converts a date to today / tomorrow if it happens to match those dates
*/
std::string DisplayFeed::reprDate(std::string date){
if(date == to_simple_string(boost::gregorian::day_clock::local_day())){date = "Today";}
else if(date == to_simple_string(boost::gregorian::day_clock::local_day()+boost::gregorian::date_duration(1))){date = "Tomorrow";}
return date;
}
void NMEAServer::receiveCommand(Command_ptr command){
if(command->getCommand()=="exit" || command->getCommand()=="logout" || command->getCommand()=="close"){
//TODO call exit on all endpoints
raise(SIGTERM);
}
else if(command->getCommand()=="endpoints"){
std::ostringstream ss;
ss << "Currently " << online.size() << " endpoints connected" << std::endl << "---------------------------------------" << std::endl;
for (std::list<Endpoint_ptr>::const_iterator endpoint = online.begin(), end = online.end(); endpoint != end; ++endpoint) {
std::string state = getEndpointState();
if(state.length()>0){
state = "("+state+")";
}
ss << (*endpoint)->getId() << '\t' << state << std::endl;
}
command->answer(ss.str(), this->shared_from_this());
}
else if(command->getCommand()=="time"){
command->answer(to_simple_string(boost::posix_time::microsec_clock::local_time())+"\n", this->shared_from_this());
}
else if(command->getCommand()=="add"){
boost::regex reg("^([[:alnum:]]*)\\h?$");
boost::regex regArg("^([[:alnum:]]*)\\s([[:print:]]+)\\h?$");
boost::cmatch matches;
std::string type;
std::string args;
bool matched=false;
if(boost::regex_search(command->getArguments().c_str(), matches, regArg)){
type=std::string(matches[1].first, matches[1].second);
args=std::string(matches[2].first, matches[2].second);
matched=true;
}
else if(boost::regex_search(command->getArguments().c_str(), matches, reg)){
type=std::string(matches[1].first, matches[1].second);
args=std::string("");
matched=true;
}
if(matched){
if(type=="file" || type=="File"){
try
{
FileEndpoint::factory(this->shared_from_this(), args);
command->answer("New file Endpoint successfully created\n", this->shared_from_this());
}
catch (std::exception& e)
{
std::ostringstream oss;
oss << "FileEndpoint Exception: " << e.what();
log(oss.str());
}
}
else if(type=="tcp" || type=="TCP"){
try
{
TCPServer::factory(this->shared_from_this(), std::atoi(args.c_str()));
command->answer("New tcp Endpoint successfully created\n", this->shared_from_this());
}
catch (std::exception& e)
{
std::ostringstream oss;
oss << "TCPSession Exception: " << e.what();
log(oss.str());
}
}
else if(type=="serial"){
std::vector<std::string> strs;
try
{
boost::split(strs, args, boost::is_any_of("\t "));
if(strs.size()==2){
unsigned int boud = lexical_cast<unsigned int>(strs[1]);
SerialPort::factory(this->shared_from_this(), strs[0] ,boud);
command->answer("New SerialPort successfully created\n", this->shared_from_this());
}
else{
command->answer(Answer::WRONG_ARGS,"Cannot create serial. Argument must be \"device boudrate\"\n", this->shared_from_this());
}
}
catch (std::exception& e)
{
std::cerr << "serial: " << e.what() << "\n";
command->answer(Answer::WRONG_ARGS,"Cannot create serial. Argument must be \"device boudrate\"\n", this->shared_from_this());
}
}
else if(type=="GPSreceiver"){
GPSEndpoint::factory(this->shared_from_this());
command->answer("New GPSEndpoint successfully created\n", this->shared_from_this());
}
else if(type=="TimeEndpoint"){
TimeEndpoint::factory(this->shared_from_this());
command->answer("New TimeEndpoint successfully created\n", this->shared_from_this());
}
else if(type=="AISreceiver"){
AISEndpoint::factory(this->shared_from_this());
command->answer("New AISEndpoint successfully created\n", this->shared_from_this());
}
else if(type=="virtualAIVDO"){
try
{
if(args.length()==9){
unsigned int mmsi = lexical_cast<unsigned int>(args);
AIVDOEndpoint::factory(this->shared_from_this(), mmsi);
command->answer("New virtualAIVDO successfully created\n", this->shared_from_this());
}
else{
command->answer(Answer::WRONG_ARGS,"Cannot create virtualAIVDO. MMSI Arguemnt must be 9 digits\n", this->shared_from_this());
}
}
catch (std::exception& e)
{
std::cerr << "virtualAIVDO: " << e.what() << "\n";
command->answer(Answer::WRONG_ARGS,"Cannot create virtualAIVDO. MMSI Arguemnt must be 9 digits\n", this->shared_from_this());
}
}
else if(type=="MemoryStore"){
MemoryStoreEndpoint::factory(this->shared_from_this(), args);
command->answer("New MemoryStoreEndpoint successfully created\n", this->shared_from_this());
}
else if(type=="Compass"){
CompassEndpoint::factory(this->shared_from_this());
command->answer("New CompassEndpoint successfully created\n", this->shared_from_this());
}
else{
command->answer(Answer::WRONG_ARGS, "Cannot understand command Argument "+command->getArguments()+" for Command "+command->getCommand()+". No such endpoint type to create.\n", this->shared_from_this());
}
}
else{
command->answer(Answer::WRONG_ARGS, "Cannot understand command Argument "+command->getArguments()+" for Command "+command->getCommand()+"\n", this->shared_from_this());
}
}
else{
CommandEndpoint::receive(command);
}
}