wyfifofile.cpp

一个不错

/* Copyright is licensed under GNU LGPL.                 by I.J.Wang 2003

   documentation is in file wyfifofile.3wy
*/

#define WYLIB_SOURCE
#include "wyfifofile.h"
#include "wy_atdestroy.h"
#include <memory>
#include <typeinfo>

const char WyFifoFile::class_name[]="WyFifoFile";

Wy__FtBits WyFifoFile::cftbits(void) WY__NOTHROW__
{
 static const Wy__FtBits fb( Wy__FtBits(S_IFIFO) );
 return(fb);
};

WyFifoFile::WyFifoFile() 
try : WyByteFlow(cftbits()) {
}
catch(const WyByteFlow::Reply& e) {
  WY_THROW( Reply(e) );
}
catch(const WyRet& e) {
 WY_NDEBUG_MSG(e);
  WY_THROW( WyRet(e) );
};

WyFifoFile::WyFifoFile(WyFileHandle fh)
try : WyByteFlow(fh,cftbits()) {
}
catch(const WyByteFlow::Reply& e) {
  WY_THROW( Reply(e) );
}
catch(const WyRet& e) {
 WY_NDEBUG_MSG(e);
  WY_THROW( WyRet(e) );
};

WyFifoFile::WyFifoFile(const WySysFile& ff)
try : WyByteFlow(ff,cftbits()) {
}
catch(const WyByteFlow::Reply& e) {
  WY_THROW( Reply(e) );
}
catch(const WyRet& e) {
 WY_NDEBUG_MSG(e);
  WY_THROW( WyRet(e) );
};

WyFifoFile::WyFifoFile(const char* pathname,int f)
try : WyByteFlow(pathname,f,cftbits()) {
}
catch(const WyByteFlow::Reply& e) {
  WY_THROW( Reply(e) );
}
catch(const WyRet& e) {
 WY_NDEBUG_MSG(e);
  WY_THROW( WyRet(e) );
};

WyFifoFile::WyFifoFile(const WyStr& pathname,int f)
try : WyByteFlow(pathname,f,cftbits()) {
}
catch(const WyByteFlow::Reply& e) {
  WY_THROW( Reply(e) );
}
catch(const WyRet& e) {
 WY_NDEBUG_MSG(e);
  WY_THROW( WyRet(e) );
};

WyFifoFile::WyFifoFile(const WyFifoFile &ff)
try : WyByteFlow(ff,cftbits()) {
}
catch(const WyByteFlow::Reply& e) {
  WY_THROW( Reply(e) );
}
catch(const WyRet& e) {
 WY_NDEBUG_MSG(e);
  WY_THROW( WyRet(e) );
};

WyFifoFile::WyFifoFile(WyFifoFile &ff, Wy::ByMove_t) WY__TSPC()
 : WyByteFlow(ff,Wy::ByMove) 
{
};

WyFifoFile* WyFifoFile::_alloc(WyRet& r) const
try {
 if(WY__EQU_TYPEID(*this,WyFifoFile)==false) {
   r=Wym_ENOSYS; WY_HERE(r);        // _alloc not overridden
   return(NULL);
 }
 WyFifoFile* p=new(std::nothrow) WyFifoFile();
 if(p==NULL) {
   r=Wym_ENOMEM; WY_HERE(r);
 } else {
   r=Ok;
 }
 return(p);
}
catch(const Reply& e) {
 r=e; WY_HERE(r);
 return(NULL);
}
catch(const WyRet& e) {
 WY_NDEBUG_MSG(e);
 WY_THROW( WyRet(e) );
};

static void close_fds(const Wy__TypeFD& fd0, const Wy__TypeFD& fd1)
{
 WySysFile::wy_close(fd0);
 WySysFile::wy_close(fd1);
};

WyRet WyFifoFile::mkpipe(WyFifoFile& rd,WyFifoFile& wr)
try {
 if(static_cast<WyFifoFile*>(&rd)==static_cast<WyFifoFile*>(&wr)) {
   WY_RETURN( Wym_EINVAL );     // rd/wr are the same object
 }
 WyRet r;
 int fds[2];
 if(::pipe(fds)!=0) {
   WY_RETURN(errno);
 }
 Wy_AtDestroy2<void,const Wy__TypeFD&,const Wy__TypeFD&>
                                      rrad_fds(close_fds,fds[0],fds[1]);

 // Note: the algorithm uses reset instead of overwriting fd to save dup(..)
 //       is because of polymorphism of the argument objects
 //
 WyFifoFile* p0( rd._alloc(r) );
 if(r!=Ok) {
   WY_RETURN(Wym_ENOMEM);
 }
 Wy_AtDestroy<void,WySysFile*> rrad_p0(Wy::_delete_one,p0);

 WyFifoFile* p1( wr._alloc(r) );
 if(r!=Ok) {
   WY_RETURN(Wym_ENOMEM);
 }
 Wy_AtDestroy<void,WySysFile*> rrad_p1(Wy::_delete_one,p1);

 if((r=p0->reset( WyFileHandle(fds[0])))!=Ok) {
   WY_RETURN(r);
 }
 if((r=p1->reset( WyFileHandle(fds[1]) ))!=Ok) {
   WY_RETURN(r);
 }
 if((r=p0->_swap(rd))!=Ok) {
   WY_THROW(r);   // assertion failure
 }
 if((r=p1->_swap(wr))!=Ok) {
   WY_THROW(r);   // assertion failure
 }
 return(Ok);
}
catch(const WyRet& e) {
 WY_NDEBUG_MSG(e);
 WY_THROW( WyRet(e) );
};

WyRet WyFifoFile::create(const char* pathname,mode_t m)
{
 if(::mkfifo(pathname,m)!=0) {
   WY_RETURN(errno);
 }
 return(Ok);
};

WyRet WyFifoFile::create(const WyStr& pathname,mode_t m)
{
 if(::mkfifo(pathname.c_str(),m)!=0) {
   WY_RETURN(errno);
 }
 return(Ok);
};