private int getClaimantCount(final ContentClaim claim) { if (claim == null) { return 0; } final ResourceClaim resourceClaim = claim.getResourceClaim(); if (resourceClaim == null) { return 0; } return claimManager.getClaimantCount(resourceClaim); }
public void flush(final ContentClaim contentClaim) throws IOException { if (contentClaim == null) { return; } flush(contentClaim.getResourceClaim()); }
private boolean isDestructable(final ContentClaim claim) { if (claim == null) { return false; } final ResourceClaim resourceClaim = claim.getResourceClaim(); if (resourceClaim == null) { return false; } return !resourceClaim.isInUse(); }
@Override public Object getFieldValue(final String fieldName) { switch (fieldName) { case ContentClaimSchema.CLAIM_CONTAINER: return resourceClaim.getContainer(); case ContentClaimSchema.CLAIM_SECTION: return resourceClaim.getSection(); case ContentClaimSchema.CLAIM_IDENTIFIER: return resourceClaim.getId(); case ContentClaimSchema.LOSS_TOLERANT: return resourceClaim.isLossTolerant(); } return null; }
@Override public int compareTo(final ContentClaim o) { final int resourceComp = resourceClaim.compareTo(o.getResourceClaim()); if (resourceComp != 0) { return resourceComp; } return Long.compare(offset, o.getOffset()); }
@Override public Object getFieldValue(final String fieldName) { switch (fieldName) { case ContentClaimSchema.RESOURCE_CLAIM: return resourceClaimFieldMap; case ContentClaimSchema.CONTENT_CLAIM_LENGTH: return contentClaim.getLength(); case ContentClaimSchema.CONTENT_CLAIM_OFFSET: return contentClaimOffset; case ContentClaimSchema.RESOURCE_CLAIM_OFFSET: return contentClaim.getOffset(); default: return null; } }
@Override public int decrementClaimantCount(final ContentClaim claim) { if (claim == null) { return 0; } return resourceClaimManager.decrementClaimantCount(claim.getResourceClaim()); }
private void markDestructable(final ContentClaim contentClaim) { if (contentClaim == null) { return; } final ResourceClaim resourceClaim = contentClaim.getResourceClaim(); if (resourceClaim == null) { return; } claimManager.markDestructable(resourceClaim); }
private ContentClaim createClaim(final String container, final String section, final String identifier, final Long offset) { if (container == null || section == null || identifier == null) { return null; } final ResourceClaim resourceClaim = resourceClaimManager.newResourceClaim(container, section, identifier, false, false); return new StandardContentClaim(resourceClaim, offset == null ? 0L : offset.longValue()); }
@Override public boolean isInUse() { // Note that it is critical here that we always check isWritable() BEFORE checking // the claimant count. This is due to the fact that if the claim is in fact writable, the claimant count // could increase. So if we first check claimant count and that is 0, and then we check isWritable, it may be // that the claimant count has changed to 1 before checking isWritable. // However, if isWritable() is false, then the only way that the claimant count can increase is if a FlowFile referencing // the Resource Claim is cloned. In this case, though, the claimant count has not become 0. // Said another way, if isWritable() == false, then the claimant count can never increase from 0. return isWritable() || claimManager.getClaimantCount(this) > 0; } }
@Override public int getClaimantCount(final ContentClaim claim) { if (claim == null) { return 0; } final ContentClaim backupClaim = getBackupClaim(claim); if (backupClaim == null) { return claimManager.getClaimantCount(resolveClaim(claim).getResourceClaim()); } else { return getBackupRepository().getClaimantCount(backupClaim); } }
@Override public ResourceClaim newResourceClaim(final String container, final String section, final String id, final boolean lossTolerant, final boolean writable) { final StandardResourceClaim claim = new StandardResourceClaim(this, container, section, id, lossTolerant); if (!writable) { claim.freeze(); } return claim; }
@Override public ResourceClaim getResourceClaim(final String container, final String section, final String id) { final ResourceClaim tempClaim = new StandardResourceClaim(this, container, section, id, false); final ClaimCount count = claimantCounts.get(tempClaim); return (count == null) ? null : count.getClaim(); }
@Override public int incrementClaimaintCount(final ContentClaim claim) { if (claim == null) { return 0; } final ContentClaim backupClaim = getBackupClaim(claim); if (backupClaim == null) { return claimManager.incrementClaimantCount(resolveClaim(claim).getResourceClaim()); } else { return getBackupRepository().incrementClaimaintCount(backupClaim); } }
protected int incrementClaimantCount(final ResourceClaim resourceClaim, final boolean newClaim) { if (resourceClaim == null) { return 0; } return resourceClaimManager.incrementClaimantCount(resourceClaim, newClaim); }
private void markDestructable(final ResourceClaim resourceClaim) { if (resourceClaim == null) { return; } claimManager.markDestructable(resourceClaim); }
@Override public int incrementClaimantCount(final ResourceClaim claim) { return incrementClaimantCount(claim, false); }
public void flush() throws IOException { forEachStream(OutputStream::flush); }
@Override public void write(final byte[] b) throws IOException { write(b, 0, b.length); }
@Override public int getClaimantCount(final ContentClaim claim) { if (claim == null) { return 0; } return resourceClaimManager.getClaimantCount(claim.getResourceClaim()); }