Java Code Examples for java.io.Reader

public void read(BluetoothSocket socket) throws IOException {
  address=socket.getRemoteDevice().getAddress();
  InputStream stream=socket.getInputStream();
  final Reader finalReader=new InputStreamReader(stream);
  CharStreams.readLines(inputSupplier(finalReader),lineProcessor());
}
 

public static String getVersion(){
  URL versionResource=Aardvark.class.getResource("/gw/vark/version.txt");
  try {
    Reader reader=StreamUtil.getInputStreamReader(versionResource.openStream());
    String version=StreamUtil.getContent(reader).trim();
    return "Aardvark version " + version;
  }
 catch (  IOException e) {
    throw GosuExceptionUtil.forceThrow(e);
  }
}
 

private static String clobToString(Clob clob){
  try {
    Reader r=clob.getCharacterStream();
    StringWriter sw=new StringWriter();
    copyStream(r,sw);
    return sw.toString();
  }
 catch (  Exception e) {
    throw new RuntimeException(e);
  }
}
 

/** 
 * Copy the contents of the specified input stream to the specified output stream, and ensure that both streams are closed before returning (even in the face of an exception).
 * @param resourceInfo The ResourceInfo object
 * @param writer The writer to write to
 * @param range Range the client wanted to retrieve
 * @exception IOException if an input/output error occurs
 */
protected void copy(CacheEntry cacheEntry,PrintWriter writer,Range range) throws IOException {
  IOException exception=null;
  InputStream resourceInputStream=cacheEntry.resource.streamContent();
  Reader reader;
  if (fileEncoding == null) {
    reader=new InputStreamReader(resourceInputStream);
  }
 else {
    reader=new InputStreamReader(resourceInputStream,fileEncoding);
  }
  exception=copyRange(reader,writer,range.start,range.end);
  reader.close();
  if (exception != null)   throw exception;
}
 

/** 
 * Loads properties from the given file
 * @param path file path
 * @return properties
 * @throws IOException errors
 */
public Map<String,String> loadPropertiesFrom(String path) throws IOException {
  Reader reader=new FileReader(new File(path));
  Properties properties=new Properties();
  try {
    properties.load(reader);
  }
  finally {
    reader.close();
  }
  return toMap(properties);
}
 

/** 
 * Main function used for validations.
 * @param pathToJSON - where to find file with json to validate
 * @return true if schema valid and false if wrong
 * @throws IOException Signals that an I/O exception has occurred.
 */
public boolean ValidateJSON(String pathToJSON) throws IOException {
  JSONStack.clear();
  ErrorsStack.clear();
  first_try=true;
  Reader in=new InputStreamReader(new FileInputStream(pathToJSON),"UTF-8");
  JsonNode rootObj=JSONMapper.readTree(in);
  LinkedList<String> schemaStack=new LinkedList<String>();
  schemaStack.add(schemaName);
  return validateObject(rootObj,"JSON",schemaStack);
}
 

@Test(dependsOnGroups="constructor") public void testGetReader() throws Exception {
  Source s=SourceFactory.newClassPathSource(resourcePath,false);
  Reader r=s.getReader();
  assertNotNull(r);
  String content=readReader(r);
  assertNotNull(content);
  assertEquals(content,sourceText);
}
 

public void resetInput(){
  Reader oldReader=reader;
  String oldEncoding=inputEncoding;
  reset();
  reader=oldReader;
  inputEncoding=oldEncoding;
}
 

private static String read(Clob c) throws SQLException, IOException {
  StringBuilder sb=new StringBuilder((int)c.length());
  Reader r=c.getCharacterStream();
  char[] cbuf=new char[CLOBBUFFERSIZE];
  int n;
  while ((n=r.read(cbuf,0,cbuf.length)) != -1) {
    sb.append(cbuf,0,n);
  }
  return sb.toString();
}
 

@Override protected void onResume(){
  super.onResume();
  Toast.makeText(this,"Querying droidcon on Twitter",Toast.LENGTH_SHORT).show();
  Reader reader=new InputStreamReader(retrieveStream(url));
  SearchResponse response=new Gson().fromJson(reader,SearchResponse.class);
  List<String> searches=new ArrayList<String>();
  Iterator<Result> i=response.results.iterator();
  while (i.hasNext()) {
    Result res=(Result)i.next();
    searches.add(res.text);
  }
  ListView v=(ListView)findViewById(R.id.list);
  v.setAdapter(new ArrayAdapter<String>(this,android.R.layout.simple_list_item_1,searches.toArray(new String[searches.size()])));
}
 

public void writeInDirectory(String _targetDirectory) throws IOException, Exception {
  Reader srcText=new StringReader(getTargetContents());
  FileWriter out=new FileWriter(new File(_targetDirectory,targetFileName));
  int charsRead;
  while ((charsRead=srcText.read(data,0,BUFSIZE)) > 0) {
    out.write(data,0,charsRead);
  }
  out.close();
  srcText.close();
}
 

public static void setSplitPath(Configuration conf,String path) throws IOException {
  conf.set(SPLIT_CONFIG_KEY,path);
  LOG.warning(String.format("Setting Split path: %s",path));
  SplitFile splitFile=new SplitFile();
  Reader r=getSplitReader(conf);
  splitFile.read(r);
  for (int i=0; i < splitFile.size(); i++) {
    PartitionName.setPartitionOutputName(conf,i,splitFile.getName(i));
  }
  r.close();
}
 

public static Interpreter create(Class<?> clazz,String name){
  Reader reader=getValueAsStream(clazz,name);
  try {
    return create(reader);
  }
  finally {
    IoUtils.close(reader);
  }
}
 

public CoeffW(File auxdataTargetDir,boolean reshapedConvolution,int correctionMode) throws IOException {
  this.correctionMode=correctionMode;
  this.auxdataTargetDir=auxdataTargetDir;
  File wFile=new File(auxdataTargetDir,FILENAME);
  Reader reader=new FileReader(wFile);
  loadCoefficient(reader);
}
 

@Override public void onSimpleHttpCallSuccess(HttpResponse response){
  Reader reader=getJSONReader(response);
  JsonParser parser=new JsonParser();
  JsonObject jsonObject=parser.parse(reader).getAsJsonObject();
  callback.onBf3CallSuccess(overviewStatsObject(jsonObject));
}
 

/** 
 * Returns a  {@link BufferedReader} for the exact file name requested.
 */
private BufferedReader getReaderFromFullFilename(String filename) throws IOException {
  Reader reader;
  if (readFromJar)   reader=new InputStreamReader(StreamUtil.fromJar(this.getClass(),filename));
 else   reader=new FileReader(filename);
  return new BufferedReader(reader);
}
 

private void appendSuperPac(Writer writer) throws IOException {
  if (deriveFrom == null) {
    return;
  }
  Reader reader=new InputStreamReader((InputStream)deriveFrom.toURL().getContent());
  StringBuilder content=new StringBuilder();
  for (int i=reader.read(); i != -1; i=reader.read()) {
    content.append((char)i);
  }
  writer.append(content.toString().replace("FindProxyForURL","originalFindProxyForURL"));
  writer.append("\n");
}
 

private static String read(Clob c) throws SQLException, IOException {
  StringBuilder sb=new StringBuilder((int)c.length());
  Reader r=c.getCharacterStream();
  char[] cbuf=new char[CLOBBUFFERSIZE];
  int n;
  while ((n=r.read(cbuf,0,cbuf.length)) != -1) {
    sb.append(cbuf,0,n);
  }
  return sb.toString();
}
 

@Test public void testDeserialize() throws IOException {
  String consumerTypeString="{\"id\":15, \"label\":\"prosumer\"}";
  Reader reader=new StringReader(consumerTypeString);
  ConsumerType consumerType=new ConsumerTypeImporter(null).createObject(SyncUtils.getObjectMapper(new Config(new HashMap<String,String>())),reader);
  assertEquals("prosumer",consumerType.getLabel());
}
 

private static String read(Clob c) throws SQLException, IOException {
  StringBuilder sb=new StringBuilder((int)c.length());
  Reader r=c.getCharacterStream();
  char[] cbuf=new char[CLOBBUFFERSIZE];
  int n;
  while ((n=r.read(cbuf,0,cbuf.length)) != -1) {
    sb.append(cbuf,0,n);
  }
  return sb.toString();
}
 

private static StringBuilder read(File file) throws IOException {
  Reader reader=new BufferedReader(new FileReader(file));
  try {
    return readAll(reader);
  }
  finally {
    reader.close();
  }
}
 

/** 
 * copies the input stream to all writers (byte per byte)
 * @param data
 * @param writer
 * @param charSet
 * @return
 * @throws IOException
 */
public static int copyToWriter(final BufferedInputStream data,final BufferedWriter writer,final Charset charSet) throws IOException {
  final Reader sourceReader=new InputStreamReader(data,charSet);
  int count=0;
  int b;
  while ((b=sourceReader.read()) != -1) {
    count++;
    writer.write(b);
  }
  writer.flush();
  return count;
}
 

/** 
 * Save the content of an InputStream to a file in UTF8 with Signature
 * @param file file to save
 * @param stream InputStream to copy to the file
 * @param append append data
 * @throws IOException something goes wrong with the file
 */
public static void saveUTF8File(final File file,final InputStream stream,final boolean append) throws IOException {
  BufferedWriter bw=null;
  OutputStreamWriter osw=null;
  final FileOutputStream fos=new FileOutputStream(file,append);
  final Reader reader=new BufferedReader(new UnicodeReader(stream,"UTF-8"));
  try {
    if (file.length() < 1) {
      fos.write(UTF8_BOMS);
    }
    osw=new OutputStreamWriter(fos,"UTF-8");
    bw=new BufferedWriter(osw);
    if (reader != null) {
      for (int i=0; (i=reader.read()) > 0; ) {
        bw.write(i);
      }
    }
  }
  finally {
    try {
      bw.close();
      fos.close();
      reader.close();
    }
 catch (    final Exception ex) {
    }
  }
}
 

@Test public void testAddReaderNTriples() throws Exception {
  InputStream defaultGraphStream=new FileInputStream(TEST_DIR_PREFIX + "default-graph.nt");
  Reader defaultGraph=new InputStreamReader(defaultGraphStream,"UTF-8");
  testCon.add(defaultGraph,"",RDFFormat.NTRIPLES);
  defaultGraph.close();
  assertTrue("Repository should contain newly added statements",testCon.hasStatement(null,publisher,nameBob,false));
  assertTrue("Repository should contain newly added statements",testCon.hasStatement(null,publisher,nameAlice,false));
  InputStream graph1Stream=new FileInputStream(TEST_DIR_PREFIX + "graph1.nt");
  Reader graph1=new InputStreamReader(graph1Stream,"UTF-8");
  try {
    testCon.add(graph1,"",RDFFormat.NTRIPLES,context1);
  }
  finally {
    graph1.close();
  }
  InputStream graph2Stream=new FileInputStream(TEST_DIR_PREFIX + "graph2.nt");
  Reader graph2=new InputStreamReader(graph2Stream,"UTF-8");
  try {
    testCon.add(graph2,"",RDFFormat.NTRIPLES,context2);
  }
  finally {
    graph2.close();
  }
  assertTrue("alice should be known in the store",testCon.hasStatement(null,name,nameAlice,false));
  assertFalse("alice should not be known in context1",testCon.hasStatement(null,name,nameAlice,false,context1));
  assertTrue("alice should be known in context2",testCon.hasStatement(null,name,nameAlice,false,context2));
  assertTrue("bob should be known in the store",testCon.hasStatement(null,name,nameBob,false));
  assertFalse("bob should not be known in context2",testCon.hasStatement(null,name,nameBob,false,context2));
  assertTrue("bib should be known in context1",testCon.hasStatement(null,name,nameBob,false,context1));
}
 

public static String readFile(String path) throws IOException {
  FileInputStream is=new FileInputStream(path);
  try {
    StringBuilder sb=new StringBuilder();
    Reader reader=new BufferedReader(new InputStreamReader(is));
    char[] buffer=new char[8192];
    int read;
    while ((read=reader.read(buffer)) > 0) {
      sb.append(buffer,0,read);
    }
    return sb.toString();
  }
  finally {
    is.close();
  }
}
 

/** 
 * Get the entity content as a String, using the provided default character set if none is found in the entity. If defaultCharset is null, the default "UTF-8" is used.
 * @param is             input stream to be saved as string
 * @param defaultCharset character set to be applied if none found in the entity
 * @return the entity content as a String
 * @throws IllegalArgumentException if entity is null or if content length > Integer.MAX_VALUE
 * @throws IOException              if an error occurs reading the input stream
 */
public static String toString(final InputStream is,final String defaultCharset) throws IOException {
  if (is == null) {
    throw new IllegalArgumentException("InputStream may not be null");
  }
  String charset=defaultCharset;
  if (charset == null) {
    charset=DEFAULT_CONTENT_CHARSET;
  }
  Reader reader=new InputStreamReader(is,charset);
  StringBuilder sb=new StringBuilder();
  int l;
  try {
    char[] tmp=new char[4096];
    while ((l=reader.read(tmp)) != -1) {
      sb.append(tmp,0,l);
    }
  }
  finally {
    reader.close();
  }
  return sb.toString();
}
 

/** 
 * Get the entity content as a String, using the provided default character set if none is found in the entity. If defaultCharset is null, the default "ISO-8859-1" is used.
 * @param entity must not be null
 * @param defaultCharset character set to be applied if none found in the entity
 * @return the entity content as a String. May be null if{@link HttpEntity#getContent()} is null.
 * @throws ParseException if header elements cannot be parsed
 * @throws IllegalArgumentException if entity is null or if content length > Integer.MAX_VALUE
 * @throws IOException if an error occurs reading the input stream
 */
public static String toString(final HttpEntity entity,final String defaultCharset) throws IOException, ParseException {
  if (entity == null) {
    throw new IllegalArgumentException("HTTP entity may not be null");
  }
  InputStream instream=entity.getContent();
  if (instream == null) {
    return null;
  }
  try {
    if (entity.getContentLength() > Integer.MAX_VALUE) {
      throw new IllegalArgumentException("HTTP entity too large to be buffered in memory");
    }
    int i=(int)entity.getContentLength();
    if (i < 0) {
      i=4096;
    }
    String charset=getContentCharSet(entity);
    if (charset == null) {
      charset=defaultCharset;
    }
    if (charset == null) {
      charset=HTTP.DEFAULT_CONTENT_CHARSET;
    }
    Reader reader=new InputStreamReader(instream,charset);
    CharArrayBuffer buffer=new CharArrayBuffer(i);
    char[] tmp=new char[1024];
    int l;
    while ((l=reader.read(tmp)) != -1) {
      buffer.append(tmp,0,l);
    }
    return buffer.toString();
  }
  finally {
    instream.close();
  }
}
 

/** 
 * Parses the expression.  The root of the expression tree is returned by  {@link #getTopNode()} method
 * @throws com.meidusa.amoeba.sqljep.ParseException If there are errors in the expression then it fires the exception
 */
final public void parseExpression(Map<String,Integer> columnMapping,Map<String,Variable> variableMapping,final Map<String,PostfixCommand> funMap) throws ParseException {
  Reader reader=new StringReader(expression);
  Parser parser=new Parser(reader){
    @Override public boolean containsKey(    String key){
      return funMap.containsKey(key);
    }
    @Override public PostfixCommandI getFunction(    String name){
      return funMap.get(name);
    }
  }
;
  parser.setColumnMapping(columnMapping);
  parser.setVariableMapping(variableMapping);
  try {
    topNode=parser.parseStream(reader);
    errorList.clear();
    errorList.addAll(parser.getErrorList());
  }
 catch (  ParseException e) {
    topNode=null;
    errorList.add(e.getMessage());
  }
catch (  Throwable e) {
    throw new com.meidusa.amoeba.sqljep.ParseException(toString(),e);
  }
  if (hasError()) {
    throw new com.meidusa.amoeba.sqljep.ParseException(getErrorInfo());
  }
  if (debug) {
    ParserVisitor v=new ParserDumpVisitor();
    try {
      topNode.jjtAccept(v,null);
    }
 catch (    ParseException e) {
      errorList.add(e.getMessage());
      e.printStackTrace();
    }
  }
}
 

private String readFile(String name) throws IOException {
  final char[] buffer=new char[0x1000];
  StringBuilder out=new StringBuilder();
  InputStream is=getResources().getAssets().open(name);
  Reader in=new InputStreamReader(is,"UTF-8");
  int read;
  do {
    read=in.read(buffer,0,buffer.length);
    if (read > 0) {
      out.append(buffer,0,read);
    }
  }
 while (read >= 0);
  return out.toString();
}
 

/** 
 * Read all the data from the given stream, and close it.
 * @return null if from is null, or the data from the stream converted to aString
 */
public static String readAll(InputStream from,String encoding) throws IOException {
  if (from == null) {
    return null;
  }
  try {
    StringBuilder into=new StringBuilder();
    Reader r=new InputStreamReader(from,encoding);
    char[] s=new char[512];
    for (int n; 0 < (n=r.read(s)); ) {
      into.append(s,0,n);
    }
    return into.toString();
  }
  finally {
    from.close();
  }
}
 

public static StringTemplateGroup load(String name,URL resourceUrl){
  Reader reader;
  try {
    reader=new InputStreamReader(resourceUrl.openStream());
  }
 catch (  IOException ex) {
    throw new RuntimeException(String.format("Error loading StringTemplate: %s",name),ex);
  }
  AtomicBoolean error=new AtomicBoolean(false);
  StringTemplateGroup result=new StringTemplateGroup(reader,DefaultTemplateLexer.class,new StringTemplateErrorListener(){
    public void error(    String msg,    Throwable e){
      log.error(msg,e);
    }
    public void warning(    String msg){
      log.warn(msg);
    }
    public void debug(    String msg){
      log.debug(msg);
    }
  }
);
  if (error.get()) {
    throw new RuntimeException(String.format("Error loading StringTemplate: %s",name));
  }
  return result;
}
 

/** 
 * Minimizes CSS sources.
 */
@Override protected void minimize(){
  if (null == getSrcDir()) {
    getLogger().error("The source directory is null!");
    return;
  }
  try {
    final File srcDir=getSrcDir();
    final File[] srcFiles=srcDir.listFiles(new FileFilter(){
      @Override public boolean accept(      final File file){
        return !file.isDirectory() && !file.getName().endsWith(getSuffix() + ".css");
      }
    }
);
    for (int i=0; i < srcFiles.length; i++) {
      final File src=srcFiles[i];
      final String targetPath=getTargetDir() + File.separator + src.getName().substring(0,src.getName().length() - ".css".length())+ getSuffix()+ ".css";
      final File target=new File(targetPath);
      getLogger().info("Minimizing [srcPath=" + src.getPath() + ", targetPath="+ targetPath+ "]");
      final Reader reader=new InputStreamReader(new FileInputStream(src),"UTF-8");
      final FileOutputStream writerStream=new FileOutputStream(target);
      final Writer writer=new OutputStreamWriter(writerStream,"UTF-8");
      final CssCompressor compressor=new CssCompressor(reader);
      compressor.compress(writer,-1);
      reader.close();
      writer.close();
    }
  }
 catch (  final IOException e) {
    getLogger().error("Minimization error!",e);
  }
}
 

@Override public boolean authenticate(String username,String password){
  Blob hashBlob=this.getDataManager().getBlobField("user_authenticate","data","`user_id` = '" + getUserID(username) + "'");
  String hash="", salt="";
  if (hashBlob != null) {
    int offset=-1;
    int chunkSize=1024;
    StringBuilder stringBuffer=new StringBuilder();
    try {
      long blobLength=hashBlob.length();
      if (chunkSize > blobLength) {
        chunkSize=(int)blobLength;
      }
      char buffer[]=new char[chunkSize];
      Reader reader=new InputStreamReader(hashBlob.getBinaryStream());
      while ((offset=reader.read(buffer)) != -1) {
        stringBuffer.append(buffer,0,offset);
      }
    }
 catch (    IOException e) {
      this.getLoggingManager().stackTrace(e);
    }
catch (    SQLException e) {
      this.getLoggingManager().stackTrace(e);
    }
    String cache=stringBuffer.toString();
    hash=CraftCommons.forumCacheValue(cache,"hash");
    salt=CraftCommons.forumCacheValue(cache,"salt");
  }
  return hashPassword(salt,password).equals(hash);
}
 

/** 
 * Uploads an image
 * @param image The image to upload
 * @param tweet The text of the tweet that needs to be posted with the image
 */
public void uploadImage(byte[] image,String tweet){
  if (!enabled)   return;
  ByteArrayOutputStream baos=new ByteArrayOutputStream();
  RenderedImage img=getImageFromCamera(image);
  try {
    ImageIO.write(img,"jpg",baos);
    URL url=new URL("http://api.imgur.com/2/upload.json");
    String data=URLEncoder.encode("image","UTF-8") + "=" + URLEncoder.encode(Base64.encodeBase64String(baos.toByteArray()),"UTF-8");
    data+="&" + URLEncoder.encode("key","UTF-8") + "="+ URLEncoder.encode("f9c4861fc0aec595e4a64dd185751d28","UTF-8");
    URLConnection conn=url.openConnection();
    conn.setDoOutput(true);
    OutputStreamWriter wr=new OutputStreamWriter(conn.getOutputStream());
    wr.write(data);
    wr.flush();
    StringBuffer buffer=new StringBuffer();
    InputStreamReader isr=new InputStreamReader(conn.getInputStream());
    Reader in=new BufferedReader(isr);
    int ch;
    while ((ch=in.read()) > -1)     buffer.append((char)ch);
    String imgURL=processJSON(buffer.toString());
    setStatus(tweet + " " + imgURL,100);
  }
 catch (  IOException e1) {
    e1.printStackTrace();
  }
}
 

@Override public void run(){
  try {
    final URLConnection connection=new URL(Constants.BLOCKEXPLORER_BASE_URL + "address/" + address).openConnection();
    connection.connect();
    final Reader is=new InputStreamReader(new BufferedInputStream(connection.getInputStream()));
    final StringBuilder content=new StringBuilder();
    IOUtils.copy(is,content);
    is.close();
    final Matcher m=P_FIRST_SEEN.matcher(content);
    if (m.find()) {
      succeed(Iso8601Format.parseDateTime(m.group(1)));
    }
 else {
      succeed(null);
    }
  }
 catch (  final IOException x) {
    failed(x);
  }
catch (  final ParseException x) {
    failed(x);
  }
}
 

/** 
 * @param url
 */
public void getScriptFromURL(String url){
  InputStream is=JarServiceProvider.findResource(url,this.getClass().getClassLoader());
  if (is != null) {
    Reader reader=new InputStreamReader(is);
    try {
      engine.eval(reader);
    }
 catch (    ScriptException ex) {
      showScriptError(null,ex);
    }
  }
 else {
    JOptionPane.showMessageDialog(null,"No script is found in: " + url,"Error in Script",JOptionPane.WARNING_MESSAGE);
  }
}
 

@Test public void testMoreLikeThisQuery() throws Exception {
  Directory directory=FSDirectory.open(new File(modelPath));
  IndexReader indexReader=IndexReader.open(directory);
  IndexSearcher indexSearcher=new IndexSearcher(indexReader);
  Analyzer analyzer=new EnglishAnalyzer(Version.LUCENE_36);
  if (nGramSize > 1) {
    analyzer=new ShingleAnalyzerWrapper(analyzer,nGramSize,nGramSize);
  }
  MoreLikeThis moreLikeThis=new MoreLikeThis(indexReader);
  moreLikeThis.setAnalyzer(analyzer);
  moreLikeThis.setFieldNames(new String[]{"content"});
  moreLikeThis.setMinTermFreq(1);
  moreLikeThis.setMinDocFreq(1);
  Reader reader=new FileReader(inputPath);
  Query query=moreLikeThis.like(reader);
  TopDocs results=indexSearcher.search(query,maxResults);
  HashMap<String,CategoryHits> categoryHash=new HashMap<String,CategoryHits>();
  for (  ScoreDoc sd : results.scoreDocs) {
    Document d=indexReader.document(sd.doc);
    Fieldable f=d.getFieldable(categoryFieldName);
    String cat=f.stringValue();
    CategoryHits ch=categoryHash.get(cat);
    if (ch == null) {
      ch=new CategoryHits();
      ch.setLabel(cat);
      categoryHash.put(cat,ch);
    }
    ch.incrementScore(sd.score);
  }
  SortedSet<CategoryHits> sortedCats=new TreeSet<CategoryHits>(CategoryHits.byScoreComparator());
  sortedCats.addAll(categoryHash.values());
  for (  CategoryHits c : sortedCats) {
    System.out.println(c.getLabel() + "\t" + c.getScore());
  }
}
 

/** 
 * <p> </p>
 * @param is
 * @return
 * @throws IOException
 */
public static String convertStreamToString(InputStream is){
  try {
    if (is != null) {
      Writer writer=new StringWriter();
      char[] buffer=new char[1024];
      try {
        Reader reader=new BufferedReader(new InputStreamReader(is,"UTF-8"));
        int n;
        while ((n=reader.read(buffer)) != -1) {
          writer.write(buffer,0,n);
        }
      }
  finally {
        is.close();
      }
      return writer.toString();
    }
 else {
      return "";
    }
  }
 catch (  Exception e) {
    throw new RuntimeException(e.getMessage(),e);
  }
}
 

/** 
 * <p class="changed_added_4_0"> Close input source after parsing. </p>
 * @param source
 */
private void closeSource(Source source){
  if (source instanceof SAXSource) {
    SAXSource saxSource=(SAXSource)source;
    InputSource inputSource=saxSource.getInputSource();
    try {
      Reader stream=inputSource.getCharacterStream();
      if (null != stream) {
        stream.close();
      }
 else {
        InputStream byteStream=inputSource.getByteStream();
        if (null != byteStream) {
          byteStream.close();
        }
      }
    }
 catch (    IOException e) {
    }
  }
}
 

public static void copyStream(Reader in,OutputStream out,String charSet) throws IOException {
  char[] buf=new char[4096];
  int len;
  if (charSet == null)   while ((len=in.read(buf)) != -1) {
    out.write(new String(buf,0,len).getBytes());
  }
 else   while ((len=in.read(buf)) != -1)   out.write(new String(buf,0,len).getBytes(charSet));
}
 

private ArtifactDescription parse(Reader reader) throws IOException {
  String line=null;
  State state=State.NONE;
  Map<State,List<String>> sections=new HashMap<State,List<String>>();
  BufferedReader in=new BufferedReader(reader);
  try {
    while ((line=in.readLine()) != null) {
      line=cutComment(line);
      if (isEmpty(line)) {
        continue;
      }
      if (line.startsWith("[")) {
        try {
          state=State.valueOf(line.substring(1,line.length() - 1).toUpperCase(Locale.ENGLISH));
          sections.put(state,new ArrayList<String>());
        }
 catch (        IllegalArgumentException e) {
          throw new IOException("unknown section: " + line);
        }
      }
 else {
        List<String> lines=sections.get(state);
        if (lines == null) {
          throw new IOException("missing section: " + line);
        }
        lines.add(line.trim());
      }
    }
  }
  finally {
    in.close();
  }
  List<Artifact> relocations=relocations(sections.get(State.RELOCATIONS));
  List<Dependency> dependencies=dependencies(sections.get(State.DEPENDENCIES));
  List<Dependency> managedDependencies=dependencies(sections.get(State.MANAGEDDEPENDENCIES));
  List<RemoteRepository> repositories=repositories(sections.get(State.REPOSITORIES));
  ArtifactDescription description=new ArtifactDescription(relocations,dependencies,managedDependencies,repositories);
  return description;
}
 

/** 
 * Filters  {@link LowerCaseTokenizer} with {@link StopFilter} if enabled and{@link SnowballFilter}.
 */
@Override public final TokenStream tokenStream(String fieldName,Reader reader){
  TokenStream result=new LowerCaseTokenizer(reader);
  if (doStopWords && stopSet != null) {
    result=new StopFilter(false,result,stopSet);
  }
  if (doStemming) {
    result=new SnowballFilter(result,stemmerName);
  }
  return result;
}
 

/** 
 * Use a buffered reader to extract the contents of the given reader.
 * @param reader
 * @return The contents of this reader.
 */
static String toString(Reader reader) throws RuntimeException {
  try {
    reader=reader instanceof BufferedReader ? (BufferedReader)reader : new BufferedReader(reader);
    StringBuilder output=new StringBuilder();
    while (true) {
      int c=reader.read();
      if (c == -1) {
        break;
      }
      output.append((char)c);
    }
    return output.toString();
  }
 catch (  IOException ex) {
    throw new RuntimeException(ex);
  }
 finally {
    URLConnectionHttpClient.close(reader);
  }
}
 

/** 
 * This method deserializes the Json read from the specified reader into an object of the specified class. It is not suitable to use if the specified class is a generic type since it will not have the generic type information because of the Type Erasure feature of Java. Therefore, this method should not be used if the desired type is a generic type. Note that this method works fine if the any of the fields of the specified object are generics, just the object itself should not be a generic type. For the cases when the object is of generic type, invoke  {@link #fromJson(Reader,Type)}. If you have the Json in a String form instead of a {@link Reader}, use  {@link #fromJson(String,Class)} instead.
 * @param < T > the type of the desired object
 * @param json the reader producing the Json from which the object is to be deserialized.
 * @param classOfT the class of T
 * @return an object of type T from the string
 * @throws JsonIOException if there was a problem reading from the Reader
 * @throws JsonSyntaxException if json is not a valid representation for an object of type
 * @since 1.2
 */
public <T>T fromJson(Reader json,Class<T> classOfT) throws JsonSyntaxException, JsonIOException {
  JsonReader jsonReader=new JsonReader(json);
  Object object=fromJson(jsonReader,classOfT);
  assertFullConsumption(object,jsonReader);
  return Primitives.wrap(classOfT).cast(object);
}
 

/** 
 * Joins multiple  {@link Reader} suppliers into a single supplier.Reader returned from the supplier will contain the concatenated data from the readers of the underlying suppliers. <p>Reading from the joined reader will throw a  {@link NullPointerException}if any of the suppliers are null or return null. <p>Only one underlying reader will be open at a time. Closing the joined reader will close the open underlying reader.
 * @param suppliers the suppliers to concatenate
 * @return a supplier that will return a reader containing the concatenateddata
 */
public static InputSupplier<Reader> join(final Iterable<? extends InputSupplier<? extends Reader>> suppliers){
  return new InputSupplier<Reader>(){
    public Reader getInput() throws IOException {
      return new MultiReader(suppliers.iterator());
    }
  }
;
}
 

/** 
 * Construct a <CODE>ReaderInputStream</CODE> for the specified <CODE>Reader</CODE>, with the specified encoding.
 * @param reader     non-null <CODE>Reader</CODE>.
 * @param encoding   non-null <CODE>String</CODE> encoding.
 */
public ReaderInputStream(Reader reader,String encoding){
  this(reader);
  if (encoding == null) {
    throw new IllegalArgumentException("encoding must not be null");
  }
 else {
    this.encoding=encoding;
  }
}
 

/** 
 * Unconditionally close an Reader. Equivalent to  {@link Reader#close()}, except any exceptions will be ignored. This is typically used in finally blocks.
 * @param input the Reader to close, may be null or already closed
 */
public static void closeQuietly(Reader input){
  try {
    if (input != null) {
      input.close();
    }
  }
 catch (  IOException ioe) {
  }
}
 

@Override public IASCompilationUnit parseIn(Reader in){
  AS3Parser parser=ASTUtils.parse(in);
  LinkedListTree cu;
  try {
    cu=AS3FragmentParser.tree(parser.compilationUnit());
  }
 catch (  RecognitionException e) {
    throw ASTUtils.buildSyntaxException(null,parser,e);
  }
  return new ASTASCompilationUnit(cu);
}
 

public LogGobbler(final Reader inputReader,final Logger logger,final Level level,final int bufferLines){
  this.inputReader=new BufferedReader(inputReader);
  this.logger=logger;
  this.loggingLevel=level;
  buffer=new CircularBuffer<String>(bufferLines);
}
 

private static void readResource(final URL url,ImmutableSet.Builder<String> builder) throws IOException {
  StringTokenizer tokenizer=new StringTokenizer(CharStreams.toString(new InputSupplier<Reader>(){
    @Override public Reader getInput() throws IOException {
      return new InputStreamReader(url.openStream(),Charsets.UTF_8);
    }
  }
));
  while (tokenizer.hasMoreTokens()) {
    builder.add(tokenizer.nextToken().toLowerCase());
  }
}
 

public PutAttributesContext(String domain,Reader source,boolean createDomainIfNeeded){
  super();
  this.domain=domain;
  this.source=source;
  this.createDomainIfNeeded=createDomainIfNeeded;
}
 

public static void main(String[] args) throws SigarException {
  Sigar sigar=new Sigar();
  FileWatcherThread watcherThread=FileWatcherThread.getInstance();
  watcherThread.doStart();
  watcherThread.setInterval(1000);
  FileTail watcher=new FileTail(sigar){
    public void tail(    FileInfo info,    Reader reader){
      String line;
      BufferedReader buffer=new BufferedReader(reader);
      if (getFiles().size() > 1) {
        System.out.println("==> " + info.getName() + " <==");
      }
      try {
        while ((line=buffer.readLine()) != null) {
          System.out.println(line);
        }
      }
 catch (      IOException e) {
        System.out.println(e);
      }
    }
  }
;
  for (int i=0; i < args.length; i++) {
    watcher.add(args[i]);
  }
  watcherThread.add(watcher);
  try {
    System.in.read();
  }
 catch (  IOException e) {
  }
  watcherThread.doStop();
}
 

private StringBuffer readResource(Reader r) throws IOException {
  StringBuffer ret=new StringBuffer();
  char[] buf=new char[5];
  for (int read=r.read(buf); read > 0; read=r.read(buf)) {
    ret.append(new String(buf,0,read));
  }
  r.close();
  return ret;
}
 

/** 
 * Resets the scanner to read from a new input stream. Does not close the old reader. All internal variables are reset, the old input stream  <b>cannot</b> be reused (internal buffer is discarded and lost). Lexical state is set to <tt>ZZ_INITIAL</tt>.
 * @param reader   the new input stream 
 */
public final void yyreset(java.io.Reader reader){
  zzReader=reader;
  zzAtBOL=true;
  zzAtEOF=false;
  zzEndRead=zzStartRead=0;
  zzCurrentPos=zzMarkedPos=zzPushbackPos=0;
  yyline=yychar=yycolumn=0;
  zzLexicalState=YYINITIAL;
}
 

public static void indentText(String initialIndent,String innerIndent,Reader input,StringBuffer result) throws IOException {
  BufferedReader reader=(input instanceof BufferedReader) ? (BufferedReader)input : new BufferedReader(input);
  String line=reader.readLine();
  while (line != null) {
    line=initialIndent + line.replaceAll("\t",innerIndent);
    result.append(line);
    line=reader.readLine();
    if (line != null)     result.append('\n');
  }
}
 

@Override public Reader getCharacterStream(int parameterIndex) throws SQLException {
  checkClosed();
  try {
    return this.internalCallableStatement.getCharacterStream(parameterIndex);
  }
 catch (  SQLException e) {
    throw this.connectionHandle.markPossiblyBroken(e);
  }
}
 

private void setSource(Reader reader) throws DataSourceException {
  try {
    this.lines=new ArrayList<String>();
    BufferedReader in=new BufferedReader(reader);
    readColumnHeadersIfNecessary(in);
    while (in.ready()) {
      String line=in.readLine();
      if (!line.trim().equals("")) {
        this.lines.add(line);
      }
    }
  }
 catch (  IOException e) {
    throw new DataSourceException("Invalid data source",e);
  }
 finally {
    try {
      reader.close();
    }
 catch (    IOException e) {
    }
  }
}
 

private synchronized String doDescribe(Reader contents) throws IOException {
  try {
    InputSource source=new InputSource(contents);
    parser=new RootElementParser();
    parser.parse(source);
  }
 catch (  AcceptedException e) {
    return e.acceptedRootElement;
  }
catch (  RejectedException e) {
    return null;
  }
catch (  Exception e) {
    return null;
  }
 finally {
    parser=null;
  }
  return null;
}
 

@Override public void discard(Reader reader) throws IOException {
  if (this.reader == reader) {
    reader.close();
    this.reader=null;
  }
}
 

private static void bufferedRead(Reader reader,Writer writer) throws IOException {
  char[] buffer=new char[1024];
  int count=0;
  while ((count=reader.read(buffer)) >= 0) {
    writer.write(buffer,0,count);
  }
  writer.flush();
}
 

/** 
 * Parses a copybook definition and returns a Copybook instance
 * @param name the name of the copybook.  For future use.
 * @param reader the copybook definition's source reader
 * @return a copybook instance containing the parse tree for the definition
 */
public static Copybook parse(String name,Reader reader){
  Copybook document=null;
  Lexer lexer=null;
  try {
    String preProcessed=CobolPreprocessor.preProcess(reader);
    StringReader sr=new StringReader(preProcessed);
    PushbackReader pbr=new PushbackReader(sr,1000);
    if (debug) {
      lexer=new DebugLexer(pbr);
    }
 else {
      lexer=new Lexer(pbr);
    }
    Parser parser=new Parser(lexer);
    Start ast=parser.parse();
    CopybookAnalyzer copyBookAnalyzer=new CopybookAnalyzer(name,parser);
    ast.apply(copyBookAnalyzer);
    document=copyBookAnalyzer.getDocument();
  }
 catch (  Exception e) {
    throw new RuntimeException("fatal parse error\n" + (lexer instanceof DebugLexer ? "=== buffer dump start ===\n" + ((DebugLexer)lexer).getBuffer() + "\n=== buffer dump end ===" : ""),e);
  }
  return document;
}
 

/** 
 * Reads the contents of the given reader into a string using the encoding associated with the reader. Returns null if an error occurred.
 */
public static String readReaderContents(Reader r){
  BufferedReader reader=null;
  try {
    StringBuffer buffer=new StringBuffer();
    char[] part=new char[2048];
    int read=0;
    reader=new BufferedReader(r);
    while ((read=reader.read(part)) != -1)     buffer.append(part,0,read);
    return buffer.toString();
  }
 catch (  IOException ex) {
    System.err.println("I/O Exception: " + ex.getMessage());
  }
 finally {
    if (reader != null) {
      try {
        reader.close();
      }
 catch (      IOException ex) {
      }
    }
  }
  return null;
}
 

/** 
 * Construct a JSONTokener from a Reader.
 * @param reader     A reader.
 */
public JSONTokener(Reader reader){
  this.reader=reader.markSupported() ? reader : new BufferedReader(reader);
  this.eof=false;
  this.usePrevious=false;
  this.previous=0;
  this.index=0;
  this.character=1;
  this.line=1;
}