diff --git a/lang/cpp/src/configuration.h b/lang/cpp/src/configuration.h
index 2e577156..24995dd4 100644
--- a/lang/cpp/src/configuration.h
+++ b/lang/cpp/src/configuration.h
@@ -1,292 +1,292 @@
 /*
   configuration.h - wraps gpgme configuration components
   Copyright (C) 2010 Klarälvdalens Datakonsult AB
   2016 Bundesamt für Sicherheit in der Informationstechnik
   Software engineering by Intevation GmbH
 
   This file is part of GPGME++.
 
   GPGME++ is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.
 
   GPGME++ 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 Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with GPGME++; see the file COPYING.LIB.  If not, write to the
   Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
 */
 
 // -*- c++ -*-
 #ifndef __GPGMEPP_CONFIGURATION_H__
 #define __GPGMEPP_CONFIGURATION_H__
 
 #include "global.h"
 
 #include "gpgmefw.h"
 
 #include <iosfwd>
 #include <vector>
 #include <string>
 #include <algorithm>
 #include <memory>
 
 namespace GpgME
 {
 namespace Configuration
 {
 
 typedef std::shared_ptr< std::remove_pointer<gpgme_conf_comp_t>::type > shared_gpgme_conf_comp_t;
 typedef std::weak_ptr< std::remove_pointer<gpgme_conf_comp_t>::type > weak_gpgme_conf_comp_t;
 
 class Argument;
 class Option;
 class Component;
 
 enum Level {
     Basic,
     Advanced,
     Expert,
     Invisible,
     Internal,
 
     NumLevels
 };
 
 enum Type {
     NoType,
     StringType,
     IntegerType,
     UnsignedIntegerType,
 
     FilenameType = 32,
     LdapServerType,
     KeyFingerprintType,
     PublicKeyType,
     SecretKeyType,
     AliasListType,
 
     MaxType
 };
 
 enum Flag {
     Group    = (1 << 0),
     Optional = (1 << 1),
     List     = (1 << 2),
     Runtime  = (1 << 3),
     Default  = (1 << 4),
     DefaultDescription = (1 << 5),
     NoArgumentDescription = (1 << 6),
     NoChange = (1 << 7),
 
     LastFlag = NoChange
 };
 
 //
 // class Component
 //
 
 class GPGMEPP_EXPORT Component
 {
 public:
     Component() : comp() {}
     explicit Component(const shared_gpgme_conf_comp_t &gpgme_comp)
         : comp(gpgme_comp) {}
 
-    // copy ctor is ok
-
+    Component(const Component &other) = default;
     const Component &operator=(const Component &other)
     {
         if (this != &other) {
             Component(other).swap(*this);
         }
         return *this;
     }
 
     void swap(Component &other)
     {
         using std::swap;
         swap(this->comp, other.comp);
     }
 
     bool isNull() const
     {
         return !comp;
     }
 
     static std::vector<Component> load(Error &err);
     Error save() const;
 
     const char *name() const;
     const char *description() const;
     const char *programName() const;
 
     Option option(unsigned int index) const;
     Option option(const char *name) const;
 
     unsigned int numOptions() const;
 
     std::vector<Option> options() const;
 
     GPGMEPP_MAKE_SAFE_BOOL_OPERATOR(!isNull())
 private:
     shared_gpgme_conf_comp_t comp;
 };
 
 //
 // class Option
 //
 
 class GPGMEPP_EXPORT Option
 {
 public:
     Option() : comp(), opt(nullptr) {}
     Option(const shared_gpgme_conf_comp_t &gpgme_comp, gpgme_conf_opt_t gpgme_opt)
         : comp(gpgme_comp), opt(gpgme_opt) {}
 
+    Option(const Option &other) = default;
     const Option &operator=(const Option &other)
     {
         if (this != &other) {
             Option(other).swap(*this);
         }
         return *this;
     }
 
     void swap(Option &other)
     {
         using std::swap;
         swap(this->comp, other.comp);
         swap(this->opt,  other.opt);
     }
 
     bool isNull() const
     {
         return comp.expired() || !opt;
     }
 
     Component parent() const;
 
     unsigned int flags() const;
 
     Level level() const;
 
     const char *name() const;
     const char *description() const;
     const char *argumentName() const;
 
     Type type() const;
     Type alternateType() const;
 
     Argument defaultValue() const;
     const char *defaultDescription() const;
 
     Argument noArgumentValue() const;
     const char *noArgumentDescription() const;
 
     /*! The value that is in the config file (or null, if it's not set). */
     Argument activeValue() const;
     /*! The value that is in this object, ie. either activeValue(), newValue(), or defaultValue() */
     Argument currentValue() const;
 
     Argument newValue() const;
     bool set() const;
     bool dirty() const;
 
     Error setNewValue(const Argument &argument);
     Error resetToDefaultValue();
     Error resetToActiveValue();
 
     Argument createNoneArgument(bool set) const;
     Argument createStringArgument(const char *value) const;
     Argument createStringArgument(const std::string &value) const;
     Argument createIntArgument(int value) const;
     Argument createUIntArgument(unsigned int value) const;
 
     Argument createNoneListArgument(unsigned int count) const;
     Argument createStringListArgument(const std::vector<const char *> &value) const;
     Argument createStringListArgument(const std::vector<std::string> &value) const;
     Argument createIntListArgument(const std::vector<int> &values) const;
     Argument createUIntListArgument(const std::vector<unsigned int> &values) const;
 
     GPGMEPP_MAKE_SAFE_BOOL_OPERATOR(!isNull())
 private:
     weak_gpgme_conf_comp_t  comp;
     gpgme_conf_opt_t opt;
 };
 
 //
 // class Argument
 //
 
 class GPGMEPP_EXPORT Argument
 {
     friend class ::GpgME::Configuration::Option;
     Argument(const shared_gpgme_conf_comp_t &comp, gpgme_conf_opt_t opt, gpgme_conf_arg_t arg, bool owns);
 public:
     Argument() : comp(), opt(nullptr), arg(nullptr) {}
     //Argument( const shared_gpgme_conf_comp_t & comp, gpgme_conf_opt_t opt, gpgme_conf_arg_t arg );
     Argument(const Argument &other);
     ~Argument();
 
     const Argument &operator=(const Argument &other)
     {
         if (this != &other) {
             Argument(other).swap(*this);
         }
         return *this;
     }
 
     void swap(Argument &other)
     {
         using std::swap;
         swap(this->comp, other.comp);
         swap(this->opt,  other.opt);
         swap(this->arg,  other.arg);
     }
 
     bool isNull() const
     {
         return comp.expired() || !opt || !arg;
     }
 
     Option parent() const;
 
     unsigned int numElements() const;
 
     bool boolValue() const;
     const char *stringValue(unsigned int index = 0) const;
     int          intValue(unsigned int index = 0) const;
     unsigned int uintValue(unsigned int index = 0) const;
 
     unsigned int numberOfTimesSet() const;
     std::vector<const char *> stringValues() const;
     std::vector<int>          intValues() const;
     std::vector<unsigned int> uintValues() const;
 
     GPGMEPP_MAKE_SAFE_BOOL_OPERATOR(!isNull())
 private:
     weak_gpgme_conf_comp_t comp;
     gpgme_conf_opt_t opt;
     gpgme_conf_arg_t arg;
 };
 
 GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, Level level);
 GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, Type type);
 GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, Flag flag);
 GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, const Component &component);
 GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, const Option &option);
 GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, const Argument &argument);
 
 } // namespace Configuration
 } // namespace GpgME
 
 GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION(Configuration::Component)
 GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION(Configuration::Option)
 GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION(Configuration::Argument)
 
 #endif // __GPGMEPP_CONFIGURATION_H__
diff --git a/lang/cpp/src/data.h b/lang/cpp/src/data.h
index df8607e7..649e4104 100644
--- a/lang/cpp/src/data.h
+++ b/lang/cpp/src/data.h
@@ -1,140 +1,141 @@
 /*
   data.h - wraps a gpgme data object
   Copyright (C) 2003,2004 Klarälvdalens Datakonsult AB
 
   This file is part of GPGME++.
 
   GPGME++ is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.
 
   GPGME++ 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 Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with GPGME++; see the file COPYING.LIB.  If not, write to the
   Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
 */
 
 #ifndef __GPGMEPP_DATA_H__
 #define __GPGMEPP_DATA_H__
 
 #include "global.h"
 #include "key.h"
 
 #include <sys/types.h> // for size_t, off_t
 #include <cstdio> // FILE
 #include <algorithm>
 #include <memory>
 
 namespace GpgME
 {
 
 class DataProvider;
 class Error;
 
 class GPGMEPP_EXPORT Data
 {
     struct Null {
 		Null() {}
 	};
 public:
     /* implicit */ Data(const Null &);
     Data();
     explicit Data(gpgme_data_t data);
 
     // Memory-Based Data Buffers:
     Data(const char *buffer, size_t size, bool copy = true);
     explicit Data(const char *filename);
     Data(const char *filename, off_t offset, size_t length);
     Data(std::FILE *fp, off_t offset, size_t length);
     // File-Based Data Buffers:
     explicit Data(std::FILE *fp);
     explicit Data(int fd);
     // Callback-Based Data Buffers:
     explicit Data(DataProvider *provider);
 
     static const Null null;
 
+    Data(const Data &other) = default;
     const Data &operator=(Data other)
     {
         swap(other);
         return *this;
     }
 
     void swap(Data &other)
     {
         using std::swap;
         swap(this->d, other.d);
     }
 
     bool isNull() const;
 
     enum Encoding {
         AutoEncoding,
         BinaryEncoding,
         Base64Encoding,
         ArmorEncoding,
         MimeEncoding,
         UrlEncoding,
         UrlEscEncoding,
         Url0Encoding,
     };
     Encoding encoding() const;
     Error setEncoding(Encoding encoding);
 
     enum Type {
         Invalid,
         Unknown,
         PGPSigned,
         PGPOther,
         PGPKey,
         CMSSigned,
         CMSEncrypted,
         CMSOther,
         X509Cert,
         PKCS12,
         PGPEncrypted,
         PGPSignature,
     };
     Type type() const;
 
     char *fileName() const;
     Error setFileName(const char *name);
 
     ssize_t read(void *buffer, size_t length);
     ssize_t write(const void *buffer, size_t length);
     off_t seek(off_t offset, int whence);
 
     /* Convenience function to do a seek (0, SEEK_SET).  */
     Error rewind();
 
     /** Try to parse the data to a key object using the
      * Protocol proto. Returns an empty list on error.*/
     std::vector<Key> toKeys(const Protocol proto = Protocol::OpenPGP) const;
 
     /** Return a copy of the data as std::string. Sets seek pos to 0 */
     std::string toString();
 
     class Private;
     Private *impl()
     {
         return d.get();
     }
     const Private *impl() const
     {
         return d.get();
     }
 private:
     std::shared_ptr<Private> d;
 };
 
 }
 
 GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION(Data)
 
 #endif // __GPGMEPP_DATA_H__
diff --git a/lang/cpp/src/decryptionresult.h b/lang/cpp/src/decryptionresult.h
index e4d542dd..84026d39 100644
--- a/lang/cpp/src/decryptionresult.h
+++ b/lang/cpp/src/decryptionresult.h
@@ -1,139 +1,141 @@
 /*
   decryptionresult.h - wraps a gpgme keygen result
   Copyright (C) 2004 Klarälvdalens Datakonsult AB
   2016 Bundesamt für Sicherheit in der Informationstechnik
   Software engineering by Intevation GmbH
 
   This file is part of GPGME++.
 
   GPGME++ is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.
 
   GPGME++ 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 Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with GPGME++; see the file COPYING.LIB.  If not, write to the
   Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
 */
 
 #ifndef __GPGMEPP_DECRYPTIONRESULT_H__
 #define __GPGMEPP_DECRYPTIONRESULT_H__
 
 #include "gpgmefw.h"
 #include "result.h"
 #include "gpgmepp_export.h"
 
 #include <vector>
 #include <algorithm>
 #include <iosfwd>
 #include <memory>
 
 namespace GpgME
 {
 
 class Error;
 
 class GPGMEPP_EXPORT DecryptionResult : public Result
 {
 public:
     DecryptionResult();
     DecryptionResult(gpgme_ctx_t ctx, int error);
     DecryptionResult(gpgme_ctx_t ctx, const Error &err);
     explicit DecryptionResult(const Error &err);
 
+    DecryptionResult(const DecryptionResult &other) = default;
     const DecryptionResult &operator=(DecryptionResult other)
     {
         swap(other);
         return *this;
     }
 
     void swap(DecryptionResult &other)
     {
         Result::swap(other);
         using std::swap;
         swap(this->d, other.d);
     }
 
     bool isNull() const;
 
     GPGMEPP_DEPRECATED const char *unsupportedAlgortihm() const
     {
         return unsupportedAlgorithm();
     }
     const char *unsupportedAlgorithm() const;
 
     GPGMEPP_DEPRECATED bool wrongKeyUsage() const
     {
         return isWrongKeyUsage();
     }
     bool isWrongKeyUsage() const;
     bool isDeVs() const;
 
     const char *fileName() const;
 
     const char *sessionKey() const;
 
     const char *symkeyAlgo() const;
 
     class Recipient;
 
     unsigned int numRecipients() const;
     Recipient recipient(unsigned int idx) const;
     std::vector<Recipient> recipients() const;
 
     bool isLegacyCipherNoMDC() const;
 
 private:
     class Private;
     void init(gpgme_ctx_t ctx);
     std::shared_ptr<Private> d;
 };
 
 GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, const DecryptionResult &result);
 
 class GPGMEPP_EXPORT DecryptionResult::Recipient
 {
 public:
     Recipient();
     explicit Recipient(gpgme_recipient_t reci);
 
+    Recipient(const Recipient &other) = default;
     const Recipient &operator=(Recipient other)
     {
         swap(other);
         return *this;
     }
 
     void swap(Recipient &other)
     {
         using std::swap;
         swap(this->d, other.d);
     }
 
     bool isNull() const;
 
     const char *keyID() const;
     const char *shortKeyID() const;
 
     unsigned int publicKeyAlgorithm() const;
     const char *publicKeyAlgorithmAsString() const;
 
     Error status() const;
 
 private:
     class Private;
     std::shared_ptr<Private> d;
 };
 
 GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, const DecryptionResult::Recipient &reci);
 
 }
 
 GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION(DecryptionResult)
 
 #endif // __GPGMEPP_DECRYPTIONRESULT_H__
diff --git a/lang/cpp/src/encryptionresult.h b/lang/cpp/src/encryptionresult.h
index 312dfec7..1aea6bb8 100644
--- a/lang/cpp/src/encryptionresult.h
+++ b/lang/cpp/src/encryptionresult.h
@@ -1,115 +1,117 @@
 /*
   encryptionresult.h - wraps a gpgme sign result
   Copyright (C) 2004 Klarälvdalens Datakonsult AB
   2016 Bundesamt für Sicherheit in der Informationstechnik
   Software engineering by Intevation GmbH
 
   This file is part of GPGME++.
 
   GPGME++ is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.
 
   GPGME++ 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 Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with GPGME++; see the file COPYING.LIB.  If not, write to the
   Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
 */
 
 #ifndef __GPGMEPP_ENCRYPTIONRESULT_H__
 #define __GPGMEPP_ENCRYPTIONRESULT_H__
 
 #include "gpgmefw.h"
 #include "result.h"
 #include "gpgmepp_export.h"
 
 #include <memory>
 
 #include <vector>
 #include <iosfwd>
 
 namespace GpgME
 {
 
 class Error;
 class InvalidRecipient;
 
 class GPGMEPP_EXPORT EncryptionResult : public Result
 {
 public:
     EncryptionResult();
     EncryptionResult(gpgme_ctx_t ctx, int error);
     EncryptionResult(gpgme_ctx_t ctx, const Error &error);
     EncryptionResult(const Error &err);
 
+    EncryptionResult(const EncryptionResult &other) = default;
     const EncryptionResult &operator=(EncryptionResult other)
     {
         swap(other);
         return *this;
     }
 
     void swap(EncryptionResult &other)
     {
         Result::swap(other);
         using std::swap;
         swap(this->d, other.d);
     }
 
     bool isNull() const;
 
     unsigned int numInvalidRecipients() const;
 
     InvalidRecipient invalidEncryptionKey(unsigned int index) const;
     std::vector<InvalidRecipient> invalidEncryptionKeys() const;
 
     class Private;
 private:
     void init(gpgme_ctx_t ctx);
     std::shared_ptr<Private> d;
 };
 
 GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, const EncryptionResult &result);
 
 class GPGMEPP_EXPORT InvalidRecipient
 {
     friend class ::GpgME::EncryptionResult;
     InvalidRecipient(const std::shared_ptr<EncryptionResult::Private> &parent, unsigned int index);
 public:
     InvalidRecipient();
 
+    InvalidRecipient(const InvalidRecipient &other) = default;
     const InvalidRecipient &operator=(InvalidRecipient other)
     {
         swap(other);
         return *this;
     }
 
     void swap(InvalidRecipient &other)
     {
         using std::swap;
         swap(this->d, other.d);
     }
 
     bool isNull() const;
 
     const char *fingerprint() const;
     Error reason() const;
 
 private:
     std::shared_ptr<EncryptionResult::Private> d;
     unsigned int idx;
 };
 
 GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, const InvalidRecipient &recipient);
 
 }
 
 GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION(EncryptionResult)
 GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION(InvalidRecipient)
 
 #endif // __GPGMEPP_ENCRYPTIONRESULT_H__
diff --git a/lang/cpp/src/engineinfo.h b/lang/cpp/src/engineinfo.h
index 52bf3474..ce7b4eaf 100644
--- a/lang/cpp/src/engineinfo.h
+++ b/lang/cpp/src/engineinfo.h
@@ -1,184 +1,185 @@
 /*
   engineinfo.h
   Copyright (C) 2004 Klarälvdalens Datakonsult AB
   2016 Bundesamt für Sicherheit in der Informationstechnik
   Software engineering by Intevation GmbH
 
   This file is part of GPGME++.
 
   GPGME++ is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.
 
   GPGME++ 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 Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with GPGME++; see the file COPYING.LIB.  If not, write to the
   Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
 */
 
 #ifndef __GPGMEPP_ENGINEINFO_H__
 #define __GPGMEPP_ENGINEINFO_H__
 
 #include "global.h"
 
 #include <memory>
 
 #include <algorithm>
 #include <string>
 #include <iostream>
 
 namespace GpgME
 {
 
 class GPGMEPP_EXPORT EngineInfo
 {
 public:
     struct Version
     {
         int major, minor, patch;
         Version()
         {
           major = 0;
           minor = 0;
           patch = 0;
         }
 
         Version(const std::string& version)
         {
             if (version.empty() ||
                 std::sscanf(version.c_str(), "%d.%d.%d", &major, &minor, &patch) != 3) {
                 major = 0;
                 minor = 0;
                 patch = 0;
             }
         }
 
         Version(const char *version)
         {
             if (!version ||
                 std::sscanf(version, "%d.%d.%d", &major, &minor, &patch) != 3) {
                 major = 0;
                 minor = 0;
                 patch = 0;
             }
         }
 
         bool operator < (const Version& other)
         {
             if (major > other.major ||
                 (major == other.major && minor > other.minor) ||
                 (major == other.major && minor == other.minor && patch > other.patch) ||
                 (major >= other.major && minor >= other.minor && patch >= other.patch)) {
                 return false;
             }
             return true;
         }
 
         bool operator < (const char* other)
         {
             return operator<(Version(other));
         }
 
         bool operator <= (const Version &other)
         {
             return !operator>(other);
         }
 
         bool operator <= (const char *other)
         {
             return operator<=(Version(other));
         }
 
         bool operator > (const char* other)
         {
             return operator>(Version(other));
         }
 
         bool operator > (const Version & other)
         {
             return !operator<(other) && !operator==(other);
         }
 
         bool operator >= (const Version &other)
         {
             return !operator<(other);
         }
 
         bool operator >= (const char *other)
         {
             return operator>=(Version(other));
         }
 
         bool operator == (const Version& other)
         {
             return major == other.major
                 && minor == other.minor
                 && patch == other.patch;
         }
 
         bool operator == (const char* other)
         {
             return operator==(Version(other));
         }
 
         bool operator != (const Version &other)
         {
             return !operator==(other);
         }
 
         bool operator != (const char *other)
         {
             return operator!=(Version(other));
         }
 
         friend std::ostream& operator << (std::ostream& stream, const Version& ver)
         {
             stream << ver.major;
             stream << '.';
             stream << ver.minor;
             stream << '.';
             stream << ver.patch;
             return stream;
         }
     };
 
     EngineInfo();
     explicit EngineInfo(gpgme_engine_info_t engine);
 
+    EngineInfo(const EngineInfo &other) = default;
     const EngineInfo &operator=(EngineInfo other)
     {
         swap(other);
         return *this;
     }
 
     void swap(EngineInfo &other)
     {
         using std::swap;
         swap(this->d, other.d);
     }
 
     bool isNull() const;
 
     Protocol protocol() const;
     const char *fileName() const;
     const char *version() const;
     Version engineVersion() const;
     const char *requiredVersion() const;
     const char *homeDirectory() const;
 
 private:
     class Private;
     std::shared_ptr<Private> d;
 };
 
 }
 
 GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION(EngineInfo)
 
 #endif // __GPGMEPP_ENGINEINFO_H__
diff --git a/lang/cpp/src/importresult.h b/lang/cpp/src/importresult.h
index 59366984..a2749331 100644
--- a/lang/cpp/src/importresult.h
+++ b/lang/cpp/src/importresult.h
@@ -1,150 +1,152 @@
 /*
   importresult.h - wraps a gpgme import result
   Copyright (C) 2004 Klarälvdalens Datakonsult AB
   2016 Bundesamt für Sicherheit in der Informationstechnik
   Software engineering by Intevation GmbH
 
   This file is part of GPGME++.
 
   GPGME++ is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.
 
   GPGME++ 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 Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with GPGME++; see the file COPYING.LIB.  If not, write to the
   Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
 */
 
 #ifndef __GPGMEPP_IMPORTRESULT_H__
 #define __GPGMEPP_IMPORTRESULT_H__
 
 #include "gpgmefw.h"
 #include "result.h"
 #include "gpgmepp_export.h"
 
 #include <memory>
 
 #include <vector>
 
 namespace GpgME
 {
 
 class Error;
 class Import;
 
 class GPGMEPP_EXPORT ImportResult : public Result
 {
 public:
     ImportResult();
     ImportResult(gpgme_ctx_t ctx, int error);
     ImportResult(gpgme_ctx_t ctx, const Error &error);
     explicit ImportResult(const Error &error);
 
+    ImportResult(const ImportResult &other) = default;
     const ImportResult &operator=(ImportResult other)
     {
         swap(other);
         return *this;
     }
 
     void swap(ImportResult &other)
     {
         Result::swap(other);
         using std::swap;
         swap(this->d, other.d);
     }
 
     /**
      * Merges the result @p other into this result (and all of its copies).
      *
      * @note The merge algorithm assumes that @p other is the result of an
      * import that was performed after the import of this result.
      * @note Some numbers cannot be consolidated reliably, e.g. the number of
      * keys without user ID.
      */
     void mergeWith(const ImportResult &other);
 
     bool isNull() const;
 
     int numConsidered() const;
     int numKeysWithoutUserID() const;
     int numImported() const;
     int numRSAImported() const;
     int numUnchanged() const;
 
     int newUserIDs() const;
     int newSubkeys() const;
     int newSignatures() const;
     int newRevocations() const;
 
     int numSecretKeysConsidered() const;
     int numSecretKeysImported() const;
     int numSecretKeysUnchanged() const;
 
     int notImported() const;
     int numV3KeysSkipped() const;
 
     Import import(unsigned int idx) const;
     std::vector<Import> imports() const;
 
     class Private;
 private:
     void init(gpgme_ctx_t ctx);
     std::shared_ptr<Private> d;
 };
 
 class GPGMEPP_EXPORT Import
 {
     friend class ::GpgME::ImportResult;
     Import(const std::shared_ptr<ImportResult::Private> &parent, unsigned int idx);
 public:
     Import();
 
+    Import(const Import &other) = default;
     const Import &operator=(Import other)
     {
         swap(other);
         return *this;
     }
 
     void swap(Import &other)
     {
         using std::swap;
         swap(this->d, other.d);
         swap(this->idx, other.idx);
     }
 
     bool isNull() const;
 
     const char *fingerprint() const;
     Error error() const;
 
     enum Status {
         Unknown = 0x0,
         NewKey = 0x1,
         NewUserIDs = 0x2,
         NewSignatures = 0x4,
         NewSubkeys = 0x8,
         ContainedSecretKey = 0x10
     };
     Status status() const;
 
 private:
     std::shared_ptr<ImportResult::Private> d;
     unsigned int idx;
 };
 
 GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, const ImportResult &irs);
 GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, const Import &imp);
 
 } // namespace GpgME
 
 GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION(ImportResult)
 GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION(Import)
 
 #endif // __GPGMEPP_IMPORTRESULT_H__
diff --git a/lang/cpp/src/key.h b/lang/cpp/src/key.h
index 0e6380db..09f1879f 100644
--- a/lang/cpp/src/key.h
+++ b/lang/cpp/src/key.h
@@ -1,550 +1,554 @@
 /*
   key.h - wraps a gpgme key
   Copyright (C) 2003, 2005 Klarälvdalens Datakonsult AB
 
   This file is part of GPGME++.
 
   GPGME++ is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.
 
   GPGME++ 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 Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with GPGME++; see the file COPYING.LIB.  If not, write to the
   Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
 */
 
 // -*- c++ -*-
 #ifndef __GPGMEPP_KEY_H__
 #define __GPGMEPP_KEY_H__
 
 #include "global.h"
 #include "notation.h"
 
 #include "gpgmefw.h"
 
 #include <memory>
 #include <sys/time.h>
 
 #include <vector>
 #include <algorithm>
 #include <string>
 
 namespace GpgME
 {
 
 class Context;
 
 class Subkey;
 class UserID;
 class TofuInfo;
 
 typedef std::shared_ptr< std::remove_pointer<gpgme_key_t>::type > shared_gpgme_key_t;
 
 enum class TrustSignatureTrust : char {
     None = 0,
     Partial,
     Complete,
 };
 
 //
 // class Key
 //
 
 class GPGMEPP_EXPORT Key
 {
     friend class ::GpgME::Context;
     struct Null {
 		Null() {}
 	};
 public:
     Key();
     /* implicit */ Key(const Null &);
     Key(const shared_gpgme_key_t &key);
     Key(gpgme_key_t key, bool acquireRef);
 
     static const Null null;
 
+    Key(const Key &other) = default;
     const Key &operator=(Key other)
     {
         swap(other);
         return *this;
     }
 
     const Key &mergeWith(const Key &other);
 
     void swap(Key &other)
     {
         using std::swap;
         swap(this->key, other.key);
     }
 
     bool isNull() const
     {
         return !key;
     }
 
     UserID userID(unsigned int index) const;
     Subkey subkey(unsigned int index) const;
 
     unsigned int numUserIDs() const;
     unsigned int numSubkeys() const;
 
     std::vector<UserID> userIDs() const;
     std::vector<Subkey> subkeys() const;
 
     bool isRevoked() const;
     bool isExpired() const;
     bool isDisabled() const;
     bool isInvalid() const;
 
     /*! Shorthand for isNull || isRevoked || isExpired ||
      *                          isDisabled || isInvalid */
     bool isBad() const;
 
     bool canEncrypt() const;
     /*!
       This function contains a workaround for old gpgme's: all secret
       OpenPGP keys canSign() == true, which canReallySign() doesn't
       have. I don't have time to find what breaks when I remove this
       workaround, but since Kleopatra merges secret into public keys,
       the workaround is not necessary there (and actively harms), I've
       added a new function instead.
      */
     bool canSign() const;
     bool canReallySign() const;
     bool canCertify() const;
     bool canAuthenticate() const;
     bool isQualified() const;
     bool isDeVs() const;
 
     bool hasSecret() const;
     GPGMEPP_DEPRECATED bool isSecret() const
     {
         return hasSecret();
     }
 
     /*!
       @return true if this is a X.509 root certificate (currently
       equivalent to something like
       strcmp( chainID(), subkey(0).fingerprint() ) == 0 )
     */
     bool isRoot() const;
 
     enum OwnerTrust { Unknown = 0, Undefined = 1, Never = 2,
                       Marginal = 3, Full = 4, Ultimate = 5
                     };
 
     OwnerTrust ownerTrust() const;
     char ownerTrustAsString() const;
 
     Protocol protocol() const;
     const char *protocolAsString() const;
 
     const char *issuerSerial() const;
     const char *issuerName() const;
     const char *chainID() const;
 
     const char *keyID() const;
     const char *shortKeyID() const;
     const char *primaryFingerprint() const;
 
     unsigned int keyListMode() const;
 
     /*! Update information about this key.
      * Starts a keylisting for this key with validity
      * and tofu information gathering. Blocks for
      * how long the keylisting takes.*/
     void update();
 
     /**
      * @brief Add a user id to this key.
      *
      * Needs gnupg 2.1.13 and the key needs to be updated
      * afterwards to see the new uid.
      *
      * @param uid should be fully formatted and UTF-8 encoded.
      *
      * @returns a possible error.
      **/
     Error addUid(const char *uid);
 
     /**
      * @brief try to locate the best pgp key for a given mailbox.
      *
      * Boils down to gpg --locate-key <mbox>
      * This may take some time if remote sources are also
      * used.
      *
      * @param mbox should be a mail address does not need to be normalized.
      *
      * @returns The best key for a mailbox or a null key.
      */
     static Key locate(const char *mbox);
 
     /* @enum Origin
      * @brief The Origin of the key. */
     enum Origin : unsigned int {
         OriginUnknown = 0,
         OriginKS = 1,
         OriginDane = 3,
         OriginWKD = 4,
         OriginURL = 5,
         OriginFile = 6,
         OriginSelf = 7,
         OriginOther = 31,
     };
     /*! Get the origin of the key.
      *
      * @returns the Origin. */
     Origin origin() const;
 
     /*! Get the last update time.
      *
      * @returns the last update time. */
     time_t lastUpdate() const;
 private:
     gpgme_key_t impl() const
     {
         return key.get();
     }
     shared_gpgme_key_t key;
 };
 
 //
 // class Subkey
 //
 
 class GPGMEPP_EXPORT Subkey
 {
 public:
     Subkey();
     Subkey(const shared_gpgme_key_t &key, gpgme_sub_key_t subkey);
     Subkey(const shared_gpgme_key_t &key, unsigned int idx);
 
+    Subkey(const Subkey &other) = default;
     const Subkey &operator=(Subkey other)
     {
         swap(other);
         return *this;
     }
 
     void swap(Subkey &other)
     {
         using std::swap;
         swap(this->key, other.key);
         swap(this->subkey, other.subkey);
     }
 
     bool isNull() const
     {
         return !key || !subkey;
     }
 
     Key parent() const;
 
     const char *keyID() const;
     const char *fingerprint() const;
 
     time_t creationTime() const;
     time_t expirationTime() const;
     bool neverExpires() const;
 
     bool isRevoked() const;
     bool isExpired() const;
     bool isInvalid() const;
     bool isDisabled() const;
 
     /*! Shorthand for isNull || isRevoked || isExpired ||
      *                          isDisabled || isInvalid */
     bool isBad() const;
 
     bool canEncrypt() const;
     bool canSign() const;
     bool canCertify() const;
     bool canAuthenticate() const;
     bool isQualified() const;
     bool isDeVs() const;
     bool isCardKey() const;
 
     bool isSecret() const;
 
     /** Same as gpgme_pubkey_algo_t */
     enum PubkeyAlgo {
         AlgoUnknown = 0,
         AlgoRSA     = 1,
         AlgoRSA_E   = 2,
         AlgoRSA_S   = 3,
         AlgoELG_E   = 16,
         AlgoDSA     = 17,
         AlgoECC     = 18,
         AlgoELG     = 20,
         AlgoECDSA   = 301,
         AlgoECDH    = 302,
         AlgoEDDSA   = 303,
         AlgoMax     = 1 << 31
     };
 
     PubkeyAlgo publicKeyAlgorithm() const;
 
     /**
       @brief Get the public key algorithm name.
 
       This only works for the pre 2.1 algorithms for ECC NULL is returned.
 
       @returns a statically allocated string with the name of the public
                key algorithm, or NULL if that name is not known.
     */
     const char *publicKeyAlgorithmAsString() const;
 
     /** @brief Same as publicKeyAlgorithmAsString but static. */
     static const char *publicKeyAlgorithmAsString(PubkeyAlgo algo);
 
     /**
        @brief Get the key algo string like GnuPG 2.1 prints it.
 
        This returns combinations of size and algorithm. Like
        bp512 or rsa2048. Misnamed because publicKeyAlgorithmAsString
        already used the older pubkey_algo_name.
        Actually uses gpgme_pubkey_algo_string.
 
        @returns the key algorithm as string. Empty string on error.
     */
     std::string algoName() const;
 
     unsigned int length() const;
 
     const char *cardSerialNumber() const;
 
     const char *keyGrip() const;
 
 private:
     shared_gpgme_key_t key;
     gpgme_sub_key_t subkey;
 };
 
 //
 // class UserID
 //
 
 class GPGMEPP_EXPORT UserID
 {
 public:
     class Signature;
 
     UserID();
     UserID(const shared_gpgme_key_t &key, gpgme_user_id_t uid);
     UserID(const shared_gpgme_key_t &key, unsigned int idx);
 
+    UserID(const UserID &other) = default;
     const UserID &operator=(UserID other)
     {
         swap(other);
         return *this;
     }
 
     void swap(UserID &other)
     {
         using std::swap;
         swap(this->key, other.key);
         swap(this->uid, other.uid);
     }
 
     bool isNull() const
     {
         return !key || !uid;
     }
 
     Key parent() const;
 
     unsigned int numSignatures() const;
     Signature signature(unsigned int index) const;
     std::vector<Signature> signatures() const;
 
     const char *id() const;
     const char *name() const;
     const char *email() const;
     const char *comment() const;
     const char *uidhash() const;
 
     enum Validity { Unknown = 0, Undefined = 1, Never = 2,
                     Marginal = 3, Full = 4, Ultimate = 5
                   };
 
     Validity validity() const;
     char validityAsString() const;
 
     bool isRevoked() const;
     bool isInvalid() const;
 
     /*! Shorthand for isNull || isRevoked || isInvalid */
     bool isBad() const;
 
     /** TOFU info for this userid.
      * @returns The TOFU stats or a null TofuInfo.
      */
     GpgME::TofuInfo tofuInfo() const;
 
     /*! Wrapper around gpgme_addrspec_from_uid.
      *
      * The input string should match the format of
      * a user id string.
      *
      * @returns a normalized mail address if found
      * or an empty string. */
     static std::string addrSpecFromString(const char *uid);
 
     /*! Wrapper around gpgme_addrspec_from_uid.
      *
      * @returns a normalized mail address for this userid
      * or an empty string. */
     std::string addrSpec() const;
 
     /*! Revoke the user id.
      *
      * Key needs update afterwards.
      *
      * @returns an error on error.*/
     Error revoke();
 
     /*! Get the origin of the key.
      *
      * @returns the Origin. */
     Key::Origin origin() const;
 
     /*! Get the last update time.
      *
      * @returns the last update time. */
     time_t lastUpdate() const;
 
     /*! Get a remark made by the key provided.
      * A remark is a signature notation on
      * this user id made by the key with the
      * name "rem@gnupg.org". Returns an error if the
      * parent key of this user id was not listed with the
      * keylist mode flags for signatures and signature notations.
      *
      * @param key The key for which comments should be searched.
      * @param error Set to GPG_ERR_NO_DATA if the keylist did
      *              not include signature notations.
      *
      * @returns The value of the comment or NULL if none exists.
      **/
     const char *remark(const Key &key,
                        Error &error) const;
 
     /*! Get multiple remarks made by potentially multiple keys. */
     std::vector <std::string> remarks(std::vector<GpgME::Key> remarkers,
                                       Error &error) const;
 
 private:
     shared_gpgme_key_t key;
     gpgme_user_id_t uid;
 };
 
 //
 // class UserID::Signature
 //
 
 class GPGMEPP_EXPORT UserID::Signature
 {
 public:
     typedef GPGMEPP_DEPRECATED GpgME::Notation Notation;
 
     Signature();
     Signature(const shared_gpgme_key_t &key, gpgme_user_id_t uid, gpgme_key_sig_t sig);
     Signature(const shared_gpgme_key_t &key, gpgme_user_id_t uid, unsigned int idx);
 
+    Signature(const Signature &other) = default;
     const Signature &operator=(Signature other)
     {
         swap(other);
         return *this;
     }
 
     void swap(Signature &other)
     {
         using std::swap;
         swap(this->key, other.key);
         swap(this->uid, other.uid);
         swap(this->sig, other.sig);
     }
 
     /*! Defines a canonical sort order for signatures of the same user ID. */
     bool operator<(const Signature &other) const;
 
     GPGMEPP_DEPRECATED bool operator<(const Signature &other);
 
     bool isNull() const
     {
         return !sig || !uid || !key ;
     }
 
     UserID parent() const;
 
     const char *signerKeyID() const;
 
     const char *algorithmAsString() const;
     unsigned int algorithm() const;
     time_t creationTime() const;
     time_t expirationTime() const;
     bool neverExpires() const;
 
     bool isRevokation() const;
     bool isInvalid() const;
     bool isExpired() const;
     bool isExportable() const;
 
     /*! Shorthand for isNull || isExpired || isInvalid */
     bool isBad() const;
 
     const char *signerUserID() const;
     const char *signerName() const;
     const char *signerEmail() const;
     const char *signerComment() const;
 
     unsigned int certClass() const;
 
     enum Status { NoError = 0, SigExpired, KeyExpired,
                   BadSignature, NoPublicKey, GeneralError
                 };
     Status status() const;
     std::string statusAsString() const;
 
     const char *policyURL() const;
 
     unsigned int numNotations() const;
     GpgME::Notation notation(unsigned int idx) const;
     std::vector<GpgME::Notation> notations() const;
 
     bool isTrustSignature() const;
     TrustSignatureTrust trustValue() const;
     unsigned int trustDepth() const;
     const char *trustScope() const;
 
 private:
     shared_gpgme_key_t key;
     gpgme_user_id_t uid;
     gpgme_key_sig_t sig;
 };
 
 GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, const UserID &uid);
 GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, const Subkey &subkey);
 GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, const Key &key);
 
 } // namespace GpgME
 
 GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION(Key)
 GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION(Subkey)
 GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION(UserID)
 GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION(UserID::Signature)
 
 GPGMEPP_MAKE_STRCMP(ByFingerprint, .primaryFingerprint());
 GPGMEPP_MAKE_STRCMP(ByKeyID, .keyID());
 GPGMEPP_MAKE_STRCMP(ByShortKeyID, .shortKeyID());
 GPGMEPP_MAKE_STRCMP(ByChainID, .chainID());
 
 #endif // __GPGMEPP_KEY_H__
diff --git a/lang/cpp/src/keygenerationresult.h b/lang/cpp/src/keygenerationresult.h
index a92151b4..1cbc9dd3 100644
--- a/lang/cpp/src/keygenerationresult.h
+++ b/lang/cpp/src/keygenerationresult.h
@@ -1,84 +1,85 @@
 /*
   keygenerationresult.h - wraps a gpgme keygen result
   Copyright (C) 2004 Klarälvdalens Datakonsult AB
   2016 Bundesamt für Sicherheit in der Informationstechnik
   Software engineering by Intevation GmbH
 
   This file is part of GPGME++.
 
   GPGME++ is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.
 
   GPGME++ 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 Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with GPGME++; see the file COPYING.LIB.  If not, write to the
   Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
 */
 
 #ifndef __GPGMEPP_KEYGENERATIONRESULT_H__
 #define __GPGMEPP_KEYGENERATIONRESULT_H__
 
 #include "gpgmefw.h"
 #include "result.h"
 #include "gpgmepp_export.h"
 
 #include <memory>
 
 namespace GpgME
 {
 
 class Error;
 
 class GPGMEPP_EXPORT KeyGenerationResult : public Result
 {
 public:
     KeyGenerationResult();
     KeyGenerationResult(gpgme_ctx_t ctx, int error);
     KeyGenerationResult(gpgme_ctx_t ctx, const Error &error);
     explicit KeyGenerationResult(const Error &err);
 
+    KeyGenerationResult(const KeyGenerationResult &other) = default;
     const KeyGenerationResult &operator=(KeyGenerationResult other)
     {
         swap(other);
         return *this;
     }
 
     void swap(KeyGenerationResult &other)
     {
         Result::swap(other);
         using std::swap;
         swap(this->d, other.d);
     }
 
     bool isNull() const;
 
     GPGMEPP_DEPRECATED bool primaryKeyGenerated() const
     {
         return isPrimaryKeyGenerated();
     }
     GPGMEPP_DEPRECATED bool subkeyGenerated() const
     {
         return isSubkeyGenerated();
     }
     bool isPrimaryKeyGenerated() const;
     bool isSubkeyGenerated() const;
     const char *fingerprint() const;
 
 private:
     class Private;
     void init(gpgme_ctx_t ctx);
     std::shared_ptr<Private> d;
 };
 
 }
 
 GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION(KeyGenerationResult)
 
 #endif // __GPGMEPP_KEYGENERATIONRESULT_H__
diff --git a/lang/cpp/src/keylistresult.h b/lang/cpp/src/keylistresult.h
index d0a86900..68e2a17b 100644
--- a/lang/cpp/src/keylistresult.h
+++ b/lang/cpp/src/keylistresult.h
@@ -1,83 +1,84 @@
 /*
   keylistresult.h - wraps a gpgme keylist result
   Copyright (C) 2004 Klarälvdalens Datakonsult AB
   2016 Bundesamt für Sicherheit in der Informationstechnik
   Software engineering by Intevation GmbH
 
   This file is part of GPGME++.
 
   GPGME++ is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.
 
   GPGME++ 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 Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with GPGME++; see the file COPYING.LIB.  If not, write to the
   Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
 */
 
 #ifndef __GPGMEPP_KEYLISTRESULT_H__
 #define __GPGMEPP_KEYLISTRESULT_H__
 
 #include "gpgmefw.h"
 #include "result.h"
 #include "gpgmepp_export.h"
 
 #include <memory>
 
 namespace GpgME
 {
 
 class Error;
 
 class GPGMEPP_EXPORT KeyListResult : public Result
 {
 public:
     KeyListResult();
     KeyListResult(gpgme_ctx_t ctx, int error);
     KeyListResult(gpgme_ctx_t ctx, const Error &error);
     explicit KeyListResult(const Error &err);
     KeyListResult(const Error &err, const _gpgme_op_keylist_result &res);
 
+    KeyListResult(const KeyListResult &other) = default;
     const KeyListResult &operator=(KeyListResult other)
     {
         swap(other);
         return *this;
     }
     void swap(KeyListResult &other)
     {
         Result::swap(other);
         using std::swap;
         swap(this->d, other.d);
     }
 
     const KeyListResult &operator+=(const KeyListResult &other)
     {
         mergeWith(other);
         return *this;
     }
 
     void mergeWith(const KeyListResult &other);
 
     bool isNull() const;
 
     bool isTruncated() const;
 
 private:
     void detach();
     void init(gpgme_ctx_t ctx);
     class Private;
     std::shared_ptr<Private> d;
 };
 
 }
 
 GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION(KeyListResult)
 
 #endif // __GPGMEPP_KEYLISTRESULT_H__
diff --git a/lang/cpp/src/notation.h b/lang/cpp/src/notation.h
index 5b89214c..b1ff2d50 100644
--- a/lang/cpp/src/notation.h
+++ b/lang/cpp/src/notation.h
@@ -1,86 +1,87 @@
 /*
   notation.h - wraps a gpgme verify result
   Copyright (C) 2004, 2007 Klarälvdalens Datakonsult AB
   2016 Bundesamt für Sicherheit in der Informationstechnik
   Software engineering by Intevation GmbH
 
   This file is part of GPGME++.
 
   GPGME++ is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.
 
   GPGME++ 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 Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with GPGME++; see the file COPYING.LIB.  If not, write to the
   Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
 */
 
 #ifndef __GPGMEPP_NOTATION_H__
 #define __GPGMEPP_NOTATION_H__
 
 #include "gpgmefw.h"
 #include "verificationresult.h"
 #include "gpgmepp_export.h"
 
 #include <memory>
 
 #include <iosfwd>
 
 namespace GpgME
 {
 
 class GPGMEPP_EXPORT Notation
 {
     friend class ::GpgME::Signature;
     Notation(const std::shared_ptr<VerificationResult::Private> &parent, unsigned int sindex, unsigned int nindex);
 public:
     Notation();
     explicit Notation(gpgme_sig_notation_t nota);
 
+    Notation(const Notation &other) = default;
     const Notation &operator=(Notation other)
     {
         swap(other);
         return *this;
     }
 
     void swap(Notation &other)
     {
         using std::swap;
         swap(this->d, other.d);
     }
 
     bool isNull() const;
 
     const char *name() const;
     const char *value() const;
 
     enum Flags {
         NoFlags = 0,
         HumanReadable = 1,
         Critical = 2
     };
     Flags flags() const;
 
     bool isHumanReadable() const;
     bool isCritical() const;
 
 private:
     class Private;
     std::shared_ptr<Private> d;
 };
 
 GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, const Notation &nota);
 GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, Notation::Flags flags);
 
 }
 
 GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION(Notation)
 
 #endif // __GPGMEPP_NOTATION_H__
diff --git a/lang/cpp/src/signingresult.h b/lang/cpp/src/signingresult.h
index c6654fca..0c2994c7 100644
--- a/lang/cpp/src/signingresult.h
+++ b/lang/cpp/src/signingresult.h
@@ -1,164 +1,167 @@
 /*
   signingresult.h - wraps a gpgme sign result
   Copyright (C) 2004 Klarälvdalens Datakonsult AB
   2016 Bundesamt für Sicherheit in der Informationstechnik
   Software engineering by Intevation GmbH
 
   This file is part of GPGME++.
 
   GPGME++ is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.
 
   GPGME++ 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 Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with GPGME++; see the file COPYING.LIB.  If not, write to the
   Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
 */
 
 #ifndef __GPGMEPP_SIGNINGRESULT_H__
 #define __GPGMEPP_SIGNINGRESULT_H__
 
 #include "global.h"
 #include "result.h"
 
 #include <time.h>
 
 #include <memory>
 
 #include <vector>
 #include <iosfwd>
 
 namespace GpgME
 {
 
 class Error;
 class CreatedSignature;
 class InvalidSigningKey;
 
 class GPGMEPP_EXPORT SigningResult : public Result
 {
 public:
     SigningResult();
     SigningResult(gpgme_ctx_t ctx, int error);
     SigningResult(gpgme_ctx_t ctx, const Error &error);
     explicit SigningResult(const Error &err);
 
+    SigningResult(const SigningResult &other) = default;
     const SigningResult &operator=(SigningResult other)
     {
         swap(other);
         return *this;
     }
 
     void swap(SigningResult &other)
     {
         Result::swap(other);
         using std::swap;
         swap(this->d, other.d);
     }
 
     bool isNull() const;
 
     CreatedSignature createdSignature(unsigned int index) const;
     std::vector<CreatedSignature> createdSignatures() const;
 
     InvalidSigningKey invalidSigningKey(unsigned int index) const;
     std::vector<InvalidSigningKey> invalidSigningKeys() const;
 
     class Private;
 private:
     void init(gpgme_ctx_t ctx);
     std::shared_ptr<Private> d;
 };
 
 GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, const SigningResult &result);
 
 class GPGMEPP_EXPORT InvalidSigningKey
 {
     friend class ::GpgME::SigningResult;
     InvalidSigningKey(const std::shared_ptr<SigningResult::Private> &parent, unsigned int index);
 public:
     InvalidSigningKey();
 
+    InvalidSigningKey(const InvalidSigningKey &other) = default;
     const InvalidSigningKey &operator=(InvalidSigningKey other)
     {
         swap(other);
         return *this;
     }
 
     void swap(InvalidSigningKey &other)
     {
         using std::swap;
         swap(this->d, other.d);
         swap(this->idx, other.idx);
     }
 
     bool isNull() const;
 
     const char *fingerprint() const;
     Error reason() const;
 
 private:
     std::shared_ptr<SigningResult::Private> d;
     unsigned int idx;
 };
 
 GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, const InvalidSigningKey &key);
 
 class GPGMEPP_EXPORT CreatedSignature
 {
     friend class ::GpgME::SigningResult;
     CreatedSignature(const std::shared_ptr<SigningResult::Private> &parent, unsigned int index);
 public:
 
     CreatedSignature();
 
+    CreatedSignature(const CreatedSignature &other) = default;
     const CreatedSignature &operator=(CreatedSignature other)
     {
         swap(other);
         return *this;
     }
 
     void swap(CreatedSignature &other)
     {
         using std::swap;
         swap(this->d, other.d);
         swap(this->idx, other.idx);
     }
 
     bool isNull() const;
 
     const char *fingerprint() const;
 
     time_t creationTime() const;
 
     SignatureMode mode() const;
 
     unsigned int publicKeyAlgorithm() const;
     const char *publicKeyAlgorithmAsString() const;
 
     unsigned int hashAlgorithm() const;
     const char *hashAlgorithmAsString() const;
 
     unsigned int signatureClass() const;
 
 private:
     std::shared_ptr<SigningResult::Private> d;
     unsigned int idx;
 };
 
 GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, const CreatedSignature &sig);
 
 }
 
 GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION(SigningResult)
 GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION(InvalidSigningKey)
 GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION(CreatedSignature)
 
 #endif // __GPGMEPP_SIGNINGRESULT_H__
diff --git a/lang/cpp/src/swdbresult.h b/lang/cpp/src/swdbresult.h
index d13b57c8..d4340fe1 100644
--- a/lang/cpp/src/swdbresult.h
+++ b/lang/cpp/src/swdbresult.h
@@ -1,129 +1,130 @@
 /*
   swdbresult.h - wraps a gpgme swdb query / rsult
   Copyright (C) 2016 by Bundesamt für Sicherheit in der Informationstechnik
   Software engineering by Intevation GmbH
 
   This file is part of GPGME++.
 
   GPGME++ is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.
 
   GPGME++ 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 Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with GPGME++; see the file COPYING.LIB.  If not, write to the
   Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
 */
 #ifndef __GPGMEPP_SWDB_H__
 #define __GPGMEPP_SWDB_H__
 
 #include "gpgmepp_export.h"
 
 #include "global.h"
 #include "engineinfo.h"
 
 #include <vector>
 #include <string>
 #include <iostream>
 #include <ostream>
 
 namespace GpgME
 {
 
 class GPGMEPP_EXPORT SwdbResult
 {
 public:
     /* Obtain swdb results through query() */
     SwdbResult();
     explicit SwdbResult(gpgme_query_swdb_result_t result);
 
     /** Query the swdb to get information about updates.
      *
      * Runs gpgconf --query-swdb through gpgme and
      * returns a list of results.
      * If iversion is given as NULL a check is only done if GPGME
      * can figure out the version by itself (for example when using
      * "gpgme" or "gnupg").
      *
      * If NULL is used for name the current gpgme version is
      * checked.
      *
      * @param name: Name of the component to query.
      * @param iversion: Optionally the installed version.
      * @param err: Optional error.
      */
     static std::vector<SwdbResult> query(const char *name,
                                          const char *iversion = NULL,
                                          Error *err = NULL);
 
+    SwdbResult(const SwdbResult &other) = default;
     const SwdbResult &operator=(SwdbResult other)
     {
         swap(other);
         return *this;
     }
 
     void swap(SwdbResult &other)
     {
         using std::swap;
         swap(this->d, other.d);
     }
     bool isNull() const;
 
     /* The name of the package (e.g. "gpgme", "gnupg") */
     std::string name() const;
 
     /* The version of the installed version.  */
     EngineInfo::Version installedVersion() const;
 
     /* The time the online info was created.  */
     unsigned long created() const;
 
     /* The time the online info was retrieved.  */
     unsigned long retrieved() const;
 
     /* This bit is set if an error occurred or some of the information
      * in this structure may not be set.  */
     bool warning() const;
 
     /* An update is available.  */
     bool update() const;
 
     /* The update is important.  */
     bool urgent() const;
 
     /* No information at all available.  */
     bool noinfo() const;
 
     /* The package name is not known. */
     bool unknown() const;
 
     /* The information here is too old.  */
     bool tooOld() const;
 
     /* Other error.  */
     bool error() const;
 
     /* The version of the latest released version.  */
     EngineInfo::Version version() const;
 
     /* The release date of that version.  */
     unsigned long releaseDate() const;
 
 private:
     class Private;
     std::shared_ptr<Private> d;
 };
 
 GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, const SwdbResult &info);
 
 } // namespace GpgME
 
 GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION(SwdbResult)
 
 #endif
diff --git a/lang/cpp/src/tofuinfo.h b/lang/cpp/src/tofuinfo.h
index 5bb024f2..67ed62a5 100644
--- a/lang/cpp/src/tofuinfo.h
+++ b/lang/cpp/src/tofuinfo.h
@@ -1,123 +1,124 @@
 /*
   tofuinfo.h - wraps gpgme tofu info
   Copyright (C) 2016 by Bundesamt für Sicherheit in der Informationstechnik
   Software engineering by Intevation GmbH
 
   This file is part of GPGME++.
 
   GPGME++ is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.
 
   GPGME++ 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 Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with GPGME++; see the file COPYING.LIB.  If not, write to the
   Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
 */
 
 #ifndef __GPGMEPP_TOFUINFO_H__
 #define __GPGMEPP_TOFUINFO_H__
 
 #include "gpgmepp_export.h"
 
 #include "global.h"
 
 #include <memory>
 
 namespace GpgME
 {
 
 class GPGMEPP_EXPORT TofuInfo
 {
 public:
     TofuInfo();
     explicit TofuInfo(gpgme_tofu_info_t info);
 
+    TofuInfo(const TofuInfo &other) = default;
     const TofuInfo &operator=(TofuInfo other)
     {
         swap(other);
         return *this;
     }
 
     void swap(TofuInfo &other)
     {
         using std::swap;
         swap(this->d, other.d);
     }
 
     bool isNull() const;
 
     /* @enum Validity
      * @brief The TOFU Validity. */
     enum Validity : unsigned int {
         /*! Unknown (uninitialized).*/
         ValidityUnknown,
         /*! TOFU Conflict.*/
         Conflict,
         /*! Key without history.*/
         NoHistory,
         /*! Key with too little history.*/
         LittleHistory,
         /*! Key with enough history for basic trust.*/
         BasicHistory,
         /*! Key with a lot of history.*/
         LargeHistory,
     };
     Validity validity() const;
 
     /* @enum Policy
      * @brief The TOFU Validity. */
     enum Policy : unsigned int {
         /*! GPGME_TOFU_POLICY_NONE */
         PolicyNone,
         /*! GPGME_TOFU_POLICY_AUTO */
         PolicyAuto,
         /*! GPGME_TOFU_POLICY_GOOD */
         PolicyGood,
         /*! GPGME_TOFU_POLICY_UNKNOWN */
         PolicyUnknown,
         /*! GPGME_TOFU_POLICY_BAD */
         PolicyBad,
         /*! GPGME_TOFU_POLICY_ASK */
         PolicyAsk,
     };
     Policy policy() const;
 
     /* Number of signatures seen for this binding.  Capped at USHRT_MAX.  */
     unsigned short signCount() const;
 
     /* Number of encryption done to this binding.  Capped at USHRT_MAX.  */
     unsigned short encrCount() const;
 
     /** Number of seconds since epoch when the first message was verified */
     unsigned long signFirst() const;
 
     /** Number of seconds since epoch when the last message was verified */
     unsigned long signLast() const;
 
     /** Number of seconds since epoch when the first message was encrypted */
     unsigned long encrFirst() const;
 
     /** Number of seconds since epoch when the last message was encrypted */
     unsigned long encrLast() const;
 
     /* If non-NULL a human readable string summarizing the TOFU data. */
     const char *description() const;
 
 private:
     class Private;
     std::shared_ptr<Private> d;
 };
 
 GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, const TofuInfo &info);
 
 } // namespace GpgME
 
 GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION(TofuInfo)
 #endif // __GPGMEPP_TOFUINFO_H__
diff --git a/lang/cpp/src/verificationresult.h b/lang/cpp/src/verificationresult.h
index 3f6299ca..f43bd39f 100644
--- a/lang/cpp/src/verificationresult.h
+++ b/lang/cpp/src/verificationresult.h
@@ -1,204 +1,206 @@
 /*
   verificationresult.h - wraps a gpgme verify result
   Copyright (C) 2004 Klarälvdalens Datakonsult AB
   2016 Bundesamt für Sicherheit in der Informationstechnik
   Software engineering by Intevation GmbH
 
   This file is part of GPGME++.
 
   GPGME++ is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.
 
   GPGME++ 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 Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with GPGME++; see the file COPYING.LIB.  If not, write to the
   Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
 */
 
 #ifndef __GPGMEPP_VERIFICATIONRESULT_H__
 #define __GPGMEPP_VERIFICATIONRESULT_H__
 
 #include "gpgmefw.h"
 #include "result.h"
 #include "gpgmepp_export.h"
 
 #include <time.h>
 
 #include <memory>
 
 #include <vector>
 #include <iosfwd>
 
 namespace GpgME
 {
 
 class Error;
 class Signature;
 class Notation;
 class Key;
 
 class GPGMEPP_EXPORT VerificationResult : public Result
 {
 public:
     VerificationResult();
     VerificationResult(gpgme_ctx_t ctx, int error);
     VerificationResult(gpgme_ctx_t ctx, const Error &error);
     explicit VerificationResult(const Error &err);
 
+    VerificationResult(const VerificationResult &other) = default;
     const VerificationResult &operator=(VerificationResult other)
     {
         swap(other);
         return *this;
     }
 
     void swap(VerificationResult &other)
     {
         Result::swap(other);
         using std::swap;
         swap(this->d, other.d);
     }
 
     bool isNull() const;
 
     const char *fileName() const;
 
     unsigned int numSignatures() const;
     Signature signature(unsigned int index) const;
     std::vector<Signature> signatures() const;
 
     class Private;
 private:
     void init(gpgme_ctx_t ctx);
     std::shared_ptr<Private> d;
 };
 
 GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, const VerificationResult &result);
 
 class GPGMEPP_EXPORT Signature
 {
     friend class ::GpgME::VerificationResult;
     Signature(const std::shared_ptr<VerificationResult::Private> &parent, unsigned int index);
 public:
     typedef GPGMEPP_DEPRECATED GpgME::Notation Notation;
 
     Signature();
 
+    Signature(const Signature &other) = default;
     const Signature &operator=(Signature other)
     {
         swap(other);
         return *this;
     }
 
     void swap(Signature &other)
     {
         using std::swap;
         swap(this->d, other.d);
         swap(this->idx, other.idx);
     }
 
     bool isNull() const;
 
     enum Summary {
         None       = 0x000,
         Valid      = 0x001,
         Green      = 0x002,
         Red        = 0x004,
         KeyRevoked = 0x008,
         KeyExpired = 0x010,
         SigExpired = 0x020,
         KeyMissing = 0x040,
         CrlMissing = 0x080,
         CrlTooOld  = 0x100,
         BadPolicy  = 0x200,
         SysError   = 0x400,
         TofuConflict= 0x800
     };
     Summary summary() const;
 
     const char *fingerprint() const;
 
     Error status() const;
 
     time_t creationTime() const;
     time_t expirationTime() const;
     bool neverExpires() const;
 
     GPGMEPP_DEPRECATED bool wrongKeyUsage() const
     {
         return isWrongKeyUsage();
     }
     bool isWrongKeyUsage() const;
     bool isVerifiedUsingChainModel() const;
     bool isDeVs() const;
 
     enum PKAStatus {
         UnknownPKAStatus, PKAVerificationFailed, PKAVerificationSucceeded
     };
     PKAStatus pkaStatus() const;
     const char *pkaAddress() const;
 
     enum Validity {
         Unknown, Undefined, Never, Marginal, Full, Ultimate
     };
     Validity validity() const;
     char validityAsString() const;
     Error nonValidityReason() const;
 
     unsigned int publicKeyAlgorithm() const;
     const char *publicKeyAlgorithmAsString() const;
 
     unsigned int hashAlgorithm() const;
     const char *hashAlgorithmAsString() const;
 
     const char *policyURL() const;
     GpgME::Notation notation(unsigned int index) const;
     std::vector<GpgME::Notation> notations() const;
 
     /** Returns the key object associated with this signature.
      * May be incomplete but will have at least the fingerprint
      * set or the associated TOFU Information if applicable. */
     GpgME::Key key() const;
 
     /* Search / Update the key of this signature.
      *
      * Same as above but if search is set to true this will
      * either update the key provided by the engine or search
      * the key in the engine. The key is cached.
      *
      * As this involves an engine call it might take some time
      * to finish so it should be avoided to do this in a UI
      * thread. The result will be cached and no engine call
      * will be done if update is set to false and a key is
      * already cached.
      *
      * If no key was provided by the engine this will look
      * up the key so this call might block while the engine
      * is called to obtain the key.
      *
      * If both search and update are false this is the same
      * as calling key()
      */
     GpgME::Key key(bool search, bool update) const;
 
 private:
     std::shared_ptr<VerificationResult::Private> d;
     unsigned int idx;
 };
 
 GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, const Signature &sig);
 GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, Signature::PKAStatus pkaStatus);
 GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, Signature::Summary summary);
 
 }
 
 GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION(VerificationResult)
 GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION(Signature)
 
 #endif // __GPGMEPP_VERIFICATIONRESULT_H__
diff --git a/lang/cpp/src/vfsmountresult.h b/lang/cpp/src/vfsmountresult.h
index b46eeb1c..6bc67ba3 100644
--- a/lang/cpp/src/vfsmountresult.h
+++ b/lang/cpp/src/vfsmountresult.h
@@ -1,76 +1,77 @@
 /*
   vfsmountresult.h - wraps a gpgme vfs mount result
   Copyright (C) 2009 Klarälvdalens Datakonsult AB <info@kdab.com>
   Author: Marc Mutz <marc@kdab.com>, Volker Krause <volker@kdab.com>
 
   This file is part of GPGME++.
 
   GPGME++ is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.
 
   GPGME++ 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 Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with GPGME++; see the file COPYING.LIB.  If not, write to the
   Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
 */
 
 #ifndef __GPGMEPP_VFSMOUNTRESULT_H__
 #define __GPGMEPP_VFSMOUNTRESULT_H__
 
 #include "gpgmefw.h"
 #include "result.h"
 #include "gpgmepp_export.h"
 
 #include <memory>
 
 #include <vector>
 #include <iosfwd>
 
 namespace GpgME
 {
 
 class Error;
 
 class GPGMEPP_EXPORT VfsMountResult : public Result
 {
 public:
     VfsMountResult();
     VfsMountResult(gpgme_ctx_t ctx, const Error &error, const Error &opError);
     explicit VfsMountResult(const Error &err);
 
+    VfsMountResult(const VfsMountResult &other) = default;
     const VfsMountResult &operator=(VfsMountResult other)
     {
         swap(other);
         return *this;
     }
 
     void swap(VfsMountResult &other)
     {
         Result::swap(other);
         using std::swap;
         swap(this->d, other.d);
     }
 
     bool isNull() const;
     const char *mountDir() const;
 
     class Private;
 private:
     void init(gpgme_ctx_t ctx);
     std::shared_ptr<Private> d;
 };
 
 GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, const VfsMountResult &result);
 
 }
 
 GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION(VfsMountResult)
 
 #endif // __GPGMEPP_VFSMOUNTRESULT_H__