include/gz/common/Util.hh

Go to the documentation of this file.

/*
 * Copyright (C) 2016 Open Source Robotics Foundation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
*/
#ifndef GZ_COMMON_UTIL_HH_
#define GZ_COMMON_UTIL_HH_
 
#include <cassert>
#include <chrono>
#include <future>
#include <memory>
#include <string>
#include <thread>
#include <vector>
 
#include <gz/common/Export.hh>
#include <gz/common/Filesystem.hh>
#include <gz/common/SystemPaths.hh>
#include <gz/common/URI.hh>
 
// Defines
 
#ifdef _WIN32
# define GZ_HOMEDIR "USERPROFILE"
#else
# define GZ_HOMEDIR "HOME"
#endif
 
#define GZ_NANO_TO_SEC 1e-9
 
#define GZ_SEC_TO_NANO 1000000000
 
#define GZ_MS_TO_NANO 1000000
 
#define GZ_US_TO_NANO 1000
 
#define GZ_SPEED_OF_LIGHT = 299792458.0
 
#define GZ_SLEEP_S(_s) (std::this_thread::sleep_for(\
                         std::chrono::seconds(_s)))
 
#define GZ_SLEEP_US(_us) (std::this_thread::sleep_for(\
                           std::chrono::microseconds(_us)))
 
#define GZ_SLEEP_MS(_ms) (std::this_thread::sleep_for(\
                           std::chrono::milliseconds(_ms)))
 
#define GZ_SLEEP_NS(_ns) (std::this_thread::sleep_for(\
                           std::chrono::nanoseconds(_ns)))
 
#define GZ_SYSTEM_TIME() (std::chrono::system_clock::now())
 
#define GZ_SYSTEM_TIME_S() (std::chrono::duration_cast<std::chrono::seconds>(\
      std::chrono::system_clock::now().time_since_epoch()).count())
 
#define GZ_SYSTEM_TIME_US() (\
    std::chrono::duration_cast<std::chrono::microseconds>(\
      std::chrono::system_clock::now().time_since_epoch()).count())
 
#define GZ_SYSTEM_TIME_MS() (\
    std::chrono::duration_cast<std::chrono::milliseconds>(\
      std::chrono::system_clock::now().time_since_epoch()).count())
 
#define GZ_SYSTEM_TIME_NS() (\
    std::chrono::duration_cast<std::chrono::nanoseconds>(\
      std::chrono::system_clock::now().time_since_epoch()).count())
 
#define GZ_ASSERT(_expr, _msg) assert((_msg, _expr))
 
namespace gz
{
  namespace common
  {
    enum NodeTransformType {TRANSLATE, ROTATE, SCALE, MATRIX};
 
    typedef std::runtime_error exception;
 
    std::string GZ_COMMON_VISIBLE systemTimeISO();
 
    std::string GZ_COMMON_VISIBLE systemTimeIso();
 
    std::string GZ_COMMON_VISIBLE timeToIso(
        const std::chrono::time_point<std::chrono::system_clock> &_time);
 
    std::string GZ_COMMON_VISIBLE logPath();
 
    void GZ_COMMON_VISIBLE addSearchPathSuffix(
        const std::string &_suffix);
 
    std::string GZ_COMMON_VISIBLE findFile(const std::string &_file);
 
    std::string GZ_COMMON_VISIBLE findFile(const std::string &_file,
                         bool _searchLocalPath);
 
    std::string GZ_COMMON_VISIBLE findFilePath(const std::string &_file);
 
    void GZ_COMMON_VISIBLE addFindFileURICallback(
        std::function<std::string(const URI &)> _cb);
 
    common::SystemPaths GZ_COMMON_VISIBLE *systemPaths();
 
    template<typename T>
    std::string sha1(const T &_buffer);
 
    std::string GZ_COMMON_VISIBLE sha1(
        void const *_buffer, std::size_t _byteCount);
 
    constexpr uint64_t GZ_COMMON_VISIBLE hash64(std::string_view _key)
    {
      const char *data = _key.data();
      const auto len = _key.size();
      const uint64_t prime = 0x100000001b3;
      uint64_t hash = 0xcbf29ce484222325;
 
      for (auto i = 0u; i < len; ++i)
      {
        uint8_t value = static_cast<uint8_t>(data[i]);
        hash = hash ^ value;
        hash *= prime;
      }
 
      return hash;
    }
 
    bool GZ_COMMON_VISIBLE env(
        const std::string &_name, std::string &_value);
 
    bool GZ_COMMON_VISIBLE env(
        const std::string &_name, std::string &_value,
        bool _allowEmpty);
 
    bool GZ_COMMON_VISIBLE setenv(
        const std::string &_name, const std::string &_value);
 
    bool GZ_COMMON_VISIBLE unsetenv(const std::string &_name);
 
    std::string GZ_COMMON_VISIBLE uuid();
 
    std::vector<std::string> GZ_COMMON_VISIBLE split(
        const std::string &_str, const std::string &_delim);
 
    void GZ_COMMON_VISIBLE ltrim(std::string &_s);
 
    void GZ_COMMON_VISIBLE rtrim(std::string &_s);
 
    void GZ_COMMON_VISIBLE trim(std::string &_s);
 
    std::string GZ_COMMON_VISIBLE ltrimmed(std::string _s);
 
    std::string GZ_COMMON_VISIBLE rtrimmed(std::string _s);
 
    std::string GZ_COMMON_VISIBLE trimmed(std::string _s);
 
    std::string GZ_COMMON_VISIBLE lowercase(const std::string &_in);
 
    std::string GZ_COMMON_VISIBLE lowercase(const char *_in);
 
    void GZ_COMMON_VISIBLE replaceAll(std::string &_result,
        const std::string &_orig,
        const std::string &_key,
        const std::string &_replacement);
 
    std::string GZ_COMMON_VISIBLE replaceAll(const std::string &_orig,
        const std::string &_key,
        const std::string &_replacement);
  }
}
 
// Implementation of get_sha1
template<typename T>
std::string gz::common::sha1(const T &_buffer)
{
  if (_buffer.size() == 0)
    return gz::common::sha1(NULL, 0);
  else
  {
    return gz::common::sha1(
        &(_buffer[0]), _buffer.size() * sizeof(_buffer[0]));
  }
}
#endif