void TargetView::repopulateList()
{
// Prevent ugly repaints
setUpdatesEnabled(false);
// Clear existing list
for(int i = 0; i < m_panes.count(); i++)
delete m_panes.at(i);
m_panes.clear();
// Repopulate list
Profile *profile = App->getProfile();
TargetList targets = profile->getTargets();
for(int i = 0; i < targets.count(); i++) {
Target *target = targets.at(i);
TargetPane *pane = new TargetPane(target, this);
target->setupTargetPane(pane);
m_panes.append(pane);
m_layout.addWidget(pane);
connect(pane, &TargetPane::rightClicked,
this, &TargetView::targetPaneRightClicked,
Qt::UniqueConnection);
}
// HACK: This must be delayed in order to actually do anything
QTimer::singleShot(10, this, SLOT(enableUpdatesTimeout()));
}
Entity * World::GetNextEntity( const str &targetname, Entity * ent )
{
TargetList * targetlist;
targetlist = GetTargetList( targetname );
return targetlist->GetNextEntity( ent );
}
void World::AddTargetEntity( const str &targetname, Entity * ent )
{
TargetList * targetlist;
targetlist = GetTargetList( targetname );
targetlist->AddEntity( ent );
}
void AncestorMoveMonitor::registerTarget(VideoOutput *target)
{
TRACE_CONTEXT(AncestorMoveMonitor::registerTarget, EVideoInternal);
TRACE_ENTRY("target 0x%08x", target);
// First un-register the target, in case this is being called as a result
// of re-parenting. This is not the most efficient way to update the
// target hash, but since this is not likely to be a frequent operation,
// simplicity is preferred over outright speed. In any case, re-parenting
// of the video widget leads to re-creation of native windows, which is
// likely to take far more processing than any implementation of this
// function.
unRegisterTarget(target);
QWidget *ancestor = target->parentWidget();
while(ancestor) {
const Hash::iterator it = m_hash.find(ancestor);
if(m_hash.end() == it) {
TargetList targetList;
targetList.append(target);
m_hash.insert(ancestor, targetList);
} else {
TargetList& targetList = it.value();
Q_ASSERT(targetList.indexOf(target) == -1);
targetList.append(target);
}
ancestor = ancestor->parentWidget();
}
dump();
TRACE_EXIT_0();
}
// FIXME: Should remove when the simple_optimizer tears down
// Initializes the update plan without adding any child nodes and
// retrieves column ids for the child scan plan.
void UpdatePlan::BuildInitialUpdatePlan(
const parser::UpdateStatement *parse_tree, std::vector<oid_t> &column_ids) {
LOG_TRACE("Creating an Update Plan");
auto t_ref = parse_tree->table;
auto table_name = std::string(t_ref->GetTableName());
auto database_name = t_ref->GetDatabaseName();
LOG_TRACE("Update database %s table %s", database_name, table_name.c_str());
target_table_ = catalog::Catalog::GetInstance()->GetTableWithName(
database_name, table_name);
PL_ASSERT(target_table_ != nullptr);
for (auto update_clause : *parse_tree->updates) {
updates_.push_back(update_clause->Copy());
}
TargetList tlist;
DirectMapList dmlist;
oid_t col_id;
auto schema = target_table_->GetSchema();
for (auto update : updates_) {
// get oid_t of the column and push it to the vector;
col_id = schema->GetColumnID(std::string(update->column));
column_ids.push_back(col_id);
auto *update_expr = update->value->Copy();
expression::ExpressionUtil::TransformExpression(target_table_->GetSchema(),
update_expr);
planner::DerivedAttribute attribute{update_expr};
attribute.attribute_info.name = update->column;
tlist.emplace_back(col_id, attribute);
}
auto &schema_columns = schema->GetColumns();
for (uint i = 0; i < schema_columns.size(); i++) {
bool is_in_target_list = false;
for (auto col_id : column_ids) {
if (schema_columns[i].column_name == schema_columns[col_id].column_name) {
is_in_target_list = true;
break;
}
}
if (is_in_target_list == false)
dmlist.emplace_back(i, std::pair<oid_t, oid_t>(0, i));
}
std::unique_ptr<const planner::ProjectInfo> project_info(
new planner::ProjectInfo(std::move(tlist), std::move(dmlist)));
project_info_ = std::move(project_info);
if (parse_tree->where != nullptr)
where_ = parse_tree->where->Copy();
else
where_ = nullptr;
expression::ExpressionUtil::TransformExpression(target_table_->GetSchema(),
where_);
}
void World::RemoveTargetEntity( const str &targetname, Entity * ent )
{
TargetList * targetlist;
if ( world_dying )
return;
targetlist = GetTargetList( targetname );
targetlist->RemoveEntity( ent );
}
/**
* @brief create a rollback segment by selecting columns from a tuple
* @param target_list The columns to be selected
* @param tuple The tuple to construct the RB
*
* TODO: Optimization can be done. We can save copying those columns that are
*already
* in the rollback segment created by the same transaction. What we need to do
*is to add
* a bitmap in the rollback segment indicating columns it contains. After that
*we
* can bypass these columns when making a new rollback segment.
*/
RBSegType RollbackSegmentPool::CreateSegmentFromTuple(
const catalog::Schema *schema, const TargetList &target_list,
const AbstractTuple *tuple) {
PL_ASSERT(schema);
PL_ASSERT(target_list.size() != 0);
size_t col_count = target_list.size();
size_t header_size = pairs_start_offset + col_count * sizeof(ColIdOffsetPair);
size_t data_size = 0;
RBSegType rb_seg = nullptr;
// First figure out the total size of the rollback segment data area
for (auto &target : target_list) {
auto col_id = target.first;
data_size += schema->GetLength(col_id);
}
// Allocate the RBSeg
rb_seg = (RBSegType)pool_.AllocateZeroes(header_size + data_size);
PL_ASSERT(rb_seg);
// Fill in the header
SetNextPtr(rb_seg, nullptr);
SetTimeStamp(rb_seg, MAX_CID);
SetColCount(rb_seg, col_count);
// Fill in the col_id & offset pair and set the data field
size_t offset = 0;
for (size_t idx = 0; idx < target_list.size(); ++idx) {
auto &target = target_list[idx];
auto col_id = target.first;
const bool is_inlined = schema->IsInlined(col_id);
const bool is_inbytes = false;
size_t inline_col_size = schema->GetLength(col_id);
size_t allocate_col_size =
(is_inlined) ? inline_col_size : schema->GetVariableLength(col_id);
SetColIdOffsetPair(rb_seg, idx, target.first, offset);
// Set the value
char *value_location = GetColDataLocation(rb_seg, idx);
Value value = tuple->GetValue(col_id);
PL_ASSERT(schema->GetType(col_id) == value.GetValueType());
value.SerializeToTupleStorageAllocateForObjects(
value_location, is_inlined, allocate_col_size, is_inbytes, &pool_);
// Update the offset
offset += inline_col_size;
}
return rb_seg;
}
void MagicMirror::Update(TargetList& targetList)
{
if (targetList.size() > 0)
{
Creature* target = targetList[rand() % targetList.size()];
if (target != this && target)
{
std::cout << m_name << " attacks " << target->GetName() << " with light beam...\n";
target->ApplyDamage(this, { 10 + rand() % m_bonusDamage, DamageType::RANGED, Element::FIRE });
}
}
}
void DownloadManager::on(TimerManagerListener::Second, uint64_t aTick) noexcept {
typedef vector<pair<string, UserPtr> > TargetList;
TargetList dropTargets;
{
Lock l(cs);
DownloadList tickList;
// Tick each ongoing download
for(DownloadList::iterator i = downloads.begin(); i != downloads.end(); ++i) {
if((*i)->getPos() > 0) {
tickList.push_back(*i);
(*i)->tick();
}
}
if(tickList.size() > 0)
fire(DownloadManagerListener::Tick(), tickList);
// Automatically remove or disconnect slow sources
if((uint32_t)(aTick / 1000) % SETTING(AUTODROP_INTERVAL) == 0) {
for(DownloadList::iterator i = downloads.begin(); i != downloads.end(); ++i) {
Download* d = *i;
uint64_t timeElapsed = aTick - d->getStart();
uint64_t timeInactive = aTick - d->getUserConnection().getLastActivity();
uint64_t bytesDownloaded = d->getPos();
bool timeElapsedOk = timeElapsed >= (uint32_t)SETTING(AUTODROP_ELAPSED) * 1000;
bool timeInactiveOk = timeInactive <= (uint32_t)SETTING(AUTODROP_INACTIVITY) * 1000;
bool speedTooLow = timeElapsedOk && timeInactiveOk && bytesDownloaded > 0 ?
bytesDownloaded / timeElapsed * 1000 < (uint32_t)SETTING(AUTODROP_SPEED) : false;
bool isUserList = d->getType() == Transfer::TYPE_FULL_LIST;
bool onlineSourcesOk = isUserList ?
true : QueueManager::getInstance()->countOnlineSources(d->getPath()) >= SETTING(AUTODROP_MINSOURCES);
bool filesizeOk = !isUserList && d->getSize() >= ((int64_t)SETTING(AUTODROP_FILESIZE)) * 1024;
bool dropIt = (isUserList && BOOLSETTING(AUTODROP_FILELISTS)) ||
(filesizeOk && BOOLSETTING(AUTODROP_ALL));
if(speedTooLow && onlineSourcesOk && dropIt) {
if(BOOLSETTING(AUTODROP_DISCONNECT) && isUserList) {
d->getUserConnection().disconnect();
} else {
dropTargets.push_back(make_pair(d->getPath(), d->getUser()));
}
}
}
}
}
for(TargetList::iterator i = dropTargets.begin(); i != dropTargets.end(); ++i) {
QueueManager::getInstance()->removeSource(i->first, i->second, QueueItem::Source::FLAG_SLOW_SOURCE);
}
}
// Test for targeting
bool ObjectiveEntity::isOnTargetList(const TargetList& list) const {
// Try to convert the weak_ptr reference to a shared_ptr
Entity* entity = Node_getEntity(_entityNode.lock());
assert(entity != NULL);
return list.isTargeted(entity);
}
void OperatorToPlanTransformer::Visit(const PhysicalProject *) {
auto project_prop = requirements_->GetPropertyOfType(PropertyType::PROJECT)
->As<PropertyProjection>();
(void)project_prop;
size_t project_list_size = project_prop->GetProjectionListSize();
// expressions to evaluate
TargetList tl = TargetList();
// columns which can be returned directly
DirectMapList dml = DirectMapList();
// schema of the projections output
std::vector<catalog::Column> columns;
for (size_t project_idx = 0; project_idx < project_list_size; project_idx++) {
auto expr = project_prop->GetProjection(project_idx);
std::string column_name;
// if the root of the expression is a column value we can
// just do a direct mapping
if (expr->GetExpressionType() == ExpressionType::VALUE_TUPLE) {
auto tup_expr = (expression::TupleValueExpression *)expr;
column_name = tup_expr->GetColumnName();
dml.push_back(
DirectMap(project_idx, std::make_pair(0, tup_expr->GetColumnId())));
}
// otherwise we need to evaluat the expression
else {
column_name = "expr" + std::to_string(project_idx);
tl.push_back(Target(project_idx, expr->Copy()));
}
columns.push_back(catalog::Column(
expr->GetValueType(), type::Type::GetTypeSize(expr->GetValueType()),
column_name));
}
// build the projection plan node and insert aboce the scan
std::unique_ptr<planner::ProjectInfo> proj_info(
new planner::ProjectInfo(std::move(tl), std::move(dml)));
std::shared_ptr<catalog::Schema> schema_ptr(new catalog::Schema(columns));
std::unique_ptr<planner::AbstractPlan> project_plan(
new planner::ProjectionPlan(std::move(proj_info), schema_ptr));
output_plan_ = std::move(project_plan);
}
Variable FunctionTargets::call( Variable &/*input*/, VarList lParams )
{
Variable vRet( Variable::typeList );
TargetList lTrg;
if( lParams.getSize() == 0 )
{
lTrg = pContext->getExplicitTargets();
}
else
{
lTrg = pContext->getTag( lParams.first().toString() );
}
for( TargetList::const_iterator i = lTrg.begin(); i; i++ )
{
for( StrList::const_iterator j = (*i)->getOutputList().begin(); j; j++ )
{
vRet.append( *j );
}
}
return vRet;
}
