int
BaseExample::add (const double _y, feature_node * _x)
{
try {
int fnum = 0;
feature_node *node = fix_feature_node ((feature_node *) _x);
// check contents
for (int i = 0; (node + i)->index >= 0; i++) {
if ((node + i)->value != 1) feature_type = DOUBLE_FEATURE; // check feature type
d = _max (d, (node + i)->index); // save max dimension
fnum++;
}
// incriment refcount
inc_refcount_feature_node (node);
pack_d = _max (fnum, pack_d);
// check class type
if (_y != +1 && _y != -1) class_type = DOUBLE_FEATURE;
// resize
x = _append (x, l, node, (feature_node*)0);
y = _append (y, l, _y, 0.0);
l++;
return 1;
}
catch (...) {
fprintf (stderr, "BaseExample::add(): Out of memory\n");
exit (EXIT_FAILURE);
return 0;
}
}
static GString *
_curl_reference_url (struct oio_url_s *u, const char *action)
{
GString *hu = _curl_url_prefix_reference (u);
g_string_append_printf (hu, "/%s/%s/reference/%s", PROXYD_PREFIX,
oio_url_get(u, OIOURL_NS), action);
_append (hu, '?', "acct", oio_url_get (u, OIOURL_ACCOUNT));
_append (hu, '&', "ref", oio_url_get (u, OIOURL_USER));
return hu;
}
static GString *
_curl_content_url (struct oio_url_s *u, const char *action)
{
GString *hu = _curl_url_prefix_containers (u);
g_string_append_printf (hu, "/%s/%s/content/%s", PROXYD_PREFIX,
oio_url_get(u, OIOURL_NS), action);
_append (hu, '?', "acct", oio_url_get (u, OIOURL_ACCOUNT));
_append (hu, '&', "ref", oio_url_get (u, OIOURL_USER));
_append_type (u, hu);
_append (hu, '&', "path", oio_url_get (u, OIOURL_PATH));
return hu;
}
BSONObj LockStat::report() const {
BSONObjBuilder b;
BSONObjBuilder t( b.subobjStart( "timeLockedMicros" ) );
_append( b , timeLocked );
t.done();
BSONObjBuilder a( b.subobjStart( "timeAcquiringMicros" ) );
_append( a , timeAcquiring );
a.done();
return b.obj();
}
size_t AOutputBuffer::append(const AString& str, size_t len)
{
if (!len)
return 0;
if (AConstant::npos == len)
return _append(str.c_str(), str.getSize());
else
{
AASSERT(this, len <= str.getSize());
return _append(str.c_str(), len);
}
}
gchar *
assemble_chunk_id(const gchar *straddr, const gchar *strvol, const gchar *strid)
{
void _append(GString *gstr, const gchar *s) {
if (gstr->str[gstr->len - 1] != '/' && *s != '/')
g_string_append_c(gstr, '/');
g_string_append(gstr, s);
}
GString *gstr = g_string_new("http://");
_append(gstr, straddr);
_append(gstr, strvol);
_append(gstr, strid);
return g_string_free(gstr, FALSE);
}
bool LogRLD::Init(const int iLoglevel, const std::string &strHostName, const std::string &strLogInnerShowName, const std::string &strLogFilePath,
const int iSchedule, const int iMaxLogFileBackupNum, const std::string &strVersion)
{
log4cplus::DailyRollingFileSchedule schedulelog = (log4cplus::DailyRollingFileSchedule)iSchedule;
/* step 1: Instantiate an appender object */
log4cplus::SharedAppenderPtr _append(new log4cplus::DailyRollingFileAppenderExtend(strLogFilePath.c_str(), schedulelog, true, iMaxLogFileBackupNum));
_append->setName("file log test");
/* step 2: Instantiate a layout object */
//std::string pattern = "%D{%Y%m%d %H:%M:%S.%Q} [%s-thread-%t ] %p %s - %m - %l%n";
std::string strPattern = "%D{%Y%m%d %H:%M:%S.%Q} [" + strHostName + "-thread-%T ] %p " + strLogInnerShowName + " - " + strVersion + "%m - %l%n";
std::auto_ptr<log4cplus::Layout> _layout(new log4cplus::PatternLayout(strPattern));
/* step 3: Attach the layout object to the appender */
_append->setLayout(_layout);
/* step 4: Instantiate a logger object */
pLoggerImpl = new log4cplus::Logger(log4cplus::Logger::getInstance("main_log"));
//pLoggerImpl = log4cplus::Logger::getInstance("main_log");
/* step 5: Attach the appender object to the logger */
pLoggerImpl->addAppender(_append);
/* step 6: Set a priority for the logger */
pLoggerImpl->setLogLevel(iLoglevel);
return true;
}
void AppenderSkeleton::doAppend(const LoggingEvent& event) {
if ((Priority::NOTSET == _threshold) || (event.priority <= _threshold)) {
if (!_filter || (_filter->decide(event) != Filter::DENY)) {
_append(event);
}
}
}
void appender::do_append(const logging_event& event)
{
if(priority::PL_ALL==threshold_|| (event.get_priority() >= threshold_))
{
_append(event);
}
}
bool Log::open_log()
{
std::string level;
if (!Config::instance().get_str_conf("log_level", level)) {
std::cout << "Can not get log_level in configuration file!" << std::endl;
return false;
}
LogLevel Log_level = string_to_log_level(level);
/* step 1: Instantiate an appender object */
SharedAppenderPtr _append(new RollingFileAppender(LOG_FILE_NAME, 1000*1024, 5));
_append->setName("file log test");
/* step 2: Instantiate a layout object */
std::string pattern = "[%p] [%D{%m/%d/%y %H:%M:%S}] [%l] - %m %n";
std::auto_ptr<Layout> _layout(new PatternLayout(pattern));
/* step 3: Attach the layout object to the appender */
_append->setLayout(_layout);
/* step 4: Instantiate a logger object */
/* step 5: Attach the appender object to the logger */
_logger.addAppender(_append);
/* step 6: Set a priority for the logger */
_logger.setLogLevel(Log_level);
return true;
}
size_t AOutputBuffer::appendU2(u2 d)
{
#ifdef _WIN32_
u1 *pData = (u1 *)&d;
char pBuffer[0x2];
//a_Reverse bytes
pBuffer[0x0] = pData[0x1];
pBuffer[0x1] = pData[0x0];
//a_Write bytes
return _append(pBuffer, 0x2);
#else
return _append((const char *)&d, 0x2);
#endif
}
size_t AOutputBuffer::append(const char *pcc)
{
if (!pcc) return 0;
size_t len = strlen(pcc);
return _append(pcc, len);
}
static GString *
_append_type (struct oio_url_s *u, GString *hu)
{
const char *type = oio_url_get (u, OIOURL_TYPE);
if (type && *type)
_append (hu, '&', "type", type);
return hu;
}
static LObject *
lisp_string_append (LObject *args)
{
LObject *obj = lipa_new_string ();
L_STRING(obj) = _append (args, L_STRING(obj));
return obj;
}
int
BaseExample::readSVindex (const char *filename, const char *mode, const int offset)
{
if (l == 0) {
fprintf(stderr, "Fatal: size == 0, Read model/example file before reading .idx file\n");
return 0;
}
FILE *fp = fopen (filename, mode);
if (!fp) return 0;
delete [] alpha;
delete [] G;
int _l = 0;
char *buf;
while ((buf = readLine (fp)) != NULL) {
double alpha_, G_;
if (2 != sscanf (buf, "%lf %lf\n", &alpha_, &G_)) {
fprintf(stderr, "Fatal: Format error %s, line %d\n", filename, _l);
fclose (fp);
return 0;
}
alpha = _append (alpha, _l, alpha_, 0.0);
G = _append (G, _l, G_, 0.0);
_l++;
}
fclose (fp);
// check size of idx file
if (l < _l) {
fprintf(stderr, "Fatal: model/example size (%d) < idx size (%d)\n", l, _l);
delete [] alpha;
delete [] G;
alpha = 0;
G = 0;
return 0;
}
svindex_size = _l;
return 1;
}
size_t AOutputBuffer::appendU4_LSB(u4 d)
{
#ifndef _WIN32_
u1 *pData = (u1 *)&d;
char pBuffer[0x4];
//a_Reverse bytes
pBuffer[0x0] = pData[0x3];
pBuffer[0x1] = pData[0x2];
pBuffer[0x2] = pData[0x1];
pBuffer[0x3] = pData[0x0];
//a_Write 4 bytes
return _append(pBuffer, 0x4);
#else
return _append((const char *)&d, 0x4);
#endif
}
T StringBuffer_vappend(T S, const char *s, va_list ap) {
assert(S);
if (STR_DEF(s)) {
va_list ap_copy;
va_copy(ap_copy, ap);
_append(S, s, ap_copy);
va_end(ap_copy);
}
return S;
}
T StringBuffer_append(T S, const char *s, ...) {
assert(S);
if (STR_DEF(s)) {
va_list ap;
va_start(ap, s);
_append(S, s, ap);
va_end(ap);
}
return S;
}
static void
_append_url (GString *gs, struct oio_url_s *url)
{
void _append (const char *n, const char *v) {
if (v)
g_string_append_printf (gs, "\"%s\":\"%s\"", n, v);
else
g_string_append_printf (gs, "\"%s\":null", n);
}
_append ("ns", oio_url_get(url, OIOURL_NS));
g_string_append_c (gs, ',');
_append ("account", oio_url_get(url, OIOURL_ACCOUNT));
g_string_append_c (gs, ',');
_append ("user", oio_url_get(url, OIOURL_USER));
g_string_append_c (gs, ',');
_append ("type", oio_url_get(url, OIOURL_TYPE));
g_string_append_c (gs, ',');
_append ("id", oio_url_get(url, OIOURL_HEXID));
}
GError *
oio_proxy_call_conscience_flush (CURL *h, const char *ns,
const char *srvtype)
{
GString *http_url = _curl_conscience_url (ns, "flush");
_append (http_url, '?', "type", srvtype);
GError *err = _proxy_call (h, "POST", http_url->str, NULL, NULL);
g_string_free(http_url, TRUE);
return err;
}
entry *_append(char lastName[], entry *e)
{
if (e->height == 0) {
strcpy(e->lastName, lastName);
e->height = 1;
e->pLeft = mallocEntry();
e->pRight = mallocEntry();
return e;
}
int cmp = strcmp(lastName, e->lastName);
if (cmp < 0)
e->pLeft = _append(lastName, e->pLeft);
else if (cmp > 0)
e->pRight = _append(lastName, e->pRight);
else
return e;
return balance(e);
}
GError *
oio_proxy_call_conscience_list_types (CURL *h, const char *ns,
GString *out)
{
GString *http_url = _curl_conscience_url (ns, "info");
_append (http_url, '?', "what", "types");
struct http_ctx_s o = { .headers = NULL, .body = out };
GError *err = _proxy_call (h, "GET", http_url->str, NULL, &o);
g_strfreev (o.headers);
g_string_free(http_url, TRUE);
return err;
}
size_t AOutputBuffer::appendU8(u8 d)
{
#ifdef _WIN32_
u1 *pData = (u1 *)&d;
char pBuffer[0x8];
//a_Reverse bytes
pBuffer[0x0] = pData[0x7];
pBuffer[0x1] = pData[0x6];
pBuffer[0x2] = pData[0x5];
pBuffer[0x3] = pData[0x4];
pBuffer[0x4] = pData[0x3];
pBuffer[0x5] = pData[0x2];
pBuffer[0x6] = pData[0x1];
pBuffer[0x7] = pData[0x0];
//a_Write bytes
return _append(pBuffer, 0x8);
#else
return _append((const char *)&d, 0x8);
#endif
}
void NetworkTransporter::send(void) {
#ifdef DEBUG
Serial.println("NetworkTransporter: send");
#endif
if (socket.connect()) {
char buffer[200];
int pos = 0;
int i;
buffer[0] = '\0';
for (i = 0; i < nr_sensors; i++) {
if (i > 0) pos = _append('&', buffer, pos);
// pos = _append(i, buffer, pos);
pos = _append(names[i], buffer, pos);
pos = _append('=', buffer, pos);
pos = _append(temperatures[i], buffer, pos);
}
#ifdef DEBUG
Serial.print("NetworkTransporter: ");
Serial.println(buffer);
#endif
socket.println("POST /save_measures HTTP/1.0");
// socket.println("Host: www.xxx.de");
socket.println("Content-Type: application/x-www-form-urlencoded");
socket.print("Content-Length: "); socket.println(pos, DEC);
socket.println();
socket.print(buffer);
set_state(NET_STATE_RECEIVE);
}
}
int _draw_power(SDL_Surface * f1, SDL_Surface * f2, int typ)
{
int yt;
proc_ret = f1;
if (f1->h >= f2->h)
if (typ)
yt = f2->h * POWER_SMALL_PADDING;
else
yt = f2->h * POWER_BIG_PADDING;
else if (typ)
yt = SMALLFONT / 2 + f2->h + f1->h * (POWER_SMALL_PADDING - 1);
else
yt = BIGFONT / 2 + f2->h + f1->h * (POWER_BIG_PADDING - 1);
_append(f2, 0, yt);
return yt;
}
void ObjectGroup::append(Object* obj, int spacing)
{
if (! obj)
return;
int starty = this->y();
for(int i=0; i < mObjects.size(); i++) {
if (mObjects[i]->y() + mObjects[i]->height() > starty)
starty = mObjects[i]->y() + mObjects[i]->height();
}
starty += spacing;
obj->setY(starty);
obj->setX(this->x());
_append(obj);
this->notify("objects", variantObjects());
//connect(this, SIGNAL(resized(int,int)), obj, SLOT(onParentResized(int, int)));
}
GError *
oio_proxy_call_reference_link (CURL *h, struct oio_url_s *u,
const char *srvtype, gboolean autocreate, GString *out)
{
GString *http_url = _curl_reference_url (u, "link");
_append (http_url, '&', "type", srvtype);
gchar *hdrin[] = {
g_strdup(PROXYD_HEADER_MODE),
g_strdup(autocreate ? "autocreate" : ""),
NULL,
};
struct http_ctx_s i = { .headers = hdrin, .body = NULL };
struct http_ctx_s o = { .headers = NULL, .body = out };
GError *err = _proxy_call (h, "POST", http_url->str, &i, &o);
_ptrv_free_content (i.headers);
g_strfreev (o.headers);
g_string_free(http_url, TRUE);
return err;
}
static GString *
_append (LObject *args, GString *str)
{
if (!lipa_null (args))
{
LObject *obj = lipa_car (args);
if (obj->type == L_OBJ_STRING)
{
return g_string_prepend (_append (lipa_cdr (args), str),
L_STRING(obj)->str);
}
else
{
fprintf (stderr, "append can only take string arguments");
}
}
else
return str;
return NULL;
}
void ObjectGroup::_load(const QVariantMap& data)
{
this->blockNotifications(true);
ResourceManager * resourceManager = ResourceManager::instance();
if (data.contains("objects") && data.value("objects").type() == QVariant::List) {
this->removeAllObjects(true);
QVariantList objects = data.value("objects").toList();
Object *obj = 0;
for(int i=0; i < objects.size(); i++) {
if (objects[i].type() == QVariant::Map) {
obj = resourceManager->createObject(objects[i].toMap(), this);
}
else if (objects[i].type() == QMetaType::QObjectStar) {
obj = qobject_cast<Object*>(objects[i].value<QObject*>());
}
if(obj)
_append(obj);
}
}
//internal data passed between resource and clones
if (data.contains("_object") && data.value("_object").type() == QVariant::Map) {
QVariantMap object = data.value("_object").toMap();
if (object.contains("_index") && object.value("_index").canConvert(QVariant::Int)) {
int _index = object.value("_index").toInt();
if (_index >= 0 && _index < mObjects.size()) {
mObjects[_index]->load(object);
//some properties are ignored by default so we need to apply them here for the child objects
if (object.contains("visible") && object.value("visible").type() == QVariant::Bool)
mObjects[_index]->setVisible(object.value("visible").toBool());
}
}
}
this->blockNotifications(false);
}
void utl::startLogInfrastrue(const char *path, int log_level) {
/* step 1: Instantiate an appender object */
//log4cplus::SharedAppenderPtr _append(new log4cplus::RollingFileAppender( logfilename.c_str(), 20*1024, 1000));
log4cplus::SharedAppenderPtr _append(new log4cplus::FileAppender( path));//, 20*1024, 1000));
//SharedAppenderPtr _append(new DailyRollingFileAppender(logfilename.c_str(), HOURLY, true, 1000));
_append->setName("append for test");
/* step 2: Instantiate a layout object */
std::string pattern = "%-6p %-15c %D %m %n ";
std::auto_ptr<log4cplus::Layout> _layout(new log4cplus::PatternLayout(pattern));
/* step 3: Attach the layout object to the appender */
_append->setLayout( _layout );
/* step 4: Instantiate a logger object */
log4cplus::Logger _logger = log4cplus::Logger::getRoot();
_logger.setLogLevel( log_level);
/* step 5: Attach the appender object to the logger */
_logger.addAppender(_append);
}
