content: /*
   * Copyright (C) 2005 DFKI GmbH. All rights reserved.
   */
  package marytts.modules;
  
  import java.io.IOException;
  import java.io.InputStream;
  import java.util.Locale;
  import java.util.Set;
  
  import marytts.datatypes.MaryDataType;
  import marytts.fst.FSTLookup;
  
  public class ProsodyGenericFST extends ProsodyGeneric {
  
      public ProsodyGenericFST(MaryDataType inputType, MaryDataType outputType,
                               Locale locale,
                               String tobipredFileName, String accentPriorities,
                               String syllableAccents, String paragraphDeclination) throws IOException {
          super(inputType, outputType, locale, tobipredFileName, accentPriorities,
                  syllableAccents, paragraphDeclination);
      }
  
  
      /**
       * Read a list from an external file. This implementation
       * can read from finite state transducer files (filenames ending in <code>.fst</code>).
       *
       * @param resourceName resource file in classpath from which to read the list; suffix identifies
       *                     list format.
       * @return An Object representing the list; checkList() must be able to
       * make sense of this. This implementation returns an FSTLookup for
       * .fst files or a Set for .txt files.
       * @throws IllegalArgumentException if the fileName suffix cannot be
       *                                  identified as a list file format.
       */
      @Override
      protected Object readListFromResource(String resourceName) throws IOException {
          String suffix = resourceName.substring(resourceName.length() - 4, resourceName.length());
          if (suffix.equals(".fst")) { // FST file
              InputStream resourceStream = this.getClass().getResourceAsStream("prosody/" + resourceName);
              // put the external FST on the map
              return new FSTLookup(resourceStream, resourceName, "ISO-8859-1");
          } else {
              return super.readListFromResource(resourceName);
          }
      }
  
      /**
       * Checks if tokenValue is contained in list.
       * This implementation is able to deal with list types
       * represented as FSTLookups or as Sets.
       *
       * @param currentVal the condition to check; can be either <code>INLIST:</code>
       *                   or <code>!INLIST:</code> followed by the list name to check.
       * @param tokenValue value to look up in the list
       * @return whether or not tokenValue is contained in the list.
       */
      @Override
      protected boolean checkList(String currentVal, String tokenValue) {
          if (currentVal == null || tokenValue == null) {
              throw new NullPointerException("Received null argument");
          }
          if (!currentVal.startsWith("INLIST") && !currentVal.startsWith("!INLIST")) {
              throw new IllegalArgumentException("currentVal does not start with INLIST or !INLIST");
          }
          boolean negation = currentVal.startsWith("!");
          String listName = currentVal.substring(currentVal.indexOf(":") + 1);
          Object listObj = listMap.get(listName);
          if (listObj == null) return false; // no list found
          boolean contains;
          if (listObj instanceof Set) {
              Set set = (Set) listObj;
              contains = set.contains(tokenValue);
          } else if (listObj instanceof FSTLookup) {
              FSTLookup fst = (FSTLookup) listObj;
              contains = fst.lookup(tokenValue).length > 0;
          } else {
              throw new IllegalArgumentException("Unknown list representation: " + listObj);
          }
          return !(contains && negation || !contains && !negation);
      }
  
  }
  