| Geant4 Cross Reference |
1 //
2 // ********************************************************************
3 // * License and Disclaimer *
4 // * *
5 // * The Geant4 software is copyright of the Copyright Holders of *
6 // * the Geant4 Collaboration. It is provided under the terms and *
7 // * conditions of the Geant4 Software License, included in the file *
8 // * LICENSE and available at http://cern.ch/geant4/license . These *
9 // * include a list of copyright holders. *
10 // * *
11 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file LICENSE and URL above *
16 // * for the full disclaimer and the limitation of liability. *
17 // * *
18 // * This code implementation is the result of the scientific and *
19 // * technical work of the GEANT4 collaboration. *
20 // * By using, copying, modifying or distributing the software (or *
21 // * any work based on the software) you agree to acknowledge its *
22 // * use in resulting scientific publications, and indicate your *
23 // * acceptance of all terms of the Geant4 Software license. *
24 // ********************************************************************
25 //
26 //
27 //
28
29 #include "G4UIArrayString.hh"
30
31 #include <iomanip>
32
33 static const char strESC = '\033';
34
35 ////////////////////////////////////////////////////////
36 G4UIArrayString::G4UIArrayString(const G4String& stream)
37 ////////////////////////////////////////////////////////
38 {
39 nElement = 0;
40 nColumn = 5; // temporal assignment
41
42 G4String astream = G4StrUtil::strip_copy(stream);
43
44 // tokenize...
45 std::size_t indx = 0;
46 while (true) {
47 std::size_t jc = astream.find(' ', indx);
48 nElement++;
49 if (jc == G4String::npos) break;
50 jc++; // fix a tiny mistake...
51 for (; jc < astream.length();) { // skip continuing spaces
52 if (astream[(G4int)jc] == ' ')
53 jc++;
54 else
55 break;
56 }
57 indx = jc;
58 }
59
60 // allocate string array
61 stringArray = new G4String[nElement];
62
63 // push...
64 indx = 0;
65 for (std::size_t i = 0; i < nElement; ++i) {
66 std::size_t jc = astream.find(' ', indx);
67 if (jc != G4String::npos)
68 stringArray[i] = astream.substr(indx, jc - indx);
69 else { // last token
70 jc = astream.length() + 1;
71 stringArray[i] = astream.substr(indx, jc - indx);
72 }
73 for (std::size_t j = 1; jc + j < astream.length(); ++j) { // skip continuing spaces
74 if (astream[G4int(jc + j)] == ' ')
75 jc++;
76 else
77 break;
78 }
79 indx = jc + 1;
80 }
81 }
82
83 ///////////////////////////////////
84 G4UIArrayString::~G4UIArrayString()
85 ///////////////////////////////////
86 {
87 delete[] stringArray;
88 }
89
90 ///////////////////////////////////////////////////////////////////
91 G4String* G4UIArrayString::GetElement(G4int icol, G4int irow) const
92 ///////////////////////////////////////////////////////////////////
93 {
94 if (icol < 1 || irow < 1) // offset of column/row is "1".
95 G4cerr << "G4UIArrayString: overrange" << G4endl;
96 if (icol > (G4int)nColumn) G4cerr << "G4UIArrayString: overrange" << G4endl;
97
98 std::size_t jq = (irow - 1) * nColumn + icol;
99 if (jq > nElement) G4cerr << "G4UIArrayString: overrange" << G4endl;
100
101 jq--;
102 return &stringArray[jq];
103 }
104
105 ////////////////////////////////////////////
106 G4int G4UIArrayString::GetNRow(G4int icol) const
107 ////////////////////////////////////////////
108 {
109 G4int ni;
110 if (nElement % nColumn == 0)
111 ni = G4int(nElement / nColumn);
112 else
113 ni = G4int(nElement / nColumn) + 1;
114
115 G4int nn = G4int(nElement % nColumn);
116 if (nn == 0) nn = (G4int)nColumn;
117
118 if (icol <= nn) return ni;
119 return ni - 1;
120 }
121
122 ////////////////////////////////////////////////
123 G4int G4UIArrayString::GetNField(G4int icol) const
124 ////////////////////////////////////////////////
125 {
126 std::size_t maxWidth = 0;
127 for (G4int iy = 1; iy <= GetNRow(icol); ++iy) {
128 std::size_t ilen = GetElement(icol, iy)->length();
129 // care for color code
130 // if(GetElement(icol,iy)-> index(strESC,0) != G4String::npos) {
131 // if(strESC == (*GetElement(icol,iy))[0] ) {
132 const char tgt = (*GetElement(icol, iy))[(std::size_t)0];
133 if (strESC == tgt) {
134 ilen -= 5;
135 }
136 if (ilen > maxWidth) maxWidth = ilen;
137 }
138
139 return (G4int)maxWidth;
140 }
141
142 /////////////////////////////////////////////////
143 G4int G4UIArrayString::CalculateColumnWidth() const
144 /////////////////////////////////////////////////
145 {
146 G4int totalWidth = 0;
147
148 for (G4int ix = 1; ix <= (G4int)nColumn; ++ix) {
149 totalWidth += GetNField(ix);
150 }
151
152 const G4int nwSpace = 2;
153 totalWidth += (nColumn - 1) * nwSpace; // for space
154
155 return totalWidth;
156 }
157
158 //////////////////////////////////////
159 void G4UIArrayString::Show(G4int ncol)
160 //////////////////////////////////////
161 {
162 // calculate #colums in need...
163 while (CalculateColumnWidth() < ncol) {
164 nColumn++;
165 }
166 while (CalculateColumnWidth() > ncol && nColumn > 1) {
167 nColumn--;
168 }
169
170 for (G4int iy = 1; iy <= GetNRow(1); iy++) {
171 G4int nc = (G4int)nColumn;
172 if (iy == GetNRow(1)) { // last row
173 nc = G4int(nElement % nColumn);
174 if (nc == 0) nc = (G4int)nColumn;
175 }
176 for (G4int ix = 1; ix <= nc; ++ix) {
177 G4String word = GetElement(ix, iy)->data();
178
179 // care for color code
180 G4String colorWord;
181 const char tgt = word[(std::size_t)0];
182 if (strESC == tgt) {
183 colorWord = word.substr(0, 5);
184 word.erase(0, 5);
185 }
186 if (! colorWord.empty()) G4cout << colorWord << std::flush;
187
188 G4cout << std::setiosflags(std::ios::left) << std::setw(GetNField(ix)) << word.c_str()
189 << std::flush;
190 // against problem w/ g++ iostream
191 if (ix != nc)
192 G4cout << " " << std::flush;
193 else
194 G4cout << G4endl;
195 }
196 }
197 }
198