How to use

getArgument

method

in

openllet.aterm.ATermAppl

@Override
public void visitHasValue(final ATermAppl term)
{
  visitRole((ATermAppl) term.getArgument(0));
  visitValue((ATermAppl) term.getArgument(1));
}

  @Override
  public void visitRestrictedDatatype(final ATermAppl dt)
  {
    isDatatype((ATermAppl) dt.getArgument(0));
  }
}

@Override
public void visitSelf(final ATermAppl term)
{
  visit((ATermAppl) term.getArgument(0));
  final OWLObjectPropertyExpression prop = (OWLObjectPropertyExpression) _obj;
  _obj = _factory.getOWLObjectHasSelf(prop);
}

/**
 * {@inheritDoc}
 */
@Override
public void visitInverse(final ATermAppl p)
{
  final OWLObjectProperty prop = (OWLObjectProperty) convert((ATermAppl) p.getArgument(0));
  _obj = _factory.getOWLObjectInverseOf(prop);
}

private Node createQualifiedRestriction(final ATermAppl term, final Property restrType)
{
  final Node restr = createRestriction(term, restrType);
  final Node qual = convert(term.getArgument(2));
  if (!ATermUtils.isTop((ATermAppl) term.getArgument(2)))
    TripleAdder.add(_graph, restr, OWL2.onClass, qual);
  _obj = restr;
  return restr;
}

@Override
public void visitAnd(final ATermAppl term)
{
  visitList((ATermList) term.getArgument(0));
  createClassExpression(OWL.intersectionOf);
}

@Override
public void visitNot(final ATermAppl term)
{
  visit((ATermAppl) term.getArgument(0));
  createClassExpression(OWL.complementOf);
}

@Override
public void visitOneOf(final ATermAppl term)
{
  _expressivity.setHasNegation(true);
  visitList((ATermList) term.getArgument(0));
}

public String invalidLiteralExplanation()
{
  final ATermAppl literal = (ATermAppl) _args[0];
  final ATermAppl datatype = (ATermAppl) literal.getArgument(2);
  return "Literal value " + ATermUtils.toString(literal) + " is not valid for the rdatatype " + ATermUtils.toString(datatype);
}

private Optional<Node> convertAtomObject(final ATermAppl t)
{
  if (ATermUtils.isVar(t))
  {
    final Optional<Node> node = JenaUtils.makeGraphNode((ATermAppl) t.getArgument(0));
    if (node.isPresent())
      TripleAdder.add(_graph, node.get(), RDF.type, SWRL.Variable);
    return node;
  }
  else
    return JenaUtils.makeGraphNode(t);
}

private Node createRestriction(final ATermAppl term, final Property restrType)
{
  final Node restr = NodeFactory.createBlankNode();
  final Node prop = convert(term.getArgument(0));
  final Node val = convert(term.getArgument(1));
  TripleAdder.add(_graph, restr, RDF.type, OWL.Restriction);
  TripleAdder.add(_graph, restr, OWL.onProperty, prop);
  TripleAdder.add(_graph, restr, restrType, val);
  _obj = restr;
  return restr;
}

@Override
public void visitInverse(final ATermAppl term)
{
  final ATermAppl p = (ATermAppl) term.getArgument(0);
  if (ATermUtils.isPrimitive(p))
    _fullyDefined = _fullyDefined && isProperty(p);
  else
    visitInverse(p);
}

@Override
public CachedNode getCached(final ATermAppl c)
{
  if (ATermUtils.isNominal(c))
    return getIndividual(c.getArgument(0)).getSame();
  else
    return _cache.get(c);
}

@Override
public void visitAnd(final ATermAppl term)
{
  visitList((ATermList) term.getArgument(0));
  if (_obj instanceof OWLClassExpression)
    _obj = _factory.getOWLObjectIntersectionOf(dynamicCastTheSet(_set, OWLClassExpression.class));
  else
    if (_obj instanceof OWLDataRange)
      _obj = _factory.getOWLDataIntersectionOf(dynamicCastTheSet(_set, OWLDataRange.class));
}

@Override
public void visitValue(final ATermAppl term)
{
  final ATermAppl nominal = (ATermAppl) term.getArgument(0);
  if (ATermUtils.isLiteral(nominal))
  {
    visitLiteral(nominal);
    _obj = _factory.getOWLDataOneOf((OWLLiteral) _obj);
  }
  else
    _obj = _factory.getOWLObjectOneOf(convertIndividual(nominal));
}

@Override
public void visitOr(final ATermAppl term)
{
  visitList((ATermList) term.getArgument(0));
  if (_obj instanceof OWLClassExpression)
    _obj = _factory.getOWLObjectUnionOf(dynamicCastTheSet(_set, OWLClassExpression.class));
  else
    if (_obj instanceof OWLDataRange)
      _obj = _factory.getOWLDataUnionOf(dynamicCastTheSet(_set, OWLDataRange.class));
}

private void convertNary(final ATermAppl axiom, final Resource type, final Property p)
{
  final Node n = NodeFactory.createBlankNode();
  TripleAdder.add(_graph, n, RDF.type, type);
  final ATermList concepts = (ATermList) axiom.getArgument(0);
  _converter.visitList(concepts);
  TripleAdder.add(_graph, n, p, _converter.getResult());
}

@Override
public void visitSelf(final ATermAppl term)
{
  final Node restr = NodeFactory.createBlankNode();
  final Node prop = convert(term.getArgument(0));
  TripleAdder.add(_graph, restr, RDF.type, OWL.Restriction);
  TripleAdder.add(_graph, restr, OWL.onProperty, prop);
  TripleAdder.add(_graph, restr, OWL2.hasSelf, JenaUtils.XSD_BOOLEAN_TRUE);
  _obj = restr;
}

@Override
public T getValue(final ATermAppl literal) throws InvalidLiteralException
{
  final T value = _range.getDatatype().getValue(literal);
  if (!_range.contains(value))
    throw new InvalidLiteralException(_name, literal.getArgument(ATermUtils.LIT_VAL_INDEX).toString());
  return value;
}

private SWRLIArgument parseToAtomIObject(final ATermAppl t)
{
  if (ATermUtils.isVar(t))
    return _factory.getSWRLVariable(IRI.create(((ATermAppl) t.getArgument(0)).getName()));
  if (_kb.isIndividual(t))
    return _factory.getSWRLIndividualArgument(_conceptConverter.convertIndividual(t));
  throw new InternalReasonerException("Unrecognized term: " + t);
}