XrdOssWrapper.hh

Go to the documentation of this file.

#ifndef _XRDOSSWRAPPER_H
#define _XRDOSSWRAPPER_H
/******************************************************************************/
/*                                                                            */
/*                      X r d O s s W r a p p e r . h h                       */
/*                                                                            */
/* (c) 2020 by the Board of Trustees of the Leland Stanford, Jr., University  */
/*                            All Rights Reserved                             */
/*   Produced by Andrew Hanushevsky for Stanford University under contract    */
/*              DE-AC02-76-SFO0515 with the Department of Energy              */
/*                                                                            */
/* This file is part of the XRootD software suite.                            */
/*                                                                            */
/* XRootD is free software: you can redistribute it and/or modify it under    */
/* the terms of the GNU Lesser General Public License as published by the     */
/* Free Software Foundation, either version 3 of the License, or (at your     */
/* option) any later version.                                                 */
/*                                                                            */
/* XRootD is distributed in the hope that it will be useful, but WITHOUT      */
/* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or      */
/* FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public       */
/* License for more details.                                                  */
/*                                                                            */
/* You should have received a copy of the GNU Lesser General Public License   */
/* along with XRootD in a file called COPYING.LESSER (LGPL license) and file  */
/* COPYING (GPL license).  If not, see <http://www.gnu.org/licenses/>.        */
/*                                                                            */
/* The copyright holder's institutional names and contributor's names may not */
/* be used to endorse or promote products derived from this software without  */
/* specific prior written permission of the institution or contributor.       */
/******************************************************************************/
 
#include "XrdOss/XrdOss.hh"
 
/******************************************************************************/
/******************************************************************************/
 
/******************************************************************************/
/*                    C l a s s   X r d O s s W r a p D F                     */
/******************************************************************************/
 
 
class XrdOssWrapDF : public XrdOssDF
{
public:
 
/******************************************************************************/
/*            D i r e c t o r y   O r i e n t e d   M e t h o d s             */
/******************************************************************************/
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual int     Opendir(const char *path, XrdOucEnv &env)
                       {return wrapDF.Opendir(path, env);}
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual int     Readdir(char *buff, int blen)
                       {return wrapDF.Readdir(buff, blen);}
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual int     StatRet(struct stat *Stat) {return wrapDF.StatRet(Stat);}
 
/******************************************************************************/
/*                 F i l e   O r i e n t e d   M e t h o d s                  */
/******************************************************************************/
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual int     Clone(XrdOssDF& srcFile) {return wrapDF.Clone(srcFile);}
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual int     Clone(const std::vector<XrdOucCloneSeg> &cVec)
                    {return wrapDF.Clone(cVec);}
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual int     Fchmod(mode_t mode) {return wrapDF.Fchmod(mode);}
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual void    Flush() {wrapDF.Flush();}
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual int     Fstat(struct stat *buf) {return wrapDF.Fstat(buf);}
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual int     Fsync() {return wrapDF.Fsync();}
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual int     Fsync(XrdSfsAio *aiop) {return wrapDF.Fsync(aiop);}
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual int     Ftruncate(unsigned long long flen)
                         {return wrapDF.Ftruncate(flen);}
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual off_t   getMmap(void **addr) {return wrapDF.getMmap(addr);}
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual int     isCompressed(char *cxidp=0) {return wrapDF.isCompressed(cxidp);}
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual int     Open(const char *path, int Oflag, mode_t Mode, XrdOucEnv &env)
                    {return wrapDF.Open(path, Oflag, Mode, env);}
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual ssize_t pgRead (void* buffer, off_t offset, size_t rdlen,
                        uint32_t* csvec, uint64_t opts)
                       {return wrapDF.pgRead(buffer,offset,rdlen,csvec,opts);}
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual int     pgRead (XrdSfsAio* aioparm, uint64_t opts)
                                              {return wrapDF.pgRead(aioparm, opts);}
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual ssize_t pgWrite(void* buffer, off_t offset, size_t wrlen,
                        uint32_t* csvec, uint64_t opts)
                       {return wrapDF.pgWrite(buffer,offset,wrlen,csvec,opts);}
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual int     pgWrite(XrdSfsAio* aioparm, uint64_t opts)
                       {return wrapDF.pgWrite(aioparm, opts);}
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual ssize_t Read(off_t offset, size_t size)
                    {return wrapDF.Read(offset, size);}
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual ssize_t Read(XrdOucRangeList& rlist)
                    {return wrapDF.Read(rlist);}
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual ssize_t Read(void *buffer, off_t offset, size_t size)
                    {return wrapDF.Read(buffer, offset, size);}
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual int     Read(XrdSfsAio *aiop) {return wrapDF.Read(aiop);}
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual ssize_t ReadRaw(void *buffer, off_t offset, size_t size)
                       {return wrapDF.ReadRaw(buffer, offset, size);}
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual ssize_t ReadV(XrdOucIOVec *readV, int rdvcnt)
                     {return wrapDF.ReadV(readV, rdvcnt);}
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual ssize_t Write(const void *buffer, off_t offset, size_t size)
                     {return wrapDF.Write(buffer, offset, size);}
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual int     Write(XrdSfsAio *aiop) {return wrapDF.Write(aiop);}
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual ssize_t WriteV(XrdOucIOVec *writeV, int wrvcnt)
                      {return wrapDF.WriteV(writeV, wrvcnt);}
 
/******************************************************************************/
/*     C o m m o n   D i r e c t o r y   a n d   F i l e   M e t h o d s      */
/******************************************************************************/
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual int     Close(long long *retsz=0) {return wrapDF.Close(retsz);}
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
uint16_t        DFType() {return wrapDF.DFType();}
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual int     Fctl(int cmd, int alen, const char *args, char **resp=0)
                    {return wrapDF.Fctl(cmd, alen, args, resp);}
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual bool    getErrMsg(std::string& eText) {return wrapDF.getErrMsg(eText);}
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual int     getFD() {return wrapDF.getFD();}
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
virtual
const char     *getTID() {return wrapDF.getTID();}
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
                XrdOssWrapDF(XrdOssDF &df2Wrap) : wrapDF(df2Wrap) {}
 
virtual        ~XrdOssWrapDF() {}
 
 
protected:
 
XrdOssDF   &wrapDF;  // Object being wrapped
};
 
/******************************************************************************/
/*                   C l a s s   X r d O s s W r a p p e r                    */
/******************************************************************************/
 
class XrdOssWrapper : public XrdOss
{
public:
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual XrdOssDF     *newDir(const char *tident)
                            {return wrapPI.newDir(tident);}
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual XrdOssDF     *newFile(const char *tident)
                             {return wrapPI.newFile(tident);}
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual int       Chmod(const char * path, mode_t mode, XrdOucEnv *envP=0)
                       {return wrapPI.Chmod(path, mode, envP);}
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual void      Connect(XrdOucEnv &env) {wrapPI.Connect(env);}
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual int       Create(const char *tid, const char *path, mode_t mode,
                         XrdOucEnv &env, int opts=0)
                        {return wrapPI.Create(tid, path, mode, env, opts);}
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual void      Disc(XrdOucEnv &env) {wrapPI.Disc(env);}
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual void      EnvInfo(XrdOucEnv *envP) {wrapPI.EnvInfo(envP);}
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual uint64_t  Features() {return wrapPI.Features();}
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual bool      getErrMsg(std::string& eText)
                           {return wrapPI.getErrMsg(eText);}
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual int       FSctl(int cmd, int alen, const char *args, char **resp=0)
                       {return wrapPI.FSctl(cmd, alen, args, resp);}
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual int       Init(XrdSysLogger *lp, const char *cfn)
                      {return wrapPI.Init(lp, cfn);}
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual int       Init(XrdSysLogger *lp, const char *cfn, XrdOucEnv *envP)
                      {return wrapPI.Init(lp, cfn, envP);}
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual int       Mkdir(const char *path, mode_t mode, int mkpath=0,
                        XrdOucEnv  *envP=0)
                       {return wrapPI.Mkdir(path, mode, mkpath, envP);}
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual int       Reloc(const char *tident, const char *path,
                        const char *cgName, const char *anchor=0)
                       {return wrapPI.Reloc(tident,path,cgName,anchor);}
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual int       Remdir(const char *path, int Opts=0, XrdOucEnv *envP=0)
                        {return wrapPI.Remdir(path, Opts, envP);}
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual int       Rename(const char *oPath, const char *nPath,
                         XrdOucEnv  *oEnvP=0, XrdOucEnv *nEnvP=0)
                        {return wrapPI.Rename(oPath, nPath, oEnvP, nEnvP);}
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual int       Stat(const char *path, struct stat *buff,
                       int opts=0, XrdOucEnv *envP=0)
                      {return wrapPI.Stat(path, buff, opts, envP);}
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual int       Stats(char *buff, int blen)
                       {return wrapPI.Stats(buff, blen);}
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual int       StatFS(const char *path, char *buff, int &blen,
                         XrdOucEnv  *envP=0)
                        {return wrapPI.StatFS(path, buff, blen, envP);}
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual int       StatLS(XrdOucEnv &env, const char *path,
                         char *buff, int &blen)
                        {return wrapPI.StatLS(env, path, buff, blen);}
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual int       StatPF(const char *path, struct stat *buff, int opts)
                        {return wrapPI.StatPF(path, buff, opts);}
 
virtual int       StatPF(const char *path, struct stat *buff)
                        {return wrapPI.StatPF(path, buff);}
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual int       StatVS(XrdOssVSInfo *vsP, const char *sname=0, int updt=0)
                        {return wrapPI.StatVS(vsP, sname, updt);}
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual int       StatXA(const char *path, char *buff, int &blen,
                         XrdOucEnv *envP=0)
                        {return wrapPI.StatXA(path, buff, blen, envP);}
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual int       StatXP(const char *path, unsigned long long &attr,
                         XrdOucEnv  *envP=0)
                        {return wrapPI.StatXP(path, attr, envP);}
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual int       Truncate(const char *path, unsigned long long fsize,
                           XrdOucEnv *envP=0)
                          {return wrapPI.Truncate(path, fsize, envP);}
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual int       Unlink(const char *path, int Opts=0, XrdOucEnv *envP=0)
                        {return wrapPI.Unlink(path, Opts, envP);}
 
                  // Default Name-to-Name Methods
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
virtual int       Lfn2Pfn(const char *Path, char *buff, int blen)
                         {return wrapPI.Lfn2Pfn(Path, buff, blen);}
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
virtual
const char       *Lfn2Pfn(const char *Path, char *buff, int blen, int &rc)
                         {return wrapPI.Lfn2Pfn(Path, buff, blen, rc);}
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
                XrdOssWrapper(XrdOss &ossRef) : wrapPI(ossRef) {}
virtual        ~XrdOssWrapper() {}
 
protected:
 
XrdOss &wrapPI;
};
#endif