Exemplo n.º 1
0
    bool hosts_map::unserialize(const tools::tlvpack& _pack)
    {
        auto tlv_scheme = _pack.get_item(host_config_types::hct_active_scheme);
        if (tlv_scheme)
        {
            active_scheme_ = tlv_scheme->get_value<bool>();
        }

        auto tlv_hosts = _pack.get_item(host_config_types::hct_hosts);
        if (tlv_hosts)
        {
            tools::tlvpack pack_hosts = tlv_hosts->get_value<tools::tlvpack>();

            for (auto tlv_host = pack_hosts.get_first(); tlv_host; tlv_host = pack_hosts.get_next())
            {
                tools::tlvpack pack_host = tlv_host->get_value<tools::tlvpack>();

                auto tlv_key = pack_host.get_item(host_config_types::hct_host_key);
                auto tlv_alt = pack_host.get_item(host_config_types::hct_host_alt);

                if (tlv_key && tlv_alt)
                {
                    hosts_[pack_string(tlv_key->get_value<std::string>())] = pack_string(tlv_alt->get_value<std::string>());
                }
            }
        }


        return true;
    }
Exemplo n.º 2
0
 inline void packet(char* buff, size_t* buff_n, bool pack)
 {
     pack_u8(&id, buff, buff_n, pack);
     pack_u8(&client_id, buff, buff_n, pack);
     pack_color(&color, buff, buff_n, pack);
     pack_string(username, PLAYER_NAME_MAX_LENGTH+1, buff, buff_n, pack);
 }
Exemplo n.º 3
0
void pack_part_names(stk::CommBuffer& buf, const stk::mesh::PartVector& parts)
{
    for(size_t i=0; i<parts.size(); ++i)
    {
        pack_string(buf, parts[i]->name());
    }
}
Exemplo n.º 4
0
unsigned int
MetaServerPacket::addPacketData(const std::string& s)
{
	unsigned int ret_off = m_writePtr - m_headPtr;
	m_writePtr = pack_string( s , m_writePtr );
	return ret_off;
}
Exemplo n.º 5
0
quint8 *MsgPackPrivate::pack_stringlist(const QStringList &list, quint8 *p, bool wr)
{
    int len = list.length();
    p = pack_arraylen(len, p, wr);
    foreach (QString item, list)
        p = pack_string(item, p, wr);
    return p;
}
Exemplo n.º 6
0
    void hosts_map::serialize(tools::tlvpack& _pack) const
    {
        _pack.push_child(tools::tlv(host_config_types::hct_active_scheme, active_scheme_));

        tools::tlvpack pack_hosts;

        for (const auto& _host : hosts_)
        {
            tools::tlvpack pack_host;

            pack_host.push_child(core::tools::tlv(host_config_types::hct_host_key, pack_string(_host.first)));
            pack_host.push_child(core::tools::tlv(host_config_types::hct_host_alt, pack_string(_host.second)));

            pack_hosts.push_child(core::tools::tlv(host_config_types::hct_host, pack_host));
        }

        _pack.push_child(tools::tlv(host_config_types::hct_hosts, pack_hosts));
    }
Exemplo n.º 7
0
static void pack_cpu_sample_event(rbkit_cpu_sample_event *event, msgpack_packer *packer) {
  rbkit_cpu_sample *sample;
  size_t count;

  msgpack_pack_map(packer, 3);
  sample = event->sample;

  // Keys 1 & 2 - event type and timestamp
  pack_event_header(packer, event->event_header.event_type);

  // Key 3 : Payload
  msgpack_pack_int(packer, rbkit_message_field_payload);
  // Value 3: Array of samples
  msgpack_pack_array(packer, sample->frame_count);

  for(count = 0; count != sample->frame_count; count++){
    msgpack_pack_map(packer, 6);

    // method_name
    msgpack_pack_int(packer, rbkit_message_field_method_name);
    pack_string(packer, sample->frames[count].method_name);

    // label
    msgpack_pack_int(packer, rbkit_message_field_label);
    pack_string(packer, sample->frames[count].label);

    // file
    msgpack_pack_int(packer, rbkit_message_field_file);
    pack_string(packer, sample->frames[count].file);

    // line
    msgpack_pack_int(packer, rbkit_message_field_line);
    msgpack_pack_unsigned_long(packer, sample->frames[count].line);

    // singleton_method
    msgpack_pack_int(packer, rbkit_message_field_singleton_method);
    msgpack_pack_int(packer, sample->frames[count].is_singleton_method);

    // thread_od
    msgpack_pack_int(packer, rbkit_message_field_thread_id);
    msgpack_pack_unsigned_long(packer, sample->frames[count].thread_id);
  }
}
Exemplo n.º 8
0
void pack_part_names_except(stk::CommBuffer& buf, const stk::mesh::PartVector& parts, stk::mesh::Part* skipPart)
{
    for(size_t i=0; i<parts.size(); ++i)
    {
        if (skipPart==nullptr || parts[i]->mesh_meta_data_ordinal() != skipPart->mesh_meta_data_ordinal())
        {
            pack_string(buf, parts[i]->name());
        }
    }
}
static void init(grib_accessor* a, const long len, grib_arguments* params) {
  int n=0;
  grib_accessor_codetable* self  = (grib_accessor_codetable*)a;
  grib_action* act=(grib_action*)(a->creator);

  self->tablename = grib_arguments_get_string(a->parent->h,params,n++);
  self->masterDir = grib_arguments_get_name(a->parent->h,params,n++);
  self->localDir = grib_arguments_get_name(a->parent->h,params,n++);

  /*if (a->flags & GRIB_ACCESSOR_FLAG_STRING_TYPE)
    printf("-------- %s type string (%ld)\n",a->name,a->flags);*/

  if (a->flags & GRIB_ACCESSOR_FLAG_TRANSIENT) {
    a->length = 0;
	if (!a->vvalue) 
		a->vvalue = grib_context_malloc_clear(a->parent->h->context,sizeof(grib_virtual_value));
    a->vvalue->type=grib_accessor_get_native_type(a);
    a->vvalue->length=len;
    if (act->default_value!=NULL) {
      const char* p = 0;
      size_t len = 1;
      long l;
      int ret=0;
      double d;
      char tmp[1024];
      grib_expression* expression=grib_arguments_get_expression(a->parent->h,act->default_value,0);
      int type = grib_expression_native_type(a->parent->h,expression);
      switch(type) {
        case GRIB_TYPE_DOUBLE:
          grib_expression_evaluate_double(a->parent->h,expression,&d);
          grib_pack_double(a,&d,&len);
          break;

        case GRIB_TYPE_LONG:
          grib_expression_evaluate_long(a->parent->h,expression,&l);
          grib_pack_long(a,&l,&len);
          break;

        default:
          len = sizeof(tmp);
          p = grib_expression_evaluate_string(a->parent->h,expression,tmp,&len,&ret);
          if (ret != GRIB_SUCCESS) {
			  grib_context_log(a->parent->h->context,GRIB_LOG_FATAL,
							   "unable to evaluate %s as string",a->name);
          }
          len = strlen(p)+1;
          pack_string(a,p,&len);
          break;
      }
    }
  } else
    a->length = len;

}
static int pack_long(grib_accessor* a, const long* val, size_t *len)
{
    char buf[80];
    size_t s;
    sprintf(buf,"%ld",*val);
#if 0
    if(*len > 1)
        return GRIB_NOT_IMPLEMENTED;
#endif
    s = strlen(buf)+1;
    return pack_string(a,buf,&s);
}
Exemplo n.º 11
0
static void pack_obj_created_event(rbkit_obj_created_event *event, msgpack_packer *packer) {
  msgpack_pack_map(packer, 3);
  pack_event_header(packer, event->event_header.event_type);

  msgpack_pack_int(packer, rbkit_message_field_payload);
  msgpack_pack_map(packer, 2);
  msgpack_pack_int(packer, rbkit_message_field_object_id);
  msgpack_pack_unsigned_long_long(packer, event->object_id);
  msgpack_pack_int(packer, rbkit_message_field_class_name);
  pack_string(packer, event->klass);
  //TODO: pack allocation info as well
}
Exemplo n.º 12
0
bool
bresultfile::set_header(const std::vector<std::string> &col_names)
{
    if( m_fp == NULL )
    {
        return false;
    }

    fseek( m_fp, 0L, SEEK_SET );
    m_col_names = col_names;
    
    std::string packed_snp_names = pack_string( m_snp_names );
    std::string packed_col_names = pack_string( m_col_names );

    m_header.snp_names_length = packed_snp_names.size( ) + 1;
    m_header.col_names_length = packed_col_names.size( ) + 1;
    m_header.num_float_cols = m_col_names.size( );

    size_t bytes_written = fwrite( &m_header, sizeof( result_header ), 1, m_fp );
    if( bytes_written != 1 )
    {
        return false;
    }

    bytes_written = fwrite( packed_snp_names.c_str( ), 1, m_header.snp_names_length, m_fp );
    if( bytes_written != m_header.snp_names_length )
    {
        return false;
    }

    bytes_written = fwrite( packed_col_names.c_str( ), 1, m_header.col_names_length, m_fp );
    if( bytes_written != m_header.col_names_length )
    {
        return false;
    }

    return true;
}
Exemplo n.º 13
0
int pack_struct_MultiCallEntry(BUFFER *buf, MultiCallEntry *ptr)
{
    if (pack_string(buf, ptr->name))
        return -1;
    if (pack_integer(buf, ptr->countent))
        return -1;
    if (pack_integer(buf, ptr->countexit))
        return -1;
    if (pack_integer(buf, ptr->tsec))
        return -1;
    if (pack_integer(buf, ptr->tusec))
        return -1;
    if (pack_integer(buf, ptr->counttime))
        return -1;
    return 0;
}
Exemplo n.º 14
0
/* pack sphere into double and integer buffers (d and i buffers are of initial
 * dsize and isize, while the final numberof of doubles and ints is packed) */
void SPHERE_Pack (SPHERE *sph, int *dsize, double **d, int *doubles, int *isize, int **i, int *ints)
{
  pack_int (isize, i, ints, sph->surface);
  pack_int (isize, i, ints, sph->volume);

  pack_doubles (dsize, d, doubles, sph->cur_center, 3);
  pack_doubles (dsize, d, doubles, (double*)sph->cur_point, 9);
  pack_double  (dsize, d, doubles, sph->cur_radius);

  pack_doubles (dsize, d, doubles, sph->ref_center, 3);
  pack_doubles (dsize, d, doubles, (double*)sph->ref_point, 9);
  pack_double  (dsize, d, doubles, sph->ref_radius);

  pack_int (isize, i, ints, sph->mat ? 1 : 0); /* pack material existence flag */
  if (sph->mat) pack_string (isize, i, ints, sph->mat->label);
}
Exemplo n.º 15
0
static void pack_value_object(msgpack_packer *packer, VALUE value) {
  VALUE rubyString;
  char *keyString;
  switch (TYPE(value)) {
    case T_FIXNUM:
      msgpack_pack_long(packer, FIX2LONG(value));
      break;
    case T_FLOAT:
      msgpack_pack_double(packer, rb_num2dbl(value));
      break;
    default:
      rubyString = rb_funcall(value, rb_intern("to_s"), 0, 0);
      keyString = StringValueCStr(rubyString);
      pack_string(packer, keyString);
      break;
  }
}
Exemplo n.º 16
0
quint8 *MsgPackPrivate::pack(const QVariant &v, quint8 *p, bool wr, QVector<QByteArray> &user_data)
{
    QMetaType::Type t = (QMetaType::Type)v.type();
    if (v.isNull() && !v.isValid())
        p = pack_nil(p, wr);
    else if (t == QMetaType::Int)
        p = pack_int(v.toInt(), p, wr);
    else if (t == QMetaType::UInt)
        p = pack_uint(v.toUInt(), p, wr);
    else if (t == QMetaType::Bool)
        p = pack_bool(v, p, wr);
    else if (t == QMetaType::QString)
        p = pack_string(v.toString(), p, wr);
    else if (t == QMetaType::QVariantList)
        p = pack_array(v.toList(), p, wr, user_data);
    else if (t == QMetaType::QStringList)
        p = pack_stringlist(v.toStringList(), p, wr);
    else if (t == QMetaType::LongLong)
        p = pack_longlong(v.toLongLong(), p, wr);
    else if (t == QMetaType::ULongLong)
        p = pack_ulonglong(v.toULongLong(), p, wr);
    else if (t == QMetaType::Double)
        p = pack_double(v.toDouble(), p, wr);
    else if (t == QMetaType::Float)
        p = pack_float(v.toFloat(), p, wr);
    else if (t == QMetaType::QByteArray)
        p = pack_bin(v.toByteArray(), p, wr);
    else if (t == QMetaType::QVariantMap)
        p = pack_map(v.toMap(), p, wr, user_data);
    else {
        if (t == QMetaType::User)
            t = (QMetaType::Type)v.userType();
        QReadLocker locker(&packers_lock);
        bool has_packer = user_packers.contains(t);
        if (has_packer)
            has_packer &= user_packers[t].packer != 0;
        locker.unlock();
        if (has_packer)
            p = pack_user(v, p, wr, user_data);
        else
            qWarning() << "MsgPack::pack can't pack type:" << t;
    }

    return p;
}
Exemplo n.º 17
0
static void
sem_object_end(void *state)
{
	PackState		_state = (PackState) state;
	msgpack_sbuffer	*buf;
	JsonContainer	current_container, parent_container;
	msgpack_packer 	*pk;
	JsonObjectField	field;
	size_t			packed_size;
	char			*packed_data;
	JsonValue		value;

	current_container = _state->current_container;
	pk = _state->pk;

	/* start to pack map */
	msgpack_pack_map(pk, current_container->via.object.length);

	/* pack each field */
	field = current_container->via.object.start;
	while (field != NULL) {
		/* pack key */
		pack_string(pk, field->key);
		/* pack value */
		pack_value(pk, field->value);
		/* next field*/
		field = field->next;
	}

	/* retrieve packed binary and reset buffer of packer */
	buf = _state->buf;
	packed_size = buf->size;
	packed_data = msgpack_sbuffer_release(buf);

	/* set packed binary to the last value of parent conationer */
	parent_container = current_container->parent;
	value = value_to_be_set(parent_container);
	value->type = MSGPACK_BINARY;
	value->via.msg.size = packed_size;
	value->via.msg.data = packed_data;

	/* step back to parent level */
	_state->current_container = parent_container;
	destroy_container(current_container);
}
Exemplo n.º 18
0
int message_serialize_request(struct message_request *req,
    msgpack_packer *pk)
{
  if (!pk || !req)
    return (-1);

  msgpack_pack_array(pk, 4);
  pack_uint8(pk, MESSAGE_TYPE_REQUEST);
  pack_uint32(pk, req->msgid);

  if (req->method.str == NULL || (pack_string(pk, req->method) == -1))
    return (-1);

  if (pack_params(pk, req->params) == -1)
    return (-1);

  return (0);
}
Exemplo n.º 19
0
/* pack ellipsoid into double and integer buffers (d and i buffers are of initial
 * dsize and isize, while the final numberof of doubles and ints is packed) */
void ELLIP_Pack (ELLIP *eli, int *dsize, double **d, int *doubles, int *isize, int **i, int *ints)
{
  pack_int (isize, i, ints, eli->surface);
  pack_int (isize, i, ints, eli->volume);

  pack_doubles (dsize, d, doubles, eli->cur_center, 3);
  pack_doubles (dsize, d, doubles, (double*)eli->cur_point, 9);

  pack_doubles (dsize, d, doubles, eli->ref_center, 3);
  pack_doubles (dsize, d, doubles, (double*)eli->ref_point, 9);

  pack_doubles (dsize, d, doubles, eli->ref_sca, 3);
  pack_doubles (dsize, d, doubles, eli->ref_rot, 9);

  pack_doubles (dsize, d, doubles, eli->cur_sca, 3);
  pack_doubles (dsize, d, doubles, eli->cur_rot, 9);

  pack_int (isize, i, ints, eli->mat ? 1 : 0); /* pack material existence flag */
  if (eli->mat) pack_string (isize, i, ints, eli->mat->label);
}
Exemplo n.º 20
0
static inline void
pack_scalar(msgpack_packer *pk, const JsonValueScalar scalar)
{
	switch (scalar.token_type) {
		case JSON_TOKEN_STRING:
			pack_string(pk, scalar.token);
			break;
		case JSON_TOKEN_NUMBER:
			pack_number(pk, scalar.token);
			break;
		case JSON_TOKEN_TRUE:
			msgpack_pack_true(pk);
			break;
		case JSON_TOKEN_FALSE:
			msgpack_pack_false(pk);
			break;
		case JSON_TOKEN_NULL:
			msgpack_pack_nil(pk);
			break;
		default:
			/* TODO: parse error */
			break;
	}
}
Exemplo n.º 21
0
void pack_local_force_data (entity *en, pack_modes mode)
{

	int
		count,
		loop;

	force
		*raw;

	campaign_criteria_type
		*campaign_criteria;

	ASSERT ((mode >= 0) && (mode < NUM_PACK_MODES));

	ASSERT (en);

	raw = (force *) get_local_entity_data (en);
	
	switch (mode)
	{
		////////////////////////////////////////
		case PACK_MODE_SERVER_SESSION:
		////////////////////////////////////////
		{
         pack_string (en, STRING_TYPE_FORCE_NAME, raw->force_name);

			// keysite_force
	
			// pilot	root
	
			pack_list_root (en, LIST_TYPE_DIVISION, &raw->division_root);
	
			pack_list_root (en, LIST_TYPE_CAMPAIGN_OBJECTIVE, &raw->campaign_objective_root);
	
			// air_registry_root
			// ground_registry_root
			// sea_registry_root

//			pack_list_root (en, LIST_TYPE_INDEPENDENT_GROUP, &raw->independent_group_root);
	
			// force_link
		
			// update link
		
			// task generation //////////////////////////////////////////////
		
			for (loop = 0; loop < NUM_ENTITY_SUB_TYPE_TASKS; loop ++)
			{
				pack_int_value (en, INT_TYPE_VALID, raw->task_generation [loop].valid);

				pack_int_value (en, INT_TYPE_TASK_GENERATION, raw->task_generation [loop].created);
			}
			/////////////////////////////////////////////////////////////////
		
			// campaign criteria ////////////////////////////////////////////
		
			count = 0;
		
			campaign_criteria = raw->campaign_criteria;
		
			while (campaign_criteria)
			{
				count ++;
		
				campaign_criteria = campaign_criteria->next;
			}
		
			pack_int_value (en, INT_TYPE_CAMPAIGN_CRITERIA_COUNT, count);
		
			campaign_criteria = raw->campaign_criteria;
		
			while (campaign_criteria)
			{
		
				pack_int_value (en, INT_TYPE_CAMPAIGN_CRITERIA_TYPE, campaign_criteria->criteria_type);
		
				pack_int_value (en, INT_TYPE_VALID, campaign_criteria->valid);
		
				pack_int_value (en, INT_TYPE_CAMPAIGN_CRITERIA_RESULT, campaign_criteria->result);
		
				pack_int_value (en, INT_TYPE_CAMPAIGN_CRITERIA_VALUE, campaign_criteria->value1);
		
				pack_int_value (en, INT_TYPE_CAMPAIGN_CRITERIA_VALUE, campaign_criteria->value2);
		
				pack_int_value (en, INT_TYPE_CAMPAIGN_CRITERIA_VALUE, campaign_criteria->value3);
		
				pack_int_value (en, INT_TYPE_CAMPAIGN_CRITERIA_VALUE, campaign_criteria->value4);
		
				campaign_criteria = campaign_criteria->next;
			}
			/////////////////////////////////////////////////////////////////
		
			// force_info_criteria
		
			for (loop = 0; loop < NUM_FORCE_INFO_CATAGORIES; loop ++)
			{
				pack_int_value (en, INT_TYPE_VALUE, raw->force_info_current_hardware [loop]);
		
				pack_int_value (en, INT_TYPE_VALUE, raw->force_info_reserve_hardware [loop]);
			}
			/////////////////////////////////////////////////////////////////
	
			for (loop = 0; loop < NUM_ENTITY_SUB_TYPE_GROUPS; loop ++)
			{
				pack_int_value (en, INT_TYPE_VALUE, raw->kills [loop]);
				pack_int_value (en, INT_TYPE_VALUE, raw->losses [loop]);
//				pack_int_value (en, INT_TYPE_VALUE, raw->group_count [loop]);
			}

			pack_float_value (en, FLOAT_TYPE_SLEEP, raw->sleep);
		
			pack_int_value (en, INT_TYPE_FORCE_ATTITUDE, raw->force_attitude);

			// sector_count
		
			pack_int_value (en, INT_TYPE_COLOUR, raw->colour);
		
			pack_int_value (en, INT_TYPE_SIDE, raw->side);
	
			break;
		}

		////////////////////////////////////////
		case PACK_MODE_CLIENT_SESSION:
		////////////////////////////////////////
		{

         pack_string (en, STRING_TYPE_FORCE_NAME, raw->force_name);

			// keysite_force
	
			pack_list_root (en, LIST_TYPE_PILOT, &raw->pilot_root);

			pack_list_root (en, LIST_TYPE_DIVISION, &raw->division_root);

			pack_list_root (en, LIST_TYPE_CAMPAIGN_OBJECTIVE, &raw->campaign_objective_root);

			//	air_registry_root
			//	ground_registry_root
			//	sea_registry_root

//			pack_list_root (en, LIST_TYPE_INDEPENDENT_GROUP, &raw->independent_group_root);
	
			pack_list_link (en, LIST_TYPE_FORCE, &raw->force_link);

			// update link

			// task generation //////////////////////////////////////////////

			for (loop = 0; loop < NUM_ENTITY_SUB_TYPE_TASKS; loop ++)
			{
				pack_int_value (en, INT_TYPE_VALID, raw->task_generation [loop].valid);

				pack_int_value (en, INT_TYPE_TASK_GENERATION, raw->task_generation [loop].created);
			}
			/////////////////////////////////////////////////////////////////

			// campaign criteria ////////////////////////////////////////////

			count = 0;

			campaign_criteria = raw->campaign_criteria;

			while (campaign_criteria)
			{
				count ++;

				campaign_criteria = campaign_criteria->next;
			}

			pack_int_value (en, INT_TYPE_CAMPAIGN_CRITERIA_COUNT, count);

			campaign_criteria = raw->campaign_criteria;

			while (campaign_criteria)
			{

				pack_int_value (en, INT_TYPE_CAMPAIGN_CRITERIA_TYPE, campaign_criteria->criteria_type);

				pack_int_value (en, INT_TYPE_VALID, campaign_criteria->valid);

				pack_int_value (en, INT_TYPE_CAMPAIGN_CRITERIA_RESULT, campaign_criteria->result);

				pack_int_value (en, INT_TYPE_CAMPAIGN_CRITERIA_VALUE, campaign_criteria->value1);

				pack_int_value (en, INT_TYPE_CAMPAIGN_CRITERIA_VALUE, campaign_criteria->value2);

				pack_int_value (en, INT_TYPE_CAMPAIGN_CRITERIA_VALUE, campaign_criteria->value3);

				pack_int_value (en, INT_TYPE_CAMPAIGN_CRITERIA_VALUE, campaign_criteria->value4);

				campaign_criteria = campaign_criteria->next;
			}
			/////////////////////////////////////////////////////////////////

			// force_info_criteria

			for (loop = 0; loop < NUM_FORCE_INFO_CATAGORIES; loop ++)
			{
				pack_int_value (en, INT_TYPE_VALUE, raw->force_info_current_hardware [loop]);

				pack_int_value (en, INT_TYPE_VALUE, raw->force_info_reserve_hardware [loop]);
			}
			/////////////////////////////////////////////////////////////////

			for (loop = 0; loop < NUM_ENTITY_SUB_TYPE_GROUPS; loop ++)
			{
				pack_int_value (en, INT_TYPE_VALUE, raw->kills [loop]);
				pack_int_value (en, INT_TYPE_VALUE, raw->losses [loop]);
//				pack_int_value (en, INT_TYPE_VALUE, raw->group_count [loop]);
			}

			pack_float_value (en, FLOAT_TYPE_SLEEP, raw->sleep);

			pack_int_value (en, INT_TYPE_FORCE_ATTITUDE, raw->force_attitude);

			pack_int_value (en, INT_TYPE_FORCE_SECTOR_COUNT, raw->sector_count);

			pack_int_value (en, INT_TYPE_COLOUR, raw->colour);

			pack_int_value (en, INT_TYPE_SIDE, raw->side);

			break;
		}
		////////////////////////////////////////
		case PACK_MODE_BROWSE_SESSION:
		////////////////////////////////////////
		{
         pack_string (en, STRING_TYPE_FORCE_NAME, raw->force_name);

			// keysite_force_root

			pack_list_root (en, LIST_TYPE_PILOT, &raw->pilot_root);

			pack_list_link (en, LIST_TYPE_FORCE, &raw->force_link);

			// update link

			// task_generation

			// campaign_criteria

			// force_info_catagories

			// sleep

			pack_int_value (en, INT_TYPE_FORCE_ATTITUDE, raw->force_attitude);

			pack_int_value (en, INT_TYPE_COLOUR, raw->colour);

			pack_int_value (en, INT_TYPE_SIDE, raw->side);

			break;
		}
	}
}
/*
 * Loads the contents of the inventory.txt file into
 * a database. Note that because the itemname
 * secondary database is associated to the inventorydb
 * (see env_setup() in gettingstarted_common.c), the
 * itemname index is automatically created when this
 * database is loaded.
 */
int
load_inventory_database(STOCK_DBS my_stock, char *inventory_file)
{
    DBT key, data;
    char buf[MAXLINE];
    char databuf[MAXDATABUF];
    size_t bufLen, dataLen;
    FILE *ifp;

    /*
     * Rather than lining everything up nicely in a struct, we're being
     * deliberately a bit sloppy here. This function illustrates how to
     * store mixed data that might be obtained from various locations
     * in your application.
     */
    float price;
    int quantity;
    char category[MAXFIELD], name[MAXFIELD];
    char vendor[MAXFIELD], sku[MAXFIELD];

    /* Load the inventory database */
    ifp = fopen(inventory_file, "r");
    if (ifp == NULL) {
	fprintf(stderr, "Error opening file '%s'\n", inventory_file);
	    return (-1);
    }

    while (fgets(buf, MAXLINE, ifp) != NULL) {
	/*
	 * Scan the line into the appropriate buffers and variables.
	 * Convenient, but not particularly safe. In a real
	 * program, there would be a lot more defensive code here.
	 */
	sscanf(buf,
	  "%20[^#]#%20[^#]#%f#%i#%20[^#]#%20[^\n]",
	  name, sku, &price, &quantity, category, vendor);

	/*
	 * Now pack it into a single contiguous memory location for
	 * storage.
	 */
	memset(databuf, 0, MAXDATABUF);
	bufLen = 0;
	dataLen = 0;

	dataLen = sizeof(float);
	memcpy(databuf, &price, dataLen);
	bufLen += dataLen;

	dataLen = sizeof(int);
	memcpy(databuf + bufLen, &quantity, dataLen);
	bufLen += dataLen;

	bufLen = pack_string(databuf, name, bufLen);
	bufLen = pack_string(databuf, sku, bufLen);
	bufLen = pack_string(databuf, category, bufLen);
	bufLen = pack_string(databuf, vendor, bufLen);

	/* Zero out the DBTs */
	memset(&key, 0, sizeof(DBT));
	memset(&data, 0, sizeof(DBT));

	/* The key is the item's SKU */
	key.data = sku;
	key.size = (u_int32_t)strlen(sku) + 1;

	/* The data is the information that we packed into databuf. */
	data.data = databuf;
	data.size = (u_int32_t)bufLen;

	/* Put the data into the database */
	my_stock.vendor_dbp->put(my_stock.inventory_dbp, 0, &key, &data, 0);
    } /* end vendors database while loop */

    /* Cleanup */
    fclose(ifp);

    return (0);
}
Exemplo n.º 23
0
static void pack_object_space_dump_event(rbkit_object_space_dump_event *event, msgpack_packer *packer) {
  size_t objects_in_batch;
  size_t objects_left;
  size_t count = 0;
  size_t i = 0;
  rbkit_object_dump_page *prev;
  rbkit_object_data *data;
  rbkit_object_dump_page * page;

  msgpack_pack_map(packer, 5);
  pack_event_header(packer, event->event_header.event_type);

  // Incrementing integer holding the correlation_id
  // indicating the event which the message belongs to
  msgpack_pack_int(packer, rbkit_message_field_correlation_id);
  msgpack_pack_int(packer, event->correlation_id);
  
  // dump total number of messages in batch
  msgpack_pack_int(packer, rbkit_message_field_complete_message_count);
  msgpack_pack_unsigned_long(packer, event->object_count);

  msgpack_pack_int(packer, rbkit_message_field_payload);

  // Find the batch size
  objects_in_batch = MAX_OBJECT_DUMPS_IN_MESSAGE ;
  objects_left = event->object_count - event->packed_objects;
  if(objects_left < MAX_OBJECT_DUMPS_IN_MESSAGE)
    objects_in_batch = objects_left;

  // Set size of array to hold all objects
  msgpack_pack_array(packer, objects_in_batch);

  // Iterate through all object data
  while(count < objects_in_batch) {
    if(event->current_page_index == RBKIT_OBJECT_DUMP_PAGE_SIZE) {
      event->current_page_index = 0;
      prev = event->current_page;
      event->current_page = event->current_page->next;
      free(prev);
    }
    page = event->current_page;
    i = event->current_page_index;
    data = &(page->data[i]);
    /* Object dump is a map that looks like this :
     * {
     *   object_id: <OBJECT_ID_IN_HEX>,
     *   class: <CLASS_NAME>,
     *   references: [<OBJECT_ID_IN_HEX>, <OBJECT_ID_IN_HEX>, ...],
     *   file: <FILE_PATH>,
     *   line: <LINE_NO>,
     *   size: <SIZE>
     * }
     */

    msgpack_pack_map(packer, 6);

    // Key1 : rbkit_message_field_object_id
    msgpack_pack_int(packer, rbkit_message_field_object_id);

    // Value1 : pointer address of object
    msgpack_pack_unsigned_long_long(packer, data->object_id);

    // Key2 : rbkit_message_field_class_name
    msgpack_pack_int(packer, rbkit_message_field_class_name);

    // Value2 : Class name of object
    pack_string(packer, data->class_name);

    // Key3 : rbkit_message_field_references
    msgpack_pack_int(packer, rbkit_message_field_references);

    // Value3 : References held by the object
    msgpack_pack_array(packer, data->reference_count);
    if(data->reference_count != 0) {
      size_t count = 0;
      for(; count < data->reference_count; count++ )
        msgpack_pack_unsigned_long_long(packer, data->references[count]);
      free(data->references);
    }

    // Key4 : rbkit_message_field_file
    msgpack_pack_int(packer, rbkit_message_field_file);

    // Value4 : File path where object is defined
    pack_string(packer, data->file);

    // Key5 : rbkit_message_field_line
    msgpack_pack_int(packer, rbkit_message_field_line);

    // Value5 : Line no where object is defined
    if(data->line == 0)
      msgpack_pack_nil(packer);
    else
      msgpack_pack_unsigned_long(packer, data->line);

    // Key6 : rbkit_message_field_size
    msgpack_pack_int(packer, rbkit_message_field_size);

    // Value6 : Size of the object in memory
    if(data->size == 0)
      msgpack_pack_nil(packer);
    else
      msgpack_pack_unsigned_long(packer, data->size);

    event->current_page_index++;
    event->packed_objects++;
    count++;
  }
}
Exemplo n.º 24
0
 inline void packet(char* buff, size_t* buff_n, bool pack)
 {
     pack_u8(&attribute_group, buff, buff_n, pack);
     pack_u8(&attribute_type, buff, buff_n, pack);
     pack_string(value, STRING_ATTRIBUTE_MAX_LENGTH+1, buff, buff_n, pack);
 }
int captureScreen()
{
	char dstpath[MAX_PATH_LENGTH];
	char* scrimage;
	int width, height;
	Evas* ev = NULL;
	Evas_Object* img;
	screenshot_data sdata;
	probeInfo_t	probeInfo;
	int ret = 0;
	static pthread_mutex_t captureScreenLock = PTHREAD_MUTEX_INITIALIZER;

	pthread_mutex_lock(&captureScreenLock);

	probeBlockStart();

	setProbePoint(&probeInfo);
	sdata.ximage = NULL;
	scrimage = captureScreenShotX(&width, &height, &sdata);
	if(scrimage != NULL)
	{
		ev = create_canvas(width, height);
		if(likely(ev != NULL))
		{
			snprintf(dstpath, sizeof(dstpath),
				 SCREENSHOT_DIRECTORY "/%d_%d.png", getpid(),
				 probeInfo.eventIndex);

			// make image buffer
			if((img = evas_object_image_add(ev)) != NULL)
			{
				//image buffer set
				evas_object_image_data_set(img, NULL);
				evas_object_image_size_set(img, width, height);
				evas_object_image_data_set(img, scrimage);

				// resize image
				if(height > MAX_HEIGHT)
				{
					width = width * MAX_HEIGHT / height;
					height = MAX_HEIGHT;
					evas_object_resize(img, width, height);
					evas_object_image_fill_set(img, 0, 0, width, height);
				}
				evas_object_image_data_update_add(img, 0, 0, width, height);

				//save file
				if(evas_object_image_save(img, dstpath, NULL, "compress=5") != 0)
				{
					chmod(dstpath, 0777);

					/* welcome to the hell */
					log_t log;
					PREPARE_LOCAL_BUF_THOUGH((char *)&log);

					/* skip header */
					LOCAL_BUF += offsetof(log_t, data);
					/* pack screenshot name */
					BUF_PTR = pack_string(LOCAL_BUF, dstpath); /* file name */
					LOCAL_BUF = BUF_PTR;

					/* pack probe */
					PACK_COMMON_BEGIN(MSG_PROBE_SCREENSHOT, API_ID_captureScreen, "", 0);
					PACK_COMMON_END('d', 0, 0, 0);
					PACK_SCREENSHOT(dstpath, getOrientation());
					SET_MSG_LEN();
					log.length = GET_MSG_LEN() + MSG_LEN_OFFSET + strlen(dstpath) + 1;

					/* send all message */
					printLog(&log, MSG_IMAGE);
				}
				else
				{
					// captureScreen : evas_object_image_save failed
					ret = -1;
				}
			}
			else
			{
				// captureScreen : evas_object_image_add failed
				ret = -1;
			}
		}
		else
		{
			// captureScreen : create canvas failed
			ret = -1;
		}
	}
	else
	{
		// captureScreen : captureScreenShotX failed
		ret = -1;
	}

	// release resources
	releaseScreenShotX(&sdata);
	if(ev)
		destroy_canvas(ev);

	probeBlockEnd();

	pthread_mutex_unlock(&captureScreenLock);
	return ret;
}
Exemplo n.º 26
0
 inline void packet(char* buff, size_t* buff_n, bool pack)
 {
     pack_u16(&id, buff, buff_n, pack);
     pack_string(msg, MECH_TEXT_SIZE_MAX+1, buff, buff_n, pack);
 }
Exemplo n.º 27
0
 inline void packet(char* buff, size_t* buff_n, bool pack)
 {
     pack_string(this->token, AUTH_TOKEN_LENGTH+1, buff, buff_n, pack);
 }
Exemplo n.º 28
0
serial pack_string_packet(string_packet* str, serial input) {
  return pack_string(str->str, str->len, input);
}
Exemplo n.º 29
0
 inline void packet(char* buff, size_t* buff_n, bool pack)
 {
     pack_u8(&id, buff, buff_n, pack);
     pack_string(name, PLAYER_NAME_MAX_LENGTH+1, buff, buff_n, pack);
 }
static int pack_string(grib_accessor* a, const char* buffer, size_t *len)
{
  grib_accessor_codetable* self = (grib_accessor_codetable*)a;
  grib_codetable*          table ;

  long i;
  size_t size = 1;

  typedef int (*cmpproc)(const char*, const char*);

  cmpproc cmp = a->flags | GRIB_ACCESSOR_FLAG_LOWERCASE ? strcasecmp : strcmp;

  if(!self->table) self->table = load_table(self);
  table=self->table;

  if(!table)
    return GRIB_ENCODING_ERROR;

  if (a->set) {
	  int err=grib_set_string(a->parent->h,a->set,buffer,len);
	  if (err!=0) return err;
  }

  for(i = 0 ; i < table->size; i++)
    if(table->entries[i].abbreviation)
		  if(cmp(table->entries[i].abbreviation,buffer) == 0)
        return grib_pack_long(a,&i,&size);

  if (a->flags & GRIB_ACCESSOR_FLAG_NO_FAIL) {
	  grib_action* act=(grib_action*)(a->creator);
	  if (act->default_value!=NULL) {
		  const char* p = 0;
		  size_t len = 1;
		  long l;
		  int ret=0;
		  double d;
		  char tmp[1024];
		  grib_expression* expression=grib_arguments_get_expression(a->parent->h,act->default_value,0);
		  int type = grib_expression_native_type(a->parent->h,expression);
		  switch(type) {
			  case GRIB_TYPE_DOUBLE:
				  grib_expression_evaluate_double(a->parent->h,expression,&d);
				  grib_pack_double(a,&d,&len);
				  break;

			  case GRIB_TYPE_LONG:
				  grib_expression_evaluate_long(a->parent->h,expression,&l);
				  grib_pack_long(a,&l,&len);
				  break;

			  default:
				  len = sizeof(tmp);
				  p = grib_expression_evaluate_string(a->parent->h,expression,tmp,&len,&ret);
				  if (ret != GRIB_SUCCESS) {
					  grib_context_log(a->parent->h->context,GRIB_LOG_FATAL,
									   "unable to evaluate %s as string",a->name);
					  return ret;
				  }
				  len = strlen(p)+1;
				  pack_string(a,p,&len);
				  break;
		  }
		  return GRIB_SUCCESS;
	  }
	
  }
  return GRIB_ENCODING_ERROR;
}