be_io_archiverecstore.h

Go to the documentation of this file.

/*
 * This software was developed at the National Institute of Standards and
 * Technology (NIST) by employees of the Federal Government in the course
 * of their official duties. Pursuant to title 17 Section 105 of the
 * United States Code, this software is not subject to copyright protection
 * and is in the public domain. NIST assumes no responsibility whatsoever for
 * its use by other parties, and makes no guarantees, expressed or implied,
 * about its quality, reliability, or any other characteristic.
 */
 
#ifndef __BE_ARCHIVERECSTORE_H__
#define __BE_ARCHIVERECSTORE_H__
 
#include <be_io_recordstore.h>
 
namespace BiometricEvaluation {
        namespace IO {
                class ArchiveRecordStore : public RecordStore {
                public: 
                        static const std::string MANIFEST_FILE_NAME;
                        static const std::string ARCHIVE_FILE_NAME;
 
                        ArchiveRecordStore(
                            const std::string &pathname,
                            const std::string &description);
 
                         ArchiveRecordStore(
                             const std::string &pathname,
                             IO::Mode mode = IO::Mode::ReadOnly);
 
                        ~ArchiveRecordStore();
 
                        /*
                         * Implementations of RecordStore methods.
                         */
 
                        /*
                         * We need the base class insert() and replace() as well
                         * otherwise, they are hidden by the declarations below.
                         */
                        using RecordStore::insert;
                        using RecordStore::replace;
 
                        void sync() const override;
 
                        void insert(
                            const std::string &key,
                            const void *const data,
                            const uint64_t size)
                            override;
 
                        void remove(
                            const std::string &key)
                            override;
 
                        Memory::uint8Array read(
                            const std::string &key) const override;
 
                        uint64_t length(
                            const std::string &key) const override;
 
                        void flush(
                            const std::string &key) const override;
 
                        RecordStore::Record sequence(
                            int cursor = BE_RECSTORE_SEQ_NEXT)
                            override;
 
                        std::string
                        sequenceKey(
                            int cursor = BE_RECSTORE_SEQ_NEXT)
                            override;
 
                        void setCursorAtKey(
                            const std::string &key)
                            override;
 
                        void move(
                            const std::string &pathname)
                            override;
        
                        uint64_t getSpaceUsed() const override;
                        unsigned int getCount() const override;
                        std::string getPathname() const override;
                        std::string getDescription() const override;
                        void changeDescription(
                            const std::string &description) override;
 
                        bool needsVacuum();
 
                        static bool needsVacuum(
                            const std::string &pathname);
 
                        static void vacuum(
                            const std::string &pathname);
        
                        std::string getArchiveName() const;
        
                        std::string getManifestName() const;
                        
                        static const long OFFSET_RECORD_REMOVED = -1;
 
                        /* Prevent copying of ArchiveRecordStore objects */
                        ArchiveRecordStore(const ArchiveRecordStore&) = delete;
                        ArchiveRecordStore&
                        operator=(
                            const ArchiveRecordStore&) = delete;
 
                private:
                        class Impl;
                        std::unique_ptr<ArchiveRecordStore::Impl> pimpl;
                };
        }
}
 
#endif /* __BE_ARCHIVERECSTORE_H__ */