FSEx.h

#pragma once
 
namespace SharpKmyIO
{
#define Z_OK            0
#define Z_STREAM_END    1
#define Z_NEED_DICT     2
#define Z_ERRNO        (-1)
#define Z_STREAM_ERROR (-2)
#define Z_DATA_ERROR   (-3)
#define Z_MEM_ERROR    (-4)
#define Z_BUF_ERROR    (-5)
#define Z_VERSION_ERROR (-6)
 
    public ref class FSEx
    {
    public:
        static bool initializeResourceFileInfo(System::String^ inPath)
        {
            return kmyIO::initializeResourceFileInfo(SharpKmyBase::StringConv::convert(inPath).c_str());
        }
 
        static bool existsResourceFile(System::String^ inPath)
        {
            return kmyIO::existsResourceFile(SharpKmyBase::StringConv::convert(inPath).c_str());
        }
 
        static array<byte>^ readResourceFileAllBytes(System::String^ inPath)
        {
            SEHTRY2{
            auto p = SharpKmyBase::StringConv::convert(inPath);
            auto size = kmyIO::getResourceFileSize(p.c_str());
            auto buff = gcnew array<byte>(size);
 
            if (size > 0)
            {
                auto* fs = kmyIO::FS::newFS();
                auto* stream = fs->open(p.c_str(), kmyIO::StreamBase::kREAD_MODE);
 
                if (stream != nullptr)
                {
                    byte* tmp;
 
                    TRACK_NEW_ARRAY(tmp, byte, size);
 
                    stream->read(tmp, sizeof(byte), size);
 
                    for (size_t i = 0; i < size; i++)
                    {
                        buff[i] = tmp[i];
                    }
 
                    SAFE_DELETE(stream);
 
                    SAFE_DELETE_ARRAY(tmp);
                }
 
                SAFE_DELETE(fs);
            }
 
            return buff;
            }SEHCATCH2;
        }
 
        static unsigned char* getCodes(bool flag, int& refCodeCnt)
        {
            SEHTRY{
            return kmyIO::getCodes(flag, refCodeCnt);
            }SEHCATCH;
        }
 
        static bool compress(System::IO::BinaryWriter^ inWriter, System::IO::MemoryStream^ inStream)
        {
            SEHTRY{
            auto srcSize = inStream->Length;
            byte* srcBuff;
 
            TRACK_NEW_ARRAY(srcBuff, byte, srcSize);
 
            for (size_t i = 0; i < srcSize; i++)
            {
                srcBuff[i] = (byte)inStream->ReadByte();
            }
 
            byte* compressBuff;
 
            TRACK_NEW_ARRAY(compressBuff, byte, srcSize);
 
            auto compressSize = (size_t)srcSize;
 
            auto result = true;
 
            switch (kmyBase::CompressUtil::compress(srcBuff, inStream->Length, compressBuff, compressSize))
            {
                case Z_STREAM_END:
                case Z_OK:
                    {
                        // ���k��̕����T�C�Y���傫���Ȃ�ꍇ�͖����k�Ŋi�[����
                        auto outSize = min(compressSize, srcSize);
                        auto outBuff = outSize == srcSize ? srcBuff : compressBuff;
 
                        for (size_t i = 0; i < outSize; i++)
                        {
                            inWriter->Write(outBuff[i]);
                        }
                    }
                    break;
                default:
                    result = false;
                    break;
            }
 
            SAFE_DELETE_ARRAY(srcBuff);
            SAFE_DELETE_ARRAY(compressBuff);
 
            return result;
            }SEHCATCH;
        }
    };
}