Atom (grakn-graql 1.1.0 API)

java.lang.Object
- ai.grakn.graql.internal.reasoner.atom.AtomicBase
- - ai.grakn.graql.internal.reasoner.atom.Atom

All Implemented Interfaces:

Atomic

Direct Known Subclasses:

Binary
```
public abstract class Atom
extends AtomicBase
```
AtomicBase extension defining specialised functionalities.

Author:

Kasper Piskorski

Constructor Summary

Constructors
Modifier Constructor and Description

protected Atom(Atom a)

protected Atom(VarPattern pattern, ReasonerQuery par)

Constructors
Modifier	Constructor and Description
`protected`	`Atom(Atom a)`
`protected`	`Atom(VarPattern pattern, ReasonerQuery par)`

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`Atom`	`addType(SchemaConcept type)`
`List<Atom>`	`atomOptions(Answer sub)`
`int`	`computePriority(Set<Var> subbedVars)` compute resolution priority based on provided substitution variables
`java.util.stream.Stream<InferenceRule>`	`getApplicableRules()`
`IdPredicate`	`getIdPredicate(Var var)`
`abstract java.util.stream.Stream<Predicate>`	`getInnerPredicates()`
`<T extends Predicate> java.util.stream.Stream<T>`	`getInnerPredicates(Class<T> type)`
`MultiUnifier`	`getMultiUnifier(Atom parentAtom, UnifierComparison unifierType)` find the (multi) unifier with parent atom
`<T extends Atomic> java.util.stream.Stream<T>`	`getNeighbours(Class<T> type)`
`java.util.stream.Stream<Atomic>`	`getNonSelectableConstraints()`
`java.util.stream.Stream<IdPredicate>`	`getPartialSubstitutions()`
`protected java.util.stream.Stream<Rule>`	`getPotentialRules()`
`<T extends Predicate> T`	`getPredicate(Var var, Class<T> type)`
`java.util.stream.Stream<Predicate>`	`getPredicates()`
`<T extends Predicate> java.util.stream.Stream<T>`	`getPredicates(Class<T> type)`
`abstract Var`	`getPredicateVariable()`
`Set<Var>`	`getRoleExpansionVariables()`
`abstract SchemaConcept`	`getSchemaConcept()`
`Set<TypeAtom>`	`getSpecificTypeConstraints()`
`java.util.stream.Stream<TypeAtom>`	`getTypeConstraints()`
`abstract ConceptId`	`getTypeId()`
`abstract Unifier`	`getUnifier(Atom parentAtom)`
`java.util.stream.Stream<VarProperty>`	`getVarProperties()`
`abstract Class<? extends VarProperty>`	`getVarPropertyClass()`
`Atom`	`inferTypes()`
`Atom`	`inferTypes(Answer sub)`
`boolean`	`isAtom()`
`boolean`	`isGround()`
`boolean`	`isRecursive()`
`protected abstract boolean`	`isRuleApplicableViaAtom(Atom headAtom)`
`boolean`	`isRuleResolvable()`
`java.util.stream.Stream<Answer>`	`materialise()`
`boolean`	`requiresMaterialisation()`
`boolean`	`requiresRoleExpansion()`
`abstract Atom`	`rewriteToUserDefined(Atom parentAtom)` rewrites the atom to one with suitably user-defined names depending on provided parent
`Atom`	`rewriteWithRelationVariable()` rewrites the atom to one with user defined relation variable
`abstract Atom`	`rewriteWithTypeVariable()`
`protected Atom`	`rewriteWithTypeVariable(Atom parentAtom)` rewrites the atom to user-defined type variable
`RelationshipAtom`	`toRelationshipAtom()`
`Set<String>`	`validateAsRuleHead(Rule rule)`

Methods inherited from class ai.grakn.graql.internal.reasoner.atom.AtomicBase
checkValid, containsVar, copy, createCombinedPattern, getCombinedPattern, getParentQuery, getPattern, getVarName, getVarNames, isUserDefined, setParentQuery, toString, tx

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface ai.grakn.graql.admin.Atomic
alphaEquivalenceHashCode, isAlphaEquivalent, isCompatibleWith, isRelation, isResource, isSelectable, isStructurallyEquivalent, isType, structuralEquivalenceHashCode, validateOntologically

- Constructor Detail
  - Atom
```
protected Atom(VarPattern pattern,
               ReasonerQuery par)
```
  - Atom
```
protected Atom(Atom a)
```
- Method Detail
  - toRelationshipAtom
```
public RelationshipAtom toRelationshipAtom()
```
  - isAtom
```
public boolean isAtom()
```
  - isRuleResolvable
```
public boolean isRuleResolvable()
```
  - isRecursive
```
public boolean isRecursive()
```
  - isGround
```
public boolean isGround()
```
    Returns:
    
    true if the atom is ground (all variables are bound)
  - getVarPropertyClass
```
public abstract Class<? extends VarProperty> getVarPropertyClass()
```
  - validateAsRuleHead
```
public Set<String> validateAsRuleHead(Rule rule)
```
    Specified by:
    
    validateAsRuleHead in interface Atomic
    
    Overrides:
    
    validateAsRuleHead in class AtomicBase
  - getVarProperties
```
public java.util.stream.Stream<VarProperty> getVarProperties()
```
    Returns:
    
    var properties this atom (its pattern) contains
  - getPartialSubstitutions
```
public java.util.stream.Stream<IdPredicate> getPartialSubstitutions()
```
    Returns:
    
    partial substitutions for this atom (NB: instances)
  - getRoleExpansionVariables
```
public Set<Var> getRoleExpansionVariables()
```
    Returns:
    
    set of variables that need to be have their roles expanded
  - computePriority
```
public int computePriority(Set<Var> subbedVars)
```
    compute resolution priority based on provided substitution variables
    
    Parameters:
    
    subbedVars - variables having a substitution
    
    Returns:
    
    resolution priority value
  - isRuleApplicableViaAtom
```
protected abstract boolean isRuleApplicableViaAtom(Atom headAtom)
```
  - getPotentialRules
```
protected java.util.stream.Stream<Rule> getPotentialRules()
```
    Returns:
    
    set of potentially applicable rules - does shallow (fast) check for applicability
  - getApplicableRules
```
public java.util.stream.Stream<InferenceRule> getApplicableRules()
```
    Returns:
    
    set of applicable rules - does detailed (slow) check for applicability
  - requiresMaterialisation
```
public boolean requiresMaterialisation()
```
    Returns:
    
    true if the atom requires materialisation in order to be referenced
  - requiresRoleExpansion
```
public boolean requiresRoleExpansion()
```
    Returns:
    
    true if the atom requires role expansion
  - getSchemaConcept
```
public abstract SchemaConcept getSchemaConcept()
```
    Returns:
    
    corresponding type if any
  - getTypeId
```
public abstract ConceptId getTypeId()
```
    Returns:
    
    type id of the corresponding type if any
  - getPredicateVariable
```
public abstract Var getPredicateVariable()
```
    Returns:
    
    value variable name
  - getPredicates
```
public java.util.stream.Stream<Predicate> getPredicates()
```
    Returns:
    
    set of predicates relevant to this atom
  - getPredicates
```
public <T extends Predicate> java.util.stream.Stream<T> getPredicates(Class<T> type)
```
    Type Parameters:
    
    T - the type of Predicate to return
    
    Parameters:
    
    type - the class of Predicate to return
    
    Returns:
    
    stream of predicates relevant to this atom
  - getIdPredicate
```
@Nullable
public IdPredicate getIdPredicate(Var var)
```
    Parameters:
    
    var - variable of interest
    
    Returns:
    
    id predicate referring to prescribed variable
  - getPredicate
```
@Nullable
public <T extends Predicate> T getPredicate(Var var,
                                                      Class<T> type)
```
    Type Parameters:
    
    T - predicate type generic
    
    Parameters:
    
    var - variable the predicate refers to
    
    type - predicate type
    
    Returns:
    
    specific predicate referring to provided variable
  - getInnerPredicates
```
public abstract java.util.stream.Stream<Predicate> getInnerPredicates()
```
  - getInnerPredicates
```
public <T extends Predicate> java.util.stream.Stream<T> getInnerPredicates(Class<T> type)
```
    Type Parameters:
    
    T - the type of Predicate to return
    
    Parameters:
    
    type - the class of Predicate to return
    
    Returns:
    
    stream of predicates relevant to this atom
  - getTypeConstraints
```
public java.util.stream.Stream<TypeAtom> getTypeConstraints()
```
    Returns:
    
    set of types relevant to this atom
  - getNeighbours
```
public <T extends Atomic> java.util.stream.Stream<T> getNeighbours(Class<T> type)
```
    Type Parameters:
    
    T - the type of neighbour Atomic to return
    
    Parameters:
    
    type - the class of Predicate to return
    
    Returns:
    
    neighbours of this atoms, i.e. atoms connected to this atom via shared variable
  - getNonSelectableConstraints
```
public java.util.stream.Stream<Atomic> getNonSelectableConstraints()
```
    Returns:
    
    set of constraints of this atom (predicates + types) that are not selectable
  - getSpecificTypeConstraints
```
public Set<TypeAtom> getSpecificTypeConstraints()
```
    Returns:
    
    set of type atoms that describe specific role players or resource owner
  - inferTypes
```
public Atom inferTypes()
```
    Specified by:
    
    inferTypes in interface Atomic
    
    Overrides:
    
    inferTypes in class AtomicBase
  - inferTypes
```
public Atom inferTypes(Answer sub)
```
    Overrides:
    
    inferTypes in class AtomicBase
  - atomOptions
```
public List<Atom> atomOptions(Answer sub)
```
    Parameters:
    
    sub - partial substitution
    
    Returns:
    
    list of possible atoms obtained by applying type inference
  - addType
```
public Atom addType(SchemaConcept type)
```
    Parameters:
    
    type - to be added to this Atom
    
    Returns:
    
    new Atom with specified type
  - materialise
```
public java.util.stream.Stream<Answer> materialise()
```
  - rewriteWithTypeVariable
```
public abstract Atom rewriteWithTypeVariable()
```
  - rewriteWithTypeVariable
```
protected Atom rewriteWithTypeVariable(Atom parentAtom)
```
    rewrites the atom to user-defined type variable
    
    Parameters:
    
    parentAtom - parent atom that triggers rewrite
    
    Returns:
    
    rewritten atom
  - rewriteWithRelationVariable
```
public Atom rewriteWithRelationVariable()
```
    rewrites the atom to one with user defined relation variable
    
    Returns:
    
    rewritten atom
  - rewriteToUserDefined
```
public abstract Atom rewriteToUserDefined(Atom parentAtom)
```
    rewrites the atom to one with suitably user-defined names depending on provided parent
    
    Parameters:
    
    parentAtom - parent atom that triggers rewrite
    
    Returns:
    
    rewritten atom
  - getUnifier
```
public abstract Unifier getUnifier(Atom parentAtom)
```
    Parameters:
    
    parentAtom - atom to be unified with
    
    Returns:
    
    corresponding unifier
  - getMultiUnifier
```
public MultiUnifier getMultiUnifier(Atom parentAtom,
                                    UnifierComparison unifierType)
```
    find the (multi) unifier with parent atom
    
    Parameters:
    
    parentAtom - atom to be unified with
    
    unifierType - type of unifier to be computed
    
    Returns:
    
    multiunifier

Class Atom

Constructor Summary

Method Summary

Methods inherited from class ai.grakn.graql.internal.reasoner.atom.AtomicBase

Methods inherited from class java.lang.Object

Methods inherited from interface ai.grakn.graql.admin.Atomic

Constructor Detail

Atom

Atom

Method Detail

toRelationshipAtom

isAtom

isRuleResolvable

isRecursive

isGround

getVarPropertyClass

validateAsRuleHead

getVarProperties

getPartialSubstitutions

getRoleExpansionVariables

computePriority

isRuleApplicableViaAtom

getPotentialRules

getApplicableRules

requiresMaterialisation

requiresRoleExpansion

getSchemaConcept

getTypeId

getPredicateVariable

getPredicates

getPredicates

getIdPredicate

getPredicate

getInnerPredicates

getInnerPredicates

getTypeConstraints

getNeighbours

getNonSelectableConstraints

getSpecificTypeConstraints

inferTypes

inferTypes

atomOptions

addType

materialise

rewriteWithTypeVariable

rewriteWithTypeVariable

rewriteWithRelationVariable

rewriteToUserDefined

getUnifier

getMultiUnifier