Tabnine Logo
Triple
Code IndexAdd Tabnine to your IDE (free)

How to use
Triple
in
org.metafacture.framework.objects

Best Java code snippets using org.metafacture.framework.objects.Triple (Showing top 20 results out of 315)

origin: metafacture/metafacture-core

@Override
public void process(final Triple triple) {
  assert !isClosed();
  if (triple.getObjectType() != ObjectType.STRING) {
    return;
  }
  final String objectValue = retrieveObjectValue(triple.getObject());
  getReceiver().process(new Triple(triple.getSubject(), triple.getPredicate(),
      objectValue));
}
origin: metafacture/metafacture-core

  @Override
  public int compare(final Triple o1, final Triple o2) {
    return order.order(o1.compareTo(o2));
  }
};
origin: metafacture/metafacture-core

public Triple(final String subject, final String predicate,
    final String object, final ObjectType objectType) {
  this.subject = subject;
  this.predicate = predicate;
  this.object = object;
  this.objectType = objectType;
  preCompHashCode = computeHashCode();
}
origin: metafacture/metafacture-core

private Path buildFilePath(final Triple triple) {
  final Path file = Paths.get(triple.getSubject(), triple.getPredicate());
  return baseDir.resolve(file).toAbsolutePath().normalize();
}
origin: metafacture/metafacture-core

public void decodeTriple(final Triple triple) {
  if(triple.getObjectType() == ObjectType.STRING){
    getReceiver().literal(triple.getPredicate(), triple.getObject());
  }else if (triple.getObjectType() == ObjectType.ENTITY){
    emitter.setDefaultName(triple.getPredicate());
    parser.parse(triple.getObject());
  }else{
    throw new UnsupportedOperationException(triple.getObjectType() + " can not yet be decoded");
  }
}
origin: metafacture/metafacture-core

public static Triple read(final ObjectInputStream in) throws IOException {
  try {
    return new Triple(in.readUTF(), in.readUTF(), in.readUTF(),
        (ObjectType) in.readObject());
  } catch (final ClassNotFoundException e) {
    throw new IOException("Cannot read triple", e);
  }
}
origin: metafacture/metafacture-core

@Override
public void process(final Triple obj) {
  subjectMatcher.reset(obj.getSubject());
  predicateMatcher.reset(obj.getPredicate());
  objectMatcher.reset(obj.getObject());
  final boolean matches = subjectMatcher.matches() || predicateMatcher.matches() || objectMatcher.matches();
  if ((matches && passMatches) || (!matches && !passMatches)) {
    getReceiver().process(obj);
  }
}
origin: metafacture/metafacture-core

@Override
public final void process(final Triple triple) {
  if (triple.getSubject().indexOf('&') == -1) {
    if (!inHeader) {
      throw new IllegalArgumentException(
          "Marginal counts and joint count must not be mixed. Marginal counts must appear first, joint counts second");
    }
    if (!triple.getSubject().startsWith(MARGINAL_PREFIX)) {
      throw new IllegalArgumentException("Marginal counts must start with '1:'");
    }
    final int marginal = Integer.parseInt(triple.getObject());
    if (marginal >= minCount) {
      marginals.put(triple.getSubject().substring(2), Integer.valueOf(marginal));
    }
  } else {
    inHeader = false;
    if (!triple.getSubject().startsWith(JOINT_PREFIX)) {
      throw new IllegalArgumentException("Joint counts must start with '2:'");
    }
    final int nab = Integer.parseInt(triple.getObject());
    final String[] keyParts = KEY_SPLIT_PATTERN.split(triple.getSubject().substring(2));
    if (nab >= minCount) {
      final int na = getMarginal(keyParts[0]);
      final int nb = getMarginal(keyParts[1]);
      processCount(keyParts[0], keyParts[1], na, nb, nab);
    }
  }
}
origin: metafacture/metafacture-core

  @Override
  public int compare(final Triple o1, final Triple o2) {
    return order.order(o1.getSubject().compareTo(o2.getSubject()));
  }
};
origin: metafacture/metafacture-core

  @Override
  public int compare(final Triple o1, final Triple o2) {
    return order.order(o1.getObject().compareTo(o2.getObject()));
  }
};
origin: metafacture/metafacture-core

  @Override
  public int compare(final Triple o1, final Triple o2) {
    return order.order(o1.getPredicate().compareTo(o2.getPredicate()));
  }
};
origin: metafacture/metafacture-core

private void dispatch(final String name, final String value, final ObjectType type) {
  if (redirect) {
    if (StandardEventNames.ID.equals(name)) {
      currentId = value;
    } else {
      final Matcher matcher = REDIRECT_PATTERN.matcher(name);
      if (matcher.find()) {
        getReceiver().process(new Triple(matcher.group(1), matcher.group(2), value, type));
      } else {
        nameBuffer.add(name);
        valueBuffer.add(value);
        typeBuffer.add(type);
      }
    }
  } else {
    getReceiver().process(new Triple(currentId, name, value, type));
  }
}
origin: metafacture/metafacture-core

  @Override
  public void process(final T obj) {
    if(obj instanceof Triple){
      final Triple triple = (Triple)obj;
      vars.put("s", triple.getSubject());
      vars.put("p", triple.getPredicate());
      vars.put("o", triple.getObject());
      getReceiver().process(StringUtil.format(template, vars));
    }else{
      final Matcher matcher = OBJ_PATTERN.matcher(template);
      getReceiver().process(matcher.replaceAll(obj.toString()));
    }
  }
}
origin: metafacture/metafacture-core

@Override
public void process(final Triple triple) {
  if (currentSubject == null) {
    currentSubject = triple.getSubject();
    getReceiver().startRecord(currentSubject);
  }
  if (currentSubject.equals(triple.getSubject())) {
    decodeTriple(triple);
  } else {
    getReceiver().endRecord();
    currentSubject = triple.getSubject();
    getReceiver().startRecord(currentSubject);
    decodeTriple(triple);
  }
}
origin: metafacture/metafacture-core

@Override
public void process(final Triple triple) {
  final Path filePath = buildFilePath(triple);
  ensureParentPathExists(filePath);
  try(final Writer writer = Files.newBufferedWriter(filePath, encoding)) {
    writer.write(triple.getObject());
  } catch (final IOException e) {
    throw new MetafactureException(e);
  }
}
origin: metafacture/metafacture-core

@Override
public void process(final Triple triple) {
  getReceiver().startRecord(triple.getSubject());
  if(triple.getObjectType() == ObjectType.STRING){
    getReceiver().literal(triple.getPredicate(), triple.getObject());
  }else if (triple.getObjectType() == ObjectType.ENTITY){
    emitter.setDefaultName(triple.getPredicate());
    parser.parse(triple.getObject());
  }else{
    throw new UnsupportedOperationException(triple.getObjectType() + " can not yet be decoded");
  }
  getReceiver().endRecord();
}
origin: metafacture/metafacture-core

@Override
public void endRecord() {
  assert !isClosed();
  nestingLevel = 0;
  if (nestingLevel == encodeLevel) {
    endEncode();
  }
  if (redirect) {
    for (int i = 0; i < nameBuffer.size(); ++i) {
      getReceiver().process(new Triple(currentId, nameBuffer.get(i), valueBuffer.get(i), typeBuffer.get(i)));
    }
    nameBuffer.clear();
    valueBuffer.clear();
    typeBuffer.clear();
  }
}
origin: metafacture/metafacture-core

@Override
public void process(final Triple triple) {
  final String[] elements = {
      triple.getSubject(),
      triple.getPredicate(),
      triple.getObject(),
  };
  getReceiver().process(new Triple(
      elements[subjectFrom.ordinal()],
      elements[predicateFrom.ordinal()],
      elements[objectFrom.ordinal()]
  ));
}
origin: metafacture/metafacture-core

  @Override
  protected void processCount(final String varA, final String varB, final int countA, final int countB,
      final int countAandB) {
    for (Metric metric : metrics) {
      final double value = metric.calculate(countA, countB, countAandB, getTotal());
      getReceiver().process(new Triple(varA + "&" + varB, metric.toString(), String.valueOf(value)));
    }
  }
}
origin: metafacture/metafacture-core

private void writeResult() {
  final Compare compareBy = getCompare();
  switch (compareBy) {
  case ALL:
    getReceiver().process(new Triple(current.toString(), countPredicate , String.valueOf(count)));
    break;
  case OBJECT:
    getReceiver().process(new Triple(current.getObject(), countPredicate, String.valueOf(count)));
    break;
  case PREDICATE:
    getReceiver().process(new Triple(current.getPredicate(), countPredicate, String.valueOf(count)));
    break;
  case SUBJECT:
  default:
    getReceiver().process(new Triple(current.getSubject(), countPredicate, String.valueOf(count)));
    break;
  }
}
org.metafacture.framework.objectsTriple

Javadoc

Stores an immutable subject-predicate-object triple.

Most used methods

  • <init>
  • getObject
  • getSubject
  • getPredicate
  • compareTo
  • computeHashCode
  • getObjectType
  • read
  • toString
  • write

Popular in Java

  • Parsing JSON documents to java classes using gson
  • runOnUiThread (Activity)
  • putExtra (Intent)
  • setScale (BigDecimal)
  • ObjectMapper (com.fasterxml.jackson.databind)
    ObjectMapper provides functionality for reading and writing JSON, either to and from basic POJOs (Pl
  • FileOutputStream (java.io)
    An output stream that writes bytes to a file. If the output file exists, it can be replaced or appen
  • Proxy (java.net)
    This class represents proxy server settings. A created instance of Proxy stores a type and an addres
  • SimpleDateFormat (java.text)
    Formats and parses dates in a locale-sensitive manner. Formatting turns a Date into a String, and pa
  • ReentrantLock (java.util.concurrent.locks)
    A reentrant mutual exclusion Lock with the same basic behavior and semantics as the implicit monitor
  • JFrame (javax.swing)
  • CodeWhisperer alternatives
Tabnine Logo
  • Products

    Search for Java codeSearch for JavaScript code
  • IDE Plugins

    IntelliJ IDEAWebStormVisual StudioAndroid StudioEclipseVisual Studio CodePyCharmSublime TextPhpStormVimGoLandRubyMineEmacsJupyter NotebookJupyter LabRiderDataGripAppCode
  • Company

    About UsContact UsCareers
  • Resources

    FAQBlogTabnine AcademyTerms of usePrivacy policyJava Code IndexJavascript Code Index
Get Tabnine for your IDE now