Merge lp:~thomas-voss/location-service/cherry-pick-fwd into lp:location-service/trunk

[Thomas Voß]

[ Alberto Mardegan ]
* Make sure that injected time is given in milliseconds
[ Thomas Voß ]
* Cherry-pick rev. 196 and 199 from lp:location-service. The changes
  got accidentally removed by merging the outstanding documentation
  branch.
* Handle responses of clients to updates asynchronously. Rely on
  dummy::ConnectivityManager as harvesting is disabled anyway. (LP:
  #1462664, #1387643)
[ Thomas Voß ]
* Add documentation for debugging, hacking and debugging the location
  service. Pull manual testing instructions over from the wiki. Add
  tools for formatting the source.
[ thomas-voss ]
* Add documentation for debugging, hacking and debugging the location
  service. Pull manual testing instructions over from the wiki. Add
  tools for formatting the source.

[ Alberto Mardegan ]
* Make sure that injected time is given in milliseconds
[ Thomas Voß ]
* Cherry-pick rev. 196 and 199 from lp:location-service. The changes
  got accidentally removed by merging the outstanding documentation
  branch.
* Handle responses of clients to updates asynchronously. Rely on
  dummy::ConnectivityManager as harvesting is disabled anyway. (LP:
  #1462664, #1387643)
[ Thomas Voß ]
* Add documentation for debugging, hacking and debugging the location
  service. Pull manual testing instructions over from the wiki. Add
  tools for formatting the source.
[ thomas-voss ]
* Add documentation for debugging, hacking and debugging the location
  service. Pull manual testing instructions over from the wiki. Add
  tools for formatting the source.

[Alberto Mardegan (mardy)]

LGTM

review: Approve

[lp:~thomas-voss/location-service/cherry-pick-fwd]

218. By Thomas Voß on 2015-11-20

Adjust default timeout for downloading GPS XTRA data.

219. By Thomas Voß on 2016-01-14

[ Alberto Mardegan ]
* Set debian source format to "3.0 (native)"
[ Scott Sweeny ]
* Allow providers to register themselves asynchronously (LP: #1415029)
* Account for changes in trust-store w.r.t. assembling the description
  of a trust prompt.
* Fix settings not being applied correctly.
* Ensure that event connections are cleaned up on destruction. (LP:
  #1480877)
[ Alberto Mardegan ]
* Send last known position on session start
[ CI Train Bot ]
* New rebuild forced.
[ Thomas Voß ]
* Factor out service::Runtime from daemon.cpp into its own .h/.cpp
  pair of files. Add test cases around correct operation of
  service::Runtime. added:
  src/location_service/com/ubuntu/location/service/runtime.cpp
  src/location_service/com/ubuntu/location/service/runtime.h
  tests/runtime_test.cpp
[ thomas-voss ]
* Factor out service::Runtime from daemon.cpp into its own .h/.cpp
  pair of files. Add test cases around correct operation of
  service::Runtime. added:
  src/location_service/com/ubuntu/location/service/runtime.cpp
  src/location_service/com/ubuntu/location/service/runtime.h
  tests/runtime_test.cpp

220. By Thomas Voß on 2016-03-17

* Add SntpClient for querying reference time information.
* Remove explicit option to disable satellite-based positioning
  services.

221. By Thomas Voß on 2016-03-17

Resync to trunk.

222. By Thomas Voß on 2016-04-01

Log to stderr by default, relying on upstart to rotate logs
appropriately. (LP: #1447110)

=== added directory '3rd-party'
=== added directory '3rd-party/boost'
=== added directory '3rd-party/boost/core'
=== added file '3rd-party/boost/core/scoped_enum.hpp'
--- 3rd-party/boost/core/scoped_enum.hpp	1970-01-01 00:00:00 +0000
+++ 3rd-party/boost/core/scoped_enum.hpp	2016-04-01 06:55:25 +0000
@@ -0,0 +1,192 @@
+//  scoped_enum.hpp  ---------------------------------------------------------//
+
+//  Copyright Beman Dawes, 2009
+//  Copyright (C) 2011-2012 Vicente J. Botet Escriba
+//  Copyright (C) 2012 Anthony Williams
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+#ifndef BOOST_CORE_SCOPED_ENUM_HPP
+#define BOOST_CORE_SCOPED_ENUM_HPP
+
+#include <boost/config.hpp>
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+#pragma once
+#endif
+
+namespace boost
+{
+
+#ifdef BOOST_NO_CXX11_SCOPED_ENUMS
+
+  /**
+   * Meta-function to get the native enum type associated to an enum class or its emulation.
+   */
+  template <typename EnumType>
+  struct native_type
+  {
+    /**
+     * The member typedef type names the native enum type associated to the scoped enum,
+     * which is it self if the compiler supports scoped enums or EnumType::enum_type if it is an emulated scoped enum.
+     */
+    typedef typename EnumType::enum_type type;
+  };
+
+  /**
+   * Casts a scoped enum to its underlying type.
+   *
+   * This function is useful when working with scoped enum classes, which doens't implicitly convert to the underlying type.
+   * @param v A scoped enum.
+   * @returns The underlying type.
+   * @throws No-throws.
+   */
+  template <typename UnderlyingType, typename EnumType>
+  UnderlyingType underlying_cast(EnumType v)
+  {
+    return v.get_underlying_value_();
+  }
+
+  /**
+   * Casts a scoped enum to its native enum type.
+   *
+   * This function is useful to make programs portable when the scoped enum emulation can not be use where native enums can.
+   *
+   * EnumType the scoped enum type
+   *
+   * @param v A scoped enum.
+   * @returns The native enum value.
+   * @throws No-throws.
+   */
+  template <typename EnumType>
+  inline
+  typename EnumType::enum_type native_value(EnumType e)
+  {
+    return e.get_native_value_();
+  }
+
+#else  // BOOST_NO_CXX11_SCOPED_ENUMS
+
+  template <typename EnumType>
+  struct native_type
+  {
+    typedef EnumType type;
+  };
+
+  template <typename UnderlyingType, typename EnumType>
+  UnderlyingType underlying_cast(EnumType v)
+  {
+    return static_cast<UnderlyingType>(v);
+  }
+
+  template <typename EnumType>
+  inline
+  EnumType native_value(EnumType e)
+  {
+    return e;
+  }
+
+#endif // BOOST_NO_CXX11_SCOPED_ENUMS
+}
+
+
+#ifdef BOOST_NO_CXX11_SCOPED_ENUMS
+
+#ifndef BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
+
+#define BOOST_SCOPED_ENUM_UT_DECLARE_CONVERSION_OPERATOR \
+     explicit operator underlying_type() const BOOST_NOEXCEPT { return get_underlying_value_(); }
+
+#else
+
+#define BOOST_SCOPED_ENUM_UT_DECLARE_CONVERSION_OPERATOR
+
+#endif
+
+/**
+ * Start a declaration of a scoped enum.
+ *
+ * @param EnumType The new scoped enum.
+ * @param UnderlyingType The underlying type.
+ */
+#define BOOST_SCOPED_ENUM_UT_DECLARE_BEGIN(EnumType, UnderlyingType)    \
+    struct EnumType {                                                   \
+        typedef void is_boost_scoped_enum_tag;                          \
+        typedef UnderlyingType underlying_type;                         \
+        EnumType() BOOST_NOEXCEPT {}                                    \
+        explicit EnumType(underlying_type v) BOOST_NOEXCEPT : v_(v) {}                 \
+        underlying_type get_underlying_value_() const BOOST_NOEXCEPT { return v_; }    \
+        BOOST_SCOPED_ENUM_UT_DECLARE_CONVERSION_OPERATOR                \
+    private:                                                            \
+        underlying_type v_;                                             \
+        typedef EnumType self_type;                                     \
+    public:                                                             \
+        enum enum_type
+
+#define BOOST_SCOPED_ENUM_DECLARE_END2() \
+        enum_type get_native_value_() const BOOST_NOEXCEPT { return enum_type(v_); } \
+        friend bool operator ==(self_type lhs, self_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)==enum_type(rhs.v_); } \
+        friend bool operator ==(self_type lhs, enum_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)==rhs; } \
+        friend bool operator ==(enum_type lhs, self_type rhs) BOOST_NOEXCEPT { return lhs==enum_type(rhs.v_); } \
+        friend bool operator !=(self_type lhs, self_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)!=enum_type(rhs.v_); } \
+        friend bool operator !=(self_type lhs, enum_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)!=rhs; } \
+        friend bool operator !=(enum_type lhs, self_type rhs) BOOST_NOEXCEPT { return lhs!=enum_type(rhs.v_); } \
+        friend bool operator <(self_type lhs, self_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)<enum_type(rhs.v_); } \
+        friend bool operator <(self_type lhs, enum_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)<rhs; } \
+        friend bool operator <(enum_type lhs, self_type rhs) BOOST_NOEXCEPT { return lhs<enum_type(rhs.v_); } \
+        friend bool operator <=(self_type lhs, self_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)<=enum_type(rhs.v_); } \
+        friend bool operator <=(self_type lhs, enum_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)<=rhs; } \
+        friend bool operator <=(enum_type lhs, self_type rhs) BOOST_NOEXCEPT { return lhs<=enum_type(rhs.v_); } \
+        friend bool operator >(self_type lhs, self_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)>enum_type(rhs.v_); } \
+        friend bool operator >(self_type lhs, enum_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)>rhs; } \
+        friend bool operator >(enum_type lhs, self_type rhs) BOOST_NOEXCEPT { return lhs>enum_type(rhs.v_); } \
+        friend bool operator >=(self_type lhs, self_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)>=enum_type(rhs.v_); } \
+        friend bool operator >=(self_type lhs, enum_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)>=rhs; } \
+        friend bool operator >=(enum_type lhs, self_type rhs) BOOST_NOEXCEPT { return lhs>=enum_type(rhs.v_); } \
+    };
+
+#define BOOST_SCOPED_ENUM_DECLARE_END(EnumType) \
+    ; \
+    EnumType(enum_type v) BOOST_NOEXCEPT : v_(v) {}                 \
+    BOOST_SCOPED_ENUM_DECLARE_END2()
+
+/**
+ * Starts a declaration of a scoped enum with the default int underlying type.
+ *
+ * @param EnumType The new scoped enum.
+ */
+#define BOOST_SCOPED_ENUM_DECLARE_BEGIN(EnumType) \
+  BOOST_SCOPED_ENUM_UT_DECLARE_BEGIN(EnumType,int)
+
+/**
+ * Name of the native enum type.
+ *
+ * @param EnumType The new scoped enum.
+ */
+#define BOOST_SCOPED_ENUM_NATIVE(EnumType) EnumType::enum_type
+/**
+ * Forward declares an scoped enum.
+ *
+ * @param EnumType The scoped enum.
+ */
+#define BOOST_SCOPED_ENUM_FORWARD_DECLARE(EnumType) struct EnumType
+
+#else  // BOOST_NO_CXX11_SCOPED_ENUMS
+
+#define BOOST_SCOPED_ENUM_UT_DECLARE_BEGIN(EnumType,UnderlyingType) enum class EnumType : UnderlyingType
+#define BOOST_SCOPED_ENUM_DECLARE_BEGIN(EnumType) enum class EnumType
+#define BOOST_SCOPED_ENUM_DECLARE_END2()
+#define BOOST_SCOPED_ENUM_DECLARE_END(EnumType) ;
+
+#define BOOST_SCOPED_ENUM_NATIVE(EnumType) EnumType
+#define BOOST_SCOPED_ENUM_FORWARD_DECLARE(EnumType) enum class EnumType
+
+#endif  // BOOST_NO_CXX11_SCOPED_ENUMS
+
+// Deprecated macros
+#define BOOST_SCOPED_ENUM_START(name) BOOST_SCOPED_ENUM_DECLARE_BEGIN(name)
+#define BOOST_SCOPED_ENUM_END BOOST_SCOPED_ENUM_DECLARE_END2()
+#define BOOST_SCOPED_ENUM(name) BOOST_SCOPED_ENUM_NATIVE(name)
+
+#endif  // BOOST_CORE_SCOPED_ENUM_HPP

=== added directory '3rd-party/boost/endian'
=== added file '3rd-party/boost/endian/arithmetic.hpp'
--- 3rd-party/boost/endian/arithmetic.hpp	1970-01-01 00:00:00 +0000
+++ 3rd-party/boost/endian/arithmetic.hpp	2016-04-01 06:55:25 +0000
@@ -0,0 +1,413 @@
+//  boost/endian/arithmetic.hpp  -------------------------------------------------------//
+
+//  (C) Copyright Darin Adler 2000
+//  (C) Copyright Beman Dawes 2006, 2009, 2014
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+//  See library home page at http://www.boost.org/libs/endian
+
+//--------------------------------------------------------------------------------------//
+
+//  Original design developed by Darin Adler based on classes developed by Mark
+//  Borgerding. Four original class templates were combined into a single endian
+//  class template by Beman Dawes, who also added the unrolled_byte_loops sign
+//  partial specialization to correctly extend the sign when cover integer size
+//  differs from endian representation size.
+
+// TODO: When a compiler supporting constexpr becomes available, try possible uses.
+
+#ifndef BOOST_ENDIAN_ARITHMETIC_HPP
+#define BOOST_ENDIAN_ARITHMETIC_HPP
+
+#if defined(_MSC_VER)  
+# pragma warning(push)  
+# pragma warning(disable:4365)  // conversion ... signed/unsigned mismatch
+#endif
+
+#ifdef BOOST_ENDIAN_LOG
+# include <iostream>
+#endif
+
+#if defined(__BORLANDC__) || defined( __CODEGEARC__)
+# pragma pack(push, 1)
+#endif
+
+#include <boost/config.hpp>
+#include <boost/predef/detail/endian_compat.h>
+#include <boost/endian/conversion.hpp>
+#include <boost/endian/buffers.hpp>
+#define  BOOST_ENDIAN_MINIMAL_COVER_OPERATORS
+#include <boost/endian/detail/cover_operators.hpp>
+#undef   BOOST_ENDIAN_MINIMAL_COVER_OPERATORS
+#include <boost/type_traits/is_signed.hpp>
+#include <boost/cstdint.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/core/scoped_enum.hpp>
+#include <iosfwd>
+#include <climits>
+
+# if CHAR_BIT != 8
+#   error Platforms with CHAR_BIT != 8 are not supported
+# endif
+
+# ifdef BOOST_NO_CXX11_DEFAULTED_FUNCTIONS
+#   define BOOST_ENDIAN_DEFAULT_CONSTRUCT {}          // C++03
+# else
+#   define BOOST_ENDIAN_DEFAULT_CONSTRUCT = default;  // C++0x
+# endif
+
+# if defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS) && defined(BOOST_ENDIAN_FORCE_PODNESS)
+#   define BOOST_ENDIAN_NO_CTORS
+# endif
+
+# ifndef BOOST_ENDIAN_EXPLICIT_CTORS
+#   define BOOST_ENDIAN_EXPLICIT_OPT
+# else
+#   define BOOST_ENDIAN_EXPLICIT_OPT explicit
+# endif
+
+//----------------------------------  synopsis  ----------------------------------------//
+
+namespace boost
+{
+namespace endian
+{
+
+  template <BOOST_SCOPED_ENUM(order) Order, class T, std::size_t n_bits,
+    BOOST_SCOPED_ENUM(align) A = align::no>
+      class endian_arithmetic;
+
+  // big endian signed integer aligned types
+  typedef endian_arithmetic<order::big, int8_t, 8, align::yes>        big_int8_at;
+  typedef endian_arithmetic<order::big, int16_t, 16, align::yes>      big_int16_at;
+  typedef endian_arithmetic<order::big, int32_t, 32, align::yes>      big_int32_at;
+  typedef endian_arithmetic<order::big, int64_t, 64, align::yes>      big_int64_at;
+
+  // big endian unsigned integer aligned types
+  typedef endian_arithmetic<order::big, uint8_t, 8, align::yes>       big_uint8_at;
+  typedef endian_arithmetic<order::big, uint16_t, 16, align::yes>     big_uint16_at;
+  typedef endian_arithmetic<order::big, uint32_t, 32, align::yes>     big_uint32_at;
+  typedef endian_arithmetic<order::big, uint64_t, 64, align::yes>     big_uint64_at;
+
+  // little endian signed integer aligned types
+  typedef endian_arithmetic<order::little, int8_t, 8, align::yes>     little_int8_at;
+  typedef endian_arithmetic<order::little, int16_t, 16, align::yes>   little_int16_at;
+  typedef endian_arithmetic<order::little, int32_t, 32, align::yes>   little_int32_at;
+  typedef endian_arithmetic<order::little, int64_t, 64, align::yes>   little_int64_at;
+
+  // little endian unsigned integer aligned types
+  typedef endian_arithmetic<order::little, uint8_t, 8, align::yes>    little_uint8_at;
+  typedef endian_arithmetic<order::little, uint16_t, 16, align::yes>  little_uint16_at;
+  typedef endian_arithmetic<order::little, uint32_t, 32, align::yes>  little_uint32_at;
+  typedef endian_arithmetic<order::little, uint64_t, 64, align::yes>  little_uint64_at;
+
+  // aligned native endian typedefs are not provided because
+  // <cstdint> types are superior for this use case
+
+  // big endian signed integer unaligned types
+  typedef endian_arithmetic<order::big, int_least8_t, 8>        big_int8_t;
+  typedef endian_arithmetic<order::big, int_least16_t, 16>      big_int16_t;
+  typedef endian_arithmetic<order::big, int_least32_t, 24>      big_int24_t;
+  typedef endian_arithmetic<order::big, int_least32_t, 32>      big_int32_t;
+  typedef endian_arithmetic<order::big, int_least64_t, 40>      big_int40_t;
+  typedef endian_arithmetic<order::big, int_least64_t, 48>      big_int48_t;
+  typedef endian_arithmetic<order::big, int_least64_t, 56>      big_int56_t;
+  typedef endian_arithmetic<order::big, int_least64_t, 64>      big_int64_t;
+
+  // big endian unsigned integer unaligned types
+  typedef endian_arithmetic<order::big, uint_least8_t, 8>       big_uint8_t;
+  typedef endian_arithmetic<order::big, uint_least16_t, 16>     big_uint16_t;
+  typedef endian_arithmetic<order::big, uint_least32_t, 24>     big_uint24_t;
+  typedef endian_arithmetic<order::big, uint_least32_t, 32>     big_uint32_t;
+  typedef endian_arithmetic<order::big, uint_least64_t, 40>     big_uint40_t;
+  typedef endian_arithmetic<order::big, uint_least64_t, 48>     big_uint48_t;
+  typedef endian_arithmetic<order::big, uint_least64_t, 56>     big_uint56_t;
+  typedef endian_arithmetic<order::big, uint_least64_t, 64>     big_uint64_t;
+
+  // little endian signed integer unaligned types
+  typedef endian_arithmetic<order::little, int_least8_t, 8>     little_int8_t;
+  typedef endian_arithmetic<order::little, int_least16_t, 16>   little_int16_t;
+  typedef endian_arithmetic<order::little, int_least32_t, 24>   little_int24_t;
+  typedef endian_arithmetic<order::little, int_least32_t, 32>   little_int32_t;
+  typedef endian_arithmetic<order::little, int_least64_t, 40>   little_int40_t;
+  typedef endian_arithmetic<order::little, int_least64_t, 48>   little_int48_t;
+  typedef endian_arithmetic<order::little, int_least64_t, 56>   little_int56_t;
+  typedef endian_arithmetic<order::little, int_least64_t, 64>   little_int64_t;
+
+  // little endian unsigned integer unaligned types
+  typedef endian_arithmetic<order::little, uint_least8_t, 8>    little_uint8_t;
+  typedef endian_arithmetic<order::little, uint_least16_t, 16>  little_uint16_t;
+  typedef endian_arithmetic<order::little, uint_least32_t, 24>  little_uint24_t;
+  typedef endian_arithmetic<order::little, uint_least32_t, 32>  little_uint32_t;
+  typedef endian_arithmetic<order::little, uint_least64_t, 40>  little_uint40_t;
+  typedef endian_arithmetic<order::little, uint_least64_t, 48>  little_uint48_t;
+  typedef endian_arithmetic<order::little, uint_least64_t, 56>  little_uint56_t;
+  typedef endian_arithmetic<order::little, uint_least64_t, 64>  little_uint64_t;
+
+# ifdef BOOST_BIG_ENDIAN
+  // native endian signed integer unaligned types
+  typedef big_int8_t   native_int8_t;
+  typedef big_int16_t  native_int16_t;
+  typedef big_int24_t  native_int24_t;
+  typedef big_int32_t  native_int32_t;
+  typedef big_int40_t  native_int40_t;
+  typedef big_int48_t  native_int48_t;
+  typedef big_int56_t  native_int56_t;
+  typedef big_int64_t  native_int64_t;
+
+  // native endian unsigned integer unaligned types
+  typedef big_uint8_t   native_uint8_t;
+  typedef big_uint16_t  native_uint16_t;
+  typedef big_uint24_t  native_uint24_t;
+  typedef big_uint32_t  native_uint32_t;
+  typedef big_uint40_t  native_uint40_t;
+  typedef big_uint48_t  native_uint48_t;
+  typedef big_uint56_t  native_uint56_t;
+  typedef big_uint64_t  native_uint64_t;
+# else
+  // native endian signed integer unaligned types
+  typedef little_int8_t   native_int8_t;
+  typedef little_int16_t  native_int16_t;
+  typedef little_int24_t  native_int24_t;
+  typedef little_int32_t  native_int32_t;
+  typedef little_int40_t  native_int40_t;
+  typedef little_int48_t  native_int48_t;
+  typedef little_int56_t  native_int56_t;
+  typedef little_int64_t  native_int64_t;
+
+  // native endian unsigned integer unaligned types
+  typedef little_uint8_t   native_uint8_t;
+  typedef little_uint16_t  native_uint16_t;
+  typedef little_uint24_t  native_uint24_t;
+  typedef little_uint32_t  native_uint32_t;
+  typedef little_uint40_t  native_uint40_t;
+  typedef little_uint48_t  native_uint48_t;
+  typedef little_uint56_t  native_uint56_t;
+  typedef little_uint64_t  native_uint64_t;
+# endif
+
+# ifdef BOOST_ENDIAN_DEPRECATED_NAMES
+
+  typedef order endianness;
+  typedef align alignment;
+
+# ifndef  BOOST_NO_CXX11_TEMPLATE_ALIASES
+  template <BOOST_SCOPED_ENUM(order) Order, class T, std::size_t n_bits,
+    BOOST_SCOPED_ENUM(align) Align = align::no>
+  using endian = endian_arithmetic<Order, T, n_bits, Align>;
+# endif
+
+  // unaligned big endian signed integer types
+  typedef endian_arithmetic< order::big, int_least8_t, 8 >           big8_t;
+  typedef endian_arithmetic< order::big, int_least16_t, 16 >         big16_t;
+  typedef endian_arithmetic< order::big, int_least32_t, 24 >         big24_t;
+  typedef endian_arithmetic< order::big, int_least32_t, 32 >         big32_t;
+  typedef endian_arithmetic< order::big, int_least64_t, 40 >         big40_t;
+  typedef endian_arithmetic< order::big, int_least64_t, 48 >         big48_t;
+  typedef endian_arithmetic< order::big, int_least64_t, 56 >         big56_t;
+  typedef endian_arithmetic< order::big, int_least64_t, 64 >         big64_t;
+
+  // unaligned big endian_arithmetic unsigned integer types
+  typedef endian_arithmetic< order::big, uint_least8_t, 8 >          ubig8_t;
+  typedef endian_arithmetic< order::big, uint_least16_t, 16 >        ubig16_t;
+  typedef endian_arithmetic< order::big, uint_least32_t, 24 >        ubig24_t;
+  typedef endian_arithmetic< order::big, uint_least32_t, 32 >        ubig32_t;
+  typedef endian_arithmetic< order::big, uint_least64_t, 40 >        ubig40_t;
+  typedef endian_arithmetic< order::big, uint_least64_t, 48 >        ubig48_t;
+  typedef endian_arithmetic< order::big, uint_least64_t, 56 >        ubig56_t;
+  typedef endian_arithmetic< order::big, uint_least64_t, 64 >        ubig64_t;
+
+  // unaligned little endian_arithmetic signed integer types
+  typedef endian_arithmetic< order::little, int_least8_t, 8 >        little8_t;
+  typedef endian_arithmetic< order::little, int_least16_t, 16 >      little16_t;
+  typedef endian_arithmetic< order::little, int_least32_t, 24 >      little24_t;
+  typedef endian_arithmetic< order::little, int_least32_t, 32 >      little32_t;
+  typedef endian_arithmetic< order::little, int_least64_t, 40 >      little40_t;
+  typedef endian_arithmetic< order::little, int_least64_t, 48 >      little48_t;
+  typedef endian_arithmetic< order::little, int_least64_t, 56 >      little56_t;
+  typedef endian_arithmetic< order::little, int_least64_t, 64 >      little64_t;
+
+  // unaligned little endian_arithmetic unsigned integer types
+  typedef endian_arithmetic< order::little, uint_least8_t, 8 >       ulittle8_t;
+  typedef endian_arithmetic< order::little, uint_least16_t, 16 >     ulittle16_t;
+  typedef endian_arithmetic< order::little, uint_least32_t, 24 >     ulittle24_t;
+  typedef endian_arithmetic< order::little, uint_least32_t, 32 >     ulittle32_t;
+  typedef endian_arithmetic< order::little, uint_least64_t, 40 >     ulittle40_t;
+  typedef endian_arithmetic< order::little, uint_least64_t, 48 >     ulittle48_t;
+  typedef endian_arithmetic< order::little, uint_least64_t, 56 >     ulittle56_t;
+  typedef endian_arithmetic< order::little, uint_least64_t, 64 >     ulittle64_t;
+
+  // unaligned native endian_arithmetic signed integer types
+  typedef endian_arithmetic< order::native, int_least8_t, 8 >        native8_t;
+  typedef endian_arithmetic< order::native, int_least16_t, 16 >      native16_t;
+  typedef endian_arithmetic< order::native, int_least32_t, 24 >      native24_t;
+  typedef endian_arithmetic< order::native, int_least32_t, 32 >      native32_t;
+  typedef endian_arithmetic< order::native, int_least64_t, 40 >      native40_t;
+  typedef endian_arithmetic< order::native, int_least64_t, 48 >      native48_t;
+  typedef endian_arithmetic< order::native, int_least64_t, 56 >      native56_t;
+  typedef endian_arithmetic< order::native, int_least64_t, 64 >      native64_t;
+
+  // unaligned native endian_arithmetic unsigned integer types
+  typedef endian_arithmetic< order::native, uint_least8_t, 8 >       unative8_t;
+  typedef endian_arithmetic< order::native, uint_least16_t, 16 >     unative16_t;
+  typedef endian_arithmetic< order::native, uint_least32_t, 24 >     unative24_t;
+  typedef endian_arithmetic< order::native, uint_least32_t, 32 >     unative32_t;
+  typedef endian_arithmetic< order::native, uint_least64_t, 40 >     unative40_t;
+  typedef endian_arithmetic< order::native, uint_least64_t, 48 >     unative48_t;
+  typedef endian_arithmetic< order::native, uint_least64_t, 56 >     unative56_t;
+  typedef endian_arithmetic< order::native, uint_least64_t, 64 >     unative64_t;
+
+  //     aligned native endian_arithmetic typedefs are not provided because
+  //     <cstdint> types are superior for this use case
+
+  typedef endian_arithmetic< order::big, int16_t, 16, align::yes >      aligned_big16_t;
+  typedef endian_arithmetic< order::big, uint16_t, 16, align::yes >     aligned_ubig16_t;
+  typedef endian_arithmetic< order::little, int16_t, 16, align::yes >   aligned_little16_t;
+  typedef endian_arithmetic< order::little, uint16_t, 16, align::yes >  aligned_ulittle16_t;
+
+  typedef endian_arithmetic< order::big, int32_t, 32, align::yes >      aligned_big32_t;
+  typedef endian_arithmetic< order::big, uint32_t, 32, align::yes >     aligned_ubig32_t;
+  typedef endian_arithmetic< order::little, int32_t, 32, align::yes >   aligned_little32_t;
+  typedef endian_arithmetic< order::little, uint32_t, 32, align::yes >  aligned_ulittle32_t;
+
+  typedef endian_arithmetic< order::big, int64_t, 64, align::yes >      aligned_big64_t;
+  typedef endian_arithmetic< order::big, uint64_t, 64, align::yes >     aligned_ubig64_t;
+  typedef endian_arithmetic< order::little, int64_t, 64, align::yes >   aligned_little64_t;
+  typedef endian_arithmetic< order::little, uint64_t, 64, align::yes >  aligned_ulittle64_t;
+
+# endif
+
+//----------------------------------  end synopsis  ------------------------------------//
+
+//  endian class template specializations  ---------------------------------------------//
+
+    //  Specializations that represent unaligned bytes.
+    //  Taking an integer type as a parameter provides a nice way to pass both
+    //  the size and signness of the desired integer and get the appropriate
+    //  corresponding integer type for the interface.
+
+    //  unaligned integer big endian specialization
+    template <typename T, std::size_t n_bits>
+    class endian_arithmetic< order::big, T, n_bits, align::no >
+      : public endian_buffer< order::big, T, n_bits, align::no >,
+        cover_operators<endian_arithmetic<order::big, T, n_bits>, T>
+    {
+        BOOST_STATIC_ASSERT( (n_bits/8)*8 == n_bits );
+      public:
+        typedef T value_type;
+#     ifndef BOOST_ENDIAN_NO_CTORS
+        endian_arithmetic() BOOST_ENDIAN_DEFAULT_CONSTRUCT
+        BOOST_ENDIAN_EXPLICIT_OPT endian_arithmetic(T val) BOOST_NOEXCEPT
+        { 
+#       ifdef BOOST_ENDIAN_LOG
+          if ( endian_log )
+            std::cout << "big, unaligned, " << n_bits << "-bits, construct(" << val << ")\n";
+#       endif
+          detail::store_big_endian<T, n_bits/8>(this->m_value, val);
+        }
+#     endif
+        endian_arithmetic& operator=(T val) BOOST_NOEXCEPT
+          { detail::store_big_endian<T, n_bits/8>(this->m_value, val); return *this; }
+        operator value_type() const BOOST_NOEXCEPT { return this->value(); }
+    };
+
+    //  unaligned little endian specialization
+    template <typename T, std::size_t n_bits>
+    class endian_arithmetic< order::little, T, n_bits, align::no >
+      : public endian_buffer< order::little, T, n_bits, align::no >,
+        cover_operators< endian_arithmetic< order::little, T, n_bits >, T >
+    {
+        BOOST_STATIC_ASSERT( (n_bits/8)*8 == n_bits );
+      public:
+        typedef T value_type;
+#     ifndef BOOST_ENDIAN_NO_CTORS
+        endian_arithmetic() BOOST_ENDIAN_DEFAULT_CONSTRUCT
+        BOOST_ENDIAN_EXPLICIT_OPT endian_arithmetic(T val) BOOST_NOEXCEPT
+        { 
+#       ifdef BOOST_ENDIAN_LOG
+          if ( endian_log )
+            std::cout << "little, unaligned, " << n_bits << "-bits, construct(" << val << ")\n";
+#       endif
+          detail::store_little_endian<T, n_bits/8>(this->m_value, val);
+        }
+#     endif
+        endian_arithmetic& operator=(T val) BOOST_NOEXCEPT
+          { detail::store_little_endian<T, n_bits/8>(this->m_value, val); return *this; }
+        operator value_type() const BOOST_NOEXCEPT { return this->value(); }
+    };
+
+  //  align::yes specializations; only n_bits == 16/32/64 supported
+
+    //  aligned big endian specialization
+    template <typename T, std::size_t n_bits>
+    class endian_arithmetic<order::big, T, n_bits, align::yes>
+      : public endian_buffer< order::big, T, n_bits, align::yes >,
+        cover_operators<endian_arithmetic<order::big, T, n_bits, align::yes>, T>
+    {
+        BOOST_STATIC_ASSERT( (n_bits/8)*8 == n_bits );
+        BOOST_STATIC_ASSERT( sizeof(T) == n_bits/8 );
+      public:
+        typedef T value_type;
+#     ifndef BOOST_ENDIAN_NO_CTORS
+        endian_arithmetic() BOOST_ENDIAN_DEFAULT_CONSTRUCT
+        BOOST_ENDIAN_EXPLICIT_OPT endian_arithmetic(T val) BOOST_NOEXCEPT
+        {
+#       ifdef BOOST_ENDIAN_LOG
+          if ( endian_log )
+            std::cout << "big, aligned, " << n_bits << "-bits, construct(" << val << ")\n";
+#       endif
+          this->m_value = ::boost::endian::native_to_big(val);
+        }
+
+#     endif  
+        endian_arithmetic& operator=(T val) BOOST_NOEXCEPT
+        {
+          this->m_value = ::boost::endian::native_to_big(val);
+          return *this;
+        }
+        operator value_type() const BOOST_NOEXCEPT { return this->value(); }
+    };
+
+    //  aligned little endian specialization
+    template <typename T, std::size_t n_bits>
+    class endian_arithmetic<order::little, T, n_bits, align::yes>
+      : public endian_buffer< order::little, T, n_bits, align::yes >,
+        cover_operators<endian_arithmetic<order::little, T, n_bits, align::yes>, T>
+    {
+        BOOST_STATIC_ASSERT( (n_bits/8)*8 == n_bits );
+        BOOST_STATIC_ASSERT( sizeof(T) == n_bits/8 );
+      public:
+        typedef T value_type;
+#     ifndef BOOST_ENDIAN_NO_CTORS
+        endian_arithmetic() BOOST_ENDIAN_DEFAULT_CONSTRUCT
+        BOOST_ENDIAN_EXPLICIT_OPT endian_arithmetic(T val) BOOST_NOEXCEPT
+        {
+#       ifdef BOOST_ENDIAN_LOG
+          if ( endian_log )
+            std::cout << "little, aligned, " << n_bits << "-bits, construct(" << val << ")\n";
+#       endif
+          this->m_value = ::boost::endian::native_to_little(val);
+        }
+#     endif  
+        endian_arithmetic& operator=(T val) BOOST_NOEXCEPT
+        {
+          this->m_value = ::boost::endian::native_to_little(val);
+          return *this;
+        }
+        operator value_type() const BOOST_NOEXCEPT { return this->value(); }
+    };
+
+} // namespace endian
+} // namespace boost
+
+#if defined(__BORLANDC__) || defined( __CODEGEARC__)
+# pragma pack(pop)
+#endif
+
+#if defined(_MSC_VER)  
+# pragma warning(pop)  
+#endif 
+
+#endif // BOOST_ENDIAN_ARITHMETIC_HPP

=== added file '3rd-party/boost/endian/buffers.hpp'
--- 3rd-party/boost/endian/buffers.hpp	1970-01-01 00:00:00 +0000
+++ 3rd-party/boost/endian/buffers.hpp	2016-04-01 06:55:25 +0000
@@ -0,0 +1,515 @@
+//  boost/endian/buffers.hpp  ----------------------------------------------------------//
+
+//  (C) Copyright Darin Adler 2000
+//  (C) Copyright Beman Dawes 2006, 2009, 2014
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+//  See library home page at http://www.boost.org/libs/endian
+
+//--------------------------------------------------------------------------------------//
+
+//  Original design developed by Darin Adler based on classes developed by Mark
+//  Borgerding. Four original class templates were combined into a single endian
+//  class template by Beman Dawes, who also added the unrolled_byte_loops sign
+//  partial specialization to correctly extend the sign when cover integer size
+//  differs from endian representation size.
+
+// TODO: When a compiler supporting constexpr becomes available, try possible uses.
+
+#ifndef BOOST_ENDIAN_BUFFERS_HPP
+#define BOOST_ENDIAN_BUFFERS_HPP
+
+#if defined(_MSC_VER)  
+# pragma warning(push)  
+# pragma warning(disable:4365)  // conversion ... signed/unsigned mismatch
+#endif
+
+#ifdef BOOST_ENDIAN_LOG
+# include <iostream>
+#endif
+
+#if defined(__BORLANDC__) || defined( __CODEGEARC__)
+# pragma pack(push, 1)
+#endif
+
+#include <boost/config.hpp>
+#include <boost/predef/detail/endian_compat.h>
+#include <boost/endian/conversion.hpp>
+#include <boost/type_traits/is_signed.hpp>
+#include <boost/cstdint.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/core/scoped_enum.hpp>
+#include <iosfwd>
+#include <climits>
+
+# if CHAR_BIT != 8
+#   error Platforms with CHAR_BIT != 8 are not supported
+# endif
+
+# ifdef BOOST_NO_CXX11_DEFAULTED_FUNCTIONS
+#   define BOOST_ENDIAN_DEFAULT_CONSTRUCT {}          // C++03
+# else
+#   define BOOST_ENDIAN_DEFAULT_CONSTRUCT = default;  // C++0x
+# endif
+
+# if defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS) && defined(BOOST_ENDIAN_FORCE_PODNESS)
+#   define BOOST_ENDIAN_NO_CTORS
+# endif
+
+//----------------------------------  synopsis  ----------------------------------------//
+
+namespace boost
+{
+namespace endian
+{
+
+  BOOST_SCOPED_ENUM_START(align)
+  {no, yes
+#   ifdef BOOST_ENDIAN_DEPRECATED_NAMES
+      , unaligned = no, aligned = yes
+#   endif
+  }; BOOST_SCOPED_ENUM_END
+
+  template <BOOST_SCOPED_ENUM(order) Order, class T, std::size_t n_bits,
+    BOOST_SCOPED_ENUM(align) A = align::no>
+      class endian_buffer;
+
+  // aligned big endian signed integer buffers
+  typedef endian_buffer<order::big, int8_t, 8, align::yes>       big_int8_buf_at;
+  typedef endian_buffer<order::big, int16_t, 16, align::yes>     big_int16_buf_at;
+  typedef endian_buffer<order::big, int32_t, 32, align::yes>     big_int32_buf_at;
+  typedef endian_buffer<order::big, int64_t, 64, align::yes>     big_int64_buf_at;
+
+  // aligned big endian unsigned integer buffers
+  typedef endian_buffer<order::big, uint8_t, 8, align::yes>      big_uint8_buf_at;
+  typedef endian_buffer<order::big, uint16_t, 16, align::yes>    big_uint16_buf_at;
+  typedef endian_buffer<order::big, uint32_t, 32, align::yes>    big_uint32_buf_at;
+  typedef endian_buffer<order::big, uint64_t, 64, align::yes>    big_uint64_buf_at;
+
+  // aligned little endian signed integer buffers
+  typedef endian_buffer<order::little, int8_t, 8, align::yes>    little_int8_buf_at;
+  typedef endian_buffer<order::little, int16_t, 16, align::yes>  little_int16_buf_at;
+  typedef endian_buffer<order::little, int32_t, 32, align::yes>  little_int32_buf_at;
+  typedef endian_buffer<order::little, int64_t, 64, align::yes>  little_int64_buf_at;
+
+  // aligned little endian unsigned integer buffers
+  typedef endian_buffer<order::little, uint8_t, 8, align::yes>   little_uint8_buf_at;
+  typedef endian_buffer<order::little, uint16_t, 16, align::yes> little_uint16_buf_at;
+  typedef endian_buffer<order::little, uint32_t, 32, align::yes> little_uint32_buf_at;
+  typedef endian_buffer<order::little, uint64_t, 64, align::yes> little_uint64_buf_at;
+
+  // aligned native endian typedefs are not provided because
+  // <cstdint> types are superior for this use case
+
+  // unaligned big endian signed integer buffers
+  typedef endian_buffer<order::big, int_least8_t, 8>        big_int8_buf_t;
+  typedef endian_buffer<order::big, int_least16_t, 16>      big_int16_buf_t;
+  typedef endian_buffer<order::big, int_least32_t, 24>      big_int24_buf_t;
+  typedef endian_buffer<order::big, int_least32_t, 32>      big_int32_buf_t;
+  typedef endian_buffer<order::big, int_least64_t, 40>      big_int40_buf_t;
+  typedef endian_buffer<order::big, int_least64_t, 48>      big_int48_buf_t;
+  typedef endian_buffer<order::big, int_least64_t, 56>      big_int56_buf_t;
+  typedef endian_buffer<order::big, int_least64_t, 64>      big_int64_buf_t;
+
+  // unaligned big endian unsigned integer buffers
+  typedef endian_buffer<order::big, uint_least8_t, 8>       big_uint8_buf_t;
+  typedef endian_buffer<order::big, uint_least16_t, 16>     big_uint16_buf_t;
+  typedef endian_buffer<order::big, uint_least32_t, 24>     big_uint24_buf_t;
+  typedef endian_buffer<order::big, uint_least32_t, 32>     big_uint32_buf_t;
+  typedef endian_buffer<order::big, uint_least64_t, 40>     big_uint40_buf_t;
+  typedef endian_buffer<order::big, uint_least64_t, 48>     big_uint48_buf_t;
+  typedef endian_buffer<order::big, uint_least64_t, 56>     big_uint56_buf_t;
+  typedef endian_buffer<order::big, uint_least64_t, 64>     big_uint64_buf_t;
+
+  // unaligned little endian signed integer buffers
+  typedef endian_buffer<order::little, int_least8_t, 8>     little_int8_buf_t;
+  typedef endian_buffer<order::little, int_least16_t, 16>   little_int16_buf_t;
+  typedef endian_buffer<order::little, int_least32_t, 24>   little_int24_buf_t;
+  typedef endian_buffer<order::little, int_least32_t, 32>   little_int32_buf_t;
+  typedef endian_buffer<order::little, int_least64_t, 40>   little_int40_buf_t;
+  typedef endian_buffer<order::little, int_least64_t, 48>   little_int48_buf_t;
+  typedef endian_buffer<order::little, int_least64_t, 56>   little_int56_buf_t;
+  typedef endian_buffer<order::little, int_least64_t, 64>   little_int64_buf_t;
+
+  // unaligned little endian unsigned integer buffers
+  typedef endian_buffer<order::little, uint_least8_t, 8>    little_uint8_buf_t;
+  typedef endian_buffer<order::little, uint_least16_t, 16>  little_uint16_buf_t;
+  typedef endian_buffer<order::little, uint_least32_t, 24>  little_uint24_buf_t;
+  typedef endian_buffer<order::little, uint_least32_t, 32>  little_uint32_buf_t;
+  typedef endian_buffer<order::little, uint_least64_t, 40>  little_uint40_buf_t;
+  typedef endian_buffer<order::little, uint_least64_t, 48>  little_uint48_buf_t;
+  typedef endian_buffer<order::little, uint_least64_t, 56>  little_uint56_buf_t;
+  typedef endian_buffer<order::little, uint_least64_t, 64>  little_uint64_buf_t;
+
+# ifdef BOOST_BIG_ENDIAN
+  // unaligned native endian signed integer buffers
+  typedef big_int8_buf_t   native_int8_buf_t;
+  typedef big_int16_buf_t  native_int16_buf_t;
+  typedef big_int24_buf_t  native_int24_buf_t;
+  typedef big_int32_buf_t  native_int32_buf_t;
+  typedef big_int40_buf_t  native_int40_buf_t;
+  typedef big_int48_buf_t  native_int48_buf_t;
+  typedef big_int56_buf_t  native_int56_buf_t;
+  typedef big_int64_buf_t  native_int64_buf_t;
+
+  // unaligned native endian unsigned integer buffers
+  typedef big_uint8_buf_t   native_uint8_buf_t;
+  typedef big_uint16_buf_t  native_uint16_buf_t;
+  typedef big_uint24_buf_t  native_uint24_buf_t;
+  typedef big_uint32_buf_t  native_uint32_buf_t;
+  typedef big_uint40_buf_t  native_uint40_buf_t;
+  typedef big_uint48_buf_t  native_uint48_buf_t;
+  typedef big_uint56_buf_t  native_uint56_buf_t;
+  typedef big_uint64_buf_t  native_uint64_buf_t;
+# else
+  // unaligned native endian signed integer buffers
+  typedef little_int8_buf_t   native_int8_buf_t;
+  typedef little_int16_buf_t  native_int16_buf_t;
+  typedef little_int24_buf_t  native_int24_buf_t;
+  typedef little_int32_buf_t  native_int32_buf_t;
+  typedef little_int40_buf_t  native_int40_buf_t;
+  typedef little_int48_buf_t  native_int48_buf_t;
+  typedef little_int56_buf_t  native_int56_buf_t;
+  typedef little_int64_buf_t  native_int64_buf_t;
+
+  // unaligned native endian unsigned integer buffers
+  typedef little_uint8_buf_t   native_uint8_buf_t;
+  typedef little_uint16_buf_t  native_uint16_buf_t;
+  typedef little_uint24_buf_t  native_uint24_buf_t;
+  typedef little_uint32_buf_t  native_uint32_buf_t;
+  typedef little_uint40_buf_t  native_uint40_buf_t;
+  typedef little_uint48_buf_t  native_uint48_buf_t;
+  typedef little_uint56_buf_t  native_uint56_buf_t;
+  typedef little_uint64_buf_t  native_uint64_buf_t;
+# endif
+
+  // Stream inserter
+  template <class charT, class traits, BOOST_SCOPED_ENUM(order) Order, class T,
+    std::size_t n_bits, BOOST_SCOPED_ENUM(align) A>
+  std::basic_ostream<charT, traits>&
+    operator<<(std::basic_ostream<charT, traits>& os,
+      const endian_buffer<Order, T, n_bits, A>& x)
+  {
+    return os << x.value();
+  }
+
+  // Stream extractor 
+  template <class charT, class traits, BOOST_SCOPED_ENUM(order) Order, class T,
+    std::size_t n_bits, BOOST_SCOPED_ENUM(align) A>
+  std::basic_istream<charT, traits>&
+    operator>>(std::basic_istream<charT, traits>& is,
+      endian_buffer<Order, T, n_bits, A>& x)
+  {
+    T i;
+    if (is >> i)
+      x = i;
+    return is;
+  }
+
+//----------------------------------  end synopsis  ------------------------------------//
+
+  namespace detail
+  {
+
+    // Unrolled loops for loading and storing streams of bytes.
+
+    template <typename T, std::size_t n_bytes,
+      bool sign=boost::is_signed<T>::value >
+    struct unrolled_byte_loops
+    {
+      typedef unrolled_byte_loops<T, n_bytes - 1, sign> next;
+
+      static T load_big(const unsigned char* bytes) BOOST_NOEXCEPT
+        { return static_cast<T>(*(bytes - 1) | (next::load_big(bytes - 1) << 8)); }
+      static T load_little(const unsigned char* bytes) BOOST_NOEXCEPT
+        { return static_cast<T>(*bytes | (next::load_little(bytes + 1) << 8)); }
+
+      static void store_big(char* bytes, T value) BOOST_NOEXCEPT
+        {
+          *(bytes - 1) = static_cast<char>(value);
+          next::store_big(bytes - 1, static_cast<T>(value >> 8));
+        }
+      static void store_little(char* bytes, T value) BOOST_NOEXCEPT
+        {
+          *bytes = static_cast<char>(value);
+          next::store_little(bytes + 1, static_cast<T>(value >> 8));
+        }
+    };
+
+    template <typename T>
+    struct unrolled_byte_loops<T, 1, false>
+    {
+      static T load_big(const unsigned char* bytes) BOOST_NOEXCEPT
+        { return *(bytes - 1); }
+      static T load_little(const unsigned char* bytes) BOOST_NOEXCEPT
+        { return *bytes; }
+      static void store_big(char* bytes, T value) BOOST_NOEXCEPT
+        { *(bytes - 1) = static_cast<char>(value); }
+      static void store_little(char* bytes, T value) BOOST_NOEXCEPT
+        { *bytes = static_cast<char>(value); }
+
+    };
+
+    template <typename T>
+    struct unrolled_byte_loops<T, 1, true>
+    {
+      static T load_big(const unsigned char* bytes) BOOST_NOEXCEPT
+        { return *reinterpret_cast<const signed char*>(bytes - 1); }
+      static T load_little(const unsigned char* bytes) BOOST_NOEXCEPT
+        { return *reinterpret_cast<const signed char*>(bytes); }
+      static void store_big(char* bytes, T value)  BOOST_NOEXCEPT
+        { *(bytes - 1) = static_cast<char>(value); }
+      static void store_little(char* bytes, T value) BOOST_NOEXCEPT
+        { *bytes = static_cast<char>(value); }
+    };
+
+    template <typename T, std::size_t n_bytes>
+    inline
+    T load_big_endian(const void* bytes) BOOST_NOEXCEPT
+    {
+      return unrolled_byte_loops<T, n_bytes>::load_big
+        (static_cast<const unsigned char*>(bytes) + n_bytes);
+    }
+
+    template <typename T, std::size_t n_bytes>
+    inline
+    T load_little_endian(const void* bytes) BOOST_NOEXCEPT
+    {
+#   if defined(__x86_64__) || defined(_M_X64) || defined(__i386) || defined(_M_IX86)
+      // On x86 (which is little endian), unaligned loads are permitted
+      if (sizeof(T) == n_bytes)  // GCC 4.9, VC++ 14.0, and probably others, elide this
+                                 // test and generate code only for the applicable return
+                                 // case since sizeof(T) and n_bytes are known at compile
+                                 // time.
+      {
+        return *reinterpret_cast<T const *>(bytes);
+      }
+#   endif
+      return unrolled_byte_loops<T, n_bytes>::load_little
+        (static_cast<const unsigned char*>(bytes));
+    }
+
+    template <typename T, std::size_t n_bytes>
+    inline
+    void store_big_endian(void* bytes, T value) BOOST_NOEXCEPT
+    {
+      unrolled_byte_loops<T, n_bytes>::store_big
+        (static_cast<char*>(bytes) + n_bytes, value);
+    }
+
+    template <typename T, std::size_t n_bytes>
+    inline
+    void store_little_endian(void* bytes, T value) BOOST_NOEXCEPT
+    {
+#     if defined(__x86_64__) || defined(_M_X64) || defined(__i386) || defined(_M_IX86)
+      // On x86 (which is little endian), unaligned stores are permitted
+      if (sizeof(T) == n_bytes)  // GCC 4.9, VC++ 14.0, and probably others, elide this
+                                 // test and generate code only for the applicable return
+                                 // case since sizeof(T) and n_bytes are known at compile
+                                 // time.
+      {
+        *reinterpret_cast<T *>(bytes) = value;
+        return;
+      }
+#     endif
+      unrolled_byte_loops<T, n_bytes>::store_little
+        (static_cast<char*>(bytes), value);
+    }
+
+  } // namespace detail
+
+# ifdef BOOST_ENDIAN_LOG
+    bool endian_log(true);
+# endif
+
+//  endian_buffer class template specializations  --------------------------------------//
+
+    //  Specializations that represent unaligned bytes.
+    //  Taking an integer type as a parameter provides a nice way to pass both
+    //  the size and signedness of the desired integer and get the appropriate
+    //  corresponding integer type for the interface.
+
+    // Q: Should endian_buffer supply "value_type operator value_type() const noexcept"?
+    // A: No. The rationale for endian_buffers is to prevent high-cost hidden
+    //    conversions. If an implicit conversion operator is supplied, hidden conversions
+    //    can occur.
+
+    //  unaligned big endian_buffer specialization
+    template <typename T, std::size_t n_bits>
+    class endian_buffer< order::big, T, n_bits, align::no >
+    {
+        BOOST_STATIC_ASSERT( (n_bits/8)*8 == n_bits );
+      public:
+        typedef T value_type;
+#     ifndef BOOST_ENDIAN_NO_CTORS
+        endian_buffer() BOOST_ENDIAN_DEFAULT_CONSTRUCT
+        explicit endian_buffer(T val) BOOST_NOEXCEPT
+        { 
+#       ifdef BOOST_ENDIAN_LOG
+          if ( endian_log )
+            std::cout << "big, unaligned, "
+              << n_bits << "-bits, construct(" << val << ")\n";
+#       endif
+          detail::store_big_endian<T, n_bits/8>(m_value, val);
+        }
+#     endif
+        endian_buffer & operator=(T val) BOOST_NOEXCEPT
+        {
+#       ifdef BOOST_ENDIAN_LOG
+          if (endian_log)
+            std::cout << "big, unaligned, " << n_bits << "-bits, assign(" << val << ")\n";
+#       endif
+          detail::store_big_endian<T, n_bits/8>(m_value, val);
+          return *this;
+        }
+        value_type value() const BOOST_NOEXCEPT
+        { 
+#       ifdef BOOST_ENDIAN_LOG
+          if ( endian_log )
+            std::cout << "big, unaligned, " << n_bits << "-bits, convert("
+              << detail::load_big_endian<T, n_bits/8>(m_value) << ")\n";
+#       endif
+          return detail::load_big_endian<T, n_bits/8>(m_value);
+        }
+        const char* data() const BOOST_NOEXCEPT  { return m_value; }
+      protected:
+        char m_value[n_bits/8];
+    };
+
+    //  unaligned little endian_buffer specialization
+    template <typename T, std::size_t n_bits>
+    class endian_buffer< order::little, T, n_bits, align::no >
+    {
+        BOOST_STATIC_ASSERT( (n_bits/8)*8 == n_bits );
+      public:
+        typedef T value_type;
+#     ifndef BOOST_ENDIAN_NO_CTORS
+        endian_buffer() BOOST_ENDIAN_DEFAULT_CONSTRUCT
+        explicit endian_buffer(T val) BOOST_NOEXCEPT
+        { 
+#       ifdef BOOST_ENDIAN_LOG
+          if ( endian_log )
+            std::cout << "little, unaligned, " << n_bits << "-bits, construct("
+              << val << ")\n";
+#       endif
+          detail::store_little_endian<T, n_bits/8>(m_value, val);
+        }
+#     endif
+        endian_buffer & operator=(T val) BOOST_NOEXCEPT
+          { detail::store_little_endian<T, n_bits/8>(m_value, val); return *this; }
+        value_type value() const BOOST_NOEXCEPT
+        { 
+#       ifdef BOOST_ENDIAN_LOG
+          if ( endian_log )
+            std::cout << "little, unaligned, " << n_bits << "-bits, convert("
+              << detail::load_little_endian<T, n_bits/8>(m_value) << ")\n";
+#       endif
+          return detail::load_little_endian<T, n_bits/8>(m_value);
+        }
+        const char* data() const BOOST_NOEXCEPT  { return m_value; }
+      protected:
+        char m_value[n_bits/8];
+    };
+
+  //  align::yes specializations; only n_bits == 16/32/64 supported
+
+    //  aligned big endian_buffer specialization
+    template <typename T, std::size_t n_bits>
+    class endian_buffer<order::big, T, n_bits, align::yes>
+    {
+        BOOST_STATIC_ASSERT( (n_bits/8)*8 == n_bits );
+        BOOST_STATIC_ASSERT( sizeof(T) == n_bits/8 );
+      public:
+        typedef T value_type;
+#     ifndef BOOST_ENDIAN_NO_CTORS
+        endian_buffer() BOOST_ENDIAN_DEFAULT_CONSTRUCT
+        explicit endian_buffer(T val) BOOST_NOEXCEPT
+        {
+#       ifdef BOOST_ENDIAN_LOG
+          if ( endian_log )
+            std::cout << "big, aligned, " << n_bits
+              << "-bits, construct(" << val << ")\n";
+#       endif
+          m_value = ::boost::endian::native_to_big(val);
+        }
+
+#     endif  
+        endian_buffer& operator=(T val) BOOST_NOEXCEPT
+        {
+          m_value = ::boost::endian::native_to_big(val);
+          return *this;
+        }
+        //operator value_type() const BOOST_NOEXCEPT
+        //{                                                                       
+        //  return ::boost::endian::big_to_native(m_value);
+        //}
+        value_type value() const BOOST_NOEXCEPT
+        {
+#       ifdef BOOST_ENDIAN_LOG
+          if ( endian_log )
+            std::cout << "big, aligned, " << n_bits << "-bits, convert("
+              << ::boost::endian::big_to_native(m_value) << ")\n";
+#       endif
+          return ::boost::endian::big_to_native(m_value);
+        }
+        const char* data() const BOOST_NOEXCEPT
+          {return reinterpret_cast<const char*>(&m_value);}
+      protected:
+        T m_value;
+    };
+
+    //  aligned little endian_buffer specialization
+    template <typename T, std::size_t n_bits>
+    class endian_buffer<order::little, T, n_bits, align::yes>
+    {
+        BOOST_STATIC_ASSERT( (n_bits/8)*8 == n_bits );
+        BOOST_STATIC_ASSERT( sizeof(T) == n_bits/8 );
+      public:
+        typedef T value_type;
+#     ifndef BOOST_ENDIAN_NO_CTORS
+        endian_buffer() BOOST_ENDIAN_DEFAULT_CONSTRUCT
+        explicit endian_buffer(T val) BOOST_NOEXCEPT
+        {
+#       ifdef BOOST_ENDIAN_LOG
+          if ( endian_log )
+            std::cout << "little, aligned, " << n_bits
+              << "-bits, construct(" << val << ")\n";
+#       endif
+          m_value = ::boost::endian::native_to_little(val);
+        }
+
+#     endif  
+        endian_buffer& operator=(T val) BOOST_NOEXCEPT
+        {
+          m_value = ::boost::endian::native_to_little(val);
+          return *this;
+        }
+        value_type value() const BOOST_NOEXCEPT
+        {
+#       ifdef BOOST_ENDIAN_LOG
+          if ( endian_log )
+            std::cout << "little, aligned, " << n_bits << "-bits, convert("
+              << ::boost::endian::little_to_native(m_value) << ")\n";
+#       endif
+          return ::boost::endian::little_to_native(m_value);
+        }
+        const char* data() const BOOST_NOEXCEPT
+          {return reinterpret_cast<const char*>(&m_value);}
+      protected:
+        T m_value;
+    };
+
+} // namespace endian
+} // namespace boost
+
+#if defined(__BORLANDC__) || defined( __CODEGEARC__)
+# pragma pack(pop)
+#endif
+
+#if defined(_MSC_VER)  
+# pragma warning(pop)  
+#endif 
+
+#endif // BOOST_ENDIAN_BUFFERS_HPP

=== added file '3rd-party/boost/endian/conversion.hpp'
--- 3rd-party/boost/endian/conversion.hpp	1970-01-01 00:00:00 +0000
+++ 3rd-party/boost/endian/conversion.hpp	2016-04-01 06:55:25 +0000
@@ -0,0 +1,487 @@
+//  boost/endian/conversion.hpp  -------------------------------------------------------//
+
+//  Copyright Beman Dawes 2010, 2011, 2014
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  http://www.boost.org/LICENSE_1_0.txt
+
+#ifndef BOOST_ENDIAN_CONVERSION_HPP
+#define BOOST_ENDIAN_CONVERSION_HPP
+
+#include <boost/config.hpp>
+#include <boost/predef/detail/endian_compat.h>
+#include <boost/cstdint.hpp>
+#include <boost/endian/detail/intrinsic.hpp>
+#include <boost/core/scoped_enum.hpp>
+#include <boost/static_assert.hpp>
+#include <algorithm>
+#include <cstring>  // for memcpy
+
+//------------------------------------- synopsis ---------------------------------------//
+
+namespace boost
+{
+namespace endian
+{
+#ifndef BOOST_ENDIAN_ORDER_ENUM_DEFINED
+  BOOST_SCOPED_ENUM_START(order)
+  {
+    big, little,
+# ifdef  BOOST_BIG_ENDIAN
+      native = big
+# else
+      native = little
+# endif
+  }; BOOST_SCOPED_ENUM_END
+# define BOOST_ENDIAN_ORDER_ENUM_DEFINED
+#endif
+
+//--------------------------------------------------------------------------------------//
+//                                                                                      //
+//                             return-by-value interfaces                               //
+//                             suggested by Phil Endecott                               //
+//                                                                                      //
+//                             user-defined types (UDTs)                                //
+//                                                                                      //
+//  All return-by-value conversion function templates are required to be implemented in //
+//  terms of an unqualified call to "endian_reverse(x)", a function returning the       //
+//  value of x with endianness reversed. This provides a customization point for any    //
+//  UDT that provides a "endian_reverse" free-function meeting the requirements.        //
+//  It must be defined in the same namespace as the UDT itself so that it will be found //
+//  by argument dependent lookup (ADL).                                                 //
+//                                                                                      //
+//--------------------------------------------------------------------------------------//
+  
+  //  customization for exact-length arithmetic types. See doc/conversion.html/#FAQ
+  inline int8_t   endian_reverse(int8_t x) BOOST_NOEXCEPT;
+  inline int16_t  endian_reverse(int16_t x) BOOST_NOEXCEPT;
+  inline int32_t  endian_reverse(int32_t x) BOOST_NOEXCEPT;
+  inline int64_t  endian_reverse(int64_t x) BOOST_NOEXCEPT;
+  inline uint8_t  endian_reverse(uint8_t x) BOOST_NOEXCEPT;
+  inline uint16_t endian_reverse(uint16_t x) BOOST_NOEXCEPT;
+  inline uint32_t endian_reverse(uint32_t x) BOOST_NOEXCEPT;
+  inline uint64_t endian_reverse(uint64_t x) BOOST_NOEXCEPT;
+
+  //  reverse byte order unless native endianness is big
+  template <class EndianReversible >
+    inline EndianReversible  big_to_native(EndianReversible  x) BOOST_NOEXCEPT;
+    //  Returns: x if native endian order is big, otherwise endian_reverse(x)
+  template <class EndianReversible >
+    inline EndianReversible  native_to_big(EndianReversible  x) BOOST_NOEXCEPT;
+    //  Returns: x if native endian order is big, otherwise endian_reverse(x)
+
+  //  reverse byte order unless native endianness is little
+  template <class EndianReversible >
+    inline EndianReversible  little_to_native(EndianReversible  x) BOOST_NOEXCEPT;
+    //  Returns: x if native endian order is little, otherwise endian_reverse(x)
+  template <class EndianReversible >
+    inline EndianReversible  native_to_little(EndianReversible  x) BOOST_NOEXCEPT;
+    //  Returns: x if native endian order is little, otherwise endian_reverse(x)
+
+  //  generic conditional reverse byte order
+  template <BOOST_SCOPED_ENUM(order) From, BOOST_SCOPED_ENUM(order) To,
+    class EndianReversible>
+      inline EndianReversible  conditional_reverse(EndianReversible from) BOOST_NOEXCEPT;
+    //  Returns: If From == To have different values, from.
+    //           Otherwise endian_reverse(from).
+    //  Remarks: The From == To test, and as a consequence which form the return takes, is
+    //           is determined at compile time.
+
+  //  runtime conditional reverse byte order
+  template <class EndianReversible >
+    inline EndianReversible  conditional_reverse(EndianReversible from,
+      BOOST_SCOPED_ENUM(order) from_order, BOOST_SCOPED_ENUM(order) to_order)
+        BOOST_NOEXCEPT;
+      //  Returns: from_order == to_order ? from : endian_reverse(from).
+
+  //------------------------------------------------------------------------------------//
+
+
+  //  Q: What happended to bswap, htobe, and the other synonym functions based on names
+  //     popularized by BSD, OS X, and Linux?
+  //  A: Turned out these may be implemented as macros on some systems. Ditto POSIX names
+  //     for such functionality. Since macros would cause endless problems with functions
+  //     of the same names, and these functions are just synonyms anyhow, they have been
+  //     removed.
+
+
+  //------------------------------------------------------------------------------------//
+  //                                                                                    //
+  //                            reverse in place interfaces                             //
+  //                                                                                    //
+  //                             user-defined types (UDTs)                              //
+  //                                                                                    //
+  //  All reverse in place function templates are required to be implemented in terms   // 
+  //  of an unqualified call to "endian_reverse_inplace(x)", a function reversing       //
+  //  the endianness of x, which is a non-const reference. This provides a              //
+  //  customization point for any UDT that provides a "reverse_inplace" free-function   //
+  //  meeting the requirements. The free-function must be declared in the same          //
+  //  namespace as the UDT itself so that it will be found by argument-dependent        //
+  //   lookup (ADL).                                                                    //
+  //                                                                                    //
+  //------------------------------------------------------------------------------------//
+
+  //  reverse in place
+  template <class EndianReversible>
+    inline void endian_reverse_inplace(EndianReversible& x) BOOST_NOEXCEPT;
+    //  Effects: x = endian_reverse(x)
+
+  //  reverse in place unless native endianness is big
+  template <class EndianReversibleInplace>
+    inline void big_to_native_inplace(EndianReversibleInplace& x) BOOST_NOEXCEPT;
+    //  Effects: none if native byte-order is big, otherwise endian_reverse_inplace(x)
+  template <class EndianReversibleInplace>
+    inline void native_to_big_inplace(EndianReversibleInplace& x) BOOST_NOEXCEPT;
+    //  Effects: none if native byte-order is big, otherwise endian_reverse_inplace(x)
+
+  //  reverse in place unless native endianness is little
+  template <class EndianReversibleInplace>
+    inline void little_to_native_inplace(EndianReversibleInplace& x) BOOST_NOEXCEPT;
+    //  Effects: none if native byte-order is little, otherwise endian_reverse_inplace(x);
+  template <class EndianReversibleInplace>
+    inline void native_to_little_inplace(EndianReversibleInplace& x) BOOST_NOEXCEPT;
+    //  Effects: none if native byte-order is little, otherwise endian_reverse_inplace(x);
+
+  //  generic conditional reverse in place
+  template <BOOST_SCOPED_ENUM(order) From, BOOST_SCOPED_ENUM(order) To,
+    class EndianReversibleInplace>
+  inline void conditional_reverse_inplace(EndianReversibleInplace& x) BOOST_NOEXCEPT; 
+
+  //  runtime reverse in place
+  template <class EndianReversibleInplace>
+  inline void conditional_reverse_inplace(EndianReversibleInplace& x,
+    BOOST_SCOPED_ENUM(order) from_order,  BOOST_SCOPED_ENUM(order) to_order)
+    BOOST_NOEXCEPT;
+
+//----------------------------------- end synopsis -------------------------------------//
+
+  namespace detail
+  {
+    //  generic reverse function template implementation approach using std::reverse
+    //  suggested by Mathias Gaunard. Primary motivation for inclusion is to have an
+    //  independent implementation to test against.
+
+    template <class T>
+    inline T std_endian_reverse(T x) BOOST_NOEXCEPT
+    {
+      T tmp(x);
+      std::reverse(
+        reinterpret_cast<unsigned char*>(&tmp),
+        reinterpret_cast<unsigned char*>(&tmp) + sizeof(T));
+      return tmp;
+    }
+
+    //  conditional unaligned reverse copy, patterned after std::reverse_copy
+    template <class T>
+      inline void big_reverse_copy(T from, char* to) BOOST_NOEXCEPT;
+    template <class T>
+      inline void big_reverse_copy(const char* from, T& to) BOOST_NOEXCEPT;
+    template <class T>
+      inline void little_reverse_copy(T from, char* to) BOOST_NOEXCEPT;
+    template <class T>
+      inline void little_reverse_copy(const char* from, T& to) BOOST_NOEXCEPT;
+  }  // namespace detail
+
+//--------------------------------------------------------------------------------------//
+//                                                                                      //
+//                            return-by-value implementation                            //
+//                                                                                      //
+//    -- portable approach suggested by tymofey, with avoidance of undefined behavior   //
+//       as suggested by Giovanni Piero Deretta, with a further refinement suggested    //
+//       by Pyry Jahkola.                                                               //
+//    -- intrinsic approach suggested by reviewers, and by David Stone, who provided    //
+//       his Boost licensed macro implementation (detail/intrinsic.hpp)                 //
+//                                                                                      //
+//--------------------------------------------------------------------------------------//
+
+  inline int8_t endian_reverse(int8_t x) BOOST_NOEXCEPT
+  {
+    return x;
+  }
+                                                
+  inline int16_t endian_reverse(int16_t x) BOOST_NOEXCEPT
+  {
+# ifdef BOOST_ENDIAN_NO_INTRINSICS  
+    return (static_cast<uint16_t>(x) << 8)
+      | (static_cast<uint16_t>(x) >> 8);
+# else
+    return BOOST_ENDIAN_INTRINSIC_BYTE_SWAP_2(static_cast<uint16_t>(x));
+# endif
+  }
+
+  inline int32_t endian_reverse(int32_t x) BOOST_NOEXCEPT
+  {
+# ifdef BOOST_ENDIAN_NO_INTRINSICS  
+    uint32_t step16;
+    step16 = static_cast<uint32_t>(x) << 16 | static_cast<uint32_t>(x) >> 16;
+    return
+        ((static_cast<uint32_t>(step16) << 8) & 0xff00ff00)
+      | ((static_cast<uint32_t>(step16) >> 8) & 0x00ff00ff);
+# else
+    return BOOST_ENDIAN_INTRINSIC_BYTE_SWAP_4(static_cast<uint32_t>(x));
+# endif
+  }
+
+  inline int64_t endian_reverse(int64_t x) BOOST_NOEXCEPT
+  {
+# ifdef BOOST_ENDIAN_NO_INTRINSICS  
+    uint64_t step32, step16;
+    step32 = static_cast<uint64_t>(x) << 32 | static_cast<uint64_t>(x) >> 32;
+    step16 = (step32 & 0x0000FFFF0000FFFFULL) << 16
+           | (step32 & 0xFFFF0000FFFF0000ULL) >> 16;
+    return static_cast<int64_t>((step16 & 0x00FF00FF00FF00FFULL) << 8
+           | (step16 & 0xFF00FF00FF00FF00ULL) >> 8);
+# else
+    return BOOST_ENDIAN_INTRINSIC_BYTE_SWAP_8(static_cast<uint64_t>(x));
+# endif
+  }
+  
+  inline uint8_t endian_reverse(uint8_t x) BOOST_NOEXCEPT
+  {
+    return x;
+  }
+
+  inline uint16_t endian_reverse(uint16_t x) BOOST_NOEXCEPT
+  {
+# ifdef BOOST_ENDIAN_NO_INTRINSICS  
+    return (x << 8)
+      | (x >> 8);
+# else
+    return BOOST_ENDIAN_INTRINSIC_BYTE_SWAP_2(x);
+# endif
+  }
+
+  inline uint32_t endian_reverse(uint32_t x) BOOST_NOEXCEPT                           
+  {
+# ifdef BOOST_ENDIAN_NO_INTRINSICS  
+    uint32_t step16;
+    step16 = x << 16 | x >> 16;
+    return
+        ((step16 << 8) & 0xff00ff00)
+      | ((step16 >> 8) & 0x00ff00ff);
+# else
+    return BOOST_ENDIAN_INTRINSIC_BYTE_SWAP_4(x);
+# endif
+  }
+
+  inline uint64_t endian_reverse(uint64_t x) BOOST_NOEXCEPT
+  {
+# ifdef BOOST_ENDIAN_NO_INTRINSICS  
+    uint64_t step32, step16;
+    step32 = x << 32 | x >> 32;
+    step16 = (step32 & 0x0000FFFF0000FFFFULL) << 16
+           | (step32 & 0xFFFF0000FFFF0000ULL) >> 16;
+    return (step16 & 0x00FF00FF00FF00FFULL) << 8
+           | (step16 & 0xFF00FF00FF00FF00ULL) >> 8;
+# else
+    return BOOST_ENDIAN_INTRINSIC_BYTE_SWAP_8(x);
+# endif
+  }
+
+  template <class EndianReversible >
+  inline EndianReversible  big_to_native(EndianReversible  x) BOOST_NOEXCEPT
+  {
+#   ifdef BOOST_BIG_ENDIAN
+    return x;
+#   else
+    return endian_reverse(x);
+#   endif
+  }
+
+  template <class EndianReversible >
+  inline EndianReversible  native_to_big(EndianReversible  x) BOOST_NOEXCEPT
+  {
+#   ifdef BOOST_BIG_ENDIAN
+    return x;
+#   else
+    return endian_reverse(x);
+#   endif
+  }
+
+  template <class EndianReversible >
+  inline EndianReversible  little_to_native(EndianReversible  x) BOOST_NOEXCEPT
+  {
+#   ifdef BOOST_LITTLE_ENDIAN
+    return x;
+#   else
+    return endian_reverse(x);
+#   endif
+  }
+
+  template <class EndianReversible >
+  inline EndianReversible  native_to_little(EndianReversible  x) BOOST_NOEXCEPT
+  {
+#   ifdef BOOST_LITTLE_ENDIAN
+    return x;
+#   else
+    return endian_reverse(x);
+#   endif
+  }
+
+  namespace detail
+  {
+    //  Primary template and specializations to support endian_reverse().
+    //  See rationale in endian_reverse() below.
+    template <BOOST_SCOPED_ENUM(order) From, BOOST_SCOPED_ENUM(order) To,
+        class EndianReversible>
+      class value_converter ;  // primary template
+    template <class T> class value_converter <order::big, order::big, T>
+      {public: T operator()(T x) BOOST_NOEXCEPT {return x;}};
+    template <class T> class value_converter <order::little, order::little, T>
+      {public: T operator()(T x) BOOST_NOEXCEPT {return x;}};
+    template <class T> class value_converter <order::big, order::little, T>
+      {public: T operator()(T x) BOOST_NOEXCEPT {return endian_reverse(x);}};
+    template <class T> class value_converter <order::little, order::big, T>
+      {public: T operator()(T x) BOOST_NOEXCEPT {return endian_reverse(x);}};
+  }
+
+  //  generic conditional reverse
+  template <BOOST_SCOPED_ENUM(order) From, BOOST_SCOPED_ENUM(order) To,
+    class EndianReversible>
+  inline EndianReversible  conditional_reverse(EndianReversible from) BOOST_NOEXCEPT  {
+    //  work around lack of function template partial specialization by instantiating
+    //  a function object of a class that is partially specialized on the two order
+    //  template parameters, and then calling its operator().
+    detail::value_converter <From, To, EndianReversible> tmp;
+    return tmp(from);
+  }
+
+  //  runtime conditional reverse
+  template <class EndianReversible >
+  inline EndianReversible  conditional_reverse(EndianReversible  from,
+    BOOST_SCOPED_ENUM(order) from_order, BOOST_SCOPED_ENUM(order) to_order) BOOST_NOEXCEPT
+  {
+    return from_order == to_order ? from : endian_reverse(from);
+  }
+
+//--------------------------------------------------------------------------------------//
+//                           reverse-in-place implementation                            //
+//--------------------------------------------------------------------------------------//
+
+  //  reverse in place
+  template <class EndianReversible>
+  inline void endian_reverse_inplace(EndianReversible& x) BOOST_NOEXCEPT
+  {
+    x = endian_reverse(x);
+  }
+
+  template <class EndianReversibleInplace>
+#   ifdef BOOST_BIG_ENDIAN
+  inline void big_to_native_inplace(EndianReversibleInplace&) BOOST_NOEXCEPT {}
+#   else
+  inline void big_to_native_inplace(EndianReversibleInplace& x) BOOST_NOEXCEPT
+    { endian_reverse_inplace(x); }
+#   endif
+  template <class EndianReversibleInplace>
+#   ifdef BOOST_BIG_ENDIAN
+  inline void native_to_big_inplace(EndianReversibleInplace&) BOOST_NOEXCEPT {}
+#   else
+  inline void native_to_big_inplace(EndianReversibleInplace& x) BOOST_NOEXCEPT
+  {
+    endian_reverse_inplace(x);
+  }
+#   endif
+
+  template <class EndianReversibleInplace>
+#   ifdef BOOST_LITTLE_ENDIAN
+  inline void little_to_native_inplace(EndianReversibleInplace&) BOOST_NOEXCEPT {}
+#   else
+  inline void little_to_native_inplace(EndianReversibleInplace& x) BOOST_NOEXCEPT
+    { endian_reverse_inplace(x); }
+#   endif
+  template <class EndianReversibleInplace>
+#   ifdef BOOST_LITTLE_ENDIAN
+  inline void native_to_little_inplace(EndianReversibleInplace&) BOOST_NOEXCEPT {}
+#   else
+  inline void native_to_little_inplace(EndianReversibleInplace& x) BOOST_NOEXCEPT
+  {
+    endian_reverse_inplace(x);
+  }
+#   endif
+
+  namespace detail
+  {
+    //  Primary template and specializations support generic 
+    //  endian_reverse_inplace().
+    //  See rationale in endian_reverse_inplace() below.
+    template <BOOST_SCOPED_ENUM(order) From, BOOST_SCOPED_ENUM(order) To,
+        class EndianReversibleInplace>
+      class converter;  // primary template
+    template <class T> class converter<order::big, order::big, T>
+      {public: void operator()(T&) BOOST_NOEXCEPT {/*no effect*/}};
+    template <class T> class converter<order::little, order::little, T>
+      {public: void operator()(T&) BOOST_NOEXCEPT {/*no effect*/}};
+    template <class T> class converter<order::big, order::little, T>
+      {public: void operator()(T& x) BOOST_NOEXCEPT { endian_reverse_inplace(x); }};
+    template <class T> class converter<order::little, order::big, T>
+      {public: void operator()(T& x) BOOST_NOEXCEPT { endian_reverse_inplace(x); }};
+  }  // namespace detail
+
+  //  generic conditional reverse in place
+  template <BOOST_SCOPED_ENUM(order) From, BOOST_SCOPED_ENUM(order) To,
+    class EndianReversibleInplace>
+  inline void conditional_reverse_inplace(EndianReversibleInplace& x) BOOST_NOEXCEPT
+  {
+    //  work around lack of function template partial specialization by instantiating
+    //  a function object of a class that is partially specialized on the two order
+    //  template parameters, and then calling its operator().
+    detail::converter<From, To, EndianReversibleInplace> tmp;
+    tmp(x);  // call operator ()
+  }
+
+  //  runtime reverse in place
+  template <class EndianReversibleInplace>
+  inline void conditional_reverse_inplace(EndianReversibleInplace& x,
+    BOOST_SCOPED_ENUM(order) from_order,  BOOST_SCOPED_ENUM(order) to_order)
+    BOOST_NOEXCEPT
+  {
+    if (from_order != to_order)
+      endian_reverse_inplace(x);
+  }
+
+
+  namespace detail
+  {
+    template <class T>
+    inline void big_reverse_copy(T from, char* to) BOOST_NOEXCEPT
+    {
+#     ifdef BOOST_BIG_ENDIAN
+      std::memcpy(to, reinterpret_cast<const char*>(&from), sizeof(T));
+#     else
+      std::reverse_copy(reinterpret_cast<const char*>(&from),
+        reinterpret_cast<const char*>(&from) + sizeof(T), to);
+#     endif
+    }
+    template <class T>
+    inline void big_reverse_copy(const char* from, T& to) BOOST_NOEXCEPT
+    {
+#     ifdef BOOST_BIG_ENDIAN
+      std::memcpy(reinterpret_cast<char*>(&to), from, sizeof(T));
+#     else
+      std::reverse_copy(from, from + sizeof(T), reinterpret_cast<char*>(&to));
+#     endif
+    }
+    template <class T>
+    inline void little_reverse_copy(T from, char* to) BOOST_NOEXCEPT
+    {
+#     ifdef BOOST_LITTLE_ENDIAN
+      std::memcpy(to, reinterpret_cast<const char*>(&from), sizeof(T));
+#     else
+      std::reverse_copy(reinterpret_cast<const char*>(&from),
+        reinterpret_cast<const char*>(&from) + sizeof(T), to);
+#     endif
+    }
+    template <class T>
+    inline void little_reverse_copy(const char* from, T& to) BOOST_NOEXCEPT
+    {
+#     ifdef BOOST_LITTLE_ENDIAN
+      std::memcpy(reinterpret_cast<char*>(&to), from, sizeof(T));
+#     else
+      std::reverse_copy(from, from + sizeof(T), reinterpret_cast<char*>(&to));
+#     endif
+    }
+  }  // namespace detail
+}  // namespace endian
+}  // namespace boost
+
+#endif // BOOST_ENDIAN_CONVERSION_HPP

=== added directory '3rd-party/boost/endian/detail'
=== added file '3rd-party/boost/endian/detail/config.hpp'
--- 3rd-party/boost/endian/detail/config.hpp	1970-01-01 00:00:00 +0000
+++ 3rd-party/boost/endian/detail/config.hpp	2016-04-01 06:55:25 +0000
@@ -0,0 +1,62 @@
+//  boost/endian/detail/config.hpp  ----------------------------------------------------//
+
+//  Copyright Beman Dawes 2003, 2010
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+//--------------------------------------------------------------------------------------// 
+
+#ifndef BOOST_ENDIAN_CONFIG_HPP
+#define BOOST_ENDIAN_CONFIG_HPP
+
+// This header implements separate compilation features as described in
+// http://www.boost.org/more/separate_compilation.html
+
+#include <boost/config.hpp>
+#include <boost/system/api_config.hpp>  // for BOOST_POSIX_API or BOOST_WINDOWS_API
+
+//  throw an exception  ----------------------------------------------------------------//
+//
+//  Exceptions were originally thrown via boost::throw_exception().
+//  As throw_exception() became more complex, it caused user error reporting
+//  to be harder to interpret, since the exception reported became much more complex.
+//  The immediate fix was to throw directly, wrapped in a macro to make any later change
+//  easier.
+
+#define BOOST_ENDIAN_THROW(EX) throw EX
+
+//  enable dynamic linking -------------------------------------------------------------//
+
+#if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_ENDIAN_DYN_LINK)
+# if defined(BOOST_ENDIAN_SOURCE)
+#   define BOOST_ENDIAN_DECL BOOST_SYMBOL_EXPORT
+# else 
+#   define BOOST_ENDIAN_DECL BOOST_SYMBOL_IMPORT
+# endif
+#else
+# define BOOST_ENDIAN_DECL
+#endif
+
+//  enable automatic library variant selection  ----------------------------------------// 
+
+#if !defined(BOOST_ENDIAN_SOURCE) && !defined(BOOST_ALL_NO_LIB) \
+  && !defined(BOOST_ENDIAN_NO_LIB)
+//
+// Set the name of our library, this will get undef'ed by auto_link.hpp
+// once it's done with it:
+//
+#define BOOST_LIB_NAME boost_endian
+//
+// If we're importing code from a dll, then tell auto_link.hpp about it:
+//
+#if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_ENDIAN_DYN_LINK)
+#  define BOOST_DYN_LINK
+#endif
+//
+// And include the header that does the work:
+//
+#include <boost/config/auto_link.hpp>
+#endif  // auto-linking disabled
+
+#endif // BOOST_ENDIAN_CONFIG_HPP

=== added file '3rd-party/boost/endian/detail/cover_operators.hpp'
--- 3rd-party/boost/endian/detail/cover_operators.hpp	1970-01-01 00:00:00 +0000
+++ 3rd-party/boost/endian/detail/cover_operators.hpp	2016-04-01 06:55:25 +0000
@@ -0,0 +1,142 @@
+//  boost/endian/detail/cover_operators.hpp ----------------------------------//
+
+//  Copyright Darin Adler 2000
+//  Copyright Beman Dawes 2008
+
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_ENDIAN_COVER_OPERATORS_HPP
+#define BOOST_ENDIAN_COVER_OPERATORS_HPP
+
+#if defined(_MSC_VER)  
+# pragma warning(push)  
+# pragma warning(disable:4365)  // conversion ... signed/unsigned mismatch
+#endif
+
+# ifndef BOOST_ENDIAN_MINIMAL_COVER_OPERATORS
+#   include <boost/operators.hpp>
+# endif
+
+#include <boost/config.hpp>
+#include <iosfwd>
+
+namespace boost
+{
+  namespace endian
+  {
+
+//--------------------------------------------------------------------------------------//
+
+//  A class that adds arithmetic operators to an arithmetic cover class
+//
+//  Uses the curiously recurring template pattern (CRTP).
+//
+//  If the class being covered has a non-explicit conversion to an integer type
+//  then a smaller number of cover operations are needed. Define the macro
+//  BOOST_ENDIAN_MINIMAL_COVER_OPERATORS to indicate this.
+//
+//  Define BOOST_NO_IO_COVER_OPERATORS if I/O cover operations are not desired.
+
+//--------------------------------------------------------------------------------------//
+
+    template <class D,   // D is the CRTP derived type, i.e. the cover class
+              class ArithmeticT>
+    class cover_operators
+#    ifndef BOOST_ENDIAN_MINIMAL_COVER_OPERATORS
+      : boost::operators<D>
+#    endif
+    {
+      // The other operations take advantage of the type conversion that's
+      // built into unary +.
+
+      // Unary operations.
+      friend ArithmeticT operator+(const D& x) BOOST_NOEXCEPT { return x; }
+#   ifndef BOOST_ENDIAN_MINIMAL_COVER_OPERATORS
+      friend ArithmeticT operator-(const D& x) BOOST_NOEXCEPT { return -+x; }
+      friend ArithmeticT operator~(const D& x) BOOST_NOEXCEPT { return ~+x; }
+      friend ArithmeticT operator!(const D& x) BOOST_NOEXCEPT { return !+x; }
+
+      // The basic ordering operations.
+      friend bool operator==(const D& x, ArithmeticT y) BOOST_NOEXCEPT { return +x == y; }
+      friend bool operator<(const D& x, ArithmeticT y) BOOST_NOEXCEPT { return +x < y; }
+#   endif
+      
+      // The basic arithmetic operations.
+      friend D& operator+=(D& x, ArithmeticT y) BOOST_NOEXCEPT
+        { return x = static_cast<ArithmeticT>(+x + y); }
+      friend D& operator-=(D& x, ArithmeticT y) BOOST_NOEXCEPT
+        { return x = static_cast<ArithmeticT>(+x - y); }
+      friend D& operator*=(D& x, ArithmeticT y) BOOST_NOEXCEPT
+        { return x = static_cast<ArithmeticT>(+x * y); }
+      friend D& operator/=(D& x, ArithmeticT y) BOOST_NOEXCEPT
+        { return x = static_cast<ArithmeticT>(+x / y); }
+      friend D& operator%=(D& x, ArithmeticT y) BOOST_NOEXCEPT
+        { return x = static_cast<ArithmeticT>(+x % y); }
+      friend D& operator&=(D& x, ArithmeticT y) BOOST_NOEXCEPT
+        { return x = static_cast<ArithmeticT>(+x & y); }
+      friend D& operator|=(D& x, ArithmeticT y) BOOST_NOEXCEPT
+        { return x = static_cast<ArithmeticT>(+x | y); }
+      friend D& operator^=(D& x, ArithmeticT y) BOOST_NOEXCEPT
+        { return x = static_cast<ArithmeticT>(+x ^ y); }
+      friend D& operator<<=(D& x, ArithmeticT y) BOOST_NOEXCEPT
+        { return x = static_cast<ArithmeticT>(+x << y); }
+      friend D& operator>>=(D& x, ArithmeticT y) BOOST_NOEXCEPT
+        { return x = static_cast<ArithmeticT>(+x >> y); }
+      
+      // A few binary arithmetic operations not covered by operators base class.
+      friend ArithmeticT operator<<(const D& x, ArithmeticT y) BOOST_NOEXCEPT
+        { return static_cast<ArithmeticT>(+x << y); }
+      friend ArithmeticT operator>>(const D& x, ArithmeticT y) BOOST_NOEXCEPT
+        { return static_cast<ArithmeticT>(+x >> y); }
+      
+      // Auto-increment and auto-decrement can be defined in terms of the
+      // arithmetic operations.
+      friend D& operator++(D& x) BOOST_NOEXCEPT { return x += 1; }
+      friend D& operator--(D& x) BOOST_NOEXCEPT { return x -= 1; }
+
+#   ifdef BOOST_ENDIAN_MINIMAL_COVER_OPERATORS
+      friend D operator++(D& x, int) BOOST_NOEXCEPT
+      { 
+        D tmp(x);
+        x += 1;
+        return tmp;
+      }
+      friend D operator--(D& x, int) BOOST_NOEXCEPT
+      { 
+        D tmp(x);
+        x -= 1;
+        return tmp;
+      }
+#   endif
+
+#   ifndef BOOST_NO_IO_COVER_OPERATORS
+
+      // Stream inserter
+      template <class charT, class traits>
+      friend std::basic_ostream<charT, traits>&
+        operator<<(std::basic_ostream<charT, traits>& os, const D& x)
+      {
+        return os << +x; 
+      }
+
+      // Stream extractor 
+      template <class charT, class traits>
+      friend std::basic_istream<charT, traits>&
+        operator>>(std::basic_istream<charT, traits>& is, D& x)
+      {
+        ArithmeticT i;
+        if (is >> i)
+          x = i;
+        return is;
+      }
+#   endif
+    };
+  } // namespace endian
+} // namespace boost
+
+#if defined(_MSC_VER)  
+# pragma warning(pop)  
+#endif 
+
+#endif // BOOST_ENDIAN_COVER_OPERATORS_HPP

=== added file '3rd-party/boost/endian/detail/disable_warnings.hpp'
--- 3rd-party/boost/endian/detail/disable_warnings.hpp	1970-01-01 00:00:00 +0000
+++ 3rd-party/boost/endian/detail/disable_warnings.hpp	2016-04-01 06:55:25 +0000
@@ -0,0 +1,33 @@
+//  disable_warnings.hpp  --------------------------------------------------------------//
+
+//  Copyright Beman Dawes 2011
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+//--------------------------------------------------------------------------------------//
+
+#ifdef  _MSC_VER
+
+#ifndef _SCL_SECURE_NO_WARNINGS
+# define _SCL_SECURE_NO_WARNINGS
+#endif
+
+#ifndef _CRT_SECURE_NO_WARNINGS
+# define _CRT_SECURE_NO_WARNINGS
+#endif
+
+# pragma warning(push)
+
+// triggered by boost/detail/lightweight_test.hpp
+# pragma warning( disable : 4640 )  // ... construction of local static object is not thread-safe
+
+// triggered by Microsoft's own headers, so disable
+# pragma warning( disable : 4820 )  // padding added after data member
+# pragma warning( disable : 4548 )  // expression before comma has no effect
+# pragma warning( disable : 4668 )  // ... is not defined as a preprocessor macro
+# pragma warning( disable : 4514 )  // ... unreferenced inline function has been removed
+# pragma warning( disable : 4710 )  // ... function not inlined
+# pragma warning( disable : 4986 )  // ... exception specification does not match previous declaration
+# pragma warning( disable : 4711 )  // ... selected for automatic inline expansion
+#endif

=== added file '3rd-party/boost/endian/detail/disable_warnings_pop.hpp'
--- 3rd-party/boost/endian/detail/disable_warnings_pop.hpp	1970-01-01 00:00:00 +0000
+++ 3rd-party/boost/endian/detail/disable_warnings_pop.hpp	2016-04-01 06:55:25 +0000
@@ -0,0 +1,12 @@
+//  disable_warnings_pop.hpp  ----------------------------------------------------------//
+
+//  Copyright Beman Dawes 2011
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+//--------------------------------------------------------------------------------------//
+
+#ifdef  _MSC_VER
+# pragma warning(push)
+#endif

=== added file '3rd-party/boost/endian/detail/intrinsic.hpp'
--- 3rd-party/boost/endian/detail/intrinsic.hpp	1970-01-01 00:00:00 +0000
+++ 3rd-party/boost/endian/detail/intrinsic.hpp	2016-04-01 06:55:25 +0000
@@ -0,0 +1,64 @@
+//  endian/detail/intrinsic.hpp  -------------------------------------------------------//
+
+//  Copyright (C) 2012 David Stone
+//  Copyright Beman Dawes 2013
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  http://www.boost.org/LICENSE_1_0.txt
+
+#ifndef BOOST_ENDIAN_INTRINSIC_HPP
+#define BOOST_ENDIAN_INTRINSIC_HPP
+
+//  Allow user to force BOOST_ENDIAN_NO_INTRINSICS in case they aren't available for a
+//  particular platform/compiler combination. Please report such platform/compiler
+//  combinations to the Boost mailing list.
+#ifndef BOOST_ENDIAN_NO_INTRINSICS
+
+#ifndef __has_builtin         // Optional of course
+  #define __has_builtin(x) 0  // Compatibility with non-clang compilers
+#endif
+
+//  GCC and Clang recent versions provide intrinsic byte swaps via builtins
+#if (defined(__clang__) && __has_builtin(__builtin_bswap32) && __has_builtin(__builtin_bswap64)) \
+  || (defined(__GNUC__ ) && \
+  (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)))
+# define BOOST_ENDIAN_INTRINSIC_MSG "__builtin_bswap16, etc."
+// prior to 4.8, gcc did not provide __builtin_bswap16 on some platforms so we emulate it
+// see http://gcc.gnu.org/bugzilla/show_bug.cgi?id=52624
+// Clang has a similar problem, but their feature test macros make it easier to detect
+# if (defined(__clang__) && __has_builtin(__builtin_bswap16)) \
+  || (defined(__GNUC__) &&(__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)))
+#   define BOOST_ENDIAN_INTRINSIC_BYTE_SWAP_2(x) __builtin_bswap16(x)
+# else
+#   define BOOST_ENDIAN_INTRINSIC_BYTE_SWAP_2(x) __builtin_bswap32((x) << 16)
+# endif
+# define BOOST_ENDIAN_INTRINSIC_BYTE_SWAP_4(x) __builtin_bswap32(x)
+# define BOOST_ENDIAN_INTRINSIC_BYTE_SWAP_8(x) __builtin_bswap64(x)
+
+//  Linux systems provide the byteswap.h header, with 
+#elif defined(__linux__)
+//  don't check for obsolete forms defined(linux) and defined(__linux) on the theory that
+//  compilers that predefine only these are so old that byteswap.h probably isn't present.
+# define BOOST_ENDIAN_INTRINSIC_MSG "byteswap.h bswap_16, etc."
+# include <byteswap.h>
+# define BOOST_ENDIAN_INTRINSIC_BYTE_SWAP_2(x) bswap_16(x)
+# define BOOST_ENDIAN_INTRINSIC_BYTE_SWAP_4(x) bswap_32(x)
+# define BOOST_ENDIAN_INTRINSIC_BYTE_SWAP_8(x) bswap_64(x)
+
+#elif defined(_MSC_VER)
+//  Microsoft documents these as being compatible since Windows 95 and specificly
+//  lists runtime library support since Visual Studio 2003 (aka 7.1).
+# define BOOST_ENDIAN_INTRINSIC_MSG "cstdlib _byteswap_ushort, etc."
+# include <cstdlib>
+# define BOOST_ENDIAN_INTRINSIC_BYTE_SWAP_2(x) _byteswap_ushort(x)
+# define BOOST_ENDIAN_INTRINSIC_BYTE_SWAP_4(x) _byteswap_ulong(x)
+# define BOOST_ENDIAN_INTRINSIC_BYTE_SWAP_8(x) _byteswap_uint64(x)
+#else
+# define BOOST_ENDIAN_NO_INTRINSICS
+# define BOOST_ENDIAN_INTRINSIC_MSG "no byte swap intrinsics"
+#endif
+
+#elif !defined(BOOST_ENDIAN_INTRINSIC_MSG)
+# define BOOST_ENDIAN_INTRINSIC_MSG "no byte swap intrinsics"
+#endif  // BOOST_ENDIAN_NO_INTRINSICS
+#endif  // BOOST_ENDIAN_INTRINSIC_HPP

=== added file '3rd-party/boost/endian/detail/lightweight_test.hpp'
--- 3rd-party/boost/endian/detail/lightweight_test.hpp	1970-01-01 00:00:00 +0000
+++ 3rd-party/boost/endian/detail/lightweight_test.hpp	2016-04-01 06:55:25 +0000
@@ -0,0 +1,223 @@
+// boost/endian/detail/lightweight_test.hpp --------------------------------------------//
+
+#ifndef BOOST_ENDIAN_LIGHTWEIGHT_TEST_HPP
+#define BOOST_ENDIAN_LIGHTWEIGHT_TEST_HPP
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+//
+//  Copyright (c) 2002, 2009, 2014 Peter Dimov
+//  Copyright (2) Beman Dawes 2010, 2011, 2015
+//  Copyright (3) Ion Gaztanaga 2013
+//
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+//
+
+#include <boost/assert.hpp>
+#include <boost/current_function.hpp>
+#include <boost/core/no_exceptions_support.hpp>
+#include <cstring>    // for memcmp
+#include <iostream>
+
+//  IDE's like Visual Studio perform better if output goes to std::cout or
+//  some other stream, so allow user to configure output stream:
+#ifndef BOOST_LIGHTWEIGHT_TEST_OSTREAM
+# define BOOST_LIGHTWEIGHT_TEST_OSTREAM std::cerr
+#endif
+
+namespace boost
+{
+namespace endian
+{
+namespace detail
+{
+
+struct report_errors_reminder
+{
+    bool called_report_errors_function;
+
+    report_errors_reminder() : called_report_errors_function(false) {}
+
+    ~report_errors_reminder()
+    {
+        BOOST_ASSERT(called_report_errors_function);  // verify report_errors() was called  
+    }
+};
+
+inline report_errors_reminder& report_errors_remind()
+{
+    static report_errors_reminder r;
+    return r;
+}
+
+inline int & test_errors()
+{
+    static int x = 0;
+    report_errors_remind();
+    return x;
+}
+
+inline void test_failed_impl(char const * expr, char const * file, int line, char const * function)
+{
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM
+      << file << "(" << line << "): test '" << expr << "' failed in function '"
+      << function << "'" << std::endl;
+    ++test_errors();
+}
+
+inline void error_impl(char const * msg, char const * file, int line, char const * function)
+{
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM
+      << file << "(" << line << "): " << msg << " in function '"
+      << function << "'" << std::endl;
+    ++test_errors();
+}
+
+inline void throw_failed_impl(char const * excep, char const * file, int line, char const * function)
+{
+   BOOST_LIGHTWEIGHT_TEST_OSTREAM
+    << file << "(" << line << "): Exception '" << excep << "' not thrown in function '"
+    << function << "'" << std::endl;
+   ++test_errors();
+}
+
+template<class T, class U> inline void test_eq_impl( char const * expr1, char const * expr2,
+  char const * file, int line, char const * function, T const & t, U const & u )
+{
+    if( t == u )
+    {
+        report_errors_remind();
+    }
+    else
+    {
+        BOOST_LIGHTWEIGHT_TEST_OSTREAM
+            << file << "(" << line << "): test '" << expr1 << " == " << expr2
+            << "' failed in function '" << function << "': "
+            << "'" << t << "' != '" << u << "'" << std::endl;
+        ++test_errors();
+    }
+}
+
+template<class T, class U> inline void test_ne_impl( char const * expr1, char const * expr2,
+  char const * file, int line, char const * function, T const & t, U const & u )
+{
+    if( t != u )
+    {
+        report_errors_remind();
+    }
+    else
+    {
+        BOOST_LIGHTWEIGHT_TEST_OSTREAM
+            << file << "(" << line << "): test '" << expr1 << " != " << expr2
+            << "' failed in function '" << function << "': "
+            << "'" << t << "' == '" << u << "'" << std::endl;
+        ++test_errors();
+    }
+}
+
+template <class T>
+std::string to_hex(const T& x)
+{
+  const char hex[] = { '0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f' };
+  std::string tmp;
+  const unsigned char* p = reinterpret_cast<const unsigned char*>(&x);
+  const unsigned char* e = p + sizeof(T);
+
+  for (; p < e; ++p)
+  {
+    tmp += hex[*p >> 4];    // high-order nibble
+    tmp += hex[*p & 0x0f];  // low-order nibble
+  }
+  return tmp;
+}
+
+template<class T, class U> inline bool test_memcmp_eq_impl(char const * expr1,
+  char const * expr2, char const * file, int line, char const * function, T const & t,
+  U const & u)
+{
+  BOOST_ASSERT(sizeof(T) == sizeof(U));
+  if (sizeof(T) == sizeof(U)
+    && std::memcmp(&t, &u, sizeof(T)) == 0)
+  {
+    report_errors_remind();
+    return true;
+  }
+  else
+  {
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM
+      << file << "(" << line << "): test 'std::memcmp(" << expr1 << ", " << expr2
+      << ") == 0' fails in function '" << function << "': "
+      << " with values '" << to_hex(t) << "' and '" << to_hex(u) << "'" << std::endl;
+    ++test_errors();
+    return false;
+  }
+}
+
+} // namespace detail
+
+inline int report_errors()
+{
+    boost::endian::detail::report_errors_remind().called_report_errors_function = true;
+
+    int errors = boost::endian::detail::test_errors();
+
+    if( errors == 0 )
+    {
+        BOOST_LIGHTWEIGHT_TEST_OSTREAM
+          << "No errors detected." << std::endl;
+        return 0;
+    }
+    else
+    {
+        BOOST_LIGHTWEIGHT_TEST_OSTREAM
+          << errors << " error" << (errors == 1? "": "s") << " detected." << std::endl;
+        return 1;
+    }
+}
+
+} // namespace endian
+} // namespace boost
+
+//////////////////////////////////////////////////////////////////////////////////////////
+//  TODO: Should all test macros return bool?  See BOOST_TEST_MEM_EQ usage in fp_exaustive_test,cpp
+//////////////////////////////////////////////////////////////////////////////////////////
+
+
+#define BOOST_TEST(expr) \
+  ((expr)? (void)0: ::boost::endian::detail::test_failed_impl(#expr, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION))
+
+#define BOOST_ERROR(msg) \
+  ( ::boost::endian::detail::error_impl(msg, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION) )
+
+#define BOOST_TEST_EQ(expr1,expr2) \
+  ( ::boost::endian::detail::test_eq_impl(#expr1, #expr2, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION, expr1, expr2) )
+#define BOOST_TEST_NE(expr1,expr2) \
+  ( ::boost::endian::detail::test_ne_impl(#expr1, #expr2, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION, expr1, expr2) )
+
+#define BOOST_TEST_MEM_EQ(expr1,expr2) \
+  (::boost::endian::detail::test_memcmp_eq_impl(#expr1, #expr2, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION, expr1, expr2))
+
+#ifndef BOOST_NO_EXCEPTIONS
+   #define BOOST_TEST_THROWS( EXPR, EXCEP )                    \
+      try {                                                    \
+         EXPR;                                                 \
+         ::boost::detail::throw_failed_impl                    \
+         (#EXCEP, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION); \
+      }                                                        \
+      catch(EXCEP const&) {                                    \
+      }                                                        \
+      catch(...) {                                             \
+         ::boost::detail::throw_failed_impl                    \
+         (#EXCEP, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION); \
+      }                                                        \
+   //
+#else
+   #define BOOST_TEST_THROWS( EXPR, EXCEP )
+#endif
+
+#endif // #ifndef BOOST_ENDIAN_LIGHTWEIGHT_TEST_HPP

=== added file '3rd-party/boost/endian/endian.hpp'
--- 3rd-party/boost/endian/endian.hpp	1970-01-01 00:00:00 +0000
+++ 3rd-party/boost/endian/endian.hpp	2016-04-01 06:55:25 +0000
@@ -0,0 +1,19 @@
+//  boost/endian/endian.hpp  -----------------------------------------------------------//
+
+//  Copyright Beman Dawes 2015
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+//  See library home page at http://www.boost.org/libs/endian
+
+#ifndef BOOST_ENDIAN_ENDIAN_HPP
+#define BOOST_ENDIAN_ENDIAN_HPP
+
+#ifndef BOOST_ENDIAN_DEPRECATED_NAMES
+# error "<boost/endian/endian.hpp> is deprecated. Define BOOST_ENDIAN_DEPRECATED_NAMES to use."
+#endif
+
+#include <boost/endian/arithmetic.hpp>
+
+#endif  //BOOST_ENDIAN_ENDIAN_HPP

=== added file '3rd-party/boost/endian/std_pair.hpp'
--- 3rd-party/boost/endian/std_pair.hpp	1970-01-01 00:00:00 +0000
+++ 3rd-party/boost/endian/std_pair.hpp	2016-04-01 06:55:25 +0000
@@ -0,0 +1,38 @@
+//  boost/endian/std_pair.hpp  ---------------------------------------------------------//
+
+//  Copyright Beman Dawes 2013
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  http://www.boost.org/LICENSE_1_0.txt
+
+//--------------------------------------------------------------------------------------//
+
+#ifndef BOOST_ENDIAN_STD_PAIR_HPP
+#define BOOST_ENDIAN_STD_PAIR_HPP
+
+#include <boost/endian/conversion.hpp>
+#include <utility>
+
+namespace boost
+{
+namespace endian
+{
+  template <class ReversibleValueT, class ReversibleValueU>
+  std::pair<ReversibleValueT, ReversibleValueU>
+    reverse_value(std::pair<ReversibleValueT, ReversibleValueU> x)
+  {
+    return std::pair<ReversibleValueT, ReversibleValueU>(reverse_value(x.first),
+      reverse_value(x.second));
+  }
+
+  template <class ReversibleT, class ReversibleU>
+  void reverse(std::pair<ReversibleT, ReversibleU>& x)
+  {
+    reverse(x.first);
+    reverse(x.second);
+  }
+
+}
+}
+
+#endif  // BOOST_ENDIAN_STD_PAIR_HPP

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2014-09-18 23:06:08 +0000
+++ CMakeLists.txt	2016-04-01 06:55:25 +0000
@@ -34,6 +34,7 @@
 pkg_check_modules(PROCESS_CPP process-cpp REQUIRED)
 pkg_check_modules(PROPERTIES_CPP properties-cpp REQUIRED)
 pkg_check_modules(TRUST_STORE trust-store REQUIRED)
+pkg_check_modules(UBUNTU_PLATFORM_HARDWARE_API ubuntu-platform-hardware-api)
 #####################################################################
 # Enable code coverage calculation with gcov/gcovr/lcov
 # Usage:
@@ -54,7 +55,23 @@
     SET (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-error=unused-local-typedefs")
 endif (DISABLE_ERROR_ON_LOCAL_TYPEDEFS_WARNINGS)
 
+#
+# Code style fixer. We rely on clang-format to adjust the formatting of source code.
+#
+find_program(CLANG_FORMAT_COMMAND NAMES clang-format-3.6 clang-format-3.5)
+if (NOT CLANG_FORMAT_COMMAND)
+  message(WARNING "Cannot find clang-format >= clang-format-3.5: formatcode target will not be available")
+endif()
+
+if (CLANG_FORMAT_COMMAND)
+  file(GLOB_RECURSE UBUNTU_LOCATION_SERVICE_INTERFACE_HEADER_FILES ${CMAKE_SOURCE_DIR}/include/*.h)
+  file(GLOB_RECURSE UBUNTU_LOCATION_SERVICE_IMPLEMENTATION_FILES ${CMAKE_SOURCE_DIR}/src/*.h ${CMAKE_SOURCE_DIR}/src/*.cpp)
+  add_custom_target(formatcode ${CLANG_FORMAT_COMMAND} -i ${UBUNTU_LOCATION_SERVICE_INTERFACE_HEADER_FILES} ${UBUNTU_LOCATION_SERVICE_IMPLEMENTATION_FILES} SOURCES _clang-format)
+endif()
+
 include_directories(
+  3rd-party/
+
   ${Boost_INCLUDE_DIRS}
   ${DBUS_INCLUDE_DIRS}
   ${DBUS_CPP_INCLUDE_DIRS}

=== added file '_clang-format'
--- _clang-format	1970-01-01 00:00:00 +0000
+++ _clang-format	2016-04-01 06:55:25 +0000
@@ -0,0 +1,56 @@
+---
+Language:        Cpp
+AccessModifierOffset: -4
+ConstructorInitializerIndentWidth: 4
+AlignEscapedNewlinesLeft: false
+AlignTrailingComments: true
+AllowAllParametersOfDeclarationOnNextLine: true
+AllowShortBlocksOnASingleLine: false
+AllowShortIfStatementsOnASingleLine: false
+AllowShortLoopsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: All
+AlwaysBreakTemplateDeclarations: false
+AlwaysBreakBeforeMultilineStrings: false
+BreakBeforeBinaryOperators: false
+BreakBeforeTernaryOperators: true
+BreakConstructorInitializersBeforeComma: false
+BinPackParameters: true
+ColumnLimit: 0
+ConstructorInitializerAllOnOneLineOrOnePerLine: false
+DerivePointerAlignment: false
+ExperimentalAutoDetectBinPacking: false
+IndentCaseLabels: false
+IndentWrappedFunctionNames: false
+IndentFunctionDeclarationAfterType: false
+MaxEmptyLinesToKeep: 1
+KeepEmptyLinesAtTheStartOfBlocks: true
+NamespaceIndentation: None
+ObjCSpaceAfterProperty: false
+ObjCSpaceBeforeProtocolList: true
+PenaltyBreakBeforeFirstCallParameter: 19
+PenaltyBreakComment: 300
+PenaltyBreakString: 1000
+PenaltyBreakFirstLessLess: 120
+PenaltyExcessCharacter: 1000000
+PenaltyReturnTypeOnItsOwnLine: 60
+PointerAlignment: Left
+SpacesBeforeTrailingComments: 1
+Cpp11BracedListStyle: true
+Standard:        Cpp11
+IndentWidth:     4
+TabWidth:        8
+UseTab:          Never
+BreakBeforeBraces: Allman
+SpacesInParentheses: false
+SpacesInAngles:  false
+SpaceInEmptyParentheses: false
+SpacesInCStyleCastParentheses: false
+SpacesInContainerLiterals: true
+SpaceBeforeAssignmentOperators: true
+ContinuationIndentWidth: 4
+CommentPragmas:  '^ IWYU pragma:'
+ForEachMacros:   [ foreach, Q_FOREACH, BOOST_FOREACH ]
+SpaceBeforeParens: ControlStatements
+DisableFormat:   false
+...
+

=== added file 'astyle-config'
--- astyle-config	1970-01-01 00:00:00 +0000
+++ astyle-config	2016-04-01 06:55:25 +0000
@@ -0,0 +1,43 @@
+# Options for formatting code with astyle.
+#
+# This helps to make code match the style guide.
+# 
+# Use like this:
+# 
+#     astyle --options=astyle-config mfile.h myfile.cpp
+# 
+# Occasionally, astyle does something silly (particularly with lambdas), so it's
+# still necessary to scan the changes for things that are wrong.
+# But, for most files, it does a good job.
+# 
+# Please consider using this before checking code in for review. Code reviews shouldn't
+# have to deal with layout issues, they are just a distraction. It's better to be able
+# to focus on semantics in a code review, with style issues out of the way.
+
+--formatted
+--style=allman
+--min-conditional-indent=2
+--indent-switches
+--max-instatement-indent=120
+--pad-header
+--align-pointer=type
+--align-reference=type
+--convert-tabs
+--close-templates
+--max-code-length=120
+
+# --pad-oper
+#
+# Commented out for now. It changes
+#
+#     for (int i=0; i<10; ++i)
+# to
+#     for (int i = 0; i < 10; ++i)
+#
+# Unfortunately, it also messes with rvalue references:
+#
+#     ResourcePtr& operator=(ResourcePtr&& r);
+#
+# becomes:
+#
+#     ResourcePtr& operator=(ResourcePtr && r);

=== modified file 'debian/changelog'
--- debian/changelog	2015-07-27 18:07:37 +0000
+++ debian/changelog	2016-04-01 06:55:25 +0000
@@ -36,6 +36,117 @@
 
  -- CI Train Bot <[e-mail]>  Thu, 28 May 2015 11:40:58 +0000
 
+location-service (2.1+15.04.20160331.2-0ubuntu1) vivid; urgency=medium
+
+  * Log to stderr by default, relying on upstart to rotate logs
+    appropriately. (LP: #1447110)
+
+ -- Thomas Voß <[e-mail]>  Thu, 31 Mar 2016 11:03:46 +0000
+
+location-service (2.1+15.04.20160308.1-0ubuntu1) vivid; urgency=medium
+
+  * Add SntpClient for querying reference time information.
+
+ -- Thomas Voß <[e-mail]>  Tue, 08 Mar 2016 08:54:07 +0000
+
+location-service (2.1+15.04.20160302.1-0ubuntu1) vivid; urgency=medium
+
+  * Remove explicit option to disable satellite-based positioning
+    services.
+
+ -- Thomas Voß <[e-mail]>  Wed, 02 Mar 2016 15:28:02 +0000
+
+location-service (2.1+15.04.20160106-0ubuntu1) vivid; urgency=medium
+
+  [ Alberto Mardegan ]
+  * Set debian source format to "3.0 (native)"
+
+  [ Scott Sweeny ]
+  * Allow providers to register themselves asynchronously (LP: #1415029)
+
+ -- Thomas Voß <[e-mail]>  Wed, 06 Jan 2016 16:15:29 +0000
+
+location-service (2.1+15.04.20151211-0ubuntu1) vivid; urgency=medium
+
+  * Account for changes in trust-store w.r.t. assembling the description
+    of a trust prompt.
+
+ -- Thomas Voß <[e-mail]>  Fri, 11 Dec 2015 08:57:44 +0000
+
+location-service (2.1+15.04.20151209-0ubuntu1) vivid; urgency=medium
+
+  * Fix settings not being applied correctly.
+
+ -- Thomas Voß <[e-mail]>  Wed, 09 Dec 2015 15:22:22 +0000
+
+location-service (2.1+15.04.20151202.1-0ubuntu1) vivid; urgency=medium
+
+  * Ensure that event connections are cleaned up on destruction. (LP:
+    #1480877)
+
+ -- Thomas Voß <[e-mail]>  Wed, 02 Dec 2015 12:12:21 +0000
+
+location-service (2.1+15.04.20151127-0ubuntu1) vivid; urgency=medium
+
+  [ Alberto Mardegan ]
+  * Send last known position on session start
+
+  [ CI Train Bot ]
+  * New rebuild forced.
+
+  [ Thomas Voß ]
+  * Factor out service::Runtime from daemon.cpp into its own .h/.cpp
+    pair of files. Add test cases around correct operation of
+    service::Runtime. added:
+    src/location_service/com/ubuntu/location/service/runtime.cpp
+    src/location_service/com/ubuntu/location/service/runtime.h
+    tests/runtime_test.cpp
+
+  [ thomas-voss ]
+  * Factor out service::Runtime from daemon.cpp into its own .h/.cpp
+    pair of files. Add test cases around correct operation of
+    service::Runtime. added:
+    src/location_service/com/ubuntu/location/service/runtime.cpp
+    src/location_service/com/ubuntu/location/service/runtime.h
+    tests/runtime_test.cpp
+
+ -- Thomas Voß <[e-mail]>  Fri, 27 Nov 2015 13:00:33 +0000
+
+location-service (2.1+15.04.20151113-0ubuntu1) vivid; urgency=medium
+
+  * Adjust default timeout for downloading GPS XTRA data.
+
+ -- Thomas Voß <[e-mail]>  Fri, 13 Nov 2015 10:33:56 +0000
+
+location-service (2.1+15.04.20151109.2-0ubuntu1) vivid; urgency=medium
+
+  [ Alberto Mardegan ]
+  * Make sure that injected time is given in milliseconds
+
+  [ Thomas Voß ]
+  * Cherry-pick rev. 196 and 199 from lp:location-service. The changes
+    got accidentally removed by merging the outstanding documentation
+    branch.
+  * Handle responses of clients to updates asynchronously. Rely on
+    dummy::ConnectivityManager as harvesting is disabled anyway. (LP:
+    #1462664, #1387643)
+
+ -- David Barth <[e-mail]>  Mon, 09 Nov 2015 20:48:48 +0000
+
+location-service (2.1+15.04.20151022-0ubuntu1) vivid; urgency=medium
+
+  [ Thomas Voß ]
+  * Add documentation for debugging, hacking and debugging the location
+    service. Pull manual testing instructions over from the wiki. Add
+    tools for formatting the source.
+
+  [ thomas-voss ]
+  * Add documentation for debugging, hacking and debugging the location
+    service. Pull manual testing instructions over from the wiki. Add
+    tools for formatting the source.
+
+ -- Thomas Voß <[e-mail]>  Thu, 22 Oct 2015 07:16:50 +0000
+
 location-service (2.1+15.04.20150427.1-0ubuntu1) vivid; urgency=medium
 
   [ CI Train Bot ]

=== modified file 'debian/source/format'
--- debian/source/format	2014-07-30 14:15:06 +0000
+++ debian/source/format	2016-04-01 06:55:25 +0000
@@ -1,1 +1,1 @@
-3.0 (quilt)
+3.0 (native)

=== modified file 'doc/Doxyfile.in'
--- doc/Doxyfile.in	2014-05-19 09:55:25 +0000
+++ doc/Doxyfile.in	2016-04-01 06:55:25 +0000
@@ -748,7 +748,7 @@
 # directories that contain image that are included in the documentation (see
 # the \image command).
 
-IMAGE_PATH             =
+IMAGE_PATH             = @CMAKE_CURRENT_SOURCE_DIR@/images
 
 # The INPUT_FILTER tag can be used to specify a program that doxygen should
 # invoke to filter for each input file. Doxygen will invoke the filter program
@@ -1463,7 +1463,7 @@
 # generate an XML file that captures the structure of
 # the code including all documentation.
 
-GENERATE_XML           = NO
+GENERATE_XML           = YES
 
 # The XML_OUTPUT tag is used to specify where the XML pages will be put.
 # If a relative path is entered the value of OUTPUT_DIRECTORY will be

=== added file 'doc/daemon_and_cli.md'
--- doc/daemon_and_cli.md	1970-01-01 00:00:00 +0000
+++ doc/daemon_and_cli.md	2016-04-01 06:55:25 +0000
@@ -0,0 +1,55 @@
+# Service Daemon and CLI
+
+The location service offers a daemon executable and a corresponding
+command-line interface for interacting with it. The daemon does not
+necessarily require root privileges, but might so depending on your
+configuration.
+
+Run the following command to receive an overview of the arguments to
+the daemon:
+
+    ubuntu-location-serviced --help
+
+An example invocation of the daemon, configuring a GPS provider that
+relies on the Android HAL to talk to the chipset, exposing the service
+on the system DBus instance:
+
+    ubuntu-location-serviced --bus system --provider gps::Provider
+
+The cli allows for querying properties of a running service instance, e.g.:
+
+    ubuntu-location-serviced-cli --bus system --get --property is_online
+
+## Configuring an Out-Of-Process Provider
+
+If you want to run a provider out of process, the daemon executable
+allows you to do so by instantiating a so-called remote provider. The
+following invocation of the service tries to connect to the provider
+instance described by the given unique DBus name and path.
+
+    ubuntu-location-serviced \
+	  --bus system \
+	  --provider remote::Provider \
+          --remote::Provider::bus=system \
+	  --remote::Provider::name=com.ubuntu.location.provider.Gps \
+	  --remote::Provider::path=/
+
+Please note that the service allows for decorating provider names to
+uniquely identify per provider configuration options and to allow for
+loading more than one provider of a certain kind. The following
+configuration configures two remote providers, one relying on GPS
+(decorated with @gps) and another one relying on network-based
+positioning (decorated with @network):
+
+    ubuntu-location-serviced \
+	  --bus system \
+	  --provider remote::Provider@gps \
+          --remote::Provider@gps::bus=system \
+	  --remote::Provider@gps::name=com.ubuntu.location.provider.Gps \
+	  --remote::Provider@gps::path=/ \
+	  --provider remote::Provider@network \
+          --remote::Provider@network::bus=system \
+	  --remote::Provider@network::name=com.ubuntu.location.provider.Network \
+	  --remote::Provider@network::path=/
+
+    

=== added file 'doc/debugging.md'
--- doc/debugging.md	1970-01-01 00:00:00 +0000
+++ doc/debugging.md	2016-04-01 06:55:25 +0000
@@ -0,0 +1,91 @@
+# Debugging
+
+Location not working? Here's how to debug.
+
+## Layers
+
+Test in OSMTouch (QML app using Qt API) before testing in webapps or
+webbrowser app. Different results? File a bug where it doesn't
+work. Same result of no location? Next step.
+
+## Check that stack works with dummy provider
+
+Edit /etc/init/ubuntu-location-provider.override to start
+location-serviced with just the dummy provider; this should
+work. Doesn't work? File a bug against location-service. Works? Reset
+config to defaults and try the next thing.
+
+## Hardware GPS breaking all of location-service
+
+GPS provider is built-in into location-service and might break all of
+it if it goes south (working on splitting it out); try enabling only
+the HERE provider on the location-serviced command-line and see if
+that works. Works? File a bug against location-service. Doesn't work?
+Move on.
+
+## HERE test
+
+To test whether the low-level HERE stack gets a location, put
+http://people.canonical.com/~lool/espoo-cli on your phone (will be
+included along HERE bits in the future) and run with:
+
+    chmod a+x espoo-cli
+    GLOG_logtostderr=1 GLOG_v=100 LD_LIBRARY_PATH=/custom/vendor/here/location-provider/lib/arm-linux-gnueabihf ./espoo-cli 5
+
+NB: 5 is the number of location updates after which the tool exits;
+updates should come in at approx 15s interval. Output looks like:
+
+    I1101 21:30:01.285964 4403 cli.cpp:117] Requested number of updates is 2
+    I1101 21:30:01.299002 4403 cli.cpp:133] Starting location updates
+    I1101 21:30:01.301888 4403 cli.cpp:141] Starting GLib main loop
+    I1101 21:30:11.304612 4403 cli.cpp:158] Location: tstamp=1414891811 lat=xyz long=foo hor. acc.=2569 alt=nan vert. acc.=nan tech=cell
+    I1101 21:30:11.306061 4403 cli.cpp:170] Remaining updates: 1
+    I1101 21:30:26.736821 4403 cli.cpp:158] Location: tstamp=1414891826 lat=xyz long=foo hor. acc.=2824 alt=nan vert. acc.=nan tech=cell
+    I1101 21:30:26.738348 4403 cli.cpp:148] Stopping location updates
+
+Low-level HERE stack works but location-serviced with just HERE
+provider doesn't work? File a bug against espoo projet (HERE) and/or
+location-service. Low-level HERE stack doesn't work? Move on
+
+## location-service and espoo-service debug
+
+Collect some debug data by editing /etc/init/ubuntu-espoo-service.conf
+and /etc/init/ubuntu-location-service.override and changing the start
+sequence to add some env vars:
+
+    export GLOG_v=200
+
+before the exec. Reboot, and start some app. You should have some log
+files under /var/log/upstart/ubuntu-espoo-service.log and
+/var/log/upstart/ubuntu-location-service.log to attach to a bug
+report; e.g. a working espoo log looks like this:
+
+    WARNING: Logging before InitGoogleLogging() is written to STDERR
+    I1105 16:30:10.221474  1620 provider.cpp:568] StartPositionUpdates
+    I1105 16:30:10.224901  1620 provider.cpp:122] Successfully started position updates.
+    I1105 16:30:10.228739  1620 provider.cpp:596] StartVelocityUpdates
+    I1105 16:30:13.046851  1621 provider.cpp:83] Received location: Position(lat: Coordinate(12.34 deg), lon: Coordinate(12.34 deg), alt: Coordinate(nan m), hor.acc.: 1430 m, ver.acc.: nan m)
+
+No position there? check connectivity API works by running:
+
+    cd /tmp
+    wget http://people.ubuntu.com/~lool/connectivity
+    GLOG_v=200 GLOG_logtostderr=1 ./connectivity
+
+you should see something like:
+
+    I1105 16:47:26.431466 11140 cached_radio_cell.cpp:160] (mcc: 123, mnc: 2, lac: 1234, id: 123456, asu: 1)
+    I1105 16:47:26.533818 11140 connectivity.cpp:47] Is wifi enabled: true
+    I1105 16:47:26.533963 11140 connectivity.cpp:48] Is wifi hw enabled: true
+    I1105 16:47:26.534010 11140 connectivity.cpp:49] Is wwan enabled: true
+    I1105 16:47:26.534050 11140 connectivity.cpp:50] Is wwan hw enabled: true
+    I1105 16:47:26.534442 11140 connectivity.cpp:122] umts(mcc: 123, mnc: 2, lac: 1234, id: 123456, asu: 1)
+    I1105 16:47:26.534633 11140 connectivity.cpp:155] (bssid: 12:12:12:12:12:12, ssid: xyz, last seen: 1415224046, mode: Mode::infrastructure, frequency: 2442, strength: 63)
+    I1105 16:47:26.534828 11140 connectivity.cpp:155] (bssid: 12:12:12:12:12:12, ssid: boing, last seen: 1415224046, mode: Mode::infrastructure, frequency: 2467, strength: 57)
+
+Also, please attach output of /usr/share/ofono/scripts/list-modems > list-modems-output.txt
+Please note that the command might take ~1 minute to complete.
+
+TODO: document dbus-monitor / d-feet capturing of client / system traffic with snooping config.
+
+

=== added file 'doc/hacking.md'
--- doc/hacking.md	1970-01-01 00:00:00 +0000
+++ doc/hacking.md	2016-04-01 06:55:25 +0000
@@ -0,0 +1,146 @@
+# Hacking
+
+
+## Building the code
+
+By default, the code is built in release mode. To build a debug version, use
+
+    $ mkdir builddebug
+    $ cd builddebug
+    $ cmake -DCMAKE_BUILD_TYPE=debug ..
+    $ make
+
+For a release version, use -DCMAKE_BUILD_TYPE=release
+
+## Running the tests
+
+    $ make
+    $ make test
+
+Note that "make test" alone is dangerous because it does not rebuild
+any tests if either the library or the test files themselves need
+rebuilding. It's not possible to fix this with cmake because cmake cannot
+add build dependencies to built-in targets. To make sure that everything
+is up-to-date, run "make" before running "make test"!
+
+## Coverage
+
+To build with the flags for coverage testing enabled and get coverage:
+
+    $ mkdir buildcoverage
+    $ cd buildcoverage
+    $ cmake -DCMAKE_BUILD_TYPE=coverage
+    $ make
+    $ make test
+    $ make coverage
+
+Unfortunately, it is not possible to get 100% coverage for some files,
+mainly due to gcc's generation of two destructors for dynamic and non-
+dynamic instances. For abstract base classes and for classes that
+prevent stack and static allocation, this causes one of the destructors
+to be reported as uncovered.
+
+There are also issues with some functions in header files that are
+incorrectly reported as uncovered due to inlining, as well as
+the impossibility of covering defensive assert(false) statements,
+such as an assert in the default branch of a switch, where the
+switch is meant to handle all possible cases explicitly.
+
+If you run a binary and get lots of warnings about a "merge mismatch for summaries",
+this is caused by having made changes to the source that add or remove code
+that was previously run, so the new coverage output cannot sensibly be merged
+into the old coverage output. You can get rid of this problem by running
+
+    $ make clean-coverage
+
+This deletes all the .gcda files, allowing the merge to (sometimes) succeed again.
+If this doesn't work either, the only remedy is to do a clean build.
+
+If lcov complains about unrecognized lines involving '=====',
+you can patch geninfo and gcovr as explained here:
+
+https://bugs.launchpad.net/gcovr/+bug/1086695/comments/2
+
+## Code style
+
+We use a format tool that fixes a whole lot of issues
+regarding code style. The formatting changes made by
+the tool are generally sensible (even though they may not be your
+personal preference in all cases). If there is a case where the formatting
+really messes things up, consider re-arranging the code to avoid the problem.
+The convenience of running the entire code base through the pretty-printer
+far outweighs any minor glitches with pretty printing, and it means that
+we get consistent code style for free, rather than endlessly having to
+watch out for formatting issues during code reviews.
+
+As of clang-format-3.7, you can use
+
+    // clang-format off
+    void    unformatted_code  ;
+    // clang-format on
+
+to suppress formatting for a section of code.
+
+To format specific files:
+
+    ${CMAKE_BINARY_DIR}/tools/formatcode x.cpp x.h
+
+If no arguments are provided, formatcode reads stdin and writes
+stdout, so you can easily pipe code into the tool from within an
+editor. For example, to reformat the entire file in vi (assuming
+${CMAKE_BINARY_DIR}/tools is in your PATH):
+
+    1G!Gformatcode
+
+To re-format all source and header files in the tree:
+
+    $ make formatcode
+
+## Thread and address sanitizer
+
+Set SANITIZER to "thread" or "address" to build with the
+corresponding sanitizer enabled.
+
+## Updating symbols file
+
+To easily spot new/removed/changed symbols in the library, the debian
+package maintains a .symbols file that lists all exported symbols
+present in the library .so. If you add new public symbols to the library,
+it's necessary to refresh the symbols file, otherwise the package will
+fail to build. The easiest way to do that is using bzr-builddeb:
+
+    $ bzr bd -- -us -uc -j8  # Don't sign source package or changes file, 8 compiles in parallel
+    $ # this will exit with an error if symbols file isn't up-to-date
+    $ cd ../build-area/location-service-[version]
+    $ ./obj-[arch]/tools/symbol_diff
+
+This creates a diff of the symbols in /tmp/symbols.diff.
+(The demangled symbols from the debian build are in ./new_symbols.)
+
+Review any changes in /tmp/symbols.diff. If they are OK:
+
+    $ cd -
+    $ patch -p0 < /tmp/symbols.diff
+
+## ABI compliance test
+
+To use this, install abi-compliance-checker package from the archives.
+
+You can use abi-compliance-checker to test whether a particular build
+is ABI compatible with another build. The tool does some source-level
+analysis in addition to checking library symbols, so it catches things
+that are potentially dangerous, but won't be picked up by just looking
+at the symbol table.
+
+Assume you have built devel in src/devel, and you have a later build
+in src/mybranch and want to check that mybranch is still compatible.
+To run the compliance test:
+
+    $ cd src
+    $ abi-compliance-checker -lib libunity-scopes.so -old devel/build/test/abi-compliance/abi.xml -new mybranch/build/test/abi-compliance/abi.xml
+
+The script will take about two minutes to run. Now point your browser at 
+
+    src/compat_reports/libunity-scopes.so/[version]_to_[version]/compat_report.html
+
+The report provides a nicely layed-out page with all the details.

=== added directory 'doc/images'
=== added file 'doc/images/LocationServiceHighLevel.png'
Binary files doc/images/LocationServiceHighLevel.png	1970-01-01 00:00:00 +0000 and doc/images/LocationServiceHighLevel.png	2016-04-01 06:55:25 +0000 differ
=== added file 'doc/intro.md'
--- doc/intro.md	1970-01-01 00:00:00 +0000
+++ doc/intro.md	2016-04-01 06:55:25 +0000
@@ -0,0 +1,67 @@
+# Introduction               {#mainpage}
+
+Ubuntu's location service is a central hub for multiplexing access to
+positioning subsystems available via hard- and software. It provides a
+client API offering positioning capabilities to applications and other
+system components, abstracting away the details of individual
+positioning solutions.
+
+## Vocabulary
+
+To make the remainder of this documentation as easily understandable
+as possible, we start over with introducing some vocabulary:
+
+- Engine: 
+    Responsible for handling input from multiple positioning
+    subsystems and maintaining the state of the overall system. Think
+    about it like the heart of the system.
+
+- Provider: 
+    A positioning subsystem that feeds into the positioning
+    engine. Common examples are a GPS provider or a network-based
+    positioning provider.
+
+- Service:
+    The point of entry for applications and services that would
+    like to receive position data.
+
+- Session:
+    In order to receive position information, every application
+    or service has to create a session with the location Service.
+
+- Update: An update is a timestamped entity to a certain type of data.
+
+- [WGS84, http://en.wikipedia.org/wiki/World_Geodetic_System]: The coordinate system that is used throughout the entire location subsystem.
+
+## Architectural Overview
+
+The high-level architecture of the service is shown in the following diagram:
+
+![High-level architectural overview](images/LocationServiceHighLevel.png)
+
+In this diagram, the configuration of the engine refers to:
+
+  * The current state of any satellite-based positioning subsystems. Can either be off or on.
+  * The current state of reporting facilities responsible for harvesting wifi and cell id measurements together with location information and sending them off to remote services. Can either be off or on.
+  * The overall state of the engine. Can either be off, on or active.
+
+The Service takes this configuration and exposes it to client
+applications. In addition, mainly for debugging purposes, the set of
+currently visible satellites (if any) is maintained and exposed to
+privileged client applications.
+
+## Privacy & Access Control
+
+Location information is highly privacy relevant. For this reason, the
+location service is deeply integrated with AppArmor and Ubuntu's
+overall trust infrastructure. Every incoming session request is
+validated and if in doubt, the user is asked to explicitly grant trust
+to the application requesting access to positioning
+information. Please see [@ref com::ubuntu::location::service::PermissionManager]
+for further details.
+
+In addition, the location service allows for selectively adjusting the
+accuracy and reporting setup of the location Engine to provide further
+fine-grained control over the exposed data to user. Within this setup,
+a user is able to entirely disable all positioning.
+

=== added file 'doc/manual_testing.md'
--- doc/manual_testing.md	1970-01-01 00:00:00 +0000
+++ doc/manual_testing.md	2016-04-01 06:55:25 +0000
@@ -0,0 +1,174 @@
+# Manual Testplan
+
+[TOC]
+
+While the automatic test suite of the location service is
+comprehensive and covers large parts of the functionality of the
+service itself, we still provide an additional level of acceptance
+testing covering the entire location stack/experience as a part of
+this document.
+
+## Dependents/Clients
+
+ - qtubuntu-sensors
+ - Qt/QML applications:
+   - Browser
+   - osmTouch
+
+## Test Plan
+
+This test plan is not supposed to be complete; use it to guide your
+manual testing so you don't miss big functional areas that are part of
+the component; also this should be used as guideline to inspire the
+exploratory testing which should be adapted smartly based on the real
+content of a MP.
+
+Please note that if you're testing the GPS provider, the location
+service relies on GPS hardware to obtain a location fix. For that, it
+might be required that you execute the manual steps listed before
+close to a window or ideally outside, with good satellite visibility
+conditions.
+
+__Note: It can take up to 15 minutes for the GPS device to get a lock, due to lack of assisted GPS__
+
+ - Install latest image on phone
+ - Install freshly built MPs that are needed for landing
+
+Depending on the default configuration of location-service on the
+image, you may skip parts of this test plan. E.g. if GPS hardware is
+disabled, skip this part. You can see which providers are enabled by
+looking at the list of providers on the location-serviced command-line
+(`ps fauxw | grep location-service`, then look at the `--provider`
+flags).
+
+### Dummy provider
+
+This tests forces location-service to use only the dummy provider;
+this providers a baseline test for the app to trust-store to
+location-service path.
+
+ - phablet-shell into the phone:
+   - `sudo service ubuntu-location-service stop && sudo /usr/bin/ubuntu-location-serviced --bus system --provider dummy::Provider --dummy::Provider::ReferenceLocationLat=48.857503 --dummy::Provider::ReferenceLocationLon=2.295072`
+ - As phablet, start the trust store again (it stops when location-service is stopped) with: `start ubuntu-location-service-trust-stored`
+ - Ensure that all AP tests for the webbrowser pass as expected
+ - Point the browser to maps.google.com (alternatively: here.com, maps.bing.fr).
+ - Request centering the map on current position and observe if it works correctly (should show the Eiffel tower)
+ - Install osmTouch from the app store
+ - Launch osmTouch and check if it centers on the Eiffel tower.
+ - Install a maps webapp such as HERE or Google Maps webapp from the app store
+ - Launch maps webapp and check if it centers on the Eiffel tower.
+
+### GPS Test Plan
+
+This applies only if GPS provider is enabled.
+
+ - (If applicable: Remember to add the silo you are testing)
+ - `sudo apt-get install ubuntu-location-service-tests`
+ - If you want to send off crowdsourced information, i.e., information about visible wifis and visible radio cells for the obtained location fixes to Mozilla's location service and our own instance: 
+   - `sudo GLOG_v=40 GLOG_logtostderr=1 GPS_TEST_ENABLE_HARVESTING_DURING_TESTS=1  /usr/bin/uls-tests/gps_provider_test --gtest_filter=*.time_to_first_fix_cold_start_without_supl_benchmark_requires_hardware`
+ - If you '''don't''' want to send off crowdsourced information:
+   - `sudo GLOG_v=40 GLOG_logtostderr=1 /usr/bin/uls-tests/gps_provider_test --gtest_filter=*.time_to_first_fix_cold_start_without_supl_benchmark_requires_hardware`
+
+ - The test will output a lot of diagnostic information to the
+   terminal and will take ~30 minutes. If satellite visibility is
+   limited, it can take even longer. The test will automatically
+   report success or failure.
+
+### Preliminary AGPS Test Plan
+
+**Does not apply to Krillin**
+
+Please note that the Krillin GPS chipset driver and its integration
+within Ubuntu does not support vanilla AGPS (i.e., SUPL) right
+now. For that, this test case is irrelevant for Krillin and is likely
+to fail.
+
+This applied only if GPS provider and some other provider (giving
+_A_ssistance) are enabled.
+
+ - Add the silo.
+ - `sudo apt-get install ubuntu-location-service-tests`
+ - Obtain a (rough) location estimate for your current location on Google maps.
+ - Make sure to replace INSERT_ESTIMATE_HERE with the respective
+   values obtained from Google maps.
+ - If you want to send off crowdsourced information, i.e., information
+   about visible wifis and visible radio cells for the obtained
+   location fixes to Mozilla's location service and our own instance:
+   - `sudo GLOG_v=40 GLOG_logtostderr=1 GPS_TEST_ENABLE_HARVESTING_DURING_TESTS=1  GPS_TEST_REF_LAT=INSERT_ESTIMATE_HERE GPS_TEST_REF_LON=INSERT_ESTIMATE_HERE /usr/bin/uls-tests/gps_provider_test --gtest_filter=*.time_to_first_fix_cold_start_with_supl_benchmark_requires_hardware`
+ - If you '''don't''' want to send off crowdsourced information:
+   - `sudo GLOG_v=40 GLOG_logtostderr=1 GPS_TEST_REF_LAT=INSERT_ESTIMATE_HERE GPS_TEST_REF_LON=INSERT_ESTIMATE_HERE /usr/bin/uls-tests/gps_provider_test --gtest_filter=*.time_to_first_fix_cold_start_with_supl_benchmark_requires_hardware`
+
+ - The test will output a lot of diagnostic information to the
+   terminal and will take ~10 minutes or less. The test will
+   automatically report success or failure.
+
+### Espoo / HERE provider
+
+This applies only if the Espoo / HERE remote provider is enabled. This
+provider should be enabled by default and may either work standalone
+as the only provider or as an assistance for the GPS hardware to lock.
+
+ - Add the silo; special exception for lxc-android-config: see https://wiki.ubuntu.com/Touch/Testing/lxc-android-config
+ - If noted, deploy an updated custom tarball:
+   - Download the tarball under /tmp ('''NOT''' under /)
+   - Unpack there: `cd /tmp; sudo tar xvf custom-vendor-here-*.tar.xz`
+   - Remove older bits: `sudo rm -rf /custom/vendor/here/`
+   - Update custom bits: `sudo mv /tmp/system/custom/vendor/here /custom/vendor`
+ - Reboot
+ - After boot, check you have these three processes running on top of location-service:
+   - slpgwd
+   - posclientd
+   - ubuntu-espoo-service
+ - Make sure SIM is unlocked and attached to the network (has some reliable signal) and that WiFi is turned on.
+ - Install OSMTouch app
+ - Run OSMTouch app, hit the position button every other second until you get a blue circle showing your current location; 
+
+# Connectivity API
+
+For integration of network-based positioning providers, the location
+service offers a connectivity API that provides access to wifi and
+cell measurements as well as information on the current overall
+connectivity status of the device. Please execute the following
+commands on a newly flashed device with a writable image:
+
+  - `sudo apt-get update && sudo apt-get build-dep location-service && sudo apt-get install libubuntu-location-service-dev ubuntu-location-service-examples`
+  - `mkdir /tmp/build && cd /tmp/build && cmake /usr/share/ubuntu-location-service/examples/standalone/connectivity/ && make`
+  - `GLOG_logtostderr=1 ./connectivity`
+
+Verify that the output looks similar to:
+
+    phablet@ubuntu-phablet:/tmp/build$ ./connectivity 
+    Is wifi enabled: true
+    Is wifi hw enabled: true
+    Is wwan enabled: false
+    Is wwan hw enabled: true
+    umts(mcc: 262, mnc: 2, lac: 5313, id: 131948771, asu: 7)
+    (bssid: BC:F2:AF:AF:19:A2, ssid: devolo-bcf2afaf19a2, last seen: 1408955086, mode: Mode::infrastructure, frequency: 2462, strength: 72)
+    (bssid: 00:22:3F:35:43:58, ssid: JustAnotherWLAN, last seen: 1408955086, mode: Mode::infrastructure, frequency: 2412, strength: 24)
+    (bssid: 82:C7:A6:40:8C:4E, ssid: EasyBox-44D054, last seen: 1408955206, mode: Mode::infrastructure, frequency: 2417, strength: 17)
+    (bssid: 00:24:01:B8:32:8D, ssid: gra, last seen: 1408955086, mode: Mode::infrastructure, frequency: 2412, strength: 12)
+    (bssid: C0:25:06:3C:28:22, ssid: FRITZ!Box 6360 Cable, last seen: 1408954966, mode: Mode::infrastructure, frequency: 2412, strength: 17)
+    (bssid: 00:1C:4A:A5:B7:59, ssid: FRITZ!Box Fon WLAN 7170, last seen: 1408954966, mode: Mode::infrastructure, frequency: 2437, strength: 10)
+    Last seen changed for wifi (bssid: BC:F2:AF:AF:19:A2, ssid: devolo-bcf2afaf19a2, last seen: 1408955257, mode: Mode::infrastructure, frequency: 2462, strength: 72)
+    Last seen changed for wifi (bssid: 00:22:3F:35:43:58, ssid: JustAnotherWLAN, last seen: 1408955257, mode: Mode::infrastructure, frequency: 2412, strength: 24)
+    Signal strength changed for wifi: (bssid: BC:F2:AF:AF:19:A2, ssid: devolo-bcf2afaf19a2, last seen: 1408955257, mode: Mode::infrastructure, frequency: 2462, strength: 73)
+
+# Trust Store Integration
+
+Please note that we are assuming a freshly wiped system for testing
+here. If you cannot fulfill that pre-condition, please run `rm -rf
+/home/phablet/.local/share/UbuntuLocationService && sudo shutdown -r` prior to running the
+tests:
+
+## Unconfined
+
+ - Open the browser, go to maps.google.com
+ - Observe the in-browser dialog asking for granting access to location.
+
+## Confined Web-App
+ 
+ - Open the Nokia Here web app, observe the trust dialog appearing.
+
+## Confined Application
+
+ - Open osmtouch and observe the osmtouch surface sliding up, presenting you with a trust dialog.

=== added file 'doc/tips_n_tricks.md'
--- doc/tips_n_tricks.md	1970-01-01 00:00:00 +0000
+++ doc/tips_n_tricks.md	2016-04-01 06:55:25 +0000
@@ -0,0 +1,21 @@
+# Tips'n'Tricks
+
+## Mark HERE license as accepted from cmdline
+
+    sudo LC_ALL=C gdbus call --system --dest org.freedesktop.Accounts --object-path /org/freedesktop/Accounts/User32011 --method org.freedesktop.DBus.Properties.Set com.ubuntu.location.providers.here.AccountsService LicenseAccepted '<true>'
+
+## Force startup after ofono and NM are started
+
+This is a *workaround* to get connectivity API to collect; mount your
+system read-write and edit
+/etc/init/ubuntu-location-provider-here-slpgwd.conf:
+
+    sudo mount -o remount,rw /
+    sudo vi /etc/init/ubuntu-location-provider-here-slpgwd.conf
+
+change: `start on started dbus and (started ofono or started network-manager)`
+to: `start on started dbus and started ofono and started network-manager`
+
+    sudo mount -o remount,ro /
+    sync
+    sudo reboot

=== modified file 'examples/service/service.cpp'
--- examples/service/service.cpp	2014-11-14 11:26:45 +0000
+++ examples/service/service.cpp	2016-04-01 06:55:25 +0000
@@ -99,7 +99,10 @@
     auto selected_providers = options.value_for_key<std::vector<std::string>>("provider");
 
     std::map<std::string, cul::ProviderFactory::Configuration> config_lut;
-    std::set<cul::Provider::Ptr> instantiated_providers;
+
+    culs::DefaultConfiguration config;
+    auto settings = std::make_shared<cul::BoostPtreeSettings>(options.value_for_key<std::string>("config-file"));
+    auto engine = config.the_engine(std::set<cul::Provider::Ptr>{}, config.the_provider_selection_policy(), settings);
 
     for (const std::string& provider : selected_providers)
     {
@@ -129,15 +132,15 @@
 
         try
         {
-            auto p = cul::ProviderFactory::instance().create_provider_for_name_with_config(
-                provider, 
-                config_lut[provider]);
-
-            if (p)
-                instantiated_providers.insert(p);
-            else
-                throw std::runtime_error("Problem instantiating provider");
-            
+            auto result = std::async(std::launch::async, [provider, config_lut, engine] {
+                return cul::ProviderFactory::instance().create_provider_for_name_with_config(
+                    provider,
+                    config_lut.at(provider),
+                    [engine](cul::Provider::Ptr provider)
+                    {
+                        engine->add_provider(provider);
+                    });
+            });
         } catch(const std::runtime_error& e)
         {
             std::cerr << "Exception instantiating provider: " << e.what() << " ... Aborting now." << std::endl;
@@ -163,15 +166,11 @@
     };
     outgoing->install_executor(dbus::asio::make_executor(outgoing));
 
-    auto settings = std::make_shared<cul::BoostPtreeSettings>(options.value_for_key<std::string>("config-file"));
-
-    culs::DefaultConfiguration config;
-
     culs::Implementation::Configuration configuration
     {
         incoming,
         outgoing,
-        config.the_engine(instantiated_providers, config.the_provider_selection_policy(), settings),
+        engine,
         config.the_permission_manager(incoming),
         culs::Harvester::Configuration
         {

=== modified file 'include/location_service/com/ubuntu/location/provider_factory.h'
--- include/location_service/com/ubuntu/location/provider_factory.h	2014-10-27 21:58:16 +0000
+++ include/location_service/com/ubuntu/location/provider_factory.h	2016-04-01 06:55:25 +0000
@@ -54,6 +54,9 @@
     // --provider=remote::Provider@gps --remote::Provider@gps::name="com.ubuntu.android.gps.Provider" --remote::Provider@gps::path="/com/ubuntu/android/gps/Provider"
     Provider::Ptr create_provider_for_name_with_config(const std::string& name, const Configuration& config);
 
+    // Async version of above.
+    void create_provider_for_name_with_config(const std::string& name, const Configuration& config, const std::function<void(Provider::Ptr)>& cb);
+
     void enumerate(const std::function<void(const std::string&, const Factory&)>& enumerator);
 
   private:

=== modified file 'po/ubuntu-location-service.pot'
--- po/ubuntu-location-service.pot	2014-09-19 09:06:30 +0000
+++ po/ubuntu-location-service.pot	2016-04-01 06:55:25 +0000
@@ -1,13 +1,14 @@
-# Copyright (C) 2014 Canonical Ltd.
-# This file is distributed under the same license as the ubuntu-location-service package.
-# Thomas Voß <[e-mail]>, 2014.
+# SOME DESCRIPTIVE TITLE.
+# Copyright (C) YEAR Canonical Ltd.
+# This file is distributed under the same license as the PACKAGE package.
+# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
 #
 #, fuzzy
 msgid ""
 msgstr ""
 "Project-Id-Version: ubuntu-location-service\n"
 "Report-Msgid-Bugs-To: \n"
-"POT-Creation-Date: 2014-09-19 01:04+0200\n"
+"POT-Creation-Date: 2015-11-27 14:07+0100\n"
 "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
 "Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
 "Language-Team: LANGUAGE <[e-mail]>\n"
@@ -16,11 +17,6 @@
 "Content-Type: text/plain; charset=CHARSET\n"
 "Content-Transfer-Encoding: 8bit\n"
 
-#: /tmp/i18n/src/location_service/com/ubuntu/location/service/trust_store_permission_manager.cpp:170
-msgid "An unconfined application wants to access your current location."
-msgstr ""
-
-#: /tmp/i18n/src/location_service/com/ubuntu/location/service/trust_store_permission_manager.cpp:173
-#, boost-format
-msgid "%1% wants to access your current location."
+#: /home/tvoss/ubuntu/scratch/fix-prompt-string/src/location_service/com/ubuntu/location/service/trust_store_permission_manager.cpp:149
+msgid "wants to access your current location."
 msgstr ""

=== modified file 'src/location_service/com/ubuntu/location/CMakeLists.txt'
--- src/location_service/com/ubuntu/location/CMakeLists.txt	2015-04-23 14:48:44 +0000
+++ src/location_service/com/ubuntu/location/CMakeLists.txt	2016-04-01 06:55:25 +0000
@@ -1,3 +1,7 @@
+if (UBUNTU_PLATFORM_HARDWARE_API_FOUND)
+  add_definitions(-DCOM_UBUNTU_LOCATION_SERVICE_HAVE_UBUNTU_PLATFORM_HARDWARE_API)
+endif()
+
 if (NET_CPP_FOUND)
   add_definitions(-DCOM_UBUNTU_LOCATION_SERVICE_HAVE_NET_CPP=1)
 
@@ -10,6 +14,8 @@
   service/config.h.in ${CMAKE_CURRENT_BINARY_DIR}/service/config.h @ONLY
 )
 
+include_directories(${UBUNTU_PLATFORM_HARDWARE_API_INCLUDE_DIRS})
+
 add_library(
   ubuntu-location-service SHARED
 
@@ -29,6 +35,7 @@
   settings.cpp
   time_based_update_policy.cpp
   set_name_for_thread.cpp
+  time_since_boot.cpp
   wifi_and_cell_reporting_state.cpp
 
   boost_ptree_settings.cpp
@@ -38,6 +45,7 @@
   service/harvester.cpp
   service/demultiplexing_reporter.h
   service/demultiplexing_reporter.cpp
+  service/runtime.cpp
   service/runtime_tests.h
   service/runtime_tests.cpp
   service/trust_store_permission_manager.cpp
@@ -125,6 +133,7 @@
   ${LIBAPPARMOR_LDFLAGS}
   ${NET_CPP_LDFLAGS}
   ${TRUST_STORE_LDFLAGS}
+  ${UBUNTU_PLATFORM_HARDWARE_API_LDFLAGS}
   ${GLog_LIBRARY}
   ${GFlags_LIBRARY}
 )

=== modified file 'src/location_service/com/ubuntu/location/connectivity/cached_wireless_network.cpp'
--- src/location_service/com/ubuntu/location/connectivity/cached_wireless_network.cpp	2015-05-28 10:57:24 +0000
+++ src/location_service/com/ubuntu/location/connectivity/cached_wireless_network.cpp	2016-04-01 06:55:25 +0000
@@ -123,7 +123,14 @@
         const org::freedesktop::NetworkManager::Device& device,
         const org::freedesktop::NetworkManager::AccessPoint& ap)
     : device_(device),
-      access_point_(ap)
+      access_point_(ap),
+      connections
+      {
+          access_point_.properties_changed->connect([this](const std::map<std::string, core::dbus::types::Variant>& dict)
+          {
+              on_access_point_properties_changed(dict);
+          })
+      }
 {
     last_seen_ = translate_time_stamp(access_point_.last_seen->get());
 
@@ -138,12 +145,11 @@
     {
         static_cast<int>(access_point_.strength->get())
     };
+}
 
-    // Wire up all the connections
-    access_point_.properties_changed->connect([this](const std::map<std::string, core::dbus::types::Variant>& dict)
-    {
-        on_access_point_properties_changed(dict);
-    });
+detail::CachedWirelessNetwork::~CachedWirelessNetwork()
+{
+    access_point_.properties_changed->disconnect(connections.ap_properties_changed);
 }
 
 void detail::CachedWirelessNetwork::on_access_point_properties_changed(const std::map<std::string, core::dbus::types::Variant>& dict)

=== modified file 'src/location_service/com/ubuntu/location/connectivity/cached_wireless_network.h'
--- src/location_service/com/ubuntu/location/connectivity/cached_wireless_network.h	2014-08-14 20:25:22 +0000
+++ src/location_service/com/ubuntu/location/connectivity/cached_wireless_network.h	2016-04-01 06:55:25 +0000
@@ -41,6 +41,8 @@
             const org::freedesktop::NetworkManager::Device& device,
             const org::freedesktop::NetworkManager::AccessPoint& ap);
 
+    ~CachedWirelessNetwork();
+
     // Timestamp when the network became visible.
     const core::Property<std::chrono::system_clock::time_point>& last_seen() const override;
 
@@ -67,6 +69,16 @@
     // The actual access point stub.
     org::freedesktop::NetworkManager::AccessPoint access_point_;
 
+    // Encapsulates all event connections that have to be cut on destruction.
+    struct
+    {
+        core::dbus::Signal
+        <
+            org::freedesktop::NetworkManager::AccessPoint::PropertiesChanged,
+            org::freedesktop::NetworkManager::AccessPoint::PropertiesChanged::ArgumentType
+        >::SubscriptionToken ap_properties_changed;
+    } connections;
+
     core::Property<std::chrono::system_clock::time_point> last_seen_;
     core::Property<std::string> bssid_;
     core::Property<std::string> ssid_;

=== modified file 'src/location_service/com/ubuntu/location/connectivity/ofono_nm_connectivity_manager.cpp'
--- src/location_service/com/ubuntu/location/connectivity/ofono_nm_connectivity_manager.cpp	2015-05-27 18:40:37 +0000
+++ src/location_service/com/ubuntu/location/connectivity/ofono_nm_connectivity_manager.cpp	2016-04-01 06:55:25 +0000
@@ -595,7 +595,7 @@
 
     xdg::NetworkManager::AccessPoint ap
     {
-        network_manager->service->add_object_for_path(ap_path)
+        network_manager->service->object_for_path(ap_path)
     };
 
     auto wifi = std::make_shared<detail::CachedWirelessNetwork>(itd->second, ap);

=== modified file 'src/location_service/com/ubuntu/location/engine.cpp'
--- src/location_service/com/ubuntu/location/engine.cpp	2015-04-23 14:48:44 +0000
+++ src/location_service/com/ubuntu/location/engine.cpp	2016-04-01 06:55:25 +0000
@@ -97,10 +97,7 @@
                 Configuration::Keys::engine_state,
                 Configuration::Defaults::engine_state);
 
-    configuration.satellite_based_positioning_state =
-            settings->get_enum_for_key<SatelliteBasedPositioningState>(
-                Configuration::Keys::satellite_based_positioning_state,
-                Configuration::Defaults::satellite_based_positioning_state);
+    configuration.satellite_based_positioning_state = Configuration::Defaults::satellite_based_positioning_state;
 
     configuration.wifi_and_cell_id_reporting_state =
             settings->get_enum_for_key<WifiAndCellIdReportingState>(
@@ -110,12 +107,7 @@
     configuration.engine_state.changed().connect([this](const Engine::Status& status)
     {
         Engine::settings->set_enum_for_key<Engine::Status>(Configuration::Keys::engine_state, status);
-    });
-
-    configuration.satellite_based_positioning_state.changed().connect([this](SatelliteBasedPositioningState state)
-    {
-        Engine::settings->set_enum_for_key<SatelliteBasedPositioningState>(Configuration::Keys::satellite_based_positioning_state, state);
-    });
+    });    
 
     configuration.wifi_and_cell_id_reporting_state.changed().connect([this](WifiAndCellIdReportingState state)
     {
@@ -129,10 +121,6 @@
         Configuration::Keys::engine_state,
         configuration.engine_state);
 
-    settings->set_enum_for_key<SatelliteBasedPositioningState>(
-        Configuration::Keys::satellite_based_positioning_state,
-        configuration.satellite_based_positioning_state);
-
     settings->set_enum_for_key<WifiAndCellIdReportingState>(
         Configuration::Keys::wifi_and_cell_id_reporting_state,
         configuration.wifi_and_cell_id_reporting_state);
@@ -169,19 +157,28 @@
 
     // We wire up changes in the engine's configuration to the respective slots
     // of the provider.
-    auto cp = updates.reference_location.changed().connect([provider](const cul::Update<cul::Position>& pos)
-    {
-        provider->on_reference_location_updated(pos);
-    });
-
-    auto cv = updates.reference_velocity.changed().connect([provider](const cul::Update<cul::Velocity>& velocity)
-    {
-        provider->on_reference_velocity_updated(velocity);
-    });
-
-    auto ch = updates.reference_heading.changed().connect([provider](const cul::Update<cul::Heading>& heading)
-    {
-        provider->on_reference_heading_updated(heading);
+    auto cp = updates.last_known_location.changed().connect([provider](const cul::Optional<cul::Update<cul::Position>>& pos)
+    {
+        if (pos)
+        {
+            provider->on_reference_location_updated(pos.get());
+        }
+    });
+
+    auto cv = updates.last_known_velocity.changed().connect([provider](const cul::Optional<cul::Update<cul::Velocity>>& velocity)
+    {
+        if (velocity)
+        {
+            provider->on_reference_velocity_updated(velocity.get());
+        }
+    });
+
+    auto ch = updates.last_known_heading.changed().connect([provider](const cul::Optional<cul::Update<cul::Heading>>& heading)
+    {
+        if (heading)
+        {
+            provider->on_reference_heading_updated(heading.get());
+        }
     });
 
     auto cr = configuration.wifi_and_cell_id_reporting_state.changed().connect([provider](cul::WifiAndCellIdReportingState state)
@@ -207,7 +204,7 @@
     // We should come up with a better heuristic here.
     auto cpr = provider->updates().position.connect([this](const cul::Update<cul::Position>& src)
     {
-        updates.reference_location = update_policy->verify_update(src);
+        updates.last_known_location = update_policy->verify_update(src);
     });
 
     std::lock_guard<std::mutex> lg(guard);

=== modified file 'src/location_service/com/ubuntu/location/engine.h'
--- src/location_service/com/ubuntu/location/engine.h	2015-04-23 14:48:44 +0000
+++ src/location_service/com/ubuntu/location/engine.h	2016-04-01 06:55:25 +0000
@@ -127,11 +127,11 @@
     struct Updates
     {
         /** The current best known reference location */
-        core::Property<Update<Position>> reference_location{};
+        core::Property<Optional<Update<Position>>> last_known_location{};
         /** The current best known velocity estimate. */
-        core::Property<Update<Velocity>> reference_velocity{};
+        core::Property<Optional<Update<Velocity>>> last_known_velocity{};
         /** The current best known heading estimate. */
-        core::Property<Update<Heading>> reference_heading{};
+        core::Property<Optional<Update<Heading>>> last_known_heading{};
         /** The current set of visible SpaceVehicles. */
         core::Property<std::map<SpaceVehicle::Key, SpaceVehicle>> visible_space_vehicles{};
     };

=== modified file 'src/location_service/com/ubuntu/location/provider_factory.cpp'
--- src/location_service/com/ubuntu/location/provider_factory.cpp	2014-10-27 21:58:16 +0000
+++ src/location_service/com/ubuntu/location/provider_factory.cpp	2016-04-01 06:55:25 +0000
@@ -52,6 +52,20 @@
     return cul::Provider::Ptr{factory_store.at(undecorated_name)(config)};
 }
 
+void cul::ProviderFactory::create_provider_for_name_with_config(
+    const std::string& name,
+    const cul::ProviderFactory::Configuration& config,
+    const std::function<void(Provider::Ptr)>& cb)
+{
+    auto undecorated_name = name.substr(0, name.find("@"));
+
+    std::lock_guard<std::mutex> lg(guard);
+    if (factory_store.count(undecorated_name) == 0)
+        return;
+
+    cb(cul::Provider::Ptr{factory_store.at(undecorated_name)(config)});
+}
+
 void cul::ProviderFactory::enumerate(
     const std::function<void(const std::string&, const cul::ProviderFactory::Factory&)>& enumerator)
 {

=== modified file 'src/location_service/com/ubuntu/location/providers/config.cpp'
--- src/location_service/com/ubuntu/location/providers/config.cpp	2014-09-15 08:58:50 +0000
+++ src/location_service/com/ubuntu/location/providers/config.cpp	2016-04-01 06:55:25 +0000
@@ -19,6 +19,7 @@
 #include <com/ubuntu/location/provider_factory.h>
 
 #include "dummy/provider.h"
+#include "dummy/delayed_provider.h"
 
 #include <map>
 
@@ -41,6 +42,12 @@
     com::ubuntu::location::providers::dummy::Provider::create_instance
 };
 
+static FactoryInjector dummy_delayed_injector
+{
+    "dummy::DelayedProvider",
+    com::ubuntu::location::providers::dummy::DelayedProvider::create_instance
+};
+
 #include <com/ubuntu/location/providers/remote/provider.h>
 static FactoryInjector remote_injector
 {

=== modified file 'src/location_service/com/ubuntu/location/providers/dummy/CMakeLists.txt'
--- src/location_service/com/ubuntu/location/providers/dummy/CMakeLists.txt	2014-02-07 17:16:49 +0000
+++ src/location_service/com/ubuntu/location/providers/dummy/CMakeLists.txt	2016-04-01 06:55:25 +0000
@@ -2,7 +2,9 @@
   dummy
   
   provider.h
-  provider.cpp)
+  provider.cpp
+  delayed_provider.h
+  delayed_provider.cpp)
 
 set(
   ENABLED_PROVIDER_TARGETS

=== added file 'src/location_service/com/ubuntu/location/providers/dummy/delayed_provider.cpp'
--- src/location_service/com/ubuntu/location/providers/dummy/delayed_provider.cpp	1970-01-01 00:00:00 +0000
+++ src/location_service/com/ubuntu/location/providers/dummy/delayed_provider.cpp	2016-04-01 06:55:25 +0000
@@ -0,0 +1,42 @@
+/*
+ * Copyright © 2015 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Scott Sweeny <[e-mail]>
+ */
+
+#include <com/ubuntu/location/logging.h>
+
+#include <chrono>
+#include <thread>
+
+#include "delayed_provider.h"
+
+namespace location = com::ubuntu::location;
+namespace dummy = com::ubuntu::location::providers::dummy;
+
+std::string dummy::DelayedProvider::class_name()
+{
+    return "dummy::DelayedProvider";
+}
+
+location::Provider::Ptr dummy::DelayedProvider::create_instance(const ProviderFactory::Configuration& config)
+{
+    int delay = config.get(dummy::DelayConfiguration::Keys::delay, 0);
+    VLOG(1) << __PRETTY_FUNCTION__ << ": delay for " << delay << "ms";
+
+    std::this_thread::sleep_for(std::chrono::milliseconds{delay});
+
+    return dummy::Provider::create_instance(config);
+}

=== added file 'src/location_service/com/ubuntu/location/providers/dummy/delayed_provider.h'
--- src/location_service/com/ubuntu/location/providers/dummy/delayed_provider.h	1970-01-01 00:00:00 +0000
+++ src/location_service/com/ubuntu/location/providers/dummy/delayed_provider.h	2016-04-01 06:55:25 +0000
@@ -0,0 +1,62 @@
+/*
+ * Copyright © 2015 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Scott Sweeny <[e-mail]>
+ */
+
+#ifndef LOCATION_SERVICE_COM_UBUNTU_LOCATION_PROVIDERS_DUMMY_DELAYED_PROVIDER_H_
+#define LOCATION_SERVICE_COM_UBUNTU_LOCATION_PROVIDERS_DUMMY_DELAYED_PROVIDER_H_
+
+#include "provider.h"
+
+namespace com
+{
+namespace ubuntu
+{
+namespace location
+{
+namespace providers
+{
+namespace dummy
+{
+    struct DelayConfiguration
+    {
+        struct Keys
+        {
+            static constexpr const char* delay
+            {
+                "DelayInMs"
+            };
+        };
+    };
+
+class DelayedProvider : public Provider
+{
+    public:
+        // For integration with the Provider factory
+        static std::string class_name();
+        // Waits for "DelayInMs" from the provided property bundle then
+        // instantiates a new provider instance, populating the configuration object
+        // from the provided property bundle.
+        static DelayedProvider::Ptr create_instance(const ProviderFactory::Configuration&);
+        // Creates a new provider instance from the given configuration.
+        DelayedProvider(const Configuration config = Configuration{});
+};
+}
+}
+}
+}
+}
+#endif // LOCATION_SERVICE_COM_UBUNTU_LOCATION_PROVIDERS_DUMMY_DELAYED_PROVIDER_H_

=== modified file 'src/location_service/com/ubuntu/location/providers/gps/CMakeLists.txt'
--- src/location_service/com/ubuntu/location/providers/gps/CMakeLists.txt	2014-07-28 19:14:58 +0000
+++ src/location_service/com/ubuntu/location/providers/gps/CMakeLists.txt	2016-04-01 06:55:25 +0000
@@ -4,30 +4,34 @@
     ON
 )
 
-if (LOCATION_SERVICE_ENABLE_GPS_PROVIDER)
-  find_file(
-    UBUNTU_HARDWARE_GPS_H gps.h
-    NAMES ubuntu/hardware/gps.h
-  )
-
-  if (UBUNTU_HARDWARE_GPS_H)
+if ((LOCATION_SERVICE_ENABLE_GPS_PROVIDER) AND (UBUNTU_PLATFORM_HARDWARE_API_FOUND))
     message(STATUS "Enabling GPS location provider")
 
+    include_directories(${UBUNTU_PLATFORM_HARDWARE_API_INCLUDE_DIRS})
+
     add_library(
         gps
 
         gps.conf
 
+        hardware_abstraction_layer.cpp
+
         android_hardware_abstraction_layer.h
         android_hardware_abstraction_layer.cpp
 
+        sntp_reference_time_source.h
+        sntp_reference_time_source.cpp
+
+        sntp_client.h
+        sntp_client.cpp
+
         hardware_abstraction_layer.h
         # hardware_abstraction_layer.cpp
 
         provider.h
         provider.cpp)
 
-    target_link_libraries(gps ubuntu_platform_hardware_api.so)
+    target_link_libraries(gps ${UBUNTU_PLATFORM_HARDWARE_API_LDFLAGS})
   
     set(
       ENABLED_PROVIDER_TARGETS
@@ -41,5 +45,4 @@
     )
 
     install(FILES gps.conf DESTINATION /etc/)
-  endif (UBUNTU_HARDWARE_GPS_H)
-endif (LOCATION_SERVICE_ENABLE_GPS_PROVIDER)
+endif ()

=== modified file 'src/location_service/com/ubuntu/location/providers/gps/android_hardware_abstraction_layer.cpp'
--- src/location_service/com/ubuntu/location/providers/gps/android_hardware_abstraction_layer.cpp	2014-10-27 21:58:16 +0000
+++ src/location_service/com/ubuntu/location/providers/gps/android_hardware_abstraction_layer.cpp	2016-04-01 06:55:25 +0000
@@ -17,6 +17,7 @@
  */
 
 #include "android_hardware_abstraction_layer.h"
+#include "sntp_reference_time_source.h"
 
 #if defined(COM_UBUNTU_LOCATION_SERVICE_HAVE_NET_CPP)
 #include "net_cpp_gps_xtra_downloader.h"
@@ -66,8 +67,6 @@
     if (config.count("XTRA_SERVER_3") > 0)
         result.xtra_hosts.push_back(config.get<std::string>("XTRA_SERVER_3"));
 
-    result.timeout = std::chrono::milliseconds{1500};
-
     return result;
 }
 
@@ -325,23 +324,18 @@
 {
     VLOG(1) << __PRETTY_FUNCTION__;
 
-    auto thiz = static_cast<android::HardwareAbstractionLayer*>(context);
-
-    if (thiz->impl.utc_time_request_handler)
-    {
-        thiz->impl.utc_time_request_handler();
-    } else
-    {
-        auto now = location::Clock::now().time_since_epoch();
-        auto thiz = static_cast<android::HardwareAbstractionLayer*>(context);
-
-        static const int zero_uncertainty = 0;
-
-        u_hardware_gps_inject_time(
-                    thiz->impl.gps_handle,
-                    now.count(),
-                    now.count(),
-                    zero_uncertainty);
+    try
+    {
+        if (auto thiz = static_cast<android::HardwareAbstractionLayer*>(context))
+            thiz->inject_reference_time(thiz->impl.reference_time_source->sample());
+    }
+    catch (const std::runtime_error& e)
+    {
+        LOG(WARNING) << "Failed to inject reference time to chipset: " << e.what();
+    }
+    catch (...)
+    {
+        LOG(WARNING) << "Failed to inject reference time to chipset.";
     }
 }
 
@@ -536,19 +530,22 @@
     return true;
 }
 
-bool android::HardwareAbstractionLayer::inject_reference_time(
-        const std::chrono::microseconds& reference_time,
-        const std::chrono::microseconds& sample_time)
+bool android::HardwareAbstractionLayer::inject_reference_time(const ReferenceTimeSample& sample)
 {
     if (!is_capable_of(gps::Capability::on_demand_time_injection))
         return false;
 
     // TODO(tvoss): We should expose the int return type of the underyling
     //  Android HAL to capture errors here.
+    //
+    // Please see:
+    //   http://androidxref.com/5.1.1_r6/xref/frameworks/base/core/java/android/net/SntpClient.java#72
+    // for the bloody details of relating the system wall clock time to the elapsed realtime since boot
+    // including deep sleep.
     u_hardware_gps_inject_time(impl.gps_handle,
-                               reference_time.count(),
-                               sample_time.count(),
-                               10);
+                               sample.since_epoch.count(),
+                               sample.since_boot.count(),
+                               sample.uncertainty.count());
     return true;
 }
 
@@ -559,6 +556,7 @@
       assistance_mode(gps::AssistanceMode::mobile_station_based),
       position_mode(gps::PositionMode::periodic),
       supl_assistant(*parent),
+      reference_time_source(configuration.reference_time_source),
       gps_xtra_configuration(configuration.gps_xtra.configuration),
       gps_xtra_downloader(configuration.gps_xtra.downloader)
 {
@@ -617,6 +615,22 @@
 
 namespace
 {
+gps::SntpReferenceTimeSource::Configuration sntp_reference_time_source_configuration(std::istream& in)
+{
+    gps::SntpReferenceTimeSource::Configuration config;
+
+    try
+    {
+        config = gps::SntpReferenceTimeSource::Configuration::from_gps_conf_ini_file(in);
+    }
+    catch (...)
+    {
+        // Consciously dropping all exceptions here.
+    }
+
+    return config;
+}
+
 android::GpsXtraDownloader::Configuration gps_xtra_downloader_configuration(std::istream& in)
 {
     android::GpsXtraDownloader::Configuration config;
@@ -643,6 +657,8 @@
 
     return config;
 }
+
+
 }
 
 std::shared_ptr<gps::HardwareAbstractionLayer> gps::HardwareAbstractionLayer::create_default_instance()
@@ -666,7 +682,8 @@
         {
             create_xtra_downloader(),
             gps_xtra_downloader_configuration((in_system_gps_conf ? in_system_gps_conf : in_gps_conf))
-        }
+        },
+        std::make_shared<gps::SntpReferenceTimeSource>(sntp_reference_time_source_configuration((in_system_gps_conf ? in_system_gps_conf : in_gps_conf)))
     };
 
     static std::shared_ptr<gps::HardwareAbstractionLayer> instance

=== modified file 'src/location_service/com/ubuntu/location/providers/gps/android_hardware_abstraction_layer.h'
--- src/location_service/com/ubuntu/location/providers/gps/android_hardware_abstraction_layer.h	2015-04-22 13:30:04 +0000
+++ src/location_service/com/ubuntu/location/providers/gps/android_hardware_abstraction_layer.h	2016-04-01 06:55:25 +0000
@@ -19,6 +19,7 @@
 #define LOCATION_SERVICE_COM_UBUNTU_LOCATION_PROVIDERS_GPS_ANDROID_HARDWARE_ABSTRACTION_LAYER_H_
 
 #include <com/ubuntu/location/providers/gps/hardware_abstraction_layer.h>
+#include <com/ubuntu/location/providers/gps/sntp_client.h>
 
 #include <ubuntu/hardware/gps.h>
 
@@ -49,7 +50,7 @@
         /** @brief Timeout on gps xtra download operations. */
         std::chrono::milliseconds timeout
         {
-            5000
+            30000
         };
 
         /** Set of hosts serving GPS xtra data. */
@@ -66,7 +67,24 @@
 };
 
 struct HardwareAbstractionLayer : public gps::HardwareAbstractionLayer
-{
+{    
+    /** @brief A ReferenceTimeSource provides samples of an arbitrary reference time source. */
+    class ReferenceTimeSource
+    {
+    public:
+        /** @cond */
+        typedef std::shared_ptr<ReferenceTimeSource> Ptr;
+
+        virtual ~ReferenceTimeSource() = default;
+        /** @endcond */
+
+        /** @brief sample returns a sample of the current ReferenceTimeSource. */
+        virtual ReferenceTimeSample sample() = 0;
+
+    protected:
+        ReferenceTimeSource() = default;
+    };
+
     /** @brief Implements gps::HardwareAbstractionLayer::SuplAssistant interface for the android gps HAL. */
     struct SuplAssistant : public gps::HardwareAbstractionLayer::SuplAssistant
     {
@@ -186,6 +204,8 @@
             std::shared_ptr<GpsXtraDownloader> downloader;
             GpsXtraDownloader::Configuration configuration;
         } gps_xtra;
+
+        ReferenceTimeSource::Ptr reference_time_source;
     };
 
     HardwareAbstractionLayer(const Configuration& configuration);
@@ -227,8 +247,8 @@
     bool set_position_mode(gps::PositionMode mode) override;
 
     bool inject_reference_position(const location::Position& position) override;
-    bool inject_reference_time(const std::chrono::microseconds& reference_time,
-                               const std::chrono::microseconds& sample_time) override;
+    bool inject_reference_time(const ReferenceTimeSample& sample) override;
+
     struct Impl
     {
         // Bootstraps access to the GPS chipset, wiring up all callbacks.
@@ -252,8 +272,8 @@
         // An implementation of the gps::HardwareAbstractionLayer::SuplAssistant interface.
         SuplAssistant supl_assistant;
 
-        // Callback for handling utc time requests.
-        gps::HardwareAbstractionLayer::UtcTimeRequestHandler utc_time_request_handler;
+        // An implementation of ReferenceTimeSource.
+        ReferenceTimeSource::Ptr reference_time_source;
 
         // Emitted whenever the set of visible space vehicles changes.
         core::Signal<std::set<location::SpaceVehicle>> space_vehicle_updates;

=== added file 'src/location_service/com/ubuntu/location/providers/gps/hardware_abstraction_layer.cpp'
--- src/location_service/com/ubuntu/location/providers/gps/hardware_abstraction_layer.cpp	1970-01-01 00:00:00 +0000
+++ src/location_service/com/ubuntu/location/providers/gps/hardware_abstraction_layer.cpp	2016-04-01 06:55:25 +0000
@@ -0,0 +1,30 @@
+/*
+ * Copyright © 2012-2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Thomas Voß <[e-mail]>
+ */
+
+#include <com/ubuntu/location/providers/gps/hardware_abstraction_layer.h>
+
+#include <iostream>
+
+namespace gps = com::ubuntu::location::providers::gps;
+
+std::ostream& gps::operator<<(std::ostream& out, const gps::HardwareAbstractionLayer::ReferenceTimeSample& sample)
+{
+    return out << "[since epoch: "  << sample.since_epoch.count() << " [ms], since boot: "
+                                    << sample.since_boot.count() << " [ms], uncertainty: "
+                                    << sample.uncertainty.count() << " [ms]";
+}

=== modified file 'src/location_service/com/ubuntu/location/providers/gps/hardware_abstraction_layer.h'
--- src/location_service/com/ubuntu/location/providers/gps/hardware_abstraction_layer.h	2014-06-06 17:52:59 +0000
+++ src/location_service/com/ubuntu/location/providers/gps/hardware_abstraction_layer.h	2016-04-01 06:55:25 +0000
@@ -18,6 +18,7 @@
 #ifndef LOCATION_SERVICE_COM_UBUNTU_LOCATION_PROVIDERS_GPS_HARDWARE_ABSTRACTION_LAYER_H_
 #define LOCATION_SERVICE_COM_UBUNTU_LOCATION_PROVIDERS_GPS_HARDWARE_ABSTRACTION_LAYER_H_
 
+#include <com/ubuntu/location/clock.h>
 #include <com/ubuntu/location/heading.h>
 #include <com/ubuntu/location/position.h>
 #include <com/ubuntu/location/space_vehicle.h>
@@ -104,6 +105,13 @@
 class HardwareAbstractionLayer
 {
 public:
+    /** @brief ReferenceTimeSample bundles together the local reference. */
+    struct ReferenceTimeSample
+    {
+        std::chrono::milliseconds since_epoch;  /**< Reference wall-clock time since the epoch (UTC). */
+        std::chrono::milliseconds since_boot;   /**< Reference time since boot. */
+        std::chrono::milliseconds uncertainty;  /**< Uncertainty estimate of the sample. */
+    };
 
     class SuplAssistant
     {
@@ -304,16 +312,17 @@
 
     /**
      * @brief Injects a new reference time to the underlying gps driver/chipset.
-     * @param reference_time The new reference time.
-     * @param sample_time When the reference time was sampled.
+     * @param sample The reference time sample
      * @return true iff the injection was successful, false otherwise.
      */
-    virtual bool inject_reference_time(const std::chrono::microseconds& reference_time,
-                                       const std::chrono::microseconds& sample_time) = 0;
+    virtual bool inject_reference_time(const ReferenceTimeSample& sample) = 0;
 
 protected:
     HardwareAbstractionLayer() = default;
 };
+
+/** @brief operator<< inserts sample into out. */
+std::ostream& operator<<(std::ostream& out, const HardwareAbstractionLayer::ReferenceTimeSample& sample);
 }
 }
 }

=== added file 'src/location_service/com/ubuntu/location/providers/gps/sntp_client.cpp'
--- src/location_service/com/ubuntu/location/providers/gps/sntp_client.cpp	1970-01-01 00:00:00 +0000
+++ src/location_service/com/ubuntu/location/providers/gps/sntp_client.cpp	2016-04-01 06:55:25 +0000
@@ -0,0 +1,210 @@
+/*
+ * Copyright © 2012-2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Thomas Voß <[e-mail]>
+ */
+
+#include <com/ubuntu/location/providers/gps/sntp_client.h>
+
+#include <com/ubuntu/location/time_since_boot.h>
+
+#include <boost/asio/ip/udp.hpp>
+#include <boost/endian/buffers.hpp>
+
+#include <bitset>
+#include <fstream>
+#include <future>
+#include <iostream>
+#include <thread>
+
+namespace location = com::ubuntu::location;
+namespace gps = location::providers::gps;
+namespace ip = boost::asio::ip;
+
+namespace
+{
+
+template<typename T>
+T sync_or_throw(std::future<T>& f)
+{
+    return f.get();
+}
+
+template<>
+void sync_or_throw<>(std::future<void>& f)
+{
+    f.get();
+}
+
+struct Now
+{
+    std::chrono::nanoseconds time = std::chrono::duration_cast<std::chrono::milliseconds>(
+                std::chrono::system_clock::now().time_since_epoch());
+    std::chrono::nanoseconds ticks = location::time_since_boot();
+};
+}
+
+const std::chrono::seconds& gps::sntp::offset_1900_to_1970()
+{
+    static const std::uint64_t secs = ((365ull * 70ull) + 17ull) * 24ull * 60ull * 60ull;
+    static const std::chrono::seconds seconds{secs};
+    return seconds;
+}
+
+gps::sntp::LeapIndicator gps::sntp::Packet::LeapIndicatorVersionMode::leap_indicator() const
+{
+    return static_cast<LeapIndicator>((livm.value() >> 6) & 0x3);
+}
+
+gps::sntp::Packet::LeapIndicatorVersionMode& gps::sntp::Packet::LeapIndicatorVersionMode::leap_indicator(LeapIndicator li)
+{
+    livm = livm.value() | (static_cast<uint8_t>(li) << 6);
+    return *this;
+}
+
+std::uint8_t gps::sntp::Packet::LeapIndicatorVersionMode::version() const
+{
+    return (livm.value() >> 3) & 0x7;
+}
+
+gps::sntp::Packet::LeapIndicatorVersionMode& gps::sntp::Packet::LeapIndicatorVersionMode::version(std::uint8_t version)
+{
+    livm = livm.value() | (version << 3);
+    return *this;
+}
+
+gps::sntp::Mode gps::sntp::Packet::LeapIndicatorVersionMode::mode() const
+{
+    return static_cast<Mode>(livm.value() & 0x7);
+}
+
+gps::sntp::Packet::LeapIndicatorVersionMode& gps::sntp::Packet::LeapIndicatorVersionMode::mode(Mode m)
+{
+    livm = static_cast<uint8_t>(m) | livm.value();
+    return *this;
+}
+
+gps::sntp::Client::Response gps::sntp::Client::request_time(const std::string& host, const std::chrono::milliseconds& timeout, boost::asio::io_service& ios)
+{
+    ip::udp::resolver resolver{ios};
+    ip::udp::socket socket{ios};
+    bool timed_out{false};
+
+    std::promise<ip::udp::resolver::iterator> promise_resolve;
+    auto future_resolve= promise_resolve.get_future();
+
+    boost::asio::deadline_timer timer{ios};
+    timer.expires_from_now(boost::posix_time::milliseconds{timeout.count()});
+    timer.async_wait([&timed_out, &resolver, &socket](const boost::system::error_code& ec)
+    {
+        if (ec)
+            return;
+
+        timed_out = true;
+
+        resolver.cancel();
+        socket.shutdown(ip::udp::socket::shutdown_both);
+        socket.close();
+    });
+
+    ip::udp::resolver::query query{ip::udp::v4(), host, "ntp"};
+
+    resolver.async_resolve(query, [&promise_resolve](const boost::system::error_code& ec, ip::udp::resolver::iterator it)
+    {
+        if (ec)
+            promise_resolve.set_exception(std::make_exception_ptr(boost::system::system_error(ec)));
+        else
+            promise_resolve.set_value(it);
+    });
+
+    auto it = sync_or_throw(future_resolve);
+
+    std::promise<void> promise_connect;
+    auto future_connect = promise_connect.get_future();
+
+    socket.async_connect(*it, [&promise_connect](const boost::system::error_code& ec)
+    {
+        if (ec)
+            promise_connect.set_exception(std::make_exception_ptr(boost::system::system_error(ec)));
+        else
+            promise_connect.set_value();
+    });
+
+    sync_or_throw(future_connect);
+
+    sntp::Packet packet;
+
+    Now before;
+    {        
+        packet = request(socket);
+        timer.cancel();
+
+        if (timed_out)
+            throw std::runtime_error("Operation timed out.");
+    }
+    Now after;
+
+    auto originate = packet.originate.to_milliseconds_since_epoch();
+    auto receive = packet.receive.to_milliseconds_since_epoch();
+    auto transmit = packet.transmit.to_milliseconds_since_epoch();
+
+    auto rtt = after.ticks - before.ticks - (transmit - receive);
+    auto offset = ((receive - originate) + (transmit - after.time))/2;
+
+    return
+    {
+        packet,
+        std::chrono::duration_cast<std::chrono::milliseconds>(after.time + offset),
+        std::chrono::duration_cast<std::chrono::milliseconds>(after.ticks),
+        std::chrono::duration_cast<std::chrono::milliseconds>(rtt)
+    };
+}
+
+gps::sntp::Packet gps::sntp::Client::request(boost::asio::ip::udp::socket& socket)
+{
+    sntp::Packet packet;
+    packet.transmit.from_milliseconds_since_epoch(
+                std::chrono::duration_cast<std::chrono::milliseconds>(
+                    std::chrono::system_clock::now().time_since_epoch()));
+    packet.livm.mode(sntp::Mode::client).version(sntp::version);
+
+    std::promise<std::size_t> promise_send;
+    auto future_send = promise_send.get_future();
+
+    socket.async_send(boost::asio::buffer(&packet, sizeof(packet)), [&promise_send](const boost::system::error_code& ec, std::size_t transferred)
+    {
+        if (ec)
+            promise_send.set_exception(std::make_exception_ptr(boost::system::system_error(ec)));
+        else
+            promise_send.set_value(transferred);
+    });
+
+    sync_or_throw(future_send);
+
+    std::promise<std::size_t> promise_receive;
+    auto future_receive = promise_receive.get_future();
+
+    socket.async_receive(boost::asio::buffer(&packet, sizeof(packet)), [&promise_receive](const boost::system::error_code& ec, std::size_t transferred)
+    {
+        if (ec)
+            promise_receive.set_exception(std::make_exception_ptr(boost::system::system_error(ec)));
+        else
+            promise_receive.set_value(transferred);
+    });
+
+    sync_or_throw(future_receive);
+
+    return packet;
+}

=== added file 'src/location_service/com/ubuntu/location/providers/gps/sntp_client.h'
--- src/location_service/com/ubuntu/location/providers/gps/sntp_client.h	1970-01-01 00:00:00 +0000
+++ src/location_service/com/ubuntu/location/providers/gps/sntp_client.h	2016-04-01 06:55:25 +0000
@@ -0,0 +1,210 @@
+/*
+ * Copyright © 2012-2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Thomas Voß <[e-mail]>
+ */
+#ifndef LOCATION_SERVICE_COM_UBUNTU_LOCATION_PROVIDERS_GPS_SNTP_CLIENT_H_
+#define LOCATION_SERVICE_COM_UBUNTU_LOCATION_PROVIDERS_GPS_SNTP_CLIENT_H_
+
+#include <com/ubuntu/location/providers/gps/android_hardware_abstraction_layer.h>
+
+#include <boost/asio.hpp>
+#include <boost/endian/buffers.hpp>
+
+#include <chrono>
+#include <string>
+
+namespace com { namespace ubuntu { namespace location { namespace providers { namespace gps { namespace sntp {
+// Please see https://tools.ietf.org/html/rfc4330 for a discussion of sntp
+// and for a detailed explanation of the different types and algorithms.
+
+namespace detail
+{
+// enum_constant returns a compile-time constant assembled from 4 or at least
+// 3 individual characters.
+template<std::uint8_t a, std::uint8_t b, std::uint8_t c, std::uint8_t d = 0>
+constexpr uint32_t enum_constant()
+{
+    return (a << 24) | (b << 16) | (c << 8) | d;
+}
+}
+
+// offset_1900_to_1970 returns the number of seconds that elapsed between 1900 and 1970.
+const std::chrono::seconds& offset_1900_to_1970();
+
+// LeapIndicator enumerates warnings of an impending
+// leap second to be inserted/deleted in the last minute of the current
+// day.
+enum class LeapIndicator : std::uint8_t
+{
+    no_warning = 0,
+    last_minute_has_61_seconds = 1,
+    last_minute_has_59_seconds = 2,
+    alarm = 3
+};
+
+// Mode enumerates the different protocol modes.
+enum class Mode : std::uint8_t
+{
+    reserved = 0,
+    symmetric_active = 1,
+    symmetric_passive = 2,
+    client = 3,
+    server = 4,
+    broadcast = 5,
+    reserved_for_control = 6,
+    reserved_for_private_use = 7
+};
+
+// ReferenceIdentifier enumerates known references for NTP-servers
+// on stratum 0 or 1.
+enum class ReferenceIdentifier : std::uint32_t
+{
+    locl = detail::enum_constant<'L','O','C','L'>(),    // uncalibrated local clock
+    cesm = detail::enum_constant<'C','E','S','M'>(),    // calibrated Cesium clock
+    rbdm = detail::enum_constant<'R','B','D','M'>(),    // calibrated Rubidium clock
+    pps  = detail::enum_constant<'P','P','S'>(),        // calibrated quartz clock or other pulse-per-second source
+    irig = detail::enum_constant<'I','R','I','G'>(),    // Inter-Range Instrumentation Group
+    acts = detail::enum_constant<'A','C','T','S'>(),    // NIST telephone modem service
+    usno = detail::enum_constant<'U','S','N','O'>(),    // USNO telephone modem service
+    ptb  = detail::enum_constant<'P','T','B'>(),        // PTB (Germany) telephone modem service
+    tdf  = detail::enum_constant<'T','D','F'>(),        // Allouis (France) Radio 164 kHz
+    dcf  = detail::enum_constant<'D','C','F'>(),        // Mainflingen (Germany) Radio 77.5 kHz
+    msf  = detail::enum_constant<'M','S', 'F'>(),       // Rugby (UK) Radio 60 kHz
+    wwv  = detail::enum_constant<'W','W','V'>(),        // Ft. Collins (US) Radio 2.5, 5, 10, 15, 20 MHz
+    wwvb = detail::enum_constant<'W','W','V','B'>(),    // Boulder (US) Radio 60 kHz
+    wwvh = detail::enum_constant<'W','W','V','H'>(),    // Kauai Hawaii (US) Radio 2.5, 5, 10, 15 MHz
+    chu  = detail::enum_constant<'C','H','U'>(),        // Ottawa (Canada) Radio 3330, 7335, 14670 kHz
+    lorc = detail::enum_constant<'L','O','R','C'>(),    // LORAN-C radionavigation system
+    omeg = detail::enum_constant<'O','M','E','G'>(),    // OMEGA radionavigation system
+    gps  = detail::enum_constant<'G','P','S'>()         // Global Positioning Service
+};
+
+// Timestamp models a fixed-point NTP timestamp relative to 01.01.1900
+template<typename Seconds, typename FractionalSeconds = Seconds>
+struct Timestamp
+{
+    // To stay on the safe side, we only allow for the types specified below.
+    // With that, we make sure that we only ever use endian-save types.
+    static_assert(std::is_same<Seconds, boost::endian::big_int16_buf_t>::value ||
+                  std::is_same<Seconds, boost::endian::big_uint16_buf_t>::value ||
+                  std::is_same<Seconds, boost::endian::big_int32_buf_t>::value ||
+                  std::is_same<Seconds, boost::endian::big_uint32_buf_t>::value,
+                  "Timestamp<> only supports boost::endian::big_{{u}int{16,32}}_buf_t");
+
+    // from_milliseconds_since_epoch fills in seconds/fractional_seconds from
+    // ms, converting to NTP's reference time.
+    void from_milliseconds_since_epoch(const std::chrono::milliseconds& ts)
+    {
+        using s = std::chrono::seconds;
+        using ms = std::chrono::milliseconds;
+
+        auto secs = std::chrono::duration_cast<s>(ts);
+        auto msecs = std::chrono::duration_cast<ms>(ts - secs);
+
+        secs += offset_1900_to_1970();
+
+        seconds = secs.count();
+        fractional_seconds = msecs.count() * std::numeric_limits<typename FractionalSeconds::value_type>::max() + 1 / 1000;
+    }
+
+    // to_milliseconds_since_epoch returns a unix timestamp calculated from
+    // an NTP-timestamp.
+    std::chrono::milliseconds to_milliseconds_since_epoch() const
+    {
+        return std::chrono::seconds{seconds.value()} - offset_1900_to_1970() +
+               std::chrono::milliseconds{(fractional_seconds.value() * 1000) / std::numeric_limits<typename FractionalSeconds::value_type>::max()};
+    }
+
+    Seconds seconds;
+    FractionalSeconds fractional_seconds;
+};
+
+// Duration is just an alias to an sntp::Timestamp.
+template<typename T, typename U>
+using Duration = Timestamp<T, U>;
+
+// Packet models the SNTP wire format.
+struct Packet
+{
+    // LeapIndicatorVersionMode helps in handling the bitfield setup
+    // for the first byte of an sntp::Packet in a portable and endianess-safe way.
+    struct LeapIndicatorVersionMode
+    {
+        // leap_indicator extracts the LeapIndicator from the underlying data.
+        LeapIndicator leap_indicator() const;
+        // leap_indicator sets the value of the leap_indicatorin in the underyling
+        // data to li.
+        LeapIndicatorVersionMode& leap_indicator(LeapIndicator li);
+
+        // version extracts the version from the underlying data.
+        std::uint8_t version() const;
+        // version adjusts the version to version in the underlying data.
+        LeapIndicatorVersionMode& version(std::uint8_t version);
+
+        // mode extracts the mode from the underlying data.
+        Mode mode() const;
+        // mode adjusts the mode to m in the underlying data.
+        LeapIndicatorVersionMode& mode(Mode m);
+
+        boost::endian::big_uint8_buf_t livm;
+    };
+
+    LeapIndicatorVersionMode livm;
+    boost::endian::big_uint8_buf_t stratum;
+    boost::endian::big_uint8_buf_t poll_interval;
+    boost::endian::big_int8_buf_t precision;
+    Duration<boost::endian::big_int16_buf_t, boost::endian::big_uint16_buf_t> root_delay;
+    Duration<boost::endian::big_uint16_buf_t, boost::endian::big_uint16_buf_t> root_dispersion;
+    boost::endian::big_uint32_buf_t reference_identifier;
+    Timestamp<boost::endian::big_uint32_buf_t> reference;
+    Timestamp<boost::endian::big_uint32_buf_t> originate;
+    Timestamp<boost::endian::big_uint32_buf_t> receive;
+    Timestamp<boost::endian::big_uint32_buf_t> transmit;
+};
+// The SNTP version we are working with.
+static constexpr const std::uint8_t version = 3;
+
+// SntpClient provides access to querying time from an NTP server in
+// a unicast scenario.
+class Client
+{
+public:
+    // Response is returned in a request for time information.
+    struct Response
+    {
+        // The raw packet that was returned from the request.
+        sntp::Packet packet;
+        // Time computed from the NTP transaction.
+        std::chrono::milliseconds ntp_time;
+        // Reference clock value corresponding to the NTP time.
+        std::chrono::milliseconds ntp_time_reference;
+        // Round-trip time of the last NTP transaction.
+        std::chrono::milliseconds round_trip_time;
+    };
+
+    // request_time_with_timeout reaches out to the SNTP server known under host,
+    // and tries to determine the current UTC reference time. The operation aborts after
+    // timeout milliseconds.
+    //
+    // std::runtime_error is thrown in case of issues.
+    Response request_time(const std::string& host, const std::chrono::milliseconds& timeout, boost::asio::io_service& ios);
+    sntp::Packet request(boost::asio::ip::udp::socket& socket);
+};
+}
+}
+
+}}}}
+#endif // LOCATION_SERVICE_COM_UBUNTU_LOCATION_PROVIDERS_GPS_SNTP_CLIENT_H_

=== added file 'src/location_service/com/ubuntu/location/providers/gps/sntp_reference_time_source.cpp'
--- src/location_service/com/ubuntu/location/providers/gps/sntp_reference_time_source.cpp	1970-01-01 00:00:00 +0000
+++ src/location_service/com/ubuntu/location/providers/gps/sntp_reference_time_source.cpp	2016-04-01 06:55:25 +0000
@@ -0,0 +1,57 @@
+/*
+ * Copyright © 2012-2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Thomas Voß <[e-mail]>
+ */
+
+#include <com/ubuntu/location/providers/gps/sntp_reference_time_source.h>
+
+#include <com/ubuntu/location/configuration.h>
+#include <com/ubuntu/location/service/runtime.h>
+
+#include <boost/property_tree/ini_parser.hpp>
+
+#include <future>
+
+namespace location = com::ubuntu::location;
+namespace gps = com::ubuntu::location::providers::gps;
+
+gps::SntpReferenceTimeSource::Configuration gps::SntpReferenceTimeSource::Configuration::from_gps_conf_ini_file(std::istream& in)
+{
+    gps::SntpReferenceTimeSource::Configuration result;
+
+    location::Configuration config;
+    boost::property_tree::read_ini(in, config);
+
+    if (config.count("NTP_SERVER") > 0)
+        result.host = config.get<std::string>("NTP_SERVER");
+
+    return result;
+}
+gps::SntpReferenceTimeSource::SntpReferenceTimeSource(const Configuration& config)
+    : config(config)
+{
+}
+
+gps::HardwareAbstractionLayer::ReferenceTimeSample gps::SntpReferenceTimeSource::sample()
+{
+    auto rt = location::service::Runtime::create();
+    rt->start();
+
+    location::providers::gps::sntp::Client sntp_client;
+    auto result = sntp_client.request_time(config.host, config.timeout, rt->service());
+
+    return {result.ntp_time, result.ntp_time_reference, result.round_trip_time};
+}

=== added file 'src/location_service/com/ubuntu/location/providers/gps/sntp_reference_time_source.h'
--- src/location_service/com/ubuntu/location/providers/gps/sntp_reference_time_source.h	1970-01-01 00:00:00 +0000
+++ src/location_service/com/ubuntu/location/providers/gps/sntp_reference_time_source.h	2016-04-01 06:55:25 +0000
@@ -0,0 +1,51 @@
+/*
+ * Copyright © 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Thomas Voß <[e-mail]>
+ */
+#ifndef LOCATION_SERVICE_COM_UBUNTU_LOCATION_PROVIDERS_GPS_SNTP_REFERENCE_TIME_SOURCE_H_
+#define LOCATION_SERVICE_COM_UBUNTU_LOCATION_PROVIDERS_GPS_SNTP_REFERENCE_TIME_SOURCE_H_
+
+#include <com/ubuntu/location/providers/gps/android_hardware_abstraction_layer.h>
+
+#include <com/ubuntu/location/providers/gps/sntp_client.h>
+
+namespace com { namespace ubuntu { namespace location { namespace providers { namespace gps {
+
+class SntpReferenceTimeSource : public android::HardwareAbstractionLayer::ReferenceTimeSource
+{
+public:
+
+    /** @brief Configuration summarizes default parameter available to implementations. */
+    struct Configuration
+    {
+        /** @brief Reads a configuration from a gps.conf file in INI format. */
+        static Configuration from_gps_conf_ini_file(std::istream& in);
+
+        std::string host{"pool.ntp.org"}; /**< NTP host. */
+        std::chrono::milliseconds timeout{5000}; /**< Timeout when querying the NTP server. */
+    };
+
+    SntpReferenceTimeSource(const Configuration& configuration);
+
+    gps::HardwareAbstractionLayer::ReferenceTimeSample sample() override;
+
+private:
+    const Configuration config;
+};
+
+}}}}}
+
+#endif // LOCATION_SERVICE_COM_UBUNTU_LOCATION_PROVIDERS_GPS_SNTP_REFERENCE_TIME_SOURCE_H_

=== modified file 'src/location_service/com/ubuntu/location/providers/remote/provider.cpp'
--- src/location_service/com/ubuntu/location/providers/remote/provider.cpp	2015-04-14 18:54:00 +0000
+++ src/location_service/com/ubuntu/location/providers/remote/provider.cpp	2016-04-01 06:55:25 +0000
@@ -23,6 +23,7 @@
 #include <com/ubuntu/location/logging.h>
 
 #include <core/dbus/object.h>
+#include <core/dbus/service_watcher.h>
 #include <core/dbus/signal.h>
 #include <core/dbus/asio/executor.h>
 
@@ -191,6 +192,28 @@
     auto service = dbus::Service::use_service(bus, name);
     auto object = service->object_for_path(path);
 
+    // Check if the service has come up
+    if (!bus->has_owner_for_name(name)) {
+        // If it hasn't wait for it to come up
+        bool valid = false;
+        std::mutex guard;
+        std::condition_variable cv;
+        dbus::DBus daemon(bus);
+        dbus::ServiceWatcher::Ptr service_watcher(
+            daemon.make_service_watcher(name, dbus::DBus::WatchMode::registration));
+
+        service_watcher->service_registered().connect([&valid, &guard, &cv]()
+            {
+                std::unique_lock<std::mutex> ul(guard);
+                valid = true;
+                cv.notify_all();
+            });
+
+        std::unique_lock<std::mutex> ul(guard);
+        if (not cv.wait_for(ul, std::chrono::seconds{30}, [&valid]() { return valid; }))
+            throw std::runtime_error("Remote service failed to start");
+    }
+
     return create_instance_with_config(remote::stub::Configuration{object});
 }
 

=== modified file 'src/location_service/com/ubuntu/location/service/daemon.cpp'
--- src/location_service/com/ubuntu/location/service/daemon.cpp	2015-04-16 10:03:29 +0000
+++ src/location_service/com/ubuntu/location/service/daemon.cpp	2016-04-01 06:55:25 +0000
@@ -20,6 +20,9 @@
 #include <com/ubuntu/location/boost_ptree_settings.h>
 #include <com/ubuntu/location/provider_factory.h>
 
+#include <com/ubuntu/location/logging.h>
+#include <com/ubuntu/location/connectivity/dummy_connectivity_manager.h>
+
 #include <com/ubuntu/location/service/default_configuration.h>
 #include <com/ubuntu/location/service/demultiplexing_reporter.h>
 #include <com/ubuntu/location/service/ichnaea_reporter.h>
@@ -30,6 +33,7 @@
 
 #include "program_options.h"
 #include "daemon.h"
+#include "runtime.h"
 
 #include <core/dbus/announcer.h>
 #include <core/dbus/resolver.h>
@@ -37,6 +41,9 @@
 
 #include <core/posix/signal.h>
 
+#include <boost/asio.hpp>
+#include <boost/filesystem.hpp>
+
 #include <system_error>
 #include <thread>
 
@@ -164,6 +171,20 @@
 
 int location::service::Daemon::main(const location::service::Daemon::Configuration& config)
 {
+    // Ensure that log files dating back to before the fix
+    // for lp:1447110 are removed and do not waste space.
+    {
+        static const boost::filesystem::path old_log_dir{"/var/log/ubuntu-location-service"};
+        boost::system::error_code ec;
+        boost::filesystem::remove_all(old_log_dir, ec);
+    }
+    // Setup logging for the daemon.
+    FLAGS_logtostderr = true;
+    FLAGS_stop_logging_if_full_disk = true;
+    FLAGS_max_log_size = 5;
+
+    google::InitGoogleLogging("com.ubuntu.location");
+
     auto trap = core::posix::trap_signals_for_all_subsequent_threads(
     {
         core::posix::Signal::sig_term,
@@ -175,116 +196,55 @@
         trap->stop();
     });
 
-    const location::Configuration empty_provider_configuration;
-
-    std::set<location::Provider::Ptr> instantiated_providers;
-
+    auto runtime = location::service::Runtime::create(4);
+
+    location::service::DefaultConfiguration dc;
+    auto engine = dc.the_engine(std::set<location::Provider::Ptr>{}, dc.the_provider_selection_policy(), config.settings);
     for (const std::string& provider : config.providers)
     {
         std::cout << "Instantiating and configuring: " << provider << std::endl;
 
         try
         {
-            auto p = location::ProviderFactory::instance().create_provider_for_name_with_config(
-                        provider,
-                        config.provider_options.count(provider) > 0 ?
-                            config.provider_options.at(provider) : empty_provider_configuration);
-
-            if (p)
-                instantiated_providers.insert(p);
-            else
-                throw std::runtime_error("Problem instantiating provider");
-
+            auto result = std::async(std::launch::async, [provider, config, engine] {
+                return location::ProviderFactory::instance().create_provider_for_name_with_config(
+                    provider,
+                    config.provider_options.count(provider) > 0 ?
+                        config.provider_options.at(provider) : location::Configuration {},
+                    [engine](Provider::Ptr provider)
+                    {
+                        engine->add_provider(provider);
+                    }
+                );
+            });
         } catch(const std::runtime_error& e)
         {
             std::cerr << "Issue instantiating provider: " << e.what() << std::endl;
         }
     }
 
-    config.incoming->install_executor(dbus::asio::make_executor(config.incoming));
-    config.outgoing->install_executor(dbus::asio::make_executor(config.outgoing));
+    config.incoming->install_executor(dbus::asio::make_executor(config.incoming, runtime->service()));
+    config.outgoing->install_executor(dbus::asio::make_executor(config.outgoing, runtime->service()));
 
-    location::service::DefaultConfiguration dc;
+    runtime->start();
 
     location::service::Implementation::Configuration configuration
     {
         config.incoming,
         config.outgoing,
-        dc.the_engine(instantiated_providers, dc.the_provider_selection_policy(), config.settings),
+        engine,
         dc.the_permission_manager(config.outgoing),
         location::service::Harvester::Configuration
         {
-            location::connectivity::platform_default_manager(),
-            // We submit location/wifi/cell measurements to both
-            // Mozilla's location service and to Ubuntu's own instance.
-            std::make_shared<service::DemultiplexingReporter>(
-            std::initializer_list<service::Harvester::Reporter::Ptr>
-            {
-                std::make_shared<service::ichnaea::Reporter>(
-                     service::ichnaea::Reporter::Configuration
-                     {
-                         "https://location.services.mozilla.com",
-                         "UbuntuLocationService",
-                         "UbuntuLocationService"
-                     }
-                ),
-                std::make_shared<service::ichnaea::Reporter>(
-                     service::ichnaea::Reporter::Configuration
-                     {
-                         "https://162.213.35.107",
-                         "UbuntuLocationService",
-                         "UbuntuLocationService"
-                     }
-                )
-            })
+            std::make_shared<dummy::ConnectivityManager>(),
+            std::make_shared<NullReporter>()
         }
     };
 
     auto location_service = std::make_shared<location::service::Implementation>(configuration);
-    // We need to ensure that any exception raised by the executor does not crash the app
-    // and also gets logged.
-    auto execute = [] (std::shared_ptr<core::dbus::Bus> bus) {
-        while(true)
-        {
-            try
-            {
-                VLOG(10) << "Starting a bus executor";
-                bus->run();
-                break; // run() exited normally
-            }
-            catch (const std::exception& e)
-            {
-                LOG(WARNING) << e.what();
-            }
-            catch (...)
-            {
-                LOG(WARNING) << "Unexpected exception was raised by the bus executor";
-            }
-        }
-    };
-
-    std::thread t1{execute, config.incoming};
-    std::thread t2{execute, config.incoming};
-    std::thread t3{execute, config.incoming};
-    std::thread t4{execute, config.outgoing};
 
     trap->run();
 
-    config.incoming->stop();
-    config.outgoing->stop();
-
-    if (t1.joinable())
-        t1.join();
-
-    if (t2.joinable())
-        t2.join();
-
-    if (t3.joinable())
-        t3.join();
-
-    if (t4.joinable())
-        t4.join();
-
     return EXIT_SUCCESS;
 }
 

=== modified file 'src/location_service/com/ubuntu/location/service/daemon_main.cpp'
--- src/location_service/com/ubuntu/location/service/daemon_main.cpp	2015-01-13 16:35:20 +0000
+++ src/location_service/com/ubuntu/location/service/daemon_main.cpp	2016-04-01 06:55:25 +0000
@@ -18,41 +18,10 @@
 
 #include "daemon.h"
 
-#include <com/ubuntu/location/logging.h>
-
-#include <boost/filesystem.hpp>
-
 namespace location = com::ubuntu::location;
 
-namespace
-{
-// The directory we put log files in.
-constexpr const char* log_dir{"/var/log/ubuntu-location-service"};
-}
-
 int main(int argc, const char** argv)
 {
-    // Setup logging for the daemon.
-    boost::system::error_code ec;
-    boost::filesystem::create_directories(boost::filesystem::path{log_dir}, ec);
-
-    // According to http://www.boost.org/doc/libs/1_55_0/libs/filesystem/doc/reference.html#create_directories
-    //   Creation failure because p resolves to an existing directory shall not be treated as an error.
-    // With that, we are free to check the error condition and adjust to stderr
-    // logging accordingly.
-    if (ec)
-    {
-        FLAGS_logtostderr = true;
-        VLOG(1) << "Problem creating directory for log files: " << ec << "."
-                << "Falling back to stderr logging.";
-    }
-
-    FLAGS_log_dir = log_dir;
-    FLAGS_stop_logging_if_full_disk = true;
-    FLAGS_max_log_size = 5;
-
-    google::InitGoogleLogging("com.ubuntu.location");
-
     location::service::Daemon::Configuration config;
     try
     {

=== modified file 'src/location_service/com/ubuntu/location/service/implementation.cpp'
--- src/location_service/com/ubuntu/location/service/implementation.cpp	2014-08-13 13:08:22 +0000
+++ src/location_service/com/ubuntu/location/service/implementation.cpp	2016-04-01 06:55:25 +0000
@@ -113,10 +113,13 @@
               {
                   visible_space_vehicles() = svs;
               }),
-          configuration.engine->updates.reference_location.changed().connect(
-              [this](const cul::Update<cul::Position>& update)
+          configuration.engine->updates.last_known_location.changed().connect(
+              [this](const cul::Optional<cul::Update<cul::Position>>& update)
               {
-                  harvester.report_position_update(update);
+                  if (update)
+                  {
+                      harvester.report_position_update(update.get());
+                  }
               })
       }
 {
@@ -149,5 +152,23 @@
         new ProxyProvider{provider_selection}
     };
 
-    return session::Interface::Ptr{new culs::session::Implementation(proxy_provider)};
+    session::Interface::Ptr session_iface{new session::Implementation(proxy_provider)};
+    std::weak_ptr<session::Interface> session_weak{session_iface};
+    session_iface->updates().position_status.changed().connect([this, session_weak](const session::Interface::Updates::Status& status)
+    {
+        cul::Optional<cul::Update<cul::Position>> last_known_position = configuration.engine->updates.last_known_location.get();
+        bool has_last_known_position = last_known_position ? true : false;
+        bool is_session_enabled = status == culs::session::Interface::Updates::Status::enabled;
+        bool is_session_on_or_active = configuration.engine->configuration.engine_state != Engine::Status::off;
+
+        if (has_last_known_position && is_session_enabled && is_session_on_or_active)
+        {
+            // Immediately send the last known position to the client
+            if (auto session_iface = session_weak.lock())
+            {
+                session_iface->updates().position = last_known_position.get();
+            }
+        }
+    });
+    return session_iface;
 }

=== modified file 'src/location_service/com/ubuntu/location/service/provider_daemon.cpp'
--- src/location_service/com/ubuntu/location/service/provider_daemon.cpp	2014-10-27 21:58:16 +0000
+++ src/location_service/com/ubuntu/location/service/provider_daemon.cpp	2016-04-01 06:55:25 +0000
@@ -25,6 +25,7 @@
 
 #include <com/ubuntu/location/service/configuration.h>
 #include <com/ubuntu/location/service/program_options.h>
+#include <com/ubuntu/location/service/runtime.h>
 
 #include <core/dbus/asio/executor.h>
 
@@ -65,7 +66,6 @@
     location::service::ProviderDaemon::Configuration result;
 
     result.connection = factory(mutable_daemon_options().bus());
-    result.connection->install_executor(core::dbus::asio::make_executor(result.connection));
 
     auto service = core::dbus::Service::add_service(
                 result.connection,
@@ -108,7 +108,15 @@
     return result;
 }
 
-int location::service::ProviderDaemon::main(const location::service::ProviderDaemon::Configuration& configuration)
+namespace
+{
+std::shared_ptr<location::service::Runtime> runtime()
+{
+    static const auto inst = location::service::Runtime::create(2);
+    return inst;
+}
+}
+int location::service::ProviderDaemon::main(const location::service::ProviderDaemon::Configuration& config)
 {
     auto trap = core::posix::trap_signals_for_all_subsequent_threads(
     {
@@ -121,27 +129,20 @@
         trap->stop();
     });
 
-    std::thread worker
-    {
-        [configuration]()
-        {
-            configuration.connection->run();
-        }
-    };
+    config.connection->install_executor(core::dbus::asio::make_executor(config.connection, runtime()->service()));
 
     auto skeleton = location::providers::remote::skeleton::create_with_configuration(location::providers::remote::skeleton::Configuration
     {
-        configuration.object,
-        configuration.connection,
-        configuration.provider
+        config.object,
+        config.connection,
+        config.provider
     });
 
+    runtime()->start();
+
     trap->run();
 
-    configuration.connection->stop();
-
-    if (worker.joinable())
-        worker.join();
+    config.connection->stop();
 
     return EXIT_SUCCESS;
 }

=== added file 'src/location_service/com/ubuntu/location/service/runtime.cpp'
--- src/location_service/com/ubuntu/location/service/runtime.cpp	1970-01-01 00:00:00 +0000
+++ src/location_service/com/ubuntu/location/service/runtime.cpp	2016-04-01 06:55:25 +0000
@@ -0,0 +1,109 @@
+/*
+ * Copyright © 2015 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTIlocationAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Thomas Voß <[e-mail]>
+ */
+#include <com/ubuntu/location/service/runtime.h>
+
+#include <com/ubuntu/location/logging.h>
+
+namespace culs = com::ubuntu::location::service;
+
+namespace
+{
+// exception_safe_run runs service, catching all exceptions and
+// restarting operation until an explicit shutdown has been requested.
+//
+// TODO(tvoss): Catching all exceptions is risky as they might signal unrecoverable