Utils.h

Go to the documentation of this file.

// $Id: Utils.h,v 1.15 2011/03/31 13:04:20 mommsen Exp $

#ifndef EventFilter_StorageManager_Utils_h
#define EventFilter_StorageManager_Utils_h

#include <string>
#include <vector>

#include "xcept/Exception.h"
#include "xdaq/ApplicationDescriptor.h"
#include "xdata/String.h"
#include "xdata/Vector.h"

#include "boost/date_time/gregorian/gregorian_types.hpp"
#include "boost/date_time/posix_time/posix_time_types.hpp"
#include "boost/thread/thread.hpp"


namespace stor {

  namespace utils {

    typedef boost::posix_time::ptime TimePoint_t;

    typedef boost::posix_time::time_duration Duration_t;

    Duration_t secondsToDuration(double const& seconds);

    double durationToSeconds(Duration_t const&);

    long secondsSinceEpoch(TimePoint_t const&);

    TimePoint_t getCurrentTime();

    void sleep(Duration_t);

    void sleepUntil(TimePoint_t);

    std::string timeStamp(TimePoint_t);

    std::string timeStampUTC(TimePoint_t);

    std::string asctimeUTC(TimePoint_t);

    std::string dateStamp(TimePoint_t);

    std::string getIdentifier(xdaq::ApplicationDescriptor*);
    
    void checkDirectory(const std::string&);
 
    void getStdVector(xdata::Vector<xdata::String>&, std::vector<std::string>&);
    void getXdataVector(const std::vector<std::string>&, xdata::Vector<xdata::String>&);

    template<typename T, class Comp = std::less<T> > 
    struct ptrComp 
    { 
      bool operator()( T const* const lhs, T const* const rhs ) const 
      { 
        return comp( *lhs, *rhs ); 
      } 
      bool operator()( boost::shared_ptr<T> const& lhs, boost::shared_ptr<T> const& rhs ) const 
      { 
        return comp( *lhs, *rhs ); 
      } 
    private: 
      Comp comp; 
    }; 


    // inline most commonly used methods //

    inline Duration_t secondsToDuration(double const& seconds)
    {
      const unsigned int fullSeconds = static_cast<unsigned int>(seconds);
      return boost::posix_time::seconds(fullSeconds)
        + boost::posix_time::millisec(static_cast<unsigned int>((seconds - fullSeconds)*1000) );
    }
    
    inline double durationToSeconds(Duration_t const& duration)
    {
      return static_cast<double>(duration.total_milliseconds()) / 1000;
    }

    inline long secondsSinceEpoch(TimePoint_t const& timestamp)
    {
      const static boost::posix_time::ptime epoch(boost::gregorian::date(1970,1,1));
      return (timestamp - epoch).total_seconds();
    }

    inline TimePoint_t getCurrentTime()
    {
      return boost::posix_time::ptime(boost::posix_time::microsec_clock::universal_time());
    }

    inline void sleep(Duration_t interval)
    {
      boost::this_thread::sleep(interval); 
    }

    inline void sleepUntil(TimePoint_t theTime)
    {
      boost::this_thread::sleep(theTime);
    }

  } // namespace utils
  
} // namespace stor

#endif // EventFilter_StorageManager_Utils_h