uk.ac.manchester.cs.jfact.helpers

Class DLTreeFactory

java.lang.Object

uk.ac.manchester.cs.jfact.helpers.DLTreeFactory

All Implemented Interfaces:

Serializable

public class DLTreeFactory
extends Object
implements Serializable

dl tree factory

See Also:

Serialized Form

Constructor Summary

Constructors

Constructor and Description
DLTreeFactory()

Method Summary

Methods

Modifier and Type	Method and Description
static DLTree	buildDisjAux(List<DLTree> arguments)
static DLTree	buildTree(Lexeme t)
static DLTree	buildTree(Lexeme t, Collection<DLTree> l)
static DLTree	buildTree(Lexeme t, DLTree t1)
static DLTree	buildTree(Lexeme t, DLTree t1, DLTree t2)
static boolean	containsC(DLTree C, DLTree D)
static DLTree	createBottom()
static DLTree	createEntry(Token tag, NamedEntry entry)
static DLTree	createInverse(DLTree R)
static DLTree	createRole(Role R)
static DLTree	createSNFAnd(Collection<DLTree> collection)
static DLTree	createSNFAnd(Collection<DLTree> collection, DLTree ancestor)
static DLTree	createSNFAnd(DLTree C, DLTree D)
static DLTree	createSNFExists(DLTree R, DLTree C) create existential restriction of given formulas (\ER.C)
static DLTree	createSNFForall(DLTree R, DLTree C)
static DLTree	createSNFGE(int n, DLTree R, DLTree C)
static DLTree	createSNFLE(int n, DLTree R, DLTree C) create at-most (LE) restriction of given formulas (max n R.C)
static DLTree	createSNFNot(DLTree C)
static DLTree	createSNFNot(DLTree C, DLTree ancestor)
static DLTree	createSNFOr(Collection<DLTree> C) create disjunction of given formulas
static DLTree	createSNFReducedAnd(DLTree C, DLTree D)
static DLTree	createSNFSelf(DLTree R) create SELF restriction for role R
static DLTree	createTop()
static DLTree	inverseComposition(DLTree tree)
static boolean	isBotRole(DLTree t) check whether T is a bottom (empty) role
static boolean	isDataRangeBigEnough(DLTree dr, int n)
static boolean	isFunctionalExpr(DLTree t, NamedEntry R) check whether T is an expression in the form (atmost 1 RNAME)
static boolean	isSemanticallyDataBottom(DLTree dr)
static boolean	isSemanticallyDataTop(DLTree dr)
static boolean	isSNF(DLTree t)
static boolean	isSubTree(DLTree t1, DLTree t2)
static boolean	isTopRole(DLTree t) check whether T is a top (universal) role
static boolean	isUniversalRole(DLTree t) check whether T is U-Role
static boolean	replaceSynonymsFromTree(DLTree desc)
static DLTree	simplifyDataTopForall(DLTree dr) simplify universal restriction with top data role
static DLTree	simplifyDataTopLE(int n, DLTree dr) simplify minimal cardinality restriction with top data role
static NamedEntry	unwrap(DLTree t) get TDE by a given DLTree
static DLTree	wrap(NamedEntry t) get DLTree by a given TDE

Methods inherited from class java.lang.Object

equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

DLTreeFactory

public DLTreeFactory()

Method Detail

createBottom

@Nonnull
public static DLTree createBottom()

Returns:

BOTTOM element

createInverse

@Nonnull
public static DLTree createInverse(DLTree R)

Parameters:

R - R

Returns:

inverse

isSemanticallyDataTop

public static boolean isSemanticallyDataTop(DLTree dr)

Parameters:

dr - dr

Returns:

true iff a data range DR is semantically equivalent to TOP. FIXME!! good approximation for now

isSemanticallyDataBottom

public static boolean isSemanticallyDataBottom(DLTree dr)

Parameters:

dr - dr

Returns:

true iff a data range DR is semantically equivalent to BOTTOM. FIXME!! good approximation for now

isDataRangeBigEnough

public static boolean isDataRangeBigEnough(DLTree dr,
                           int n)

Parameters:

dr - dr

n - n

Returns:

true iff the cardinality of a given data range DR is greater than N. FIXME!! good approximation for now

simplifyDataTopForall

@Nonnull
public static DLTree simplifyDataTopForall(DLTree dr)

simplify universal restriction with top data role

Parameters:

dr - dr

Returns:

simplified tree

simplifyDataTopLE

@Nonnull
public static DLTree simplifyDataTopLE(int n,
                               DLTree dr)

simplify minimal cardinality restriction with top data role

Parameters:

n - n

dr - dr

Returns:

simplified tree

buildDisjAux

@Nonnull
public static DLTree buildDisjAux(List<DLTree> arguments)

Parameters:

arguments - arguments to AND

Returns:

a construction in the form AND (\neg q_i)

createSNFAnd

@Nonnull
public static DLTree createSNFAnd(DLTree C,
                          DLTree D)

Parameters:

C - C

D - D

Returns:

and

createSNFAnd

@Nonnull
public static DLTree createSNFAnd(Collection<DLTree> collection)

Parameters:

collection - collection

Returns:

and

containsC

public static boolean containsC(DLTree C,
                DLTree D)

Parameters:

C - c

D - d

Returns:

true if c equals d or d is contained in c

createSNFReducedAnd

@Nonnull
public static DLTree createSNFReducedAnd(DLTree C,
                                 DLTree D)

Parameters:

C - c

D - d

Returns:

C and D

createSNFAnd

@Nonnull
public static DLTree createSNFAnd(Collection<DLTree> collection,
                          @Nonnull
                          DLTree ancestor)

Parameters:

collection - collection

ancestor - ancestor

Returns:

and

createSNFExists

@Nonnull
public static DLTree createSNFExists(DLTree R,
                             DLTree C)

create existential restriction of given formulas (\ER.C)

Parameters:

R - R

C - C

Returns:

exist R C

createSNFForall

@Nonnull
public static DLTree createSNFForall(DLTree R,
                             DLTree C)

Parameters:

R - R

C - C

Returns:

for all

createRole

@Nonnull
public static DLTree createRole(Role R)

Parameters:

R - R

Returns:

role

createEntry

@Nonnull
public static DLTree createEntry(Token tag,
                         NamedEntry entry)

Parameters:

tag - tag

entry - entry

Returns:

entry

createSNFLE

@Nonnull
public static DLTree createSNFLE(int n,
                         DLTree R,
                         DLTree C)

create at-most (LE) restriction of given formulas (max n R.C)

Parameters:

n - n

R - R

C - C

Returns:

at most

isBotRole

public static boolean isBotRole(DLTree t)

check whether T is a bottom (empty) role

Parameters:

t - tree

Returns:

true if bottom

isTopRole

public static boolean isTopRole(DLTree t)

check whether T is a top (universal) role

Parameters:

t - tree

Returns:

true if top role

createSNFSelf

@Nonnull
public static DLTree createSNFSelf(DLTree R)

create SELF restriction for role R

Parameters:

R - R

Returns:

self

createSNFGE

@Nonnull
public static DLTree createSNFGE(int n,
                         DLTree R,
                         DLTree C)

Parameters:

n - n

R - R

C - C

Returns:

at least

createSNFNot

@Nonnull
public static DLTree createSNFNot(DLTree C)

Parameters:

C - C

Returns:

not

createSNFNot

@Nonnull
public static DLTree createSNFNot(@Nonnull
                          DLTree C,
                          @Nonnull
                          DLTree ancestor)

Parameters:

C - C

ancestor - ancestor

Returns:

not

createSNFOr

@Nonnull
public static DLTree createSNFOr(Collection<DLTree> C)

create disjunction of given formulas

Parameters:

C - C

Returns:

OR C

createTop

@Nonnull
public static DLTree createTop()

Returns:

TOP element

inverseComposition

@Nonnull
public static DLTree inverseComposition(DLTree tree)

Parameters:

tree - tree

Returns:

inverse

wrap

@Nonnull
public static DLTree wrap(NamedEntry t)

get DLTree by a given TDE

Parameters:

t - t

Returns:

wrapped entry

unwrap

@Nonnull
public static NamedEntry unwrap(DLTree t)

get TDE by a given DLTree

Parameters:

t - t

Returns:

unwrapped entry

buildTree

@Nonnull
public static DLTree buildTree(Lexeme t,
                       DLTree t1,
                       DLTree t2)

Parameters:

t - t

t1 - t1

t2 - t2

Returns:

tree with two children

buildTree

@Nonnull
public static DLTree buildTree(Lexeme t,
                       Collection<DLTree> l)

Parameters:

t - t

l - list

Returns:

tree with multiple children

buildTree

@Nonnull
public static DLTree buildTree(Lexeme t,
                       DLTree t1)

Parameters:

t - t

t1 - t1

Returns:

single child tree

buildTree

@Nonnull
public static DLTree buildTree(Lexeme t)

Parameters:

t - t

Returns:

leaf tree

isFunctionalExpr

public static boolean isFunctionalExpr(DLTree t,
                       NamedEntry R)

check whether T is an expression in the form (atmost 1 RNAME)

Parameters:

t - t

R - R

Returns:

true if functional

isSNF

public static boolean isSNF(DLTree t)

Parameters:

t - t

Returns:

true is SNF

isSubTree

public static boolean isSubTree(DLTree t1,
                DLTree t2)

Parameters:

t1 - t1

t2 - t2

Returns:

true if t2 is a subtree

isUniversalRole

public static boolean isUniversalRole(DLTree t)

check whether T is U-Role

Parameters:

t - t

Returns:

true if universal

replaceSynonymsFromTree

public static boolean replaceSynonymsFromTree(DLTree desc)

Parameters:

desc - desc

Returns:

true if changes happen