File content as of revision 6:6f002d202f59:

#ifndef SN_SnSDUtils
#define SN_SnSDUtils

#include <stdio.h>
#include <stdint.h>

#include "SnCommWin.h"
#include "SnBitUtils.h"
#include "SnPowerFrame.h"

class SnEventFrame;
class SnConfigFrame;

// a namespace-like class to handle the i/o with the SD card

class SnSDUtils {
 public:
    static const char* const kSDsubDir;
    static const uint8_t     kFNBufSize=128;
    static const uint8_t     kIOvers; // file I/O version
    static const uint32_t    kMaxSizeOfFileHdr;
    
 private:
    
    static
    FILE* OpenSDFile(const char* name, const char* mode);
    
    static
    uint16_t GetSeqNum(const uint64_t macadr,
                       const uint32_t run);
    
    static
    const char* GetOutFileName(const uint64_t macadr,
                               const uint32_t run,
                               const uint16_t seq);
    
    static
    void  DeleteFile(FILE*& f, const char* fname);
        
    static char fgCurFileName[kFNBufSize];
    static FILE* fgCurFile;
    
 public:
    SnSDUtils() {}
    virtual ~SnSDUtils() {}
    
    static
    int   CloseOutputFile(FILE* f)
        { return (f!=0) ? fclose(f) : 0; }
    
    static
    FILE* OpenNewOutputFile(const uint64_t macadr,
                            const uint32_t run,
                            const uint16_t v1, const uint16_t v2);
    
    static
    FILE* OpenExistingFile(const char* name, const bool setcurrent);
    
    static
    SnCommWin::ECommWinResult SendAllFiles(SnCommWin* comm,
                                           const bool doDelete,
                                           const uint32_t timeout,
                                           char* const buf,
                                           const uint32_t bsize,
                                           const SnConfigFrame& curConf,
                                                 SnEventFrame& evt);
    
    static
    const char* GetCurFileName() { return fgCurFileName; }
    
    static
    FILE*       GetCurFile() { return fgCurFile; }
    
    static
    bool  WriteEventTo(FILE* efile, char* const evtBuf,
                       const SnEventFrame& evt,
                       const SnConfigFrame& conf);
    
    static
    bool  WriteConfig(FILE* efile,
                      const SnConfigFrame& conf);
    /*
    static
    bool  WriteFileHeader(FILE* f, const uint64_t macadr,
                          const uint32_t run, const uint16_t seq,
                          const uint16_t v1, const uint16_t v2);
    
    static
    bool  ReadFileHeader(FILE* f, uint64_t& macadr,
                         uint32_t& run, uint16_t& seq,
                         uint16_t& v1, uint16_t& v2);
    */
    template<class T>
    static
    SnCommWin::ECommWinResult WriteFileHeader(T& f, const uint64_t macadr,
                      const uint32_t run, const uint16_t seq,
                      const uint16_t v1, const uint16_t v2) {
        // MUST INCREMENT kIOvers if these writes are altered
        f = SnBitUtils::WriteTo(f, kIOvers);
        f = SnBitUtils::WriteTo(f, macadr);
        f = SnBitUtils::WriteTo(f, run);
        f = SnBitUtils::WriteTo(f, seq);
        SnPowerFrame::WriteTo(f, v1, v2);
        return SnCommWin::kOkMsgSent;
    }
    
    template<class T>
    static
    SnCommWin::ECommWinResult ReadFileHeader(T& f, uint64_t& macadr,
                     uint32_t& run, uint16_t& seq,
                     uint16_t& v1, uint16_t& v2) {
        uint8_t Rv=0;
        f = SnBitUtils::ReadFrom(f, Rv);
        f = SnBitUtils::ReadFrom(f, macadr);
        f = SnBitUtils::ReadFrom(f, run);
        f = SnBitUtils::ReadFrom(f, seq);
        if (Rv>1) {
            SnPowerFrame::ReadFrom(f, v1, v2);
        }
        return SnCommWin::kOkWithMsg;
    }
    
    static
    uint32_t SizeOfFileHeader() { return kMaxSizeOfFileHdr; }
    
    friend class SnSDUtilsWhisperer; // to restrict access to specific functions
};

class SnSDUtilsWhisperer {
    static
    void  DeleteFile(FILE*& f, const char* fname) {
        return SnSDUtils::DeleteFile(f, fname);
    }
    
    friend class SnCommWin; // the one who's allowed to use me
};

#endif // SN_SnSDUtils