#ifndef HelpersH
#define HelpersH

/*
  Helpers.h - internal 'stream' like helpers

************************************************************************
 Copyright (C) 2009, 2010  by Russell J. Peters, Roger Aelbrecht

   This file is part of TZipMaster Version 1.9.

    TZipMaster 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 3 of the License, or
    (at your option) any later version.

    TZipMaster 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 TZipMaster.  If not, see <http://www.gnu.org/licenses/>.

    contact: problems@delphizip.org (include ZipMaster in the subject).
    updates: http://www.delphizip.org
    DelphiZip maillist subscribe at http://www.freelists.org/list/delphizip 
************************************************************************

  last modified 2009-07-05
---------------------------------------------------------------------------*/

// return >0 has drive, 0 no drive, -1 stream, -2 autostream
bool __fastcall ZStreamStat(const char *fn, struct stati64 *res);

class ZStreamIO
{
private:
    ZStreamIO(const ZStreamIO& src);
    ZStreamIO& operator=(const ZStreamIO &src);
    int canseek;
    bool __fastcall GetIsSeekable(void);
protected:
    DZStrW ffname;
    bool fFile;
    bool fIsTemp;
    DZOp *Owner;
    virtual bool __fastcall DefSeekable(void) = 0;
public:
    ZStreamIO(DZOp *theOwner, const DZStrW& filename);
    virtual ~ZStreamIO();
    bool operator!() const;
    virtual bool Read(LPVOID lpBuffer, DWORD nNumberOfBytesToRead,
                      LPDWORD lpNumberOfBytesRead) = 0;
    virtual bool Write(LPCVOID lpBuffer, DWORD nNumberOfBytesToWrite,
                       LPDWORD lpNumberOfBytesWritten) = 0;
    virtual __int64 SetPosition(__int64 ofs, int from) = 0;
    virtual bool SetTime(const FILETIME* lpCreationTime,
                         const FILETIME* lpLastAccessTime,
                         const FILETIME* lpLastWriteTime) = 0;
    virtual bool GetTime(FILETIME* lpCreationTime,
                         FILETIME* lpLastAccessTime,
						 FILETIME* lpLastWriteTime) = 0;
	virtual bool SetEndOfFile(void);
    virtual bool Close() = 0;
    virtual bool IsOpen() const = 0;
    __property bool IsFile = {read = fFile};
    __property DZStrW fname = {read = ffname};
    __property bool IsTemp = {read = fIsTemp, write = fIsTemp};
    __property bool IsSeekable = {read = GetIsSeekable};
};

class ZFile: public ZStreamIO
{
private:
    ZFile(const ZFile& src);
    ZFile& operator=(const ZFile &src);
    HANDLE fHandle;
protected:
    virtual bool __fastcall DefSeekable(void);
public:
    ZFile(DZOp *theOwner, const DZStrW& lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode,
          LPSECURITY_ATTRIBUTES lpSecurityAttributes,
          DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes);
    ZFile(DZOp *theOwner, const DZStrW& lpFileName, DWORD Flags);
    virtual ~ZFile();
    bool Read(LPVOID lpBuffer, DWORD nNumberOfBytesToRead,
              LPDWORD lpNumberOfBytesRead);
    bool Write(LPCVOID lpBuffer, DWORD nNumberOfBytesToWrite,
               LPDWORD lpNumberOfBytesWritten);
    __int64 SetPosition(__int64 ofs, int from);
    bool SetTime(const FILETIME* lpCreationTime,
                 const FILETIME* lpLastAccessTime,
                 const FILETIME* lpLastWriteTime);
    bool GetTime(FILETIME* lpCreationTime,
                 FILETIME* lpLastAccessTime,
				 FILETIME* lpLastWriteTime);
	bool SetEndOfFile(void);
    bool Close();
	bool IsOpen() const;
};

class ZStream: public ZStreamIO
{
private:
    ZStream(const ZStream& src);
    ZStream& operator=(const ZStream &src);
    bool CanClose;
    void* zHandle;
    int Number;
protected:
    virtual bool __fastcall DefSeekable(void);
public:
    ZStream(DZOp *theOwner, const DZStrW& filename, void* astream);
    ZStream(DZOp *theOwner, const DZStrW& filename);
    virtual ~ZStream();
    bool Read(LPVOID lpBuffer, DWORD nNumberOfBytesToRead,
              LPDWORD lpNumberOfBytesRead);
    bool Write(LPCVOID lpBuffer, DWORD nNumberOfBytesToWrite,
               LPDWORD lpNumberOfBytesWritten);
    __int64 SetPosition(__int64 ofs, int from);
    bool SetTime(const FILETIME* lpCreationTime,
                 const FILETIME* lpLastAccessTime,
                 const FILETIME* lpLastWriteTime);
    bool GetTime(FILETIME* lpCreationTime,
                 FILETIME* lpLastAccessTime,
				 FILETIME* lpLastWriteTime);
    bool Close();
	bool IsOpen() const;
};

class AutoStream
{
private:
    AutoStream(const AutoStream& src);
    AutoStream& operator=(const AutoStream &src);
    ZStreamIO **theStream;
public:
    AutoStream(ZStreamIO **zs);
    ~AutoStream();
    operator ZStreamIO*()const
    {
        return *theStream;
    };

    void Assign(ZStreamIO **zs);
    ZStreamIO *Stream()
    {
        return *theStream;
    };
};

#endif