struct token *expand(struct token *original)
{
const struct token *list;
struct token *res;
/* Do nothing if there is nothing to expand. */
if (!needs_expansion(original))
return original;
list = original;
res = calloc(1, sizeof(*res));
res[0] = token_end;
while (list->token != END) {
const struct macro *def = definition(*list);
struct token **args;
/* Only expand function-like macros if they appear as function
* invocations, beginning with an open paranthesis. */
if (def && !is_macro_expanded(def) &&
(def->type != FUNCTION_LIKE || peek_next(list + 1) == '('))
{
args = read_args(list + 1, &list, def);
res = concat(res, expand_macro(def, args));
} else {
res = append(res, *list++);
}
}
free(original);
return res;
}
void CSensor::load()
{
if (m_handle)
{
char *error; error = nullptr;
TFGetStatistics getStatistics;
TFGetFrameAvialable getFrameAvialable;
MON_IMPORT(TFInitSensor , initSensor );
MON_IMPORT(TFGetName , getName );
MON_IMPORT(TFGetDefinition , getDefinition );
MON_IMPORT(TFGetDefinitionLength, getDefinitionLength);
MON_IMPORT(TFGetStatistics , getStatistics );
MON_IMPORT(TFGetFrameAvialable , getFrameAvialable );
initSensor(MON_ST_LOGGER, MON_ST_CONFIG->folder("sensors")->folder(name()));
setDefinition(getDefinition());
if(name().compare(getName()) != 0)
{
MON_LOG_ERR("Detected try to load sensor " << getName() << ", renamed to " << name());
}
for(auto &frame : definition()->frames())
{
m_frames[frame] = new CFrame(this, getStatistics, getFrameAvialable, frame);
}
}
}
object_t *eval(object_t *exp, object_t *env) {
object_t *ret = NULL;
if (evaluate_to_self(exp)) {
ret = exp;
}
else if (quoted(exp)) {
ret = car(cdr(exp));
}
else if (definition(exp)) {
object_t *symb = car(cdr(exp)),
*val = car(cdr(cdr(exp)));
if (val == NULL) {
create_new_variable(symb, get_nil(), env);
} else {
create_new_variable(symb,
eval(val, env),
env);
}
ret = symb;
}
else if (is_symbol(exp)) {
//printf("\nfound symbol: %s\n\n", exp->values.symbol.value);
ret = find_variable_value(exp, env);
}
else if (function(exp)) {
object_t *arguments = make_arguments(cdr(exp), env);
object_t *func = eval(car(exp), env);
if (func == NULL || func == get_nil() ||
func->type != t_primitive) {
fprintf(stderr, "func: %d\n", (unsigned int)func);
//fprintf(stderr, "type: %d\n", func->type);
die("Not a primitive!\n");
} else {
ret = (func->values.primitive.function)(arguments);
}
} else if (maybe_eval_to_function(exp)) {
object_t *c = car(exp);
object_t *func = eval(c, env);
if (!(func == NULL || nilp(func))) {
object_t *arguments = make_arguments(cdr(exp), env);
ret = (func->values.primitive.function)(arguments);
}
else {
die("Not a function!\n");
}
}
else {
die("Can't eval!\n");
}
return ret;
}
void UmlUseCaseDiagram::write_it(FileOut & out) {
const char * k = ((_uml_20) ? "ownedMember" : "packagedElement");
UmlUseCaseDiagramDefinition * def = definition();
const Q3PtrVector<UmlUseCaseAssociation> & assocs = def->associations();
int n = (int) assocs.size();
for (int rank = 0; rank != n; rank += 1)
assocs.at(rank)->write(out, this, rank, k);
unload();
}
bool all_children_closed(func_decl * f) const {
func_decl_set * def = definition(f);
if (!def)
return true;
func_decl_set::iterator it = def->begin();
func_decl_set::iterator end = def->end();
for (; it != end; ++it) {
if (get_color(*it) != CLOSED)
return false;
}
return true;
}
bool visit_children(func_decl * f) {
func_decl_set * def = definition(f);
if (!def)
return true;
bool visited = true;
func_decl_set::iterator it = def->begin();
func_decl_set::iterator end = def->end();
for (; it != end; ++it) {
visit(*it, visited);
}
return visited;
}
void PlusProtocol::translate(const igtl::ImageMessage::Pointer body)
{
CX_LOG_DEBUG() << "Image incoming to plusprotocol";
//DIMENSION
int x = 0;
int y = 1;
int z = 2;
//There seems to be a bug in the received images spacing from the plusserver
/*
float wrong_spacing[3];
body->GetSpacing(wrong_spacing);
float right_spacing[3];
right_spacing[x] = wrong_spacing[x];
right_spacing[y] = wrong_spacing[z];
right_spacing[z] = 1;
body->SetSpacing(right_spacing);
*/
int dimensions_p[3];
body->GetDimensions(dimensions_p);
float spacing[3];
body->GetSpacing(spacing);
int extent_p[3];
extent_p[x] = dimensions_p[x]-1;
extent_p[y] = dimensions_p[y]-1;
extent_p[z] = dimensions_p[z]-1;
//IMAGE
IGTLinkConversion converter;
ImagePtr theImage = converter.decode(body);
IGTLinkConversionBase baseConverter;
double timestamp_ms = baseConverter.decode_timestamp(body).toMSecsSinceEpoch();
timestamp_ms = this->getSyncedTimestampForTransformsAndImages(timestamp_ms);
theImage->setAcquisitionTime(QDateTime::fromMSecsSinceEpoch(timestamp_ms));
emit image(theImage);
//PROBEDEFINITION
ProbeDefinitionPtr definition(new ProbeDefinition);
definition->setUseDigitalVideo(true);
definition->setType(ProbeDefinition::tLINEAR);
definition->setSpacing(Vector3D(spacing[x], spacing[y], spacing[z]));
definition->setSize(QSize(dimensions_p[x], dimensions_p[y]));
definition->setOrigin_p(Vector3D(dimensions_p[x]/2, 0, 0));
double depthstart_mm = 0;
double depthend_mm = extent_p[y]*spacing[y];
double width_mm = extent_p[x]*spacing[x];
definition->setSector(depthstart_mm, depthend_mm, width_mm);
definition->setClipRect_p(DoubleBoundingBox3D(0, extent_p[x], 0, extent_p[y], 0, extent_p[z]));
emit probedefinition(mProbeToTrackerName, definition);
}
VectorFont::Glyph::Glyph( const std::string &hershey_glyph_definition, const double word_space_percentage, const double character_space_percentage )
{
m_word_space_percentage = word_space_percentage;
m_character_space_percentage = character_space_percentage;
std::string definition(hershey_glyph_definition);
if (definition.size() >= 2)
{
double left_edge = PointToMM(double(definition[0] - 'R'));
double right_edge = PointToMM(double( definition[1] - 'R'));
definition.erase(0,2);
m_bounding_box.Insert( left_edge, 0, 0 );
m_bounding_box.Insert( right_edge, 0, 0 );
if (definition.size() >= 2)
{
double x = double(definition[0] - 'R');
double y = double(definition[1] - 'R') * -1.0;
definition.erase(0,2);
while (definition.size() > 0)
{
if (definition.size() >= 2)
{
if ((definition[0] == ' ') && (definition[1] == 'R'))
{
// This is a 'pen up' item. Set the new coordinates but don't draw anything.
definition.erase(0,2);
x = double(definition[0] - 'R');
y = double(definition[1] - 'R') * -1.0;
}
else
{
double to_x = double(definition[0] - 'R');
double to_y = double(definition[1] - 'R') * -1.0;
GlyphLine *line = new GlyphLine( PointToMM(x), PointToMM(y), PointToMM(to_x), PointToMM(to_y) );
m_graphics_list.push_back( line );
m_bounding_box.Insert( line->BoundingBox() );
x = to_x;
y = to_y;
}
}
definition.erase(0,2);
}
}
} // End if - then
} // End constructor
OptionalModelObject ReverseTranslator::translateInternalMass( const WorkspaceObject & workspaceObject )
{
if( workspaceObject.iddObject().type() != IddObjectType::InternalMass ){
LOG(Error, "WorkspaceObject is not IddObjectType: InternalMass");
return boost::none;
}
// create the definition
openstudio::model::InternalMassDefinition definition(m_model);
OptionalString s = workspaceObject.name();
if(s){
definition.setName(*s + " Definition");
}
OptionalWorkspaceObject target = workspaceObject.getTarget(openstudio::InternalMassFields::ConstructionName);
if (target){
OptionalModelObject modelObject = translateAndMapWorkspaceObject(*target);
if (modelObject){
if (modelObject->optionalCast<ConstructionBase>()){
definition.setConstruction(modelObject->cast<ConstructionBase>());
}
}
}
OptionalDouble d = workspaceObject.getDouble(openstudio::InternalMassFields::SurfaceArea);
if(d){
definition.setSurfaceArea(*d);
}
// create the instance
InternalMass internalMass(definition);
s = workspaceObject.name();
if(s){
internalMass.setName(*s);
}
target = workspaceObject.getTarget(openstudio::InternalMassFields::ZoneName);
if (target){
OptionalModelObject modelObject = translateAndMapWorkspaceObject(*target);
if (modelObject){
if (modelObject->optionalCast<Space>()){
internalMass.setSpace(modelObject->cast<Space>());
}else if (modelObject->optionalCast<SpaceType>()){
internalMass.setSpaceType(modelObject->cast<SpaceType>());
}
}
}
return internalMass;
}
static int needs_expansion(const struct token *list)
{
const struct macro *def;
while (list->token != END) {
def = definition(*list);
if (def && !is_macro_expanded(def))
return 1;
list++;
}
return 0;
}
QStringList CheckConstraint::create() const {
QStringList ret;
QStringList checks;
QStringList cols = columnNames();
for (QStringList::const_iterator i = cols.begin(); i != cols.end(); i++) {
checks.append(QString("%1 %2").arg((*i), definition()));
}
ret.append(QString("ALTER TABLE %1 ADD CONSTRAINT %2 CHECK (%3);")
.arg(table()->qualifiedName())
.arg(name())
.arg(checks.join(" AND ")));
return ret;
}
precedence * mk_precedence(ast_manager & m, order_params const & params) {
if (params.m_order_precedence_gen.empty())
return mk_default_precedence(m, params);
symbol user("user");
symbol definition("definition");
symbol interpreted("interpreted");
symbol frequency("frequency");
symbol arity("arity");
symbol arbitrary("arbitrary");
symbol inv("-");
ptr_buffer<precedence> ps;
svector<symbol>::const_iterator it = params.m_order_precedence_gen.begin();
svector<symbol>::const_iterator end = params.m_order_precedence_gen.end();
bool prev_inv = false;
for (; it != end; ++it) {
symbol curr = *it;
if (curr == user) {
if (params.m_order_precedence.empty())
ps.push_back(mk_inv_precedence(prev_inv, alloc(user_precedence, m, params.m_order_precedence.size(), params.m_order_precedence.c_ptr())));
}
else if (curr == definition) {
warning_msg("definition precedence was not implement yet.");
}
else if (curr == interpreted) {
ps.push_back(mk_inv_precedence(prev_inv, alloc(interpreted_precedence)));
}
else if (curr == frequency) {
warning_msg("frequency precedence was not implement yet.");
}
else if (curr == arity) {
ps.push_back(mk_inv_precedence(prev_inv, alloc(arity_precedence)));
}
else if (curr == arbitrary) {
ps.push_back(mk_inv_precedence(prev_inv, alloc(arbitrary_precedence)));
// it is pointless to continue, arbitrary_precedence is a total order
return mk_lex_precedence(ps);
}
else if (curr == inv) {
prev_inv = true;
}
else {
warning_msg("invalid precedence generator: ignoring atom '%s'.", curr.bare_str());
}
}
return mk_lex_precedence(ps);
}
void generate_literal_chain_comparison(ast::tree& ast, ast::node* root, ast::node* atom, formatter& output)
{
ast::node* arg_0 = atom->first_child;
plnnrc_assert(arg_0 && ast::is_term_variable(arg_0));
ast::node* arg_1 = arg_0->next_sibling;
plnnrc_assert(arg_1 && ast::is_term_variable(arg_1) && !arg_1->next_sibling);
plnnrc_assert(definition(arg_0) && definition(arg_1));
const char* comparison_op = atom->s_expr->token;
int var_index_0 = ast::annotation<ast::term_ann>(arg_0)->var_index;
int var_index_1 = ast::annotation<ast::term_ann>(arg_1)->var_index;
if (ast::is_op_not(root))
{
output.writeln("if (!(state._%d %s state._%d))", var_index_0, comparison_op, var_index_1);
}
else
{
output.writeln("if (state._%d %s state._%d)", var_index_0, comparison_op, var_index_1);
}
{
scope s(output, root->next_sibling != 0);
if (root->next_sibling)
{
generate_literal_chain(ast, root->next_sibling, output);
}
else
{
output.writeln("PLNNR_COROUTINE_YIELD(state);");
}
}
}
void SpawnSystem::AddSpawn(Lua::LuaRef function, const glm::vec4& area, float minDelay, float maxDelay)
{
// Validate function.
if(!function.isFunction())
return;
// Create a spawn definition.
SpawnDefinition definition(function, area, minDelay, maxDelay);
// Roll the initial delay.
definition.currentDelay = std::uniform_real<float>(minDelay, maxDelay)(spawnRandom);
// Add a definition to the list.
m_spawnList.push_back(definition);
}
QString JsScriptingComponent::getStartedScriptFromAgrs() const
{
// TODO: Handle optional argument ... may be it should be one more extension
QStringList args = definition()->arguments();
auto it = std::find(args.cbegin(), args.cend(), "--start-script");
if (it == args.cend())
return QString();
++it;
if (it == args.cend()) {
Log.e("Wrong parameters. Usage [--start-script <scriptFilePath>]");
return QString();
}
return *it;
}
int
main(int argc, char **argv)
{
char buf[20];
signal(SIGFPE, fpecatch);
cmdname = argv[0];
while (argc > 1 && *argv[1] == '-') {
switch (argv[1][1]) {
case 'd':
dbg = atoi(&argv[1][2]);
if (dbg == 0)
dbg = 1;
fprintf(stderr, "%s\n", version);
break;
}
argc--;
argv++;
}
setdefaults();
objlist = (obj **) grow((char *)objlist, "objlist", nobjlist += 1000, sizeof(obj *));
text = (Text *) grow((char *)text, "text", ntextlist += 1000, sizeof(Text));
attr = (Attr *) grow((char *)attr, "attr", nattrlist += 100, sizeof(Attr));
sprintf(buf, "/%d/", getpid());
pushsrc(String, buf);
definition("pid");
curfile = infile;
pushsrc(File, curfile->fname);
if (argc <= 1) {
curfile->fin = stdin;
curfile->fname = tostring("-");
getdata();
} else
while (argc-- > 1) {
if ((curfile->fin = fopen(*++argv, "r")) == NULL) {
fprintf(stderr, "%s: can't open %s\n", cmdname, *argv);
exit(1);
}
curfile->fname = tostring(*argv);
getdata();
fclose(curfile->fin);
free(curfile->fname);
}
return anyerr;
}
ToolBarsManager::ToolBarDefinition ToolBarsManager::getToolBarDefinition(int identifier)
{
if (m_definitions.isEmpty())
{
getToolBarDefinitions();
}
if (identifier >= 0 && identifier < m_definitions.count())
{
ToolBarDefinition definition(m_definitions[identifier]);
definition.identifier = identifier;
return definition;
}
return ToolBarDefinition();
}
void ToolBarsManager::resetToolBar(int identifier)
{
QAction *action(qobject_cast<QAction*>(sender()));
if (action && identifier < 0)
{
identifier = action->data().toInt();
}
if (identifier >= 0 && identifier < OtherToolBar && QMessageBox::question(NULL, tr("Reset Toolbar"), tr("Do you really want to reset this toolbar to default configuration?"), (QMessageBox::Yes | QMessageBox::Cancel)) == QMessageBox::Yes)
{
const QHash<QString, ToolBarDefinition> defaultDefinitions(loadToolBars(SessionsManager::getReadableDataPath(QLatin1String("toolBars.json"), true), true));
ToolBarDefinition definition(defaultDefinitions.value(getToolBarName(identifier)));
definition.identifier = identifier;
setToolBar(definition);
}
}
void EdWidget::Save( const char* xmlFilename,
KrConsole* console,
const std::string& surfaceName,
int nTrans,
const KrRGBA* trans )
{
TiXmlDocument doc;
doc.SetValue( xmlFilename );
TiXmlElement definition( "Definition" );
definition.SetAttribute( "filename", surfaceName.c_str() );
for( int i=0; i<nTrans; i++ )
{
char key[256];
char value[256];
sprintf( key, "Transparent%d", i );
sprintf( value, "#%02x%02x%02x", trans[i].c.red, trans[i].c.green, trans[i].c.blue );
definition.SetAttribute( key, value );
}
GlSListIterator< EdWidget* > it( children );
for( it.Begin(); !it.Done(); it.Next() )
it.Current()->BuildXML( &definition );
doc.InsertEndChild( definition );
doc.SaveFile();
if ( doc.Error() )
{
console->Print( "Error saving XML. '%s'\n", doc.ErrorDesc() );
}
else
{
console->Print( "XML file '%s' saved.\n", xmlFilename );
}
}
boost::optional<ModelObject> SpaceLoadInstance_Impl::definitionAsModelObject() const {
OptionalModelObject result = definition();
return result;
}
void generate_literal_chain(ast::tree& ast, ast::node* root, formatter& output)
{
plnnrc_assert(ast::is_op_not(root) || ast::is_term_call(root) || is_atom(root) || is_comparison_op(root));
ast::node* atom = root;
if (ast::is_op_not(root))
{
atom = root->first_child;
}
if (ast::is_comparison_op(atom))
{
generate_literal_chain_comparison(ast, root, atom, output);
return;
}
if (ast::is_term_call(atom))
{
generate_literal_chain_call_term(ast, root, atom, output);
return;
}
const char* atom_id = atom->s_expr->token;
int atom_index = ast::annotation<ast::atom_ann>(atom)->index;
if (ast::is_op_not(root) && all_unbound(atom))
{
output.writeln("if (!tuple_list::head<%i_tuple>(world.atoms[atom_%i]))", atom_id, atom_id);
{
scope s(output);
if (root->next_sibling)
{
generate_literal_chain(ast, root->next_sibling, output);
}
else
{
output.writeln("PLNNR_COROUTINE_YIELD(state);");
}
}
}
else if (ast::is_op_not(root) && all_bound(atom))
{
output.writeln("for (state.%i_%d = tuple_list::head<%i_tuple>(world.atoms[atom_%i]); state.%i_%d != 0; state.%i_%d = state.%i_%d->next)",
atom_id, atom_index,
atom_id,
atom_id,
atom_id, atom_index,
atom_id, atom_index,
atom_id, atom_index);
{
scope s(output);
int atom_param_index = 0;
for (ast::node* term = atom->first_child; term != 0; term = term->next_sibling)
{
if (ast::is_term_variable(term))
{
int var_index = ast::annotation<ast::term_ann>(term)->var_index;
output.writeln("if (state.%i_%d->_%d == state._%d)", atom_id, atom_index, atom_param_index, var_index);
{
scope s(output, !is_last(term));
output.writeln("break;");
}
}
if (ast::is_term_call(term))
{
paste_precondition_function_call paste(term, "state._");
output.writeln("if (state.%i_%d->_%d == world.%p)", atom_id, atom_index, atom_param_index, &paste);
{
scope s(output, !is_last(term));
output.writeln("break;");
}
}
++atom_param_index;
}
}
output.writeln("if (state.%i_%d == 0)", atom_id, atom_index);
{
scope s(output, is_first(root));
if (root->next_sibling)
{
generate_literal_chain(ast, root->next_sibling, output);
}
else
{
output.writeln("PLNNR_COROUTINE_YIELD(state);");
}
}
}
else
{
output.writeln("for (state.%i_%d = tuple_list::head<%i_tuple>(world.atoms[atom_%i]); state.%i_%d != 0; state.%i_%d = state.%i_%d->next)",
atom_id, atom_index,
atom_id,
atom_id,
atom_id, atom_index,
atom_id, atom_index,
atom_id, atom_index);
{
scope s(output, is_first(root));
const char* comparison_op = "!=";
if (ast::is_op_not(root))
{
comparison_op = "==";
}
int atom_param_index = 0;
for (ast::node* term = atom->first_child; term != 0; term = term->next_sibling)
{
if (ast::is_term_variable(term) && definition(term))
{
int var_index = ast::annotation<ast::term_ann>(term)->var_index;
output.writeln("if (state.%i_%d->_%d %s state._%d)", atom_id, atom_index, atom_param_index, comparison_op, var_index);
{
scope s(output);
output.writeln("continue;");
}
}
if (ast::is_term_call(term))
{
paste_precondition_function_call paste(term, "state._");
output.writeln("if (state.%i_%d->_%d %s world.%p)", atom_id, atom_index, atom_param_index, comparison_op, &paste);
{
scope s(output);
output.writeln("continue;");
}
}
++atom_param_index;
}
atom_param_index = 0;
for (ast::node* term = atom->first_child; term != 0; term = term->next_sibling)
{
if (ast::is_term_variable(term) && !definition(term))
{
int var_index = ast::annotation<ast::term_ann>(term)->var_index;
output.writeln("state._%d = state.%i_%d->_%d;", var_index, atom_id, atom_index, atom_param_index);
output.newline();
}
++atom_param_index;
}
if (root->next_sibling)
{
generate_literal_chain(ast, root->next_sibling, output);
}
else
{
output.writeln("PLNNR_COROUTINE_YIELD(state);");
}
}
}
}
void operator()(const T& definition) const {
definition(function_template_);
}
OtherEquipmentDefinition OtherEquipment_Impl::otherEquipmentDefinition() const {
return definition().cast<OtherEquipmentDefinition>();
}
boost::optional<model::ModelObject> ReverseTranslator::translateExteriorLights(
const WorkspaceObject& workspaceObject)
{
if (workspaceObject.iddObject().type() != IddObjectType::Exterior_Lights) {
LOG(Error,"WorkspaceObject " << workspaceObject.briefDescription()
<< " is not of IddObjectType::Exterior_Lights.");
return boost::none;
}
model::ExteriorLightsDefinition definition(m_model);
OptionalString s;
OptionalDouble d;
if ((s = workspaceObject.name())) {
definition.setName(*s + " Definition");
}
if ((d = workspaceObject.getDouble(Exterior_LightsFields::DesignLevel))){
definition.setDesignLevel(*d);
}
model::OptionalExteriorLights exteriorLights;
model::OptionalSchedule schedule;
if (OptionalWorkspaceObject target = workspaceObject.getTarget(Exterior_LightsFields::ScheduleName))
{
if (model::OptionalModelObject modelObject = translateAndMapWorkspaceObject(*target)) {
schedule = modelObject->optionalCast<model::Schedule>();
}
}
if (schedule) {
try {
exteriorLights = model::ExteriorLights(definition,*schedule);
}
catch (std::exception& e) {
LOG(Warn,"Could not reverse translate " << workspaceObject.briefDescription()
<< " in full, because " << e.what() << ".");
}
}
if (!exteriorLights) {
exteriorLights = model::ExteriorLights(definition);
}
OS_ASSERT(exteriorLights);
if ((s = workspaceObject.name())) {
exteriorLights->setName(*s);
}
if ((s = workspaceObject.getString(Exterior_LightsFields::ControlOption,false,true))) {
exteriorLights->setControlOption(*s);
}
if ((s = workspaceObject.getString(Exterior_LightsFields::EndUseSubcategory,false,true))) {
exteriorLights->setEndUseSubcategory(*s);
}
return *exteriorLights;
}
SteamEquipmentDefinition SteamEquipment_Impl::steamEquipmentDefinition() const {
return definition().cast<SteamEquipmentDefinition>();
}
WaterUseEquipmentDefinition WaterUseEquipment_Impl::waterUseEquipmentDefinition() const
{
return definition().cast<WaterUseEquipmentDefinition>();
}
boost::optional<model::ModelObject> ReverseTranslator::translateExteriorFuelEquipment(
const WorkspaceObject& workspaceObject)
{
if (workspaceObject.iddObject().type() != IddObjectType::Exterior_FuelEquipment) {
LOG(Error,"WorkspaceObject " << workspaceObject.briefDescription()
<< " is not of IddObjectType::Exterior_FuelEquipment.");
return boost::none;
}
// Create an EquipmentDefinition to hold the Design Level
model::ExteriorFuelEquipmentDefinition definition(m_model);
OptionalString s;
OptionalDouble d;
if ((s = workspaceObject.name())) {
definition.setName(*s + " Definition");
}
if ((d = workspaceObject.getDouble(Exterior_FuelEquipmentFields::DesignLevel))){
definition.setDesignLevel(*d);
}
model::OptionalExteriorFuelEquipment exteriorFuelEquipment;
model::OptionalSchedule schedule;
if (OptionalWorkspaceObject target = workspaceObject.getTarget(Exterior_FuelEquipmentFields::ScheduleName))
{
if (model::OptionalModelObject modelObject = translateAndMapWorkspaceObject(*target)) {
schedule = modelObject->optionalCast<model::Schedule>();
}
}
if (schedule) {
try {
exteriorFuelEquipment = model::ExteriorFuelEquipment(definition,*schedule);
}
catch (std::exception& e) {
LOG(Warn,"Could not reverse translate " << workspaceObject.briefDescription()
<< " in full, because " << e.what() << ".");
}
}
if (!exteriorFuelEquipment) {
exteriorFuelEquipment = model::ExteriorFuelEquipment(definition);
}
OS_ASSERT(exteriorFuelEquipment);
if ((s = workspaceObject.name())) {
exteriorFuelEquipment->setName(*s);
}
if ((s = workspaceObject.getString(Exterior_FuelEquipmentFields::FuelUseType,false,true))) {
exteriorFuelEquipment->setFuelType(*s);
} else {
LOG(Warn, "The Fuel Use Type (required) isn't set for " << workspaceObject.briefDescription() <<
" while it is a required field with no default... Will default to Electricity")
exteriorFuelEquipment->setFuelType("Electricity");
}
if ((s = workspaceObject.getString(Exterior_FuelEquipmentFields::EndUseSubcategory,false,true))) {
exteriorFuelEquipment->setEndUseSubcategory(*s);
}
return *exteriorFuelEquipment;
}
OptionalModelObject ReverseTranslator::translateGasEquipment( const WorkspaceObject & workspaceObject )
{
if( workspaceObject.iddObject().type() != IddObjectType::GasEquipment ){
LOG(Error, "WorkspaceObject is not IddObjectType: GasEquipment");
return boost::none;
}
// create the definition
openstudio::model::GasEquipmentDefinition definition(m_model);
OptionalString s = workspaceObject.name();
if(s){
definition.setName(*s + " Definition");
}
s = workspaceObject.getString(openstudio::GasEquipmentFields::DesignLevelCalculationMethod, true);
OS_ASSERT(s);
OptionalDouble d;
if (istringEqual("EquipmentLevel", *s)){
d = workspaceObject.getDouble(openstudio::GasEquipmentFields::DesignLevel);
if (d){
definition.setDesignLevel(*d);
}else{
LOG(Error, "EquipmentLevel value not found for workspace object " << workspaceObject);
}
}else if(istringEqual("Watts/Area", *s)){
d = workspaceObject.getDouble(openstudio::GasEquipmentFields::PowerperZoneFloorArea);
if (d){
definition.setWattsperSpaceFloorArea(*d);
}else{
LOG(Error, "Watts/Area value not found for workspace object " << workspaceObject);
}
}else if(istringEqual("Watts/Person", *s)){
d = workspaceObject.getDouble(openstudio::GasEquipmentFields::PowerperPerson);
if (d){
definition.setWattsperPerson(*d);
}else{
LOG(Error, "Watts/Person value not found for workspace object " << workspaceObject);
}
}else{
LOG(Error, "Unknown DesignLevelCalculationMethod value for workspace object" << workspaceObject);
}
d = workspaceObject.getDouble(openstudio::GasEquipmentFields::FractionLatent);
if (d){
definition.setFractionLatent(*d);
}
d = workspaceObject.getDouble(openstudio::GasEquipmentFields::FractionRadiant);
if (d){
definition.setFractionRadiant(*d);
}
d = workspaceObject.getDouble(openstudio::GasEquipmentFields::FractionLost);
if (d){
definition.setFractionLost(*d);
}
d = workspaceObject.getDouble(openstudio::GasEquipmentFields::CarbonDioxideGenerationRate);
if (d){
definition.setCarbonDioxideGenerationRate(*d);
}
// create the instance
GasEquipment gasEquipment(definition);
s = workspaceObject.name();
if(s){
gasEquipment.setName(*s);
}
OptionalWorkspaceObject target = workspaceObject.getTarget(openstudio::GasEquipmentFields::ZoneorZoneListName);
if (target){
OptionalModelObject modelObject = translateAndMapWorkspaceObject(*target);
if (modelObject){
if (modelObject->optionalCast<Space>()){
gasEquipment.setSpace(modelObject->cast<Space>());
}else if (modelObject->optionalCast<SpaceType>()){
gasEquipment.setSpaceType(modelObject->cast<SpaceType>());
}
}
}
target = workspaceObject.getTarget(openstudio::GasEquipmentFields::ScheduleName);
if (target){
OptionalModelObject modelObject = translateAndMapWorkspaceObject(*target);
if (modelObject){
if (OptionalSchedule intermediate = modelObject->optionalCast<Schedule>()){
Schedule schedule(*intermediate);
gasEquipment.setSchedule(schedule);
}
}
}
s = workspaceObject.getString(openstudio::GasEquipmentFields::EndUseSubcategory);
if(s){
gasEquipment.setEndUseSubcategory(*s);
}
return gasEquipment;
}
EntityDefinition* EntityDefinitionManager::definition(const Model::AttributableNode* attributable) const {
ensure(attributable != nullptr, "attributable is null");
return definition(attributable->attribute(Model::AttributeNames::Classname));
}
void testSymbolVersionDefinitions()
{
ElfFileSet set;
set.addFile(QStringLiteral(LIBDIR "libversioned-symbols.so"));
QVERIFY(set.size() > 1);
auto f = set.file(0);
QVERIFY(f);
const auto symDefIndex = f->indexOfSection(".gnu.version_d");
const auto symbolVersionDefs = f->section<ElfGNUSymbolVersionDefinitionsSection>(symDefIndex);
QVERIFY(symbolVersionDefs);
QCOMPARE(symbolVersionDefs->entryCount(), 3u);
ElfGNUSymbolVersionDefinition *defV1 = nullptr, *defV2 = nullptr;
auto def = symbolVersionDefs->definition(1);
QVERIFY(def);
QCOMPARE(def->versionIndex(), (uint16_t)2);
QCOMPARE(symbolVersionDefs->definitionForVersionIndex(2), def);
if (def->auxiliarySize() == 1)
defV1 = def;
else
defV2 = def;
def = symbolVersionDefs->definition(2);
QVERIFY(def);
QCOMPARE(def->versionIndex(), (uint16_t)3);
QCOMPARE(symbolVersionDefs->definitionForVersionIndex(3), def);
if (def->auxiliarySize() == 1)
defV1 = def;
else
defV2 = def;
QVERIFY(defV1);
QVERIFY(defV2);
QCOMPARE(defV2->auxiliarySize(), (uint16_t)2);
auto defEntry = defV2->auxiliaryEntry(0);
QVERIFY(defEntry);
QCOMPARE(defEntry->name(), "VER2");
defEntry = defV2->auxiliaryEntry(1);
QVERIFY(defEntry);
QCOMPARE(defEntry->name(), "VER1");
QCOMPARE(defV1->auxiliarySize(), (uint16_t)1);
defEntry = defV1->auxiliaryEntry(0);
QVERIFY(defEntry);
QCOMPARE(defEntry->name(), "VER1");
const auto symVerIndex = f->indexOfSection(".gnu.version");
const auto symbolVersionTable = f->section<ElfGNUSymbolVersionTable>(symVerIndex);
QVERIFY(symbolVersionTable);
const auto dynTabIndex = f->indexOfSection(".dynsym");
QVERIFY(dynTabIndex > 0);
const auto symTab = f->section<ElfSymbolTableSection>(dynTabIndex);
QVERIFY(symTab);
QCOMPARE(symTab->header()->entryCount(), symbolVersionTable->header()->entryCount());
ElfSymbolTableEntry *f1 = nullptr, *f2 = nullptr, *f_ver1 = nullptr, *f_ver2 = nullptr;
for (uint i = 0; i < symTab->header()->entryCount(); ++i) {
auto sym = symTab->entry(i);
QVERIFY(sym);
if (strcmp(sym->name(), "function1") == 0)
f1 = sym;
else if (strcmp(sym->name(), "function2") == 0)
f2 = sym;
else if (strcmp(sym->name(), "function") == 0) {
qDebug() << symbolVersionTable->versionIndex(i);
if (symbolVersionTable->versionIndex(i) == defV2->versionIndex())
f_ver2 = sym;
else if (symbolVersionTable->versionIndex(i) == defV1->versionIndex())
f_ver1 = sym;
}
}
QVERIFY(f1);
QVERIFY(f2);
QVERIFY(f_ver1);
QVERIFY(f_ver2);
QCOMPARE(f1->value(), f_ver1->value());
QCOMPARE(f2->value(), f_ver2->value());
}
