bool CNotificationHelper::HasNotifications(const std::string &DevIdx)
{
std::stringstream s_str(DevIdx);
unsigned long long idxll;
s_str >> idxll;
return HasNotifications(idxll);
}
void CCameraHandler::ReloadCameras()
{
std::vector<std::string> _AddedCameras;
boost::lock_guard<boost::mutex> l(m_mutex);
m_cameradevices.clear();
std::stringstream szQuery;
std::vector<std::vector<std::string> > result;
std::vector<std::vector<std::string> >::const_iterator itt;
szQuery << "SELECT ID, Name, Address, Port, Username, Password, ImageURL FROM Cameras WHERE (Enabled == 1) ORDER BY ID";
result=m_sql.query(szQuery.str());
if (result.size()>0)
{
_log.Log(LOG_STATUS,"Camera: settings (re)loaded");
for (itt=result.begin(); itt!=result.end(); ++itt)
{
std::vector<std::string> sd=*itt;
cameraDevice citem;
std::stringstream s_str( sd[0] );
s_str >> citem.ID;
citem.Name = sd[1];
citem.Address = sd[2];
citem.Port = atoi(sd[3].c_str());
citem.Username = base64_decode(sd[4]);
citem.Password = base64_decode(sd[5]);
citem.ImageURL = sd[6];
m_cameradevices.push_back(citem);
_AddedCameras.push_back(sd[0]);
}
}
int main()
{
std::string word;
std::getline(std::cin,word);
std::stringstream s_str(word);
std::vector<std::string> words;
std::string a1,b1,c1,d1;
while (std::getline(s_str, word, ' ')){
words.push_back(word);
/* if(words.at(0))a1 = words.at(0);
if(words.at(1))b1 = words.at(1);
if(words.at(2))c1 = words.at(2);
if(words.at(3))d1 = words.at(3);*/
}
/*if(word.at(0))a1 = words.at(0);
else if(word.at(0) && word.at(1))b1 = words.at(1);
else if(word.at(2))c1 = words.at(2);
else if(word.at(3))d1 = words.at(3);
*/
std::cout<<words.size();
// std::cout<<a1<<b1<<c1<<d1;
}
std::vector<_tNotification> CNotificationHelper::GetNotifications(const std::string &DevIdx)
{
std::stringstream s_str(DevIdx);
unsigned long long idxll;
s_str >> idxll;
return GetNotifications(idxll);
}
bool CNotificationHelper::HasNotifications(const std::string &DevIdx)
{
std::stringstream s_str(DevIdx);
uint64_t idxll;
s_str >> idxll;
return HasNotifications(idxll);
}
int EmacsFile::fio_get_line( unsigned char *buf, int len )
{
fgets( s_str(buf), len, m_file );
if( ferror( m_file ) )
return -1;
if( feof( m_file ) )
return 0;
return get_fixup_buffer( buf, strlen( (const char *)buf ) );
}
void SentencePool::addSentence(target t, std::string s){
std::string token;
std::istringstream s_str(s);
std::vector<uint>* vec_tmp = new std::vector<uint>();
while(s_str >> token) {
vec_tmp->push_back(elex.getWord_or_add(token));
}
if (t == ref)
reference.push_back(vec_tmp);
else
guess.push_back(vec_tmp);
}
/**
* putString
*/
JSValueRef putStringForJSBuffer (JSContextRef ctx, JSObjectRef function, JSObjectRef object, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)
{
BUFFER(buffer);
ARGCOUNTMIN(1);
auto string = HyperloopToString(ctx,arguments[0]);
if (string!=nullptr)
{
std::wstring w_str(string->Begin());
std::string s_str(w_str.begin(), w_str.end());
const char *copy = s_str.c_str();
size_t length = strlen(copy);
CHECK_SIZE_AND_GROW(length,0);
memcpy(buffer->buffer,copy,length);
}
return JSValueMakeUndefined(ctx);
}
void CSBFSpot::ImportOldMonthData()
{
_log.Log(LOG_STATUS, "SBFSpot Import Old Month Data: Start");
//check if this device exists in the database, if not exit
bool bDeviceExits = true;
std::vector<std::vector<std::string> > result;
result = m_sql.safe_query("SELECT ID FROM DeviceStatus WHERE (HardwareID==%d) AND (DeviceID=='%q') AND (Type==%d) AND (Subtype==%d)",
m_HwdID, "00000001", int(pTypeGeneral), int(sTypeKwh));
if (result.size() < 1)
{
//Lets create the sensor, and try again
SendMeter(0, 1, 0, 0, "SolarMain");
result = m_sql.safe_query("SELECT ID FROM DeviceStatus WHERE (HardwareID==%d) AND (DeviceID=='%q') AND (Type==%d) AND (Subtype==%d)",
m_HwdID, "00000001", int(pTypeGeneral), int(sTypeKwh));
if (result.size() < 1)
{
_log.Log(LOG_ERROR, "SBFSpot Import Old Month Data: FAILED - Cannot find sensor in database");
return;
}
}
unsigned long long ulID;
std::stringstream s_str(result[0][0]);
s_str >> ulID;
//Try actual year, and previous year
time_t atime = time(NULL);
struct tm ltime;
localtime_r(&atime, <ime);
int totyearsback = 2;
int startYear = ltime.tm_year + 1900 - totyearsback;
for (int iYear = startYear; iYear != startYear + 1 + totyearsback; iYear++)
{
for (int iMonth = 1; iMonth != 12+1; iMonth++)
{
ImportOldMonthData(ulID,iYear, iMonth);
}
}
_log.Log(LOG_STATUS, "SBFSpot Import Old Month Data: Complete");
}
void CScheduler::ReloadSchedules()
{
boost::lock_guard<boost::mutex> l(m_mutex);
m_scheduleitems.clear();
std::stringstream szQuery;
std::vector<std::vector<std::string> > result;
//Add Device Timers
szQuery << "SELECT T1.DeviceRowID, T1.Time, T1.Type, T1.Cmd, T1.Level, T1.Days, T2.Name, T2.Used, T1.UseRandomness, T1.Hue, T1.[Date] FROM Timers as T1, DeviceStatus as T2 WHERE ((T1.Active == 1) AND (T1.TimerPlan == " << m_sql.m_ActiveTimerPlan << ") AND (T2.ID == T1.DeviceRowID)) ORDER BY T1.ID";
result = m_sql.query(szQuery.str());
if (result.size() > 0)
{
std::vector<std::vector<std::string> >::const_iterator itt;
for (itt = result.begin(); itt != result.end(); ++itt)
{
std::vector<std::string> sd = *itt;
bool bDUsed = (atoi(sd[7].c_str()) != 0);
if (bDUsed == true)
{
tScheduleItem titem;
titem.bEnabled = true;
titem.bIsScene = false;
titem.bIsThermostat = false;
_eTimerType timerType = (_eTimerType)atoi(sd[2].c_str());
std::stringstream s_str(sd[0]);
s_str >> titem.RowID;
titem.startHour = (unsigned char)atoi(sd[1].substr(0, 2).c_str());
titem.startMin = (unsigned char)atoi(sd[1].substr(3, 2).c_str());
titem.startTime = 0;
titem.timerType = timerType;
titem.timerCmd = (_eTimerCommand)atoi(sd[3].c_str());
titem.Level = (unsigned char)atoi(sd[4].c_str());
titem.bUseRandmoness = (atoi(sd[8].c_str()) != 0);
titem.Hue = atoi(sd[9].c_str());
if (timerType == TTYPE_FIXEDDATETIME)
{
std::string sdate = sd[10];
if (sdate.size() != 10)
continue; //invalid
titem.startYear = (unsigned short)atoi(sdate.substr(0, 4).c_str());
titem.startMonth = (unsigned char)atoi(sdate.substr(5, 2).c_str());
titem.startDay = (unsigned char)atoi(sdate.substr(8, 2).c_str());
}
if ((titem.timerCmd == TCMD_ON) && (titem.Level == 0))
{
titem.Level = 100;
}
titem.Days = atoi(sd[5].c_str());
titem.DeviceName = sd[6];
if (AdjustScheduleItem(&titem, false) == true)
m_scheduleitems.push_back(titem);
}
else
{
void test_op_plus (charT, Traits*, Allocator*,
const StringFunc &func,
const StringTestCase &tcase)
{
typedef std::basic_string <charT, Traits, Allocator> String;
typedef typename UserTraits<charT>::MemFun UTMemFun;
static const std::size_t BUFSIZE = 256;
static charT wstr_buf [BUFSIZE];
static charT warg_buf [BUFSIZE];
std::size_t str_len = sizeof wstr_buf / sizeof *wstr_buf;
std::size_t arg_len = sizeof warg_buf / sizeof *warg_buf;
charT* wstr = rw_expand (wstr_buf, tcase.str, tcase.str_len, &str_len);
charT* warg = rw_expand (warg_buf, tcase.arg, tcase.arg_len, &arg_len);
static charT wres_buf [BUFSIZE];
std::size_t res_len = sizeof wres_buf / sizeof *wres_buf;
charT* wres = rw_expand (wres_buf, tcase.res, tcase.nres, &res_len);
// construct the string object to be modified
// and the (possibly unused) argument string
/* const */ String s_str (wstr, str_len);
const String s_arg (warg, arg_len);
if (wstr != wstr_buf)
delete[] wstr;
if (warg != warg_buf)
delete[] warg;
wstr = 0;
warg = 0;
String s_res;
// save the state of the string object before the call
// to detect wxception safety violations (changes to
// the state of the object after an exception)
const StringState str_state (rw_get_string_state (s_res));
const charT* const arg1_ptr = tcase.str ? s_str.c_str () : s_arg.c_str ();
const String& arg1_str = tcase.str ? s_str : s_arg;
const charT* const arg2_ptr = tcase.arg ? s_arg.c_str () : s_str.c_str ();
const String& arg2_str = tcase.arg ? s_arg : s_str;
const charT arg_val = make_char (char (tcase.val), (charT*)0);
std::size_t total_length_calls = 0;
std::size_t n_length_calls = 0;
std::size_t* const rg_calls = rw_get_call_counters ((Traits*)0, (charT*)0);
if (rg_calls)
total_length_calls = rg_calls [UTMemFun::length];
rwt_free_store* const pst = rwt_get_free_store (0);
SharedAlloc* const pal = SharedAlloc::instance ();
// iterate for`throw_after' starting at the next call to operator new,
// forcing each call to throw an exception, until the function finally
// succeeds (i.e, no exception is thrown)
std::size_t throw_count;
for (throw_count = 0; ; ++throw_count) {
// (name of) expected and caught exception
const char* expected = 0;
const char* caught = 0;
#ifndef _RWSTD_NO_EXCEPTIONS
if (0 == tcase.bthrow) {
// by default excercise the exception safety of the function
// by iteratively inducing an exception at each call to operator
// new or Allocator::allocate() until the call succeeds
expected = exceptions [3]; // bad_alloc
*pst->throw_at_calls_ [0] = pst->new_calls_ [0] + throw_count + 1;
pal->throw_at_calls_ [pal->m_allocate] =
pal->throw_at_calls_ [pal->m_allocate] + throw_count + 1;
}
else {
// exceptions disabled for this test case
}
#else // if defined (_RWSTD_NO_EXCEPTIONS)
if (tcase.bthrow) {
if (wres != wres_buf)
delete[] wres;
return;
}
#endif // _RWSTD_NO_EXCEPTIONS
// start checking for memory leaks
rw_check_leaks (s_res.get_allocator ());
try {
switch (func.which_) {
case OpPlus (cptr_cstr):
s_res = arg1_ptr + arg2_str;
if (rg_calls)
n_length_calls = rg_calls [UTMemFun::length];
break;
case OpPlus (cstr_cstr):
s_res = arg1_str + arg2_str;
break;
case OpPlus (cstr_cptr):
s_res = arg1_str + arg2_ptr;
if (rg_calls)
n_length_calls = rg_calls [UTMemFun::length];
break;
case OpPlus (cstr_val):
s_res = arg1_str + arg_val;
break;
case OpPlus (val_cstr):
s_res = arg_val + arg2_str;
break;
default:
RW_ASSERT ("test logic error: unknown operator+ overload");
return;
}
// verfiy that strings length are equal
rw_assert (res_len == s_res.size (), 0, tcase.line,
"line %d. %{$FUNCALL} expected %{#*s} "
"with length %zu, got %{/*.*Gs} with length %zu",
__LINE__, int (tcase.nres), tcase.res, res_len,
int (sizeof (charT)), int (s_res.size ()),
s_res.c_str (), s_res.size ());
if (res_len == s_res.size ()) {
// if the result length matches the expected length
// (and only then), also verify that the modified
// string matches the expected result
const std::size_t match =
rw_match (tcase.res, s_res.c_str(), s_res.size ());
rw_assert (match == res_len, 0, tcase.line,
"line %d. %{$FUNCALL} expected %{#*s}, "
"got %{/*.*Gs}, difference at offset %zu",
__LINE__, int (tcase.nres), tcase.res,
int (sizeof (charT)), int (s_res.size ()),
s_res.c_str (), match);
}
// verify that Traits::length was used
if ((OpPlus (cptr_cstr) == func.which_
|| OpPlus (cstr_cptr) == func.which_) && rg_calls) {
rw_assert (n_length_calls - total_length_calls > 0,
0, tcase.line, "line %d. %{$FUNCALL} doesn't "
"use traits::length()", __LINE__);
}
}
#ifndef _RWSTD_NO_EXCEPTIONS
catch (const std::bad_alloc &ex) {
caught = exceptions [3];
rw_assert (0 == tcase.bthrow, 0, tcase.line,
"line %d. %{$FUNCALL} %{?}expected %s,%{:}"
"unexpectedly%{;} caught std::%s(%#s)",
__LINE__, 0 != expected, expected, caught, ex.what ());
}
catch (const std::exception &ex) {
caught = exceptions [4];
rw_assert (0, 0, tcase.line,
"line %d. %{$FUNCALL} %{?}expected %s,%{:}"
"unexpectedly%{;} caught std::%s(%#s)",
__LINE__, 0 != expected, expected, caught, ex.what ());
}
catch (...) {
caught = exceptions [0];
rw_assert (0, 0, tcase.line,
"line %d. %{$FUNCALL} %{?}expected %s,%{:}"
"unexpectedly%{;} caught %s",
__LINE__, 0 != expected, expected, caught);
}
#endif // _RWSTD_NO_EXCEPTIONS
// FIXME: verify the number of blocks the function call
// is expected to allocate and detect any memory leaks
rw_check_leaks (s_res.get_allocator (), tcase.line,
std::size_t (-1), std::size_t (-1));
if (caught) {
// verify that an exception thrown during allocation
// didn't cause a change in the state of the object
str_state.assert_equal (rw_get_string_state (s_res),
__LINE__, tcase.line, caught);
if (0 == tcase.bthrow) {
// allow this call to operator new to succeed and try
// to make the next one to fail during the next call
// to the same function again
continue;
}
}
else if (0 < tcase.bthrow) {
rw_assert (caught == expected, 0, tcase.line,
"line %d. %{$FUNCALL} %{?}expected %s, caught %s"
"%{:}unexpectedly caught %s%{;}",
__LINE__, 0 != expected, expected, caught, caught);
}
break;
}
#ifndef _RWSTD_NO_REPLACEABLE_NEW_DELETE
// verify that if exceptions are enabled and when capacity changes
// at least one exception is thrown
const std::size_t expect_throws = str_state.capacity_ < s_res.capacity ();
#else // if defined (_RWSTD_NO_REPLACEABLE_NEW_DELETE)
const std::size_t expect_throws =
(StringIds::UserAlloc == func.alloc_id_)
? str_state.capacity_ < s_res.capacity () : 0;
#endif // _RWSTD_NO_REPLACEABLE_NEW_DELETE
// we may got no more 2 bad_allocs
rw_assert (expect_throws <= throw_count && throw_count <= 2, 0, tcase.line,
"line %d: %{$FUNCALL}: expected at least 1 %s exception "
"while changing capacity from %zu to %zu, got %zu",
__LINE__, exceptions [3],
str_state.capacity_, s_res.capacity (), throw_count);
// disable bad_alloc exceptions
*pst->throw_at_calls_ [0] = 0;
pal->throw_at_calls_ [pal->m_allocate] = 0;
if (wres != wres_buf)
delete[] wres;
}
