DataFile.h

// -*- c++ -*-
#if !defined(_DATAFILE_H_)
#define _DATAFILE_H_

// system
#include <stdio.h>

// tools
#include "tools/Filename.h"
#include "tools/AutoPtr.h"
#include "tools/AutoFilePtr.h"

// storage
#include "storage/CtrlInfo.h"
#include "storage/RawValue.h"


class DataFile {

public:

    static const uint32_t cookie = 0x41444631;

    static DataFile *reference(const stdString &dirname,
                               const stdString &basename, bool for_write);

    DataFile *reference();

    size_t refCount() const
    {    return ref_count; }

    bool is_new_file;

    bool isTaggedFile() { return is_tagged_file; }
    
    //
    void release();

    bool is_writable() const
    { return for_write; }

    FileOffset getSize() const;
    
    void reopen();

  static void show_all_sizes();

    static size_t clear_cache();

    static void close_all();

    const stdString &getFilename() {   return filename; }

    const stdString &getDirname () {   return dirname;  }

    const stdString &getBasename() {   return basename; }

    class DataHeader *getHeader(FileOffset offset);

    size_t getHeaderSize(const stdString &name,
                         DbrType dbr_type, DbrCount dbr_count,
                         size_t num_samples);
    
    class DataHeader *addHeader(const stdString &name,
                                DbrType dbr_type, DbrCount dbr_count,
                                double period, size_t num_samples);

    void addCtrlInfo(const CtrlInfo &info, FileOffset &offset);

  void write(const CtrlInfo& ctrlInfo, FileOffset offset);

  void read(CtrlInfo& ctrlInfo, FileOffset offset);

private:

    friend class DataHeader;
    friend class DataWriter;
    friend class RawDataReaderEA3;
    // Attach DataFile to disk file of given name.
    // Existing file is opened, otherwise new one is created.
    // Unlike the reference() call, the constructor
    // expexts a normalized dirname/basename/filename.
    DataFile(const stdString &dirname,
             const stdString &basename,
             const stdString &filename, bool for_write);

    // Close file.
    ~DataFile();

    // prohibit assignment or implicit copy:
    // (these are not implemented, use reference() !)
    DataFile(const DataFile &other);
    DataFile &operator = (const DataFile &other);

    // The current data file
    AutoFilePtr file;
    size_t ref_count;
    bool   for_write;
    bool   is_tagged_file;
    stdString filename;
    stdString dirname;
    stdString basename;
};


class DataHeader {

public:
    

  DataHeader(DataFile *datafile);

  ~DataHeader();
    
  enum // Scott Meyers' "enum hack":
    {   FilenameLength = 40     };

  // NOTE: For now, the layout of the following must not
  // change because it defines the on-disk layout (except for byte order)!

  struct DataHeaderData {
    FileOffset  dir_offset;     
    FileOffset  next_offset;    
    FileOffset  prev_offset;    
    FileOffset  curr_offset;    
    uint32_t    num_samples;    
    FileOffset  ctrl_info_offset;  
    uint32_t    buf_size;  
    uint32_t    buf_free;       
    DbrType     dbr_type;       
    DbrCount    dbr_count;      
    uint8_t     pad[4];         
    double      period;         
    epicsTimeStamp  begin_time;  
    epicsTimeStamp  next_file_time; 
    epicsTimeStamp  end_time;       
    char        prev_file[FilenameLength]; 
    char        next_file[FilenameLength]; 
  } data; 

    DataFile *datafile;


    FileOffset offset;
    
    void clear();

    bool isValid();
    
    size_t available();

    size_t capacity();
    
    void read(FileOffset offset);

    void write() const;

    bool read_next();

    bool read_prev();

    void set_prev(const stdString &basename, FileOffset offset);
     
    void set_next(const stdString &basename, FileOffset offset);

    void show(FILE *f, bool full_detail);

private:
    bool get_prev_next(const char *name, FileOffset new_offset);
};


#endif // !defined(_DATAFILE_H_)