Program Listing for File ecal_time.h

Return to documentation for file (ecal/core/include/ecal/ecal_time.h)

/* ========================= eCAL LICENSE =================================
 *
 * Copyright (C) 2016 - 2019 Continental Corporation
 *
 * 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.
 *
 * ========================= eCAL LICENSE =================================
*/

#pragma once

#include <ecal/ecal_os.h>
#include <string>
#include <chrono>

namespace eCAL
{
  namespace Time
  {
    ECAL_API std::string GetName();

    ECAL_API long long GetMicroSeconds();

    ECAL_API long long GetNanoSeconds();

    ECAL_API bool SetNanoSeconds(long long time_);

    ECAL_API bool IsSynchronized();

    ECAL_API bool IsMaster();

    ECAL_API void SleepForNanoseconds(long long duration_nsecs_);

    ECAL_API void GetStatus(int& error_, std::string* status_message_);


    template<class _Rep,
             class _Period> inline
      void sleep_for(const std::chrono::duration<_Rep, _Period>& _Rel_time) {
               long long duration_nsecs = (std::chrono::duration_cast<std::chrono::nanoseconds>(_Rel_time)).count();
               SleepForNanoseconds(duration_nsecs);
    }

    /* @cond */
    struct ecal_clock
    {
      typedef std::chrono::nanoseconds            duration;
      typedef duration::rep                       rep;
      typedef duration::period                    period;
      typedef std::chrono::time_point<ecal_clock> time_point;
      static const bool                           is_steady = false;

      static time_point now()
      {
        return time_point (duration(GetNanoSeconds()));
      }
    };
    /* @endcond */
  }
}

#ifdef ECAL_C_DLL

#include <ecal/ecalc.h>

namespace eCAL
{
  namespace Time
  {
    inline std::string GetName()
    {
      void* buf = nullptr;
      std::string name;
      size_t buf_len = eCAL_Time_GetName(&buf, ECAL_ALLOCATE_4ME);
      if (buf_len > 0)
      {
        name = std::string(static_cast<char*>(buf), buf_len);
        eCAL_FreeMem(buf);
      }
      return(name);
    }

    inline long long GetMicroSeconds()
    {
      return(eCAL_Time_GetMicroSeconds());
    }

    inline long long GetNanoSeconds()
    {
      return(eCAL_Time_GetNanoSeconds());
    }

    inline bool SetNanoSeconds(long long time_)
    {
      return(eCAL_Time_SetNanoSeconds(time_) != 0);
    }

    inline bool IsSynchronized()
    {
      return(eCAL_Time_IsTimeSynchronized() != 0);
    }

    inline bool IsMaster()
    {
      return(eCAL_Time_IsTimeMaster() != 0);
    }

    inline void SleepForNanoseconds(long long duration_nsecs_)
    {
      eCAL_Time_SleepForNanoseconds(duration_nsecs_);
    }

    inline void GetStatus(int& error_, std::string* const status_message_)
    {
      if (status_message_) {
        char* buf = nullptr;
        int bytes_copied = eCAL_Time_GetStatus(&error_, &buf, ECAL_ALLOCATE_4ME);
        status_message_->assign((char*)buf, bytes_copied);
        eCAL_FreeMem(buf);
      }
      else {
        eCAL_Time_GetStatus(&error_, nullptr, -1);
      }
    }
  }
}

#endif /* ECAL_C_DLL */