static void write_element(const region_element* element, DWORD *buffer,
INT* filled)
{
write_dword(buffer, filled, element->type);
switch (element->type)
{
case CombineModeReplace:
case CombineModeIntersect:
case CombineModeUnion:
case CombineModeXor:
case CombineModeExclude:
case CombineModeComplement:
write_element(element->elementdata.combine.left, buffer, filled);
write_element(element->elementdata.combine.right, buffer, filled);
break;
case RegionDataRect:
write_float(buffer, filled, element->elementdata.rect.X);
write_float(buffer, filled, element->elementdata.rect.Y);
write_float(buffer, filled, element->elementdata.rect.Width);
write_float(buffer, filled, element->elementdata.rect.Height);
break;
case RegionDataPath:
{
DWORD size = write_path_data(element->elementdata.path, buffer + *filled + 1);
write_dword(buffer, filled, size);
*filled += size / sizeof(DWORD);
break;
}
case RegionDataEmptyRect:
case RegionDataInfiniteRect:
break;
}
}
void service_properties_writer::write_metrics(const service_properties::metrics_properties& metrics, std::ostringstream& output)
{
write_element(xml_service_properties_version, metrics.version());
write_element(xml_service_properties_enabled, metrics.enabled() ? header_value_true : header_value_false);
write_element(xml_service_properties_include_apis, metrics.include_apis() ? header_value_true : header_value_false);
write_retention_policy(metrics.retention_policy_enabled(), metrics.retention_days(), output);
}
void service_properties_writer::write_cors_rule(const service_properties::cors_rule& rule, std::ostringstream& output)
{
write_element(xml_service_properties_allowed_origins, core::string_join(rule.allowed_origins(), U(",")));
write_element(xml_service_properties_allowed_methods, core::string_join(rule.allowed_methods(), U(",")));
write_element(xml_service_properties_max_age, rule.max_age().count());
write_element(xml_service_properties_exposed_headers, core::string_join(rule.exposed_headers(), U(",")));
write_element(xml_service_properties_allowed_headers, core::string_join(rule.allowed_headers(), U(",")));
}
void service_properties_writer::write_logging(const service_properties::logging_properties& logging, std::ostringstream& output)
{
write_element(xml_service_properties_version, logging.version());
write_element(xml_service_properties_delete, logging.delete_enabled() ? header_value_true : header_value_false);
write_element(xml_service_properties_read, logging.read_enabled() ? header_value_true : header_value_false);
write_element(xml_service_properties_write, logging.write_enabled() ? header_value_true : header_value_false);
write_retention_policy(logging.retention_policy_enabled(), logging.retention_days(), output);
}
static void write_element(const region_element* element, DWORD *buffer,
INT* filled)
{
write_dword(buffer, filled, element->type);
switch (element->type)
{
case CombineModeReplace:
case CombineModeIntersect:
case CombineModeUnion:
case CombineModeXor:
case CombineModeExclude:
case CombineModeComplement:
write_element(element->elementdata.combine.left, buffer, filled);
write_element(element->elementdata.combine.right, buffer, filled);
break;
case RegionDataRect:
write_float(buffer, filled, element->elementdata.rect.X);
write_float(buffer, filled, element->elementdata.rect.Y);
write_float(buffer, filled, element->elementdata.rect.Width);
write_float(buffer, filled, element->elementdata.rect.Height);
break;
case RegionDataPath:
{
INT i;
const GpPath* path = element->elementdata.pathdata.path;
memcpy(buffer + *filled, &element->elementdata.pathdata.pathheader,
sizeof(element->elementdata.pathdata.pathheader));
*filled += sizeof(element->elementdata.pathdata.pathheader) / sizeof(DWORD);
switch (element->elementdata.pathdata.pathheader.flags)
{
case FLAGS_NOFLAGS:
for (i = 0; i < path->pathdata.Count; i++)
{
write_float(buffer, filled, path->pathdata.Points[i].X);
write_float(buffer, filled, path->pathdata.Points[i].Y);
}
break;
case FLAGS_INTPATH:
for (i = 0; i < path->pathdata.Count; i++)
{
write_packed_point(buffer, filled,
&path->pathdata.Points[i]);
}
}
write_path_types(buffer, filled, path);
break;
}
case RegionDataEmptyRect:
case RegionDataInfiniteRect:
break;
}
}
void service_properties_writer::write_retention_policy(bool enabled, int days, std::ostringstream& output)
{
write_start_element(xml_service_properties_retention);
if (enabled)
{
write_element(xml_service_properties_enabled, header_value_true);
write_element(xml_service_properties_retention_days, days);
}
else
{
write_element(xml_service_properties_enabled, header_value_false);
}
write_end_element();
}
static void write_doc(bson_buffer* buffer, VALUE hash, VALUE check_keys) {
int start_position = buffer->position;
int length_location = buffer_save_bytes(buffer, 4);
VALUE key = rb_str_new2("_id");
if (rb_funcall(hash, rb_intern("has_key?"), 1, key) == Qtrue) {
VALUE id = rb_hash_aref(hash, key);
write_element_allow_id(key, id, pack_extra(buffer, check_keys), 1);
}
key = ID2SYM(rb_intern("_id"));
if (rb_funcall(hash, rb_intern("has_key?"), 1, key) == Qtrue) {
VALUE id = rb_hash_aref(hash, key);
write_element_allow_id(key, id, pack_extra(buffer, check_keys), 1);
}
// we have to check for an OrderedHash and handle that specially
if (strcmp(rb_class2name(RBASIC(hash)->klass), "OrderedHash") == 0) {
VALUE keys = rb_funcall(hash, rb_intern("keys"), 0);
int i;
for(i = 0; i < RARRAY_LEN(keys); i++) {
VALUE key = RARRAY_PTR(keys)[i];
VALUE value = rb_hash_aref(hash, key);
write_element(key, value, pack_extra(buffer, check_keys));
}
} else {
rb_hash_foreach(hash, write_element, pack_extra(buffer, check_keys));
}
// write null byte and fill in length
buffer_write_bytes(buffer, &zero, 1);
int length = buffer->position - start_position;
memcpy(buffer->buffer + length_location, &length, 4);
}
/******************************************************************************
* ModelGen_GUI()
* Generates PLY files for various GUI elements (buttons, etc.)
* TODO: literally only does 'button'.
******************************************************************************/
void ModelGen_GUI()
{
FILE* fp;
char dir[] = "StdAssets/Models/GUI/";
/* Button.ply */
if(!(fp = open_file(dir, "Button.ply"))) {
return;
}
write_element(fp, "vertex", 4);
write_element(fp, "face", 1);
write_end_header(fp);
fprintf(fp, "%f %f %f\n%f %f %f\n%f %f %f\n%f %f %f\n",
0.0f,0.0f,0.0f, 1.0f,0.0f,0.0f, 1.0f,1.0f,0.0f, 0.0f,1.0f,0.0f);
fprintf(fp, "4 %d %d %d %d", 0, 1, 2, 3);
fclose(fp);
}
void xml_writer_impl::write_variant(const variant& value)
{
if ((m_mode & xml_mode::Preserve)==0)
{
m_stack.top().m_attributes.insert("variant", variant(variant::enum_to_string(value.type())));
}
write_element(value);
}
std::string service_properties_writer::write(const service_properties& properties, const service_properties_includes& includes)
{
std::ostringstream outstream;
initialize(outstream);
write_start_element(xml_service_properties);
if (includes.logging())
{
write_start_element(xml_service_properties_logging);
write_logging(properties.logging(), outstream);
write_end_element();
}
if (includes.hour_metrics())
{
write_start_element(xml_service_properties_hour_metrics);
write_metrics(properties.hour_metrics(), outstream);
write_end_element();
}
if (includes.minute_metrics())
{
write_start_element(xml_service_properties_minute_metrics);
write_metrics(properties.minute_metrics(), outstream);
write_end_element();
}
if (includes.cors())
{
write_start_element(xml_service_properties_cors);
for (auto iter = properties.cors().cbegin(); iter != properties.cors().cend(); ++iter)
{
write_start_element(xml_service_properties_cors_rule);
write_cors_rule(*iter, outstream);
write_end_element();
}
write_end_element();
}
if (!properties.default_service_version().empty())
{
write_element(xml_service_properties_default_service_version, properties.default_service_version());
}
finalize();
return outstream.str();
}
DWORD write_region_data(const GpRegion *region, void *data)
{
struct region_header *header = data;
INT filled = 0;
DWORD size;
size = sizeof(struct region_header) + get_element_size(®ion->node);
if (!data) return size;
header->magic = VERSION_MAGIC2;
header->num_children = region->num_children;
filled += 2;
/* With few exceptions, everything written is DWORD aligned,
* so use that as our base */
write_element(®ion->node, (DWORD*)data, &filled);
return size;
}
static void write_doc(buffer_t buffer, VALUE hash, VALUE check_keys) {
buffer_position start_position = buffer_get_position(buffer);
buffer_position length_location = buffer_save_space(buffer, 4);
buffer_position length;
VALUE id_str = rb_str_new2("_id");
VALUE id_sym = ID2SYM(rb_intern("_id"));
if (length_location == -1) {
rb_raise(rb_eNoMemError, "failed to allocate memory in buffer.c");
}
if (rb_funcall(hash, rb_intern("has_key?"), 1, id_str) == Qtrue) {
VALUE id = rb_hash_aref(hash, id_str);
write_element_allow_id(id_str, id, pack_extra(buffer, check_keys), 1);
} else if (rb_funcall(hash, rb_intern("has_key?"), 1, id_sym) == Qtrue) {
VALUE id = rb_hash_aref(hash, id_sym);
write_element_allow_id(id_sym, id, pack_extra(buffer, check_keys), 1);
}
// we have to check for an OrderedHash and handle that specially
if (strcmp(rb_class2name(RBASIC(hash)->klass), "OrderedHash") == 0) {
VALUE keys = rb_funcall(hash, rb_intern("keys"), 0);
int i;
for(i = 0; i < RARRAY_LEN(keys); i++) {
VALUE key = RARRAY_PTR(keys)[i];
VALUE value = rb_hash_aref(hash, key);
write_element(key, value, pack_extra(buffer, check_keys));
}
} else {
rb_hash_foreach(hash, write_element, pack_extra(buffer, check_keys));
}
// write null byte and fill in length
SAFE_WRITE(buffer, &zero, 1);
length = buffer_get_position(buffer) - start_position;
// make sure that length doesn't exceed 4MB
if (length > 4 * 1024 * 1024) {
buffer_free(buffer);
rb_raise(InvalidDocument, "Document too large: BSON documents are limited to 4MB.");
return;
}
SAFE_WRITE_AT_POS(buffer, length_location, (const char*)&length, 4);
}
/*****************************************************************************
* GdipGetRegionData [GDIPLUS.@]
*
* Returns the header, followed by combining ops and region elements.
*
* PARAMS
* region [I] region to retrieve from
* buffer [O] buffer to hold the resulting data
* size [I] size of the buffer
* needed [O] (optional) how much data was written
*
* RETURNS
* SUCCESS: Ok
* FAILURE: InvalidParameter
*
* NOTES
* The header contains the size, a checksum, a version string, and the number
* of children. The size does not count itself or the checksum.
* Version is always something like 0xdbc01001 or 0xdbc01002
*
* An element is a RECT, or PATH; Combining ops are stored as their
* CombineMode value. Special regions (infinite, empty) emit just their
* op-code; GpRectFs emit their code followed by their points; GpPaths emit
* their code followed by a second header for the path followed by the actual
* path data. Followed by the flags for each point. The pathheader contains
* the size of the data to follow, a version number again, followed by a count
* of how many points, and any special flags which may apply. 0x4000 means its
* a path of shorts instead of FLOAT.
*
* Combining Ops are stored in reverse order from when they were constructed;
* the output is a tree where the left side combining area is always taken
* first.
*/
GpStatus WINGDIPAPI GdipGetRegionData(GpRegion *region, BYTE *buffer, UINT size,
UINT *needed)
{
struct _region_header
{
DWORD size;
DWORD checksum;
DWORD magic;
DWORD num_children;
} *region_header;
INT filled = 0;
UINT required;
GpStatus status;
TRACE("%p, %p, %d, %p\n", region, buffer, size, needed);
if (!region || !buffer || !size)
return InvalidParameter;
status = GdipGetRegionDataSize(region, &required);
if (status != Ok) return status;
if (size < required)
{
if (needed) *needed = size;
return InsufficientBuffer;
}
region_header = (struct _region_header *)buffer;
region_header->size = sizeheader_size + get_element_size(®ion->node);
region_header->checksum = 0;
region_header->magic = VERSION_MAGIC;
region_header->num_children = region->num_children;
filled += 4;
/* With few exceptions, everything written is DWORD aligned,
* so use that as our base */
write_element(®ion->node, (DWORD*)buffer, &filled);
if (needed)
*needed = filled * sizeof(DWORD);
return Ok;
}
/*****************************************************************************
* GdipGetRegionData [GDIPLUS.@]
*
* Returns the header, followed by combining ops and region elements.
*
* PARAMS
* region [I] region to retrieve from
* buffer [O] buffer to hold the resulting data
* size [I] size of the buffer
* needed [O] (optional) how much data was written
*
* RETURNS
* SUCCESS: Ok
* FAILURE: InvalidParameter
*
* NOTES
* The header contains the size, a checksum, a version string, and the number
* of children. The size does not count itself or the checksum.
* Version is always something like 0xdbc01001 or 0xdbc01002
*
* An element is a RECT, or PATH; Combining ops are stored as their
* CombineMode value. Special regions (infinite, empty) emit just their
* op-code; GpRectFs emit their code followed by their points; GpPaths emit
* their code followed by a second header for the path followed by the actual
* path data. Followed by the flags for each point. The pathheader contains
* the size of the data to follow, a version number again, followed by a count
* of how many points, and any special flags which may apply. 0x4000 means its
* a path of shorts instead of FLOAT.
*
* Combining Ops are stored in reverse order from when they were constructed;
* the output is a tree where the left side combining area is always taken
* first.
*/
GpStatus WINGDIPAPI GdipGetRegionData(GpRegion *region, BYTE *buffer, UINT size,
UINT *needed)
{
INT filled = 0;
TRACE("%p, %p, %d, %p\n", region, buffer, size, needed);
if (!(region && buffer && size))
return InvalidParameter;
memcpy(buffer, ®ion->header, sizeof(region->header));
filled += sizeof(region->header) / sizeof(DWORD);
/* With few exceptions, everything written is DWORD aligned,
* so use that as our base */
write_element(®ion->node, (DWORD*)buffer, &filled);
if (needed)
*needed = filled * sizeof(DWORD);
return Ok;
}
dmz::Boolean
dmz::NetModulePacketCodecBasic::HeaderElement::write_header (
const Handle PacketID,
Marshal &data) {
Boolean result (True);
if (write_element (PacketID, data)) {
HeaderElement *current (next);
while (current) {
result = current->write_element (PacketID, data);
if (!result) { current = 0; }
else { current = current->next; }
}
}
else { result = False; }
return result;
}
static int write_element_allow_id(VALUE key, VALUE value, VALUE extra, int allow_id) {
buffer_t buffer = (buffer_t)NUM2LL(rb_ary_entry(extra, 0));
VALUE check_keys = rb_ary_entry(extra, 1);
if (TYPE(key) == T_SYMBOL) {
// TODO better way to do this... ?
key = rb_str_new2(rb_id2name(SYM2ID(key)));
}
if (TYPE(key) != T_STRING) {
buffer_free(buffer);
rb_raise(rb_eTypeError, "keys must be strings or symbols");
}
if (!allow_id && strcmp("_id", RSTRING_PTR(key)) == 0) {
return ST_CONTINUE;
}
if (check_keys == Qtrue) {
int i;
if (RSTRING_LEN(key) > 0 && RSTRING_PTR(key)[0] == '$') {
buffer_free(buffer);
rb_raise(InvalidName, "key must not start with '$'");
}
for (i = 0; i < RSTRING_LEN(key); i++) {
if (RSTRING_PTR(key)[i] == '.') {
buffer_free(buffer);
rb_raise(InvalidName, "key must not contain '.'");
}
}
}
switch(TYPE(value)) {
case T_BIGNUM:
case T_FIXNUM:
{
if (rb_funcall(value, rb_intern(">"), 1, LL2NUM(9223372036854775807LL)) == Qtrue ||
rb_funcall(value, rb_intern("<"), 1, LL2NUM(-9223372036854775808ULL)) == Qtrue) {
buffer_free(buffer);
rb_raise(rb_eRangeError, "MongoDB can only handle 8-byte ints");
}
if (rb_funcall(value, rb_intern(">"), 1, INT2NUM(2147483647L)) == Qtrue ||
rb_funcall(value, rb_intern("<"), 1, INT2NUM(-2147483648L)) == Qtrue) {
long long ll_value;
write_name_and_type(buffer, key, 0x12);
ll_value = NUM2LL(value);
SAFE_WRITE(buffer, (char*)&ll_value, 8);
} else {
int int_value;
write_name_and_type(buffer, key, 0x10);
int_value = NUM2LL(value);
SAFE_WRITE(buffer, (char*)&int_value, 4);
}
break;
}
case T_TRUE:
{
write_name_and_type(buffer, key, 0x08);
SAFE_WRITE(buffer, &one, 1);
break;
}
case T_FALSE:
{
write_name_and_type(buffer, key, 0x08);
SAFE_WRITE(buffer, &zero, 1);
break;
}
case T_FLOAT:
{
double d = NUM2DBL(value);
write_name_and_type(buffer, key, 0x01);
SAFE_WRITE(buffer, (char*)&d, 8);
break;
}
case T_NIL:
{
write_name_and_type(buffer, key, 0x0A);
break;
}
case T_HASH:
{
write_name_and_type(buffer, key, 0x03);
write_doc(buffer, value, check_keys);
break;
}
case T_ARRAY:
{
buffer_position length_location, start_position, obj_length;
int items, i;
VALUE* values;
write_name_and_type(buffer, key, 0x04);
start_position = buffer_get_position(buffer);
// save space for length
length_location = buffer_save_space(buffer, 4);
if (length_location == -1) {
rb_raise(rb_eNoMemError, "failed to allocate memory in buffer.c");
}
items = RARRAY_LEN(value);
values = RARRAY_PTR(value);
for(i = 0; i < items; i++) {
char* name;
VALUE key;
INT2STRING(&name, i);
key = rb_str_new2(name);
write_element(key, values[i], pack_extra(buffer, check_keys));
free(name);
}
// write null byte and fill in length
SAFE_WRITE(buffer, &zero, 1);
obj_length = buffer_get_position(buffer) - start_position;
SAFE_WRITE_AT_POS(buffer, length_location, (const char*)&obj_length, 4);
break;
}
case T_STRING:
{
if (strcmp(rb_class2name(RBASIC(value)->klass),
"Mongo::Code") == 0) {
buffer_position length_location, start_position, total_length;
int length;
write_name_and_type(buffer, key, 0x0F);
start_position = buffer_get_position(buffer);
length_location = buffer_save_space(buffer, 4);
if (length_location == -1) {
rb_raise(rb_eNoMemError, "failed to allocate memory in buffer.c");
}
length = RSTRING_LEN(value) + 1;
SAFE_WRITE(buffer, (char*)&length, 4);
SAFE_WRITE(buffer, RSTRING_PTR(value), length - 1);
SAFE_WRITE(buffer, &zero, 1);
write_doc(buffer, rb_funcall(value, rb_intern("scope"), 0), Qfalse);
total_length = buffer_get_position(buffer) - start_position;
SAFE_WRITE_AT_POS(buffer, length_location, (const char*)&total_length, 4);
break;
} else {
int length;
write_name_and_type(buffer, key, 0x02);
value = TO_UTF8(value);
length = RSTRING_LEN(value) + 1;
SAFE_WRITE(buffer, (char*)&length, 4);
write_utf8(buffer, value, 0);
SAFE_WRITE(buffer, &zero, 1);
break;
}
}
case T_SYMBOL:
{
const char* str_value = rb_id2name(SYM2ID(value));
int length = strlen(str_value) + 1;
write_name_and_type(buffer, key, 0x0E);
SAFE_WRITE(buffer, (char*)&length, 4);
SAFE_WRITE(buffer, str_value, length);
break;
}
case T_OBJECT:
{
// TODO there has to be a better way to do these checks...
const char* cls = rb_class2name(RBASIC(value)->klass);
if (strcmp(cls, "Mongo::Binary") == 0 ||
strcmp(cls, "ByteBuffer") == 0) {
const char subtype = strcmp(cls, "ByteBuffer") ?
(const char)FIX2INT(rb_funcall(value, rb_intern("subtype"), 0)) : 2;
VALUE string_data = rb_funcall(value, rb_intern("to_s"), 0);
int length = RSTRING_LEN(string_data);
write_name_and_type(buffer, key, 0x05);
if (subtype == 2) {
const int other_length = length + 4;
SAFE_WRITE(buffer, (const char*)&other_length, 4);
SAFE_WRITE(buffer, &subtype, 1);
}
SAFE_WRITE(buffer, (const char*)&length, 4);
if (subtype != 2) {
SAFE_WRITE(buffer, &subtype, 1);
}
SAFE_WRITE(buffer, RSTRING_PTR(string_data), length);
break;
}
if (strcmp(cls, "Mongo::ObjectID") == 0) {
VALUE as_array = rb_funcall(value, rb_intern("to_a"), 0);
int i;
write_name_and_type(buffer, key, 0x07);
for (i = 0; i < 12; i++) {
char byte = (char)FIX2INT(RARRAY_PTR(as_array)[i]);
SAFE_WRITE(buffer, &byte, 1);
}
break;
}
if (strcmp(cls, "Mongo::DBRef") == 0) {
buffer_position length_location, start_position, obj_length;
VALUE ns, oid;
write_name_and_type(buffer, key, 0x03);
start_position = buffer_get_position(buffer);
// save space for length
length_location = buffer_save_space(buffer, 4);
if (length_location == -1) {
rb_raise(rb_eNoMemError, "failed to allocate memory in buffer.c");
}
ns = rb_funcall(value, rb_intern("namespace"), 0);
write_element(rb_str_new2("$ref"), ns, pack_extra(buffer, Qfalse));
oid = rb_funcall(value, rb_intern("object_id"), 0);
write_element(rb_str_new2("$id"), oid, pack_extra(buffer, Qfalse));
// write null byte and fill in length
SAFE_WRITE(buffer, &zero, 1);
obj_length = buffer_get_position(buffer) - start_position;
SAFE_WRITE_AT_POS(buffer, length_location, (const char*)&obj_length, 4);
break;
}
if (strcmp(cls, "Mongo::MaxKey") == 0) {
write_name_and_type(buffer, key, 0x7f);
break;
}
if (strcmp(cls, "Mongo::MinKey") == 0) {
write_name_and_type(buffer, key, 0xff);
break;
}
if (strcmp(cls, "DateTime") == 0 || strcmp(cls, "Date") == 0 || strcmp(cls, "ActiveSupport::TimeWithZone") == 0) {
buffer_free(buffer);
rb_raise(InvalidDocument, "%s is not currently supported; use a UTC Time instance instead.", cls);
break;
}
if(strcmp(cls, "Complex") == 0 || strcmp(cls, "Rational") == 0 || strcmp(cls, "BigDecimal") == 0) {
buffer_free(buffer);
rb_raise(InvalidDocument, "Cannot serialize the Numeric type %s as BSON; only Bignum, Fixnum, and Float are supported.", cls);
break;
}
buffer_free(buffer);
rb_raise(InvalidDocument, "Cannot serialize an object of class %s into BSON.", cls);
break;
}
case T_DATA:
{
const char* cls = rb_class2name(RBASIC(value)->klass);
if (strcmp(cls, "Time") == 0) {
double t = NUM2DBL(rb_funcall(value, rb_intern("to_f"), 0));
long long time_since_epoch = (long long)round(t * 1000);
write_name_and_type(buffer, key, 0x09);
SAFE_WRITE(buffer, (const char*)&time_since_epoch, 8);
break;
}
if(strcmp(cls, "BigDecimal") == 0) {
buffer_free(buffer);
rb_raise(InvalidDocument, "Cannot serialize the Numeric type %s as BSON; only Bignum, Fixnum, and Float are supported.", cls);
break;
}
buffer_free(buffer);
rb_raise(InvalidDocument, "Cannot serialize an object of class %s into BSON.", cls);
break;
}
case T_REGEXP:
{
VALUE pattern = RREGEXP_SRC(value);
long flags = RREGEXP(value)->ptr->options;
VALUE has_extra;
write_name_and_type(buffer, key, 0x0B);
pattern = TO_UTF8(pattern);
write_utf8(buffer, pattern, 1);
SAFE_WRITE(buffer, &zero, 1);
if (flags & IGNORECASE) {
char ignorecase = 'i';
SAFE_WRITE(buffer, &ignorecase, 1);
}
if (flags & MULTILINE) {
char multiline = 'm';
SAFE_WRITE(buffer, &multiline, 1);
}
if (flags & EXTENDED) {
char extended = 'x';
SAFE_WRITE(buffer, &extended, 1);
}
has_extra = rb_funcall(value, rb_intern("respond_to?"), 1, rb_str_new2("extra_options_str"));
if (TYPE(has_extra) == T_TRUE) {
VALUE extra = rb_funcall(value, rb_intern("extra_options_str"), 0);
buffer_position old_position = buffer_get_position(buffer);
SAFE_WRITE(buffer, RSTRING_PTR(extra), RSTRING_LEN(extra));
qsort(buffer_get_buffer(buffer) + old_position, RSTRING_LEN(extra), sizeof(char), cmp_char);
}
SAFE_WRITE(buffer, &zero, 1);
break;
}
default:
{
const char* cls = rb_class2name(RBASIC(value)->klass);
buffer_free(buffer);
rb_raise(InvalidDocument, "Cannot serialize an object of class %s (type %d) into BSON.", cls, TYPE(value));
break;
}
}
return ST_CONTINUE;
}
static PyObject *
obf_encode_circuit(PyObject *self, PyObject *args)
{
PyObject *py_state, *py_ys, *py_xdegs;
mpz_t tmp, c_star;
mpz_t *alphas, *betas;
int n, m, ydeg;
int *indices, *pows;
char *circuit, *fname;
int fnamelen = sizeof(int) + 5;
int idx_set_size;
struct state *s;
if (!PyArg_ParseTuple(args, "OsOOiii", &py_state, &circuit, &py_ys,
&py_xdegs, &ydeg, &n,&m)){
fprintf(stderr,"!!!!!!!! NOT PARSING !!!!!!!!!!!!!!!!\n");
return NULL;}
s = (struct state *) PyCapsule_GetPointer(py_state, NULL);
if (s == NULL)
return NULL;
fname = (char *) malloc(sizeof(char) * fnamelen);
if (fname == NULL)
return NULL;
int ierr,rank,world_size;
ierr = MPI_Comm_rank ( MPI_COMM_WORLD, &rank );
ierr = MPI_Comm_size(MPI_COMM_WORLD,&world_size);
struct clt_mlm_ser_enc* sent_mlm = stat_ser(&(s->mlm));
//broadcast_clt_mlm_ser_enc(sent_mlm);
ser_stat( sent_mlm,&(s->mlm) );
mpz_init_set(s->nev, s->mlm.gs[0]);
mpz_init_set(s->nchk, s->mlm.gs[1]);
mpz_inits(c_star, tmp, NULL);
rank = 0;
world_size =1;
int start_n_loop = rank*n/world_size;
int stop_n_loop = (rank+1)*n/world_size;
//int size_n_loop = start_n_loop - stop_n_loop;
int start_m_loop = rank*m/world_size;
int stop_m_loop = (rank+1)*m/world_size;
//int size_m_loop = start_m_loop;
alphas = (mpz_t *) malloc(sizeof(mpz_t) * n);
#pragma omp parallel for
for (int i = 0; i < n; ++i) {
mpz_init(alphas[i]);
mpz_urandomm(alphas[i], s->mlm.rng, s->nchk);
}
betas = (mpz_t *) malloc(sizeof(mpz_t) * m);
#pragma omp parallel for
for (int i = 0; i < m; ++i) {
mpz_init(betas[i]);
mpz_urandomm(betas[i], s->mlm.rng, s->nchk);
}
std::vector<std::vector<char> > alpha_send = mpz_arr_to_vec(alphas, n);
std::vector<std::vector<char> > beta_send = mpz_arr_to_vec(betas, m);
//broadcast_vec_vec(&alpha_send);
//broadcast_vec_vec(&beta_send);
vec_to_mpz_array(alphas,alpha_send);
vec_to_mpz_array(betas,beta_send);
fprintf(stderr,"Process %d has g[0] = %lu\n",rank,mpz_get_ui(s->mlm.gs[0]));
fprintf(stderr,"Process %d has pzt = %lu\n",rank,mpz_get_ui(s->mlm.pzt));
fprintf(stderr,"Process %d has alpha = %lu\n",rank,mpz_get_ui(alphas[2]));
// The index set is laid out as follows:
// - The first 2 * n entries contain X_i,0 and X_i,1
// - The next n entries contain Z_i
// - The next n entries contain W_i
// - The final entry contains Y
idx_set_size = 4 * n + 1;
indices = (int *) malloc(sizeof(int) * idx_set_size);
pows = (int *) malloc(sizeof(int) * idx_set_size);
//MR
fprintf(stderr, "m: %d , n: %d \n ", m,n);
for (int i = start_n_loop; i <stop_n_loop ; ++i) {
fprintf(stderr,"In loop: %d\n",i);
mpz_t out, elems[2];
int deg;
mpz_inits(out, elems[0], elems[1], NULL);
deg = PyLong_AsLong(PyList_GET_ITEM(py_xdegs, i));
//MR
//fprintf(stderr, "%d, " ,deg);
set_indices_pows(indices, pows, 1, 2 * i, 1);
mpz_set_ui(elems[0], 0);
mpz_set(elems[1], alphas[i]);
clt_mlm_encode(&s->mlm, out, 2, elems, 1, indices, pows);
(void) snprintf(fname, fnamelen, "x_%d_0", i);
(void) write_element(s->dir, out, fname);
fprintf(stderr,"Past 1st encode In loop: %d\n",i);
set_indices_pows(indices, pows, 1, 2 * i, 1);
mpz_set_ui(elems[0], 1);
mpz_set_ui(elems[1], 1);
clt_mlm_encode(&s->mlm, out, 2, elems, 1, indices, pows);
(void) snprintf(fname, fnamelen, "u_%d_0", i);
(void) write_element(s->dir, out, fname);
set_indices_pows(indices, pows, 1, 2 * i + 1, 1);
mpz_set_ui(elems[0], 1);
mpz_set(elems[1], alphas[i]);
clt_mlm_encode(&s->mlm, out, 2, elems, 1, indices, pows);
fprintf(stderr,"Past Third encode In loop: %d\n",i);
(void) snprintf(fname, fnamelen, "x_%d_1", i);
(void) write_element(s->dir, out, fname);
set_indices_pows(indices, pows, 1, 2 * i + 1, 1);
mpz_set_ui(elems[0], 1);
mpz_set_ui(elems[1], 1);
clt_mlm_encode(&s->mlm, out, 2, elems, 1, indices, pows);
(void) snprintf(fname, fnamelen, "u_%d_1", i);
(void) write_element(s->dir, out, fname);
mpz_urandomm(elems[0], s->mlm.rng, s->nev);
mpz_urandomm(elems[1], s->mlm.rng, s->nchk);
set_indices_pows(indices, pows, 3, 2 * i + 1, deg, 2 * n + i, 1,
3 * n + i, 1);
clt_mlm_encode(&s->mlm, out, 2, elems, 3, indices, pows);
(void) snprintf(fname, fnamelen, "z_%d_0", i);
(void) write_element(s->dir, out, fname);
set_indices_pows(indices, pows, 1, 3 * n + i, 1);
mpz_set_ui(elems[0], 0);
clt_mlm_encode(&s->mlm, out, 2, elems, 1, indices, pows);
(void) snprintf(fname, fnamelen, "w_%d_0", i);
(void) write_element(s->dir, out, fname);
mpz_urandomm(elems[0], s->mlm.rng, s->nev);
mpz_urandomm(elems[1], s->mlm.rng, s->nchk);
set_indices_pows(indices, pows, 3, 2 * i, deg, 2 * n + i, 1, 3 * n + i, 1);
clt_mlm_encode(&s->mlm, out, 2, elems, 3, indices, pows);
(void) snprintf(fname, fnamelen, "z_%d_1", i);
(void) write_element(s->dir, out, fname);
set_indices_pows(indices, pows, 1, 3 * n + i, 1);
mpz_set_ui(elems[0], 0);
clt_mlm_encode(&s->mlm, out, 2, elems, 1, indices, pows);
(void) snprintf(fname, fnamelen, "w_%d_1", i);
(void) write_element(s->dir, out, fname);
mpz_clears(out, elems[0], elems[1], NULL);
}
set_indices_pows(indices, pows, 1, 4 * n, 1);
for (int i = start_m_loop; i < stop_m_loop; ++i) {
mpz_t out, elems[2];
mpz_inits(out, elems[0], elems[1], NULL);
py_to_mpz(elems[0], PyList_GET_ITEM(py_ys, i));
if (mpz_sgn(elems[0]) == -1) {
mpz_mod(elems[0], elems[0], s->nev);
}
mpz_set(elems[1], betas[i]);
clt_mlm_encode(&s->mlm, out, 2, elems, 1, indices, pows);
(void) snprintf(fname, fnamelen, "y_%d", i);
(void) write_element(s->dir, out, fname);
mpz_clears(out, elems[0], elems[1], NULL);
}
if(rank==0) {
mpz_t elems[2];
mpz_init_set_ui(elems[0], 1);
mpz_init_set_ui(elems[1], 1);
clt_mlm_encode(&s->mlm, tmp, 2, elems, 1, indices, pows);
(void) write_element(s->dir, tmp, "v");
mpz_clears(elems[0], elems[1], NULL);
}
if(rank==0){
struct circuit *c;
c = circ_parse(circuit);
{
int circnamelen;
char *circname;
circnamelen = strlen(s->dir) + strlen("/circuit") + 2;
circname = (char *) malloc(sizeof(char) * circnamelen);
(void) snprintf(circname, circnamelen, "%s/circuit", s->dir);
(void) circ_copy_circuit(circuit, circname);
free(circname);
}
(void) circ_evaluate(c, alphas, betas, c_star, s->mlm.q);
circ_cleanup(c);
}
//GET ALPHAS AND BETAS BACK TO ROOT! Maybe with a gather?
if(rank==0){
{
mpz_t elems[2];
// The C* encoding contains everything but the W_i symbols.
// Here we calculate the appropriate indices and powers.
for (int i = 0; i < n; ++i) {
int deg;
deg = PyLong_AsLong(PyList_GET_ITEM(py_xdegs, i));
// X_i,0^deg(x_i)
indices[2 * i] = 2 * i;
pows[2 * i] = deg;
// X_i,1^deg(x_i)
indices[2 * i + 1] = 2 * i + 1;
pows[2 * i + 1] = deg;
// Z_i
indices[2 * n + i] = 2 * n + i;
pows[2 * n + i] = 1;
}
// Y^deg(y)
indices[3 * n] = 4 * n;
pows[3 * n] = ydeg;
// Encode against these indices/powers
mpz_init_set_ui(elems[0], 0);
mpz_init_set(elems[1], c_star);
clt_mlm_encode(&s->mlm, tmp, 2, elems, 3 * n + 1, indices, pows);
}
(void) write_element(s->dir, tmp, "c_star");
}
mpz_clears(c_star, tmp, NULL);
fprintf(stderr,"QSIZE= %d\n",(mpz_sizeinbase(s->mlm.q, 2)));
fprintf(stderr,"Process %d has finished its encoding work!\n",rank);
MPI_Barrier(MPI_COMM_WORLD);
Py_RETURN_NONE;
}
static void write_element(const region_element* element, DWORD *buffer,
INT* filled)
{
write_dword(buffer, filled, element->type);
switch (element->type)
{
case CombineModeReplace:
case CombineModeIntersect:
case CombineModeUnion:
case CombineModeXor:
case CombineModeExclude:
case CombineModeComplement:
write_element(element->elementdata.combine.left, buffer, filled);
write_element(element->elementdata.combine.right, buffer, filled);
break;
case RegionDataRect:
write_float(buffer, filled, element->elementdata.rect.X);
write_float(buffer, filled, element->elementdata.rect.Y);
write_float(buffer, filled, element->elementdata.rect.Width);
write_float(buffer, filled, element->elementdata.rect.Height);
break;
case RegionDataPath:
{
INT i;
const GpPath* path = element->elementdata.path;
struct _pathheader
{
DWORD size;
DWORD magic;
DWORD count;
DWORD flags;
} *pathheader;
pathheader = (struct _pathheader *)(buffer + *filled);
pathheader->flags = is_integer_path(path) ? FLAGS_INTPATH : FLAGS_NOFLAGS;
/* 3 for headers, once again size doesn't count itself */
pathheader->size = sizeof(DWORD) * 3;
if (pathheader->flags & FLAGS_INTPATH)
pathheader->size += 2 * sizeof(SHORT) * path->pathdata.Count;
else
pathheader->size += 2 * sizeof(FLOAT) * path->pathdata.Count;
pathheader->size += get_pathtypes_size(path);
pathheader->magic = VERSION_MAGIC;
pathheader->count = path->pathdata.Count;
*filled += 4;
switch (pathheader->flags & FLAGS_INTPATH)
{
case FLAGS_NOFLAGS:
for (i = 0; i < path->pathdata.Count; i++)
{
write_float(buffer, filled, path->pathdata.Points[i].X);
write_float(buffer, filled, path->pathdata.Points[i].Y);
}
break;
case FLAGS_INTPATH:
for (i = 0; i < path->pathdata.Count; i++)
{
write_packed_point(buffer, filled,
&path->pathdata.Points[i]);
}
break;
}
write_path_types(buffer, filled, path);
break;
}
case RegionDataEmptyRect:
case RegionDataInfiniteRect:
break;
}
}
static int write_element_with_id(VALUE key, VALUE value, VALUE extra) {
return write_element(key, value, extra, 1);
}
static int write_element_allow_id(VALUE key, VALUE value, VALUE extra, int allow_id) {
bson_buffer* buffer = (bson_buffer*)NUM2INT(rb_ary_entry(extra, 0));
VALUE check_keys = rb_ary_entry(extra, 1);
if (TYPE(key) == T_SYMBOL) {
// TODO better way to do this... ?
key = rb_str_new2(rb_id2name(SYM2ID(key)));
}
if (TYPE(key) != T_STRING) {
rb_raise(rb_eTypeError, "keys must be strings or symbols");
}
if (!allow_id && strcmp("_id", RSTRING_PTR(key)) == 0) {
return ST_CONTINUE;
}
if (check_keys == Qtrue) {
if (RSTRING_LEN(key) > 0 && RSTRING_PTR(key)[0] == '$') {
rb_raise(rb_eRuntimeError, "key must not start with '$'");
}
int i;
for (i = 0; i < RSTRING_LEN(key); i++) {
if (RSTRING_PTR(key)[i] == '.') {
rb_raise(rb_eRuntimeError, "key must not contain '.'");
}
}
}
switch(TYPE(value)) {
case T_BIGNUM:
{
if (rb_funcall(value, rb_intern(">"), 1, INT2NUM(2147483647)) == Qtrue ||
rb_funcall(value, rb_intern("<"), 1, INT2NUM(-2147483648)) == Qtrue) {
rb_raise(rb_eRangeError, "MongoDB can only handle 4-byte ints - try converting to a double before saving");
}
write_name_and_type(buffer, key, 0x10);
VALUE as_f = rb_funcall(value, rb_intern("to_f"), 0);
int int_value = NUM2LL(as_f);
buffer_write_bytes(buffer, (char*)&int_value, 4);
break;
}
case T_FIXNUM:
{
write_name_and_type(buffer, key, 0x10);
int int_value = FIX2INT(value);
buffer_write_bytes(buffer, (char*)&int_value, 4);
break;
}
case T_TRUE:
{
write_name_and_type(buffer, key, 0x08);
buffer_write_bytes(buffer, &one, 1);
break;
}
case T_FALSE:
{
write_name_and_type(buffer, key, 0x08);
buffer_write_bytes(buffer, &zero, 1);
break;
}
case T_FLOAT:
{
write_name_and_type(buffer, key, 0x01);
double d = NUM2DBL(value);
buffer_write_bytes(buffer, (char*)&d, 8);
break;
}
case T_NIL:
{
write_name_and_type(buffer, key, 0x0A);
break;
}
case T_HASH:
{
write_name_and_type(buffer, key, 0x03);
write_doc(buffer, value, check_keys);
break;
}
case T_ARRAY:
{
write_name_and_type(buffer, key, 0x04);
int start_position = buffer->position;
// save space for length
int length_location = buffer_save_bytes(buffer, 4);
int items = RARRAY_LEN(value);
VALUE* values = RARRAY_PTR(value);
int i;
for(i = 0; i < items; i++) {
char* name;
asprintf(&name, "%d", i);
VALUE key = rb_str_new2(name);
write_element(key, values[i], pack_extra(buffer, check_keys));
free(name);
}
// write null byte and fill in length
buffer_write_bytes(buffer, &zero, 1);
int obj_length = buffer->position - start_position;
memcpy(buffer->buffer + length_location, &obj_length, 4);
break;
}
case T_STRING:
{
if (strcmp(rb_class2name(RBASIC(value)->klass),
"XGen::Mongo::Driver::Code") == 0) {
write_name_and_type(buffer, key, 0x0F);
int start_position = buffer->position;
int length_location = buffer_save_bytes(buffer, 4);
int length = RSTRING_LEN(value) + 1;
buffer_write_bytes(buffer, (char*)&length, 4);
buffer_write_bytes(buffer, RSTRING_PTR(value), length - 1);
buffer_write_bytes(buffer, &zero, 1);
write_doc(buffer, rb_funcall(value, rb_intern("scope"), 0), Qfalse);
int total_length = buffer->position - start_position;
memcpy(buffer->buffer + length_location, &total_length, 4);
break;
} else {
write_name_and_type(buffer, key, 0x02);
int length = RSTRING_LEN(value) + 1;
buffer_write_bytes(buffer, (char*)&length, 4);
buffer_write_bytes(buffer, RSTRING_PTR(value), length - 1);
buffer_write_bytes(buffer, &zero, 1);
break;
}
}
case T_SYMBOL:
{
write_name_and_type(buffer, key, 0x0E);
const char* str_value = rb_id2name(SYM2ID(value));
int length = strlen(str_value) + 1;
buffer_write_bytes(buffer, (char*)&length, 4);
buffer_write_bytes(buffer, str_value, length);
break;
}
case T_OBJECT:
{
// TODO there has to be a better way to do these checks...
const char* cls = rb_class2name(RBASIC(value)->klass);
if (strcmp(cls, "XGen::Mongo::Driver::Binary") == 0 ||
strcmp(cls, "ByteBuffer") == 0) {
write_name_and_type(buffer, key, 0x05);
const char subtype = strcmp(cls, "ByteBuffer") ?
(const char)FIX2INT(rb_funcall(value, rb_intern("subtype"), 0)) : 2;
VALUE string_data = rb_funcall(value, rb_intern("to_s"), 0);
int length = RSTRING_LEN(string_data);
if (subtype == 2) {
const int other_length = length + 4;
buffer_write_bytes(buffer, (const char*)&other_length, 4);
buffer_write_bytes(buffer, &subtype, 1);
}
buffer_write_bytes(buffer, (const char*)&length, 4);
if (subtype != 2) {
buffer_write_bytes(buffer, &subtype, 1);
}
buffer_write_bytes(buffer, RSTRING_PTR(string_data), length);
break;
}
if (strcmp(cls, "XGen::Mongo::Driver::ObjectID") == 0) {
write_name_and_type(buffer, key, 0x07);
VALUE as_array = rb_funcall(value, rb_intern("to_a"), 0);
int i;
for (i = 0; i < 12; i++) {
char byte = (char)FIX2INT(RARRAY_PTR(as_array)[i]);
buffer_write_bytes(buffer, &byte, 1);
}
break;
}
if (strcmp(cls, "XGen::Mongo::Driver::DBRef") == 0) {
write_name_and_type(buffer, key, 0x03);
int start_position = buffer->position;
// save space for length
int length_location = buffer_save_bytes(buffer, 4);
VALUE ns = rb_funcall(value, rb_intern("namespace"), 0);
write_element(rb_str_new2("$ref"), ns, pack_extra(buffer, Qfalse));
VALUE oid = rb_funcall(value, rb_intern("object_id"), 0);
write_element(rb_str_new2("$id"), oid, pack_extra(buffer, Qfalse));
// write null byte and fill in length
buffer_write_bytes(buffer, &zero, 1);
int obj_length = buffer->position - start_position;
memcpy(buffer->buffer + length_location, &obj_length, 4);
break;
}
if (strcmp(cls, "XGen::Mongo::Driver::Undefined") == 0) {
write_name_and_type(buffer, key, 0x06);
break;
}
}
case T_DATA:
{
// TODO again, is this really the only way to do this?
const char* cls = rb_class2name(RBASIC(value)->klass);
if (strcmp(cls, "Time") == 0) {
write_name_and_type(buffer, key, 0x09);
double t = NUM2DBL(rb_funcall(value, rb_intern("to_f"), 0));
long long time_since_epoch = (long long)round(t * 1000);
buffer_write_bytes(buffer, (const char*)&time_since_epoch, 8);
break;
}
}
case T_REGEXP:
{
write_name_and_type(buffer, key, 0x0B);
int length = RREGEXP_SRC_LEN(value);
char* pattern = (char*)RREGEXP_SRC_PTR(value);
buffer_write_bytes(buffer, pattern, length);
buffer_write_bytes(buffer, &zero, 1);
long flags = RREGEXP(value)->ptr->options;
if (flags & IGNORECASE) {
char ignorecase = 'i';
buffer_write_bytes(buffer, &ignorecase, 1);
}
if (flags & MULTILINE) {
char multiline = 'm';
buffer_write_bytes(buffer, &multiline, 1);
}
if (flags & EXTENDED) {
char extended = 'x';
buffer_write_bytes(buffer, &extended, 1);
}
VALUE has_extra = rb_funcall(value, rb_intern("respond_to?"), 1, rb_str_new2("extra_options_str"));
if (TYPE(has_extra) == T_TRUE) {
VALUE extra = rb_funcall(value, rb_intern("extra_options_str"), 0);
int old_position = buffer->position;
buffer_write_bytes(buffer, RSTRING_PTR(extra), RSTRING_LEN(extra));
qsort(buffer->buffer + old_position, RSTRING_LEN(extra), sizeof(char), cmp_char);
}
buffer_write_bytes(buffer, &zero, 1);
break;
}
default:
{
rb_raise(rb_eTypeError, "no c encoder for this type yet (%d)", TYPE(value));
break;
}
}
return ST_CONTINUE;
}
void xml_writer_impl::write_document(const variant& document)
{
try
{
if ((m_mode & xml_mode::NoHeader)==0)
{
// output the XML header
write_header();
}
if ((m_mode & xml_mode::Preserve)!=0)
{
bool first(true);
if (document.is<variant::Mapping>())
{
std::string element_name;
variant::const_iterator it, end(document.end());
for (it=document.begin(); it!=end; ++it)
{
if (it.key()==xml_text)
{
boost::throw_exception(variant_error("Encountered text in document node"));
}
else if (it.key()==xml_attributes)
{
boost::throw_exception(variant_error("Encountered attributes in document node"));
}
else if (it.key()==xml_instruction)
{
if (!first)
{
m_os << indent();
}
write_instruction(it.value());
}
else if (it.key()==xml_comment)
{
if (!first)
{
m_os << indent();
}
write_comment(it.value());
}
else
{
if (element_name.empty())
{
element_name = it.key();
}
else
{
boost::throw_exception(variant_error((boost::format("Illegal element %s encountered in document, expecting single element %s at root") % it.key() % element_name).str()));
}
push(it.key());
if (!first)
{
m_os << indent();
}
write_element(it.value());
pop();
}
first = false;
}
}
else
{
boost::throw_exception(variant_error("Invalid document structure, root node must be a Dictionary or Bag"));
}
}
else
{
push();
write_variant(document);
pop();
}
}
catch (const std::exception &e)
{
boost::throw_exception(variant_error(e.what()));
}
catch (...)
{
boost::throw_exception(variant_error("Unhandled Exception"));
}
}
void xml_writer_impl::write_element(const variant& element)
{
try
{
if (element.is<variant::Collection>() && element.empty() && element.type() != variant::DataTable)
{
write_empty_element();
return;
}
switch(element.type())
{
case variant::None:
{
write_empty_element();
break;
}
case variant::Any:
case variant::String:
{
if (element.as<std::string>().empty())
{
write_empty_element();
break;
}
}
case variant::Float:
case variant::Double:
case variant::Int32:
case variant::UInt32:
case variant::Int64:
case variant::UInt64:
case variant::Boolean:
case variant::Date:
case variant::Time:
case variant::DateTime:
{
m_os << start_tag();
write_text(element);
m_os << end_tag();
break;
}
case variant::Dictionary:
case variant::Bag:
{
if ((m_mode & xml_mode::Preserve)!=0)
{
if (element.has_key(xml_attributes))
{
m_stack.top().m_attributes = element[xml_attributes];
if (element.size()==1)
{
write_empty_element();
break;
}
}
m_os << start_tag();
bool prev_is_text = false;
variant::const_iterator it, end(element.end());
for (it=element.begin(); it!=end; ++it)
{
if (it.key()==xml_attributes)
{
continue;
}
else if (it.key()==xml_text)
{
write_text(it.value());
prev_is_text = true;
}
else if (it.key()==xml_instruction)
{
push(it.key());
if (!prev_is_text)
{
m_os << indent();
}
write_instruction(it.value());
prev_is_text = false;
pop();
}
else if (it.key()==xml_comment)
{
push(it.key());
if (!prev_is_text)
{
m_os << indent();
}
write_comment(it.value());
prev_is_text = false;
pop();
}
else
{
push(it.key());
if (!prev_is_text)
{
m_os << indent();
}
write_element(it.value());
prev_is_text = false;
pop();
}
}
if (!prev_is_text)
{
m_os << indent();
}
m_os << end_tag();
}
else
{
m_os << start_tag();
variant::const_iterator it, end(element.end());
for (it=element.begin(); it!=end; ++it)
{
push(it.key());
m_os << indent();
write_variant(it.value());
pop();
}
m_os << indent() << end_tag();
}
break;
}
case variant::List:
{
m_os << start_tag();
BOOST_FOREACH(const variant& item, element)
{
push();
m_os << indent();
write_variant(item);
pop();
}
m_os << indent();
m_os << end_tag();
break;
}
case variant::Tuple:
{
m_stack.top().m_attributes.insert("size", variant(element.size()));
m_os << start_tag();
BOOST_FOREACH(const variant& item, element)
{
push();
m_os << indent();
write_variant(item);
pop();
}
m_os << indent();
m_os << end_tag();
break;
}
case variant::TimeSeries:
{
m_os << start_tag();
variant::const_iterator it, end = element.end();
for (it=element.begin(); it!=end; ++it)
{
push().insert("time", variant(it.time()));
m_os << indent();
write_variant(it.value());
pop();
}
m_os << indent();
m_os << end_tag();
break;
}
case variant::DataTable:
{
const data_table& dt = element.m_value.get<variant::DataTable>();
m_stack.top().m_attributes
.insert("rows", variant(dt.size()))
.insert("columns", variant(dt.columns().size()));
m_os << start_tag();
if (!dt.columns().empty())
{
push("Columns");
m_os << indent() << start_tag();
for (data_table::column_container_type::const_iterator column_iter = dt.columns().begin()
; column_iter != dt.columns().end()
; ++column_iter)
{
push("Column")
.insert("name", variant(column_iter->name()))
.insert("type", variant(variant::enum_to_string(column_iter->type())));
m_os << indent();
write_empty_element();
pop();
}
m_os << indent() << end_tag();
pop();
}
for (data_table::column_container_type::const_iterator column_iter = dt.columns().begin()
; column_iter != dt.columns().end()
; ++column_iter)
{
push("Column").insert("name", variant(column_iter->name()));
m_os << indent() << start_tag();
if (column_iter->type() & variant_base::Primitive)
{
boost::scoped_ptr<data_table_column_writer> column_writer(
make_data_table_column_stream_writer(*column_iter, m_os)
);
while (column_writer->has_next())
{
push("V");
m_os << indent() << start_tag();
column_writer->write();
m_os << end_tag();
pop();
column_writer->advance();
}
}
else
{
variant::const_iterator iter(column_iter->begin());
variant::const_iterator end(column_iter->end());
while (iter != end)
{
push("V");
m_os << indent();
write_variant(*(iter++));
pop();
}
}
m_os << indent() << end_tag();
pop();
}
m_os << indent();
m_os << end_tag();
break;
}
case variant::Buffer:
{
m_os << start_tag();
const void *data = element.as<void*>();
size_t size = element.size();
if (data!=nullptr && size>0)
{
unsigned int n = 0;
boost::scoped_ptr<char> b64(detail::b64_encode((const char*)data, (unsigned int)size, &n));
if (!b64.get())
{
boost::throw_exception(variant_error("Unable to base64 encode data"));
}
m_os << b64.get();
}
m_os << end_tag();
break;
}
case variant::Object:
{
const object& obj(element.as<object>());
// write class name
m_stack.top().m_attributes
.insert("class", variant(obj.name()))
.insert("version", variant(obj.version()));
m_os << start_tag();
// write parameter dictionary
variant params;
obj.deflate(params);
push("params");
m_os << indent();
write_variant(params);
pop();
m_os << indent();
m_os << end_tag();
break;
}
case variant::Exception:
{
m_os << start_tag();
exception_data e(element.as<exception_data>());
push("type");
m_os << indent();
write_element(variant(e.type()));
pop();
push("message");
m_os << indent();
write_element(variant(e.message()));
pop();
if (!e.source().empty())
{
push("source");
m_os << indent();
write_element(variant(e.source()));
pop();
}
if (!e.stack().empty())
{
push("stack");
m_os << indent();
write_element(variant(e.stack()));
pop();
}
m_os << indent();
m_os << end_tag();
break;
}
case variant::Array:
{
const typed_array& a(element.as<typed_array>());
m_stack.top().m_attributes
.insert("size", variant(a.size()))
.insert("type", variant(variant::enum_to_string(a.type())));
m_os << start_tag();
for (size_t i=0; i<a.size(); ++i)
{
push();
m_os << indent();
write_element(variant(a[i]));
pop();
}
m_os << indent();
m_os << end_tag();
break;
}
default:
boost::throw_exception(variant_error("Case exhaustion: " + variant::enum_to_string(element.type())));
}
/******************************************************************************
* ModelGen_Charset()
* Generates a mesh based character set and writes each character to a PLY
* file.
******************************************************************************/
void ModelGen_Charset()
{
tvuint i, j;
/* # of lines in each character */
int charSizes[] = {
3, /* A */
5, /* B */
3, /* D */
3, /* C */
4, /* E */
3, /* F */
5, /* G */
3, /* H */
3, /* I */
4, /* J */
3, /* K */
2, /* L */
4, /* M */
3, /* N */
4, /* O */
3, /* P */
5, /* Q */
4, /* R */
3, /* S */
2, /* T */
3, /* U */
2, /* V */
4, /* W */
2, /* X */
3, /* Y */
3, /* Z */
};
/* lines for each character */
float font[26][5*4] = {
{-1,-1,0,1, 0,1,1,-1, -.5f,0,.5f,0}, /* A */
{-1,1,-1,-1, -1,1,1,.5f, 1,.5f,-1,0, -1,0,1,-.5f, 1,-.5f,-1,-1}, /* B */
{-1,1,1,1, -1,1,-1,-1, -1,-1,1,-1}, /* C */
{-1,1,-1,-1, -1,1,1,0, 1,0,-1,-1}, /* D */
{-1,1,1,1, -1,1,-1,-1, -1,-1,1,-1, -1,0, 1,0}, /* E */
{-1,1,1,1, -1,1,-1,-1, -1,0, 1,0}, /* F */
{-1,1,1,1, -1,1,-1,-1, -1,-1,1,-1, 1,-1,1,0, 1,0,0,0}, /* G */
{-1,1,-1,-1, 1,1,1,-1, -1,0,1,0}, /* H */
{-1,1,1,1, 0,1,0,-1, -1,-1,1,-1}, /* I */
{-1,1,1,1, 0,1,0,-1, -1,-1,0,-1, -1,-1,-1,0}, /* J */
{-1,1,-1,-1, -1,0,1,1, -1,0,1,-1}, /* K */
{-1,1,-1,-1, -1,-1,1,-1}, /* L */
{-1,1,-1,-1, -1,1,0,0, 0,0,1,1, 1,1,1,-1}, /* M */
{-1,1,-1,-1, -1,1,1,-1, 1,1,1,-1}, /* N */
{-1,1,1,1, -1,1,-1,-1, -1,-1,1,-1, 1,1,1,-1}, /* O */
{-1,1,-1,-1, -1,1,1,.5f, 1,.5f,-1,0}, /* P */
{-1,1,1,1, -1,1,-1,-1, -1,-1,1,-1, 1,1,1,-1, 0,0,1,-1}, /* Q */
{-1,1,-1,-1, -1,1,1,.5f, 1,.5f,-1,0, -1,0,1,-1}, /* R */
{-1,1,1,1, -1,1,1-1, 1,-1,-1,-1}, /* S */
{-1,1,1,1, 0,1,0,-1}, /* T */
{-1,1,-1,-1, -1,-1,1,-1, 1,1,1,-1}, /* U */
{-1,1,0,-1, 0,-1,1,1}, /* V */
{-1,1,-1,-1, -1,-1,0,0, 0,0,1,-1, 1,-1,1,1}, /* W */
{-1,1,1,-1, -1,-1,1,1}, /* X */
{-1,1,0,0, 1,1,0,0, 0,0,0,-1}, /* Y */
{-1,1,1,1, 1,1,-1,-1, -1,-1, 1,-1} /* Z */
};
for(i = 0; i < 26; ++i) {
FILE* fp;
char dir[] = "StdAssets/Models/Charset/";
char file[31];
strcpy(file, " .ply");
file[0] = 'A'+i;
if(!(fp = open_file(dir, file))) {
return;
}
write_header(fp);
write_element(fp, "vertex", charSizes[i]*2);
write_element(fp, "face", charSizes[i]);
write_end_header(fp);
for(j = 0; j < charSizes[i]*2; ++j) {
fprintf(fp, "%f %f 0.0\n", font[i][j*2], font[i][j*2+1]);
}
for(j = 0; j < charSizes[i]; ++j) {
fprintf(fp, "2 %d %d\n", j*2, j*2+1);
}
fclose(fp);
}
}
