library: libGFAL
#include "TGFALFile.h"

TGFALSystem

class description - header file - source file
viewCVS header - viewCVS source

class TGFALSystem: public TSystem

Inheritance Inherited Members Includes Libraries
Class Charts

Function Members (Methods)

Display options:
Show inherited
Show non-public
public:
TGFALSystem()
virtual~TGFALSystem()
virtual voidTSystem::Abort(int code = 0)
voidTObject::AbstractMethod(const char* method) const
virtual intTSystem::AcceptConnection(int sock)
virtual Bool_tAccessPathName(const char* path, EAccessMode mode)
virtual voidTSystem::AddFileHandler(TFileHandler* fh)
virtual voidTSystem::AddIncludePath(const char* includePath)
virtual voidTSystem::AddLinkedLibs(const char* linkedLib)
virtual voidTSystem::AddSignalHandler(TSignalHandler* sh)
virtual voidTSystem::AddTimer(TTimer* t)
virtual intTSystem::AnnounceTcpService(int port, Bool_t reuse, int backlog, int tcpwindowsize = -1)
virtual intTSystem::AnnounceUnixService(int port, int backlog)
virtual voidTObject::AppendPad(Option_t* option = "")
virtual const char*TSystem::BaseName(const char* pathname)
voidTSystem::Beep(Int_t freq = -1, Int_t duration = -1, Bool_t setDefault = kFALSE)
virtual voidTObject::Browse(TBrowser* b)
Bool_tTSystem::cd(const char* path)
virtual Bool_tTSystem::ChangeDirectory(const char* path)
virtual intTSystem::Chmod(const char* file, UInt_t mode)
static TClass*Class()
virtual const char*TObject::ClassName() const
virtual voidTSystem::CleanCompiledMacros()
virtual voidTNamed::Clear(Option_t* option = "")
virtual TObject*TNamed::Clone(const char* newname = "") const
virtual voidTSystem::CloseConnection(int sock, Bool_t force = kFALSE)
virtual voidTSystem::Closelog()
virtual intTSystem::ClosePipe(FILE* pipe)
virtual Int_tTNamed::Compare(const TObject* obj) const
virtual intTSystem::CompileMacro(const char* filename, Option_t* opt = "", const char* library_name = "", const char* build_dir = "")
virtual char*TSystem::ConcatFileName(const char* dir, const char* name)
virtual voidTNamed::Copy(TObject& named) const
virtual intTSystem::CopyFile(const char* from, const char* to, Bool_t overwrite = kFALSE)
virtual voidTObject::Delete(Option_t* option = "")
virtual const char*TSystem::DirName(const char* pathname)
virtual voidTSystem::DispatchOneEvent(Bool_t pendingOnly = kFALSE)
virtual Int_tTObject::DistancetoPrimitive(Int_t px, Int_t py)
virtual voidTObject::Draw(Option_t* option = "")
virtual voidTObject::DrawClass() const
virtual TObject*TObject::DrawClone(Option_t* option = "") const
virtual voidTObject::Dump() const
virtual char*TSystem::DynamicPathName(const char* lib, Bool_t quiet = kFALSE)
virtual Func_tTSystem::DynFindSymbol(const char* module, const char* entry)
virtual voidTObject::Error(const char* method, const char* msgfmt) const
virtual Int_tTSystem::Exec(const char* shellcmd)
virtual voidTObject::Execute(const char* method, const char* params, Int_t* error = 0)
virtual voidTObject::Execute(TMethod* method, TObjArray* params, Int_t* error = 0)
virtual voidTObject::ExecuteEvent(Int_t event, Int_t px, Int_t py)
virtual voidTSystem::Exit(int code, Bool_t mode = kTRUE)
virtual voidTSystem::ExitLoop()
virtual Bool_tTSystem::ExpandPathName(TString& path)
virtual char*TSystem::ExpandPathName(const char* path)
virtual voidTObject::Fatal(const char* method, const char* msgfmt) const
virtual voidTNamed::FillBuffer(char*& buffer)
virtual const char*TSystem::FindFile(const char* search, TString& file, EAccessMode mode = kFileExists)
virtual TObject*TObject::FindObject(const char* name) const
virtual TObject*TObject::FindObject(const TObject* obj) const
virtual voidFreeDirectory(void* dirp)
virtual TSystem::EAclicModeTSystem::GetAclicMode() const
voidTSystem::GetBeepDefaults(Int_t& freq, Int_t& duration) const
virtual const char*TSystem::GetBuildArch() const
virtual const char*TSystem::GetBuildDir() const
virtual const char*TSystem::GetBuildNode() const
virtual intTSystem::GetCpuInfo(CpuInfo_t* info, Int_t sampleTime = 1000) const
virtual const char*GetDirEntry(void* dirp)
virtual Option_t*TObject::GetDrawOption() const
static Long_tTObject::GetDtorOnly()
virtual const char*TSystem::GetDynamicPath()
virtual Int_tTSystem::GetEffectiveGid()
virtual Int_tTSystem::GetEffectiveUid()
virtual const char*TSystem::Getenv(const char* env)
static Int_tTSystem::GetErrno()
virtual const char*TSystem::GetError()
const char*TSystem::GetErrorStr() const
virtual const char*TSystem::GetFlagsDebug() const
virtual const char*TSystem::GetFlagsOpt() const
virtual Int_tTSystem::GetFPEMask()
virtual intTSystem::GetFsInfo(const char* path, Long_t* id, Long_t* bsize, Long_t* blocks, Long_t* bfree)
virtual Int_tTSystem::GetGid(const char* group = "0")
virtual UserGroup_t*TSystem::GetGroupInfo(Int_t gid)
virtual UserGroup_t*TSystem::GetGroupInfo(const char* group = "0")
virtual TInetAddressTSystem::GetHostByName(const char* server)
virtual const char*TObject::GetIconName() const
virtual const char*TSystem::GetIncludePath()
virtual const char*TSystem::GetLibraries(const char* regexp = "", const char* option = "", Bool_t isRegexp = kTRUE)
virtual const char*TSystem::GetLinkdefSuffix() const
virtual const char*TSystem::GetLinkedLibs() const
virtual TSeqCollection*TSystem::GetListOfFileHandlers() const
virtual const char*TSystem::GetMakeExe() const
virtual const char*TSystem::GetMakeSharedLib() const
virtual intTSystem::GetMemInfo(MemInfo_t* info) const
virtual const char*TNamed::GetName() const
virtual char*TObject::GetObjectInfo(Int_t px, Int_t py) const
static Bool_tTObject::GetObjectStat()
virtual const char*TSystem::GetObjExt() const
virtual Option_t*TObject::GetOption() const
virtual Int_tGetPathInfo(const char* path, FileStat_t& buf)
virtual TInetAddressTSystem::GetPeerName(int sock)
virtual intTSystem::GetPid()
virtual intTSystem::GetProcInfo(ProcInfo_t* info) const
virtual intTSystem::GetServiceByName(const char* service)
virtual char*TSystem::GetServiceByPort(int port)
virtual TInetAddressTSystem::GetSockName(int sock)
virtual intTSystem::GetSockOpt(int sock, int kind, int* val)
virtual const char*TSystem::GetSoExt() const
virtual intTSystem::GetSysInfo(SysInfo_t* info) const
virtual const char*TNamed::GetTitle() const
virtual Int_tTSystem::GetUid(const char* user = "0")
virtual UInt_tTObject::GetUniqueID() const
virtual UserGroup_t*TSystem::GetUserInfo(Int_t uid)
virtual UserGroup_t*TSystem::GetUserInfo(const char* user = "0")
virtual Bool_tTObject::HandleTimer(TTimer* timer)
virtual ULong_tTNamed::Hash() const
virtual const char*TSystem::HomeDirectory(const char* userName = "0")
virtual const char*TSystem::HostName()
virtual voidTSystem::IgnoreInterrupt(Bool_t ignore = kTRUE)
virtual voidTSystem::IgnoreSignal(ESignals sig, Bool_t ignore = kTRUE)
Bool_tTSystem::InControl() const
virtual voidTObject::Info(const char* method, const char* msgfmt) const
virtual Bool_tTObject::InheritsFrom(const char* classname) const
virtual Bool_tTObject::InheritsFrom(const TClass* cl) const
virtual Bool_tTSystem::Init()
virtual voidTSystem::InnerLoop()
virtual voidTObject::Inspect() const
voidTObject::InvertBit(UInt_t f)
virtual TClass*IsA() const
virtual Bool_tTSystem::IsAbsoluteFileName(const char* dir)
virtual Bool_tTObject::IsEqual(const TObject* obj) const
virtual Bool_tTSystem::IsFileInIncludePath(const char* name, char** fullpath = "0")
virtual Bool_tTObject::IsFolder() const
Bool_tTObject::IsOnHeap() const
virtual Bool_tTNamed::IsSortable() const
Bool_tTObject::IsZombie() const
virtual intTSystem::Link(const char* from, const char* to)
virtual voidTSystem::ListLibraries(const char* regexp = "")
virtual voidTSystem::ListSymbols(const char* module, const char* re = "")
virtual intTSystem::Load(const char* module, const char* entry = "", Bool_t system = kFALSE)
virtual voidTNamed::ls(Option_t* option = "") const
virtual Int_tMakeDirectory(const char* name)
voidTObject::MayNotUse(const char* method) const
virtual intTSystem::mkdir(const char* name, Bool_t recursive = kFALSE)
virtual Long_tTSystem::NextTimeOut(Bool_t mode)
virtual Bool_tTObject::Notify()
virtual TTimeTSystem::Now()
virtual intTSystem::OpenConnection(const char* server, int port, int tcpwindowsize = -1)
virtual void*OpenDirectory(const char* name)
virtual voidTSystem::Openlog(const char* name, Int_t options, ELogFacility facility)
virtual FILE*TSystem::OpenPipe(const char* command, const char* mode)
static voidTObject::operator delete(void* ptr)
static voidTObject::operator delete(void* ptr, void* vp)
static voidTObject::operator delete[](void* ptr)
static voidTObject::operator delete[](void* ptr, void* vp)
void*TObject::operator new(size_t sz)
void*TObject::operator new(size_t sz, void* vp)
void*TObject::operator new[](size_t sz)
void*TObject::operator new[](size_t sz, void* vp)
TNamed&TNamed::operator=(const TNamed& rhs)
virtual voidTObject::Paint(Option_t* option = "")
virtual voidTObject::Pop()
virtual const char*TSystem::PrependPathName(const char* dir, TString& name)
virtual voidTNamed::Print(Option_t* option = "") const
virtual Bool_tTSystem::ProcessEvents()
const char*TSystem::pwd()
virtual Int_tTObject::Read(const char* name)
virtual voidTObject::RecursiveRemove(TObject* obj)
virtual intTSystem::RecvBuf(int sock, void* buffer, int length)
virtual intTSystem::RecvRaw(int sock, void* buffer, int length, int flag)
virtual Int_tTSystem::RedirectOutput(const char* name, const char* mode = "a")
virtual TFileHandler*TSystem::RemoveFileHandler(TFileHandler* fh)
voidTSystem::RemoveOnExit(TObject* obj)
virtual TSignalHandler*TSystem::RemoveSignalHandler(TSignalHandler* sh)
virtual TTimer*TSystem::RemoveTimer(TTimer* t)
virtual intTSystem::Rename(const char* from, const char* to)
voidTObject::ResetBit(UInt_t f)
static voidTSystem::ResetErrno()
virtual voidTSystem::ResetSignal(ESignals sig, Bool_t reset = kTRUE)
virtual voidTSystem::ResetTimer(TTimer*)
virtual voidTSystem::Run()
virtual voidTObject::SaveAs(const char* filename = "", Option_t* option = "") const
virtual voidTObject::SavePrimitive(ostream& out, Option_t* option = "")
virtual Int_tTSystem::Select(TList* active, Long_t timeout)
virtual Int_tTSystem::Select(TFileHandler* fh, Long_t timeout)
virtual intTSystem::SendBuf(int sock, const void* buffer, int length)
virtual intTSystem::SendRaw(int sock, const void* buffer, int length, int flag)
virtual voidTSystem::SetAclicMode(TSystem::EAclicMode mode)
voidTObject::SetBit(UInt_t f)
voidTObject::SetBit(UInt_t f, Bool_t set)
virtual voidTSystem::SetBuildDir(const char*)
virtual voidTSystem::SetDisplay()
virtual voidTObject::SetDrawOption(Option_t* option = "")
static voidTObject::SetDtorOnly(void* obj)
virtual voidTSystem::SetDynamicPath(const char* pathname)
virtual voidTSystem::Setenv(const char* name, const char* value)
voidTSystem::SetErrorStr(const char* errstr)
virtual voidTSystem::SetFlagsDebug(const char*)
virtual voidTSystem::SetFlagsOpt(const char*)
virtual Int_tTSystem::SetFPEMask(Int_t mask = kDefaultMask)
virtual voidTSystem::SetIncludePath(const char* includePath)
virtual voidTSystem::SetLinkdefSuffix(const char* suffix)
virtual voidTSystem::SetLinkedLibs(const char* linkedLibs)
virtual voidTSystem::SetMakeExe(const char* directives)
virtual voidTSystem::SetMakeSharedLib(const char* directives)
virtual voidTNamed::SetName(const char* name)
virtual voidTNamed::SetNameTitle(const char* name, const char* title)
static voidTObject::SetObjectStat(Bool_t stat)
virtual voidTSystem::SetObjExt(const char* objExt)
virtual voidTSystem::SetProgname(const char* name)
virtual intTSystem::SetSockOpt(int sock, int kind, int val)
virtual voidTSystem::SetSoExt(const char* soExt)
virtual voidTNamed::SetTitle(const char* title = "")
virtual voidTObject::SetUniqueID(UInt_t uid)
virtual voidShowMembers(TMemberInspector& insp, char* parent)
virtual Int_tTNamed::Sizeof() const
virtual voidTSystem::Sleep(UInt_t milliSec)
virtual TStringTSystem::SplitAclicMode(const char* filename, TString& mode, TString& args, TString& io) const
virtual voidTSystem::StackTrace()
virtual voidStreamer(TBuffer& b)
voidStreamerNVirtual(TBuffer& b)
virtual intTSystem::Symlink(const char* from, const char* to)
virtual voidTObject::SysError(const char* method, const char* msgfmt) const
virtual voidTSystem::Syslog(ELogLevel level, const char* mess)
virtual const char*TSystem::TempDirectory() const
virtual FILE*TSystem::TempFileName(TString& base, const char* dir = "0")
Bool_tTObject::TestBit(UInt_t f) const
Int_tTObject::TestBits(UInt_t f) const
virtual intTSystem::Umask(Int_t mask)
virtual const char*TSystem::UnixPathName(const char* unixpathname)
virtual intTSystem::Unlink(const char* name)
virtual voidTSystem::Unload(const char* module)
virtual voidTSystem::Unsetenv(const char* name)
virtual voidTObject::UseCurrentStyle()
virtual intTSystem::Utime(const char* file, Long_t modtime, Long_t actime)
virtual voidTObject::Warning(const char* method, const char* msgfmt) const
virtual char*TSystem::Which(const char* search, const char* file, EAccessMode mode = kFileExists)
virtual const char*TSystem::WorkingDirectory()
virtual Int_tTObject::Write(const char* name = "0", Int_t option = 0, Int_t bufsize = 0)
virtual Int_tTObject::Write(const char* name = "0", Int_t option = 0, Int_t bufsize = 0) const
protected:
virtual Bool_tTSystem::ConsistentWith(const char* path, void* dirptr = 0)
virtual voidTSystem::DoBeep(Int_t = -1, Int_t = -1) const
virtual voidTObject::DoError(int level, const char* location, const char* fmt, va_list va) const
virtual const char*TSystem::ExpandFileName(const char* fname)
TSystem*TSystem::FindHelper(const char* path, void* dirptr = 0)
virtual const char*TSystem::GetLinkedLibraries()
voidTObject::MakeZombie()
virtual voidTSystem::SigAlarmInterruptsSyscalls(Bool_t)
static const char*TSystem::StripOffProto(const char* path, const char* proto)
private:
virtual void*GetDirPtr() const

Data Members

public:
enum TSystem::EAclicMode { kDefault
kDebug
kOpt
};
enum TObject::EStatusBits { kCanDelete
kMustCleanup
kObjInCanvas
kIsReferenced
kHasUUID
kCannotPick
kNoContextMenu
kInvalidObject
};
enum TObject::[unnamed] { kIsOnHeap
kNotDeleted
kZombie
kBitMask
kSingleKey
kOverwrite
kWriteDelete
};
protected:
TFdSet*TSystem::fReadmask!Files that should be checked for read events
TFdSet*TSystem::fWritemask!Files that should be checked for write events
TFdSet*TSystem::fReadready!Files with reads waiting
TFdSet*TSystem::fWriteready!Files with writes waiting
TFdSet*TSystem::fSignals!Signals that were trapped
Int_tTSystem::fNfdNumber of fd's in masks
Int_tTSystem::fMaxrfdLargest fd in read mask
Int_tTSystem::fMaxwfdLargest fd in write mask
Int_tTSystem::fSigcntNumber of pending signals
TStringTSystem::fWdpathWorking directory
TStringTSystem::fHostnameHostname
Bool_tTSystem::fInsideNotifyUsed by DispatchTimers()
Int_tTSystem::fBeepFreqUsed by Beep()
Int_tTSystem::fBeepDurationUsed by Beep()
Bool_tTSystem::fInControlTrue if in eventloop
Bool_tTSystem::fDoneTrue if eventloop should be finished
Int_tTSystem::fLevelLevel of nested eventloops
TStringTSystem::fLastErrorStringLast system error message
TSeqCollection*TSystem::fTimersList of timers
TSeqCollection*TSystem::fSignalHandlerList of signal handlers
TSeqCollection*TSystem::fFileHandlerList of file handlers
TSeqCollection*TSystem::fOnExitListList of items to be cleaned-up on exit
TStringTSystem::fListLibsList shared libraries, cache used by GetLibraries
TStringTSystem::fBuildArchArchitecure for which ROOT was built (passed to ./configure)
TStringTSystem::fBuildNodeDetailed information where ROOT was built
TStringTSystem::fBuildDirLocation where to build ACLiC shared library and use as scratch area.
TStringTSystem::fFlagsDebugFlags for debug compilation
TStringTSystem::fFlagsOptFlags for optimized compilation
TStringTSystem::fListPathsList of all include (fIncludePath + interpreter include path). Cache used by GetIncludePath
TStringTSystem::fIncludePathUsed to expand $IncludePath in the directives given to SetMakeSharedLib and SetMakeExe
TStringTSystem::fLinkedLibsUsed to expand $LinkedLibs in the directives given to SetMakeSharedLib and SetMakeExe
TStringTSystem::fSoExtExtension of shared library (.so, .sl, .a, .dll, etc.)
TStringTSystem::fObjExtExtension of object files (.o, .obj, etc.)
TSystem::EAclicModeTSystem::fAclicModeWhether the compilation should be done debug or opt
TStringTSystem::fMakeSharedLibDirective used to build a shared library
TStringTSystem::fMakeExeDirective used to build an executable
TStringTSystem::fLinkdefSuffixDefault suffix for linkdef files to be used by ACLiC
TSeqCollection*TSystem::fCompiledList of shared libs from compiled macros to be deleted
TSeqCollection*TSystem::fHelpersList of helper classes for alternative file/directory access
TStringTNamed::fNameobject identifier
TStringTNamed::fTitleobject title
private:
void*fDirpdirectory handler

Class Description

                                                                      
 TGFALFile                                                            
                                                                      
 A TGFALFile is like a normal TFile except that it reads and writes   
 its data via the underlaying Grid access mechanism.                  
 TGFALFile file names are either a logical file name, a guid, an      
 SURL or a TURL, like:                                                
                                                                      
    gfal:/lfn/user/r/rdm/galice.root                                  
                                                                      
 Grid storage interactions today require using several existing       
 software components:                                                 
  - The replica catalog services to locate valid replicas of          
    files.                                                            
  - The SRM software to ensure:                                       
     - files  exist on disk (they are recalled from mass              
       storage if necessary) or                                       
     - space is allocated on disk for new files (they are possibly    
       migrated to mass storage later)                                
  - A file access mechanism to access files from the storage          
    system on the worker node.                                        
                                                                      
 The GFAL library hides these interactions and presents a Posix       
 interface for the I/O operations. The currently supported protocols  
 are: file for local access, dcap, gsidcap and kdcap (dCache access   
 protocol) and rfio (CASTOR access protocol).                         
                                                                      
 File naming convention:                                              
 A file name can be a Logical File Name (LFN), a Grid Unique          
 IDentifier (GUID), a file replica (SURL) or a Transport file         
 name (TURL):                                                         
                                                                      
     an LFN starts with lfn:                                          
        for example lfn:baud/testgfal15                               
                                                                      
     a GUID starts with guid:                                         
        for example guid:2cd59291-7ae7-4778-af6d-b1f423719441         
                                                                      
     an SURL starts with srm://                                       
         for example srm://wacdr002d.cern.ch:8443/castor/             
                    cern.ch/user/b/baud/testgfal15                    
                                                                      
      a TURL starts with a protocol name:                             
          for example rfio:///castor/cern.ch/user/b/baud/testgfal15   
                                                                      
 Note that for the TGFALFile plugin to work, all these pathnames      
 should be prepended by gfal:.
TGFALSystem()
 Create helper class that allows directory access via GFAL.
Int_t MakeDirectory(const char *dir)
 Make a directory via GFAL.
void * OpenDirectory(const char *dir)
 Open a directory via GFAL. Returns an opaque pointer to a dir
 structure. Returns 0 in case of error.
void FreeDirectory(void *dirp)
 Free directory via GFAL.
const char * GetDirEntry(void *dirp)
 Get directory entry via GFAL. Returns 0 in case no more entries.
Int_t GetPathInfo(const char *path, FileStat_t &buf)
 Get info about a file. Info is returned in the form of a FileStat_t
 structure (see TSystem.h).
 The function returns 0 in case of success and 1 if the file could
 not be stat'ed.
Bool_t AccessPathName(const char *path, EAccessMode mode)
 Returns FALSE if one can access a file using the specified access mode.
 Mode is the same as for the Unix access(2) function.
 Attention, bizarre convention of return value!!
void * GetDirPtr()
{ return fDirp; }
virtual ~TGFALSystem()
{ }

Author: Fons Rademakers 8/12/2005
Last update: root/gfal:$Name: $:$Id: TGFALFile.cxx,v 1.6 2006/06/21 13:57:53 rdm Exp $
Copyright (C) 1995-2005, Rene Brun and Fons Rademakers. *

ROOT page - Class index - Class Hierarchy - Top of the page
This page has been automatically generated. If you have any comments or suggestions about the page layout send a mail to ROOT support, or contact the developers with any questions or problems regarding ROOT.