Prevent accidental aggregates

*  The compiler can provide many non-explicit constructors for
   aggregate types.  This is sometimes desired, but it can
   happen accidentally, resulting in run-time errors.

*  This commit assures that no types are aggregates unless existing
   code is using aggregate initialization.

src/ripple/protocol/impl/ErrorCodes.cpp

@@ -29,6 +29,8 @@ namespace std {
 template <>
 struct hash <ripple::error_code_i>
 {
+    explicit hash() = default;
+
     std::size_t operator() (ripple::error_code_i value) const
     {
         return value;

src/ripple/protocol/impl/SField.cpp

@@ -46,6 +46,8 @@ using StaticScopedLockType = std::lock_guard <std::mutex>;
 // Give this translation unit only, permission to construct SFields
 struct SField::make
 {
+    explicit make() = default;
+
     template <class ...Args>
     static SField one(SField const* p, Args&& ...args)
     {

src/ripple/protocol/impl/STVar.h

@@ -31,8 +31,15 @@
 namespace ripple {
 namespace detail {
 
-struct defaultObject_t { };
-struct nonPresentObject_t { };
+struct defaultObject_t
+{
+    explicit defaultObject_t() = default;
+};
+
+struct nonPresentObject_t
+{
+    explicit nonPresentObject_t() = default;
+};
 
 extern defaultObject_t defaultObject;
 extern nonPresentObject_t nonPresentObject;