void TBox :: addConceptToHeap ( TConcept* pConcept )
{
// choose proper tag by concept
DagTag tag = pConcept->isPrimitive() ?
(pConcept->isSingleton() ? dtPSingleton : dtPConcept):
(pConcept->isSingleton() ? dtNSingleton : dtNConcept);
// NSingleton is a nominal
if ( tag == dtNSingleton && !pConcept->isSynonym() )
static_cast<TIndividual*>(pConcept)->setNominal();
// new concept's addition
DLVertex* ver = new DLVertex(tag);
ver->setConcept(pConcept);
pConcept->pName = DLHeap.directAdd(ver);
BipolarPointer desc = bpTOP;
// translate body of a concept
if ( pConcept->Description != NULL ) // complex concept
desc = tree2dag(pConcept->Description);
else // only primivive concepts here
fpp_assert ( pConcept->isPrimitive() );
// update concept's entry
pConcept->pBody = desc;
ver->setChild(desc);
if ( !pConcept->isSynonym() && pConcept->index() == 0 )
setConceptIndex(pConcept);
}
/// fills AND-like vertex V with an AND-like expression T; process result
BipolarPointer
TBox :: and2dag ( const DLTree* t )
{
BipolarPointer ret = bpBOTTOM;
DLVertex* v = new DLVertex(dtAnd);
if ( fillANDVertex ( v, t ) ) // clash found
delete v;
else // AND vertex
switch ( v->end() - v->begin() )
{
case 0: // and(TOP) = TOP
delete v;
return bpTOP;
case 1: // and(C) = C
ret = *v->begin();
delete v;
break;
default:
ret = DLHeap.add(v);
break;
}
return ret;
}
/// @return true if the DAG in the SL structure is the same that is loaded
static bool
VerifyDag ( const DLDag& dag, SaveLoadManager& m )
{
unsigned int j, size;
size = m.loadUInt();
if ( size != dag.size() )
{
std::cout << "DAG verification fail: size " << size << ", expected " << dag.size() << "\n";
return false;
}
for ( j = 2; j < size; ++j )
{
DagTag tag = static_cast<DagTag>(m.loadUInt());
DLVertex* v = new DLVertex(tag);
v->Load(m);
if ( *v != dag[j] )
{
std::cout << "DAG verification fail: dag entry at " << j << " is ";
v->Print(std::cout);
std::cout << ", expected ";
dag[j].Print(std::cout);
std::cout << "\n";
delete v;
return false;
}
delete v;
}
return true;
}
void LogicFeatures :: fillDAGData ( const DLVertex& v, bool )
{
switch ( v.Type () )
{
case dtForall:
setX(lfSomeConstructor);
break;
case dtLE:
setX(lfNConstructor);
if ( v.getC() != bpTOP )
setX(lfQConstructor);
break;
case dtPSingleton:
case dtNSingleton:
setX(lfSingleton);
break;
case dtIrr:
setX(lfSelfRef);
break;
default: // any other vertex -- nothing to do
break;
}
}
/// transform splitted concept registered in SPLIT to a dag representation
void
TBox :: split2dag ( TSplitVar* split )
{
DLVertex* v = new DLVertex(dtSplitConcept);
for ( TSplitVar::iterator p = split->begin(), p_end = split->end(); p != p_end; ++p )
v->addChild(p->C->pName);
split->C->pBody = DLHeap.directAdd(v);
split->C->setPrimitive(false);
DLHeap.replaceVertex ( split->C->pName, new DLVertex ( dtNConcept, split->C->pBody ), split->C );
DLHeap.directAdd(new DLVertex ( dtChoose, split->C->pName ));
}
void
modelCacheIan :: processAutomaton ( const DLVertex& cur )
{
const RAStateTransitions& RST = cur.getRole()->getAutomaton()[cur.getState()];
// for every transition starting from a given state,
// add the role that is accepted by a transition
for ( RAStateTransitions::const_iterator i = RST.begin(), i_end = RST.end(); i < i_end; ++i )
for ( RATransition::const_iterator r = (*i)->begin(), r_end = (*i)->end(); r < r_end; ++r )
forallRoles.insert((*r)->index());
}
void
LoadDLDag ( DLDag& dag, SaveLoadManager& m )
{
unsigned int j, size;
size = m.loadUInt();
for ( j = 2; j < size; ++j )
{
DagTag tag = static_cast<DagTag>(m.loadUInt());
DLVertex* v = new DLVertex(tag);
v->Load(m);
dag.directAdd(v);
}
// only reasoning now -- no cache
dag.setFinalSize();
}
/// register data expression in the DAG
BipolarPointer TBox :: addDataExprToHeap ( TDataEntry* p )
{
if ( isValid(p->getBP()) ) // already registered value
return p->getBP();
// determine the type of an entry
DagTag dt = p->isBasicDataType() ? dtDataType : p->isDataValue() ? dtDataValue : dtDataExpr;
BipolarPointer hostBP = bpTOP;
// register host type first (if any)
if ( p->getType() != NULL )
hostBP = addDataExprToHeap(const_cast<TDataEntry*>(p->getType()));
// create new DAG entry for the data value
DLVertex* ver = new DLVertex ( dt, hostBP );
ver->setConcept(p);
p->setBP(DLHeap.directAdd(ver));
return p->getBP();
}
void
DLDag :: removeQuery ( void )
{
for ( size_t i = size()-1; i >= finalDagSize; --i )
{
DLVertex* v = Heap[i];
switch ( v->Type() )
{
case dtData:
static_cast<TDataEntry*>(v->getConcept())->setBP(bpINVALID);
break;
case dtConcept:
static_cast<TConcept*>(v->getConcept())->clear();
break;
default:
break;
}
delete v;
}
Heap.resize(finalDagSize);
}
void modelCacheIan :: processConcept ( const DLVertex& cur, bool pos, bool det )
{
switch ( cur.Type() )
{
case dtTop: // sanity checks
case dtDataType: // data entries can not be cached
case dtDataValue:
case dtDataExpr:
fpp_unreachable();
break;
case dtNConcept: // add concepts to Concepts
case dtPConcept:
case dtNSingleton:
case dtPSingleton:
(det ? getDConcepts(pos) : getNConcepts(pos)).insert(static_cast<const ClassifiableEntry*>(cur.getConcept())->index());
break;
case dtIrr: // for \neg \ER.Self: add R to AR-set
case dtForall: // add AR.C roles to forallRoles
case dtLE: // for <= n R: add R to forallRoles
if ( unlikely ( cur.getRole()->isTop() ) ) // force clash to every other edge
(pos ? forallRoles : existsRoles).completeSet();
else if ( pos ) // no need to deal with existentials here: they would be created through edges
{
if ( cur.getRole()->isSimple() )
forallRoles.insert(cur.getRole()->index());
else
processAutomaton(cur);
}
break;
default: // all other -- nothing to do
break;
}
}