Printout.h

Go to the documentation of this file.

//==========================================================================
//  AIDA Detector description implementation for LCD
//--------------------------------------------------------------------------
// Copyright (C) Organisation europeenne pour la Recherche nucleaire (CERN)
// All rights reserved.
//
// For the licensing terms see $DD4hepINSTALL/LICENSE.
// For the list of contributors see $DD4hepINSTALL/doc/CREDITS.
//
// Author     : M.Frank
//
//==========================================================================
#ifndef DD4HEP_PRINTOUT_H
#define DD4HEP_PRINTOUT_H

// Framework include files

// C/C++ include files
#include <cstdio>
#include <cstdlib>
#include <cstdarg>
#include <map>
#include <string>
#include <iostream>

class TNamed;

namespace DD4hep {

  // Forward declarations
  class NamedObject;
  template <typename T> class Handle;
  typedef Handle<NamedObject> Ref_t;

  namespace Geometry {

    // Forward declarations
    class LCDD;
    class VisAttr;
    class DetElement;
    class PlacedVolume;
  }

  enum PrintLevel {
    NOLOG    = 0,
    VERBOSE  = 1,
    DEBUG    = 2,
    INFO     = 3,
    WARNING  = 4,
    ERROR    = 5,
    FATAL    = 6,
    ALWAYS   = 7
  };

#ifndef __CINT__
  typedef size_t (*output_function1_t)(void*, PrintLevel severity, const char*, const char*);
  typedef size_t (*output_function2_t)(void*, PrintLevel severity, const char*, const char*, va_list& args);


  std::string arguments(int argc, char** argv);
  

  int printout(PrintLevel severity, const char* src, const char* fmt, ...);


  int printout(PrintLevel severity, const std::string& src, const char* fmt, ...);


  int printout(PrintLevel severity, const std::string& src, const std::string& fmt, ...);


  int printout(PrintLevel severity, const char* src, const std::string& fmt, ...);


  int printout(PrintLevel severity, const char* src, const char* fmt, va_list& args);


  int printout(PrintLevel severity, const std::string& src, const char* fmt, va_list& args);


  int printout(PrintLevel severity, const std::string& src, const std::string& fmt, va_list& args);


  int printout(PrintLevel severity, const char* src, const std::string& fmt, va_list& args);


  int except(const std::string& src, const std::string& fmt, ...);


  int except(const char* src, const char* fmt, ...);


  int except(const std::string& src, const std::string& fmt, va_list& args);


  int except(const char* src, const char* fmt, va_list& args);

  /*
   *  @arg src        [string,read-only]   Information source (component, etc.)
   *  @arg fmt        [string,read-only]   Format string for ellipsis args
   *  @return Status code indicating success or failure
   */
  std::string format(const std::string& src, const std::string& fmt, ...);


  std::string format(const char* src, const char* fmt, ...);


  std::string format(const std::string& src, const std::string& fmt, va_list& args);


  std::string format(const char* src, const char* fmt, va_list& args);

  void setPrinter(void* print_arg, output_function1_t fcn);

  void setPrinter2(void* print_arg, output_function2_t fcn);

#endif // __CINT__

  std::string setPrintFormat(const std::string& new_format);

  PrintLevel setPrintLevel(PrintLevel new_level);

  PrintLevel printLevel();

  PrintLevel printLevel(const char* value);

  PrintLevel printLevel(const std::string& value);


  template <typename T> struct Printer {
    const Geometry::LCDD* lcdd;
    std::ostream& os;
    std::string prefix;
    Printer(const Geometry::LCDD* l, std::ostream& stream, const std::string& p = "")
      : lcdd(l), os(stream), prefix(p) {
    }
    void operator()(const T& value) const;
  };

  template <typename T> inline std::ostream& print(const T& object, std::ostream& os = std::cout,
                                                   const std::string& indent = "") {
    Printer<T>(0, os, indent)(object);
    return os;
  }


  template <typename T> struct PrintMap {
    typedef T item_type;
    typedef const std::map<std::string, Ref_t> cont_type;

    const Geometry::LCDD* lcdd;
    std::ostream& os;
    std::string text;
    cont_type& cont;
    PrintMap(const Geometry::LCDD* l, std::ostream& stream, cont_type& c, const std::string& t = "")
      : lcdd(l), os(stream), text(t), cont(c) {
    }
    void operator()() const;
  };

  inline const char* yes_no(bool value) {
    return value ? "YES" : "NO ";
  }
  inline const char* true_false(bool value) {
    return value ? "true " : "false";
  }

} /* End namespace DD4hep      */
#endif    /* DD4HEP_PRINTOUT_H         */