Reads a list of symbol descriptions

@param filename
@return list of SymbolDescriptions
@throws IOException
491649
public static List<SymbolDescription> readSymbolDescriptions()
			throws IOException {
		String filename = "importcategories.txt";
		List<SymbolDescription> list = new ArrayList<>();
		List<String[]> lines = readArray(filename);
		String category = "";
		String subCategory = null;
		for (String[] array : lines) {
			if (array.length > 0) {
				String mainItem = array[0];
				if (mainItem.startsWith("[")) {
					category = mainItem;
					subCategory = null;
				} else if (mainItem.startsWith("<")) {
					subCategory = mainItem;
				} else {
					String description = null;
					if (array.length > 1) {
						description = array[1];
					}
					list.add(new SymbolDescription(mainItem, Optional
							.fromNullable(description), category, Optional
							.fromNullable(subCategory)));
				}
			}
		}
		return list;
	}
1231023
public static List<String> readBuildConfigFile( String fileName, File outputDir )
        throws IOException
    {
        List<String> arguments = new ArrayList<String>();
        File argFile = new File( outputDir, fileName );
        if ( FileUtils.fileExists( argFile.getAbsolutePath() ) )
        {
            FileReader reader = new FileReader( argFile );
            BufferedReader bufRead = new BufferedReader( reader );
            String line = null;
            do
            {
                line = bufRead.readLine();
                if ( null != line )
                {
                    arguments.add( line );
                }
            }
            while ( null != line );
        }
        return arguments;
    }
617500
public static Map<String, List<double[]>> readUCRData(String fileName)
      throws IOException, NumberFormatException {

    Map<String, List<double[]>> res = new HashMap<String, List<double[]>>();

    BufferedReader br = new BufferedReader(new FileReader(new File(fileName)));
    String line = "";
    while ((line = br.readLine()) != null) {
      if (line.trim().length() == 0) {
        continue;
      }
      String[] split = line.trim().split("[\\,\\s]+");

      String label = split[0];
      Double num = parseValue(label);
      String seriesType = label;
      if (!(Double.isNaN(num))) {
        seriesType = String.valueOf(num.intValue());
      }
      double[] series = new double[split.length - 1];
      for (int i = 1; i < split.length; i++) {
        series[i - 1] = Double.valueOf(split[i].trim()).doubleValue();
      }

      if (!res.containsKey(seriesType)) {
        res.put(seriesType, new ArrayList<double[]>());
      }

      res.get(seriesType).add(series);
    }

    br.close();
    return res;

  }
1112700
public static List<String> readFileToList(String _fileName) {
        List<String> localText = getTextfileFromUrl(_fileName);
        return localText;
    }
579350
def _readfile(cls, filename):
        
        f = codecs.open(filename, encoding='utf-8')
        filedata = f.read()
        f.close()
        tokenz = LM.tokenize(filedata, mode='c')
        #print tokenz
        return tokenz
417374
public List<String> readList() throws IOException
   {
      InputStream in = PrivilegedFileHelper.fileInputStream(logFile);
      try
      {
         List<String> list = new ArrayList<String>();
         BufferedReader reader = new BufferedReader(new InputStreamReader(in));
         String line;
         while ((line = reader.readLine()) != null)
         {
            if (!line.matches("\\x00++"))
            {
               list.add(line);
            }
         }
         return list;

      }
      finally
      {
         if (in != null)
         {
            try
            {
               in.close();
            }
            catch (IOException e)
            {
               LOG.warn("Exception while closing error log: " + e.toString());
            }
         }
      }
   }
405313
static private String readFile(String fileName) throws IOException {
    BufferedReader br = new BufferedReader(new FileReader(fileName));
    try {
      StringBuilder sb = new StringBuilder();
      String line = br.readLine();

      while (line != null) {
        sb.append(line);
        sb.append("\n");
        line = br.readLine();
      }
      return sb.toString();
    } finally {
      br.close();
    }
  }
522251
public List<String> getFileLinesAsList(File f) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(
            new DataInputStream(new FileInputStream(f))));
        List<String> result = new LinkedList<String>();
        String strLine;
        while ((strLine = br.readLine()) != null) {
            result.add(strLine);
        }
        br.close();
        return result;

    }
8753
public List<Decl.Named> getRegisteredDeclarations(QualifiedName name) {
		Group g = symbolTable.get(name.getUnit());
		if (g != null) {
			return g.getRegisteredDeclarations(name.getName());
		} else {
			return Collections.EMPTY_LIST;
		}
	}
666146
public static String readCharacters(
                    final File file
                    )
    throws IOException
    {
        Reader  reader = new BufferedReader( new InputStreamReader(
                        new FileInputStream( file ), Charset.forName( "UTF-8" ) ) );
        // Note:
        // The character set should be specified to parse XML
        // containing Japanese characters.

        StringWriter  sw = new StringWriter();
        Writer  writer = new BufferedWriter( sw );

        copy( reader, writer );

        String  characters = sw.toString();

        return characters;
    }
499142
public static ImmutableList<File> loadFileList(final File fileList) throws IOException {
    return loadFileList(Files.asCharSource(fileList, Charsets.UTF_8));
  }
1339249
private List<String> readFile(File file) throws Exception {
        List<String> content = new ArrayList<>(100);
        try (BufferedReader is = new BufferedReader(new InputStreamReader(new FileInputStream(file), "UTF-8"))) {
            String line;
            while ((line = is.readLine()) != null) {
                content.add(line);
            }
            return content;
        }
    }
957206
public static List<String> readLines(File file) throws IOException {
        return IOGroovyMethods.readLines(newReader(file));
    }
1347185
def _set_symbols(self, file_name, configure):
        

        self.symbols = []
        if file_name is None:
            file_name = os.path.join(os.path.dirname(os.path.dirname(
                os.path.dirname(os.path.realpath(__file__))
            )), 'symbols.xml')
        xmldoc = minidom.parse(file_name)
        symbols_xml = xmldoc.getElementsByTagName(
            'symbols'
        )[0].getElementsByTagName('symbol')
        for symbol_xml in symbols_xml:
            self.symbols.append({
                'symbol': symbol_xml.attributes['symbol'].value,
                'description': configure.get_parameter(
                    symbol_xml.attributes['description'].value
                )
            })
1095482
public static List<Formula> readCNF(final String fileName, final FormulaFactory f) throws IOException {
    return readCNF(new File(fileName), f, "v");
  }
1087641
public static List<String> readLines(File targetFile, String charsetName) {
        return readLines(targetFile.toPath(), charsetName);
    }
691939
public static String readFile(String fileName) throws IOException {
        logger.entering(fileName);
        Preconditions.checkArgument(StringUtils.isNotBlank(fileName), "File name cannot be null (or) empty.");
        StringBuilder output = new StringBuilder();
        try (BufferedReader buffreader = new BufferedReader(new InputStreamReader(loadFile(fileName),
                Charset.forName("UTF-8")))) {
            String line = null;
            while ((line = buffreader.readLine()) != null) {
                output.append(line);
            }
        }
        logger.exiting(output);
        return output.toString();
    }