MojErr MojDbKind::update(MojObject* newObj, const MojObject* oldObj, MojDbOp op, MojDbReq& req, bool checkSchema)
{
MojLogTrace(s_log);
MojErr err = checkPermission(op, req);
MojErrCheck(err);
err = req.curKind(this);
MojErrCheck(err);
#if defined(TESTDBKIND)
MojString s;
MojErr e2;
if (oldObj) {
e2 = oldObj->toJson(s);
MojLogInfo(s_log, _T("Kind_Update_OldObj: %s ;\n"), s.data());
}
if (newObj) {
e2 = newObj->toJson(s);
MojLogInfo(s_log, _T("Kind_Update_NewObj: %s ;\n"), s.data());
}
#endif
if (newObj) {
// add the _backup property if not set
if (m_backup && !newObj->contains(MojDb::SyncKey)) {
err = newObj->putBool(MojDb::SyncKey, true);
MojErrCheck(err);
}
// TEMPORARY!!! This should be done in pre-update to also check parent kinds
// warning message comes from preUpdate
if(checkSchema)
{
MojSchema::Result res;
err = m_schema.validate(*newObj, res);
MojErrCheck(err);
if (!res.valid())
{
MojErrThrowMsg(MojErrSchemaValidation, _T("schema validation failed for kind '%s': %s"),
m_id.data(), res.msg().data());
}
}
}
// update revSets and validate schema
err = preUpdate(newObj, oldObj, req);
MojErrCheck(err);
// update indexes
MojVector<MojDbKind*> kindVec;
MojInt32 idxcount = 0;
err = updateIndexes(newObj, oldObj, req, op, kindVec, idxcount);
MojLogInfo(s_log, _T("Kind_UpdateIndexes_End: %s; supers = %zu; indexcount = %zu; updated = %d \n"), this->id().data(),
m_supers.size(), m_indexes.size(), idxcount);
MojErrCheck(err);
return MojErrNone;
}
void System::update()
{
preUpdate();
auto it = entities.begin();
while(it != entities.end()){
updateEntity(**it);
it++;
}
postUpdate();
}
bool CommonBfJlModules::delayedExpand(NodePtr pNode)
{
assert(m_pBfsHandler != nullptr);
if (pNode->isRoot())
return false;
NodePtr pParent = pNode->getParent();
if (pParent->getSequence() < getJobLevelRoot()->getSequence() ||
m_pBfsHandler->shouldDelayedExpand(pNode) == false)
return false;
if (dispatch(pParent)) {
preUpdate(pParent);
return true;
}
return false;
}
bool QPSolver::solve(const rbd::MultiBody& mb, rbd::MultiBodyConfig& mbc)
{
preUpdate(mb, mbc);
bool success = solver_->solve();
if(!success)
{
solver_->errorMsg(mb,
tasks_, eqConstr_, inEqConstr_,
genInEqConstr_, boundConstr_,
std::cerr) << std::endl;
}
postUpdate(mb, mbc, success);
return success;
}
void View::doUpdate() {
if (g_gameSystem->isRunning()) {
return;
}
uint_t now = OsUtil::milliseconds();
m_frameTime = now - m_frameOldTime;
m_frameOldTime = now;
if (m_frameTime > 2000) {
// Printf("DEBUG");
}
preUpdate();
m_camera.setTarget(m_frame->getRenderTarget());
m_camera.setViewRect(m_frame->getRenderTarget()->getRect());
m_camera.setOrigin(m_eyeMatrix.origin);
m_camera.setViewAxis(m_eyeMatrix.axis);
m_camera.setFov(0, 60);
m_camera.setTime(now);
g_renderSystem->beginFrame(m_camera.getTarget());
#if 0
gRenderSystem->beginScene(m_camera);
#endif
if (!m_context->isLoading()) {
doRender();
}
#if 0
gRenderSystem->endScene();
#endif
drawAxis();
//t = Milliseconds();
g_renderSystem->endFrame();
m_frameNumCur++;
}
void Scene::updateBase(const float deltaTime)
{
if (isActive())
{
const float dt = deltaTime * m_deltaScale;
// Have to check every step since engine state
// might be changed at any time
if (Engine::getState() == Engine::State::Running)
preUpdate(dt);
if (Engine::getState() == Engine::State::Running)
Object::update(dt);
if (detail::CullerComponent::cullingEnabled() && Engine::getState() < Engine::State::Frozen)
m_cullingWorld.update(1.f / 60.f);
if (Engine::getState() == Engine::State::Running)
postUpdate(dt);
}
}
void NormalDelete(pBtree p,int key)
{
int pos;
pos=Find(p->Key,1,p->Sum,key);
if(IsLeaf(p))
{
if(Equal(p,pos,key))
{
Delete(p,pos);
}
return;
}
else
{
if(Equal(p,pos,key))
{
if(NodeAvailable(p->Child[pos-1]))
{
key=preUpdate(p,pos);
NormalDelete(p->Child[pos-1],key);
}
else if(NodeAvailable(p->Child[pos]))
{
key=postUpdate(p,pos);
NormalDelete(p->Child[pos],key);
}
else
{
Union(p,pos);
NormalDelete(p->Child[pos-1],key);
}
}
else
{
if(NodeAvailable(p->Child[pos-1]))
{
NormalDelete(p->Child[pos-1],key);
}
else
{
if(Exist(pos-2,p)&&NodeAvailable(p->Child[pos-2]))
{
rightFix(pos-2,p,pos-1);
NormalDelete(p->Child[pos-1],key);
}
else if(Exist(pos,p)&&NodeAvailable(p->Child[pos]))
{
leftFix(pos-1,p,pos);
NormalDelete(p->Child[pos-1],key);
}
else if(Exist(pos-2,p))
{
Union(p,pos-1);
NormalDelete(p->Child[pos-2],key);
}
else
{
Union(p,pos);
NormalDelete(p->Child[pos-1],key);
}
}
}
}
}
void VisualizationManager::onUpdate()
{
ros::WallDuration wall_diff = ros::WallTime::now() - last_update_wall_time_;
ros::Duration ros_diff = ros::Time::now() - last_update_ros_time_;
float wall_dt = wall_diff.toSec();
float ros_dt = ros_diff.toSec();
last_update_ros_time_ = ros::Time::now();
last_update_wall_time_ = ros::WallTime::now();
//ROS_INFO("time since last update: %fs", wall_dt);
if(ros_dt < 0.0)
{
resetTime();
}
ros::spinOnce();
Q_EMIT preUpdate();
frame_manager_->update();
root_display_group_->update( wall_dt, ros_dt );
view_manager_->update(wall_dt, ros_dt);
time_update_timer_ += wall_dt;
if( time_update_timer_ > 0.1f )
{
time_update_timer_ = 0.0f;
updateTime();
}
frame_update_timer_ += wall_dt;
if(frame_update_timer_ > 1.0f)
{
frame_update_timer_ = 0.0f;
updateFrames();
}
selection_manager_->update();
if( tool_manager_->getCurrentTool() )
{
tool_manager_->getCurrentTool()->update(wall_dt, ros_dt);
}
if ( view_manager_ &&
view_manager_->getCurrent() &&
view_manager_->getCurrent()->getCamera() )
{
directional_light_->setDirection(view_manager_->getCurrent()->getCamera()->getDerivedDirection());
}
frame_count_++;
//ROS_INFO("rviz/scenegraph update completed");
if ( render_requested_ || wall_dt > 0.01 )
{
render_requested_ = 0;
boost::mutex::scoped_lock lock(private_->render_mutex_);
if ( render_panel_list_.size() == 0 )
ogre_root_->renderOneFrame();
for ( int i = 0; i < render_panel_list_.size(); i++ )
{
if( render_panel_render_mask_[i] )
{
active_view_id_ = i;
render_panel_list_[i]->getRenderWindow()->update(true);
}
}
}
//ROS_INFO("finished rendering one frame");
}
void System::update(double dt)
{
preUpdate();
do_update(dt);
postUpdate();
}
void AdvancedImageWidget::forceUpdate()
{
emit preUpdate();
mUi->widget->update();
}
bool Charts::Chart::update(void)
{
preUpdate();
const glm::float_t width = this->size.width;
const glm::float_t height = this->size.height;
if (!TR_VERIFY(width > 0.0 && height > 0.0)) {
return false;
}
bool changed = false;
if (title) {
changed = changed || title->versionChanged();
}
Margin internalMargin;
for (auto axis : axisList) {
addAxisInternalMargin(internalMargin, axis);
}
renderArgs.margin = Margin::add(margin, internalMargin);
if (renderArgs.screenSize.x != width || renderArgs.screenSize.y != height) {
if(!doRelayout) {
const glm::vec2 marginProjection(renderArgs.margin.left + renderArgs.margin.right, renderArgs.margin.top + renderArgs.margin.bottom);
const glm::vec2 newSize(width - marginProjection.x, height - marginProjection.y);
if (resizeMode == ResizeMode::Rescale) {
if (renderArgs.screenSize.x > 0.0 && renderArgs.screenSize.y > 0.0) {
const glm::vec2 oldSize(renderArgs.screenSize.x - marginProjection.x, renderArgs.screenSize.y - marginProjection.y);
scale *= (newSize / oldSize);
} else {
offset = glm::vec2(0.f);
scale = newSize;
}
} else if (resizeMode == ResizeMode::Relayout) {
offset = glm::vec2(0.f);
scale = newSize;
}
}
renderArgs.screenSize = glm::vec2(width, height);
renderArgs.contentScaleFactor = contentScaleFactor;
renderArgs.projection = glm::ortho(0.f, renderArgs.screenSize.x, 0.f, renderArgs.screenSize.y, -1000.f, +1000.f);
}
if (glm::float_t(contentScaleFactor) != renderArgs.contentScaleFactor) {
renderArgs.contentScaleFactor = contentScaleFactor;
}
renderArgs.areaStart = glm::vec2(renderArgs.margin.left, renderArgs.margin.bottom);
renderArgs.areaSize = renderArgs.screenSize - glm::vec2(renderArgs.margin.left + renderArgs.margin.right, renderArgs.margin.top + renderArgs.margin.bottom);
if (doRelayout) {
offset = glm::dvec2(0.f);
scale = renderArgs.areaSize;
doRelayout = false;
} else {
applyAnimations();
applyConstraints();
}
// must check this AFTER applying animations and constraints
changed = changed || versionChanged();
renderArgs.offset = offset;
renderArgs.scale = scale;
renderArgs.clearColor = Utils::colorToVec4(backgroundColor);
for (auto axis : axisList) {
//if (axis->isEnabled()) {
changed |= axis->update(renderArgs);
//}
}
for (auto series : seriesList) {
//if (series->isEnabled()) {
changed |= series->update(renderArgs);
//}
}
for (auto decoration : decorationList) {
//if (decoration->isEnabled()) {
changed |= decoration->update(renderArgs);
//}
}
if (!preRendered) {
// we mark the chart as changed if it has not been pre-rendered, the purpose of the update changed value is
// conditional rendering and if we update twice before calling render we will still need to render again.
changed = true;
}
if(changed) {
preRendered = false;
}
preUpdated = false;
markVersion();
if (title) {
title->markVersion();
}
updated = true;
return changed;
}
void TransformableMarkerOperatorAction::onInitialize() {
connect( vis_manager_, SIGNAL( preUpdate() ), this, SLOT( update() ));
updateObjectArrayTopic();
}
