org.jrimum.bopepo.pdf.Files Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of bpp-cobranca Show documentation
Show all versions of bpp-cobranca Show documentation
This is a fork and merge from JRimum ( http://www.jrimum.org ),
- Bopepo: https://github.com/jrimum/bopepo
- Texgit: https://github.com/jrimum/texgit
- Valia: https://github.com/jrimum/vallia
- Utilix: https://github.com/jrimum/utilix
- Domkee: https://github.com/jrimum/domkee
For Brazillian Boleto Payment Method. So much thanks for original authors:
Gilmar P. S. L, Misael Barreto and Rômulo Augusto.
The newest version!
/*
* Copyright 2008 JRimum Project
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by
* applicable law or agreed to in writing, software distributed under the
* License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS
* OF ANY KIND, either express or implied. See the License for the specific
* language governing permissions and limitations under the License.
*
* Created at: 30/03/2008 - 18:17:54
*
* ================================================================================
*
* Direitos autorais 2008 JRimum Project
*
* Licenciado sob a Licença Apache, Versão 2.0 ("LICENÇA"); você não pode usar
* esse arquivo exceto em conformidade com a esta LICENÇA. Você pode obter uma
* cópia desta LICENÇA em http://www.apache.org/licenses/LICENSE-2.0 A menos que
* haja exigência legal ou acordo por escrito, a distribuição de software sob
* esta LICENÇA se dará “COMO ESTÁ”, SEM GARANTIAS OU CONDIÇÕES DE QUALQUER
* TIPO, sejam expressas ou tácitas. Veja a LICENÇA para a redação específica a
* reger permissões e limitações sob esta LICENÇA.
*
* Criado em: 30/03/2008 - 18:17:54
*
*/
package org.jrimum.bopepo.pdf;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.WeakHashMap;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;
import org.jrimum.utilix.Exceptions;
import org.jrimum.utilix.Objects;
import org.jrimum.utilix.Strings;
/**
*
* Utilitário para manipular arquivos e fluxos de arquivos.
*
*
*
* @author Gilmar P.S.L
* @author Misael Barreto
* @author Rômulo Augusto
* @author Nordeste Fomento
* Mercantil
*
* @since 0.2
*
* @version 0.2
*/
public class Files {
private static final int DEFAULT_BUFFER_SIZE = 4096;
public static final String ZIP_SUFFIX = ".zip";
/**
* Utility class pattern: classe não instanciável
*
* @throws IllegalStateException Caso haja alguma tentativa de utilização
* deste construtor.
*/
private Files() {
Exceptions.throwIllegalStateException("Instanciação não permitida!");
}
/**
*
* Transforma um array de bytes em um arquivo.
*
*
* @param pathName - Caminho do arquivo para onde os bytes serão escritos.
* @param bytes - Bytes a serem copiados.
*
* @return Objeto File com o conteúdo sendo o dos bytes
*
* @throws FileNotFoundException
* @throws IOException
* @throws IllegalArgumentException Caso {@code pathName} ou {@code bytes}
* seja null, vazio ou contenha apenas espaços em branco
* @since 0.2
*/
public static File bytesToFile(String pathName, byte[] bytes)
throws FileNotFoundException, IOException {
Strings.checkNotBlank(pathName);
Objects.checkNotNull(bytes);
return bytesToFile(new File(pathName), bytes);
}
/**
*
* Transforma um array de bytes em um arquivo.
*
*
* @param file - arquivo para onde os bytes serão escritos.
* @param bytes - Bytes a serem copiados.
*
* @return Objeto File com o conteúdo sendo o dos bytes
*
* @throws FileNotFoundException
* @throws IOException
* @throws IllegalArgumentException Caso {@code pathName} ou {@code bytes}
* seja null, vazio ou contenha apenas espaços em branco
*
* @since 0.2
*/
public static File bytesToFile(File file, byte[] bytes)
throws FileNotFoundException, IOException {
Objects.checkNotNull(file);
Objects.checkNotNull(bytes);
if (file.length() > Integer.MAX_VALUE) {
Exceptions.throwIllegalArgumentException(
"TAMANHO DO ARQUIVO MAIOR DO QUE O SUPORTADO: "
+ Integer.MAX_VALUE);
}
OutputStream out = new FileOutputStream(file);
out.write(bytes);
out.flush();
out.close();
return file;
}
/**
*
* Transforma um array de bytes em um ByteArrayOutputStream.
*
*
* @param bytes - Bytes que serão escritos no objeto ByteArrayOutputStream
*
* @return ByteArrayOutputStream ou null
*
* @throws IOException
* @throws IllegalArgumentException Caso os {@code bytes} sejam
* {@code null}.
*
* @since 0.2
*/
public static ByteArrayOutputStream bytesToStream(byte[] bytes)
throws IOException {
Objects.checkNotNull(bytes);
ByteArrayOutputStream byteOut = new ByteArrayOutputStream();
byteOut.write(bytes);
return byteOut;
}
/**
* Retorna o conteúdo do arquivo em um array de bytes.
*
* @param file
* @return Conteúdo em um array de bytes.
* @throws IOException
* @throws IllegalArgumentException Caso o {@code file} seja {@code null}.
*/
public static byte[] fileToBytes(File file) throws IOException {
Objects.checkNotNull(file);
InputStream is = new FileInputStream(file);
byte[] bytes = new byte[(int) file.length()];
int offset = 0;
int numRead = 0;
while ((offset < bytes.length)
&& ((numRead = is.read(bytes, offset, bytes.length - offset)) >= 0)) {
offset += numRead;
}
is.close();
Objects.checkArgument(offset == bytes.length,
"Não foi possível completar a leitura do arquivo: "
+ file.getName());
return bytes;
}
/**
* Retorna o conteúdo do {@code InputStream} em um array de bytes.
*
*
* Fecha o {@code InputStream} após leitura.
*
*
* @param input
* @return Conteúdo em um array de bytes.
* @throws IOException
* @throws IllegalArgumentException Caso o {@code input} seja {@code null}.
*/
public static byte[] toByteArray(InputStream input) throws IOException {
Objects.checkNotNull(input);
ByteArrayOutputStream output = new ByteArrayOutputStream();
byte[] buffer = new byte[DEFAULT_BUFFER_SIZE];
int n = 0;
while (-1 != (n = input.read(buffer))) {
output.write(buffer, 0, n);
}
input.close();
output.flush();
return output.toByteArray();
}
public static File zip(File f) {
return zip(f.getName(), f);
}
public static File zip(String zipedName, File f) {
try {
return bytesToFile(File.createTempFile(zipedName, ZIP_SUFFIX), zip(toByteArray(f), f.getName()));
} catch (IOException e) {
throw new IllegalStateException(e);
}
}
public static byte[] zip(byte[] fileToZip, String fileZipedName) {
ByteArrayOutputStream obout = new ByteArrayOutputStream();
ZipOutputStream out = null;
try {
out = new ZipOutputStream(obout);
out.setMethod(ZipOutputStream.DEFLATED);
out.putNextEntry(new ZipEntry(fileZipedName));
out.write(fileToZip);
} catch (IOException e) {
throw new IllegalStateException(e);
} finally {
if (out != null) {
try {
// Close the input stream and return bytes
out.close();
} catch (Exception e) {
return Exceptions.throwIllegalStateException(e);
}
}
}
return obout.toByteArray();
}
public static File zip(Collection files) {
Map toZip = new WeakHashMap(files.size());
for (File f : files) {
toZip.put(f.getName(), f);
}
return zip(toZip);
}
public static File zip(Map files) {
return zip("ZipedFiles", files);
}
public static File zip(String zipedName, Map files) {
Map bytFiles = new HashMap(files.size());
for (Entry nameAndFile : files.entrySet()) {
bytFiles.put(nameAndFile.getKey(), toByteArray(nameAndFile
.getValue()));
}
try {
return bytesToFile(File.createTempFile(zipedName, ZIP_SUFFIX), zipBytes(bytFiles));
} catch (IOException e) {
throw new IllegalStateException(e);
}
}
public static byte[] zipBytes(Map files) {
// Create a buffer for reading the files
byte[] buf = new byte[DEFAULT_BUFFER_SIZE];
ByteArrayOutputStream outs = new ByteArrayOutputStream();
try {
// Create the ZIP file
ZipOutputStream out = new ZipOutputStream(outs);
// Compress the files
for (Entry entry : files.entrySet()) {
if (entry.getValue() != null) {
ByteArrayInputStream in = new ByteArrayInputStream(entry
.getValue());
// Add ZIP entry to output stream.
out.putNextEntry(new ZipEntry(normalizeName(entry.getKey())));
// Transfer bytes from the file to the ZIP file
int len;
while ((len = in.read(buf)) > 0) {
out.write(buf, 0, len);
}
// Complete the entry
out.closeEntry();
in.close();
}
}
// Complete the ZIP file
out.close();
return outs.toByteArray();
} catch (IOException e) {
throw new IllegalStateException(e);
}
}
public static byte[] toByteArray(File file) {
try {
InputStream is = new FileInputStream(file);
long length = file.length();
if (length > Integer.MAX_VALUE) {
Exceptions.throwIllegalArgumentException(String.format("File is too large! Max file length capacity is %s bytes.", length));
}
byte[] bytes = new byte[(int) length];
int offset = 0;
int numRead = 0;
while ((offset < bytes.length)
&& ((numRead = is.read(bytes, offset, bytes.length - offset)) >= 0)) {
offset += numRead;
}
is.close();
if (offset < bytes.length) {
throw new IOException("Could not completely read file " + file.getName());
}
return bytes;
} catch (Exception e) {
return Exceptions.throwIllegalStateException(e);
}
}
/**
* Gera uma string para ser utilizada como nome de arquivo. Ou como base de
* código para retirar acentos de um texto com Java Os nomes são sem acento
* e ao invés de " " é usado _ .
*
* @param name string a ser usada como nome borderoArquivo
* @return retorna o nome do borderoArquivo alterado.
*/
public static String normalizeName(String name) {
name = name.replaceAll(" ", "_");
name = Strings.eliminateAccent(name);
name = name.replaceAll("[^\\p{ASCII}]", "");
return name;
}
}