TZIPMember

class TZIPMember : public TArchiveMember

    public:

                      TZIPMember()
                      TZIPMember(const char* name)
                      TZIPMember(const TZIPMember& member)
              virtual ~TZIPMember()
       static TClass* Class()
               UInt_t GetAttrExt() const
               UInt_t GetAttrInt() const
               UInt_t GetCRC32() const
                void* GetGlobal() const
             Long64_t GetGlobalLen() const
               UInt_t GetLevel() const
                void* GetLocal() const
             Long64_t GetLocalLen() const
               UInt_t GetMethod() const
      virtual TClass* IsA() const
          TZIPMember& operator=(const TZIPMember& rhs)
         virtual void Print(Option_t* option = "") const
         virtual void ShowMembers(TMemberInspector& insp, char* parent)
         virtual void Streamer(TBuffer& b)
                 void StreamerNVirtual(TBuffer& b)

Data Members

    private:

         void* fLocal      Extra file header data
      Long64_t fLocalLen   Length of extra file header data
         void* fGlobal     Extra directory data
      Long64_t fGlobalLen  Length of extra directory data
        UInt_t fCRC32      CRC-32 for all decompressed data
        UInt_t fAttrInt    Internal file attributes
        UInt_t fAttrExt    External file attributes
        UInt_t fMethod     Compression type
        UInt_t fLevel      Compression level

Class Description

                                                                      
 TZIPFile                                                             
                                                                      
 This class describes a ZIP archive file containing multiple          
 sub-files. Typically the sub-files are ROOT files. Notice that       
 the ROOT files should not be compressed when being added to the      
 ZIP file, since ROOT files are normally already compressed.          
 Such a ZIP file should be created like:                              
                                                                      
    zip -n root multi file1.root file2.root                           
                                                                      
 which creates a ZIP file multi.zip.                                  
                                                                      
 A ZIP archive consists of files compressed with the popular ZLIB     
 compression algorithm. The archive format is used among others by    
 PKZip and Info-ZIP. The compression algorithm is also used by        
 GZIP and the PNG graphics standard. The format of the archives is    
 explained briefly below. This class provides an interface to read    
 such archives.                                                       
                                                                      
 A ZIP archive contains a prefix, series of archive members           
 (sub-files), and a central directory. In theory the archive could    
 span multiple disks (or files) with the central directory of the     
 whole archive on the last disk, but this class does not support      
 such multi-part archives. The prefix is only used in self-extracting 
 executable archive files.                                            
                                                                      
 The members are stored in the archive sequentially, each with a      
 local header followed by the (optionally) compressed data; the local 
 header describes the member, including its file name and compressed  
 and real sizes. The central directory includes the member details    
 again, plus allows an extra member comment to be added. The last     
 member in the central directory is an end marker that can contain    
 a comment for the whole archive. Both the local header and the       
 central directory can also carry extra member-specific data; the     
 data in the local and global parts can be different.                 
 The fact that the archive has a global directory makes it efficient  
 and allows for only the reading of the desired data, one does not    
 have to scan through the whole file to find the desired sub-file.    
                                                                      
 Once the archive has been opened, the client can query the members   
 and read their contents by asking the archive for an offset where    
 the sub-file starts. The members can be accessed in any order.       
                                                                      

 Default ctor.

 Create ZIP member file.

 Copy ctor.

 Cleanup.

 Pretty print basic ZIP member info.

Inline Functions

        TZIPMember& operator=(const TZIPMember& rhs)
              void* GetLocal() const
           Long64_t GetLocalLen() const
              void* GetGlobal() const
           Long64_t GetGlobalLen() const
             UInt_t GetCRC32() const
             UInt_t GetAttrInt() const
             UInt_t GetAttrExt() const
             UInt_t GetMethod() const
             UInt_t GetLevel() const
            TClass* Class()
            TClass* IsA() const
               void ShowMembers(TMemberInspector& insp, char* parent)
               void Streamer(TBuffer& b)
               void StreamerNVirtual(TBuffer& b)