1 /* 2 * Licensed to the Apache Software Foundation (ASF) under one or more 3 * contributor license agreements. See the NOTICE file distributed with 4 * this work for additional information regarding copyright ownership. 5 * The ASF licenses this file to You under the Apache License, Version 2.0 6 * (the "License"); you may not use this file except in compliance with 7 * the License. You may obtain a copy of the License at 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the License for the specific language governing permissions and 15 * limitations under the License. 16 */ 17 18 package org.apache.any23.writer; 19 20 import org.apache.any23.extractor.ExtractionContext; 21 import org.eclipse.rdf4j.model.IRI; 22 import org.eclipse.rdf4j.model.Resource; 23 import org.eclipse.rdf4j.model.Value; 24 25 /** 26 * This class connects a {@link TripleHandler} to a {@link TripleWriter} by writing received data. 27 * 28 * @author Hans Brende (hansbrende@apache.org) 29 */ 30 public abstract class TripleWriterHandler implements TripleHandler, TripleWriter { 31 32 /** 33 * Writers may override this method to handle a "receiveTriple" extraction event. The default implementation calls: 34 * 35 * <pre> 36 * {@code this.writeTriple(s, p, o, context == null || g != null ? g : context.getDocumentIRI())} 37 * </pre> 38 * 39 * @param s 40 * the subject received 41 * @param p 42 * the predicate received 43 * @param o 44 * the object received 45 * @param g 46 * the graph name received, or null 47 * @param context 48 * the extraction context 49 * 50 * @throws TripleHandlerException 51 * if there was an error responding to a received triple 52 */ 53 @Override 54 public void receiveTriple(Resource s, IRI p, Value o, IRI g, ExtractionContext context) 55 throws TripleHandlerException { 56 writeTriple(s, p, o, context == null || g != null ? g : context.getDocumentIRI()); 57 } 58 59 /** 60 * Writers may override this method to handle a "receiveNamespace" extraction event. The default implementation 61 * calls: 62 * 63 * <pre> 64 * {@code this.writeNamespace(prefix, uri)} 65 * </pre> 66 * 67 * @param prefix 68 * namespace prefix. 69 * @param uri 70 * namespace <i>IRI</i>. 71 * @param context 72 * the extraction context 73 * 74 * @throws TripleHandlerException 75 * if there was an error responding to the received namepsace. 76 */ 77 @Override 78 public void receiveNamespace(String prefix, String uri, ExtractionContext context) throws TripleHandlerException { 79 writeNamespace(prefix, uri); 80 } 81 82 /** 83 * Writers may override this method to handle a "startDocument" extraction event. The default implementation does 84 * nothing. 85 * 86 * @param documentIRI 87 * the name of the document that was started 88 * 89 * @throws TripleHandlerException 90 * if an error occurred while responding to a "startDocument" extraction event. 91 */ 92 @Override 93 public void startDocument(IRI documentIRI) throws TripleHandlerException { 94 } 95 96 /** 97 * Writers may override this method to handle an "openContext" extraction event. The default implementation does 98 * nothing. 99 * 100 * @param context 101 * the context that was opened 102 * 103 * @throws TripleHandlerException 104 * if an error occurred while responding to a "startDocument" extraction event. 105 */ 106 @Override 107 public void openContext(ExtractionContext context) throws TripleHandlerException { 108 } 109 110 /** 111 * Writers may override this method to handle a "closeContext" extraction event. The default implementation does 112 * nothing. 113 * 114 * @param context 115 * the context to be closed. 116 * 117 * @throws TripleHandlerException 118 * if an error occurred while responding to a "closeContext" extraction event. 119 */ 120 @Override 121 public void closeContext(ExtractionContext context) throws TripleHandlerException { 122 } 123 124 /** 125 * Writers may override this method to handle an "endDocument" extraction event. The default implementation does 126 * nothing. 127 * 128 * @param documentIRI 129 * the document IRI. 130 * 131 * @throws TripleHandlerException 132 * if an error occurred while responding to a "endDocument" extraction event. 133 */ 134 @Override 135 public void endDocument(IRI documentIRI) throws TripleHandlerException { 136 } 137 138 /** 139 * Writers may override this method to handle a "setContentLength" extraction event. The default implementation does 140 * nothing. 141 * 142 * @param contentLength 143 * length of the content being processed. 144 */ 145 @Override 146 public void setContentLength(long contentLength) { 147 } 148 149 }