source: trunk/gli/src/org/greenstone/gatherer/remote/ZipCollectionArchives.java@ 13320

package org.greenstone.gatherer.remote;

import java.io.*;
import java.util.zip.*;
import org.greenstone.gatherer.util.ZipTools;


/**
 */
public class ZipCollectionArchives
{
    static public void main(String[] args)
    {
    if (args.length != 3) {
        System.err.println("Usage: ZipCollectionArchives <zip-file> <collect-directory-path> <collection-name>");
        return;
    }

    String zip_file_path = args[0];
    String collect_directory_path = args[1];
    String collection_name = args[2];

    if (!collect_directory_path.endsWith(File.separator)) {
        collect_directory_path += File.separator;
    }

    try {
        ZipOutputStream zos = new ZipOutputStream(new FileOutputStream(zip_file_path));

        // Add archives directory, with doc.xml files only
        String archives_relative_path = collection_name + File.separator + "archives";
        ZipTools.ZipFilter collection_archives_zip_filter = new CollectionArchivesZipFilter();
        ZipTools.addFileToZip(zos, collect_directory_path, archives_relative_path, collection_archives_zip_filter);

        zos.close();
    }
    catch (Exception exception) {
        exception.printStackTrace();
    }
    }


    static public class CollectionArchivesZipFilter
    extends ZipTools.NullZipFilter
    {
    private byte[] bytes_remaining = new byte[0];
    private int section_depth = 0;
    private boolean in_section_content = false;


    public boolean shouldIncludeFile(String relative_file_path)
    {
        // Only doc.xml files are included
        return (relative_file_path.equals("doc.xml") || relative_file_path.endsWith(File.separator + "doc.xml"));
    }


    public int filterFileContent(BufferedInputStream bis, byte[] data, int bytes_to_read)
    {
        try {
        // Read the next chunk of bytes from the file
        byte[] bytes_read_this_time = new byte[bytes_to_read];
        int num_bytes_read_this_time = bis.read(bytes_read_this_time, 0, bytes_to_read);
        if (num_bytes_read_this_time == -1) {
            // We must be at the end of the file
            return -1;
        }

        // Add this chunk to the bytes remaining from last time
        byte[] bytes_unprocessed = new byte[bytes_remaining.length + num_bytes_read_this_time];
        for (int i = 0; i < bytes_remaining.length; i++) {
            bytes_unprocessed[i] = bytes_remaining[i];
        }
        for (int i = 0; i < num_bytes_read_this_time; i++) {
            bytes_unprocessed[bytes_remaining.length + i] = bytes_read_this_time[i];
        }

        // Split the chunk into lines and filter them
        int num_bytes_processed = 0;
        int num_bytes_unfiltered = 0;
        int last_line_start = 0;
        for (int i = 0; (i < bytes_unprocessed.length && num_bytes_unfiltered < bytes_to_read); i++) {
            // Found the end of a line
            if (bytes_unprocessed[i] == '\n') {
            int line_length = i - last_line_start + 1;
            String line = new String(bytes_unprocessed, last_line_start, line_length);

            // If this line isn't filtered, write it to the data array
            if (!filterFileLine(line)) {
                for (int j = 0; (j < line_length && num_bytes_unfiltered < bytes_to_read); j++) {
                data[num_bytes_unfiltered] = bytes_unprocessed[last_line_start + j];
                num_bytes_unfiltered++;
                num_bytes_processed++;
                }
            }
            // Otherwise ignore it
            else {
                num_bytes_processed = i + 1;
            }

            last_line_start = i + 1;
            }
        }

        // Create a new byte array containing any bytes remaining (these will be processed next time)
        int num_bytes_remaining = bytes_unprocessed.length - num_bytes_processed;
        bytes_remaining = new byte[num_bytes_remaining];
        for (int i = 0; i < num_bytes_remaining; i++) {
            bytes_remaining[i] = bytes_unprocessed[num_bytes_processed + i];
        }

        return num_bytes_unfiltered;
        }
        catch (Exception exception) {
        exception.printStackTrace();
        }

        return -1;
    }


    private boolean filterFileLine(String line)
    {
        boolean filter_line = false;

        if (line.indexOf("<Section>") != -1) {
        section_depth++;
        }
        if (line.indexOf("<Content>") != -1) {
        in_section_content = true;
        }

        // If we're in a subsection or in a content element, filter this line
        if (section_depth > 1 || in_section_content) {
        filter_line = true;
        }

        if (line.indexOf("</Content>") != -1) {
        in_section_content = false;
        }
        if (line.indexOf("</Section>") != -1) {
        section_depth--;
        }

        return filter_line;
    }
    }
}