Logo ROOT  
Reference Guide
TSchemaRuleProcessor.h
Go to the documentation of this file.
1 // @(#)root/core:$Id$
2 // author: Lukasz Janyst <ljanyst@cern.ch>
3 
4 #ifndef ROOT_TSchemaRuleProcessor
5 #define ROOT_TSchemaRuleProcessor
6 
7 // NOTE: #included by libCore and libCling. All symbols must be inline.
8 
9 #include <cstring>
10 #include <string>
11 #include <list>
12 #include <utility>
13 #include <cstdlib>
14 #include <iostream>
15 #include <algorithm>
16 #include "RtypesCore.h"
17 
18 #include "TSchemaType.h"
19 
20 namespace ROOT {
21 namespace Internal {
23  {
24  public:
25  //---------------------------------------------------------------------
26  static void SplitList( const std::string& source,
27  std::list<std::string>& result,
28  char delimiter=',')
29  {
30  // Split the string producing a list of substrings
31 
32  std::string::size_type curr;
33  std::string::size_type last = 0;
34  std::string::size_type size;
35  std::string elem;
36 
37  result.clear();
38 
39  while( last != source.size() ) {
40  curr = source.find( delimiter, last );
41 
42  if( curr == std::string::npos ) {
43  curr = source.size()-1;
44  size = curr-last+1;
45  }
46  else size = curr-last;
47 
48  elem = Trim( source.substr( last, size ) );
49  if( !elem.empty() )
50  result.push_back( elem );
51 
52  last = curr+1;
53  }
54  }
55 
56  static void SplitDeclaration( const std::string& source,
57  std::list<std::pair<ROOT::Internal::TSchemaType,std::string> >& result)
58  {
59  // Split a declaration string producing a list of substrings
60  // Typically we have:
61  // int mem; SomeType mem2; SomeTmp<const key, const value> mem3;
62 
63  std::string::size_type curr;
64  std::string::size_type last = 0;
65  std::string::size_type size;
66  std::string elem;
67  std::string type;
68  std::string dims;
69 
70  result.clear();
71 
72  while( last != source.size() ) {
73  // Split on semi-colons.
74  curr = source.find( ';', last );
75 
76  if( curr == std::string::npos ) {
77  curr = source.size()-1;
78  size = curr-last+1;
79  }
80  else size = curr-last;
81 
82  // Extra spaces.
83  elem = Trim( source.substr( last, size ) );
84  if( !elem.empty() ) {
85  unsigned int level = 0;
86 
87  // Split between the typename and the membername
88  // Take in consideration template names.
89  for(std::string::size_type j=elem.size(); j>0; --j) {
90  std::string::size_type i = j-1;
91  if (elem[i]=='<') { ++level; }
92  else if (elem[i]=='>') { if (level==0) { continue; } ; --level; }
93  else if (level == 0 && isspace(elem[i])) {
94  type = elem.substr( 0, i );
95  // At the first iteration we know we have a space.
96  while( elem[i]=='*' || elem[i]=='&' || isspace(elem[i]) ) {
97  ++i;
98  if (strcmp("const",elem.c_str()+i)==0 && (i+5)>elem.size()
99  && ( elem[i+5]=='*' || elem[i+5]=='&' || isspace(elem[i+5])) ) {
100  i += 5;
101  type += "const ";
102  } else if (elem[i]=='*' || elem[i]=='&') {
103  type += elem[i];
104  }
105  }
106  std::string::size_type endvar = i;
107  while( endvar!=elem.size() && elem[endvar] != '[' ) {
108  ++endvar;
109  }
110  if (endvar != elem.size() ) {
111  dims = Trim( elem.substr(endvar, elem.size()-endvar) );
112  }
113  elem = Trim( elem.substr(i, endvar-i) );
114  break;
115  }
116  }
117  result.push_back( make_pair(ROOT::Internal::TSchemaType(type,dims),elem) );
118  }
119  last = curr+1;
120  }
121  }
122 
123  //---------------------------------------------------------------------
124  static std::string Trim( const std::string& source )
125  {
126  // Trim the whitespaces at the beginning and at the end of
127  // given source string
128 
129  std::string::size_type start, end;
130  for( start = 0; start < source.size(); ++start) {
131  if ( isspace(source[start]) ) {
132  continue;
133  } else if ( source[start] == '\\' && (start+1)<source.size() && (source[start+1]=='\n' || source[start+1]=='\r') ) {
134  ++start;
135  continue;
136  } else {
137  // Not a white space.
138  break;
139  }
140  }
141  if( start == source.size() )
142  return "";
143  for( end = source.size()-1; end > start; --end ) {
144  if ( (source[end]=='\n' || source[end]=='\r') && end > (start+1) && source[end-1] == '\\' ) {
145  --end;
146  continue;
147  } else if ( isspace(source[end]) ) {
148  continue;
149  } else {
150  // Not a white space.
151  break;
152  }
153  }
154  return source.substr( start, end-start+1 );
155  }
156 
157  //---------------------------------------------------------------------
158  static bool ProcessVersion( const std::string& source,
159  std::pair<Int_t, Int_t>& result )
160  {
161  // Check if a version is specified correctly
162  // The result is set the following way:
163  // x : first = x second = x
164  // -x : first = -10 second = x
165  // x-y : first = x second = y
166  // x- : first = x second = 50000
167  // if the given string is invalid (false is returned)
168  // then the state of the result is undefined
169 
170  std::string::size_type hyphenI;
171  std::string first;
172  std::string second;
173 
174  std::string version = Trim( source );
175 
176  if( version.empty() )
177  return false;
178 
179  //------------------------------------------------------------------
180  // Do we have a star?
181  //------------------------------------------------------------------
182  if( version == "*" ) {
183  result.first = -10;
184  result.second = 50000;
185  return true;
186  }
187 
188  //------------------------------------------------------------------
189  // Check if we have a minus somewhere, if not then single version
190  // number was specified
191  //------------------------------------------------------------------
192  hyphenI = version.find( '-' );
193  if( hyphenI == std::string::npos && IsANumber( version ) ) {
194  result.first = result.second = atoi( version.c_str() );
195  return true;
196  }
197 
198  //------------------------------------------------------------------
199  // We start with the hyphen
200  //------------------------------------------------------------------
201  if( hyphenI == 0 ) {
202  second = Trim( version.substr( 1 ) );
203  if( IsANumber( second ) ) {
204  result.first = -10;
205  result.second = atoi( second.c_str() );
206  return true;
207  }
208  }
209 
210  //------------------------------------------------------------------
211  // We end with the hyphen
212  //------------------------------------------------------------------
213  if( hyphenI == version.size()-1 ) {
214  first = Trim( version.substr( 0, version.size()-1 ) );
215  if( IsANumber( first ) ) {
216  result.first = atoi( first.c_str() );
217  result.second = 50000;
218  return true;
219  }
220  }
221 
222  //------------------------------------------------------------------
223  // We have the hyphen somewhere in the middle
224  //------------------------------------------------------------------
225  first = Trim( version.substr( 0, hyphenI ) );
226  second = Trim( version.substr( hyphenI+1, version.size()-hyphenI-1 ) );
227  if( IsANumber( first ) && IsANumber( second ) ) {
228  result.first = atoi( first.c_str() );
229  result.second = atoi( second.c_str() );
230  return true;
231  }
232 
233  return false;
234  }
235 
236  //---------------------------------------------------------------------
237  /// Check if given string consists of digits.
238  static bool IsANumber( const std::string& source, bool acceptHex = false )
239  {
240  if( source.empty() )
241  return false;
242 
243  if( acceptHex && source.size() > 2 && source[0] == '0' && source[1] == 'x'
244  && std::all_of(source.begin()+2, source.end(), [](unsigned char c){return std::isxdigit(c);}) )
245  return true;
246 
247  return std::all_of(source.begin(), source.end(), [](unsigned char c){return std::isdigit(c);});
248  }
249  };
250 } // namespace Internal
251 } // namespace ROOT
252 
253 #endif // ROOT_TSchemaRuleProcessor
c
#define c(i)
Definition: RSha256.hxx:101
first
Definition: first.py:1
TSchemaType.h
ROOT::Internal::TSchemaRuleProcessor
Definition: TSchemaRuleProcessor.h:23
ROOT::Internal::TSchemaRuleProcessor::Trim
static std::string Trim(const std::string &source)
Definition: TSchemaRuleProcessor.h:124
ROOT::Internal::TSchemaRuleProcessor::ProcessVersion
static bool ProcessVersion(const std::string &source, std::pair< Int_t, Int_t > &result)
Definition: TSchemaRuleProcessor.h:158
ROOT::Internal::TSchemaRuleProcessor::IsANumber
static bool IsANumber(const std::string &source, bool acceptHex=false)
Check if given string consists of digits.
Definition: TSchemaRuleProcessor.h:238
ROOT::Internal::TSchemaType
Definition: TSchemaType.h:13
RtypesCore.h
ROOT::Internal::TSchemaRuleProcessor::SplitDeclaration
static void SplitDeclaration(const std::string &source, std::list< std::pair< ROOT::Internal::TSchemaType, std::string > > &result)
Definition: TSchemaRuleProcessor.h:56
type
int type
Definition: TGX11.cxx:120
TGeant4Unit::second
static constexpr double second
Definition: TGeant4SystemOfUnits.h:151
ROOT
tbb::task_arena is an alias of tbb::interface7::task_arena, which doesn't allow to forward declare tb...
Definition: StringConv.hxx:21
ROOT::Internal::TSchemaRuleProcessor::SplitList
static void SplitList(const std::string &source, std::list< std::string > &result, char delimiter=',')
Definition: TSchemaRuleProcessor.h:26