os.hpp

Go to the documentation of this file.

#pragma once
/*
 * Copyright (c) 2012, 2013 Aldebaran Robotics. All rights reserved.
 * Use of this source code is governed by a BSD-style license that can be
 * found in the COPYING file.
 */

#ifndef _QI_OS_HPP_
# define _QI_OS_HPP_

# include <cstdio>
# include <string>
# include <map>
# include <vector>
# include <qi/api.hpp>
# include <qi/types.hpp>
# include <qi/path.hpp>
# include <qi/clock.hpp>

# include <boost/lexical_cast.hpp>

#ifdef _WIN32
#ifndef SIGKILL
#define SIGKILL 9
#endif
#endif

struct stat;

namespace qi {

  namespace os {
    QI_API FILE* fopen(const char *filename, const char *mode);
    QI_API int stat(const char *filename, struct stat *pstat);
    QI_API int checkdbg();
    QI_API std::string home();
    QI_API std::string mktmpdir(const char *prefix = "");
    QI_API std::string tmp();
    QI_API void symlink(const qi::Path& source, const qi::Path& destination);
    QI_API std::string gethostname();
    QI_API int isatty(int fd = 1);

    QI_API bool fnmatch(const std::string &pattern, const std::string &string);

    // lib C
    QI_API char* strdup(const char *src);
    QI_API int snprintf(char *str, size_t size, const char *format, ...);

    QI_API std::string getenv(const char *var);

    QI_API std::string pathsep();

    QI_API int setenv(const char *var, const char *value);
    QI_API std::string timezone();

    // time
    QI_API void sleep(unsigned int seconds);
    QI_API void msleep(unsigned int milliseconds);
    struct QI_API timeval {
      qi::int64_t tv_sec;  
      qi::int64_t tv_usec; 

      timeval() : tv_sec(0), tv_usec(0) {}
      timeval(int64_t sec, int64_t usec) : tv_sec(sec), tv_usec(usec) {}
      explicit timeval(int64_t usec);
      explicit timeval(const qi::Duration &);
      explicit timeval(const qi::SystemClockTimePoint &);
    };

    QI_API QI_API_DEPRECATED int gettimeofday(qi::os::timeval *tp);
    QI_API qi::int64_t ustime();
    QI_API std::pair<int64_t, int64_t> cputime();

    QI_API qi::os::timeval operator+(const qi::os::timeval &lhs,
                                     const qi::os::timeval &rhs);
    QI_API qi::os::timeval operator+(const qi::os::timeval &lhs,
                                     long                   us);
    QI_API qi::os::timeval operator-(const qi::os::timeval &lhs,
                                     const qi::os::timeval &rhs);
    QI_API qi::os::timeval operator-(const qi::os::timeval &lhs,
                                     long                   us);

    QI_API void *dlopen(const char *filename, int flag = -1);
    QI_API int dlclose(void *handle);
    QI_API void *dlsym(void *handle, const char *symbol);
    QI_API const char *dlerror();

    // process management
    QI_API int spawnvp(char *const argv[]);
    QI_API int spawnlp(const char* argv, ...);
    QI_API int system(const char *command);
    QI_API int getpid();
    QI_API int gettid();
    QI_API int waitpid(int pid, int* status);
    QI_API int kill(int pid, int sig);

    QI_API bool isProcessRunning(int pid, const std::string& fileName = std::string());

    QI_API unsigned short findAvailablePort(unsigned short port);
    QI_API std::map<std::string, std::vector<std::string> > hostIPAddrs(bool ipv6Addr = false);

    QI_API void setCurrentThreadName(const std::string &name);
    QI_API std::string currentThreadName();


    class QI_API ScopedThreadName {
    public:
      ScopedThreadName(const std::string& newName) {
        _oldName = currentThreadName();
        setCurrentThreadName(newName);
      };
      ~ScopedThreadName() {
        setCurrentThreadName(_oldName);
      }
    private:
      std::string _oldName;
    };


    QI_API bool setCurrentThreadCPUAffinity(const std::vector<int> &cpus);
    QI_API long numberOfCPUs();
    QI_API std::string getMachineId();
    QI_API std::string generateUuid();
    QI_API size_t memoryUsage(unsigned int pid);


    template <typename T>
    inline T getEnvParam(const char* name, T defaultVal)
    {
      std::string sval = qi::os::getenv(name);
      if (sval.empty())
        return defaultVal;
      else
        return boost::lexical_cast<T>(sval);
    }

  }
}

#endif  // _QI_OS_HPP_