bool SlamContextInterface::process(CommandNode* commandNode)
{
if (! _slam) {
return true;
}
switch (commandNode->commandType()) {
case CT_ADD_NODE:
{
AddNode* c = static_cast<AddNode*>(commandNode);
return _slam->addNode(c->tag(), c->id(), c->dimension(), c->values());
}
case CT_ADD_EDGE:
{
AddEdge* c = static_cast<AddEdge*>(commandNode);
return _slam->addEdge(c->tag(), c->id(), c->dimension(), c->id1(), c->id2(), c->values(), c->information());
}
case CT_SOLVE_STATE:
{
//SolveState* c = static_cast<SolveState*>(commandNode);
return _slam->solveState();
}
case CT_QUERY_STATE:
{
QueryState* c = static_cast<QueryState*>(commandNode);
return _slam->queryState(c->ids());
}
case CT_FIX:
{
FixNode* c = static_cast<FixNode*>(commandNode);
return _slam->fixNode(c->ids());
}
}
cerr << __PRETTY_FUNCTION__ << ": Unknown command type" << endl;
return false;
}
R ColumnBase::aggregate(T target, std::size_t start, std::size_t end,
std::size_t limit, std::size_t* return_ndx) const
{
condition cond;
int c = condition::condition;
typedef typename ColumnTypeTraits2<condition, T>::column_type ColType;
typedef typename ColumnTypeTraits2<condition, T>::array_type ArrType;
if (end == std::size_t(-1))
end = size();
QueryState<R> state;
state.init(action, null_ptr, limit);
ColType* column = const_cast<ColType*>(static_cast<const ColType*>(this));
SequentialGetter<T> sg(column);
bool cont = true;
for (size_t s = start; cont && s < end; ) {
sg.cache_next(s);
size_t end2 = sg.local_end(end);
if(util::SameType<T, int64_t>::value) {
cont = (static_cast<const Array*>(sg.m_array_ptr))->find(c, action, int64_t(target), s - sg.m_leaf_start, end2, sg.m_leaf_start, reinterpret_cast<QueryState<int64_t>*>(&state));
}
else {
for(size_t local_index = s - sg.m_leaf_start; cont && local_index < end2; local_index++) {
T v = ((ArrType*)(sg.m_array_ptr))->get(local_index);
if(cond(v, target)) {
cont = (static_cast<QueryState<R>*>(&state))->template match<action, false>(s + local_index , 0, static_cast<R>(v));
}
}
}
s = end2 + sg.m_leaf_start;
}
if (return_ndx)
*return_ndx = state.m_minmax_index;
return state.m_state;
}
R aggregate(const ColType& column, T target, size_t start, size_t end,
size_t limit, size_t* return_ndx)
{
if (end == npos)
end = column.size();
QueryState<R> state;
state.init(action, nullptr, limit);
SequentialGetter<ColType> sg { &column };
bool cont = true;
for (size_t s = start; cont && s < end; ) {
sg.cache_next(s);
size_t start2 = s - sg.m_leaf_start;
size_t end2 = sg.local_end(end);
cont = _impl::FindInLeaf<ColType>::template find<action, Condition>(*sg.m_leaf_ptr, target, start2, end2, sg.m_leaf_start, state);
s = sg.m_leaf_start + end2;
}
if (return_ndx)
*return_ndx = state.m_minmax_index;
return state.m_state;
}
