From 027a655b55dbe92b83f2fefbce4bedeac4deed6c Mon Sep 17 00:00:00 2001 From: Alarig Le Lay Date: Thu, 30 Mar 2023 11:24:17 +0200 Subject: [PATCH] dev-libs/ucommon: new package, add 7.0.0 --- dev-libs/ucommon/Manifest | 1 + ...ucommon-6.0.3-install_gcrypt.m4_file.patch | 126 +++++ ...+17-dynamic-exception-specifications.patch | 502 ++++++++++++++++++ dev-libs/ucommon/metadata.xml | 5 + dev-libs/ucommon/ucommon-7.0.0.ebuild | 75 +++ 5 files changed, 709 insertions(+) create mode 100644 dev-libs/ucommon/Manifest create mode 100644 dev-libs/ucommon/files/ucommon-6.0.3-install_gcrypt.m4_file.patch create mode 100644 dev-libs/ucommon/files/ucommon-7.0.0-c++17-dynamic-exception-specifications.patch create mode 100644 dev-libs/ucommon/metadata.xml create mode 100644 dev-libs/ucommon/ucommon-7.0.0.ebuild diff --git a/dev-libs/ucommon/Manifest b/dev-libs/ucommon/Manifest new file mode 100644 index 0000000..57e0375 --- /dev/null +++ b/dev-libs/ucommon/Manifest @@ -0,0 +1 @@ +DIST ucommon-7.0.0.tar.gz 837905 BLAKE2B ddc82d5d1a88d66f353d9e69eacd7cfaaa0204acb8b9c4152559a009d287f2ffdb7feedc6fc0303c93a39d607498dd15bf83798d088857582f79be435d010ca7 SHA512 d32f8603d920eb98b5d4bc75224a7a8bb8bf2001a8dd3152626a8438ea4c39503a7446dec3aa90cf464b7abb68a6e42bac488ef9705517bd333b64bce219915b diff --git a/dev-libs/ucommon/files/ucommon-6.0.3-install_gcrypt.m4_file.patch b/dev-libs/ucommon/files/ucommon-6.0.3-install_gcrypt.m4_file.patch new file mode 100644 index 0000000..502a27b --- /dev/null +++ b/dev-libs/ucommon/files/ucommon-6.0.3-install_gcrypt.m4_file.patch @@ -0,0 +1,126 @@ +--- /dev/null ++++ m4/libgcrypt.m4 +@@ -0,0 +1,123 @@ ++dnl Autoconf macros for libgcrypt ++dnl Copyright (C) 2002, 2004 Free Software Foundation, Inc. ++dnl ++dnl This file is free software; as a special exception the author gives ++dnl unlimited permission to copy and/or distribute it, with or without ++dnl modifications, as long as this notice is preserved. ++dnl ++dnl This file is distributed in the hope that it will be useful, but ++dnl WITHOUT ANY WARRANTY, to the extent permitted by law; without even the ++dnl implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. ++ ++ ++dnl AM_PATH_LIBGCRYPT([MINIMUM-VERSION, ++dnl [ACTION-IF-FOUND [, ACTION-IF-NOT-FOUND ]]]) ++dnl Test for libgcrypt and define LIBGCRYPT_CFLAGS and LIBGCRYPT_LIBS. ++dnl MINIMUN-VERSION is a string with the version number optionalliy prefixed ++dnl with the API version to also check the API compatibility. Example: ++dnl a MINIMUN-VERSION of 1:1.2.5 won't pass the test unless the installed ++dnl version of libgcrypt is at least 1.2.5 *and* the API number is 1. Using ++dnl this features allows to prevent build against newer versions of libgcrypt ++dnl with a changed API. ++dnl ++AC_DEFUN([AM_PATH_LIBGCRYPT], ++[ AC_ARG_WITH(libgcrypt-prefix, ++ AC_HELP_STRING([--with-libgcrypt-prefix=PFX], ++ [prefix where LIBGCRYPT is installed (optional)]), ++ libgcrypt_config_prefix="$withval", libgcrypt_config_prefix="") ++ if test x$libgcrypt_config_prefix != x ; then ++ if test x${LIBGCRYPT_CONFIG+set} != xset ; then ++ LIBGCRYPT_CONFIG=$libgcrypt_config_prefix/bin/libgcrypt-config ++ fi ++ fi ++ ++ AC_PATH_TOOL(LIBGCRYPT_CONFIG, libgcrypt-config, no) ++ tmp=ifelse([$1], ,1:1.2.0,$1) ++ if echo "$tmp" | grep ':' >/dev/null 2>/dev/null ; then ++ req_libgcrypt_api=`echo "$tmp" | sed 's/\(.*\):\(.*\)/\1/'` ++ min_libgcrypt_version=`echo "$tmp" | sed 's/\(.*\):\(.*\)/\2/'` ++ else ++ req_libgcrypt_api=0 ++ min_libgcrypt_version="$tmp" ++ fi ++ ++ AC_MSG_CHECKING(for LIBGCRYPT - version >= $min_libgcrypt_version) ++ ok=no ++ if test "$LIBGCRYPT_CONFIG" != "no" ; then ++ req_major=`echo $min_libgcrypt_version | \ ++ sed 's/\([[0-9]]*\)\.\([[0-9]]*\)\.\([[0-9]]*\)/\1/'` ++ req_minor=`echo $min_libgcrypt_version | \ ++ sed 's/\([[0-9]]*\)\.\([[0-9]]*\)\.\([[0-9]]*\)/\2/'` ++ req_micro=`echo $min_libgcrypt_version | \ ++ sed 's/\([[0-9]]*\)\.\([[0-9]]*\)\.\([[0-9]]*\)/\3/'` ++ libgcrypt_config_version=`$LIBGCRYPT_CONFIG --version` ++ major=`echo $libgcrypt_config_version | \ ++ sed 's/\([[0-9]]*\)\.\([[0-9]]*\)\.\([[0-9]]*\).*/\1/'` ++ minor=`echo $libgcrypt_config_version | \ ++ sed 's/\([[0-9]]*\)\.\([[0-9]]*\)\.\([[0-9]]*\).*/\2/'` ++ micro=`echo $libgcrypt_config_version | \ ++ sed 's/\([[0-9]]*\)\.\([[0-9]]*\)\.\([[0-9]]*\).*/\3/'` ++ if test "$major" -gt "$req_major"; then ++ ok=yes ++ else ++ if test "$major" -eq "$req_major"; then ++ if test "$minor" -gt "$req_minor"; then ++ ok=yes ++ else ++ if test "$minor" -eq "$req_minor"; then ++ if test "$micro" -ge "$req_micro"; then ++ ok=yes ++ fi ++ fi ++ fi ++ fi ++ fi ++ fi ++ if test $ok = yes; then ++ AC_MSG_RESULT([yes ($libgcrypt_config_version)]) ++ else ++ AC_MSG_RESULT(no) ++ fi ++ if test $ok = yes; then ++ # If we have a recent libgcrypt, we should also check that the ++ # API is compatible ++ if test "$req_libgcrypt_api" -gt 0 ; then ++ tmp=`$LIBGCRYPT_CONFIG --api-version 2>/dev/null || echo 0` ++ if test "$tmp" -gt 0 ; then ++ AC_MSG_CHECKING([LIBGCRYPT API version]) ++ if test "$req_libgcrypt_api" -eq "$tmp" ; then ++ AC_MSG_RESULT([okay]) ++ else ++ ok=no ++ AC_MSG_RESULT([does not match. want=$req_libgcrypt_api got=$tmp]) ++ fi ++ fi ++ fi ++ fi ++ if test $ok = yes; then ++ LIBGCRYPT_CFLAGS=`$LIBGCRYPT_CONFIG --cflags` ++ LIBGCRYPT_LIBS=`$LIBGCRYPT_CONFIG --libs` ++ ifelse([$2], , :, [$2]) ++ if test x"$host" != x ; then ++ libgcrypt_config_host=`$LIBGCRYPT_CONFIG --host 2>/dev/null || echo none` ++ if test x"$libgcrypt_config_host" != xnone ; then ++ if test x"$libgcrypt_config_host" != x"$host" ; then ++ AC_MSG_WARN([[ ++*** ++*** The config script $LIBGCRYPT_CONFIG was ++*** built for $libgcrypt_config_host and thus may not match the ++*** used host $host. ++*** You may want to use the configure option --with-libgcrypt-prefix ++*** to specify a matching config script. ++***]]) ++ fi ++ fi ++ fi ++ else ++ LIBGCRYPT_CFLAGS="" ++ LIBGCRYPT_LIBS="" ++ ifelse([$3], , :, [$3]) ++ fi ++ AC_SUBST(LIBGCRYPT_CFLAGS) ++ AC_SUBST(LIBGCRYPT_LIBS) ++]) diff --git a/dev-libs/ucommon/files/ucommon-7.0.0-c++17-dynamic-exception-specifications.patch b/dev-libs/ucommon/files/ucommon-7.0.0-c++17-dynamic-exception-specifications.patch new file mode 100644 index 0000000..49e4b78 --- /dev/null +++ b/dev-libs/ucommon/files/ucommon-7.0.0-c++17-dynamic-exception-specifications.patch @@ -0,0 +1,502 @@ +--- a/commoncpp/exception.cpp ++++ b/commoncpp/exception.cpp +@@ -53,14 +53,14 @@ + + namespace ost { + +-Exception::Exception(const String& what_arg) throw(): ++Exception::Exception(const String& what_arg) : + _what(what_arg) + {} + +-Exception::~Exception() throw() ++Exception::~Exception() + {} + +-const char *Exception::what() const throw() ++const char *Exception::what() const noexcept + { + return _what.c_str(); + } +@@ -70,22 +70,22 @@ + return _what.c_str(); + } + +-IOException::IOException(const String &what_arg, long systemError) throw() : ++IOException::IOException(const String &what_arg, long systemError) : + Exception(what_arg), _systemError(systemError), + _systemErrorString(NULL) { + } + +-IOException::~IOException() throw() ++IOException::~IOException() + { + delete [] _systemErrorString; + } + +-long IOException::getSystemError() const throw() ++long IOException::getSystemError() const + { + return _systemError; + } + +-const char* IOException::getSystemErrorString() const throw() ++const char* IOException::getSystemErrorString() const + { + const uint32_t errStrSize = 2048; + if ( !_systemErrorString ) +--- a/commoncpp/persist.cpp ++++ b/commoncpp/persist.cpp +@@ -39,7 +39,7 @@ + return _what; + } + +-PersistException::~PersistException() throw() ++PersistException::~PersistException() + { + } + +@@ -114,7 +114,7 @@ + TypeManager::remove(myName.c_str()); + } + +-PersistEngine::PersistEngine(std::iostream& stream, EngineMode mode) throw(PersistException) : ++PersistEngine::PersistEngine(std::iostream& stream, EngineMode mode) : + myUnderlyingStream(stream), myOperationalMode(mode) + { + } +@@ -125,7 +125,7 @@ + myUnderlyingStream.sync(); + } + +-void PersistEngine::writeBinary(const uint8_t* data, const uint32_t size) throw(PersistException) ++void PersistEngine::writeBinary(const uint8_t* data, const uint32_t size) + { + if(myOperationalMode != modeWrite) + throw("Cannot write to an input Engine"); +@@ -133,14 +133,14 @@ + } + + +-void PersistEngine::readBinary(uint8_t* data, uint32_t size) throw(PersistException) ++void PersistEngine::readBinary(uint8_t* data, uint32_t size) + { + if(myOperationalMode != modeRead) + throw("Cannot read from an output Engine"); + myUnderlyingStream.read((char *)data,size); + } + +-void PersistEngine::write(const PersistObject *object) throw(PersistException) ++void PersistEngine::write(const PersistObject *object) + { + // Pre-step, if object is NULL, then don't serialize it - serialize a + // marker to say that it is null. +@@ -181,7 +181,7 @@ + } + } + +-void PersistEngine::read(PersistObject &object) throw(PersistException) ++void PersistEngine::read(PersistObject &object) + { + uint32_t id = 0; + read(id); +@@ -202,7 +202,7 @@ + readObject(&object); + } + +-void PersistEngine::read(PersistObject *&object) throw(PersistException) ++void PersistEngine::read(PersistObject *&object) + { + uint32_t id = 0; + read(id); +@@ -237,7 +237,7 @@ + throw(PersistException(std::string("Unable to instantiate object of class ")+className)); + } + +-void PersistEngine::readObject(PersistObject* object) throw(PersistException) ++void PersistEngine::readObject(PersistObject* object) + { + // Okay then - we can make this object + myArchiveVector.push_back(object); +@@ -251,7 +251,7 @@ + throw( PersistException("Missing End-of-Object marker")); + } + +-const std::string PersistEngine::readClass() throw(PersistException) ++const std::string PersistEngine::readClass() + { + // Okay - read the identifier for the class in... + uint32_t classId = 0; +@@ -269,14 +269,14 @@ + return className; + } + +-void PersistEngine::write(const std::string& str) throw(PersistException) ++void PersistEngine::write(const std::string& str) + { + uint32_t len = (uint32_t)str.length(); + write(len); + writeBinary((uint8_t*)str.c_str(),len); + } + +-void PersistEngine::read(std::string& str) throw(PersistException) ++void PersistEngine::read(std::string& str) + { + uint32_t len = 0; + read(len); +--- a/commoncpp/tokenizer.cpp ++++ b/commoncpp/tokenizer.cpp +@@ -70,7 +70,7 @@ + } + + +-StringTokenizer::iterator& StringTokenizer::iterator::operator ++ () THROWS (StringTokenizer::NoSuchElementException) ++StringTokenizer::iterator& StringTokenizer::iterator::operator ++ () + { + + // someone requested to read beyond the end .. tsts +@@ -106,7 +106,7 @@ + * if no one requests the token, no time is spent skipping the whitespaces + * or allocating memory. + */ +-const char * StringTokenizer::iterator::operator * () THROWS (StringTokenizer::NoSuchElementException) ++const char * StringTokenizer::iterator::operator * () + { + // someone requested to read beyond the end .. tsts + if (endp == myTok->itEnd.endp) +--- a/inc/commoncpp/exception.h ++++ b/inc/commoncpp/exception.h +@@ -77,10 +77,10 @@ + String _what; + + public: +- Exception(const String& what_arg) throw(); +- virtual ~Exception() throw(); ++ Exception(const String& what_arg); ++ virtual ~Exception(); + virtual const char *getString() const; +- virtual const char *what() const throw(); ++ virtual const char *what() const noexcept; + }; + + /** +@@ -96,11 +96,11 @@ + mutable char* _systemErrorString; + + public: +- IOException(const String &what_arg, long systemError = 0) throw(); +- virtual ~IOException() throw(); ++ IOException(const String &what_arg, long systemError = 0); ++ virtual ~IOException(); + +- virtual long getSystemError() const throw(); +- virtual const char* getSystemErrorString() const throw(); ++ virtual long getSystemError() const; ++ virtual const char* getSystemErrorString() const; + }; + + /** +--- a/inc/commoncpp/persist.h ++++ b/inc/commoncpp/persist.h +@@ -46,7 +46,7 @@ + PersistException(const std::string& reason); + const std::string& getString() const; + +- virtual ~PersistException() throw(); ++ virtual ~PersistException(); + + protected: + std::string _what; +@@ -210,7 +210,7 @@ + * the given mode. The stream must be initialized properly prior + * to this call or problems will ensue. + */ +- PersistEngine(std::iostream& stream, EngineMode mode) throw(PersistException); ++ PersistEngine(std::iostream& stream, EngineMode mode); + + virtual ~PersistEngine(); + +@@ -219,75 +219,75 @@ + /** + * writes a PersistObject from a reference. + */ +- inline void write(const PersistObject &object) throw(PersistException) ++ inline void write(const PersistObject &object) + {write(&object);} + + /** + * writes a PersistObject from a pointer. + */ +- void write(const PersistObject *object) throw(PersistException); ++ void write(const PersistObject *object); + + // writes supported primitive types + // shortcut, to make the following more readable + #define CCXX_ENGINEWRITE_REF(valref) writeBinary((const uint8_t*)&valref,sizeof(valref)) +- inline void write(int8_t i) throw(PersistException) { CCXX_ENGINEWRITE_REF(i); } +- inline void write(uint8_t i) throw(PersistException) { CCXX_ENGINEWRITE_REF(i); } +- inline void write(int16_t i) throw(PersistException) { CCXX_ENGINEWRITE_REF(i); } +- inline void write(uint16_t i) throw(PersistException) { CCXX_ENGINEWRITE_REF(i); } +- inline void write(int32_t i) throw(PersistException) { CCXX_ENGINEWRITE_REF(i); } +- inline void write(uint32_t i) throw(PersistException) { CCXX_ENGINEWRITE_REF(i); } +- inline void write(float i) throw(PersistException) { CCXX_ENGINEWRITE_REF(i); } +- inline void write(double i) throw(PersistException) { CCXX_ENGINEWRITE_REF(i); } +- inline void write(bool i) throw(PersistException) { CCXX_ENGINEWRITE_REF(i); } ++ inline void write(int8_t i) { CCXX_ENGINEWRITE_REF(i); } ++ inline void write(uint8_t i) { CCXX_ENGINEWRITE_REF(i); } ++ inline void write(int16_t i) { CCXX_ENGINEWRITE_REF(i); } ++ inline void write(uint16_t i) { CCXX_ENGINEWRITE_REF(i); } ++ inline void write(int32_t i) { CCXX_ENGINEWRITE_REF(i); } ++ inline void write(uint32_t i) { CCXX_ENGINEWRITE_REF(i); } ++ inline void write(float i) { CCXX_ENGINEWRITE_REF(i); } ++ inline void write(double i) { CCXX_ENGINEWRITE_REF(i); } ++ inline void write(bool i) { CCXX_ENGINEWRITE_REF(i); } + #undef CCXX_ENGINEWRITE_REF + +- void write(const std::string& str) throw(PersistException); ++ void write(const std::string& str); + + // Every write operation boils down to one or more of these +- void writeBinary(const uint8_t* data, const uint32_t size) throw(PersistException); ++ void writeBinary(const uint8_t* data, const uint32_t size); + + // Read Operations + + /** + * reads a PersistObject into a reference overwriting the object. + */ +- void read(PersistObject &object) throw(PersistException); ++ void read(PersistObject &object); + + /** + * reads a PersistObject into a pointer allocating memory for the object if necessary. + */ +- void read(PersistObject *&object) throw(PersistException); ++ void read(PersistObject *&object); + + // reads supported primitive types + // shortcut, to make the following more readable + #define CCXX_ENGINEREAD_REF(valref) readBinary((uint8_t*)&valref,sizeof(valref)) +- inline void read(int8_t& i) throw(PersistException) { CCXX_ENGINEREAD_REF(i); } +- inline void read(uint8_t& i) throw(PersistException) { CCXX_ENGINEREAD_REF(i); } +- inline void read(int16_t& i) throw(PersistException) { CCXX_ENGINEREAD_REF(i); } +- inline void read(uint16_t& i) throw(PersistException) { CCXX_ENGINEREAD_REF(i); } +- inline void read(int32_t& i) throw(PersistException) { CCXX_ENGINEREAD_REF(i); } +- inline void read(uint32_t& i) throw(PersistException) { CCXX_ENGINEREAD_REF(i); } +- inline void read(float& i) throw(PersistException) { CCXX_ENGINEREAD_REF(i); } +- inline void read(double& i) throw(PersistException) { CCXX_ENGINEREAD_REF(i); } +- inline void read(bool &i) throw(PersistException) { CCXX_ENGINEREAD_REF(i); } ++ inline void read(int8_t& i) { CCXX_ENGINEREAD_REF(i); } ++ inline void read(uint8_t& i) { CCXX_ENGINEREAD_REF(i); } ++ inline void read(int16_t& i) { CCXX_ENGINEREAD_REF(i); } ++ inline void read(uint16_t& i) { CCXX_ENGINEREAD_REF(i); } ++ inline void read(int32_t& i) { CCXX_ENGINEREAD_REF(i); } ++ inline void read(uint32_t& i) { CCXX_ENGINEREAD_REF(i); } ++ inline void read(float& i) { CCXX_ENGINEREAD_REF(i); } ++ inline void read(double& i) { CCXX_ENGINEREAD_REF(i); } ++ inline void read(bool &i) { CCXX_ENGINEREAD_REF(i); } + #undef CCXX_ENGINEREAD_REF + +- void read(std::string& str) throw(PersistException); ++ void read(std::string& str); + + // Every read operation boiled down to one or more of these +- void readBinary(uint8_t* data, uint32_t size) throw(PersistException); ++ void readBinary(uint8_t* data, uint32_t size); + + private: + /** + * reads the actual object data into a pre-instantiated object pointer + * by calling the read function of the derived class. + */ +- void readObject(PersistObject* object) throw(PersistException); ++ void readObject(PersistObject* object); + + /** + * reads in a class name, and caches it into the ClassMap. + */ +- const std::string readClass() throw(PersistException); ++ const std::string readClass(); + + + /** +@@ -319,63 +319,63 @@ + + // Standard >> and << stream operators for PersistObject + /** @relates PersistEngine */ +-inline PersistEngine& operator >>( PersistEngine& ar, PersistObject &ob) throw(PersistException) {CCXX_RE(ar,ob);} ++inline PersistEngine& operator >>( PersistEngine& ar, PersistObject &ob) {CCXX_RE(ar,ob);} + /** @relates PersistEngine */ +-inline PersistEngine& operator >>( PersistEngine& ar, PersistObject *&ob) throw(PersistException) {CCXX_RE(ar,ob);} ++inline PersistEngine& operator >>( PersistEngine& ar, PersistObject *&ob) {CCXX_RE(ar,ob);} + /** @relates PersistEngine */ +-inline PersistEngine& operator <<( PersistEngine& ar, PersistObject const &ob) throw(PersistException) {CCXX_WE(ar,ob);} ++inline PersistEngine& operator <<( PersistEngine& ar, PersistObject const &ob) {CCXX_WE(ar,ob);} + /** @relates PersistEngine */ +-inline PersistEngine& operator <<( PersistEngine& ar, PersistObject const *ob) throw(PersistException) {CCXX_WE(ar,ob);} ++inline PersistEngine& operator <<( PersistEngine& ar, PersistObject const *ob) {CCXX_WE(ar,ob);} + + /** @relates PersistEngine */ +-inline PersistEngine& operator >>( PersistEngine& ar, int8_t& ob) throw(PersistException) {CCXX_RE(ar,ob);} ++inline PersistEngine& operator >>( PersistEngine& ar, int8_t& ob) {CCXX_RE(ar,ob);} + /** @relates PersistEngine */ +-inline PersistEngine& operator <<( PersistEngine& ar, int8_t ob) throw(PersistException) {CCXX_WE(ar,ob);} ++inline PersistEngine& operator <<( PersistEngine& ar, int8_t ob) {CCXX_WE(ar,ob);} + + /** @relates PersistEngine */ +-inline PersistEngine& operator >>( PersistEngine& ar, uint8_t& ob) throw(PersistException) {CCXX_RE(ar,ob);} ++inline PersistEngine& operator >>( PersistEngine& ar, uint8_t& ob) {CCXX_RE(ar,ob);} + /** @relates PersistEngine */ +-inline PersistEngine& operator <<( PersistEngine& ar, uint8_t ob) throw(PersistException) {CCXX_WE(ar,ob);} ++inline PersistEngine& operator <<( PersistEngine& ar, uint8_t ob) {CCXX_WE(ar,ob);} + + /** @relates PersistEngine */ +-inline PersistEngine& operator >>( PersistEngine& ar, int16_t& ob) throw(PersistException) {CCXX_RE(ar,ob);} ++inline PersistEngine& operator >>( PersistEngine& ar, int16_t& ob) {CCXX_RE(ar,ob);} + /** @relates PersistEngine */ +-inline PersistEngine& operator <<( PersistEngine& ar, int16_t ob) throw(PersistException) {CCXX_WE(ar,ob);} ++inline PersistEngine& operator <<( PersistEngine& ar, int16_t ob) {CCXX_WE(ar,ob);} + + /** @relates PersistEngine */ +-inline PersistEngine& operator >>( PersistEngine& ar, uint16_t& ob) throw(PersistException) {CCXX_RE(ar,ob);} ++inline PersistEngine& operator >>( PersistEngine& ar, uint16_t& ob) {CCXX_RE(ar,ob);} + /** @relates PersistEngine */ +-inline PersistEngine& operator <<( PersistEngine& ar, uint16_t ob) throw(PersistException) {CCXX_WE(ar,ob);} ++inline PersistEngine& operator <<( PersistEngine& ar, uint16_t ob) {CCXX_WE(ar,ob);} + + /** @relates PersistEngine */ +-inline PersistEngine& operator >>( PersistEngine& ar, int32_t& ob) throw(PersistException) {CCXX_RE(ar,ob);} ++inline PersistEngine& operator >>( PersistEngine& ar, int32_t& ob) {CCXX_RE(ar,ob);} + /** @relates PersistEngine */ +-inline PersistEngine& operator <<( PersistEngine& ar, int32_t ob) throw(PersistException) {CCXX_WE(ar,ob);} ++inline PersistEngine& operator <<( PersistEngine& ar, int32_t ob) {CCXX_WE(ar,ob);} + + /** @relates PersistEngine */ +-inline PersistEngine& operator >>( PersistEngine& ar, uint32_t& ob) throw(PersistException) {CCXX_RE(ar,ob);} ++inline PersistEngine& operator >>( PersistEngine& ar, uint32_t& ob) {CCXX_RE(ar,ob);} + /** @relates PersistEngine */ +-inline PersistEngine& operator <<( PersistEngine& ar, uint32_t ob) throw(PersistException) {CCXX_WE(ar,ob);} ++inline PersistEngine& operator <<( PersistEngine& ar, uint32_t ob) {CCXX_WE(ar,ob);} + + /** @relates PersistEngine */ +-inline PersistEngine& operator >>( PersistEngine& ar, float& ob) throw(PersistException) {CCXX_RE(ar,ob);} ++inline PersistEngine& operator >>( PersistEngine& ar, float& ob) {CCXX_RE(ar,ob);} + /** @relates PersistEngine */ +-inline PersistEngine& operator <<( PersistEngine& ar, float ob) throw(PersistException) {CCXX_WE(ar,ob);} ++inline PersistEngine& operator <<( PersistEngine& ar, float ob) {CCXX_WE(ar,ob);} + + /** @relates PersistEngine */ +-inline PersistEngine& operator >>( PersistEngine& ar, double& ob) throw(PersistException) {CCXX_RE(ar,ob);} ++inline PersistEngine& operator >>( PersistEngine& ar, double& ob) {CCXX_RE(ar,ob);} + /** @relates PersistEngine */ +-inline PersistEngine& operator <<( PersistEngine& ar, double ob) throw(PersistException) {CCXX_WE(ar,ob);} ++inline PersistEngine& operator <<( PersistEngine& ar, double ob) {CCXX_WE(ar,ob);} + + /** @relates PersistEngine */ +-inline PersistEngine& operator >>( PersistEngine& ar, std::string& ob) throw(PersistException) {CCXX_RE(ar,ob);} ++inline PersistEngine& operator >>( PersistEngine& ar, std::string& ob) {CCXX_RE(ar,ob);} + /** @relates PersistEngine */ +-inline PersistEngine& operator <<( PersistEngine& ar, std::string ob) throw(PersistException) {CCXX_WE(ar,ob);} ++inline PersistEngine& operator <<( PersistEngine& ar, std::string ob) {CCXX_WE(ar,ob);} + + /** @relates PersistEngine */ +-inline PersistEngine& operator >>( PersistEngine& ar, bool& ob) throw(PersistException) {CCXX_RE(ar,ob);} ++inline PersistEngine& operator >>( PersistEngine& ar, bool& ob) {CCXX_RE(ar,ob);} + /** @relates PersistEngine */ +-inline PersistEngine& operator <<( PersistEngine& ar, bool ob) throw(PersistException) {CCXX_WE(ar,ob);} ++inline PersistEngine& operator <<( PersistEngine& ar, bool ob) {CCXX_WE(ar,ob);} + + #undef CCXX_RE + #undef CCXX_WE +@@ -390,7 +390,7 @@ + * the engine + */ + template +-PersistEngine& operator <<( PersistEngine& ar, typename std::vector const& ob) throw(PersistException) ++PersistEngine& operator <<( PersistEngine& ar, typename std::vector const& ob) + { + ar << (uint32_t)ob.size(); + for(unsigned int i=0; i < ob.size(); ++i) +@@ -404,7 +404,7 @@ + * an engine. + */ + template +-PersistEngine& operator >>( PersistEngine& ar, typename std::vector& ob) throw(PersistException) ++PersistEngine& operator >>( PersistEngine& ar, typename std::vector& ob) + { + ob.clear(); + uint32_t siz; +@@ -421,7 +421,7 @@ + * the engine + */ + template +-PersistEngine& operator <<( PersistEngine& ar, typename std::deque const& ob) throw(PersistException) ++PersistEngine& operator <<( PersistEngine& ar, typename std::deque const& ob) + { + ar << (uint32_t)ob.size(); + for(typename std::deque::const_iterator it=ob.begin(); it != ob.end(); ++it) +@@ -435,7 +435,7 @@ + * an engine. + */ + template +-PersistEngine& operator >>( PersistEngine& ar, typename std::deque& ob) throw(PersistException) ++PersistEngine& operator >>( PersistEngine& ar, typename std::deque& ob) + { + ob.clear(); + uint32_t siz; +@@ -456,7 +456,7 @@ + * to an engine. + */ + template +-PersistEngine& operator <<( PersistEngine& ar, typename std::map const & ob) throw(PersistException) ++PersistEngine& operator <<( PersistEngine& ar, typename std::map const & ob) + { + ar << (uint32_t)ob.size(); + for(typename std::map::const_iterator it = ob.begin();it != ob.end();++it) +@@ -470,7 +470,7 @@ + * from an engine. + */ + template +-PersistEngine& operator >>( PersistEngine& ar, typename std::map& ob) throw(PersistException) ++PersistEngine& operator >>( PersistEngine& ar, typename std::map& ob) + { + ob.clear(); + uint32_t siz; +@@ -488,7 +488,7 @@ + * serialize a pair of some serializable content to the engine. + */ + template +-PersistEngine& operator <<( PersistEngine& ar, std::pair &ob) throw(PersistException) ++PersistEngine& operator <<( PersistEngine& ar, std::pair &ob) + { + ar << ob.first << ob.second; + return ar; +@@ -499,7 +499,7 @@ + * deserialize a pair of some serializable content to the engine. + */ + template +-PersistEngine& operator >>(PersistEngine& ar, std::pair &ob) throw(PersistException) ++PersistEngine& operator >>(PersistEngine& ar, std::pair &ob) + { + ar >> ob.first >> ob.second; + return ar; +--- a/inc/commoncpp/tokenizer.h ++++ b/inc/commoncpp/tokenizer.h +@@ -175,7 +175,7 @@ + /** + * shifts this iterator to the next token in the string. + */ +- iterator &operator++() THROWS (NoSuchElementException); ++ iterator &operator++(); + + /** + * returns the immutable string this iterator +@@ -185,7 +185,7 @@ + * invalidated for each iteration. If you need the token, + * copy it (e.g. with strdup()); + */ +- const char* operator*() THROWS (NoSuchElementException); ++ const char* operator*(); + + /** + * returns the next delimiter after the current token or diff --git a/dev-libs/ucommon/metadata.xml b/dev-libs/ucommon/metadata.xml new file mode 100644 index 0000000..85e4ed8 --- /dev/null +++ b/dev-libs/ucommon/metadata.xml @@ -0,0 +1,5 @@ + + + + + diff --git a/dev-libs/ucommon/ucommon-7.0.0.ebuild b/dev-libs/ucommon/ucommon-7.0.0.ebuild new file mode 100644 index 0000000..52f0936 --- /dev/null +++ b/dev-libs/ucommon/ucommon-7.0.0.ebuild @@ -0,0 +1,75 @@ +# Copyright 1999-2021 Gentoo Authors +# Distributed under the terms of the GNU General Public License v2 + +EAPI=7 + +inherit autotools flag-o-matic + +DESCRIPTION="Portable C++ runtime for threads and sockets" +HOMEPAGE="https://www.gnu.org/software/commoncpp" +SRC_URI="mirror://gnu/commoncpp/${P}.tar.gz" + +LICENSE="LGPL-3" +SLOT="0/8" # soname version +KEYWORDS="amd64 ~ppc ~ppc64 x86 ~amd64-linux" +IUSE="doc +cxx debug ssl gnutls" + +RDEPEND=" + ssl? ( + net-libs/gnutls:= + dev-libs/libgcrypt:= + )" +DEPEND="${RDEPEND}" +BDEPEND=" + virtual/pkgconfig + doc? ( app-doc/doxygen )" + +PATCHES=( + "${FILESDIR}"/${PN}-6.0.3-install_gcrypt.m4_file.patch + "${FILESDIR}"/${PN}-7.0.0-c++17-dynamic-exception-specifications.patch +) + +src_prepare() { + default + + # Aclocal 1.13 deprecated error BGO #467674 + sed -e 's/AM_CONFIG_HEADER/AC_CONFIG_HEADERS/g' -i configure.ac || die + + # don't install latex and rtf documents + sed -e '/^GENERATE_LATEX/s@YES@NO@' -e '/^GENERATE_RTF/s@YES@NO@' \ + -i Doxyfile.in || die + + eautoreconf +} + +src_configure() { + # https://bugs.gentoo.org/730018 + # need to link GCC's libatomic when compiling with clang + append-libs -latomic + + local myeconfargs=( + --disable-static + --with-pkg-config + # don't bother with openssl, incompatible with the 1.1 API + --with-sslstack=$(usex ssl gnu nossl) + $(use_enable cxx stdcpp) + ) + econf "${myeconfargs[@]}" +} + +src_compile() { + default + + if use doc; then + emake doxy + HTML_DOCS=( doc/html/. ) + fi +} + +src_install() { + default + dodoc SUPPORT + + # no static archives + find "${ED}" -name '*.la' -delete || die +}