wefts_coffee_base.h

Go to the documentation of this file.

/*
   wefts_coffee_base.h
   Abstract base class for cooperative file functions enlarged environment

   $Id: wefts_coffee_base.h,v 1.6 2004/04/01 04:30:17 jonnymind Exp $
---------------------------------------------
   Begin      : 2003-08-15 16:30
   Author     : Giancarlo Niccolai

   Last modified because:

*/

/**************************************************************************
*   This program is free software; you can redistribute it and/or modify  *
*   it under the terms of the GNU Library General Public License as       *
*   published by the Free Software Foundation; either version 2.1 of the  *
*   License, or (at your option) any later version.                       *
***************************************************************************/


#ifndef WT_COFFEE_BASE_H
#define WT_COFFEE_BASE_H

#include <wefts_cleanup.h>
#include <string>

namespace Wefts {

#if defined(_MSC_VER) || defined(__BORLANDC__) 
typedef unsigned __int64 file_size_t;
#else
typedef long long file_size_t;
#endif

typedef enum {
   /* The file should not be locked */
   LM_SHARED,
   /* The file should not be locked against writes, but read may occur */
   LM_SHARED_RO,
   /* The file should not be locked against both reads & writes */
   LM_EXCLUSIVE,
} LockMode;


typedef enum {
   OM_RO,
   OM_WO,
   OM_RW,
   OM_TRUNC_WO,
   OM_TRUNC_RW,
   OM_APPEND_WO,
   OM_APPEND_RW
} OpenMode;

typedef enum {
   CM_ARCHIVE,
   CM_SYSTEM,
   CM_EXECUTABLE,
   CM_PRIVATE,
   CM_PRIVATE_EX
} CreateMode;


typedef enum {
   CFF_DONE,
   CFF_WAITING,
   CFF_TIMEDOUT,

   CFF_SOFTERROR,

   CFF_HARDERROR,

   CFF_PROGERROR
}CffStatus;

typedef enum {
   SW_FROM_BEGIN=0,
   SW_FROM_CUR=1,
   SW_FROM_CURENT=1,
   SW_FROM_END=2
} SeekWhence;

class OSFileFuncBase {
protected:
   OSFileFuncBase() {
      m_timeout = -1.0;
      m_osError = 0;
      m_status = CFF_DONE;
   }

   double m_timeout;
   CffStatus m_status;
   int m_osError;

public:
   virtual inline CffStatus open(
      std::string filespec,             // the file name
      OpenMode openMode = OM_RO,        // open mode
      LockMode lockMode = LM_SHARED   // the file lock mode
      ) = 0;

   virtual inline CffStatus create(
      std::string filespec,               // the file name
      CreateMode cMode = CM_ARCHIVE,      // system atrribute
      LockMode lockMode = LM_EXCLUSIVE  // the file lock mode
      ) = 0;

   inline virtual void getDescriptor( void *data ) const = 0;

   inline virtual void setDescriptor( void *data ) = 0;


   inline CffStatus status() const { return m_status; }

   inline void status(const CffStatus st ) { m_status = st ; }

   inline int osError() const { return m_osError; }

   inline void osError( const int osError ) { m_osError = osError; }


   inline double timeout() const { return m_timeout; }

   inline void timeout( const double to ) { m_timeout = to; }

   /* Clears the timeout.
     All the operations on this class will be blocking.
   */
   inline void clearTimeout() { timeout( -1.0 ); }

   /* Set all operations on this class to be non-blocking.
     Functions will return immediately if the operation cannot be
     compelted without any wait.
   */
   inline void dontBlock() { timeout( 0.0 ); }

   virtual file_size_t read( void *buffer, const file_size_t len ) = 0;

   virtual file_size_t write( void *buffer, const file_size_t len ) = 0;

   virtual file_size_t seek(
      const file_size_t position,
      const SeekWhence swFrom= SW_FROM_BEGIN
      ) = 0;

   virtual CffStatus close()=0;

   inline virtual void setStdIn() = 0;
   
   inline virtual void setStdOut() = 0;
   
   inline virtual void setStdErr() = 0;

};

class OSProcessBase: public CleanupHandler
{
private:
   void internal_init()
   {
      m_started = false;
      m_ended = false;
      m_mergeStdErr = false;
      m_retval = -1;
      m_osError = 0;
      m_detached = false;
   }

protected:
   int m_osError;
   bool m_started;
   bool m_ended;
   bool m_mergeStdErr;
   int m_retval;
   bool m_detached;
   OSProcessBase()
      :CleanupHandler()
   {
      internal_init();
   }
   
public:
   
   virtual bool running()=0;
   
   virtual bool wait( const double seconds=-1.0 )=0;
   
   virtual bool start( const std::string process, bool useShell=false, bool usePath=true )=0;
   
   virtual bool stop()=0;
   
   virtual bool getProcessValue( int &retvalue ) const=0;
   
   int osError() const { return m_osError; }

   virtual file_size_t getProcessId() const =0;   
   
   virtual int write( const void *data, const int size, const double seconds=-1.0 )=0;
   
   virtual int read( void *data, const int size, const double seconds=-1.0 )=0;
   
   virtual int readStdErr( void *data, const int size, const double seconds=-1.0 )=0;
   
   virtual void mergeStdErr()=0;
   
   virtual void detach()=0;
   
   virtual void sinkInput() = 0;
   virtual void sinkOutput() = 0;
   virtual void sinkError() = 0;

   virtual bool closeRead()=0;
   virtual bool closeWrite()=0;
   virtual bool closeStdErr()=0;
   
   virtual void handleCleanup( int code, void *caller=0 ) = 0;
};

} // namespace

#endif

/* end of wefts_coffee_base.h */

---