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