template<class Device>
class timer
{

  public:

    typedef Device device_type;
    typedef typename Device::time_duration_type time_duration_type;

    enum start_options { auto_start = 1, manual_start };

    explicit timer(time_duration_type initial_duration = time_duration_type(0, 0, 0), start_options start_op = auto_start)
    :m_elapsed(initial_duration), m_running(false)
    {
        if(start_op == auto_start)
            start();
    }

    void start() 
    {
	    if(!m_running)
        {
		    m_device.start();
            m_running = true;
        }
    }

    void restart()
    {
        reset();
        start();
    }

    time_duration_type elapsed() const
    {
        return m_running ? (m_device.elapsed() + m_elapsed) : m_elapsed;
    }

    void pause()
    {
        if(m_running)
        {
            m_elapsed += m_device.elapsed();
            m_device.reset();
            m_running = false;
        }
    }

    void resume()
    {
        if(!m_running)
        {
            m_device.start();
            m_running = true;
        }
    }

    void reset()
    {
        m_elapsed = time_duration_type(0,0,0);
        m_device.reset();
        m_running = false;
    }


  private:

    mutable device_type         m_device;
    mutable time_duration_type  m_elapsed;
    bool                        m_running;

};

template <class Clock>
class ptime_device
{

  public:

    typedef Clock clock_type;
    typedef typename clock_type::time_duration_type time_duration_type;

    explicit ptime_device()
    : m_start(date_time::not_a_date_time), m_elapsed(0, 0, 0)
    {
    }

    void start()
    {
        if(m_start.is_not_a_date_time())
            m_start = clock_type::local_time();
    }
    
    time_duration_type elapsed()
    {
        if(!m_start.is_not_a_date_time())
        {
            posix_time::ptime current(clock_type::local_time());
            m_elapsed += (current - m_start);
            m_start = current;
        }
        return m_elapsed;
    }

    void reset()
    {
        m_start   = date_time::not_a_date_time;
        m_elapsed = time_duration_type(0,0,0);
    }

  private:

    posix_time::ptime   m_start;
    time_duration_type  m_elapsed;

};

typedef timer< ptime_device<posix_time::microsec_clock> > microsec_timer;
typedef timer< ptime_device<posix_time::second_clock> > second_timer;