RemoteContext.hpp

Go to the documentation of this file.

/*
 * DUNE DAQ modification notice:
 * This file has been modified from the original ATLAS ers source for the DUNE DAQ project.
 * Fork baseline commit: 8267df82a4f6fe6bf02c4014923eba19eddc4614 (2020-04-14).
 * Renamed since fork: yes (from ers/RemoteContext.h to include/ers/RemoteContext.hpp).
 *
 * Original copyright:
 * Copyright (C) 2001-2020 CERN for the benefit of the ATLAS collaboration.
 * Licensed under the Apache License, Version 2.0.
 */
 
/*
 *  RemoteContext.h
 *  ers
 *
 *  Created by Serguei Kolos on 26.11.05.
 *  Copyright 2004 CERN. All rights reserved.
 *
 */
 
#ifndef ERS_REMOTE_CONTEXT_H
#define ERS_REMOTE_CONTEXT_H
 
 
#include <ers/Context.hpp>
 
namespace ers
{   
    struct RemoteProcessContext
    {
    RemoteProcessContext(   const std::string & host_name,
                int pid,
                int tid,
                const std::string & cwd,
                int uid,
                const std::string & uname,
                                const std::string & app_name )
      : m_host_name( host_name ),
            m_pid( pid ),
            m_tid( tid ),
            m_cwd( cwd ),
            m_uid( uid ),
            m_uname( uname ),
            m_app_name( app_name )
        { ; }
        
    const std::string   m_host_name;    
    const pid_t         m_pid;      
    const pid_t         m_tid;      
    const std::string   m_cwd;      
    const int       m_uid;      
    const std::string   m_uname;    
    const std::string   m_app_name; 
    };
    
    class RemoteContext : public Context
    {
      public:

    RemoteContext(  const std::string & package,
                const std::string & filename,
                int line_number,
                        const std::string & function_name,
                        const RemoteProcessContext & pc )
      : m_process( pc ),
        m_package_name( package ),
            m_file_name( filename ),
        m_function_name( function_name ),
        m_line_number( line_number )
    { ; }
 
        virtual ~RemoteContext()
        { ; }
 
        virtual Context * clone() const         
        { return new RemoteContext( *this ); }
        
        const char * cwd() const            
        { return m_process.m_cwd.c_str(); }
        
        const char * file_name() const          
        { return m_file_name.c_str(); }
        
        const char * function_name() const      
        { return m_function_name.c_str(); }
        
        const char * host_name() const          
        { return m_process.m_host_name.c_str(); }
        
        int line_number() const             
        { return m_line_number; }
        
        const char * package_name() const       
        { return m_package_name.c_str(); }
        
        pid_t process_id() const            
        { return m_process.m_pid; }
        
        pid_t thread_id() const             
        { return m_process.m_tid; }
        
        void * const * stack_symbols() const        
        { return 0; }
        
        int stack_size() const              
        { return 0; }
        
        int user_id() const             
        { return m_process.m_uid; }
        
        const char * user_name() const          
        { return m_process.m_uname.c_str(); }
 
        const char * application_name() const       
        { return m_process.m_app_name.c_str(); }
 
      private:
        const RemoteProcessContext  m_process;      
        const std::string       m_package_name;     
        const std::string       m_file_name;        
    const std::string       m_function_name;    
    const int           m_line_number;        
    };
}
 
#endif