public void testCreatePropertyStrangeURITwoArgs() {
   final String local = "_345";
   final Property p = model.createProperty(RDF.getURI(), local);
   Assert.assertEquals(RDF.getURI(), p.getNameSpace());
   Assert.assertEquals(local, p.getLocalName());
   Assert.assertEquals(RDF.getURI() + local, p.getURI());
 }
 public void testCreatePropertyStrangeURI() {
   final String uri = RDF.getURI() + "_345";
   final Property p = model.createProperty(uri);
   Assert.assertEquals(RDF.getURI(), p.getNameSpace());
   Assert.assertEquals("_345", p.getLocalName());
   Assert.assertEquals(uri, p.getURI());
 }
 @Override
 public boolean accept(OntClass cls) {
   if (!cls.isAnon()) {
     return cls.getURI().startsWith(RDF.getURI());
   }
   return false;
 }
Example #4
0
public class WriterConst {
  // See INDENT_PREDICATE
  //    public static final int MIN_SUBJECT     = 4 ;

  /** Minimum width of the predicate columns. */
  public static final int MIN_PREDICATE = 4;

  /** Subjects longer than this have a NL after them. */
  public static final int LONG_SUBJECT = 20;
  /** Predicates longer than this have a NL after them. */
  public static final int LONG_PREDICATE = 30;

  /** The IRI column in a prefix. */
  public static final int PREFIX_IRI = 15;

  // Pretty writers - do object lists?
  // The block writers do not do object lists.
  public static boolean OBJECT_LISTS = true;

  //    // Fixed column widths (unused).
  //    public static int COLW_SUBJECT          = 6 ;
  //    public static int COLW_PREDICATE        = 10 ;

  /** Column for start of predicate */
  public static final int INDENT_PREDICATE = 8;

  /** Column for start of object */
  public static final int INDENT_OBJECT = 8;

  /** Indent for triples in default graph blocks */
  public static final int INDENT_GDFT = 2;
  /** Indent for trinples in named graph blocks */
  public static final int INDENT_GNMD = 4;

  /** Minimum gap from S to P and from P to O */
  public static final int MIN_GAP = 2;

  /** Minimum gap from S to P */
  public static final int GAP_S_P = MIN_GAP;
  /** Minimum gap from P to O */
  public static final int GAP_P_O = MIN_GAP;

  /** Whether to put in a newline after the opening { of a default graph block */
  public static final boolean NL_GDFT_START = false;
  /** Whether to put in a newline after the opening { of a named graph block */
  public static final boolean NL_GNMD_START = true;

  /** Whether to put the closing } of a default graph block on a newline */
  public static final boolean NL_GDFT_END = true;
  /** Whether to put the closing } of a named graph block on a newline */
  public static final boolean NL_GNMD_END = true;

  // Constants.
  public static final String rdfNS = RDF.getURI();
  public static final Node RDF_type = RDF.Nodes.type;
  public static final Node RDF_First = RDF.Nodes.first;
  public static final Node RDF_Rest = RDF.Nodes.rest;
  public static final Node RDF_Nil = RDF.Nodes.nil;
}
public class GraphContainerUtils {
  private static final Node RDFtype = RDF.type.asNode();
  private static final Node BAG = RDF.Bag.asNode();
  private static final Node ALT = RDF.Alt.asNode();
  private static final Node SEQ = RDF.Seq.asNode();
  private static final String membershipPattern = RDF.getURI() + "_(\\d+)";
  private static final int NOT_FOUND = -9999;

  public static Collection<Node> containerMembers(Graph graph, Node container) {
    return containerMembers(graph, container, null);
  }

  public static Collection<Node> containerMembers(Graph graph, Node container, Node containerType) {
    if (!isContainer(graph, container, containerType)) return null;

    ExtendedIterator<Triple> iter = graph.find(container, Node.ANY, Node.ANY);

    SortedMap<Integer, Node> triples = new TreeMap<Integer, Node>(order);
    try {
      for (; iter.hasNext(); ) {
        Triple t = iter.next();
        int index = getIndex(t);
        if (index == NOT_FOUND) continue;
        // Insert
        triples.put(new Integer(index), t.getObject());
      }
    } finally {
      iter.close();
    }
    return triples.values();
  }

  //            List x = new ArrayList() ;
  //            try {
  //              for ( ; iter.hasNext() ; )
  //              {
  //                  // Sort triples in a sorted set.
  //                  // Then extract.
  //                  Triple t = (Triple)iter.next() ;
  //                  String p = t.getPredicate().getURI() ;
  //
  //                  if ( p.matches(membershipPattern) )
  //                      x.add(t.getObject()) ;
  //              }
  //          } finally { iter.close() ; }
  //          return x ;
  //      }

  public static boolean isContainerMember(
      Graph graph, Node container, Node containerType, Node member) {
    return countContainerMember(graph, container, containerType, member, true) != 0;
  }

  public static int countContainerMember(
      Graph graph, Node container, Node containerType, Node member) {
    return countContainerMember(graph, container, containerType, member, false);
  }

  private static int countContainerMember(
      Graph graph, Node container, Node containerType, Node member, boolean stopEarly) {
    if (graph == null) {
      Log.warn(GraphContainerUtils.class, "containerMember called with null graph");
      return 0;
    }

    if (container == null) {
      Log.warn(GraphContainerUtils.class, "containerMember called with null list");
      return 0;
    }
    if (member == null) {
      Log.warn(GraphContainerUtils.class, "containerMember called with null member");
      return 0;
    }

    if (!isContainer(graph, container, containerType)) return 0;

    int count = 0;
    ExtendedIterator<Triple> iter = graph.find(container, Node.ANY, member);
    try {
      for (; iter.hasNext(); ) {
        Triple t = iter.next();
        Node p = t.getPredicate();
        String u = p.getURI();

        if (u.matches(membershipPattern)) {
          count++;
          if (stopEarly) return count;
        }
      }
    } finally {
      iter.close();
    }
    return count;
  }

  //    public static boolean isContainer(Graph graph, Node container)
  //    { return isContainer(graph, container, null) ; }

  public static boolean isContainer(Graph graph, Node container, Node containerType) {
    //        if ( container.isLiteral() )
    //            return false ;

    if (containerType == null)
      return isContainer(graph, container, BAG)
          || isContainer(graph, container, ALT)
          || isContainer(graph, container, SEQ);

    return graph.contains(container, RDFtype, containerType);
  }

  static Pattern pattern = Pattern.compile(membershipPattern);

  private static int getIndex(Triple triple) {
    String u = triple.getPredicate().getURI();
    // Must be _nnn.
    Matcher m = pattern.matcher(u);
    if (!m.find()) return NOT_FOUND;
    String index = m.group(1);
    return Integer.parseInt(index);
  }

  static ContainerOrder order = new ContainerOrder();

  private static class ContainerOrder implements java.util.Comparator<Integer> {
    public int compare(Integer i1, Integer i2) {
      int index1 = i1.intValue();
      int index2 = i2.intValue();

      if (index1 < index2) return Expr.CMP_LESS;
      if (index1 > index2) return Expr.CMP_GREATER;
      return Expr.CMP_EQUAL;
    }
  }
}