void ItemDocument::select(const QCanvasItemList &list) {
const QCanvasItemList::const_iterator end = list.end();
for (QCanvasItemList::const_iterator it = list.begin(); it != end; ++it)
selectList()->addQCanvasItem(*it);
selectList()->setSelected(true);
}
void ItemDocument::fillContextMenu(const QPoint & pos) {
Q_UNUSED(pos);
ItemView *activeItemView = dynamic_cast<ItemView*>(activeView());
if (!KTechlab::self() || !activeItemView)
return;
KAction * align_actions[] = {
activeItemView->action("align_horizontally"),
activeItemView->action("align_vertically"),
activeItemView->action("distribute_horizontally"),
activeItemView->action("distribute_vertically")
};
bool enableAlignment = selectList()->itemCount() > 1;
if (!enableAlignment) return;
for (unsigned i = 0; i < 4; ++i) {
align_actions[i]->setEnabled(true);
m_pAlignmentAction->remove(align_actions[i]);
m_pAlignmentAction->insert(align_actions[i]);
}
QPtrList<KAction> alignment_actions;
alignment_actions.append(m_pAlignmentAction);
KTechlab::self()->plugActionList("alignment_actionlist", alignment_actions);
}
GlobalDataTypeRegistry::RegistResult GlobalDataTypeRegistry::remove(Entry* dtd)
{
if (!dtd)
{
UAVCAN_ASSERT(0);
return RegistResultInvalidParams;
}
if (isFrozen())
{
return RegistResultFrozen;
}
List* list = selectList(dtd->descriptor.getKind());
if (!list)
{
return RegistResultInvalidParams;
}
list->remove(dtd); // If this call came from regist<>(), that would be enough
Entry* p = list->get(); // But anyway
while (p)
{
Entry* const next = p->getNextListNode();
if (p->descriptor.match(dtd->descriptor.getKind(), dtd->descriptor.getFullName()))
{
list->remove(p);
}
p = next;
}
return RegistResultOk;
}
void ListEditor::removeListClicked()
{
QString lname=listName->currentText();
if(lists->contains(lname)) lists->erase(lname);
listName->removeItem(listName->currentItem());
selectList(0);
}
DataTypeSignature GlobalDataTypeRegistry::computeAggregateSignature(DataTypeKind kind,
DataTypeIDMask& inout_id_mask) const
{
UAVCAN_ASSERT(isFrozen()); // Computing the signature if the registry is not frozen is pointless
const List* list = selectList(kind);
if (!list)
{
UAVCAN_ASSERT(0);
return DataTypeSignature();
}
int prev_dtid = -1;
DataTypeSignature signature;
bool signature_initialized = false;
Entry* p = list->get();
while (p)
{
const DataTypeDescriptor& desc = p->descriptor;
const int dtid = desc.getID().get();
if (inout_id_mask[unsigned(dtid)])
{
if (signature_initialized)
{
signature.extend(desc.getSignature());
}
else
{
signature = DataTypeSignature(desc.getSignature());
}
signature_initialized = true;
}
UAVCAN_ASSERT(prev_dtid < dtid); // Making sure that list is ordered properly
prev_dtid++;
while (prev_dtid < dtid)
{
inout_id_mask[unsigned(prev_dtid++)] = false; // Erasing bits for missing types
}
UAVCAN_ASSERT(prev_dtid == dtid);
p = p->getNextListNode();
}
prev_dtid++;
while (prev_dtid <= DataTypeID::Max)
{
inout_id_mask[unsigned(prev_dtid++)] = false;
}
return signature;
}
void StoreSqdb::insert (SourceDesc& desc)
{
sqdb::transaction tr (m_session);
bool const found (select (desc));
if (found)
{
selectList (desc);
}
else
{
Error error;
String const sourceID (desc.source->uniqueID().toStdString());
String const createParam (desc.source->createParam().toStdString());
String const lastFetchTime (Utilities::timeToString (desc.lastFetchTime));
String const expirationTime (Utilities::timeToString (desc.expirationTime));
sqdb::statement st = (m_session.prepare <<
"INSERT INTO Validators_Source ( "
" sourceID, "
" createParam, "
" lastFetchTime, "
" expirationTime "
") VALUES ( "
" ?, ?, ?, ? "
"); "
,sqdb::use (sourceID)
,sqdb::use (createParam)
,sqdb::use (lastFetchTime)
,sqdb::use (expirationTime)
);
st.execute_and_fetch (error);
if (! error)
{
error = tr.commit ();
}
if (error)
{
tr.rollback ();
report (error, __FILE__, __LINE__);
}
}
}
void GlobalDataTypeRegistry::getDataTypeIDMask(DataTypeKind kind, DataTypeIDMask& mask) const
{
(void)mask.reset();
const List* list = selectList(kind);
if (!list)
{
UAVCAN_ASSERT(0);
return;
}
Entry* p = list->get();
while (p)
{
UAVCAN_ASSERT(p->descriptor.getKind() == kind);
mask[p->descriptor.getID().get()] = true;
p = p->getNextListNode();
}
}
void ListEditor::addListClicked()
{
bool ok;
int t=listType->currentItem();
QString name=QInputDialog::getText(tr("New "+listTypeName[t]), tr("Enter list name:"), QLineEdit::Normal,QString::null, &ok, this);
if(name!="" && ok)
{
if( listName->findText(name) != -1 )
{
QMessageBox::critical(this,tr("Error"),tr("List \"")+name+tr("\" already exists. Enter another name"));
return;
}
listName->insertItem(name);
lists->insert(name,VtlList::create(listTypeName[t]));
selectList(listName->count()-1);
}
}
int ListEditor::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QWidget::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
switch (_id) {
case 0: shown((*reinterpret_cast< bool(*)>(_a[1]))); break;
case 1: addListClicked(); break;
case 2: removeListClicked(); break;
case 3: load(); break;
case 4: selectList((*reinterpret_cast< int(*)>(_a[1]))); break;
default: ;
}
_id -= 5;
}
return _id;
}
void ItemDocument::slotInitItemActions() {
ItemView * activeItemView = dynamic_cast<ItemView*>(activeView());
if (!KTechlab::self() || !activeItemView)
return;
KAction * align_actions[] = {
activeItemView->action("align_horizontally"),
activeItemView->action("align_vertically"),
activeItemView->action("distribute_horizontally"),
activeItemView->action("distribute_vertically")
};
bool enableAlignment = selectList()->itemCount() > 1;
for (unsigned i = 0; i < 4; ++i)
align_actions[i]->setEnabled(enableAlignment);
}
const DataTypeDescriptor* GlobalDataTypeRegistry::find(DataTypeKind kind, DataTypeID dtid) const
{
const List* list = selectList(kind);
if (!list)
{
UAVCAN_ASSERT(0);
return NULL;
}
Entry* p = list->get();
while (p)
{
if (p->descriptor.match(kind, dtid))
{
return &p->descriptor;
}
p = p->getNextListNode();
}
return NULL;
}
//----------------------------------------------------------------------------
// The select list here is: (<fixed-count-cols>, <sum-col-refs>)
// The count cols become:
// Case( If <count-col> IS NULL THEN 0 ELSE <count-col>)
// Since the count cols were transformed from COUNT to SUM(@OP), They will
// now evaluate to NULL instead of 0 when no data is returned, for MAVs
// without a GROUP BY clause. This is what is fixed here.
//----------------------------------------------------------------------------
RelRoot *MavRelRootBuilder::buildRootForNoGroupBy(RelExpr *topNode)
{
ItemExprList selectList(heap_);
for (CollIndex i=0; i<countCols_.entries(); i++)
{
const MVColumnInfo *currentMavColumn = countCols_[i];
const NAString& colName = currentMavColumn->getColName();
// Build a col reference to the SYS_DELTA column.
ItemExpr *sysDeltaColExpr = new(heap_)
ColReference(new(heap_) ColRefName(colName, deltaCorrName_));
ItemExpr *condExpr = new(heap_)
Case(NULL, new(heap_)
IfThenElse(new(heap_) UnLogic(ITM_IS_NULL, sysDeltaColExpr),
new(heap_) SystemLiteral(0),
sysDeltaColExpr->copyTree(heap_)));
ItemExpr *renamedColExpr = new(heap_)
RenameCol(condExpr, new(heap_) ColRefName(colName, deltaCorrName_));
selectList.insert(renamedColExpr);
}
// Add the SUM cols.
addColsToSelectList(sumCols_, selectList, deltaCorrName_);
// Add the extra Min/Max columns.
selectList.insert(extraMinMaxColRefs_);
// The select list is ready. Create the root over topNode.
RelRoot *newRoot = new(heap_)
RelRoot(topNode, REL_ROOT, selectList.convertToItemExpr());
newRoot->setDontOpenNewScope();
selectList.clear();
return newRoot;
} // MavRelRootBuilder::buildRootForNoGroupBy()
//----------------------------------------------------------------------------
// First, do the COUNT columns.
// The select list of this root is (*, <count cols>).
// For COUNT, the SYS_CALC.col expr is:
// SYS_MAV.col + SYS_DELTA.col
// For MAVs without a GROUP BY clause, this is later fixed by
// buildRootForNoGroupBy().
//----------------------------------------------------------------------------
RelRoot *MavRelRootBuilder::buildRootForCount(RelExpr *topNode)
{
// Start the select list with *
ItemExprList selectList(heap_);
addStarToSelectList(selectList);
addColsToSelectList(groupByCols_, selectList, deltaCorrName_, &calcCorrName_);
// For each column in the COUNT list
for (CollIndex i=0; i<countCols_.entries(); i++)
{
MVColumnInfo *currentCol = countCols_[i];
const NAString& colName = currentCol->getColName();
// Find the column in the SYS_DELTA and SYS_MAV lists.
ItemExpr *sysDeltaColExpr = new(heap_)
ColReference(new(heap_) ColRefName(colName, deltaCorrName_));
ItemExpr *sysMavColExpr = new(heap_)
ColReference(new(heap_) ColRefName(colName, mavCorrName_));
ItemExpr *newCalcExpr = new(heap_)
BiArith(ITM_PLUS, sysDeltaColExpr, sysMavColExpr);
// Add the col expression as SYS_CALC.col
ColRefName *calcColName = new(heap_) ColRefName(colName, calcCorrName_);
ItemExpr *newCalcCol = new(heap_) RenameCol(newCalcExpr, calcColName);
selectList.insert(newCalcCol);
}
// The select list is ready. Create the root over topNode.
RelRoot *newRoot = new(heap_)
RelRoot(topNode, REL_ROOT, selectList.convertToItemExpr());
newRoot->setDontOpenNewScope();
selectList.clear();
return newRoot;
} // MavRelRootBuilder::buildRootForCount()
ListEditor::ListEditor(Lists *ll,QWidget *p) :
QWidget(p,"ListEditor",Qt::Dialog),
lists(ll),editor(new TableEditor * [3])
{
//setModal (false);
setupUi(this);
for(int i=0;i<nListType;i++) listType->insertItem(tr(listTypeName[i]));
vboxLayout->add(editor[0] = new StringListEditor(this));
editor[0]->hide();
vboxLayout->add(editor[1] = new PictureListEditor(this));
editor[1]->hide();
vboxLayout->add(editor[2] = new CommandListEditor(this));
//selectListType(listType->currentItem());
connect(listName,SIGNAL(activated(int)),this,SLOT(selectList(int)));
connect(addList,SIGNAL(clicked()),this,SLOT(addListClicked()));
connect(removeList,SIGNAL(clicked()),this,SLOT(removeListClicked()));
//ListEditorFormLayout->add(editor[2] = new CommandListEditor(this));
//lists=new Lists;
load();
selectList(0);
}
void ItemDocument::lowerZ() {
lowerZ(selectList()->items(true));
}
void ItemDocument::raiseZ() {
raiseZ(selectList()->items(true));
}
//----------------------------------------------------------------------------
// Next, do the SUM, MIN and MAX columns, using the already calculated
// and bound COUNT columns (SYS_CALC.dep1).
// For col=SUM(a), the new expr is:
// CASE
// 1) WHEN (SYS_CALC.dep1 = 0) THEN NULL
// 2) WHEN (SYS_MAV.col IS NULL) THEN SYS_DELTA.col
// 3) WHEN (SYS_DELTA.col IS NULL) THEN SYS_MAV.col
// ELSE SYS_MAV.col + SYS_DELTA.col
// END
// For col=MIN(a), the else clause is replaced by (no MIN ItemExpr):
// WHEN (SYS_MAV.col < SYS_DELTA.col) THEN SYS_MAV.col
// ELSE SYS_DELTA.col
// For col=MAX(a), the else clause is:
// WHEN (SYS_MAV.col > SYS_DELTA.col) THEN SYS_MAV.col
// ELSE SYS_DELTA.col
//----------------------------------------------------------------------------
RelRoot *MavRelRootBuilder::buildRootForSum(RelExpr *topNode)
{
// Start the select list with *
ItemExprList selectList(heap_);
addStarToSelectList(selectList);
// For each column in the COUNT list
for (CollIndex i=0; i<sumCols_.entries(); i++)
{
MVColumnInfo *currentCol = sumCols_[i];
const NAString& colName = currentCol->getColName();
// Find the column in the SYS_DELTA and SYS_MAV lists.
ItemExpr *sysDeltaColExpr = new(heap_)
ColReference(new(heap_) ColRefName(colName, deltaCorrName_));
ItemExpr *sysMavColExpr = new(heap_)
ColReference(new(heap_) ColRefName(colName, mavCorrName_));
// Find the dependent SYS_CALC COUNT column.
ItemExpr *calcDep1 =
buildDepColExpr(calcCorrName_, currentCol->getDepCol1());
// Build the condition bottom-up - do the ELSE clause first.
ItemExpr *elseClause = NULL;
if (currentCol->getOperatorType() == ITM_SUM)
{
// The ELSE clause for SUM is (SYS_MAV.col + SYS_DELTA.col).
elseClause = new(heap_)
BiArith(ITM_PLUS, sysDeltaColExpr, sysMavColExpr);
}
else
{
// The ELSE clause for MIN is:
// WHEN (SYS_MAV.col < SYS_DELTA.col) THEN SYS_MAV.col
// ELSE SYS_DELTA.col
// For MAX the < operator is replaced by >.
OperatorTypeEnum sign =
(currentCol->getOperatorType()==ITM_MIN ? ITM_LESS : ITM_GREATER);
elseClause = new(heap_)
IfThenElse(new(heap_) BiRelat(sign, sysMavColExpr, sysDeltaColExpr),
sysMavColExpr,
sysDeltaColExpr);
}
// The 3rd WHEN clause: WHEN (SYS_DELTA.col IS NULL) THEN SYS_MAV.col
ItemExpr *when3Clause = new(heap_)
IfThenElse(new(heap_) UnLogic(ITM_IS_NULL, sysDeltaColExpr),
sysMavColExpr,
elseClause);
// The 2nd WHEN clause: WHEN (SYS_MAV.col IS NULL) THEN SYS_DELTA.col
ItemExpr *when2Clause = new(heap_)
IfThenElse(new(heap_) UnLogic(ITM_IS_NULL, sysMavColExpr),
sysDeltaColExpr,
when3Clause);
// The 1st WHEN clause: WHEN (SYS_CALC.dep1 = 0) THEN NULL
ItemExpr *when1Clause = new(heap_)
IfThenElse(new(heap_) BiRelat(ITM_EQUAL,
calcDep1,
new(heap_) SystemLiteral(0)),
new(heap_) SystemLiteral(), // NULL constant
when2Clause);
// Build the CASE on top.
ItemExpr *newCalcExpr = new(heap_) Case(NULL, when1Clause);
// Add the col expression as SYS_CALC.col
ColRefName *calcColName = new(heap_) ColRefName(colName, calcCorrName_);
ItemExpr *newCalcCol = new(heap_) RenameCol(newCalcExpr, calcColName);
selectList.insert(newCalcCol);
}
// The select list is ready. Create the root over topNode.
RelRoot *newRoot = new(heap_)
RelRoot(topNode, REL_ROOT, selectList.convertToItemExpr());
newRoot->setDontOpenNewScope();
selectList.clear();
return newRoot;
} // MavRelRootBuilder::buildRootForSum()
void ItemDocument::distributeVertically() {
selectList()->slotDistributeVertically();
if (ICNDocument *icnd = dynamic_cast<ICNDocument*>(this))
icnd->requestRerouteInvalidatedConnectors();
}
// these look dangerous., see todo in header file.
void ItemDocument::alignHorizontally() {
selectList()->slotAlignHorizontally();
if (ICNDocument *icnd = dynamic_cast<ICNDocument*>(this))
icnd->requestRerouteInvalidatedConnectors();
}
void ItemDocument::unselect(QCanvasItem *qcanvasItem) {
selectList()->removeQCanvasItem(qcanvasItem);
qcanvasItem->setSelected(false);
}
//----------------------------------------------------------------------------
// Next, do the other columns (AVG, STDDEV, VARIANCE), using the already
// calculated and bound COUNT and SUM columns.
// There are 3 dependent columns here (found using MVInfo):
// dep1 is COUNT(a),
// dep2 is SUM(a),
// dep3 is SUM(a*a) (only for STDDEV and VARIANCE)
// depCount is COUNT(a)
// In the case of STDDEV with a weight parameter - STDDEV(a,b), then
// dep1 is SUM(b),
// dep2 is SUM(a*b),
// dep3 is SUM(a*a*b)
// depCount is COUNT(a*b) and is the dependent column of dep2.
//
// For col=AVG(a), the new expr is:
// CASE
// WHEN (SYS_CALC.depCount = 0) THEN NULL
// ELSE SYS_CALC.dep2 / SYS_CALC.dep1
// END
//
// For STDDEV and VARIANCE its:
// CASE
// WHEN (SYS_CALC.depCount = 0) THEN NULL
// ELSE ScalarVariance(SYS_CALC.dep3, SYS_CALC.dep2, SYS_CALC.dep1)
// END
// depCount is the COUNT dependent column of dep2. This works also in the
// case of STDDEV with a weight parameter
//----------------------------------------------------------------------------
RelRoot *MavRelRootBuilder::buildRootForOthers(RelExpr *topNode)
{
// Start the select list with *
ItemExprList selectList(heap_);
addStarToSelectList(selectList);
// For each column in the COUNT list
for (CollIndex i=0; i<otherCols_.entries(); i++)
{
MVColumnInfo *currentCol = otherCols_[i];
const NAString& colName = currentCol->getColName();
const NAType *desiredType = new(heap_) SQLDoublePrecision(TRUE);
// Find the dependent SYS_CALC COUNT and SUM columns.
ItemExpr *calcDep1 =
buildDepColExpr(calcCorrName_, currentCol->getDepCol1());
ItemExpr *calcDep2 =
buildDepColExpr(calcCorrName_, currentCol->getDepCol2());
ItemExpr *calcDep3 = NULL;
ItemExpr *calcDepCount = NULL;
if (currentCol->getOperatorType() == ITM_AVG)
{
calcDepCount = calcDep1;
}
else
{
// dep3 and depCount are needed only for STDDEV and VARIANCE.
calcDep3 = buildDepColExpr(calcCorrName_, currentCol->getDepCol3());
// depCount is the dereferenced dep1 column of dep2.
MVColumnInfo *dep2ColInfo =
mavCols_.getMvColInfoByIndex(currentCol->getDepCol2());
calcDepCount =
buildDepColExpr(calcCorrName_, dep2ColInfo->getDepCol1());
}
// Build the condition bottom-up - do the ELSE clause first.
ItemExpr *elseClause = NULL;
if (currentCol->getOperatorType() == ITM_AVG)
{
// For AVG, the ELSE clause is (SYS_CALC.dep2 / SYS_CALC.dep1).
elseClause = new(heap_)
BiArith(ITM_DIVIDE, calcDep2, calcDep1);
}
else
{
// For STDDEV and VARIANCE, the ELSE clause is
// ScalarVariance(SYS_CALC.dep3, SYS_CALC.dep2, SYS_CALC.dep1)
elseClause = new(heap_)
ScalarVariance(currentCol->getOperatorType(),
new(heap_) Cast(calcDep3, desiredType),
new(heap_) Cast(calcDep2, desiredType),
new(heap_) Cast(calcDep1, desiredType));
}
// The WHEN clause is the same for AVG, STDDEV and VARIANCE:
// WHEN (SYS_CALC.depCount = 0) THEN NULL
ItemExpr *whenClause = new(heap_)
IfThenElse(new(heap_) BiRelat(ITM_EQUAL,
calcDepCount,
new(heap_) SystemLiteral(0)),
new(heap_) SystemLiteral(), // NULL constant
elseClause);
// Put the CASE on top.
ItemExpr *newCalcExpr = new(heap_) Case(NULL, whenClause);
// Add the col expression as SYS_CALC.col
ColRefName *calcColName = new(heap_) ColRefName(colName, calcCorrName_);
ItemExpr *newCalcCol = new(heap_) RenameCol(newCalcExpr, calcColName);
selectList.insert(newCalcCol);
}
// The select list is ready. Create the root over topNode.
RelRoot *newRoot = new(heap_)
RelRoot(topNode, REL_ROOT, selectList.convertToItemExpr());
newRoot->setDontOpenNewScope();
selectList.clear();
return newRoot;
} // MavRelRootBuilder::buildRootForOthers()
void ItemDocument::select(QCanvasItem *item) {
if (!item) return;
item->setSelected(selectList()->contains(item) || selectList()->addQCanvasItem(item));
}
void ItemDocument::unselectAll() {
selectList()->removeAllItems();
}
//----------------------------------------------------------------------------
// Finally, Add the @GOP (Group Op) column- The select list is (*, <GOP expr>)
// This column is either 1, 2, 3 or 4 (see enum GroupOpNumbers).
// This is later used as the condition that routes the request down to the
// MAV Insert, MAV Delete or MAV Update nodes.
// @GOP is defined as (cnts represents the column name for COUNT(*)):
// CASE
// WHEN (SYS_MAV.cnts IS NULL) THEN GOP_INSERT
// WHEN (SYS_MAV.cnts = (0 - SYS_DELTA.cnts)) THEN GOP_DELETE
// WHEN <minMaxRecomputeCondition_> THEN GOP_MINMAX_RECOMPUTE
// ELSE GOP_UPDATE
// END
// The minMaxRecomputeCondition_ condition is built during the
// buildRootForDelta() phase, and checks if any of the current Min/Max values
// were deleted, so that recalculation is needed.
//
// A predicate is added to the RelRoot node to filter self-cancelling delta
// rows. The condition for a self-cancelling row is:
// (SYS_MAV.cnts IS NULL AND SYS_DELTA.cnts = 0)
//----------------------------------------------------------------------------
RelRoot *MavRelRootBuilder::buildRootForGop(RelExpr *topNode)
{
// Find the MAV column name for COUNT(*).
const NAString& countStarColName =
mavCols_[posOfCountStar_]->getColName();
// The condition for Insert to MAV
ItemExpr *insCondition = new(heap_) // (MAV.cnts IS NULL)
UnLogic(ITM_IS_NULL,
new(heap_) ColReference(new(heap_)
ColRefName(countStarColName, mavCorrName_)));
// The condition for Delete from MAV
// (MAV.cnts = (0 - SYS_DELTA.cnts))
ItemExpr *delCondition = new(heap_)
BiRelat(ITM_EQUAL,
new(heap_) ColReference(new(heap_)
ColRefName(countStarColName, mavCorrName_)),
new(heap_) BiArith(ITM_MINUS,
new(heap_) SystemLiteral(0),
new(heap_) ColReference(new(heap_)
ColRefName(countStarColName, deltaCorrName_))));
// These are the constants for all possible GOP column values.
ItemExpr *constInsert = new(heap_) SystemLiteral(MavBuilder::GOP_INSERT);
ItemExpr *constDelete = new(heap_) SystemLiteral(MavBuilder::GOP_DELETE);
ItemExpr *constUpdate = new(heap_) SystemLiteral(MavBuilder::GOP_UPDATE);
ItemExpr *constRecompFromUpdate = new(heap_) SystemLiteral(MavBuilder::GOP_MINMAX_RECOMPUTE_FROM_UPDATE);
ItemExpr *constRecompFromInsert = new(heap_) SystemLiteral(MavBuilder::GOP_MINMAX_RECOMPUTE_FROM_INSERT);
// The condition for recompute when a min/max value was deleted was created
// during the buildRootForDelta() phase. If there are no Min/Max columns,
// it is NULL, and therefore redundant.
ItemExpr *lastClause;
if (minMaxRecomputeOnUpdateCondition_ == NULL)
lastClause = constUpdate;
else
lastClause = new(heap_)
IfThenElse(minMaxRecomputeOnUpdateCondition_,
constRecompFromUpdate,
constUpdate);
ItemExpr *insertClause;
if (minMaxRecomputeOnInsertCondition_ == NULL)
insertClause = constInsert;
else
insertClause = new(heap_)
Case(NULL, new(heap_) IfThenElse(minMaxRecomputeOnInsertCondition_,
constRecompFromInsert,
constInsert));
// Build the CASE and IF operators
ItemExpr *gopExpression = new(heap_)
Case(NULL,
new(heap_) IfThenElse(insCondition, insertClause,
new(heap_) IfThenElse(delCondition, constDelete, lastClause)));
// Add the GOP expression as SYS_CALC.@GOP.
ColRefName *gopColName = new(heap_)
ColRefName(MavBuilder::getVirtualGopColumnName(), calcCorrName_);
ItemExpr *gopColumn = new(heap_) RenameCol(gopExpression, gopColName);
// Start the select list with *
ItemExprList selectList(heap_);
addStarToSelectList(selectList);
selectList.insert(gopColumn);
// The select list is ready. Create the root over topNode.
RelRoot *newRoot = new(heap_)
RelRoot(topNode, REL_ROOT, selectList.convertToItemExpr());
newRoot->setDontOpenNewScope();
selectList.clear();
return newRoot;
} // MavRelRootBuilder::buildRootForGop()
GlobalDataTypeRegistry::RegistResult GlobalDataTypeRegistry::registImpl(Entry* dtd)
{
if (!dtd || (dtd->descriptor.getID() > DataTypeID::Max))
{
UAVCAN_ASSERT(0);
return RegistResultInvalidParams;
}
if (isFrozen())
{
return RegistResultFrozen;
}
List* list = selectList(dtd->descriptor.getKind());
if (!list)
{
return RegistResultInvalidParams;
}
{ // Collision check
Entry* p = list->get();
while (p)
{
if (p->descriptor.getID() == dtd->descriptor.getID()) // ID collision
{
return RegistResultCollision;
}
if (!std::strncmp(p->descriptor.getFullName(), dtd->descriptor.getFullName(),
DataTypeDescriptor::MaxFullNameLen)) // Name collision
{
return RegistResultCollision;
}
p = p->getNextListNode();
}
}
#if UAVCAN_DEBUG
const unsigned len_before = list->getLength();
#endif
list->insertBefore(dtd, EntryInsertionComparator(dtd));
#if UAVCAN_DEBUG
{ // List integrity check
const unsigned len_after = list->getLength();
if ((len_before + 1) != len_after)
{
UAVCAN_ASSERT(0);
std::abort();
}
}
{ // Order check
Entry* p = list->get();
int id = -1;
while (p)
{
if (id >= p->descriptor.getID().get())
{
UAVCAN_ASSERT(0);
std::abort();
}
id = p->descriptor.getID().get();
p = p->getNextListNode();
}
}
#endif
return RegistResultOk;
}
