static mrb_value
hdb_put(mrb_state *mrb, mrb_value self)
{
mrb_value key, value;
mrb_bool sync;
bool result = false;
mrb_int args;
void *kbuf, *vbuf;
int ksize, vsize;
mrb_int kint, vint;
hdb_context *context = DATA_PTR(self);
args = mrb_get_args(mrb, "oo|b", &key, &value, &sync);
if (args == 2) {
sync = true;
}
if (!get_content(key, &kint, &kbuf, &ksize)) {
mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid type of key");
}
if (!get_content(value, &vint, &vbuf, &vsize)) {
mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid type of value");
}
if (sync) {
result = tchdbput(context->hdb, kbuf, ksize, vbuf, vsize);
} else {
result = tchdbputasync(context->hdb, kbuf, ksize, vbuf, vsize);
}
return mrb_bool_value(result);
}
static void
parse_command (xmlNodePtr node, InputPadTableCmd *cmd)
{
xmlNodePtr current;
gboolean has_execl = FALSE;
for (current = node; current; current = current->next) {
if (current->type == XML_ELEMENT_NODE) {
if (!g_strcmp0 ((char *) current->name, "label")) {
if (current->children) {
get_content (current->children, &cmd->label, TRUE);
} else {
g_error ("tag %s does not have child tags in the file %s",
(char *) current->name,
xml_file);
}
}
if (!g_strcmp0 ((char *) current->name, "execl")) {
if (current->children) {
get_content (current->children, &cmd->execl, FALSE);
has_execl = TRUE;
} else {
g_error ("tag %s does not have child tags in the file %s",
(char *) current->name,
xml_file);
}
}
}
}
if (!has_execl) {
g_error ("tag %s does not find \"execl\" tag in file %s",
node->parent ? node->parent->name ? (char *) node->parent->name : "(null)" : "(null)",
xml_file);
}
}
//Функция инициализирует графику и все переменные
void init_manager(WINDOW ***win, char content[2][512][128], unsigned count[2], char patch[2][512], unsigned *active, unsigned *print, unsigned *select)
{
//Инициализация графики
initscr();
cbreak();
curs_set(0);
noecho();
keypad(stdscr, TRUE);
//Выделение памяти
(*win) = malloc(4 * sizeof(WINDOW *));
//Инициализации переменных
(*active) = LEFT;
(*print) = 0;
(*select) = 0;
getcwd(patch[LEFT], 512);
getcwd(patch[RIGHT], 512);
count[LEFT] = get_content(patch[LEFT], content[LEFT]);
count[RIGHT] = get_content(patch[RIGHT], content[RIGHT]);
(*win)[BLEFT] = newwin(LINES, COLS / 2, 0, 0);
(*win)[BRIGHT] = newwin(LINES, COLS / 2, 0, COLS / 2);
(*win)[LEFT] = newwin(LINES - 2, (COLS / 2) - 2, 1, 1);
(*win)[RIGHT] = newwin(LINES - 2, (COLS / 2) - 2, 1, (COLS / 2) + 1);
refresh();
}
std::size_t message::write(std::ostream& out,
boost::system::error_code& ec, bool headers_only)
{
// reset error_code
ec.clear();
// initialize write buffers for send operation using HTTP headers
write_buffers_t write_buffers;
prepare_buffers_for_send(write_buffers, true, false);
// append payload content to write buffers (if there is any)
if (!headers_only && get_content_length() > 0 && get_content() != NULL)
write_buffers.push_back(boost::asio::buffer(get_content(), get_content_length()));
// write message to the output stream
std::size_t bytes_out = 0;
for (write_buffers_t::const_iterator i=write_buffers.begin(); i!=write_buffers.end(); ++i) {
const char *ptr = boost::asio::buffer_cast<const char*>(*i);
size_t len = boost::asio::buffer_size(*i);
out.write(ptr, len);
bytes_out += len;
}
return bytes_out;
}
std::size_t message::send(tcp::connection& tcp_conn,
boost::system::error_code& ec, bool headers_only)
{
// initialize write buffers for send operation using HTTP headers
write_buffers_t write_buffers;
prepare_buffers_for_send(write_buffers, tcp_conn.get_keep_alive(), false);
// append payload content to write buffers (if there is any)
if (!headers_only && get_content_length() > 0 && get_content() != NULL)
write_buffers.push_back(boost::asio::buffer(get_content(), get_content_length()));
// send the message and return the result
return tcp_conn.write(write_buffers, ec);
}
void custom_ontrigger_logic(processor_session *ps, processor_context *ctx) {
flow_file_record * ffr = get(ps, ctx);
REQUIRE(ffr != nullptr);
uint8_t * buffer = (uint8_t*)malloc(ffr->size* sizeof(uint8_t));
get_content(ffr, buffer, ffr->size);
REQUIRE(strncmp(reinterpret_cast<const char *>(buffer), test_file_content.c_str(), test_file_content.size()) == 0);
attribute attr;
attr.key = "filename";
attr.value_size = 0;
REQUIRE(get_attribute(ffr, &attr) == 0);
REQUIRE(attr.value_size > 0);
const char * custom_value = "custom value";
REQUIRE(add_attribute(ffr, "custom attribute", (void*)custom_value, strlen(custom_value)) == 0);
char prop_value[20];
REQUIRE(get_property(ctx, "Some test propery", prop_value, 20) == 0);
REQUIRE(strncmp("test value", prop_value, strlen(prop_value)) == 0);
transfer_to_relationship(ffr, ps, SUCCESS_RELATIONSHIP);
free_flowfile(ffr);
free(buffer);
}
static int load_file(const char* file_path, int offset_block, int blocks) {
printf("Try to load:%s", file_path);
if (blocks) {
printf(", offset block:%d, blocks:%d\n", offset_block, blocks);
} else {
printf("\n");
}
bool ret = false;
resource_content content;
snprintf(content.path, sizeof(content.path), "%s", file_path);
content.load_addr = 0;
if (!get_content(&content)) {
goto end;
}
if (!blocks) {
if (!load_content(&content)) {
goto end;
}
} else {
void* data = malloc(blocks * BLOCK_SIZE);
if (!data)
goto end;
if (!load_content_data(&content, offset_block, data, blocks)) {
goto end;
}
}
ret = true;
end:
free_content(&content);
return ret;
}
/**
* \brief Update level name.
*/
void ptb::frame_play_story::update_level_name()
{
// Adjust the height of m_name_text in position_controls() to the height
// of this font
const bear::visual::writing w
( get_layer().get_level().get_globals().get_font
("font/level_name-42x50.fnt", 50),
gettext(m_levels[m_index].get_id().c_str()) );
m_name_text->set_size
( std::min(w.get_width(), get_content().width()), 50 );
m_name_text->set_scene_element( bear::visual::scene_writing(0, 0, w) );
m_name_text->set_position
( (get_content().width() - m_name_text->width()) / 2,
m_thumb->top() + get_margin());
} // frame_play_story::update_level_name()
static void
parse_keys (xmlNodePtr node, InputPadTable **ptable)
{
xmlNodePtr current;
gboolean has_keys = FALSE;
for (current = node; current; current = current->next) {
if (current->type == XML_ELEMENT_NODE) {
if (!g_strcmp0 ((char *) current->name, "keysyms")) {
(*ptable)->type = INPUT_PAD_TABLE_TYPE_KEYSYMS;
if (current->children) {
get_content (current->children, &(*ptable)->data.keysyms, FALSE);
has_keys = TRUE;
} else {
g_error ("tag %s does not have child tags in the file %s",
(char *) current->name,
xml_file);
}
}
}
}
if (!has_keys) {
g_error ("tag %s does not find \"keysyms\" tag in file %s",
node->parent ? node->parent->name ? (char *) node->parent->name : "(null)" : "(null)",
xml_file);
}
}
/*
处理静态内容
*/
void deal_static(int client_sock,char *path,int file_size){
//send_head(client_sock,path);
//FILE *file=fopen(path,"r");
char *buf;
char file[file_size];
//对buf进行内存分配
buf = (char *)malloc(file_size);
//打开文件
int fd = open(path,O_RDONLY);
if(fd==-1){
not_found(client_sock,path);
}else{
//发送头部
send_head(client_sock,path);
//获取内容
get_content(buf,fd,file_size);
//给客户端发送文件内容
send(client_sock,buf,file_size,0);
}
//释放内容，这很重要
free(buf);
close(fd);
return;
}
/**
* \brief Create the radio button group.
* \param f The font to use for the text.
*/
bear::gui::radio_group*
ptb::frame_profiles::create_profiles_radio_buttons( bear::visual::font f )
{
bear::gui::radio_group* const radio_group( new bear::gui::radio_group );
radio_group->set_size
( std::numeric_limits<bear::gui::size_type>::max(),
std::numeric_limits<bear::gui::size_type>::max() );
m_profile_radio_buttons.resize(PTB_NUMBER_OF_PROFILES);
for ( unsigned int i = 0; i < PTB_NUMBER_OF_PROFILES; ++i )
{
m_profile_radio_buttons[i] =
new bear::gui::radio_button( get_radio_off(), get_radio_on(), f );
m_profile_radio_buttons[i]->set_text( "Width fill placeholder" );
allow_focus(*m_profile_radio_buttons[i]);
radio_group->add_button(m_profile_radio_buttons[i], get_margin());
}
radio_group->fit();
get_content().insert( radio_group );
m_profile_radio_buttons.back()->check();
return radio_group;
} // frame_profiles::create_profiles_radio_buttons()
/**
* grl_net_wc_request_finish:
* @self: a #GrlNetWc instance
* @result: The result of the request
* @content: The contents of the resource
* @length: (allow-none): The length of the contents or %NULL if it is not
* needed
* @error: return location for a #GError, or %NULL
*
* Finishes an asynchronous load of the file's contents.
* The contents are placed in contents, and length is set to the size of the
* contents string.
*
* The content address will be invalidated at the next request. So if you
* want to keep it, please copy it into another address.
*
* Returns: %TRUE if the request was successfull. If %FALSE an error occurred.
*/
gboolean
grl_net_wc_request_finish (GrlNetWc *self,
GAsyncResult *result,
gchar **content,
gsize *length,
GError **error)
{
GSimpleAsyncResult *res = G_SIMPLE_ASYNC_RESULT (result);
gboolean ret = TRUE;
g_warn_if_fail (g_simple_async_result_get_source_tag (res) ==
grl_net_wc_request_async);
void *op = g_simple_async_result_get_op_res_gpointer (res);
if (g_simple_async_result_propagate_error (res, error) == TRUE) {
ret = FALSE;
goto end_func;
}
if (is_mocked ())
get_content_mocked (self, op, content, length);
else
get_content(self, op, content, length);
end_func:
if (is_mocked ())
free_mock_op_res (op);
else
free_op_res (op);
return ret;
}
static mrb_value
hdb_assoc(mrb_state *mrb, mrb_value self)
{
hdb_context *context = DATA_PTR(self);
void *kbuf;
int ksize;
mrb_int kint;
mrb_value ary;
int sp;
void *value;
mrb_value key, result;
mrb_get_args(mrb, "o", &key);
if (!get_content(key, &kint, &kbuf, &ksize)) {
return mrb_nil_value();
}
value = tchdbget(context->hdb, kbuf, ksize, &sp);
if (value == NULL || sp <= 0) {
if (value) {
free(value);
}
return mrb_nil_value();
}
result = mrb_str_new(mrb, value, sp);
free(value);
ary = mrb_ary_new_capa(mrb, 2);
mrb_ary_push(mrb, ary, key);
mrb_ary_push(mrb, ary, result);
return ary;
}
static mrb_value
hdb_get(mrb_state *mrb, mrb_value self)
{
hdb_context *context = DATA_PTR(self);
mrb_value key, result;
void *kbuf;
int ksize;
mrb_int kint;
int sp = 0;
void *value;
mrb_get_args(mrb, "o", &key);
if (!get_content(key, &kint, &kbuf, &ksize)) {
mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid type of key");
}
value = tchdbget(context->hdb, kbuf, ksize, &sp);
if (value == NULL || sp <= 0) {
if (value) {
free(value);
}
return mrb_nil_value();
}
result = mrb_str_new(mrb, value, sp);
free(value);
return result;
}
void FolderPost::Deserialize(Json::Value& root) {
Post::Deserialize(root);
Json::Value folder(Json::objectValue);
get_content("folder", folder);
folder_.set_foldername(folder.get("foldername", "").asString());
folder_.set_parent_post_id(folder.get("parent_post", "").asString());
folder_.set_folder_post_id(id());
}
/**
* \brief Insert a control in the list of activable controls.
* \param c The control to insert in the list.
*/
void ptb::frame::insert_control( bear::gui::visual_component& c )
{
get_content().insert(&c);
m_controls.push_back(&c);
if ( m_controls.size() == 1 )
switch_to_control(0);
} // frame::insert_control()
static void
parse_string (xmlNodePtr node, InputPadTableStr *str)
{
xmlNodePtr current;
gboolean has_label = FALSE;
for (current = node; current; current = current->next) {
if (current->type == XML_ELEMENT_NODE) {
if (!g_strcmp0 ((char *) current->name, "label")) {
if (current->children) {
get_content (current->children, &str->label, FALSE);
has_label = TRUE;
} else {
g_error ("tag %s does not have child tags in the file %s",
(char *) current->name,
xml_file);
}
}
if (!g_strcmp0 ((char *) current->name, "comment")) {
if (current->children) {
get_content (current->children, &str->comment, TRUE);
} else {
g_error ("tag %s does not have child tags in the file %s",
(char *) current->name,
xml_file);
}
}
if (!g_strcmp0 ((char *) current->name, "rawtext")) {
if (current->children) {
get_content (current->children, &str->rawtext, TRUE);
} else {
g_error ("tag %s does not have child tags in the file %s",
(char *) current->name,
xml_file);
}
}
}
}
if (!has_label) {
g_error ("tag %s does not find \"label\" tag in file %s",
node->parent ? node->parent->name ? (char *) node->parent->name : "(null)" : "(null)",
xml_file);
}
}
/**
* \brief Create the static text components.
*/
void ptb::frame_play_story::create_controls()
{
m_thumb = new bear::gui::picture( get_default_thumb() );
m_name_text = new bear::gui::scene_element();
m_status_picture = new bear::gui::picture( get_status_picture() );
get_content().insert( m_thumb );
get_content().insert( m_name_text );
get_content().insert( m_status_picture );
m_second_player_status.energy = new horizontal_gauge
( get_layer().get_level().get_globals(), 100, "bar (light blue)",
"bar (red)", "heart", true );
m_first_player_status.energy = new horizontal_gauge
( get_layer().get_level().get_globals(), 100, "bar (green)",
"bar (red)", "heart", true );
create_player_component(m_first_player_status);
create_player_component(m_second_player_status);
create_bonus_component();
bear::gui::visual_component* ok = create_ok_button();
bear::gui::visual_component* back = create_back_button();
bear::gui::visual_component* previous = create_previous_button();
bear::gui::visual_component* next = create_next_button();
position_controls( ok->top() + get_margin() );
bear::gui::size_type sum_w
( 3 * get_margin() + ok->width() + back->width() + previous->width()
+ next->width() );
const bear::gui::size_type w
( (m_bonus->width() + m_thumb->width() + 2*get_margin() - sum_w) / 3);
back->set_left( ok->right() + w );
previous->set_left( back->right() + w );
next->set_right( m_status_picture->right() );
ok->set_focus();
fit( get_margin() );
} // frame_play_story::create_controls()
void atom_parser::parse_feed(feed& f, xmlNode * rootNode) {
if (!rootNode)
throw exception(_("XML root node is NULL"));
switch (f.rss_version) {
case ATOM_0_3:
ns = ATOM_0_3_URI;
break;
case ATOM_1_0:
ns = ATOM_1_0_URI;
break;
case ATOM_0_3_NONS:
ns = nullptr;
break;
default:
ns = nullptr;
break;
}
f.language = get_prop(rootNode, "lang");
globalbase = get_prop(rootNode, "base", XML_URI);
for (xmlNode * node = rootNode->children; node != nullptr; node = node->next) {
if (node_is(node, "title", ns)) {
f.title = get_content(node);
f.title_type = get_prop(node, "type");
if (f.title_type == "")
f.title_type = "text";
} else if (node_is(node, "subtitle", ns)) {
f.description = get_content(node);
} else if (node_is(node, "link", ns)) {
std::string rel = get_prop(node, "rel");
if (rel == "alternate") {
f.link = newsbeuter::utils::absolute_url(globalbase, get_prop(node, "href"));
}
} else if (node_is(node, "updated", ns)) {
f.pubDate = w3cdtf_to_rfc822(get_content(node));
} else if (node_is(node, "entry", ns)) {
f.items.push_back(parse_entry(node));
}
}
}
size_t write_data(void *ptr,size_t size,size_t nmemb,void *stream)
{
FILE *fp;
int rs;
get_content((char *)ptr);
fp=fopen("/dev/null","w");
rs=fwrite(ptr,size,nmemb,fp);
fclose(fp);
return rs;
}
std::string rss_parser::get_xml_content(xmlNode * node) {
xmlBufferPtr buf = xmlBufferCreate();
std::string result;
if (node->children) {
for (xmlNodePtr ptr = node->children; ptr != NULL; ptr = ptr->next) {
if (xmlNodeDump(buf, doc, ptr, 0, 0) >= 0) {
result.append((const char *)xmlBufferContent(buf));
xmlBufferEmpty(buf);
} else {
result.append(get_content(ptr));
}
}
} else {
result = get_content(node); // fallback
}
xmlBufferFree(buf);
return result;
}
void open_dir(char* name, char patch[2][512], char content[512][128], unsigned *count, unsigned active)
{
struct stat info;
stat(name, &info);
if(info.st_mode == 16877)
{
chdir(name);
getcwd(patch[active], 512);
(*count) = get_content(patch[active], content);
}
}
/**
* @brief HTTP::download
* @return int
*/
int HTTP::download()
{
initiateConnection(); // connection init
send_request(); // send request with headers
get_headers(); // get headers, find if chunked, redirection etc.
std::string s = get_content(); // save the content
std::ofstream out("output.xml");
out << s; // save to file
out.close();
return 0;
}
/**
* tests fd() as well as chk_inst()
*/
static char * test_fd() {
Logo good, b_varnum, b_inst, b_chk_inst;
char *buffer;
int ret;
printf("Testing %s\n", __FUNCTION__);
/* good input */
good = setup(2, "FD 20");
insert_line(good, "FD A");
/* bad varnum */
b_varnum = setup(1, "FD AB");
/* bad instruction */
b_inst = setup(1, "RT 20");
/* test chk_inst error checking */
b_chk_inst = setup(1, "FD");
ret = fd(good);
mu_assert("error, ret != 0", ret == 0);
good->counter = good->counter + 1;
/* set the variable */
set_var("A", good->vars, 30.0);
ret = fd(good);
mu_assert("error, ret != 0", ret == 0);
tear_down(good);
/* expect postscript and test the output file */
char str[STR_LENGTH] = "";
char tmp[LINE_LENGTH];
sprintf(tmp, "%.2f 0 rlineto\n", 20 * LOGO2PS_FACTOR);
strcat(str, tmp);
sprintf(tmp, "%.2f 0 rlineto\n", 30 * LOGO2PS_FACTOR);
strcat(str, tmp);
buffer = get_content(TEST_OUT);
mu_assert("error, TEST_OUT is not as expected",
strcmp(buffer, str) == 0);
free(buffer);
ret = fd(b_varnum);
mu_assert("error, ret != PARSE_ERR", ret == PARSE_ERR);
tear_down(b_varnum);
ret = fd(b_inst);
mu_assert("error, ret != PARSE_ERR", ret == PARSE_ERR);
tear_down(b_inst);
ret = fd(b_chk_inst);
mu_assert("error, ret != PARSE_ERR", ret == PARSE_ERR);
tear_down(b_chk_inst);
return 0;
}
/**
* \brief Create all bonus components.
*/
void ptb::frame_play_story::create_bonus_component()
{
m_bonus =
new bear::gui::horizontal_flow(3, 3, bear::visual::color_type("e50f0f"));
get_content().insert( m_bonus );
m_bonus->set_background_color(PTB_THEME_FACE);
set_borders_down(*m_bonus);
insert_control( *m_bonus );
m_bonus_text = new bear::gui::static_text(get_font());
insert( m_bonus_text );
m_bonus_text->set_background_color(PTB_THEME_FACE);
set_borders_down(*m_bonus_text);
} // frame_play_story::create_bonus_component()
/**
* \brief The focus has been set on the frame or one of its children.
*/
void ptb::frame::on_focused()
{
const bear::gui::visual_component* c(get_content().get_focus());
std::size_t i(0);
bool stop(false);
while ( !stop && (i!=m_controls.size()) )
if ( m_controls[i] == c )
stop = true;
else
++i;
if ( i!=m_current_control )
switch_to_control(i);
} // frame::on_focus_on()
bool NoteOfTheDay::has_changed(const gnote::Note::Ptr & note)
{
const sharp::DateTime & date_time = note->create_date();
const std::string original_xml
= get_content(Glib::Date(
date_time.day(),
static_cast<Glib::Date::Month>(date_time.month()),
date_time.year()),
note->manager());
return get_content_without_title(note->text_content())
== get_content_without_title(
gnote::utils::XmlDecoder::decode(original_xml))
? false
: true;
}
static mrb_value
hdb_check_key(mrb_state *mrb, mrb_value self)
{
hdb_context *context = DATA_PTR(self);
void *kbuf;
int ksize;
mrb_int kint;
mrb_value key;
mrb_get_args(mrb, "o", &key);
if (!get_content(key, &kint, &kbuf, &ksize)) {
return mrb_nil_value();
}
return mrb_bool_value(tchdbvsiz(context->hdb, kbuf, ksize) >= 0);
}
static PyObject *xhttp(PyObject *self, PyObject *args)
{
char *content = NULL;
char *appid;
char *secret_key;
char *q;
char *from;
char *to;
if(!PyArg_ParseTuple(args, "s|ssss", &appid, &secret_key, &q, &from, &to))
{
return NULL;
}
get_content(appid, secret_key, q, from, to, &content);
return Py_BuildValue("s", content);
if(content) free(content);
}
static void update_leds(void) {
// only display something with a valid clock content
uint8_t on = (clock.state == VALID);
uint8_t p = on ? (cycle_position() + GLOBAL_OFFSET)%(CYCLE_POS_CNT) : 0;
// handle any daughter boards
for (uint8_t i=0; i<ELEMS(daughters); i++) {
uint8_t content = on ? get_content((p+daughters[i].offset)%CYCLE_POS_CNT) : 0;
// invert the bitmask since LED are activated on LOW ports.
if (daughters[i].shift) {
shift_out(~content);
} else {
// directly connected
LED_PORT = ~content;
}
}
// activate the daughter board LEDs
trigger_latch();
}
