void inject_value(const type_descriptor& type_descriptor, const field& field, const void* source_ptr, reflectable& target) { VAR* target_ptr = ⌖ VAR* head_ptr = static_cast<char*>(static_cast<void*>(target_ptr)); VAR* field_ptr = static_cast<void*>(head_ptr + get_value_offset(field)); type_descriptor.inject_value(source_ptr, field_ptr); }
void inspect_value(const type_descriptor& type_descriptor, const reflectable& source, const field& field, void* target_ptr) { VAR* source_ptr = &source; VAR* head_ptr = static_cast<const char*>(static_cast<const void*>(source_ptr)); VAR* field_ptr = static_cast<const void*>(head_ptr + get_value_offset(field)); type_descriptor.inspect_value(field_ptr, target_ptr); }
complex_assert::complex_assert(MODULE *module) { if (oclass==NULL) { // register to receive notice for first top down. bottom up, and second top down synchronizations oclass = gl_register_class(module,"complex_assert",sizeof(complex_assert),PC_AUTOLOCK|PC_OBSERVER); if (oclass==NULL) throw "unable to register class complex_assert"; else oclass->trl = TRL_PROVEN; if (gl_publish_variable(oclass, // TO DO: publish your variables here PT_enumeration,"status",get_status_offset(), PT_KEYWORD,"ASSERT_TRUE",(enumeration)ASSERT_TRUE, PT_KEYWORD,"ASSERT_FALSE",(enumeration)ASSERT_FALSE, PT_KEYWORD,"ASSERT_NONE",(enumeration)ASSERT_NONE, PT_enumeration, "once", get_once_offset(), PT_KEYWORD,"ONCE_FALSE",(enumeration)ONCE_FALSE, PT_KEYWORD,"ONCE_TRUE",(enumeration)ONCE_TRUE, PT_KEYWORD,"ONCE_DONE",(enumeration)ONCE_DONE, PT_enumeration, "operation", get_operation_offset(), PT_KEYWORD,"FULL",(enumeration)FULL, PT_KEYWORD,"REAL",(enumeration)REAL, PT_KEYWORD,"IMAGINARY",(enumeration)IMAGINARY, PT_KEYWORD,"MAGNITUDE",(enumeration)MAGNITUDE, PT_KEYWORD,"ANGLE",(enumeration)ANGLE, // If using, please specify in radians PT_complex, "value", get_value_offset(), PT_double, "within", get_within_offset(), PT_char1024, "target", get_target_offset(), NULL)<1){ char msg[256]; sprintf(msg, "unable to publish properties in %s",__FILE__); throw msg; } defaults = this; status = ASSERT_TRUE; within = 0.0; value = 0.0; once = ONCE_FALSE; once_value = 0; operation = FULL; } }
double_assert::double_assert(MODULE *module) { if (oclass==NULL) { // register to receive notice for first top down. bottom up, and second top down synchronizations oclass = gl_register_class(module,"double_assert",sizeof(double_assert),PC_AUTOLOCK|PC_OBSERVER); if (oclass==NULL) throw "unable to register class double_assert"; else oclass->trl = TRL_PROVEN; if (gl_publish_variable(oclass, // TO DO: publish your variables here PT_enumeration,"status",get_status_offset(),PT_DESCRIPTION,"Conditions for the assert checks", PT_KEYWORD,"ASSERT_TRUE",(enumeration)ASSERT_TRUE, PT_KEYWORD,"ASSERT_FALSE",(enumeration)ASSERT_FALSE, PT_KEYWORD,"ASSERT_NONE",(enumeration)ASSERT_NONE, PT_enumeration, "once", get_once_offset(),PT_DESCRIPTION,"Conditions for a single assert check", PT_KEYWORD,"ONCE_FALSE",(enumeration)ONCE_FALSE, PT_KEYWORD,"ONCE_TRUE",(enumeration)ONCE_TRUE, PT_KEYWORD,"ONCE_DONE",(enumeration)ONCE_DONE, PT_enumeration, "within_mode", get_within_mode_offset(),PT_DESCRIPTION,"Method of applying tolerance", PT_KEYWORD,"WITHIN_VALUE",(enumeration)IN_ABS, PT_KEYWORD,"WITHIN_RATIO",(enumeration)IN_RATIO, PT_double, "value", get_value_offset(),PT_DESCRIPTION,"Value to assert", PT_double, "within", get_within_offset(),PT_DESCRIPTION,"Tolerance for a successful assert", PT_char1024, "target", get_target_offset(),PT_DESCRIPTION,"Property to perform the assert upon", NULL)<1){ char msg[256]; sprintf(msg, "unable to publish properties in %s",__FILE__); throw msg; } defaults = this; status = ASSERT_TRUE; within = 0.0; within_mode = IN_ABS; value = 0.0; once = ONCE_FALSE; once_value = 0; } }
static void read_value_internal(const std::shared_ptr<type_t>& type, const symbols_t& symbols, reflectable& reflectable) { // read sub-type values if (VAL* base_type_index = get_base_type_index_opt(*type).get()) { VAL& base_type = get_type(*base_type_index); read_value_internal(base_type, symbols, reflectable); } // read current type values VAL& field_vector = get_field_vector(*type); VAR symbols_iter = std::begin(symbols); VAL symbols_end = std::end(symbols); for (VAL& field_kvp : field_vector) { if (symbols_iter != symbols_end) { VAL& field = field_kvp.second; VAL& field_symbol = *symbols_iter; VAL& field_type_index = get_type_index(*field); VAL& field_type_descriptor = get_type_descriptor(field_type_index); VAL& field_ptr = static_cast<char*>(static_cast<void*>(&reflectable)) + get_value_offset(*field); read_value(*field_type_descriptor, field_symbol, field_ptr); ++symbols_iter; } } }
void write_value_internal(const std::shared_ptr<type_t>& type, const reflectable& reflectable, symbols_t& symbols) { // write sub-type values if (VAL* base_type_index = get_base_type_index_opt(*type).get()) { VAL& base_type = get_type(*base_type_index); write_value_internal(base_type, reflectable, symbols); } // write current type values VAL& field_vector = get_field_vector(*type); for (VAL& field_kvp : field_vector) { symbol field_symbol_mvb{}; VAL& field = field_kvp.second; VAL& field_type_index = get_type_index(*field); VAL& field_type_descriptor = get_type_descriptor(field_type_index); VAL& field_ptr = static_cast<const char*>(static_cast<const void*>(&reflectable)) + get_value_offset(*field); write_value(*field_type_descriptor, field_ptr, field_symbol_mvb); symbols.emplace_back(std::move(field_symbol_mvb)); } }