fileflow.h

 
/*
 *  Copyright (c) 2002    National Research Council
 *
 *  All rights reserved.
 *
 *  This material is confidential and proprietary information of
 *  National Research Council Canada ("Confidential Information").
 *  This Confidential Information may only be used and reproduced
 *  in accordance with the terms of the license agreement.
 *
 */
 
#ifndef __INCLUDED_SCOPIRA_TOOL_FILEFLOW_H__
#define __INCLUDED_SCOPIRA_TOOL_FILEFLOW_H__

#include <fcntl.h>

#include <scopira/tool/platform.h>

#include <scopira/tool/flow.h>
#include <scopira/tool/export.h>

namespace scopira
{
  namespace tool
  {
    class fileflow;

    class read_flocker;
    class write_flocker;

    class filememory;

    enum {
      copy_c = 0,
      copysoftlink_c = 1,
      copyhardlink_c = 2,
    };

    bool copy_file(const std::string &srcfile, const std::string &destfile, short copytype = copy_c);
  }
}

class scopira::tool::fileflow : public scopira::tool::iflow_i, public scopira::tool::oflow_i
{
  protected:
    mode_t dm_mode;
    int dm_hand;
    bool dm_fail;

  public:

    enum {
      append_c = 1024,
      trunc_c = 2048,
      linked_c = 4096,
      existing_c = 8192,
    };
    enum {
      stdin_c = -1,
      stdout_c = -2,
      stderr_c = -3
    };
    enum seek_dir_t {
      seek_start_c = 0,
      seek_end_c = 1,
      seek_cur_c
    };
    typedef ::off_t offset_t;

    SCOPIRA_EXPORT fileflow(void);
    SCOPIRA_EXPORT fileflow(const std::string& filename, mode_t mode);
    SCOPIRA_EXPORT fileflow(int fd, mode_t mode);

    SCOPIRA_EXPORT virtual ~fileflow();

    SCOPIRA_EXPORT virtual bool failed(void) const;

    SCOPIRA_EXPORT virtual size_t read(byte_t* _buf, size_t _maxsize);
    SCOPIRA_EXPORT virtual size_t write(const byte_t* _buf, size_t _size);

    SCOPIRA_EXPORT void open(const std::string& filename, mode_t mode);
    SCOPIRA_EXPORT void open(int fd,  mode_t mode);
    SCOPIRA_EXPORT void close(void);

    // gets the raw OS object. use with care
    int get_os_handle(void) const { return dm_hand; }

    // additional fileflow specific stuff: seeking

    SCOPIRA_EXPORT offset_t seek(offset_t howmuch, seek_dir_t dir = seek_start_c);
    SCOPIRA_EXPORT void seek_reset(void) { seek(0); };

    SCOPIRA_EXPORT offset_t tell(void) const;

    SCOPIRA_EXPORT bool resize(offset_t newsz);

    // additional fileflow specific stuff: locking

    SCOPIRA_EXPORT void read_lock(void);
    SCOPIRA_EXPORT bool try_read_lock(void);
    SCOPIRA_EXPORT void write_lock(void);
    SCOPIRA_EXPORT bool try_write_lock(void);
    SCOPIRA_EXPORT void unlock(void);
};

class scopira::tool::read_flocker
{
  protected:
    scopira::tool::fileflow &dm_file;
  public:
    read_flocker(fileflow &f) : dm_file(f) { dm_file.read_lock(); }
    ~read_flocker() { dm_file.unlock(); }
};

class scopira::tool::write_flocker
{
  protected:
    scopira::tool::fileflow &dm_file;
  public:
    write_flocker(fileflow &f) : dm_file(f) { dm_file.write_lock(); }
    ~write_flocker() { dm_file.unlock(); }
};

class scopira::tool::filememory
{
  public:
    typedef ::off_t offset_t;

    enum {
      read_c = 1,
      write_c = 2,
      private_c = 4,      // does MAP_PRIVATE instead of MAP_SHARED
    };
  private:
    void *dm_ptr;
    size_t dm_len;
#ifdef PLATFORM_win32
    HANDLE dm_mappingobj;
#endif
  public:
    SCOPIRA_EXPORT filememory(void);
    SCOPIRA_EXPORT ~filememory();

    void *c_array(void) const { return dm_ptr; }

    SCOPIRA_EXPORT bool open(fileflow &f, size_t len, int flags = read_c|write_c);
    SCOPIRA_EXPORT void close(void);

    SCOPIRA_EXPORT void sync(void);
};

#endif