Writer.h

浏览该文件的文档.

/************************************************************************
* @file Writer.h
*
* @brief
*
* @details
*
* @author wukx
*
* @version  v1.0
*
* @date  2016.9.30
*
* @license 北京华科软科技有限公司
*
*************************************************************************/
 
#ifndef BIMHOMEBASE_WRITER_H
#define BIMHOMEBASE_WRITER_H
 
 
#include <set>
#include <string>
#include <sstream>
#include <vector>
#include <cassert>
 
#ifdef _MSC_VER
#include <zipios++/zipios-config.h>
#endif
#include <zipios++/zipfile.h>
#include <zipios++/zipinputstream.h>
#include <zipios++/zipoutputstream.h>
#include <zipios++/meta-iostreams.h>
 
#include <Base/Common/FileInfo.h>
 
 
 
namespace Base
{
 
    class Persistence;
 
    class BaseExport Writer
    {
    public:
        Writer();
 
        virtual ~Writer();
 
        void setForceXML(bool on);
 
        bool isForceXML();
 
        void setFileVersion(int version);
 
        int getFileVersion() const;
 
        void insertAsciiFile(const char* FileName);
 
        void insertBinFile(const char* FileName);
 
        std::string addFile(const char* Name, const Base::Persistence* Object, std::string Path = "");
 
        virtual void writeFiles() = 0;
 
        const std::vector<std::string>& getFilenames() const;
 
        void setMode(const std::string& mode);
 
        void setModes(const std::set<std::string>& modes);
 
        bool getMode(const std::string& mode) const;
 
        std::set<std::string> getModes() const;
 
        void clearMode(const std::string& mode);
 
        void clearModes();
 
        void addError(const std::string& error);
 
        bool hasErrors() const;
 
        void clearErrors();
 
        std::vector<std::string> getErrors() const;
 
        const char* ind() const { return indBuf; }
 
        void incInd();
 
        void decInd();
 
        virtual std::ostream& Stream() = 0;
 
        std::string ObjectName;
 
        std::string getUniqueFileName(const char* Name);
 
    protected:
        struct FileEntry
        {
            std::string FileName; 
            const Base::Persistence* Object; 
            std::string FilePath; 
        };
 
        std::vector<FileEntry> FileList; 
        std::vector<std::string> FileNames; 
        std::vector<std::string> Errors; 
        std::set<std::string> Modes; 
        short indent; 
        char indBuf[1024]; 
        bool forceXML; 
        int fileVersion; 
    private:
        Writer(const Writer&); 
        Writer& operator=(const Writer&); 
    };
 
 
    class BaseExport ZipWriter : public Writer
    {
    public:
        ZipWriter(const char* FileName);
 
        ZipWriter(std::ostream&);
 
        virtual ~ZipWriter();
 
        virtual void writeFiles();
 
        virtual std::ostream& Stream() { return ZipStream; }
 
        void setComment(const char* str) { ZipStream.setComment(str); }
 
        void setLevel(int level) { ZipStream.setLevel(level); }
 
        void putNextEntry(const char* str) { ZipStream.putNextEntry(str); }
 
        zipios::ZipOutputStream& getZipStream() { return ZipStream; }
 
    private:
        zipios::ZipOutputStream ZipStream; 
    };
 
    class BaseExport StringWriter : public Writer
    {
    public:
        virtual std::ostream& Stream() { return StrStream; }
 
        std::string getString() const { return StrStream.str(); }
 
        virtual void writeFiles() {}
 
    private:
        std::stringstream StrStream; 
    };
 
    class BaseExport FileWriter : public Writer
    {
    public:
        FileWriter(const char* DirName);
 
        virtual ~FileWriter();
 
        void putNextEntry(const char* file);
 
        virtual void writeFiles();
 
        virtual std::ostream& Stream() { return FileStream; }
 
        void close() { FileStream.close(); }
 
        virtual bool shouldWrite(const std::string& name, const Base::Persistence* Object) const;
 
    protected:
        std::string DirName; 
        std::ofstream FileStream; 
    };
 
 
}  //namespace Base
 
 
#endif // BIMHOMEBASE_WRITER_H