afx.h

/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

#ifndef BAGEL_MFC_AFX_H
#define BAGEL_MFC_AFX_H

#include "common/stream.h"
#include "bagel/mfc/minwindef.h"

namespace Bagel {
namespace MFC {

struct CRuntimeClass;
class CObject;
class CException;
class CFileException;

#define DECLARE_DYNAMIC(class_name) \
    public: \
    static const CRuntimeClass class##class_name; \
    virtual const CRuntimeClass *GetRuntimeClass() const override; \


#define RUNTIME_CLASS(class_name) ((const CRuntimeClass *)(&class_name::class##class_name))

#define IMPLEMENT_RUNTIMECLASS(class_name, base_class_name, wSchema, pfnNew) \
    const CRuntimeClass class_name::class##class_name = { \
        #class_name, sizeof(class class_name), wSchema, pfnNew, \
            RUNTIME_CLASS(base_class_name) }; \
    const CRuntimeClass* class_name::GetRuntimeClass() const \
    { return RUNTIME_CLASS(class_name); }

#define IMPLEMENT_DYNAMIC(class_name, base_class_name) \
    IMPLEMENT_RUNTIMECLASS(class_name, base_class_name, 0xFFFF, nullptr)

#define IMPLEMENT_DYNCREATE(class_name, base_class_name) \
    CObject *class_name::CreateObject() \
    { return new class_name; } \
    IMPLEMENT_RUNTIMECLASS(class_name, base_class_name, 0xFFFF, \
                           class_name::CreateObject)

#define ASSERT_KINDOF(class_name, object) \
    assert((object)->IsKindOf(RUNTIME_CLASS(class_name)))
#define ASSERT_VALID(X) assert((X) != nullptr)

struct CRuntimeClass {
    const char *m_lpszClassName;
    int m_nObjectSize;
    unsigned int m_wSchema;
    CObject *(*m_pfnCreateObject)();
    const CRuntimeClass *m_pBaseClass;

    CObject *CreateObject() const;
    bool IsDerivedFrom(const CRuntimeClass *pBaseClass) const;
};

class CDumpContext {
};

class CObject {
public:
    static const CRuntimeClass classCObject;
public:
    CObject();
    CObject(const CObject &) = default;
    CObject &operator=(const CObject &) = default;
    virtual ~CObject() = 0;
    virtual const CRuntimeClass *GetRuntimeClass() const;

    virtual void AssertValid() const {}
    virtual void Dump(CDumpContext &dc) const {}

    bool IsKindOf(const CRuntimeClass *pClass) const;
};

class CFile : public CObject {
    DECLARE_DYNAMIC(CFile)
public:
    // Flag values
    enum OpenFlags {
        modeRead = (int)0x00000,
        modeWrite = (int)0x00001,
        modeReadWrite = (int)0x00002,
        shareCompat = (int)0x00000,
        shareExclusive = (int)0x00010,
        shareDenyWrite = (int)0x00020,
        shareDenyRead = (int)0x00030,
        shareDenyNone = (int)0x00040,
        modeNoInherit = (int)0x00080,
        typeUnicode = (int)0x00400, // used in derived classes (e.g. CStdioFile) only
        modeCreate = (int)0x01000,
        modeNoTruncate = (int)0x02000,
        typeText = (int)0x04000, // used in derived classes (e.g. CStdioFile) only
        typeBinary = (int)0x08000, // used in derived classes (e.g. CStdioFile) only
        osNoBuffer = (int)0x10000,
        osWriteThrough = (int)0x20000,
        osRandomAccess = (int)0x40000,
        osSequentialScan = (int)0x80000,
    };

    enum Attribute {
        normal = 0x00,                // note: not same as FILE_ATTRIBUTE_NORMAL
        readOnly = FILE_ATTRIBUTE_READONLY,
        hidden = FILE_ATTRIBUTE_HIDDEN,
        system = FILE_ATTRIBUTE_SYSTEM,
        volume = 0x08,
        directory = FILE_ATTRIBUTE_DIRECTORY,
        archive = FILE_ATTRIBUTE_ARCHIVE,
        device = FILE_ATTRIBUTE_DEVICE,
        temporary = FILE_ATTRIBUTE_TEMPORARY,
        sparse = FILE_ATTRIBUTE_SPARSE_FILE,
        reparsePt = FILE_ATTRIBUTE_REPARSE_POINT,
        compressed = FILE_ATTRIBUTE_COMPRESSED,
        offline = FILE_ATTRIBUTE_OFFLINE,
        notIndexed = FILE_ATTRIBUTE_NOT_CONTENT_INDEXED,
        encrypted = FILE_ATTRIBUTE_ENCRYPTED
    };

    enum SeekPosition {
        begin = 0x0, current = 0x1, end = 0x2
    };

private:
    Common::Stream *_stream = nullptr;

    Common::SeekableReadStream *readStream() const;
    Common::WriteStream *writeStream() const;

public:
    CFile() {}
    CFile(const char *lpszFileName, unsigned int nOpenFlags);
    ~CFile() {
        Close();
    }

    bool Open(const char *lpszFileName,
        unsigned int nOpenFlags = CFile::modeRead,
        CFileException *pError = nullptr);
    void Close();
    void Abort();
    uint64 SeekToEnd();
    void SeekToBegin();
    virtual uint64 Seek(int64 lOff, unsigned int nFrom);
    virtual uint64 GetLength() const;
    virtual uint64 GetPosition() const;

    virtual unsigned int Read(void *lpBuf, unsigned int nCount);
    virtual void Write(const void *lpBuf, unsigned int nCount);
    unsigned int ReadHuge(void *lpBuf, unsigned int nCount) {
        return Read(lpBuf, nCount);
    }

    operator Common::SeekableReadStream *() {
        return readStream();
    }
    operator Common::SeekableReadStream &() {
        return *readStream();
    }

    Common::SeekableReadStream *detach();
};

/*============================================================================*/
/* Exceptions - Not supported in ScummVM */
class CException {};
class CFileException : public CException {};

} // namespace MFC
} // namespace Bagel

#endif