marytts.datatypes.MaryDataType Maven / Gradle / Ivy
The newest version!
/**
* Copyright 2000-2006 DFKI GmbH.
* All Rights Reserved. Use is subject to license terms.
*
* This file is part of MARY TTS.
*
* MARY TTS is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, version 3 of the License.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program. If not, see knownDataTypes;
private static Map dataTypesByName;
private static boolean registrationComplete;
private static Logger logger;
/**
* Create a new, empty data type registry.
*/
static {
knownDataTypes = new LinkedList();
dataTypesByName = new HashMap();
registrationComplete = false;
logger = MaryUtils.getLogger("MaryDataType");
}
public static void registerDataType(MaryDataType type) {
if (!dataTypesByName.containsKey(type.name())) {
dataTypesByName.put(type.name(), type);
knownDataTypes.add(type);
}
}
/**
* Determine whether or not the registration is complete. When the registration is not (yet) complete, calls to
*
*
* @return false when the registration is still open, true when it is complete.
*/
public static boolean getRegistrationComplete() {
return registrationComplete;
}
/**
* Indicate that the registration is now complete. No further calls to registerModules() will be possible.
*
* @throws IllegalStateException
* if called when registration was already completed before.
*/
public static void setRegistrationComplete() throws IllegalStateException {
if (registrationComplete)
throw new IllegalStateException("Registration has already completed, cannot do that a second time");
sortDataTypes();
registrationComplete = true;
}
private static void sortDataTypes() {
Collections.sort(knownDataTypes, new Comparator() {
public int compare(MaryDataType one, MaryDataType two) {
// First, sort by input type / output type status:
if (one.isInputType() && !two.isInputType()) {
return -1; // one is first
} else if (two.isInputType() && !one.isInputType()) {
return 1; // two is first
// Now, either both or none of them are input types
} else if (one.isOutputType() && !two.isOutputType()) {
return 1; // two is first
} else if (two.isOutputType() && !one.isOutputType()) {
return -1; // one is first
} else if (one.isInputType() && two.isInputType() && !one.isOutputType() && !two.isOutputType()) {
// Both are only input types -> if one is plain text, the other XML,
// text goes first
if (!one.isXMLType() && two.isXMLType()) {
return -1; // one is first
} else if (!two.isXMLType() && one.isXMLType()) {
return 1; // two is first
}
} else if (!one.isInputType() && !two.isInputType() && !one.isOutputType() && !two.isOutputType()) {
return 0; // both are equal
}
if (one.isMaryXML() && two.isXMLType() && !two.isMaryXML()) {
return 1; // xml input format two is first
} else if (two.isMaryXML() && one.isXMLType() && !one.isMaryXML()) {
return -1; // xml input format one is first
}
if (one.name().equals("TEXT") && !two.name().equals("TEXT")) {
return -1; // one is first
} else if (two.name().equals("TEXT") && !one.name().equals("TEXT")) {
return 1; // two is first
}
if (one.name().startsWith("TEXT") && !two.name().startsWith("TEXT")) {
return -1; // one is first
} else if (two.name().startsWith("TEXT") && !one.name().startsWith("TEXT")) {
return 1; // two is first
}
if (ModuleRegistry.modulesRequiredForProcessing(one, two, null) == null) {
// if (modulesRequiredForProcessing(two, one, null) == null)
// System.err.println("cannot compare the datatypes " + one.name() + " and " + two.name());
return 1; // two is first
} else {
return -1; // one is first
}
}
});
// A test said this was sorted in 12 ms, so no harm done.
}
/**
* Provide the names of all registered data types that can be used as input.
*
* @return a vector containing the string names of data types.
* @throws IllegalStateException
* if this method is called while registration is ongoing.
*/
public static Vector getInputTypeStrings() {
if (!registrationComplete)
throw new IllegalStateException("Cannot inquire about data types while registration is ongoing");
Vector result = new Vector(10);
for (MaryDataType t : knownDataTypes) {
if (t.isInputType())
result.add(t.name());
}
return result;
}
/**
* Provide the names of all registered data types that can be used as output.
*
* @return a vector containing the string names of data types.
* @throws IllegalStateException
* if this method is called while registration is ongoing.
*/
public static Vector getOutputTypeStrings() {
if (!registrationComplete)
throw new IllegalStateException("Cannot inquire about data types while registration is ongoing");
Vector result = new Vector(10);
for (MaryDataType t : knownDataTypes) {
if (t.isOutputType())
result.add(t.name());
}
return result;
}
/**
* Provide the list of all registered data types that can be used as input.
*
* @return a list containing data types.
* @throws IllegalStateException
* if this method is called while registration is ongoing.
*/
public static List getInputTypes() {
if (!registrationComplete)
throw new IllegalStateException("Cannot inquire about data types while registration is ongoing");
Vector result = new Vector(10);
for (MaryDataType t : knownDataTypes) {
if (t.isInputType())
result.add(t);
}
return result;
}
/**
* Provide the list of all registered data types that can be used as output.
*
* @return a list containing data types.
* @throws IllegalStateException
* if this method is called while registration is ongoing.
*/
public static List getOutputTypes() {
if (!registrationComplete)
throw new IllegalStateException("Cannot inquire about data types while registration is ongoing");
Vector result = new Vector(10);
for (MaryDataType t : knownDataTypes) {
if (t.isOutputType())
result.add(t);
}
return result;
}
/**
* Look up a data type by name.
*
* @param name
* the name of the data type
* @return the requested data type, or null if there is no known data type with the given name
*/
public static MaryDataType get(String name) {
if (!registrationComplete)
throw new IllegalStateException("Cannot inquire about data types while registration is ongoing");
return dataTypesByName.get(name);
}
/**
* Provide a list of known data types, i.e. of data types used by any of the known modules, partially sorted in the order of
* processing.
*
* @return a list of all known data types
*/
public static List getDataTypes() {
if (!registrationComplete)
throw new IllegalStateException("Cannot inquire about data types while registration is ongoing");
return Collections.unmodifiableList(knownDataTypes);
}
// ///////////////////////////////////////////////////////////////////
// //////////////////////// Example texts ////////////////////////////
// ///////////////////////////////////////////////////////////////////
/**
* Get an example text for the given type and the given locale.
*
* @param type
* type
* @param locale
* locale
* @return an example text suitable for type and locale, or null if none is available.
*/
public static String getExampleText(MaryDataType type, Locale locale) {
// Convention:
// - example texts for locale null are Resources in same package as type;
// - example texts for a given locale are in marytts.language..datatypes.
// - example texts are always encoded as UTF-8.
InputStream exampleStream;
if (locale == null) {
exampleStream = type.getClass().getResourceAsStream(type.name() + ".example");
} else {
exampleStream = type.getClass()
.getResourceAsStream(
"/marytts/language/" + locale.toString() + "/datatypes/" + type.name() + "." + locale.toString()
+ ".example");
}
if (exampleStream == null)
return null;
try {
return IOUtils.toString(exampleStream, "UTF-8");
} catch (IOException e) {
logger.debug("Could not get example text for " + type.name() + " / locale " + locale);
return null;
}
}
// ///////////////////////////////////////////////////////////////////
// //////////////////////// Helper: Traits ///////////////////////////
// ///////////////////////////////////////////////////////////////////
public static class Traits {
private boolean isTextType; // alternative: binary data
private boolean isXMLType;
private boolean isMaryXML;
private boolean isUtterances;
public Traits(boolean isTextType, boolean isXMLType, boolean isMaryXML, boolean isUtterances) {
// Some plausibility checks:
if (isMaryXML)
assert isXMLType;
if (isXMLType)
assert isTextType;
if (isTextType)
assert !isUtterances;
this.isTextType = isTextType;
this.isXMLType = isXMLType;
this.isMaryXML = isMaryXML;
this.isUtterances = isUtterances;
}
public boolean isTextType() {
return isTextType;
}
public boolean isXMLType() {
return isXMLType;
}
public boolean isMaryXML() {
return isMaryXML;
}
public boolean isUtterances() {
return isUtterances;
}
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy