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-2022  Made to Order Software Corp.  All Rights Reserved
 
  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)
{
}
 
 
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();
}
 
 
std::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 inclusive");
    }
    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())
    {
        // never compress 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