util.hpp

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2005 by Mario Juric   *
 *   mjuric@astro.Princeton.EDU   *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

#ifndef _astro_util_h
#define _astro_util_h

#include "macros.h"
#include "astro_types.hpp"
#include "constants.hpp"

#include <cmath>
#include <string>
#include <cstdlib>
#include <memory.h>
#include <ctype.h>
#include <stdio.h>
#include <exception>
#include <stdexcept>

#ifndef _WIN32
#include <cxxabi.h>
#endif

#ifndef NULL
#define NULL 0
#endif

namespace peyton {
namespace util {

        //      Radians approxSunLongitude(peyton::MJD t);

        std::string ltrim(const std::string &str, const std::string &whitespace = "\t ");
        std::string rtrim(const std::string &str, const std::string &whitespace = "\t ");
        std::string  trim(const std::string &str, const std::string &whitespace = "\t ");
        char *trim(char *txt);
        char *trim(char *dest, const char *src);

        std::string pad(const std::string &s, size_t n, char c = ' ');

        std::string unescape(const std::string &str);

        inline std::string tolower(const std::string &s) { std::string o(s); FOREACH2(std::string::iterator, o) { *i = ::tolower(*i); }; return o; }
        inline std::string toupper(const std::string &s) { std::string o(s); FOREACH2(std::string::iterator, o) { *i = ::toupper(*i); }; return o; }

        inline std::string str(size_t n) { char buf[20]; sprintf(buf, "%lu", n); return buf; }
        inline std::string str(int n) { char buf[20]; sprintf(buf, "%d", n); return buf; }
        inline std::string str(char c) { char buf[2] = {c, 0}; return buf; }
        inline std::string str(double n, const char *fmt = "%f") { char buf[20]; sprintf(buf, fmt, n); return buf; }
        #if 0
        template<typename T>
        inline std::string str(const T& var)
        {
                std::ostringstream ss;
                ss << var;
                return ss.str();
        }
        #endif

        struct demangling_error : public std::runtime_error {
                demangling_error(const char* s): std::runtime_error(("While demangling " + std::string(s)).c_str()) {}
        };

#ifdef _WIN32
        inline std::string type_name(const std::type_info &ti){
                // TODO: find out how to do demangling in Windows
                return ti.name();
        }
#else
        inline std::string type_name(const std::type_info &ti){
                int status = 0;
                char * tmp = abi::__cxa_demangle(ti.name(), 0, 0, &status);
                std::string name = tmp;
                free(tmp);
                if(status != 0)
                        throw demangling_error(ti.name());
                return name;
        }

#endif

        template<typename T>
                std::string type_name()
                {
                        return type_name(typeid(T));
                }

        template<typename T>
                std::string type_name(const T& t)
                {
                        return type_name<T>();
                }
}
namespace Util = util; // backwards compatibility hack

}

using namespace peyton::util;

#endif