import org.jbibtex.ParseException; //导入依赖的package包/类
/**
 *
 * @throws IOException 
 * @throws ParseException 
 * @throws InvalidPaperIdException
 */
public void downloadAllPapers() throws IOException, ParseException, InvalidPaperIdException {
    System.out.printf(
            "\nDownloading %d papers from %s respository to %s\n", 
            getEntriesCollection().size(), repository, downloadDir);
    System.out.printf("Origin BibTeX file: %s\n\n", bibFileName);
    int i = 0;
    for (BibTeXEntry bibEntry : getEntriesCollection()) {
        i++;
        Paper paper = repository.getPaperInstance(this, bibEntry);
        paper.setOrderInsideBibTexFile(i);
        try {
            System.out.println(paper);
            paper.downloadAndIfSuccessfulSetLocalFileNameAndUrl();
        } catch (PaperNotAvailableForDownloadException ex) {
            System.out.println("Paper " + paper.getTitle() + ". " + ex.getLocalizedMessage());
        }
    }
    this.saveChangesInBibTexFile();
}
 

import org.jbibtex.ParseException; //导入依赖的package包/类
/**
 * Helper tool to convert bibtex to {@link Reference} annotations. Reads
 * from stdin, writes to stdout.
 * 
 * @param args
 *            not used
 * @throws IOException
 * @throws ParseException
 */
public static void main(String[] args) throws IOException, ParseException {
	System.out.println("Enter bibtex record(s), followed by ctrl-d: ");

	final Reader reader = new InputStreamReader(System.in);

	final BibTeXParser parser = new BibTeXParser();
	final BibTeXDatabase database = parser.parse(reader);

	System.out.println();

	for (final BibTeXEntry entry : database.getEntries().values()) {
		final Reference r = MockReference.makeReference(entry);
		System.out.println(StandardFormatters.REFERENCE_ANNOTATION.format(r));
	}
}
 

import org.jbibtex.ParseException; //导入依赖的package包/类
/**
 * <p>Loads a BibTeX database from a stream.</p>
 * <p>This method does not close the given stream. The caller is
 * responsible for closing it.</p>
 * @param is the input stream to read from
 * @return the BibTeX database
 * @throws IOException if the database could not be read
 * @throws ParseException if the database is invalid
 */
public BibTeXDatabase loadDatabase(InputStream is) throws IOException, ParseException {
	Reader reader = new InputStreamReader(is, "UTF-8");
	BibTeXParser parser = new BibTeXParser() {
		@Override
		public void checkStringResolution(Key key, BibTeXString string) {
			if (string == null) {
				//ignore
			}
		}
	};
	try {
		return parser.parse(reader);
	} catch (TokenMgrException err) {
		throw new ParseException("Could not parse BibTeX library: " +
				err.getMessage());
	}
}
 

import org.jbibtex.ParseException; //导入依赖的package包/类
/**
 * 
 * Converts to String a value get from a BibTeX entry.
 *
 * @param value Value of a field from a BibTeX entry.
 * @return Returns the value as string
 * @throws org.jbibtex.ParseException
 * @throws java.io.UnsupportedEncodingException
 */
public String keyValueToStr(Value value) throws ParseException, UnsupportedEncodingException {
    String str = (value == null ? "" : value.toUserString());
    if (str.indexOf('\\') > -1 || str.indexOf('{') > -1) {
        LaTeXParser latexParser = new LaTeXParser();
        List<LaTeXObject> latexObjects = latexParser.parse(str);
        LaTeXPrinter latexPrinter = new LaTeXPrinter();
        str = latexPrinter.print(latexObjects);
    }
    return str;
}
 

import org.jbibtex.ParseException; //导入依赖的package包/类
/**
 * Executes the command line application to parse the bibtex file
 * and download the papers.
 * 
 * @param args The command line arguments, in order:<br/>
 *   1º - Name of the bibtex file to be processed.<br/>
 *   2º - Destination directory where to download the papers.<br/>
 *   3º - Name of the repository where to download the papers.
 * @see Main#showUsage() 
 */
public static void main(String args[]) {
    try {
        new Main(args);
    }catch(IllegalArgumentException e){
        showUsage();
    } catch (ParseException|InvalidPaperIdException|IOException|ClassNotFoundException|InstantiationException ex) {
        System.err.println(ex.getMessage());
        Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
    }    
}
 

import org.jbibtex.ParseException; //导入依赖的package包/类
private void createBibTexParserAndParseIt(final String bibFileName) throws ParseException {
    try (final CharacterFilterReader filterReader = new CharacterFilterReader(reader)) {
        parser = this.getBibTexParserInstance();
        database = parser.parse(filterReader);
    } catch (Exception e) {
        e.printStackTrace(System.out);
        throw new ParseException(
                "It was not possible to pase the bibtex file " + bibFileName + ". Maybe the file is invalid\n");        
    }
}
 

import org.jbibtex.ParseException; //导入依赖的package包/类
private String parseLaTeX(String latexString) {
	String plainString = "";
	try {
		LaTeXParser parser = new LaTeXParser();
		List<LaTeXObject> latexObjects = parser.parse(latexString);
		LaTeXPrinter printer = new LaTeXPrinter();
		plainString = printer.print(latexObjects);
	} catch (TokenMgrException | ParseException e) {
		System.out.println(e.getMessage());
		return latexString;
	}
	return plainString;
}
 

import org.jbibtex.ParseException; //导入依赖的package包/类
/**
 * Default constructor
 */
public BibTeXConverter() {
	try {
		latexParser = new LaTeXParser();
	} catch (ParseException e) {
		// can actually never happen because the default constructor
		// of LaTeXParser doesn't throw
		throw new RuntimeException(e);
	}
	latexPrinter = new LaTeXPrinter();
}
 

import org.jbibtex.ParseException; //导入依赖的package包/类
/**
 * Loads the <code>unix.bib</code> database from the classpath
 * @return the database
 * @throws IOException if the database could not be loaded
 * @throws ParseException if the database is invalid
 */
protected static BibTeXDatabase loadUnixDatabase() throws IOException, ParseException {
	BibTeXDatabase db;
	try (InputStream is = AbstractBibTeXTest.class.getResourceAsStream("/unix.bib.gz")) {
		GZIPInputStream gis = new GZIPInputStream(is);
		db = new BibTeXConverter().loadDatabase(gis);
	}
	return db;
}
 

import org.jbibtex.ParseException; //导入依赖的package包/类
public Main(String args[]) throws ParseException, ClassNotFoundException, InstantiationException, IOException, FileNotFoundException, InvalidPaperIdException {
     getComandLineParameters(args);
     downloadPapersInBibFile();   
}
 

import org.jbibtex.ParseException; //导入依赖的package包/类
private void downloadPapersInBibFile() throws FileNotFoundException, ParseException, ClassNotFoundException, InstantiationException, IOException, InvalidPaperIdException {
    BibTexPapersDownloader bibtex = new BibTexPapersDownloader(bibFileName, repositoryName);
    bibtex.setDownloadDir(downloadDir);
    bibtex.downloadAllPapers();
}
 

import org.jbibtex.ParseException; //导入依赖的package包/类
/**
 * 
 * @param bibFileNameContainingThePapersToDownload Name of BibTeX file to be parsed.
 * @param classNameOfRepositoryWhereToDownloadThePapers Name of the class of the web repository
 * where the papers in the bibtex file have to be downloaded.
 * For instance, IEEE, ACM, Elsevier, etc.
 * @throws java.io.FileNotFoundException
 * @throws org.jbibtex.ParseException
 * @throws java.lang.ClassNotFoundException
 * @throws java.lang.InstantiationException
 * @see com.manoelcampos.bibtexpaperdownloader.repository.PaperRepositoryFactory
 */
public BibTexPapersDownloader(
        final String bibFileNameContainingThePapersToDownload, 
        final String classNameOfRepositoryWhereToDownloadThePapers) throws FileNotFoundException, ParseException, ClassNotFoundException, InstantiationException {
    this.repository = 
            PaperRepositoryFactory.getInstance(
                    classNameOfRepositoryWhereToDownloadThePapers);
    this.setBibFileNameAndCreateBibFileReader(bibFileNameContainingThePapersToDownload);        
    this.createBibTexParserAndParseIt(bibFileNameContainingThePapersToDownload);
}
 

import org.jbibtex.ParseException; //导入依赖的package包/类
Library loadLibrary(InputStream is) throws IOException, ParseException {
	Reader reader = new InputStreamReader(is, "UTF-8");
	$name parser = new $name();
	return parser.parse(reader);
}