| Geant4 Cross Reference |
1 // 1 //
2 // ******************************************* 2 // ********************************************************************
3 // * License and Disclaimer 3 // * License and Disclaimer *
4 // * 4 // * *
5 // * The Geant4 software is copyright of th 5 // * The Geant4 software is copyright of the Copyright Holders of *
6 // * the Geant4 Collaboration. It is provided 6 // * the Geant4 Collaboration. It is provided under the terms and *
7 // * conditions of the Geant4 Software License 7 // * conditions of the Geant4 Software License, included in the file *
8 // * LICENSE and available at http://cern.ch/ 8 // * LICENSE and available at http://cern.ch/geant4/license . These *
9 // * include a list of copyright holders. 9 // * include a list of copyright holders. *
10 // * 10 // * *
11 // * Neither the authors of this software syst 11 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing fin 12 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warran 13 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assum 14 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file 15 // * use. Please see the license in the file LICENSE and URL above *
16 // * for the full disclaimer and the limitatio 16 // * for the full disclaimer and the limitation of liability. *
17 // * 17 // * *
18 // * This code implementation is the result 18 // * This code implementation is the result of the scientific and *
19 // * technical work of the GEANT4 collaboratio 19 // * technical work of the GEANT4 collaboration. *
20 // * By using, copying, modifying or distri 20 // * By using, copying, modifying or distributing the software (or *
21 // * any work based on the software) you ag 21 // * any work based on the software) you agree to acknowledge its *
22 // * use in resulting scientific publicati 22 // * use in resulting scientific publications, and indicate your *
23 // * acceptance of all terms of the Geant4 Sof 23 // * acceptance of all terms of the Geant4 Software license. *
24 // ******************************************* 24 // ********************************************************************
25 // 25 //
26 // G4BuffercoutDestination class implementatio 26 // G4BuffercoutDestination class implementation
27 // 27 //
28 // Author: A.Dotti (SLAC), 14 April 2017 28 // Author: A.Dotti (SLAC), 14 April 2017
29 // ------------------------------------------- 29 // --------------------------------------------------------------------
30 30
31 #include "G4BuffercoutDestination.hh" <<
32 <<
33 #include "G4AutoLock.hh" <<
34 <<
35 #include <iostream> 31 #include <iostream>
36 32
37 // Private class to implement buffering of log << 33 #include "G4AutoLock.hh"
38 class G4BuffercoutDestination::BufferImpl << 34 #include "G4BuffercoutDestination.hh"
39 { <<
40 public: <<
41 using FlushFn_t = std::function<void(const s <<
42 <<
43 public: <<
44 explicit BufferImpl(std::size_t maxSize) : m <<
45 explicit BufferImpl(std::size_t maxSize, Flu <<
46 <<
47 ~BufferImpl() = default; <<
48 <<
49 // Set number of characters to hold before F <<
50 // If buffer exceeds new maximum, Flush() wi <<
51 void SetMaxSize(std::size_t n) { m_maxSize = <<
52 <<
53 // Reset buffer without flushing <<
54 void Reset() <<
55 { <<
56 m_buffer.str(""); <<
57 m_buffer.clear(); <<
58 m_currentSize = 0; <<
59 } <<
60 <<
61 G4int Receive(const G4String& msg) <<
62 { <<
63 m_currentSize += msg.size(); <<
64 m_buffer << msg; <<
65 <<
66 if (m_maxSize > 0 && m_currentSize > m_max <<
67 return Flush(); <<
68 } <<
69 return 0; <<
70 } <<
71 <<
72 // Flush buffer to destination and reset it <<
73 G4int Flush() <<
74 { <<
75 m_flushFn(m_buffer.str()); <<
76 Reset(); <<
77 return 0; <<
78 } <<
79 <<
80 private: <<
81 std::size_t m_maxSize = 0; <<
82 std::ostringstream m_buffer; <<
83 std::size_t m_currentSize = 0; <<
84 FlushFn_t m_flushFn = [](auto& s) { std::cou <<
85 }; <<
86 35
87 // ------------------------------------------- 36 // --------------------------------------------------------------------
88 G4BuffercoutDestination::G4BuffercoutDestinati 37 G4BuffercoutDestination::G4BuffercoutDestination(std::size_t max)
89 : m_maxSize(max), << 38 : m_buffer_out("")
90 m_buffer_dbg(std::make_unique<BufferImpl>( << 39 , m_buffer_err("")
91 m_buffer_out(std::make_unique<BufferImpl>( << 40 , m_maxSize(max)
92 m_buffer_err(std::make_unique<BufferImpl>( <<
93 {} 41 {}
94 42
95 // ------------------------------------------- 43 // --------------------------------------------------------------------
96 G4BuffercoutDestination::~G4BuffercoutDestinat 44 G4BuffercoutDestination::~G4BuffercoutDestination() { Finalize(); }
97 45
98 // ------------------------------------------- 46 // --------------------------------------------------------------------
99 void G4BuffercoutDestination::Finalize() 47 void G4BuffercoutDestination::Finalize()
100 { 48 {
101 FlushG4cerr(); 49 FlushG4cerr();
102 FlushG4cout(); 50 FlushG4cout();
103 FlushG4debug(); <<
104 } <<
105 <<
106 // ------------------------------------------- <<
107 G4int G4BuffercoutDestination::ReceiveG4debug( <<
108 { <<
109 return m_buffer_dbg->Receive(msg); <<
110 } 51 }
111 52
112 // ------------------------------------------- 53 // --------------------------------------------------------------------
113 G4int G4BuffercoutDestination::ReceiveG4cout(c 54 G4int G4BuffercoutDestination::ReceiveG4cout(const G4String& msg)
114 { 55 {
115 return m_buffer_out->Receive(msg); << 56 m_currentSize_out += msg.size();
>> 57 m_buffer_out << msg;
>> 58 // If there is a max size and it has been reached, flush
>> 59 if(m_maxSize > 0 && m_currentSize_out >= m_maxSize)
>> 60 {
>> 61 FlushG4cout();
>> 62 }
>> 63 return 0;
116 } 64 }
117 65
118 // ------------------------------------------- 66 // --------------------------------------------------------------------
119 G4int G4BuffercoutDestination::ReceiveG4cerr(c 67 G4int G4BuffercoutDestination::ReceiveG4cerr(const G4String& msg)
120 { 68 {
121 return m_buffer_err->Receive(msg); << 69 m_currentSize_err += msg.size();
>> 70 m_buffer_err << msg;
>> 71 // If there is a max size and it has been reached, flush
>> 72 if(m_maxSize > 0 && m_currentSize_err >= m_maxSize)
>> 73 {
>> 74 FlushG4cerr();
>> 75 }
>> 76 return 0;
122 } 77 }
123 78
124 // ------------------------------------------- 79 // --------------------------------------------------------------------
125 G4int G4BuffercoutDestination::FlushG4debug() << 80 G4int G4BuffercoutDestination::FlushG4cout()
126 { 81 {
127 return m_buffer_dbg->Flush(); << 82 std::cout << m_buffer_out.str() << std::flush;
>> 83 ResetCout();
>> 84 return 0;
128 } 85 }
129 86
130 // ------------------------------------------- 87 // --------------------------------------------------------------------
131 G4int G4BuffercoutDestination::FlushG4cout() << 88 void G4BuffercoutDestination::ResetCout()
132 { 89 {
133 return m_buffer_out->Flush(); << 90 m_buffer_out.str("");
>> 91 m_buffer_out.clear();
>> 92 m_currentSize_out = 0;
134 } 93 }
135 94
136 // ------------------------------------------- 95 // --------------------------------------------------------------------
137 G4int G4BuffercoutDestination::FlushG4cerr() 96 G4int G4BuffercoutDestination::FlushG4cerr()
138 { 97 {
139 return m_buffer_err->Flush(); << 98 std::cerr << m_buffer_err.str() << std::flush;
>> 99 ResetCerr();
>> 100 return 0;
140 } 101 }
141 102
142 // ------------------------------------------- 103 // --------------------------------------------------------------------
143 void G4BuffercoutDestination::SetMaxSize(std:: << 104 void G4BuffercoutDestination::ResetCerr()
144 { 105 {
145 m_maxSize = max; << 106 m_buffer_err.str("");
146 m_buffer_dbg->SetMaxSize(m_maxSize); << 107 m_buffer_err.clear();
147 m_buffer_out->SetMaxSize(m_maxSize); << 108 m_currentSize_err = 0;
148 m_buffer_err->SetMaxSize(m_maxSize); <<
149 } 109 }
150 110