fileentry.cpp

Go to the documentation of this file.

/*
  Zipios -- a small C++ library that provides easy access to .zip files.

  Copyright (C) 2000-2007  Thomas Sondergaard
  Copyright (C) 2015-2019  Made to Order Software Corporation

  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.

  This library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, write to the Free Software
  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "zipios/fileentry.hpp"

#include "zipios/zipiosexceptions.hpp"

#include "zipios_common.hpp"


namespace zipios
{

FileEntry::FileEntry(FilePath const& filename, std::string const& comment)
    : m_filename(filename)
    , m_comment(comment)
    //, m_uncompressed_size(0) -- auto-init
    //, m_unix_time(0) -- auto-init
    //, m_entry_offset(0) -- auto-init
    //, m_compress_method(StorageMethod::STORED) -- auto-init
    //, m_compression_level(COMPRESSION_LEVEL_DEFAULT) -- auto-init
    //, m_crc_32(0) -- auto-init
    //, m_has_crc_32(false) -- auto-init
    //, m_valid(false) -- auto-init
{
}


FileEntry::~FileEntry()
{
}


std::string FileEntry::getComment() const
{
    return m_comment;
}


size_t FileEntry::getCompressedSize() const
{
    return getSize();
}




FileEntry::crc32_t FileEntry::getCrc() const
{
    return m_crc_32;
}


std::streampos FileEntry::getEntryOffset() const
{
    return m_entry_offset;
}


FileEntry::buffer_t FileEntry::getExtra() const
{
    return m_extra_field;
}


size_t FileEntry::getHeaderSize() const
{
    return 0;
}


FileEntry::CompressionLevel FileEntry::getLevel() const
{
    if(isDirectory())
    {
        return COMPRESSION_LEVEL_NONE;
    }
    return m_compression_level;
}


StorageMethod FileEntry::getMethod() const
{
    if(isDirectory())
    {
        // make sure we do not return anything else than STORED
        // for a directory
        return StorageMethod::STORED;
    }
    return m_compress_method;
}




std::string FileEntry::getName() const
{
    return m_filename;
}


std::string FileEntry::getFileName() const
{
    return m_filename.filename();
}


size_t FileEntry::getSize() const
{
    return m_uncompressed_size;
}


DOSDateTime::dosdatetime_t FileEntry::getTime() const
{
    if(m_unix_time == 0)
    {
        return 0;
    }

    DOSDateTime t;
    t.setUnixTimestamp(m_unix_time);
    return t.getDOSDateTime();
}


std::time_t FileEntry::getUnixTime() const
{
    return m_unix_time;
}


bool FileEntry::hasCrc() const
{
    return m_has_crc_32;
}


bool FileEntry::isDirectory() const
{
    return m_filename.isDirectory();
}


bool FileEntry::isEqual(FileEntry const & file_entry) const
{
    return m_filename          == file_entry.m_filename
        && m_comment           == file_entry.m_comment
        && m_uncompressed_size == file_entry.m_uncompressed_size
        && m_unix_time         == file_entry.m_unix_time
        && m_compress_method   == file_entry.m_compress_method
        && m_crc_32            == file_entry.m_crc_32
        && m_has_crc_32        == file_entry.m_has_crc_32
        && m_valid             == file_entry.m_valid;
        //&& m_extra_field       == file_entry.m_extra_field -- ignored in comparison
}


bool FileEntry::isValid() const
{
    return m_valid;
}


void FileEntry::setComment(std::string const& comment)
{
    // WARNING: we do NOT check the maximum size here because it can depend
    //          on the output format which is just zip now but could be a
    //          bit extended later (i.e. Zip64)
    m_comment = comment;
}


void FileEntry::setCompressedSize(size_t size)
{
    static_cast<void>(size);
}


void FileEntry::setCrc(crc32_t crc)
{
    static_cast<void>(crc);
}


void FileEntry::setEntryOffset(std::streampos offset)
{
    m_entry_offset = offset;
}


void FileEntry::setExtra(buffer_t const& extra)
{
    m_extra_field = extra;
}


void FileEntry::setLevel(CompressionLevel level)
{
    if(level < COMPRESSION_LEVEL_DEFAULT || level > COMPRESSION_LEVEL_MAXIMUM)
    {
        throw InvalidStateException("level must be between COMPRESSION_LEVEL_DEFAULT and COMPRESSION_LEVEL_MAXIMUM");
    }
    if(isDirectory())
    {
        if(level >= COMPRESSION_LEVEL_MINIMUM)
        {
            throw InvalidStateException("directories cannot be marked with a compression level other than COMPRESSION_LEVEL_NONE (defaults will also work");
        }
        m_compression_level = COMPRESSION_LEVEL_NONE;
    }
    else
    {
        m_compression_level = level;
    }
}


void FileEntry::setMethod(StorageMethod method)
{
    switch(method)
    {
    case StorageMethod::STORED:
    //case StorageMethod::SHRUNK:
    //case StorageMethod::REDUCED1:
    //case StorageMethod::REDUCED2:
    //case StorageMethod::REDUCED3:
    //case StorageMethod::REDUCED4:
    //case StorageMethod::IMPLODED:
    //case StorageMethod::TOKENIZED:
    case StorageMethod::DEFLATED:
    //case StorageMethod::DEFLATED64:
    //case StorageMethod::OLD_TERSE:
    //case StorageMethod::RESERVED11:
    //case StorageMethod::BZIP2:
    //case StorageMethod::REVERVED13:
    //case StorageMethod::LZMA:
    //case StorageMethod::RESERVED15:
    //case StorageMethod::RESERVED16:
    //case StorageMethod::RESERVED17:
    //case StorageMethod::NEW_TERSE:
    //case StorageMethod::LZ77:
    //case StorageMethod::WAVPACK:
    //case StorageMethod::PPMD_I_1:
        break;

    default:
        throw InvalidStateException("unknown method");

    }

    if(isDirectory())
    {
        // force uncompressed for directories
        m_compress_method = StorageMethod::STORED;
    }
    else
    {
        m_compress_method = method;
    }
}


void FileEntry::setSize(size_t size)
{
    m_uncompressed_size = size;
}


void FileEntry::setTime(DOSDateTime::dosdatetime_t dosdatetime)
{
    DOSDateTime t;
    t.setDOSDateTime(dosdatetime);
    setUnixTime(t.getUnixTimestamp());
}


void FileEntry::setUnixTime(std::time_t time)
{
    m_unix_time = time;
}


std::string FileEntry::toString() const
{
    OutputStringStream sout;
    sout << m_filename;
    if(isDirectory())
    {
        sout << " (directory)";
    }
    else
    {
        sout << " ("
             << m_uncompressed_size << " byte"
             << (m_uncompressed_size == 1 ? "" : "s");
        size_t const compressed_size(getCompressedSize());
        if(compressed_size != m_uncompressed_size)
        {
             // this is not currently accessible since only the
             // ZipLocalEntry and ZipCentralDirectoryEntry have
             // a compressed size
             sout << ",  " // LCOV_EXCL_LINE
                  << compressed_size << " byte" // LCOV_EXCL_LINE
                  << (compressed_size == 1 ? "" : "s") // LCOV_EXCL_LINE
                  << " compressed"; // LCOV_EXCL_LINE
        }
        sout << ")";
    }
    return sout.str();
}


void FileEntry::read(std::istream& is)
{
    static_cast<void>(is);
    throw IOException("FileEntry::read(): read not available with this type of FileEntry.");
}


void FileEntry::write(std::ostream& os)
{
    static_cast<void>(os);
    throw IOException("FileEntry::write(): write not available with this type of FileEntry.");
}


std::ostream& operator << (std::ostream& os, FileEntry const& entry)
{
    os << entry.toString();
    return os;
}


} // namespace

// Local Variables:
// mode: cpp
// indent-tabs-mode: nil
// c-basic-offset: 4
// tab-width: 4
// End:

// vim: ts=4 sw=4 et