LSSTApplications  1.1.2+25,10.0+13,10.0+132,10.0+133,10.0+224,10.0+41,10.0+8,10.0-1-g0f53050+14,10.0-1-g4b7b172+19,10.0-1-g61a5bae+98,10.0-1-g7408a83+3,10.0-1-gc1e0f5a+19,10.0-1-gdb4482e+14,10.0-11-g3947115+2,10.0-12-g8719d8b+2,10.0-15-ga3f480f+1,10.0-2-g4f67435,10.0-2-gcb4bc6c+26,10.0-28-gf7f57a9+1,10.0-3-g1bbe32c+14,10.0-3-g5b46d21,10.0-4-g027f45f+5,10.0-4-g86f66b5+2,10.0-4-gc4fccf3+24,10.0-40-g4349866+2,10.0-5-g766159b,10.0-5-gca2295e+25,10.0-6-g462a451+1
LSSTDataManagementBasePackage
Namespaces | Classes | Functions
lsst::utils Namespace Reference

Namespaces

 eups
 EUPS bindings.
 
 multithreading
 
 tests
 
 version
 

Classes

class  Symbol
 
struct  n
 
struct  key
 

Functions

std::string demangleType (std::string const _typeName)
 
template<class T >
int fpclassify (T t)
 
template<class T >
int isfinite (T t)
 
template<class T >
int isinf (T t)
 
template<class T >
int isnan (T t)
 
template<class T >
int isnormal (T t)
 
std::string raRadToStr (double raRad)
 
std::string decRadToStr (double decRad)
 
std::string raDegToStr (double raDeg)
 
std::string decDegToStr (double decDeg)
 
std::string raDecRadToStr (double raRad, double decRad)
 
std::string raDecDegToStr (double raDeg, double decDeg)
 
double raStrToRad (std::string raStr, std::string delimiter=":")
 
double raStrToDeg (std::string raStr, std::string delimiter=":")
 
double decStrToRad (std::string decStr, std::string delimiter=":")
 
double decStrToDeg (std::string decStr, std::string delimiter=":")
 
void guessSvnVersion (std::string const &headURL, std::string &OUTPUT)
 
boost::any stringToAny (std::string valueString)
 

Function Documentation

std::string lsst::utils::demangleType ( std::string const  _typeName)

Definition at line 113 of file Demangle.cc.

113  {
114 #if 1
115  typedef multi_index_container<
116  Symbol,
117  indexed_by<
118  ordered_unique<tag<n>,
119  member<Symbol, int, &Symbol::n> >,
120  ordered_unique<tag<key>,
121  member<Symbol, std::string, &Symbol::key> >
122  >
123  > SymbolTable;
124  typedef SymbolTable::index<n>::type::iterator nIterator;
125  typedef SymbolTable::index<key>::type::iterator keyIterator;
126  Symbol::reset();
127 
128  // Here's my symbol table and its indices
129  SymbolTable st;
130 
131  SymbolTable::index<n>::type &nIndex = st.get<n>();
132  SymbolTable::index<key>::type &keyIndex = st.get<key>();
133  //
134  // Start mangling
135  //
136  std::string typeName("");
137  const char *ptr = _typeName.c_str();
138 
139  if (*ptr == 'r' || *ptr == 'V' || *ptr == 'K') {
140  ptr++; // (restrict/volatile/const)
141  }
142 
143  if (*ptr == 'P') ptr++; // We passed "this" which is (type *)
144 
145  std::string currentSymbol = ""; // Current symbol
146  std::stack<char> typeStack; // Did we last see an N or an I?
147 
148  int lastTokenWasType = 0; // When > 0, the last token was a type such as int or float
149  while (*ptr != '\0') {
150  lastTokenWasType--;
151  switch (*ptr) {
152  case 'E':
153  ptr++;
154  currentSymbol = "";
155 
156  if (typeStack.empty()) {
157  typeStack.push('\a'); // at least don't crash
158  }
159 
160  if (typeStack.top() == 'I') {
161  typeName += '>';
162  } else if (typeStack.top() == 'L') {
163  ;
164  } else if (typeStack.top() == 'N') {
165  ;
166  }
167  typeStack.pop();
168 
169  if (!typeStack.empty() && typeStack.top() == 'I') {
170  if (*ptr != 'E' && typeName[typeName.size() - 1] != '<') {
171  typeName += ',';
172  }
173  }
174 
175  break;
176  case 'I':
177  typeStack.push(*ptr++);
178  currentSymbol = "";
179 
180  typeName += '<';
181  break;
182  case 'L':
183  typeStack.push(*ptr++);
184  currentSymbol = "";
185  {
186  std::string type;
187  if (interpret_typeletter(*ptr, type)) {
188  typeName += "(" + type + ')';
189  } else {
190  typeName += 'c';
191  }
192  ptr++;
193  }
194  if (*ptr == 'n') {
195  typeName += '-'; ptr++;
196  }
197  while (*ptr != '\0' && *ptr != 'E') {
198  typeName += *ptr++;
199  }
200  break;
201  case 'N':
202  typeStack.push(*ptr++);
203  currentSymbol = "";
204  break;
205  case 'S':
206  ++ptr;
207  switch (*ptr) {
208  case 't': typeName += "::std::"; break;
209  case 'a': typeName += "::std::allocator"; break;
210  case 'b': typeName += "::std::basic_string"; break;
211  case 's': typeName += "::std::basic_string<char,::std::char_traits<char>,::std::allocator<char>>"; break;
212  case 'i': typeName += "::std::basic_istream<char, std::char_traits<char> >"; break;
213  case 'o': typeName += "::std::basic_ostream<char,std::char_traits<char>>"; break;
214  case 'd': typeName += "::std::basic_iostream<char,std::char_traits<char>>"; break;
215  default:
216  {
217  int subst = 0; // number of substitution
218 
219  if (*ptr == '_') {
220  ; // S_ => 0
221  } else if (isdigit(*ptr) || isupper(*ptr)) {
222  while (isdigit(*ptr) || isupper(*ptr)) {
223  if (isdigit(*ptr)) {
224  subst = 36*subst + (*ptr - '0');
225  } else {
226  subst = 36*subst + 10 + (*ptr - 'A');
227  }
228  ptr++;
229  }
230  subst++; // S_ == 0; S1_ == 1
231  assert (*ptr == '_');
232  ptr++;
233  }
234 
235  nIterator sym = nIndex.find(subst);
236  if (sym == nIndex.end()) { // not found
237  typeName += (boost::format("[S%d]") % subst).str();
238  } else {
239  typeName += sym->key;
240  }
241 
242  }
243  break;
244  }
245  currentSymbol = "";
246  break;
247  case '0': case '1': case '2': case '3': case '4':
248  case '5': case '6': case '7': case '8': case '9':
249  {
250  const int len = atoi(ptr++);
251  while (isdigit(*ptr)) ptr++;
252 
253  std::string name = "";
254  for (int i = 0; *ptr != '\0' && i < len; i++) {
255  name += *ptr++;
256  }
257 
258  if (currentSymbol != "") {
259  currentSymbol += "::";
260  typeName += "::";
261  }
262 
263  currentSymbol += name;
264  typeName += name;
265 
266  if (keyIndex.find(currentSymbol) == keyIndex.end()) {
267  st.insert(currentSymbol);
268  }
269  }
270  break;
271  default:
272  {
273  std::string type;
274  if (interpret_typeletter(*ptr, type)) {
275  if (lastTokenWasType > 0) {
276  typeName += ",";
277  }
278  typeName += type;
279  lastTokenWasType = 2; // it'll be decremented on every char in the name
280  } else {
281  typeName += *ptr;
282  }
283  ptr++;
284  }
285  }
286  }
287 
288  static volatile bool dumpSymbolTable = false; // can be set from gdb
289  if (dumpSymbolTable) {
290  // The test on the iterator is paranoid, but they _could_
291  // have deleted elements. In this case, they didn't.
292  for (unsigned int i = 0; i < st.size(); i++) {
293  nIterator el = nIndex.find(2);
294  if (el != nIndex.end()) { // did we find it?
295  el->print();
296  }
297  }
298  }
299 
300  return typeName;
301 #else
302  return _typeName;
303 #endif
304 }
template<class T >
int lsst::utils::fpclassify ( T  t)

Definition at line 95 of file ieee.h.

95  {
96  return lsst_fpclassify(t);
97 }
void lsst::utils::guessSvnVersion ( std::string const &  headURL,
std::string &  version 
)

Return a version name given an SVN HeadURL

Given a string of the form Dollar HeadURL: svn+ssh://svn.lsstcorp.org/DC2/fw/tags/1.1/foo Dollar (where I've written Dollar to foil svn) try to guess the version.

If the string is misformed, return "(NOSVN)";

If the version appears to be on the trunk, return "svn" as this is presumably an untagged * version

If the version appears to be in branches, tags, or tickets return the version string (with " B", "", or " T" appended respectively)

Otherwise return the svn URL

Note: for this to be set by svn, you'll have to set the svn property svn:keywords to expand HeadURL in the file where the HeadURL originates.

Parameters
headURLthe HeadURL String
versionthe desired version

Definition at line 53 of file Utils.cc.

55  {
56  const boost::regex getURL("^\\$HeadURL:\\s+([^$ ]+)\\s*\\$$");
57  boost::smatch matchObject;
58  if (boost::regex_search(headURL, matchObject, getURL)) {
59  version = matchObject[1];
60 
61  const boost::regex getVersion("(branches|tags|tickets|trunk)/([^/]+)");
62  if (boost::regex_search(version, matchObject, getVersion)) {
63  std::string type = matchObject[1];
64  version = matchObject[2];
65 
66  if (type == "branches") {
67  version += "B";
68  } else if (type == "tickets") {
69  version += "T" ;
70  } else if (type == "trunk") {
71  version = "svn";
72  }
73  }
74  } else {
75  version = "(NOSVN)";
76  return;
77  }
78 }
template<class T >
int lsst::utils::isfinite ( T  t)

Definition at line 100 of file ieee.h.

100  {
101  return lsst_isfinite(t);
102 }
template<class T >
int lsst::utils::isinf ( T  t)

Definition at line 105 of file ieee.h.

105  {
106  return lsst_isinf(t);
107 }
template<class T >
int lsst::utils::isnan ( T  t)

Definition at line 110 of file ieee.h.

110  {
111  return lsst_isnan(t);
112 }
template<class T >
int lsst::utils::isnormal ( T  t)

Definition at line 115 of file ieee.h.

115  {
116  return lsst_isnormal(t);
117 }
boost::any lsst::utils::stringToAny ( std::string  valueString)

Definition at line 83 of file Utils.cc.

84 {
85  const boost::regex intRegex("(\\Q+\\E|\\Q-\\E){0,1}[0-9]+");
86  const boost::regex doubleRegex("(\\Q+\\E|\\Q-\\E){0,1}([0-9]*\\.[0-9]+|[0-9]+\\.[0-9]*)((e|E)(\\Q+\\E|\\Q-\\E){0,1}[0-9]+){0,1}");
87  const boost::regex FitsStringRegex("'(.*)'");
88 
89  boost::smatch matchStrings;
90 
91  std::istringstream converter(valueString);
92 
93  if (boost::regex_match(valueString, intRegex)) {
94  // convert the string to an int
95  int intVal;
96  converter >> intVal;
97  return boost::any(intVal);
98  }
99 
100  if (boost::regex_match(valueString, doubleRegex)) {
101  // convert the string to a double
102  double doubleVal;
103  converter >> doubleVal;
104  return boost::any(doubleVal);
105  }
106 
107  if (boost::regex_match(valueString, matchStrings, FitsStringRegex)) {
108  // strip off the enclosing single quotes and return the string
109  return boost::any(matchStrings[1].str());
110  }
111 
112  return boost::any(valueString);
113 }
ndarray::any
boost::enable_if< typename ExpressionTraits< Scalar >::IsScalar, bool >::type any(Scalar const &scalar)
Definition: operators.h:1165
Generated on Tue Apr 21 2015 10:05:16 for LSSTApplications by   doxygen 1.8.5