lsst::utils Namespace Reference

Namespaces
	multithreading
	tests
	version

Classes
class	Symbol
struct	n
struct	key

Functions
std::string	demangleType (std::string const _typeName)
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=":")
std::string	getPackageDir (std::string const &packageName)
	return the root directory of a setup package More...

Function Documentation

std::string lsst::utils::demangleType

(

std::string const

_typeName

)

Definition at line 113 of file Demangle.cc.

                                                  {
#if 1
    typedef multi_index_container<
        Symbol,
        indexed_by<
            ordered_unique<tag<n>,
                member<Symbol, int, &Symbol::n> >,
            ordered_unique<tag<key>,
                member<Symbol, std::string, &Symbol::key> >
        >
    > SymbolTable;
    typedef SymbolTable::index<n>::type::iterator nIterator;
    typedef SymbolTable::index<key>::type::iterator keyIterator;
    Symbol::reset();
   
    // Here's my symbol table and its indices
    SymbolTable st;
    
    SymbolTable::index<n>::type &nIndex = st.get<n>();
    SymbolTable::index<key>::type &keyIndex = st.get<key>();
    //
    // Start mangling
    //
    std::string typeName("");
    const char *ptr = _typeName.c_str();

    if (*ptr == 'r' || *ptr == 'V' || *ptr == 'K') {
        ptr++;                          // (restrict/volatile/const)
    }
    
    if (*ptr == 'P') ptr++;             // We passed "this" which is (type *)

    std::string currentSymbol = "";     // Current symbol
    std::stack<char> typeStack;         // Did we last see an N or an I?

    int lastTokenWasType = 0;           // When > 0, the last token was a type such as int or float
    while (*ptr != '\0') {
        lastTokenWasType--;
        switch (*ptr) {
          case 'E':
            ptr++;
            currentSymbol = "";

            if (typeStack.empty()) {
                typeStack.push('\a');   // at least don't crash
            }

            if (typeStack.top() == 'I') {
                typeName += '>';
            } else if (typeStack.top() == 'L') {
                ;
            } else if (typeStack.top() == 'N') {
                ;
            }
            typeStack.pop();

            if (!typeStack.empty() && typeStack.top() == 'I') {
                if (*ptr != 'E' && typeName[typeName.size() - 1] != '<') {
                    typeName += ',';
                }
            }
                        
            break;
          case 'I':
            typeStack.push(*ptr++);
            currentSymbol = "";

            typeName += '<';
            break;
          case 'L':
            typeStack.push(*ptr++);
            currentSymbol = "";
            {
                std::string type;
                if (interpret_typeletter(*ptr, type)) {
                    typeName += "(" + type + ')';
                } else {
                    typeName += 'c';
                }
                ptr++;
            }
            if (*ptr == 'n') {
                typeName += '-'; ptr++;
            }
            while (*ptr != '\0' && *ptr != 'E') {
                typeName += *ptr++;
            }
            break;
          case 'N':
            typeStack.push(*ptr++);
            currentSymbol = "";
            break;
          case 'S':
            ++ptr;
            switch (*ptr) {
              case 't': typeName += "::std::"; break;
              case 'a': typeName += "::std::allocator"; break;
              case 'b': typeName += "::std::basic_string"; break;
              case 's': typeName += "::std::basic_string<char,::std::char_traits<char>,::std::allocator<char>>"; break;
              case 'i': typeName += "::std::basic_istream<char,  std::char_traits<char> >"; break;
              case 'o': typeName += "::std::basic_ostream<char,std::char_traits<char>>"; break;
              case 'd': typeName += "::std::basic_iostream<char,std::char_traits<char>>"; break;
              default:
                {
                    int subst = 0;      // number of substitution

                    if (*ptr == '_') {
                        ;                   // S_ => 0
                    } else if (isdigit(*ptr) || isupper(*ptr)) {
                        while (isdigit(*ptr) || isupper(*ptr)) {
                            if (isdigit(*ptr)) {
                                subst = 36*subst + (*ptr - '0');
                            } else {
                                subst = 36*subst + 10 + (*ptr - 'A');
                            }
                            ptr++;
                        }
                        subst++;            // S_ == 0; S1_ == 1
                        assert (*ptr == '_');
                        ptr++;
                    }

                    nIterator sym = nIndex.find(subst);
                    if (sym == nIndex.end()) { // not found
                        typeName += (boost::format("[S%d]") % subst).str();
                    } else {
                        typeName += sym->key;
                    }

                }
                break;
            }
            currentSymbol = "";
            break;
          case '0': case '1': case '2': case '3': case '4':
          case '5': case '6': case '7': case '8': case '9':
            {
                const int len = atoi(ptr++);
                while (isdigit(*ptr)) ptr++;

                std::string name = "";
                for (int i = 0; *ptr != '\0' && i < len; i++) {
                    name += *ptr++;
                }

                if (currentSymbol != "") {
                    currentSymbol += "::";
                    typeName += "::";
                }
            
                currentSymbol += name;
                typeName += name;

                if (keyIndex.find(currentSymbol) == keyIndex.end()) {
                    st.insert(currentSymbol);
                }
            }
            break;
          default:
            {
                std::string type;
                if (interpret_typeletter(*ptr, type)) {
                    if (lastTokenWasType > 0) {
                        typeName += ",";
                    }
                    typeName += type;
                    lastTokenWasType = 2; // it'll be decremented on every char in the name
                } else {
                    typeName += *ptr;
                }
                ptr++;
            }
        }
    }

    static volatile bool dumpSymbolTable = false; // can be set from gdb
    if (dumpSymbolTable) {
        // The test on the iterator is paranoid, but they _could_
        // have deleted elements.  In this case, they didn't.
        for (unsigned int i = 0; i < st.size(); i++) {
            nIterator el = nIndex.find(2);
            if (el != nIndex.end()) {          // did we find it?
                el->print();
            }
        }
    }

    return typeName;
#else
    return _typeName;
#endif
}

std::string lsst::utils::getPackageDir

(

std::string const &

packageName

)

return the root directory of a setup package

Parameters

[in]

packageName

name of package (e.g. "utils")

Exceptions

lsst::pex::exceptions::NotFoundError

if desired version can't be found

Examples:

spatialCellExample.cc.

Definition at line 34 of file Utils.cc.

                                                      {
    std::string envVar = packageName;      // package's environment variable
    
    transform(envVar.begin(), envVar.end(), envVar.begin(), (int (*)(int)) toupper);
    envVar += "_DIR";
    
    char const *dir = getenv(envVar.c_str());
    if (!dir) {
        throw LSST_EXCEPT(lsst::pex::exceptions::NotFoundError, "Package " + packageName + " not found");
    }
    
    return dir;
}