Java tutorial
/* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.apache.tika.parser.ctakes; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.io.Serializable; import java.util.Properties; import static org.apache.commons.io.output.NullOutputStream.NULL_OUTPUT_STREAM; /** * Configuration for {@see CTAKESContentHandler}. * * This class allows to enable cTAKES and set its parameters. */ public class CTAKESConfig implements Serializable { /** * Serial version UID */ private static final long serialVersionUID = -1599741171775528923L; // Path to XML descriptor for AnalysisEngine private String aeDescriptorPath = "/ctakes-core/desc/analysis_engine/SentencesAndTokensAggregate.xml"; // UMLS username private String UMLSUser = ""; // UMLS password private String UMLSPass = ""; // Enables formatted output private boolean prettyPrint = true; // Type of cTAKES (UIMA) serializer private CTAKESSerializer serializerType = CTAKESSerializer.XMI; // OutputStream object used for CAS serialization private OutputStream stream = NULL_OUTPUT_STREAM; // Enables CAS serialization private boolean serialize = false; // Enables text analysis using cTAKES private boolean text = true; // List of metadata to analyze using cTAKES private String[] metadata = null; // List of annotation properties to add to metadata in addition to text covered by an annotation private CTAKESAnnotationProperty[] annotationProps = null; // Character used to separate the annotation properties into metadata private char separatorChar = ':'; /** * Default constructor. */ public CTAKESConfig() { init(this.getClass().getResourceAsStream("CTAKESConfig.properties")); } /** * Loads properties from InputStream and then tries to close InputStream. * @param stream {@see InputStream} object used to read properties. */ public CTAKESConfig(InputStream stream) { init(stream); } private void init(InputStream stream) { if (stream == null) { return; } Properties props = new Properties(); try { props.load(stream); } catch (IOException e) { // TODO warning } finally { if (stream != null) { try { stream.close(); } catch (IOException ioe) { // TODO warning } } } setAeDescriptorPath(props.getProperty("aeDescriptorPath", getAeDescriptorPath())); setUMLSUser(props.getProperty("UMLSUser", getUMLSUser())); setUMLSPass(props.getProperty("UMLSPass", getUMLSPass())); setText(Boolean.valueOf(props.getProperty("text", Boolean.toString(isText())))); setMetadata(props.getProperty("metadata", getMetadataAsString()).split(",")); setAnnotationProps(props.getProperty("annotationProps", getAnnotationPropsAsString()).split(",")); setSeparatorChar(props.getProperty("separatorChar", Character.toString(getSeparatorChar())).charAt(0)); } /** * Returns the path to XML descriptor for AnalysisEngine. * @return the path to XML descriptor for AnalysisEngine. */ public String getAeDescriptorPath() { return aeDescriptorPath; } /** * Returns the UMLS username. * @return the UMLS username. */ public String getUMLSUser() { return UMLSUser; } /** * Returns the UMLS password. * @return the UMLS password. */ public String getUMLSPass() { return UMLSPass; } /** * Returns {@code true} if formatted output is enabled, {@code false} otherwise. * @return {@code true} if formatted output is enabled, {@code false} otherwise. */ public boolean isPrettyPrint() { return prettyPrint; } /** * Returns the type of cTAKES (UIMA) serializer used to write the CAS. * @return the type of cTAKES serializer. */ public CTAKESSerializer getSerializerType() { return serializerType; } /** * Returns an {@see OutputStream} object used write the CAS. * @return {@see OutputStream} object used write the CAS. */ public OutputStream getOutputStream() { return stream; } /** * Returns {@code true} if CAS serialization is enabled, {@code false} otherwise. * @return {@code true} if CAS serialization output is enabled, {@code false} otherwise. */ public boolean isSerialize() { return serialize; } /** * Returns {@code true} if content text analysis is enabled {@code false} otherwise. * @return {@code true} if content text analysis is enabled {@code false} otherwise. */ public boolean isText() { return text; } /** * Returns an array of metadata whose values will be analyzed using cTAKES. * @return an array of metadata whose values will be analyzed using cTAKES. */ public String[] getMetadata() { return metadata; } /** * Returns a string containing a comma-separated list of metadata whose values will be analyzed using cTAKES. * @return a string containing a comma-separated list of metadata whose values will be analyzed using cTAKES. */ public String getMetadataAsString() { if (metadata == null) { return ""; } StringBuilder sb = new StringBuilder(); for (int i = 0; i < metadata.length; i++) { sb.append(metadata[i]); if (i < metadata.length - 1) { sb.append(","); } } return sb.toString(); } /** * Returns an array of {@see CTAKESAnnotationProperty}'s that will be included into cTAKES metadata. * @return an array of {@see CTAKESAnnotationProperty}'s that will be included into cTAKES metadata. */ public CTAKESAnnotationProperty[] getAnnotationProps() { return annotationProps; } /** * Returns a string containing a comma-separated list of {@see CTAKESAnnotationProperty} names that will be included into cTAKES metadata. * @return */ public String getAnnotationPropsAsString() { StringBuilder sb = new StringBuilder(); sb.append("coveredText"); if (annotationProps != null) { for (CTAKESAnnotationProperty property : annotationProps) { sb.append(separatorChar); sb.append(property.getName()); } } return sb.toString(); } /** * Returns the separator character used for annotation properties. * @return the separator character used for annotation properties. */ public char getSeparatorChar() { return separatorChar; } /** * Sets the path to XML descriptor for AnalysisEngine. * @param aeDescriptorPath the path to XML descriptor for AnalysisEngine. */ public void setAeDescriptorPath(String aeDescriptorPath) { this.aeDescriptorPath = aeDescriptorPath; } /** * Sets the UMLS username. * @param uMLSUser the UMLS username. */ public void setUMLSUser(String uMLSUser) { this.UMLSUser = uMLSUser; } /** * Sets the UMLS password. * @param uMLSPass the UMLS password. */ public void setUMLSPass(String uMLSPass) { this.UMLSPass = uMLSPass; } /** * Enables the formatted output for serializer. * @param prettyPrint {@true} to enable formatted output, {@code false} otherwise. */ public void setPrettyPrint(boolean prettyPrint) { this.prettyPrint = prettyPrint; } /** * Sets the type of cTAKES (UIMA) serializer used to write CAS. * @param serializerType the type of cTAKES serializer. */ public void setSerializerType(CTAKESSerializer serializerType) { this.serializerType = serializerType; } /** * Sets the {@see OutputStream} object used to write the CAS. * @param stream the {@see OutputStream} object used to write the CAS. */ public void setOutputStream(OutputStream stream) { this.stream = stream; } /** * Enables CAS serialization. * @param serialize {@true} to enable CAS serialization, {@code false} otherwise. */ public void setSerialize(boolean serialize) { this.serialize = serialize; } /** * Enables content text analysis using cTAKES. * @param text {@true} to enable content text analysis, {@code false} otherwise. */ public void setText(boolean text) { this.text = text; } /** * Sets the metadata whose values will be analyzed using cTAKES. * @param metadata the metadata whose values will be analyzed using cTAKES. */ public void setMetadata(String[] metadata) { this.metadata = metadata; } /** * Sets the {@see CTAKESAnnotationProperty}'s that will be included into cTAKES metadata. * @param annotationProps the {@see CTAKESAnnotationProperty}'s that will be included into cTAKES metadata. */ public void setAnnotationProps(CTAKESAnnotationProperty[] annotationProps) { this.annotationProps = annotationProps; } /** * ets the {@see CTAKESAnnotationProperty}'s that will be included into cTAKES metadata. * @param annotationProps the {@see CTAKESAnnotationProperty}'s that will be included into cTAKES metadata. */ public void setAnnotationProps(String[] annotationProps) { CTAKESAnnotationProperty[] properties = new CTAKESAnnotationProperty[annotationProps.length]; for (int i = 0; i < annotationProps.length; i++) { properties[i] = CTAKESAnnotationProperty.valueOf(annotationProps[i]); } setAnnotationProps(properties); } /** * Sets the separator character used for annotation properties. * @param separatorChar the separator character used for annotation properties. */ public void setSeparatorChar(char separatorChar) { this.separatorChar = separatorChar; } }