---

files.h

#ifndef CRYPTOPP_FILES_H
#define CRYPTOPP_FILES_H

#include "cryptlib.h"
#include "filters.h"

#include <iostream>
#include <fstream>

NAMESPACE_BEGIN(CryptoPP)

class FileStore : public Store
{
public:
        class Err : public BufferedTransformation::Err
        {
        public:
                Err(const std::string &s) : BufferedTransformation::Err(INPUT_ERROR, s) {}
        };
        class OpenErr : public Err {public: OpenErr(const std::string &filename) : Err("FileStore: error opening file for reading: " + filename) {}};
        class ReadErr : public Err {public: ReadErr() : Err("FileStore: error reading file") {}};

        FileStore(std::istream &in);
        FileStore(const char *filename);

        std::istream& GetStream() {return m_in;}

        unsigned long MaxRetrievable() const;
        unsigned int Peek(byte &outByte) const;

        unsigned long TransferTo(BufferedTransformation &target, unsigned long transferMax=ULONG_MAX);
        unsigned long CopyTo(BufferedTransformation &target, unsigned long copyMax=ULONG_MAX) const;

private:
        std::ifstream m_file;
        std::istream &m_in;
        SecByteBlock m_buffer;
};

class FileSource : public Source
{
public:
        typedef FileStore::Err Err;
        typedef FileStore::OpenErr OpenErr;
        typedef FileStore::ReadErr ReadErr;

        FileSource(std::istream &in, bool pumpAll, BufferedTransformation *outQueue = NULL);
        FileSource(const char *filename, bool pumpAll, BufferedTransformation *outQueue = NULL);

        std::istream& GetStream() {return m_store.GetStream();}

        unsigned long Pump(unsigned long pumpMax=ULONG_MAX)
                {return m_store.TransferTo(*AttachedTransformation(), pumpMax);}
        unsigned int PumpMessages(unsigned int count=UINT_MAX)
                {return m_store.TransferMessagesTo(*AttachedTransformation(), count);}

private:
        FileStore m_store;
};

class FileSink : public Sink
{
public:
        class Err : public BufferedTransformation::Err
        {
        public:
                Err(const std::string &s) : BufferedTransformation::Err(OUTPUT_ERROR, s) {}
        };
        class OpenErr : public Err {public: OpenErr(const std::string &filename) : Err("FileSink: error opening file for writing: " + filename) {}};
        class WriteErr : public Err {public: WriteErr() : Err("FileSink: error writing file") {}};

        FileSink(std::ostream &out);
        FileSink(const char *filename, bool binary=true);

        std::ostream& GetStream() {return out;}

        void Flush(bool=true, int=-1);
        void MessageEnd(int=-1);
        void Put(byte inByte)
        {
                out.put(inByte);
                if (!out.good())
                  throw WriteErr();
        }

        void Put(const byte *inString, unsigned int length);

private:
        std::ofstream file;
        std::ostream& out;
};

NAMESPACE_END

#endif

---